github.com/google/skylark@v0.0.0-20181101142754-a5f7082aabed/testdata/builtins.sky (about) 1 # Tests of Skylark built-in functions 2 3 load("assert.sky", "assert") 4 5 # len 6 assert.eq(len([1, 2, 3]), 3) 7 assert.eq(len((1, 2, 3)), 3) 8 assert.eq(len({1: 2}), 1) 9 assert.fails(lambda: len(1), "int.*has no len") 10 11 # and, or 12 assert.eq(123 or "foo", 123) 13 assert.eq(0 or "foo", "foo") 14 assert.eq(123 and "foo", "foo") 15 assert.eq(0 and "foo", 0) 16 none = None 17 _1 = none and none[0] # rhs is not evaluated 18 _2 = (not none) or none[0] # rhs is not evaluated 19 20 # any, all 21 assert.true(all([])) 22 assert.true(all([1, True, "foo"])) 23 assert.true(not all([1, True, ""])) 24 assert.true(not any([])) 25 assert.true(any([0, False, "foo"])) 26 assert.true(not any([0, False, ""])) 27 28 # in 29 assert.true(3 in [1, 2, 3]) 30 assert.true(4 not in [1, 2, 3]) 31 assert.true(3 in (1, 2, 3)) 32 assert.true(4 not in (1, 2, 3)) 33 assert.fails(lambda: 3 in "foo", "in.*requires string as left operand") 34 assert.true(123 in {123: ""}) 35 assert.true(456 not in {123:""}) 36 assert.true([] not in {123: ""}) 37 38 # sorted 39 assert.eq(sorted([42, 123, 3]), [3, 42, 123]) 40 assert.eq(sorted([42, 123, 3], reverse=True), [123, 42, 3]) 41 assert.eq(sorted(["wiz", "foo", "bar"]), ["bar", "foo", "wiz"]) 42 assert.eq(sorted(["wiz", "foo", "bar"], reverse=True), ["wiz", "foo", "bar"]) 43 assert.fails(lambda: sorted([1, 2, None, 3]), "int < NoneType not implemented") 44 assert.fails(lambda: sorted([1, "one"]), "string < int not implemented") 45 # custom key function 46 assert.eq(sorted(["two", "three", "four"], key=len), 47 ["two", "four", "three"]) 48 assert.eq(sorted(["two", "three", "four"], key=len, reverse=True), 49 ["three", "four", "two"]) 50 assert.fails(lambda: sorted([1, 2, 3], key=None), "got NoneType, want callable") 51 # sort is stable 52 pairs = [(4, 0), (3, 1), (4, 2), (2, 3), (3, 4), (1, 5), (2, 6), (3, 7)] 53 assert.eq(sorted(pairs, key=lambda x: x[0]), 54 [(1, 5), 55 (2, 3), (2, 6), 56 (3, 1), (3, 4), (3, 7), 57 (4, 0), (4, 2)]) 58 59 # reversed 60 assert.eq(reversed([1, 144, 81, 16]), [16, 81, 144, 1]) 61 62 # set 63 assert.contains(set([1, 2, 3]), 1) 64 assert.true(4 not in set([1, 2, 3])) 65 assert.eq(len(set([1, 2, 3])), 3) 66 assert.eq(sorted([x for x in set([1, 2, 3])]), [1, 2, 3]) 67 68 # dict 69 assert.eq(dict([(1, 2), (3, 4)]), {1: 2, 3: 4}) 70 assert.eq(dict([(1, 2), (3, 4)], foo="bar"), {1: 2, 3: 4, "foo": "bar"}) 71 assert.eq(dict({1:2, 3:4}), {1: 2, 3: 4}) 72 assert.eq(dict({1:2, 3:4}.items()), {1: 2, 3: 4}) 73 74 # range 75 assert.eq("range", type(range(10))) 76 assert.eq("range(10)", str(range(0, 10, 1))) 77 assert.eq("range(1, 10)", str(range(1, 10))) 78 assert.eq("range(0, 10, -1)", str(range(0, 10, -1))) 79 assert.fails(lambda: {range(10): 10}, "unhashable: range") 80 assert.true(bool(range(1, 2))) 81 assert.true(not(range(2, 1))) # an empty range is false 82 assert.eq([x*x for x in range(5)], [0, 1, 4, 9, 16]) 83 assert.eq(list(range(5)), [0, 1, 2, 3, 4]) 84 assert.eq(list(range(-5)), []) 85 assert.eq(list(range(2, 5)), [2, 3, 4]) 86 assert.eq(list(range(5, 2)), []) 87 assert.eq(list(range(-2, -5)), []) 88 assert.eq(list(range(-5, -2)), [-5, -4, -3]) 89 assert.eq(list(range(2, 10, 3)), [2, 5, 8]) 90 assert.eq(list(range(10, 2, -3)), [10, 7, 4]) 91 assert.eq(list(range(-2, -10, -3)), [-2, -5, -8]) 92 assert.eq(list(range(-10, -2, 3)), [-10, -7, -4]) 93 assert.eq(list(range(10, 2, -1)), [10, 9, 8, 7, 6, 5, 4, 3]) 94 assert.eq(list(range(5)[1:]), [1, 2, 3, 4]) 95 assert.eq(len(range(5)[1:]), 4) 96 assert.eq(list(range(5)[:2]), [0, 1]) 97 assert.eq(list(range(10)[1:]), [1, 2, 3, 4, 5, 6, 7, 8, 9]) 98 assert.eq(list(range(10)[1:9:2]), [1, 3, 5, 7]) 99 assert.eq(list(range(10)[1:10:2]), [1, 3, 5, 7, 9]) 100 assert.eq(list(range(10)[1:11:2]), [1, 3, 5, 7, 9]) 101 assert.eq(list(range(10)[::-2]), [9, 7, 5, 3, 1]) 102 assert.eq(list(range(0, 10, 2)[::2]), [0, 4, 8]) 103 assert.eq(list(range(0, 10, 2)[::-2]), [8, 4, 0]) 104 assert.fails(lambda: range(3000000000), "3000000000 out of range") # signed 32-bit values only 105 assert.eq(len(range(0x7fffffff)), 0x7fffffff) # O(1) 106 # Two ranges compare equal if they denote the same sequence: 107 assert.eq(range(0), range(2, 1, 3)) # [] 108 assert.eq(range(0, 3, 2), range(0, 4, 2)) # [0, 2] 109 assert.ne(range(1, 10), range(2, 10)) 110 assert.fails(lambda: range(0) < range(0), "range < range not implemented") 111 # <number> in <range> 112 assert.contains(range(3), 1) 113 assert.contains(range(3), 2.0) # acts like 2 114 assert.fails(lambda: True in range(3), "requires integer.*not bool") # bools aren't numbers 115 assert.fails(lambda: "one" in range(10), "requires integer.*not string") 116 assert.true(4 not in range(4)) 117 assert.true(1e15 not in range(4)) # too big for int32 118 assert.true(1e100 not in range(4)) # too big for int64 119 120 # list 121 assert.eq(list("abc".elems()), ["a", "b", "c"]) 122 assert.eq(sorted(list({"a": 1, "b": 2})), ['a', 'b']) 123 124 # min, max 125 assert.eq(min(5, -2, 1, 7, 3), -2) 126 assert.eq(max(5, -2, 1, 7, 3), 7) 127 assert.eq(min([5, -2, 1, 7, 3]), -2) 128 assert.eq(min("one", "two", "three", "four"), "four") 129 assert.eq(max("one", "two", "three", "four"), "two") 130 assert.fails(min, "min requires at least one positional argument") 131 assert.fails(lambda: min(1), "not iterable") 132 assert.fails(lambda: min([]), "empty") 133 assert.eq(min(5, -2, 1, 7, 3, key=lambda x: x*x), 1) # min absolute value 134 assert.eq(min(5, -2, 1, 7, 3, key=lambda x: -x), 7) # min negated value 135 136 # enumerate 137 assert.eq(enumerate("abc".elems()), [(0, "a"), (1, "b"), (2, "c")]) 138 assert.eq(enumerate([False, True, None], 42), [(42, False), (43, True), (44, None)]) 139 140 # zip 141 assert.eq(zip(), []) 142 assert.eq(zip([]), []) 143 assert.eq(zip([1, 2, 3]), [(1,), (2,), (3,)]) 144 assert.eq(zip("".elems()), []) 145 assert.eq(zip("abc".elems(), 146 list("def".elems()), 147 "hijk".elems()), 148 [("a", "d", "h"), ("b", "e", "i"), ("c", "f", "j")]) 149 z1 = [1] 150 assert.eq(zip(z1), [(1,)]) 151 z1.append(2) 152 assert.eq(zip(z1), [(1,), (2,)]) 153 assert.fails(lambda: zip(z1, 1), "zip: argument #2 is not iterable: int") 154 z1.append(3) 155 156 # dir for builtin_function_or_method 157 assert.eq(dir(None), []) 158 assert.eq(dir({})[:3], ["clear", "get", "items"]) # etc 159 assert.eq(dir(1), []) 160 assert.eq(dir([])[:3], ["append", "clear", "extend"]) # etc 161 162 # hasattr, getattr, dir 163 # hasfields is an application-defined type defined in eval_test.go. 164 hf = hasfields() 165 assert.eq(dir(hf), []) 166 assert.true(not hasattr(hf, "x")) 167 assert.fails(lambda: getattr(hf, "x"), "no .x field or method") 168 assert.eq(getattr(hf, "x", 42), 42) 169 hf.x = 1 170 assert.true(hasattr(hf, "x")) 171 assert.eq(getattr(hf, "x"), 1) 172 assert.eq(hf.x, 1) 173 hf.x = 2 174 assert.eq(getattr(hf, "x"), 2) 175 assert.eq(hf.x, 2) 176 # built-in types can have attributes (methods) too. 177 myset = set([]) 178 assert.eq(dir(myset), ["union"]) 179 assert.true(hasattr(myset, "union")) 180 assert.true(not hasattr(myset, "onion")) 181 assert.eq(str(getattr(myset, "union")), "<built-in method union of set value>") 182 assert.fails(lambda: getattr(myset, "onion"), "no .onion field or method") 183 assert.eq(getattr(myset, "onion", 42), 42) 184 185 # repr 186 assert.eq(repr(1), "1") 187 assert.eq(repr("x"), '"x"') 188 assert.eq(repr(["x", 1]), '["x", 1]')