superacli 1.1.6 → 1.1.8

package/ref-monty/crates/monty/test_cases/int__bigint_errors.py

@@ -1,260 +0,0 @@
-# Tests for error cases in BigInt-related builtins and operations
-# All error messages must match CPython exactly
-# Uses 'in str(e)' checks since Monty's str(e) includes the type name
-
-# === Setup constants ===
-MAX_I64 = 9223372036854775807
-BIGINT = MAX_I64 + 1  # Force BigInt creation
-
-
-# === hex() errors ===
-try:
-    hex('str')
-    assert False, 'hex(str) should raise TypeError'
-except TypeError as e:
-    assert "'str' object cannot be interpreted as an integer" in str(e), f'hex str error: {e}'
-
-try:
-    hex(1.5)
-    assert False, 'hex(float) should raise TypeError'
-except TypeError as e:
-    assert "'float' object cannot be interpreted as an integer" in str(e), f'hex float error: {e}'
-
-try:
-    hex([])
-    assert False, 'hex(list) should raise TypeError'
-except TypeError as e:
-    assert "'list' object cannot be interpreted as an integer" in str(e), f'hex list error: {e}'
-
-
-# === bin() errors ===
-try:
-    bin('str')
-    assert False, 'bin(str) should raise TypeError'
-except TypeError as e:
-    assert "'str' object cannot be interpreted as an integer" in str(e), f'bin str error: {e}'
-
-try:
-    bin(1.5)
-    assert False, 'bin(float) should raise TypeError'
-except TypeError as e:
-    assert "'float' object cannot be interpreted as an integer" in str(e), f'bin float error: {e}'
-
-try:
-    bin({})
-    assert False, 'bin(dict) should raise TypeError'
-except TypeError as e:
-    assert "'dict' object cannot be interpreted as an integer" in str(e), f'bin dict error: {e}'
-
-
-# === oct() errors ===
-try:
-    oct('str')
-    assert False, 'oct(str) should raise TypeError'
-except TypeError as e:
-    assert "'str' object cannot be interpreted as an integer" in str(e), f'oct str error: {e}'
-
-try:
-    oct(1.5)
-    assert False, 'oct(float) should raise TypeError'
-except TypeError as e:
-    assert "'float' object cannot be interpreted as an integer" in str(e), f'oct float error: {e}'
-
-try:
-    oct((1, 2))
-    assert False, 'oct(tuple) should raise TypeError'
-except TypeError as e:
-    assert "'tuple' object cannot be interpreted as an integer" in str(e), f'oct tuple error: {e}'
-
-
-# === divmod() division by zero ===
-try:
-    divmod(10, 0)
-    assert False, 'divmod(int, 0) should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'division by zero' in str(e), f'divmod int/0 error: {e}'
-
-try:
-    divmod(BIGINT, 0)
-    assert False, 'divmod(bigint, 0) should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'division by zero' in str(e), f'divmod bigint/0 error: {e}'
-
-try:
-    divmod(10, BIGINT - BIGINT)  # BigInt zero
-    assert False, 'divmod(int, bigint_zero) should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'division by zero' in str(e), f'divmod int/bigint_zero error: {e}'
-
-try:
-    divmod(BIGINT, BIGINT - BIGINT)  # BigInt / BigInt zero
-    assert False, 'divmod(bigint, bigint_zero) should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'division by zero' in str(e), f'divmod bigint/bigint_zero error: {e}'
-
-try:
-    divmod(10.0, 0.0)
-    assert False, 'divmod(float, 0.0) should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'division by zero' in str(e), f'divmod float/0.0 error: {e}'
-
-try:
-    divmod(10, 0.0)
-    assert False, 'divmod(int, 0.0) should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'division by zero' in str(e), f'divmod int/0.0 error: {e}'
-
-try:
-    divmod(10.0, 0)
-    assert False, 'divmod(float, 0) should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'division by zero' in str(e), f'divmod float/0 error: {e}'
-
-
-# === divmod() type errors ===
-try:
-    divmod('a', 5)
-    assert False, 'divmod(str, int) should raise TypeError'
-except TypeError as e:
-    assert "unsupported operand type(s) for divmod(): 'str' and 'int'" in str(e), f'divmod str/int error: {e}'
-
-try:
-    divmod(5, 'a')
-    assert False, 'divmod(int, str) should raise TypeError'
-except TypeError as e:
-    assert "unsupported operand type(s) for divmod(): 'int' and 'str'" in str(e), f'divmod int/str error: {e}'
-
-try:
-    divmod([], 5)
-    assert False, 'divmod(list, int) should raise TypeError'
-except TypeError as e:
-    assert "unsupported operand type(s) for divmod(): 'list' and 'int'" in str(e), f'divmod list/int error: {e}'
-
-try:
-    divmod(BIGINT, 'a')
-    assert False, 'divmod(bigint, str) should raise TypeError'
-except TypeError as e:
-    assert "unsupported operand type(s) for divmod(): 'int' and 'str'" in str(e), f'divmod bigint/str error: {e}'
-
-
-# === pow() zero to negative power ===
-try:
-    pow(0.0, -1)
-    assert False, 'pow(0.0, -1) should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'zero to a negative power' in str(e), f'pow 0.0/-1 error: {e}'
-
-try:
-    pow(0, -1.0)
-    assert False, 'pow(0, -1.0) should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'zero to a negative power' in str(e), f'pow 0/-1.0 error: {e}'
-
-try:
-    pow(0.0, -2.0)
-    assert False, 'pow(0.0, -2.0) should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'zero to a negative power' in str(e), f'pow 0.0/-2.0 error: {e}'
-
-
-# === pow() with modulo errors ===
-try:
-    pow(2, 10, 0)
-    assert False, 'pow(2, 10, 0) should raise ValueError'
-except ValueError as e:
-    assert 'pow() 3rd argument cannot be 0' in str(e), f'pow mod=0 error: {e}'
-
-# Note: pow(2, -1, 5) computes modular inverse in Python 3.8+, not an error
-# But pow(2, -1, 4) raises an error because 2 is not invertible mod 4
-try:
-    pow(2, -1, 4)  # gcd(2, 4) != 1, no inverse exists
-    assert False, 'pow(2, -1, 4) should raise ValueError'
-except ValueError as e:
-    # CPython: "base is not invertible for the given modulus"
-    # Monty: "pow() 2nd argument cannot be negative when 3rd argument specified"
-    # Accept either message since Monty doesn't support modular inverse yet
-    assert 'not invertible' in str(e) or 'cannot be negative' in str(e), f'pow non-invertible error: {e}'
-
-try:
-    pow(2.0, 2, 5)
-    assert False, 'pow(float, int, int) should raise TypeError'
-except TypeError as e:
-    assert 'pow() 3rd argument not allowed unless all arguments are integers' in str(e), f'pow float mod error: {e}'
-
-try:
-    pow(2, 2.0, 5)
-    assert False, 'pow(int, float, int) should raise TypeError'
-except TypeError as e:
-    assert 'pow() 3rd argument not allowed unless all arguments are integers' in str(e), f'pow float exp mod error: {e}'
-
-try:
-    pow(2, 2, 5.0)
-    assert False, 'pow(int, int, float) should raise TypeError'
-except TypeError as e:
-    assert 'pow() 3rd argument not allowed unless all arguments are integers' in str(e), f'pow float mod2 error: {e}'
-
-
-# === abs() type errors ===
-try:
-    abs('str')
-    assert False, 'abs(str) should raise TypeError'
-except TypeError as e:
-    assert "bad operand type for abs(): 'str'" in str(e), f'abs str error: {e}'
-
-try:
-    abs([])
-    assert False, 'abs(list) should raise TypeError'
-except TypeError as e:
-    assert "bad operand type for abs(): 'list'" in str(e), f'abs list error: {e}'
-
-try:
-    abs({})
-    assert False, 'abs(dict) should raise TypeError'
-except TypeError as e:
-    assert "bad operand type for abs(): 'dict'" in str(e), f'abs dict error: {e}'
-
-
-# === pow() type errors (** operator) ===
-try:
-    5 ** 'x'
-    assert False, '5 ** str should raise TypeError'
-except TypeError as e:
-    assert "unsupported operand type(s) for ** or pow(): 'int' and 'str'" in str(e), f'int ** str error: {e}'
-
-try:
-    'x' ** 5
-    assert False, 'str ** int should raise TypeError'
-except TypeError as e:
-    assert "unsupported operand type(s) for ** or pow(): 'str' and 'int'" in str(e), f'str ** int error: {e}'
-
-try:
-    BIGINT ** 'x'
-    assert False, 'bigint ** str should raise TypeError'
-except TypeError as e:
-    assert "unsupported operand type(s) for ** or pow(): 'int' and 'str'" in str(e), f'bigint ** str error: {e}'
-
-
-# === Division by zero with BigInt ===
-try:
-    BIGINT // 0
-    assert False, 'bigint // 0 should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'division by zero' in str(e), f'bigint floordiv error: {e}'
-
-try:
-    BIGINT % 0
-    assert False, 'bigint % 0 should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'division by zero' in str(e), f'bigint mod error: {e}'
-
-try:
-    10 // (BIGINT - BIGINT)  # int // BigInt zero
-    assert False, 'int // bigint_zero should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'division by zero' in str(e), f'int floordiv bigint_zero error: {e}'
-
-try:
-    10 % (BIGINT - BIGINT)  # int % BigInt zero
-    assert False, 'int % bigint_zero should raise ZeroDivisionError'
-except ZeroDivisionError as e:
-    assert 'division by zero' in str(e), f'int mod bigint_zero error: {e}'

