superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,260 @@
+# 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

@@ -0,0 +1,219 @@
+# === 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

@@ -0,0 +1,84 @@
+# === 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

@@ -0,0 +1,36 @@
+# 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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,2 @@
+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

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