1# Tests of Starlark 'int'
2
3load("assert.star", "assert")
4
5# basic arithmetic
6assert.eq(0 - 1, -1)
7assert.eq(0 + 1, +1)
8assert.eq(1 + 1, 2)
9assert.eq(5 + 7, 12)
10assert.eq(5 * 7, 35)
11assert.eq(5 - 7, -2)
12
13# int boundaries
14maxint64 = (1 << 63) - 1
15minint64 = -1 << 63
16maxint32 = (1 << 31) - 1
17minint32 = -1 << 31
18assert.eq(maxint64, 9223372036854775807)
19assert.eq(minint64, -9223372036854775808)
20assert.eq(maxint32, 2147483647)
21assert.eq(minint32, -2147483648)
22
23# truth
24def truth():
25 assert.true(not 0)
26 for m in [1, maxint32]: # Test small/big ranges
27 assert.true(123 * m)
28 assert.true(-1 * m)
29
30truth()
31
32# floored division
33# (For real division, see float.star.)
34def division():
35 for m in [1, maxint32]: # Test small/big ranges
36 assert.eq((100 * m) // (7 * m), 14)
37 assert.eq((100 * m) // (-7 * m), -15)
38 assert.eq((-100 * m) // (7 * m), -15) # NB: different from Go/Java
39 assert.eq((-100 * m) // (-7 * m), 14) # NB: different from Go/Java
40 assert.eq((98 * m) // (7 * m), 14)
41 assert.eq((98 * m) // (-7 * m), -14)
42 assert.eq((-98 * m) // (7 * m), -14)
43 assert.eq((-98 * m) // (-7 * m), 14)
44
45division()
46
47# remainder
48def remainder():
49 for m in [1, maxint32]: # Test small/big ranges
50 assert.eq((100 * m) % (7 * m), 2 * m)
51 assert.eq((100 * m) % (-7 * m), -5 * m) # NB: different from Go/Java
52 assert.eq((-100 * m) % (7 * m), 5 * m) # NB: different from Go/Java
53 assert.eq((-100 * m) % (-7 * m), -2 * m)
54 assert.eq((98 * m) % (7 * m), 0)
55 assert.eq((98 * m) % (-7 * m), 0)
56 assert.eq((-98 * m) % (7 * m), 0)
57 assert.eq((-98 * m) % (-7 * m), 0)
58
59remainder()
60
61# compound assignment
62def compound():
63 x = 1
64 x += 1
65 assert.eq(x, 2)
66 x -= 3
67 assert.eq(x, -1)
68 x *= 39
69 assert.eq(x, -39)
70 x //= 4
71 assert.eq(x, -10)
72 x /= -2
73 assert.eq(x, 5)
74 x %= 3
75 assert.eq(x, 2)
76
77 # use resolve.AllowBitwise to enable the ops:
78 x = 2
79 x &= 1
80 assert.eq(x, 0)
81 x |= 2
82 assert.eq(x, 2)
83 x ^= 3
84 assert.eq(x, 1)
85 x <<= 2
86 assert.eq(x, 4)
87 x >>= 2
88 assert.eq(x, 1)
89
90compound()
91
92# int conversion
93# See float.star for float-to-int conversions.
94# We follow Python 3 here, but I can't see the method in its madness.
95# int from bool/int/float
96assert.fails(int, "missing argument") # int()
97assert.eq(int(False), 0)
98assert.eq(int(True), 1)
99assert.eq(int(3), 3)
100assert.eq(int(3.1), 3)
101assert.fails(lambda: int(3, base = 10), "non-string with explicit base")
102assert.fails(lambda: int(True, 10), "non-string with explicit base")
103
104# int from string, base implicitly 10
105assert.eq(int("100000000000000000000"), 10000000000 * 10000000000)
106assert.eq(int("-100000000000000000000"), -10000000000 * 10000000000)
107assert.eq(int("123"), 123)
108assert.eq(int("-123"), -123)
109assert.eq(int("0123"), 123) # not octal
110assert.eq(int("-0123"), -123)
111assert.fails(lambda: int("0x12"), "invalid literal with base 10")
112assert.fails(lambda: int("-0x12"), "invalid literal with base 10")
113assert.fails(lambda: int("0o123"), "invalid literal.*base 10")
114assert.fails(lambda: int("-0o123"), "invalid literal.*base 10")
115
116# int from string, explicit base
117assert.eq(int("0"), 0)
118assert.eq(int("00"), 0)
119assert.eq(int("0", base = 10), 0)
120assert.eq(int("00", base = 10), 0)
121assert.eq(int("0", base = 8), 0)
122assert.eq(int("00", base = 8), 0)
123assert.eq(int("-0"), 0)
124assert.eq(int("-00"), 0)
125assert.eq(int("-0", base = 10), 0)
126assert.eq(int("-00", base = 10), 0)
127assert.eq(int("-0", base = 8), 0)
128assert.eq(int("-00", base = 8), 0)
129assert.eq(int("+0"), 0)
130assert.eq(int("+00"), 0)
131assert.eq(int("+0", base = 10), 0)
132assert.eq(int("+00", base = 10), 0)
133assert.eq(int("+0", base = 8), 0)
134assert.eq(int("+00", base = 8), 0)
135assert.eq(int("11", base = 9), 10)
136assert.eq(int("-11", base = 9), -10)
137assert.eq(int("10011", base = 2), 19)
138assert.eq(int("-10011", base = 2), -19)
139assert.eq(int("123", 8), 83)
140assert.eq(int("-123", 8), -83)
141assert.eq(int("0123", 8), 83) # redundant zeros permitted
142assert.eq(int("-0123", 8), -83)
143assert.eq(int("00123", 8), 83)
144assert.eq(int("-00123", 8), -83)
145assert.eq(int("0o123", 8), 83)
146assert.eq(int("-0o123", 8), -83)
147assert.eq(int("123", 7), 66) # 1*7*7 + 2*7 + 3
148assert.eq(int("-123", 7), -66)
149assert.eq(int("12", 16), 18)
150assert.eq(int("-12", 16), -18)
151assert.eq(int("0x12", 16), 18)
152assert.eq(int("-0x12", 16), -18)
153assert.eq(0x1000000000000001 * 0x1000000000000001, 0x1000000000000002000000000000001)
154assert.eq(int("1010", 2), 10)
155assert.eq(int("111111101", 2), 509)
156assert.eq(int("0b0101", 0), 5)
157assert.eq(int("0b0101", 2), 5) # prefix is redundant with explicit base
158assert.eq(int("0b00000", 0), 0)
159assert.eq(1111111111111111 * 1111111111111111, 1234567901234567654320987654321)
160assert.fails(lambda: int("0x123", 8), "invalid literal.*base 8")
161assert.fails(lambda: int("-0x123", 8), "invalid literal.*base 8")
162assert.fails(lambda: int("0o123", 16), "invalid literal.*base 16")
163assert.fails(lambda: int("-0o123", 16), "invalid literal.*base 16")
164assert.fails(lambda: int("0x110", 2), "invalid literal.*base 2")
165
166# Base prefix is honored only if base=0, or if the prefix matches the explicit base.
167# See https://github.com/google/starlark-go/issues/337
168assert.fails(lambda: int("0b0"), "invalid literal.*base 10")
169assert.eq(int("0b0", 0), 0)
170assert.eq(int("0b0", 2), 0)
171assert.eq(int("0b0", 16), 0xb0)
172assert.eq(int("0x0b0", 16), 0xb0)
173assert.eq(int("0x0b0", 0), 0xb0)
174assert.eq(int("0x0b0101", 16), 0x0b0101)
175
176# int from string, auto detect base
177assert.eq(int("123", 0), 123)
178assert.eq(int("+123", 0), +123)
179assert.eq(int("-123", 0), -123)
180assert.eq(int("0x12", 0), 18)
181assert.eq(int("+0x12", 0), +18)
182assert.eq(int("-0x12", 0), -18)
183assert.eq(int("0o123", 0), 83)
184assert.eq(int("+0o123", 0), +83)
185assert.eq(int("-0o123", 0), -83)
186assert.fails(lambda: int("0123", 0), "invalid literal.*base 0") # valid in Python 2.7
187assert.fails(lambda: int("-0123", 0), "invalid literal.*base 0")
188
189# github.com/google/starlark-go/issues/108
190assert.fails(lambda: int("0Oxa", 8), "invalid literal with base 8: 0Oxa")
191
192# follow-on bugs to issue 108
193assert.fails(lambda: int("--4"), "invalid literal with base 10: --4")
194assert.fails(lambda: int("++4"), "invalid literal with base 10: \\+\\+4")
195assert.fails(lambda: int("+-4"), "invalid literal with base 10: \\+-4")
196assert.fails(lambda: int("0x-4", 16), "invalid literal with base 16: 0x-4")
197
198# bitwise union (int|int), intersection (int&int), XOR (int^int), unary not (~int),
199# left shift (int<<int), and right shift (int>>int).
200# use resolve.AllowBitwise to enable the ops.
201# TODO(adonovan): this is not yet in the Starlark spec,
202# but there is consensus that it should be.
203assert.eq(1 | 2, 3)
204assert.eq(3 | 6, 7)
205assert.eq((1 | 2) & (2 | 4), 2)
206assert.eq(1 ^ 2, 3)
207assert.eq(2 ^ 2, 0)
208assert.eq(1 | 0 ^ 1, 1) # check | and ^ operators precedence
209assert.eq(~1, -2)
210assert.eq(~(-2), 1)
211assert.eq(~0, -1)
212assert.eq(1 << 2, 4)
213assert.eq(2 >> 1, 1)
214assert.fails(lambda: 2 << -1, "negative shift count")
215assert.fails(lambda: 1 << 512, "shift count too large")
216
217# comparisons
218# TODO(adonovan): test: < > == != etc
219def comparisons():
220 for m in [1, maxint32 / 2, maxint32]: # Test small/big ranges
221 assert.lt(-2 * m, -1 * m)
222 assert.lt(-1 * m, 0 * m)
223 assert.lt(0 * m, 1 * m)
224 assert.lt(1 * m, 2 * m)
225 assert.true(2 * m >= 2 * m)
226 assert.true(2 * m > 1 * m)
227 assert.true(1 * m >= 1 * m)
228 assert.true(1 * m > 0 * m)
229 assert.true(0 * m >= 0 * m)
230 assert.true(0 * m > -1 * m)
231 assert.true(-1 * m >= -1 * m)
232 assert.true(-1 * m > -2 * m)
233
234comparisons()
235
236# precision
237assert.eq(str(maxint64), "9223372036854775807")
238assert.eq(str(maxint64 + 1), "9223372036854775808")
239assert.eq(str(minint64), "-9223372036854775808")
240assert.eq(str(minint64 - 1), "-9223372036854775809")
241assert.eq(str(minint64 * minint64), "85070591730234615865843651857942052864")
242assert.eq(str(maxint32 + 1), "2147483648")
243assert.eq(str(minint32 - 1), "-2147483649")
244assert.eq(str(minint32 * minint32), "4611686018427387904")
245assert.eq(str(minint32 | maxint32), "-1")
246assert.eq(str(minint32 & minint32), "-2147483648")
247assert.eq(str(minint32 ^ maxint32), "-1")
248assert.eq(str(minint32 // -1), "2147483648")
249
250# string formatting
251assert.eq("%o %x %d" % (0o755, 0xDEADBEEF, 42), "755 deadbeef 42")
252nums = [-95, -1, 0, +1, +95]
253assert.eq(" ".join(["%o" % x for x in nums]), "-137 -1 0 1 137")
254assert.eq(" ".join(["%d" % x for x in nums]), "-95 -1 0 1 95")
255assert.eq(" ".join(["%i" % x for x in nums]), "-95 -1 0 1 95")
256assert.eq(" ".join(["%x" % x for x in nums]), "-5f -1 0 1 5f")
257assert.eq(" ".join(["%X" % x for x in nums]), "-5F -1 0 1 5F")
258assert.eq("%o %x %d" % (123, 123, 123), "173 7b 123")
259assert.eq("%o %x %d" % (123.1, 123.1, 123.1), "173 7b 123") # non-int operands are acceptable
260assert.fails(lambda: "%d" % True, "cannot convert bool to int")
View as plain text