package/ref-monty/crates/monty/test_cases/int__ops.py

@@ -1,219 +0,0 @@
-# === Integer addition ===
-assert 1 + 2 == 3, 'basic add'
-assert 5 + 0 == 5, 'add zero'
-assert 0 + 5 == 5, 'zero add'
-
-# === Integer subtraction ===
-assert 5 - 3 == 2, 'basic sub'
-assert 5 - 0 == 5, 'sub zero'
-
-# === Mixed int/float addition ===
-assert 3 + 4.0 == 7.0, 'int add float'
-assert 4.0 + 3 == 7.0, 'float add int'
-assert -2 + 3.5 == 1.5, 'neg int add float'
-assert 0 + 2.5 == 2.5, 'zero add float'
-assert 2.5 + 0 == 2.5, 'float add zero'
-
-# === Mixed int/float subtraction ===
-assert 5 - 2.5 == 2.5, 'int sub float'
-assert 5.5 - 2 == 3.5, 'float sub int'
-assert -3 - 1.5 == -4.5, 'neg int sub float'
-assert 1.5 - (-2) == 3.5, 'float sub neg int'
-
-# === Float subtraction ===
-assert 5.5 - 2.5 == 3.0, 'float sub float'
-assert 0.0 - 1.5 == -1.5, 'zero sub float'
-
-# === Integer modulo ===
-assert 10 % 3 == 1, 'basic mod'
-assert 3 % 10 == 3, 'mod larger divisor'
-assert 9 % 3 == 0, 'mod zero result'
-
-# === Augmented assignment (+=) ===
-x = 5
-x += 3
-assert x == 8, 'basic iadd'
-
-# === Integer repr/str ===
-assert repr(42) == '42', 'int repr'
-assert str(42) == '42', 'int str'
-
-# === Float repr/str ===
-assert repr(2.5) == '2.5', 'float repr'
-assert str(2.5) == '2.5', 'float str'
-
-# === Integer multiplication ===
-assert 3 * 4 == 12, 'basic int mult'
-assert 5 * 0 == 0, 'mult by zero'
-assert 0 * 5 == 0, 'zero mult'
-assert -3 * 4 == -12, 'negative mult'
-assert 3 * -4 == -12, 'mult negative'
-assert -3 * -4 == 12, 'neg mult neg'
-
-# === Float multiplication ===
-assert 3.0 * 4.0 == 12.0, 'float mult'
-assert 2.5 * 2.0 == 5.0, 'float mult 2'
-
-# === Mixed int/float multiplication ===
-assert 3 * 4.0 == 12.0, 'int mult float'
-assert 4.0 * 3 == 12.0, 'float mult int'
-
-# === True division (always returns float) ===
-assert 6 / 2 == 3.0, 'int div exact'
-assert 7 / 2 == 3.5, 'int div remainder'
-assert 1 / 4 == 0.25, 'int div fraction'
-assert 6.0 / 2.0 == 3.0, 'float div'
-assert 7 / 2.0 == 3.5, 'int div float'
-assert 7.0 / 2 == 3.5, 'float div int'
-assert -7 / 2 == -3.5, 'neg div'
-
-# === Floor division ===
-assert 7 // 2 == 3, 'int floor div'
-assert 6 // 2 == 3, 'int floor div exact'
-assert -7 // 2 == -4, 'neg floor div rounds down'
-assert 7 // -2 == -4, 'floor div neg rounds down'
-assert -7 // -2 == 3, 'neg floor div neg'
-assert 7.0 // 2.0 == 3.0, 'float floor div'
-assert 7 // 2.0 == 3.0, 'int floor div float'
-assert 7.0 // 2 == 3.0, 'float floor div int'
-assert -7.0 // 2.0 == -4.0, 'neg float floor div'
-
-# === Power (exponentiation) ===
-assert 2**3 == 8, 'int pow'
-assert 2**10 == 1024, 'int pow large'
-assert 2**0 == 1, 'pow zero'
-assert (-2) ** 3 == -8, 'neg base pow'
-assert (-2) ** 2 == 4, 'neg base even pow'
-assert 2**-1 == 0.5, 'pow neg returns float'
-assert 2**-2 == 0.25, 'pow neg 2'
-assert 4.0**2.0 == 16.0, 'float pow'
-assert 4**0.5 == 2.0, 'sqrt via pow'
-assert 8 ** (1 / 3) == 2.0, 'cube root via pow'
-assert 2.0**3 == 8.0, 'float pow int'
-
-# === Augmented assignment operators ===
-# *=
-x = 5
-x *= 3
-assert x == 15, 'imult'
-
-# /=
-x = 10
-x /= 4
-assert x == 2.5, 'idiv'
-
-# //=
-x = 10
-x //= 3
-assert x == 3, 'ifloordiv'
-
-# **=
-x = 2
-x **= 4
-assert x == 16, 'ipow'
-
-# -=
-x = 10
-x -= 3
-assert x == 7, 'isub'
-
-# %=
-x = 10
-x %= 3
-assert x == 1, 'imod'
-
-# === Bool arithmetic (True=1, False=0) ===
-# Bool multiplication
-assert True * 3 == 3, 'bool mult int'
-assert False * 5 == 0, 'false mult int'
-assert 3 * True == 3, 'int mult bool'
-assert 3 * False == 0, 'int mult false'
-assert True * True == 1, 'bool mult bool'
-assert True * False == 0, 'bool mult false'
-assert True * 2.5 == 2.5, 'bool mult float'
-assert 2.5 * True == 2.5, 'float mult bool'
-
-# Bool division
-assert True / 2 == 0.5, 'bool div int'
-assert False / 2 == 0.0, 'false div int'
-assert 4 / True == 4.0, 'int div bool'
-assert True / True == 1.0, 'bool div bool'
-assert True / 2.0 == 0.5, 'bool div float'
-assert 4.0 / True == 4.0, 'float div bool'
-
-# Bool floor division
-assert True // 2 == 0, 'bool floordiv int'
-assert False // 2 == 0, 'false floordiv int'
-assert 5 // True == 5, 'int floordiv bool'
-assert True // True == 1, 'bool floordiv bool'
-assert True // 2.0 == 0.0, 'bool floordiv float'
-assert 5.5 // True == 5.0, 'float floordiv bool'
-
-# Bool power
-assert True**3 == 1, 'bool pow int'
-assert False**3 == 0, 'false pow int'
-assert 2**True == 2, 'int pow bool true'
-assert 2**False == 1, 'int pow bool false'
-assert True**True == 1, 'bool pow bool'
-assert False**False == 1, 'false pow false'
-assert True**2.0 == 1.0, 'bool pow float'
-assert 2.0**True == 2.0, 'float pow bool true'
-assert 2.0**False == 1.0, 'float pow bool false'
-
-# === Unary positive (no-op for numbers, converts bools to int) ===
-assert +5 == 5, 'unary pos int'
-assert +(-3) == -3, 'unary pos neg int'
-assert +0 == 0, 'unary pos zero'
-assert +3.14 == 3.14, 'unary pos float'
-assert +(-2.5) == -2.5, 'unary pos neg float'
-assert +0.0 == 0.0, 'unary pos zero float'
-assert +True == 1, 'unary pos true'
-assert +False == 0, 'unary pos false'
-# Verify +bool returns int type, not bool
-assert type(+True) == int, 'unary pos true returns int type'
-assert type(+False) == int, 'unary pos false returns int type'
-
-# === Unary negative ===
-assert -5 == -5, 'unary neg int'
-assert -(-3) == 3, 'unary neg neg int'
-assert -0 == 0, 'unary neg zero'
-assert -3.14 == -3.14, 'unary neg float'
-assert -(-2.5) == 2.5, 'unary neg neg float'
-assert -True == -1, 'unary neg true'
-assert repr(-True) == '-1', 'unary neg true repr'
-assert -False == 0, 'unary neg false'
-assert repr(-False) == '0', 'unary neg false repr'
-
-# === Unary invert (bitwise NOT) ===
-assert ~0 == -1, 'unary invert zero'
-assert ~1 == -2, 'unary invert one'
-assert ~(-1) == 0, 'unary invert neg one'
-assert ~True == -2, 'unary invert true'
-assert repr(~True) == '-2', 'unary invert true repr'
-assert ~False == -1, 'unary invert false'
-assert repr(~False) == '-1', 'unary invert false repr'
-
-assert int('123') == 123, 'int conversion from string'
-assert int('  123  ') == 123, 'int conversion from string trim'
-assert int('1_234 ') == 1234, 'int conversion from string'
-
-try:
-    int('abc')
-except ValueError as e:
-    assert str(e) == "invalid literal for int() with base 10: 'abc'", f'got err: {e}'
-else:
-    raise AssertionError('int conversion from string should fail')
-
-try:
-    int(' ')
-except ValueError as e:
-    assert str(e) == "invalid literal for int() with base 10: ' '", f'got err: {e}'
-else:
-    raise AssertionError('int conversion from string should fail')
-
-try:
-    int('a\tbc')
-except ValueError as e:
-    assert str(e) == "invalid literal for int() with base 10: 'a\\tbc'", f'got err: {e}'
-else:
-    raise AssertionError('int conversion from string should fail')

