| [case testI64BasicOps] |
| from typing import List, Any, Tuple |
| |
| MYPY = False |
| if MYPY: |
| from mypy_extensions import i64, i32 |
| |
| from testutil import assertRaises |
| |
| def inc(n: i64) -> i64: |
| return n + 1 |
| |
| def test_inc() -> None: |
| # Use int() to avoid constant folding |
| n = 1 + int() |
| m = 2 + int() |
| assert inc(n) == m |
| |
| def min_ll(x: i64, y: i64) -> i64: |
| if x < y: |
| return x |
| else: |
| return y |
| |
| def test_min() -> None: |
| assert min_ll(1 + int(), 2) == 1 |
| assert min_ll(2 + int(), 1) == 1 |
| assert min_ll(1 + int(), 1) == 1 |
| assert min_ll(-2 + int(), 1) == -2 |
| assert min_ll(1 + int(), -2) == -2 |
| |
| def eq(x: i64, y: i64) -> bool: |
| return x == y |
| |
| def test_eq() -> None: |
| assert eq(int(), int()) |
| assert eq(5 + int(), 5 + int()) |
| assert eq(-5 + int(), -5 + int()) |
| assert not eq(int(), 1 + int()) |
| assert not eq(5 + int(), 6 + int()) |
| assert not eq(-5 + int(), -6 + int()) |
| assert not eq(-5 + int(), 5 + int()) |
| |
| def test_comparisons() -> None: |
| one: i64 = 1 + int() |
| one2: i64 = 1 + int() |
| two: i64 = 2 + int() |
| assert one < two |
| assert not (one < one2) |
| assert not (two < one) |
| assert two > one |
| assert not (one > one2) |
| assert not (one > two) |
| assert one <= two |
| assert one <= one2 |
| assert not (two <= one) |
| assert two >= one |
| assert one >= one2 |
| assert not (one >= two) |
| assert one == one2 |
| assert not (one == two) |
| assert one != two |
| assert not (one != one2) |
| |
| def div_by_3(x: i64) -> i64: |
| return x // 3 |
| |
| def div_by_neg_3(x: i64) -> i64: |
| return x // -3 |
| |
| def div(x: i64, y: i64) -> i64: |
| return x // y |
| |
| def test_divide_by_constant() -> None: |
| for i in range(-1000, 1000): |
| assert div_by_3(i) == i // 3 |
| for i in range(-2**63, -2**63 + 1000): |
| assert div_by_3(i) == i // 3 |
| for i in range(2**63 - 1000, 2**63): |
| assert div_by_3(i) == i // 3 |
| |
| def test_divide_by_negative_constant() -> None: |
| for i in range(-1000, 1000): |
| assert div_by_neg_3(i) == i // -3 |
| for i in range(-2**63, -2**63 + 1000): |
| assert div_by_neg_3(i) == i // -3 |
| for i in range(2**63 - 1000, 2**63): |
| assert div_by_neg_3(i) == i // -3 |
| |
| def test_divide_by_variable() -> None: |
| values = (list(range(-50, 50)) + |
| list(range(-2**63, -2**63 + 10)) + |
| list(range(2**63 - 10, 2**63))) |
| for x in values: |
| for y in values: |
| if y != 0: |
| if x // y == 2**63: |
| with assertRaises(OverflowError, "integer division overflow"): |
| div(x, y) |
| else: |
| assert div(x, y) == x // y |
| else: |
| with assertRaises(ZeroDivisionError, "integer division or modulo by zero"): |
| div(x, y) |
| |
| def mod_by_7(x: i64) -> i64: |
| return x % 7 |
| |
| def mod_by_neg_7(x: i64) -> i64: |
| return x // -7 |
| |
| def mod(x: i64, y: i64) -> i64: |
| return x % y |
| |
| def test_mod_by_constant() -> None: |
| for i in range(-1000, 1000): |
| assert mod_by_7(i) == i % 7 |
| for i in range(-2**63, -2**63 + 1000): |
| assert mod_by_7(i) == i % 7 |
| for i in range(2**63 - 1000, 2**63): |
| assert mod_by_7(i) == i % 7 |
| |
| def test_mod_by_negative_constant() -> None: |
| for i in range(-1000, 1000): |
| assert mod_by_neg_7(i) == i // -7 |
| for i in range(-2**63, -2**63 + 1000): |
| assert mod_by_neg_7(i) == i // -7 |
| for i in range(2**63 - 1000, 2**63): |
| assert mod_by_neg_7(i) == i // -7 |
| |
| def test_mod_by_variable() -> None: |
| values = (list(range(-50, 50)) + |
| list(range(-2**63, -2**63 + 10)) + |
| list(range(2**63 - 10, 2**63))) |
| for x in values: |
| for y in values: |
| if y != 0: |
| assert mod(x, y) == x % y |
| else: |
| with assertRaises(ZeroDivisionError, "integer division or modulo by zero"): |
| mod(x, y) |
| |
| def get_item(a: List[i64], n: i64) -> i64: |
| return a[n] |
| |
| def test_get_list_item() -> None: |
| a = [1, 6, -2] |
| assert get_item(a, 0) == 1 |
| assert get_item(a, 1) == 6 |
| assert get_item(a, 2) == -2 |
| assert get_item(a, -1) == -2 |
| assert get_item(a, -2) == 6 |
| assert get_item(a, -3) == 1 |
| with assertRaises(IndexError, "list index out of range"): |
| get_item(a, 3) |
| with assertRaises(IndexError, "list index out of range"): |
| get_item(a, -4) |
| # TODO: Very large/small values and indexes |
| |
| def test_simple_arithmetic_ops() -> None: |
| zero: i64 = int() |
| one: i64 = zero + 1 |
| two: i64 = one + 1 |
| neg_one: i64 = -one |
| assert one + one == 2 |
| assert one + two == 3 |
| assert one + neg_one == 0 |
| assert one - one == 0 |
| assert one - two == -1 |
| assert one * one == 1 |
| assert one * two == 2 |
| assert two * two == 4 |
| assert two * neg_one == -2 |
| assert neg_one * one == -1 |
| assert neg_one * neg_one == 1 |
| assert two * 0 == 0 |
| assert 0 * two == 0 |
| assert -one == -1 |
| assert -two == -2 |
| assert -neg_one == 1 |
| assert -zero == 0 |
| |
| def test_bitwise_ops() -> None: |
| x: i64 = 7997307308812232241 + int() |
| y: i64 = 4333433528471475340 + int() |
| z: i64 = -2462230749488444526 + int() |
| zero: i64 = int() |
| one: i64 = zero + 1 |
| two: i64 = zero + 2 |
| neg_one: i64 = -one |
| |
| assert x & y == 3179577071592752128 |
| assert x & z == 5536089561888850448 |
| assert z & z == z |
| assert x & zero == 0 |
| |
| assert x | y == 9151163765690955453 |
| assert x | z == -1013002565062733 |
| assert z | z == z |
| assert x | 0 == x |
| |
| assert x ^ y == 5971586694098203325 |
| assert x ^ z == -5537102564453913181 |
| assert z ^ z == 0 |
| assert z ^ 0 == z |
| |
| assert x << one == -2452129456085087134 |
| assert x << two == -4904258912170174268 |
| assert z << two == 8597821075755773512 |
| assert z << 0 == z |
| |
| assert x >> one == 3998653654406116120 |
| assert x >> two == 1999326827203058060 |
| assert z >> two == -615557687372111132 |
| assert z >> 0 == z |
| |
| assert ~x == -7997307308812232242 |
| assert ~z == 2462230749488444525 |
| assert ~zero == -1 |
| assert ~neg_one == 0 |
| |
| def test_coerce_to_and_from_int() -> None: |
| for shift in range(0, 64): |
| for sign in 1, -1: |
| for delta in range(-5, 5): |
| n = sign * (1 << shift) + delta |
| if -(1 << 63) <= n < (1 << 63): |
| x: i64 = n |
| m: int = x |
| assert m == n |
| |
| def test_explicit_conversion_to_i64() -> None: |
| x = i64(5) |
| assert x == 5 |
| y = int() - 113 |
| x = i64(y) |
| assert x == -113 |
| n32: i32 = 1733 |
| x = i64(n32) |
| assert x == 1733 |
| n32 = -1733 |
| x = i64(n32) |
| assert x == -1733 |
| z = i64(x) |
| assert z == -1733 |
| |
| def test_explicit_conversion_overflow() -> None: |
| max_i64 = int() + 2**63 - 1 |
| x = i64(max_i64) |
| assert x == 2**63 - 1 |
| assert int(x) == max_i64 |
| |
| min_i64 = int() - 2**63 |
| y = i64(min_i64) |
| assert y == -2**63 |
| assert int(y) == min_i64 |
| |
| too_big = int() + 2**63 |
| with assertRaises(OverflowError): |
| x = i64(too_big) |
| |
| too_small = int() - 2**63 - 1 |
| with assertRaises(OverflowError): |
| x = i64(too_small) |
| |
| def test_i64_from_large_small_literal() -> None: |
| x = i64(2**63 - 1) |
| assert x == 2**63 - 1 |
| x = i64(-2**63) |
| assert x == -2**63 |
| |
| def test_tuple_i64() -> None: |
| a: i64 = 1 |
| b: i64 = 2 |
| t = (a, b) |
| a, b = t |
| assert a == 1 |
| assert b == 2 |
| x: Any = t |
| tt: Tuple[i64, i64] = x |
| assert tt == (1, 2) |
| |
| def test_list_set_item() -> None: |
| a: List[i64] = [0, 2, 6] |
| z: i64 = int() |
| a[z] = 1 |
| assert a == [1, 2, 6] |
| a[z + 2] = 9 |
| assert a == [1, 2, 9] |
| a[-(z + 1)] = 10 |
| assert a == [1, 2, 10] |
| a[-(z + 3)] = 3 |
| assert a == [3, 2, 10] |
| with assertRaises(IndexError): |
| a[z + 3] = 0 |
| with assertRaises(IndexError): |
| a[-(z + 4)] = 0 |
| assert a == [3, 2, 10] |
| |
| class C: |
| def __init__(self, x: i64) -> None: |
| self.x = x |
| |
| def test_attributes() -> None: |
| i: i64 |
| for i in range(-1000, 1000): |
| c = C(i) |
| assert c.x == i |
| c.x = i + 1 |
| assert c.x == i + 1 |
| |
| def test_mixed_comparisons() -> None: |
| i64_3: i64 = int() + 3 |
| int_5 = int() + 5 |
| assert i64_3 < int_5 |
| assert int_5 > i64_3 |
| b = i64_3 > int_5 |
| assert not b |
| |
| int_largest = int() + (1 << 63) - 1 |
| assert int_largest > i64_3 |
| int_smallest = int() - (1 << 63) |
| assert i64_3 > int_smallest |
| |
| int_too_big = int() + (1 << 63) |
| int_too_small = int() - (1 << 63) - 1 |
| with assertRaises(OverflowError): |
| assert i64_3 < int_too_big |
| with assertRaises(OverflowError): |
| assert int_too_big < i64_3 |
| with assertRaises(OverflowError): |
| assert i64_3 > int_too_small |
| with assertRaises(OverflowError): |
| assert int_too_small < i64_3 |
| |
| def test_mixed_comparisons_32bit() -> None: |
| # Test edge cases on 32-bit platforms |
| i64_3: i64 = int() + 3 |
| int_5 = int() + 5 |
| |
| int_largest_short = int() + (1 << 30) - 1 |
| int_largest_short_i64: i64 = int_largest_short |
| assert int_largest_short > i64_3 |
| int_smallest_short = int() - (1 << 30) |
| int_smallest_short_i64: i64 = int_smallest_short |
| assert i64_3 > int_smallest_short |
| |
| int_big = int() + (1 << 30) |
| assert int_big > i64_3 |
| int_small = int() - (1 << 30) - 1 |
| assert i64_3 > int_small |
| |
| assert int_smallest_short_i64 > int_small |
| assert int_largest_short_i64 < int_big |
| |
| def test_mixed_arithmetic_and_bitwise_ops() -> None: |
| i64_3: i64 = int() + 3 |
| int_5 = int() + 5 |
| assert i64_3 + int_5 == 8 |
| assert int_5 - i64_3 == 2 |
| assert i64_3 << int_5 == 96 |
| assert int_5 << i64_3 == 40 |
| assert i64_3 ^ int_5 == 6 |
| assert int_5 | i64_3 == 7 |
| |
| int_largest = int() + (1 << 63) - 1 |
| assert int_largest - i64_3 == 9223372036854775804 |
| int_smallest = int() - (1 << 63) |
| assert int_smallest + i64_3 == -9223372036854775805 |
| |
| int_too_big = int() + (1 << 63) |
| int_too_small = int() - (1 << 63) - 1 |
| with assertRaises(OverflowError): |
| assert i64_3 & int_too_big |
| with assertRaises(OverflowError): |
| assert int_too_small & i64_3 |
| |
| def test_for_loop() -> None: |
| n: i64 = 0 |
| for i in range(i64(5 + int())): |
| n += i |
| assert n == 10 |
| n = 0 |
| for i in range(i64(5)): |
| n += i |
| assert n == 10 |
| n = 0 |
| for i in range(i64(2 + int()), 5 + int()): |
| n += i |
| assert n == 9 |
| n = 0 |
| for i in range(2, i64(5 + int())): |
| n += i |
| assert n == 9 |
| assert sum([x * x for x in range(i64(4 + int()))]) == 1 + 4 + 9 |
| |
| [case testI64ErrorValuesAndUndefined] |
| from typing import Any |
| import sys |
| |
| from mypy_extensions import mypyc_attr |
| from typing_extensions import Final |
| |
| MYPY = False |
| if MYPY: |
| from mypy_extensions import i64 |
| |
| from testutil import assertRaises |
| |
| def maybe_raise(n: i64, error: bool) -> i64: |
| if error: |
| raise ValueError() |
| return n |
| |
| def test_error_value() -> None: |
| for i in range(-1000, 1000): |
| assert maybe_raise(i, False) == i |
| with assertRaises(ValueError): |
| maybe_raise(0, True) |
| |
| class C: |
| def maybe_raise(self, n: i64, error: bool) -> i64: |
| if error: |
| raise ValueError() |
| return n |
| |
| def test_method_error_value() -> None: |
| for i in range(-1000, 1000): |
| assert C().maybe_raise(i, False) == i |
| with assertRaises(ValueError): |
| C().maybe_raise(0, True) |
| |
| def test_unbox_int() -> None: |
| for i in list(range(-1000, 1000)) + [-(1 << 63), (1 << 63) - 1]: |
| o: Any = i |
| x: i64 = i |
| assert x == i |
| y: i64 = o |
| assert y == i |
| |
| def test_unbox_int_fails() -> None: |
| o: Any = 'x' |
| if sys.version_info[0] == 3 and sys.version_info[1] < 10: |
| msg = "an integer is required (got type str)" |
| else: |
| msg = "'str' object cannot be interpreted as an integer" |
| with assertRaises(TypeError, msg): |
| x: i64 = o |
| o2: Any = 1 << 63 |
| with assertRaises(OverflowError, "int too large to convert to i64"): |
| y: i64 = o2 |
| o3: Any = -(1 << 63 + 1) |
| with assertRaises(OverflowError, "int too large to convert to i64"): |
| z: i64 = o3 |
| |
| class Uninit: |
| x: i64 |
| y: i64 = 0 |
| z: i64 |
| |
| class Derived(Uninit): |
| a: i64 = 1 |
| b: i64 |
| c: i64 = 2 |
| |
| class Derived2(Derived): |
| h: i64 |
| |
| def test_uninitialized_attr() -> None: |
| o = Uninit() |
| assert o.y == 0 |
| with assertRaises(AttributeError): |
| o.x |
| with assertRaises(AttributeError): |
| o.z |
| o.x = 1 |
| assert o.x == 1 |
| with assertRaises(AttributeError): |
| o.z |
| o.z = 2 |
| assert o.z == 2 |
| |
| # This is the error value, but it's also a valid normal value |
| MAGIC: Final = -113 |
| |
| def test_magic_value() -> None: |
| o = Uninit() |
| o.x = MAGIC |
| assert o.x == MAGIC |
| with assertRaises(AttributeError): |
| o.z |
| o.z = MAGIC |
| assert o.x == MAGIC |
| assert o.z == MAGIC |
| |
| def test_magic_value_via_any() -> None: |
| o: Any = Uninit() |
| with assertRaises(AttributeError): |
| o.x |
| with assertRaises(AttributeError): |
| o.z |
| o.x = MAGIC |
| assert o.x == MAGIC |
| with assertRaises(AttributeError): |
| o.z |
| o.z = MAGIC |
| assert o.z == MAGIC |
| |
| def test_magic_value_and_inheritance() -> None: |
| o = Derived2() |
| o.x = MAGIC |
| assert o.x == MAGIC |
| with assertRaises(AttributeError): |
| o.z |
| with assertRaises(AttributeError): |
| o.b |
| with assertRaises(AttributeError): |
| o.h |
| o.z = MAGIC |
| assert o.z == MAGIC |
| with assertRaises(AttributeError): |
| o.b |
| with assertRaises(AttributeError): |
| o.h |
| o.h = MAGIC |
| assert o.h == MAGIC |
| with assertRaises(AttributeError): |
| o.b |
| o.b = MAGIC |
| assert o.b == MAGIC |
| |
| @mypyc_attr(allow_interpreted_subclasses=True) |
| class MagicInit: |
| x: i64 = MAGIC |
| |
| def test_magic_value_as_initializer() -> None: |
| o = MagicInit() |
| assert o.x == MAGIC |
| |
| class ManyUninit: |
| a1: i64 |
| a2: i64 |
| a3: i64 |
| a4: i64 |
| a5: i64 |
| a6: i64 |
| a7: i64 |
| a8: i64 |
| a9: i64 |
| a10: i64 |
| a11: i64 |
| a12: i64 |
| a13: i64 |
| a14: i64 |
| a15: i64 |
| a16: i64 |
| a17: i64 |
| a18: i64 |
| a19: i64 |
| a20: i64 |
| a21: i64 |
| a22: i64 |
| a23: i64 |
| a24: i64 |
| a25: i64 |
| a26: i64 |
| a27: i64 |
| a28: i64 |
| a29: i64 |
| a30: i64 |
| a31: i64 |
| a32: i64 |
| a33: i64 |
| a34: i64 |
| a35: i64 |
| a36: i64 |
| a37: i64 |
| a38: i64 |
| a39: i64 |
| a40: i64 |
| a41: i64 |
| a42: i64 |
| a43: i64 |
| a44: i64 |
| a45: i64 |
| a46: i64 |
| a47: i64 |
| a48: i64 |
| a49: i64 |
| a50: i64 |
| a51: i64 |
| a52: i64 |
| a53: i64 |
| a54: i64 |
| a55: i64 |
| a56: i64 |
| a57: i64 |
| a58: i64 |
| a59: i64 |
| a60: i64 |
| a61: i64 |
| a62: i64 |
| a63: i64 |
| a64: i64 |
| a65: i64 |
| a66: i64 |
| a67: i64 |
| a68: i64 |
| a69: i64 |
| a70: i64 |
| a71: i64 |
| a72: i64 |
| a73: i64 |
| a74: i64 |
| a75: i64 |
| a76: i64 |
| a77: i64 |
| a78: i64 |
| a79: i64 |
| a80: i64 |
| a81: i64 |
| a82: i64 |
| a83: i64 |
| a84: i64 |
| a85: i64 |
| a86: i64 |
| a87: i64 |
| a88: i64 |
| a89: i64 |
| a90: i64 |
| a91: i64 |
| a92: i64 |
| a93: i64 |
| a94: i64 |
| a95: i64 |
| a96: i64 |
| a97: i64 |
| a98: i64 |
| a99: i64 |
| a100: i64 |
| |
| def test_many_uninitialized_attributes() -> None: |
| o = ManyUninit() |
| with assertRaises(AttributeError): |
| o.a1 |
| with assertRaises(AttributeError): |
| o.a10 |
| with assertRaises(AttributeError): |
| o.a20 |
| with assertRaises(AttributeError): |
| o.a30 |
| with assertRaises(AttributeError): |
| o.a31 |
| with assertRaises(AttributeError): |
| o.a32 |
| with assertRaises(AttributeError): |
| o.a33 |
| with assertRaises(AttributeError): |
| o.a40 |
| with assertRaises(AttributeError): |
| o.a50 |
| with assertRaises(AttributeError): |
| o.a60 |
| with assertRaises(AttributeError): |
| o.a62 |
| with assertRaises(AttributeError): |
| o.a63 |
| with assertRaises(AttributeError): |
| o.a64 |
| with assertRaises(AttributeError): |
| o.a65 |
| with assertRaises(AttributeError): |
| o.a80 |
| with assertRaises(AttributeError): |
| o.a100 |
| o.a30 = MAGIC |
| assert o.a30 == MAGIC |
| o.a31 = MAGIC |
| assert o.a31 == MAGIC |
| o.a32 = MAGIC |
| assert o.a32 == MAGIC |
| o.a33 = MAGIC |
| assert o.a33 == MAGIC |
| with assertRaises(AttributeError): |
| o.a34 |
| o.a62 = MAGIC |
| assert o.a62 == MAGIC |
| o.a63 = MAGIC |
| assert o.a63 == MAGIC |
| o.a64 = MAGIC |
| assert o.a64 == MAGIC |
| o.a65 = MAGIC |
| assert o.a65 == MAGIC |
| with assertRaises(AttributeError): |
| o.a66 |
| |
| class BaseNoBitmap: |
| x: int = 5 |
| |
| class DerivedBitmap(BaseNoBitmap): |
| # Subclass needs a bitmap, but base class doesn't have it. |
| y: i64 |
| |
| def test_derived_adds_bitmap() -> None: |
| d = DerivedBitmap() |
| d.x = 643 |
| b: BaseNoBitmap = d |
| assert b.x == 643 |
| |
| class Delete: |
| __deletable__ = ['x', 'y'] |
| x: i64 |
| y: i64 |
| |
| def test_del() -> None: |
| o = Delete() |
| o.x = MAGIC |
| o.y = -1 |
| assert o.x == MAGIC |
| assert o.y == -1 |
| del o.x |
| with assertRaises(AttributeError): |
| o.x |
| assert o.y == -1 |
| del o.y |
| with assertRaises(AttributeError): |
| o.y |
| o.x = 5 |
| assert o.x == 5 |
| with assertRaises(AttributeError): |
| o.y |
| del o.x |
| with assertRaises(AttributeError): |
| o.x |
| |
| [case testI64DefaultArgValues] |
| from typing import Any, Iterator |
| from typing_extensions import Final |
| |
| MAGIC: Final = -113 |
| |
| MYPY = False |
| if MYPY: |
| from mypy_extensions import i64 |
| |
| def f(x: i64, y: i64 = 5) -> i64: |
| return x + y |
| |
| def test_simple_default_arg() -> None: |
| assert f(3) == 8 |
| assert f(4, 9) == 13 |
| assert f(5, MAGIC) == -108 |
| for i in range(-1000, 1000): |
| assert f(1, i) == 1 + i |
| f2: Any = f |
| assert f2(3) == 8 |
| assert f2(4, 9) == 13 |
| assert f2(5, MAGIC) == -108 |
| |
| def g(a: i64, b: i64 = 1, c: int = 2, d: i64 = 3) -> i64: |
| return a + b + c + d |
| |
| def test_two_default_args() -> None: |
| assert g(10) == 16 |
| assert g(10, 2) == 17 |
| assert g(10, 2, 3) == 18 |
| assert g(10, 2, 3, 4) == 19 |
| g2: Any = g |
| assert g2(10) == 16 |
| assert g2(10, 2) == 17 |
| assert g2(10, 2, 3) == 18 |
| assert g2(10, 2, 3, 4) == 19 |
| |
| class C: |
| def __init__(self) -> None: |
| self.i: i64 = 1 |
| |
| def m(self, a: i64, b: i64 = 1, c: int = 2, d: i64 = 3) -> i64: |
| return self.i + a + b + c + d |
| |
| class D(C): |
| def m(self, a: i64, b: i64 = 2, c: int = 3, d: i64 = 4) -> i64: |
| return self.i + a + b + c + d |
| |
| def mm(self, a: i64 = 2, b: i64 = 1) -> i64: |
| return self.i + a + b |
| |
| @staticmethod |
| def s(a: i64 = 2, b: i64 = 1) -> i64: |
| return a + b |
| |
| @classmethod |
| def c(cls, a: i64 = 2, b: i64 = 3) -> i64: |
| assert cls is D |
| return a + b |
| |
| def test_method_default_args() -> None: |
| a = [C(), D()] |
| assert a[0].m(4) == 11 |
| d = D() |
| assert d.mm() == 4 |
| assert d.mm(5) == 7 |
| assert d.mm(MAGIC) == MAGIC + 2 |
| assert d.mm(b=5) == 8 |
| assert D.mm(d) == 4 |
| assert D.mm(d, 6) == 8 |
| assert D.mm(d, MAGIC) == MAGIC + 2 |
| assert D.mm(d, b=6) == 9 |
| dd: Any = d |
| assert dd.mm() == 4 |
| assert dd.mm(5) == 7 |
| assert dd.mm(MAGIC) == MAGIC + 2 |
| assert dd.mm(b=5) == 8 |
| |
| def test_static_method_default_args() -> None: |
| d = D() |
| assert d.s() == 3 |
| assert d.s(5) == 6 |
| assert d.s(MAGIC) == MAGIC + 1 |
| assert d.s(5, 6) == 11 |
| assert D.s() == 3 |
| assert D.s(5) == 6 |
| assert D.s(MAGIC) == MAGIC + 1 |
| assert D.s(5, 6) == 11 |
| dd: Any = d |
| assert dd.s() == 3 |
| assert dd.s(5) == 6 |
| assert dd.s(MAGIC) == MAGIC + 1 |
| assert dd.s(5, 6) == 11 |
| |
| def test_class_method_default_args() -> None: |
| d = D() |
| assert d.c() == 5 |
| assert d.c(5) == 8 |
| assert d.c(MAGIC) == MAGIC + 3 |
| assert d.c(b=5) == 7 |
| assert D.c() == 5 |
| assert D.c(5) == 8 |
| assert D.c(MAGIC) == MAGIC + 3 |
| assert D.c(b=5) == 7 |
| dd: Any = d |
| assert dd.c() == 5 |
| assert dd.c(5) == 8 |
| assert dd.c(MAGIC) == MAGIC + 3 |
| assert dd.c(b=5) == 7 |
| |
| class Init: |
| def __init__(self, x: i64 = 2, y: i64 = 5) -> None: |
| self.x = x |
| self.y = y |
| |
| def test_init_default_args() -> None: |
| o = Init() |
| assert o.x == 2 |
| assert o.y == 5 |
| o = Init(7, 8) |
| assert o.x == 7 |
| assert o.y == 8 |
| o = Init(4) |
| assert o.x == 4 |
| assert o.y == 5 |
| o = Init(MAGIC, MAGIC) |
| assert o.x == MAGIC |
| assert o.y == MAGIC |
| o = Init(3, MAGIC) |
| assert o.x == 3 |
| assert o.y == MAGIC |
| o = Init(MAGIC, 11) |
| assert o.x == MAGIC |
| assert o.y == 11 |
| o = Init(MAGIC) |
| assert o.x == MAGIC |
| assert o.y == 5 |
| o = Init(y=MAGIC) |
| assert o.x == 2 |
| assert o.y == MAGIC |
| |
| def kw_only(*, a: i64 = 1, b: int = 2, c: i64 = 3) -> i64: |
| return a + b + c * 2 |
| |
| def test_kw_only_default_args() -> None: |
| assert kw_only() == 9 |
| assert kw_only(a=2) == 10 |
| assert kw_only(b=4) == 11 |
| assert kw_only(c=11) == 25 |
| assert kw_only(a=2, c=4) == 12 |
| assert kw_only(c=4, a=2) == 12 |
| kw_only2: Any = kw_only |
| assert kw_only2() == 9 |
| assert kw_only2(a=2) == 10 |
| assert kw_only2(b=4) == 11 |
| assert kw_only2(c=11) == 25 |
| assert kw_only2(a=2, c=4) == 12 |
| assert kw_only2(c=4, a=2) == 12 |
| |
| def many_args( |
| a1: i64 = 0, |
| a2: i64 = 1, |
| a3: i64 = 2, |
| a4: i64 = 3, |
| a5: i64 = 4, |
| a6: i64 = 5, |
| a7: i64 = 6, |
| a8: i64 = 7, |
| a9: i64 = 8, |
| a10: i64 = 9, |
| a11: i64 = 10, |
| a12: i64 = 11, |
| a13: i64 = 12, |
| a14: i64 = 13, |
| a15: i64 = 14, |
| a16: i64 = 15, |
| a17: i64 = 16, |
| a18: i64 = 17, |
| a19: i64 = 18, |
| a20: i64 = 19, |
| a21: i64 = 20, |
| a22: i64 = 21, |
| a23: i64 = 22, |
| a24: i64 = 23, |
| a25: i64 = 24, |
| a26: i64 = 25, |
| a27: i64 = 26, |
| a28: i64 = 27, |
| a29: i64 = 28, |
| a30: i64 = 29, |
| a31: i64 = 30, |
| a32: i64 = 31, |
| a33: i64 = 32, |
| a34: i64 = 33, |
| ) -> i64: |
| return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13 + a14 + a15 + a16 + a17 + a18 + a19 + a20 + a21 + a22 + a23 + a24 + a25 + a26 + a27 + a28 + a29 + a30 + a31 + a32 + a33 + a34 |
| |
| def test_many_args() -> None: |
| assert many_args() == 561 |
| assert many_args(a1=100) == 661 |
| assert many_args(a2=101) == 661 |
| assert many_args(a15=114) == 661 |
| assert many_args(a31=130) == 661 |
| assert many_args(a32=131) == 661 |
| assert many_args(a33=232) == 761 |
| assert many_args(a34=333) == 861 |
| assert many_args(a1=100, a33=232) == 861 |
| f: Any = many_args |
| assert f() == 561 |
| assert f(a1=100) == 661 |
| assert f(a2=101) == 661 |
| assert f(a15=114) == 661 |
| assert f(a31=130) == 661 |
| assert f(a32=131) == 661 |
| assert f(a33=232) == 761 |
| assert f(a34=333) == 861 |
| assert f(a1=100, a33=232) == 861 |
| |
| def test_nested_function_defaults() -> None: |
| a: i64 = 1 |
| |
| def nested(x: i64 = 2, y: i64 = 3) -> i64: |
| return a + x + y |
| |
| assert nested() == 6 |
| assert nested(3) == 7 |
| assert nested(y=5) == 8 |
| assert nested(MAGIC) == MAGIC + 4 |
| a = 11 |
| assert nested() == 16 |
| |
| |
| def test_nested_function_defaults_via_any() -> None: |
| a: i64 = 1 |
| |
| def nested_native(x: i64 = 2, y: i64 = 3) -> i64: |
| return a + x + y |
| |
| nested: Any = nested_native |
| |
| assert nested() == 6 |
| assert nested(3) == 7 |
| assert nested(y=5) == 8 |
| assert nested(MAGIC) == MAGIC + 4 |
| a = 11 |
| assert nested() == 16 |
| |
| def gen(x: i64 = 1, y: i64 = 2) -> Iterator[i64]: |
| yield x + y |
| |
| def test_generator() -> None: |
| g = gen() |
| assert next(g) == 3 |
| g = gen(2) |
| assert next(g) == 4 |
| g = gen(2, 3) |
| assert next(g) == 5 |
| a: Any = gen |
| g = a() |
| assert next(g) == 3 |
| g = a(2) |
| assert next(g) == 4 |
| g = a(2, 3) |
| assert next(g) == 5 |
| |
| def magic_default(x: i64 = MAGIC) -> i64: |
| return x |
| |
| def test_magic_default() -> None: |
| assert magic_default() == MAGIC |
| assert magic_default(1) == 1 |
| assert magic_default(MAGIC) == MAGIC |
| a: Any = magic_default |
| assert a() == MAGIC |
| assert a(1) == 1 |
| assert a(MAGIC) == MAGIC |
| |
| [case testI64UndefinedLocal] |
| from typing_extensions import Final |
| |
| MYPY = False |
| if MYPY: |
| from mypy_extensions import i64, i32 |
| |
| from testutil import assertRaises |
| |
| MAGIC: Final = -113 |
| |
| |
| def test_conditionally_defined_local() -> None: |
| x = not int() |
| if x: |
| y: i64 = 5 |
| z: i32 = 6 |
| assert y == 5 |
| assert z == 6 |
| |
| def test_conditionally_undefined_local() -> None: |
| x = int() |
| if x: |
| y: i64 = 5 |
| z: i32 = 6 |
| else: |
| ok: i64 = 7 |
| assert ok == 7 |
| try: |
| print(y) |
| except NameError as e: |
| assert str(e) == 'local variable "y" referenced before assignment' |
| else: |
| assert False |
| try: |
| print(z) |
| except NameError as e: |
| assert str(e) == 'local variable "z" referenced before assignment' |
| else: |
| assert False |
| |
| def test_assign_error_value_conditionally() -> None: |
| x = int() |
| if not x: |
| y: i64 = MAGIC |
| z: i32 = MAGIC |
| assert y == MAGIC |
| assert z == MAGIC |
| |
| def test_many_locals() -> None: |
| x = int() |
| if x: |
| a0: i64 = 0 |
| a1: i64 = 1 |
| a2: i64 = 2 |
| a3: i64 = 3 |
| a4: i64 = 4 |
| a5: i64 = 5 |
| a6: i64 = 6 |
| a7: i64 = 7 |
| a8: i64 = 8 |
| a9: i64 = 9 |
| a10: i64 = 10 |
| a11: i64 = 11 |
| a12: i64 = 12 |
| a13: i64 = 13 |
| a14: i64 = 14 |
| a15: i64 = 15 |
| a16: i64 = 16 |
| a17: i64 = 17 |
| a18: i64 = 18 |
| a19: i64 = 19 |
| a20: i64 = 20 |
| a21: i64 = 21 |
| a22: i64 = 22 |
| a23: i64 = 23 |
| a24: i64 = 24 |
| a25: i64 = 25 |
| a26: i64 = 26 |
| a27: i64 = 27 |
| a28: i64 = 28 |
| a29: i64 = 29 |
| a30: i64 = 30 |
| a31: i64 = 31 |
| a32: i64 = 32 |
| a33: i64 = 33 |
| with assertRaises(NameError): |
| print(a0) |
| with assertRaises(NameError): |
| print(a31) |
| with assertRaises(NameError): |
| print(a32) |
| with assertRaises(NameError): |
| print(a33) |
| a0 = 5 |
| assert a0 == 5 |
| with assertRaises(NameError): |
| print(a31) |
| with assertRaises(NameError): |
| print(a32) |
| with assertRaises(NameError): |
| print(a33) |
| a32 = 55 |
| assert a0 == 5 |
| assert a32 == 55 |
| with assertRaises(NameError): |
| print(a31) |
| with assertRaises(NameError): |
| print(a33) |
| a31 = 10 |
| a33 = 20 |
| assert a0 == 5 |
| assert a31 == 10 |
| assert a32 == 55 |
| assert a33 == 20 |
| |
| [case testI64GlueMethods] |
| from typing_extensions import Final |
| |
| MYPY = False |
| if MYPY: |
| from mypy_extensions import i64 |
| |
| MAGIC: Final = -113 |
| |
| class Base: |
| def foo(self) -> i64: |
| return 5 |
| |
| def bar(self, x: i64 = 2) -> i64: |
| return x + 1 |
| |
| def hoho(self, x: i64) -> i64: |
| return x - 1 |
| |
| class Derived(Base): |
| def foo(self, x: i64 = 5) -> i64: |
| return x + 10 |
| |
| def bar(self, x: i64 = 3, y: i64 = 20) -> i64: |
| return x + y + 2 |
| |
| def hoho(self, x: i64 = 7) -> i64: |
| return x - 2 |
| |
| def test_derived_adds_bitmap() -> None: |
| b: Base = Derived() |
| assert b.foo() == 15 |
| |
| def test_derived_adds_another_default_arg() -> None: |
| b: Base = Derived() |
| assert b.bar() == 25 |
| assert b.bar(1) == 23 |
| assert b.bar(MAGIC) == MAGIC + 22 |
| |
| def test_derived_switches_arg_to_have_default() -> None: |
| b: Base = Derived() |
| assert b.hoho(5) == 3 |
| assert b.hoho(MAGIC) == MAGIC - 2 |
