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") 261