package/ref-monty/crates/monty/test_cases/int__overflow_division.py

@@ -1,84 +0,0 @@
-# === i64::MIN // -1 overflow ===
-INT_MIN = -(2**63)
-INT_MAX = 2**63 - 1
-
-assert INT_MIN // -1 == 9223372036854775808, 'INT_MIN // -1'
-assert INT_MIN % -1 == 0, 'INT_MIN % -1'
-
-q, r = divmod(INT_MIN, -1)
-assert q == 9223372036854775808, 'divmod(INT_MIN, -1) quot'
-assert r == 0, 'divmod(INT_MIN, -1) rem'
-
-# === augmented assignment ===
-x = INT_MIN
-x //= -1
-assert x == 9223372036854775808, 'INT_MIN //= -1'
-
-x = INT_MIN
-x %= -1
-assert x == 0, 'INT_MIN %= -1'
-
-# === i64 boundary values ===
-assert INT_MIN // 1 == INT_MIN, 'INT_MIN // 1'
-assert INT_MIN // -2 == 4611686018427387904, 'INT_MIN // -2'
-assert INT_MIN % 1 == 0, 'INT_MIN % 1'
-assert INT_MIN % -2 == 0, 'INT_MIN % -2'
-assert INT_MIN % 3 == 1, 'INT_MIN % 3'
-
-assert INT_MAX // -1 == -INT_MAX, 'INT_MAX // -1'
-assert INT_MAX % -1 == 0, 'INT_MAX % -1'
-assert INT_MAX // 2 == 4611686018427387903, 'INT_MAX // 2'
-assert INT_MAX % 2 == 1, 'INT_MAX % 2'
-
-# === boundary divisors ===
-assert INT_MIN // INT_MIN == 1, 'INT_MIN // INT_MIN'
-assert INT_MIN // INT_MAX == -2, 'INT_MIN // INT_MAX'
-assert INT_MAX // INT_MIN == -1, 'INT_MAX // INT_MIN'
-assert INT_MIN % INT_MIN == 0, 'INT_MIN % INT_MIN'
-assert INT_MAX % INT_MAX == 0, 'INT_MAX % INT_MAX'
-
-# === sign combinations ===
-assert -7 // 2 == -4, '-7 // 2'
-assert 7 // -2 == -4, '7 // -2'
-assert -7 % 2 == 1, '-7 % 2'
-assert 7 % -2 == -1, '7 % -2'
-
-q, r = divmod(-7, 2)
-assert q == -4, 'divmod(-7, 2) quot'
-assert r == 1, 'divmod(-7, 2) rem'
-
-q, r = divmod(7, -2)
-assert q == -4, 'divmod(7, -2) quot'
-assert r == -1, 'divmod(7, -2) rem'
-
-# === divmod at boundaries ===
-q, r = divmod(INT_MIN, 2)
-assert q == -4611686018427387904, 'divmod(INT_MIN, 2) quot'
-assert r == 0, 'divmod(INT_MIN, 2) rem'
-
-q, r = divmod(INT_MAX, -1)
-assert q == -INT_MAX, 'divmod(INT_MAX, -1) quot'
-assert r == 0, 'divmod(INT_MAX, -1) rem'
-
-q, r = divmod(INT_MIN, INT_MAX)
-assert q == -2, 'divmod(INT_MIN, INT_MAX) quot'
-assert r == INT_MAX - 1, 'divmod(INT_MIN, INT_MAX) rem'
-
-# === divmod invariant: q * b + r == a ===
-q, r = divmod(INT_MIN, -1)
-assert q * -1 + r == INT_MIN, 'divmod(INT_MIN, -1) invariant'
-
-q, r = divmod(INT_MIN, 3)
-assert q * 3 + r == INT_MIN, 'divmod(INT_MIN, 3) invariant'
-assert q == -3074457345618258603, 'divmod(INT_MIN, 3) quot'
-assert r == 1, 'divmod(INT_MIN, 3) rem'
-
-# === CompareModEq patterns ===
-x = INT_MIN
-assert x % -1 == 0, 'INT_MIN % -1 == 0'
-assert x % 2 == 0, 'INT_MIN % 2 == 0'
-assert x % 3 == 1, 'INT_MIN % 3 == 1'
-
-x = INT_MAX
-assert x % -1 == 0, 'INT_MAX % -1 == 0'
-assert x % 2 == 1, 'INT_MAX % 2 == 1'

package/ref-monty/crates/monty/test_cases/is_variant__all.py

@@ -1,36 +0,0 @@
-# Tests that values of different types are returned correctly
-# Also tests identity operators with singletons
-
-# === Boolean values ===
-assert repr(False) == 'False', 'False repr'
-assert repr(True) == 'True', 'True repr'
-
-# === None value ===
-assert repr(None) == 'None', 'None repr'
-
-# === Ellipsis value ===
-assert repr(...) == 'Ellipsis', 'Ellipsis repr'
-
-# === Ellipsis identity ===
-assert (... is ...) == True, 'ellipsis is ellipsis'
-assert (None is ...) == False, 'none is not ellipsis'
-
-# === Type checks against None ===
-assert (False is None) == False, 'False is not None'
-assert (True is None) == False, 'True is not None'
-assert (None is None) == True, 'None is None'
-assert (42 is None) == False, 'int is not None'
-assert (3.14 is None) == False, 'float is not None'
-assert ([1, 2] is None) == False, 'list is not None'
-assert ('hello' is None) == False, 'str is not None'
-assert ((1, 2) is None) == False, 'tuple is not None'
-
-# === Type checks against Ellipsis ===
-assert (False is ...) == False, 'False is not Ellipsis'
-assert (True is ...) == False, 'True is not Ellipsis'
-assert (None is ...) == False, 'None is not Ellipsis'
-assert (42 is ...) == False, 'int is not Ellipsis'
-assert (3.14 is ...) == False, 'float is not Ellipsis'
-assert ([1, 2] is ...) == False, 'list is not Ellipsis'
-assert ('hello' is ...) == False, 'str is not Ellipsis'
-assert ((1, 2) is ...) == False, 'tuple is not Ellipsis'

package/ref-monty/crates/monty/test_cases/isinstance__arg2_list_error.py

@@ -1,2 +0,0 @@
-isinstance(1, [int, str])
-# Raise=TypeError('isinstance() arg 2 must be a type, a tuple of types, or a union')

package/ref-monty/crates/monty/test_cases/isinstance__arg2_type_error.py

@@ -1,2 +0,0 @@
-isinstance(1, 'int')
-# Raise=TypeError('isinstance() arg 2 must be a type, a tuple of types, or a union')

package/ref-monty/crates/monty/test_cases/iter__dict_mutation.py

@@ -1,4 +0,0 @@
-d = {'a': 1, 'b': 2}
-for k in d:
-    d['c'] = 3
-# Raise=RuntimeError('dictionary changed size during iteration')