superacli 1.1.6 → 1.1.8

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

@@ -1,10 +0,0 @@
-x = [1, 2, 3]
-x.foo = 1
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "attr__set_list_error.py", line 2, in <module>
-    x.foo = 1
-    ~~~~~
-AttributeError: 'list' object has no attribute 'foo' and no __dict__ for setting new attributes
-"""

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

@@ -1,68 +0,0 @@
-# This test case is also used in the benchmark (benches/main.rs)
-# List operations
-my_list = []
-my_list.append(1)
-my_list.append(2)
-my_list.insert(0, 0)
-list_len = len(my_list)
-list_item = my_list[1]
-
-# Dict operations
-my_dict = {}
-my_dict['a'] = 10
-my_dict['b'] = 20
-dict_val = my_dict['a']
-popped = my_dict.pop('b')
-dict_len = len(my_dict)
-
-# Tuple operations
-my_tuple = (1, 2, 3)
-tuple_item = my_tuple[0]
-tuple_len = len(my_tuple)
-
-# String operations
-s = 'hello'
-s += ' world'
-str_len = len(s)
-
-
-# Function definition and call
-def add(x, y):
-    return x + y
-
-
-func_result = add(3, 4)
-
-# For loop with if/elif/else
-total = 0
-for i in range(10):
-    if i < 3:
-        total += 1
-    elif i < 6:
-        total += 2
-    else:
-        total += 3
-
-# Boolean operators and comparisons
-flag = True and not False
-check = 1 < 2 and 3 > 2
-identity = None is None
-not_identity = 1 is not None
-compare = 5 >= 5 and 5 <= 5 and 4 != 5
-
-# Assert with message
-assert total > 0, 'total should be positive'
-
-# List comprehension
-squares = [x * x for x in range(10)]
-comp_sum = sum(squares)
-
-# Dict comprehension
-square_dict = {x: x * x for x in range(5)}
-dict_comp_sum = sum(square_dict.values())
-
-# Final result
-result = list_len + list_item + dict_val + dict_len + tuple_item + tuple_len
-result += str_len + func_result + total + comp_sum + dict_comp_sum
-result
-# Return=373

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

@@ -1,20 +0,0 @@
-# === Boolean 'and' operator ===
-# returns first falsy value, or last value if all truthy
-assert (5 and 3) == 3, 'and truthy'
-assert (0 and 3) == 0, 'and falsy'
-assert (1 and 2 and 3) == 3, 'and chained'
-
-# === Boolean 'or' operator ===
-# returns first truthy value, or last value if all falsy
-assert (5 or 3) == 5, 'or truthy'
-assert (0 or 3) == 3, 'or falsy'
-assert (0 or 0 or 3) == 3, 'or chained'
-
-# === Boolean 'not' operator ===
-assert (not 5) == False, 'not truthy'
-assert (not 0) == True, 'not falsy'
-assert (not None) == True, 'not None'
-
-# === Complex boolean expressions ===
-assert ((1 and 2) or (3 and 0)) == 2, 'complex and/or'
-assert (not (0 and 1)) == True, 'not and combined'

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

@@ -1,2 +0,0 @@
-len + 1
-# Raise=TypeError("unsupported operand type(s) for +: 'builtin_function_or_method' and 'int'")

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

@@ -1,62 +0,0 @@
-assert list(filter(None, [0, 1, False, True, '', 'hello'])) == [1, True, 'hello'], 'filter None removes falsy values'
-assert list(filter(None, [])) == [], 'filter None on empty list'
-assert list(filter(None, [0, 0, 0])) == [], 'filter None removes all zeros'
-assert list(filter(None, [1, 2, 3])) == [1, 2, 3], 'filter None keeps truthy values'
-assert list(filter(None, ['', '', 'x'])) == ['x'], 'filter None keeps non-empty string'
-
-assert list(filter(abs, [-1, 0, 1])) == [-1, 1], 'filter with abs keeps non-zero'
-assert list(filter(abs, [0, 0, 0])) == [], 'filter with abs removes zeros'
-assert list(filter(abs, [-5, -3, 0, 2, 0, 4])) == [-5, -3, 2, 4], 'filter with abs mixed'
-
-assert list(filter(bool, [0, 1, '', 'x'])) == [1, 'x'], 'filter with bool'
-assert list(filter(bool, [False, True, 0, 1])) == [True, 1], 'filter with bool booleans and ints'
-assert list(filter(bool, [[], [1], (), (2,)])) == [[1], (2,)], 'filter with bool containers'
-
-# Note: len returns int, so empty containers return 0 (falsy), non-empty return truthy
-assert list(filter(len, ['', 'a', '', 'bc'])) == ['a', 'bc'], 'filter with len on strings'
-assert list(filter(len, [[], [1], [], [2, 3]])) == [[1], [2, 3]], 'filter with len on lists'
-assert list(filter(len, [(), (1,), (), (2, 3)])) == [(1,), (2, 3)], 'filter with len on tuples'
-
-assert list(filter(int, ['0', '1', '2', '0'])) == ['1', '2'], 'filter with int on string numbers'
-assert list(filter(int, [0.0, 1.5, 0.0, 2.3])) == [1.5, 2.3], 'filter with int on floats'
-
-assert list(filter(str, [0, 1, '', 'x'])) == [0, 1, 'x'], 'filter with str converts and checks truthiness'
-
-assert list(filter(None, [1, 2, 3])) == [1, 2, 3], 'filter list'
-
-assert list(filter(None, (0, 1, 2))) == [1, 2], 'filter tuple'
-
-assert list(filter(None, 'abc')) == ['a', 'b', 'c'], 'filter string'
-assert list(filter(None, 'a b')) == ['a', ' ', 'b'], 'filter string with space'
-
-assert list(filter(None, range(0, 5))) == [1, 2, 3, 4], 'filter range'
-assert list(filter(None, range(1, 4))) == [1, 2, 3], 'filter range all truthy'
-
-assert list(filter(None, {0, 1, 2})) == [1, 2] or list(filter(None, {0, 1, 2})) == [2, 1], 'filter set'
-
-assert list(filter(None, [])) == [], 'filter empty list'
-assert list(filter(None, ())) == [], 'filter empty tuple'
-assert list(filter(None, '')) == [], 'filter empty string'
-assert list(filter(None, range(0))) == [], 'filter empty range'
-
-assert list(filter(None, [[], [1], []])) == [[1]], 'filter nested lists'
-assert list(filter(None, [(), (1,), ()])) == [(1,)], 'filter nested tuples'
-
-
-# filter() with user-defined function
-# This should error until user-defined functions are supported
-def is_positive(x):
-    return x > 0
-
-
-assert list(filter(is_positive, [-1, 1])) == [1], 'filter with user-defined function keeps positives'
-
-
-assert list(filter(lambda x: x > 0, [-1, 1])) == [1], 'filter with lambda keeps positives'
-
-
-try:
-    list(filter(4, [1, 2]))
-    assert False, 'filter with non-callable first argument should raise TypeError'
-except TypeError as e:
-    assert str(e) == "'int' object is not callable", 'filter with non-callable first argument raises TypeError'

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

@@ -1,11 +0,0 @@
-# filter() with non-iterable second argument
-filter(None, 42)
-
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "builtin__filter_not_iterable.py", line 2, in <module>
-    filter(None, 42)
-    ~~~~~~~~~~~~~~~~
-TypeError: 'int' object is not iterable
-"""

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

@@ -1,84 +0,0 @@
-# Test getattr() builtin function
-
-s = slice(1, 10, 2)
-assert getattr(s, 'start') == 1, 'getattr(slice, "start") should return 1'
-assert getattr(s, 'stop') == 10, 'getattr(slice, "stop") should return 10'
-assert getattr(s, 'step') == 2, 'getattr(slice, "step") should return 2'
-
-assert getattr(s, 'nonexistent', 'default') == 'default', 'getattr with default should return default'
-assert getattr(s, 'nonexistent', None) == None, 'getattr with None default should return None'
-assert getattr(s, 'nonexistent', 42) == 42, 'getattr with numeric default should return number'
-
-assert getattr(s, 'start', 999) == 1, 'getattr should return actual value, not default'
-
-try:
-    getattr(s, 'nonexistent')
-    assert False, 'getattr should raise AttributeError for missing attribute'
-except AttributeError:
-    pass
-
-try:
-    getattr()
-    assert False, 'getattr() with no args should raise TypeError'
-except TypeError as e:
-    assert str(e) == 'getattr expected at least 2 arguments, got 0', str(e)
-
-try:
-    getattr(kwarg=1)
-    assert False, 'getattr() with keyword arg should raise TypeError'
-except TypeError as e:
-    assert str(e) == 'getattr() takes no keyword arguments', str(e)
-
-try:
-    getattr(s)
-    assert False, 'getattr() with 1 arg should raise TypeError'
-except TypeError as e:
-    assert str(e) == 'getattr expected at least 2 arguments, got 1', str(e)
-
-try:
-    getattr(s, 'start', 'default', 'extra')
-    assert False, 'getattr() with 4 args should raise TypeError'
-except TypeError as e:
-    assert str(e) == 'getattr expected at most 3 arguments, got 4', str(e)
-
-try:
-    getattr(s, 123)
-    assert False, 'getattr() with non-string name should raise TypeError'
-except TypeError as e:
-    assert str(e) == "attribute name must be string, not 'int'", str(e)
-
-try:
-    getattr(s, None)
-    assert False, 'getattr() with None name should raise TypeError'
-except TypeError as e:
-    assert str(e) == "attribute name must be string, not 'NoneType'", str(e)
-
-try:
-    raise ValueError('test error')
-except ValueError as e:
-    args = getattr(e, 'args')
-    assert args == ('test error',), 'exception args should be accessible via getattr'
-
-# === Dynamic (heap-allocated) attribute name strings ===
-# These test that getattr works with non-interned strings (e.g. from concatenation)
-s2 = slice(5, 15, 3)
-attr_name = 'sta' + 'rt'
-assert getattr(s2, attr_name) == 5, 'getattr with concatenated string should work'
-
-attr_name = 'st' + 'op'
-assert getattr(s2, attr_name) == 15, 'getattr with concatenated "stop" should work'
-
-attr_name = 'st' + 'ep'
-assert getattr(s2, attr_name) == 3, 'getattr with concatenated "step" should work'
-
-# Dynamic attribute name with default for missing attribute
-attr_name = 'non' + 'existent'
-assert getattr(s2, attr_name, 42) == 42, 'getattr with dynamic missing attr should return default'
-
-# Dynamic attribute name on exception
-try:
-    raise TypeError('dynamic test')
-except TypeError as e:
-    attr_name = 'ar' + 'gs'
-    args = getattr(e, attr_name)
-    assert args == ('dynamic test',), 'exception args via dynamic string should work'

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

@@ -1,42 +0,0 @@
-# === sum() ===
-# Basic sum operations
-assert sum([1, 2, 3]) == 6, 'sum of list'
-assert sum([1, 2, 3], 10) == 16, 'sum with start value'
-assert sum(()) == 0, 'sum of empty tuple'
-assert sum([], 5) == 5, 'sum of empty list with start'
-assert sum(range(5)) == 10, 'sum of range'
-assert sum([1.5, 2.5, 3.0], 0.0) == 7.0, 'sum of floats with float start'
-# Note: sum of floats without start requires py_add to support int+float
-
-# sum with different iterables
-assert sum({1, 2, 3}) == 6, 'sum of set'
-assert sum({1: 'a', 2: 'b', 3: 'c'}) == 6, 'sum of dict keys'
-
-# === any() ===
-# Basic any operations
-assert any([True, False, False]) == True, 'any with one True'
-assert any([False, False, False]) == False, 'any with all False'
-assert any([]) == False, 'any of empty list'
-assert any([0, 0, 1]) == True, 'any with truthy int'
-assert any([0, '', None]) == False, 'any with all falsy'
-assert any(['', 'hello']) == True, 'any with non-empty string'
-assert any(range(0, 5)) == True, 'any of range (has non-zero)'
-assert any(range(0, 1)) == False, 'any of range(0,1) is False (only 0)'
-
-# === all() ===
-# Basic all operations
-assert all([True, True, True]) == True, 'all with all True'
-assert all([True, False, True]) == False, 'all with one False'
-assert all([]) == True, 'all of empty list'
-assert all([1, 2, 3]) == True, 'all with truthy ints'
-assert all([1, 0, 3]) == False, 'all with zero'
-assert all(['a', 'b', 'c']) == True, 'all with non-empty strings'
-assert all(['a', '', 'c']) == False, 'all with empty string'
-
-# More edge cases with nested structures
-assert any([[1], [], [3]]) == True, 'any with nested lists (some non-empty)'
-assert all([[1], [2], [3]]) == True, 'all with non-empty nested lists'
-
-# sum with lists (list + list is supported)
-assert sum([[1], [2], [3]], []) == [1, 2, 3], 'sum lists with empty start'
-# Note: sum with tuples requires Tuple py_add which is not implemented

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

@@ -1,66 +0,0 @@
-# === iter() on various iterables ===
-# iter() creates an iterator from an iterable
-
-# iter() on list
-it = iter([1, 2, 3])
-assert next(it) == 1, 'iter list: first element should be 1'
-assert next(it) == 2, 'iter list: second element should be 2'
-assert next(it) == 3, 'iter list: third element should be 3'
-
-# iter() on tuple
-it = iter((10, 20))
-assert next(it) == 10, 'iter tuple: first element should be 10'
-assert next(it) == 20, 'iter tuple: second element should be 20'
-
-# iter() on string
-it = iter('ab')
-assert next(it) == 'a', 'iter string: first element should be a'
-assert next(it) == 'b', 'iter string: second element should be b'
-
-# iter() on range
-it = iter(range(3))
-assert next(it) == 0, 'iter range: first element should be 0'
-assert next(it) == 1, 'iter range: second element should be 1'
-assert next(it) == 2, 'iter range: third element should be 2'
-
-# iter() on dict iterates over keys
-d = {'x': 1, 'y': 2}
-it = iter(d)
-keys = [next(it), next(it)]
-assert 'x' in keys, 'iter dict: x should be in keys'
-assert 'y' in keys, 'iter dict: y should be in keys'
-
-# === next() with default value ===
-# next() returns default when iterator is exhausted
-
-it = iter([42])
-assert next(it) == 42, 'next: first element should be 42'
-assert next(it, 'done') == 'done', 'next with default: should return default when exhausted'
-
-# Check default with various types
-it = iter([])
-assert next(it, None) is None, 'next with None default: should return None'
-assert next(it, 0) == 0, 'next with 0 default: should return 0'
-assert next(it, []) == [], 'next with empty list default: should return empty list'
-
-# === iter() on iterator returns itself ===
-# Calling iter() on an iterator should return the same iterator
-
-original = iter([1, 2, 3])
-same = iter(original)
-# They should iterate over the same values
-assert next(original) == 1, 'iter on iterator: original first should be 1'
-assert next(same) == 2, 'iter on iterator: same should continue from 2'
-assert next(original) == 3, 'iter on iterator: original should continue to 3'
-
-# === Multiple independent iterators ===
-# Creating multiple iterators over the same iterable should be independent
-
-data = [1, 2, 3]
-it1 = iter(data)
-it2 = iter(data)
-assert next(it1) == 1, 'independent iterators: it1 first should be 1'
-assert next(it1) == 2, 'independent iterators: it1 second should be 2'
-assert next(it2) == 1, 'independent iterators: it2 first should be 1 (independent)'
-assert next(it1) == 3, 'independent iterators: it1 third should be 3'
-assert next(it2) == 2, 'independent iterators: it2 second should be 2'

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

@@ -1,74 +0,0 @@
-assert list(map(abs, [-1, 0, 1, -2])) == [1, 0, 1, 2], 'map with abs'
-assert list(map(abs, [0, 0, 0])) == [0, 0, 0], 'map with abs all zeros'
-
-assert list(map(str, [1, 2, 3])) == ['1', '2', '3'], 'map with str on ints'
-assert list(map(str, [True, False])) == ['True', 'False'], 'map with str on bools'
-
-assert list(map(int, ['1', '2', '3'])) == [1, 2, 3], 'map with int on strings'
-assert list(map(int, [1.1, 2.9, 3.5])) == [1, 2, 3], 'map with int on floats'
-assert list(map(int, [True, False, True])) == [1, 0, 1], 'map with int on bools'
-
-assert list(map(bool, [0, 1, '', 'x'])) == [False, True, False, True], 'map with bool'
-assert list(map(bool, [[], [1], (), (2,)])) == [False, True, False, True], 'map with bool on containers'
-
-assert list(map(len, ['', 'a', 'ab', 'abc'])) == [0, 1, 2, 3], 'map with len on strings'
-assert list(map(len, [[], [1], [1, 2], [1, 2, 3]])) == [0, 1, 2, 3], 'map with len on lists'
-
-assert list(map(float, [1, 2, 3])) == [1.0, 2.0, 3.0], 'map with float on ints'
-assert list(map(float, ['1.5', '2.5'])) == [1.5, 2.5], 'map with float on strings'
-
-assert list(map(abs, [1, -2, 3])) == [1, 2, 3], 'map on list'
-
-assert list(map(abs, (1, -2, 3))) == [1, 2, 3], 'map on tuple'
-
-assert list(map(ord, 'abc')) == [97, 98, 99], 'map ord on string'
-
-assert list(map(abs, range(-3, 3))) == [3, 2, 1, 0, 1, 2], 'map on range'
-
-result = list(map(abs, {-1, 0, 1}))
-assert sorted(result) == [0, 1, 1], 'map on set'
-
-assert list(map(abs, [])) == [], 'map on empty list'
-assert list(map(abs, ())) == [], 'map on empty tuple'
-assert list(map(abs, '')) == [], 'map on empty string'
-assert list(map(abs, range(0))) == [], 'map on empty range'
-
-assert list(map(list, [(1, 2), (3, 4)])) == [[1, 2], [3, 4]], 'map with list constructor'
-assert list(map(tuple, [[1, 2], [3, 4]])) == [(1, 2), (3, 4)], 'map with tuple constructor'
-
-assert list(map(pow, [2, 3, 4], [3, 2, 2])) == [8, 9, 16], 'map with pow and 2 iterables'
-
-assert list(map(divmod, [10, 20, 30], [3, 6, 7])) == [(3, 1), (3, 2), (4, 2)], 'map with divmod and 2 iterables'
-
-assert list(map(pow, [2, 3, 4, 5], [3, 2])) == [8, 9], 'map stops at shortest iterable'
-assert list(map(pow, [2, 3], [3, 2, 1, 0])) == [8, 9], 'map stops at shortest iterable (first shorter)'
-
-assert list(map(pow, [2], [3, 4, 5])) == [8], 'map with single item in shortest'
-
-
-def f(x):
-    return x * 2
-
-
-assert list(map(f, [1, 2, 3])) == [2, 4, 6], 'map with custom function'
-
-
-def raise_exception(x):
-    raise ValueError('Intentional error')
-
-
-try:
-    list(map(raise_exception, [1, 2, 3]))
-    assert False, 'should have failed with exception'
-except ValueError as e:
-    assert str(e) == 'Intentional error', 'map with function that raises exception'
-
-try:
-    map()
-except TypeError as e:
-    assert str(e) == 'map() must have at least two arguments.', 'map with no arguments'
-
-try:
-    map(None)
-except TypeError as e:
-    assert str(e) == 'map() must have at least two arguments.', 'map with only function argument'

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

@@ -1,11 +0,0 @@
-# map() with non-iterable second argument
-map(abs, 42)
-
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "builtin__map_not_iterable.py", line 2, in <module>
-    map(abs, 42)
-    ~~~~~~~~~~~~
-TypeError: 'int' object is not iterable
-"""

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

@@ -1,154 +0,0 @@
-# === abs() ===
-# Basic abs operations
-assert abs(5) == 5, 'abs of positive int'
-assert abs(-5) == 5, 'abs of negative int'
-assert abs(0) == 0, 'abs of zero'
-assert abs(3.14) == 3.14, 'abs of positive float'
-assert abs(-3.14) == 3.14, 'abs of negative float'
-assert abs(True) == 1, 'abs of True'
-assert abs(False) == 0, 'abs of False'
-
-# === round() ===
-# Basic round operations
-assert round(2.5) == 2, 'round 2.5 (bankers rounding)'
-assert round(3.5) == 4, 'round 3.5 (bankers rounding)'
-assert round(0.5) == 0, 'round 0.5 (bankers rounding)'
-assert round(-0.5) == 0, 'round -0.5 (bankers rounding)'
-assert round(2.4) == 2, 'round 2.4'
-assert round(2.6) == 3, 'round 2.6'
-assert round(-2.5) == -2, 'round -2.5'
-assert round(-1.5) == -2, 'round -1.5 (bankers rounding)'
-assert round(5) == 5, 'round integer'
-
-# round with ndigits
-assert round(3.14159, 2) == 3.14, 'round to 2 digits'
-assert round(3.14159, 0) == 3.0, 'round to 0 digits returns float'
-assert repr(round(-0.4, 0)) == '-0.0', 'round(-0.4, 0) preserves negative zero sign'
-assert repr(round(-0.5, 0)) == '-0.0', 'round(-0.5, 0) preserves negative zero sign'
-assert round(1234, -2) == 1200, 'round int to nearest 100'
-assert round(1250, -2) == 1200, 'round 1250 to nearest 100 (bankers)'
-assert round(1350, -2) == 1400, 'round 1350 to nearest 100'
-assert round(15, -1) == 20, 'round 15 to nearest 10 (bankers)'
-assert round(25, -1) == 20, 'round 25 to nearest 10 (bankers)'
-
-# round with None
-assert round(2.5, None) == 2, 'round with None ndigits'
-assert round(True, -1) == 0, 'round True with negative digits behaves like int'
-assert round(True, 2) == 1, 'round True with positive digits returns int'
-assert round(False, -3) == 0, 'round False with negative digits stays zero'
-
-# round type errors
-threw = False
-try:
-    round(1.2, 1.5)
-except TypeError:
-    threw = True
-assert threw, 'round with non-int ndigits raises TypeError'
-
-# round edge cases with extreme values
-assert isinstance(round(1e15), int), 'round large float returns int'
-assert isinstance(round(-1e15), int), 'round large negative float returns int'
-assert round(0.0) == 0, 'round(0.0) is zero'
-assert round(-0.0) == 0, 'round(-0.0) is zero'
-
-# round special float values (infinity / NaN)
-inf = float('inf')
-neg_inf = float('-inf')
-nan = float('nan')
-
-threw = False
-try:
-    round(inf)
-except OverflowError:
-    threw = True
-assert threw, 'round(inf) raises OverflowError'
-
-threw = False
-try:
-    round(neg_inf)
-except OverflowError:
-    threw = True
-assert threw, 'round(-inf) raises OverflowError'
-
-threw = False
-try:
-    round(nan)
-except ValueError:
-    threw = True
-assert threw, 'round(nan) raises ValueError'
-
-r = round(inf, 0)
-assert r == inf, 'round(inf, 0) returns inf'
-
-r = round(neg_inf, 0)
-assert r == neg_inf, 'round(-inf, 0) returns -inf'
-
-r = round(nan, 0)
-assert r != r, 'round(nan, 0) returns NaN'
-
-# round with extreme ndigits values
-assert round(1.23, 10**6) == 1.23, 'round with huge positive ndigits returns original float'
-assert round(1.23, -(10**6)) == 0.0, 'round with huge negative ndigits returns zero'
-assert repr(round(-1.23, -(10**6))) == '-0.0', 'round with huge negative ndigits preserves signed zero'
-
-# round with float result (ndigits specified)
-assert isinstance(round(1.5, 1), float), 'round with ndigits returns float'
-assert round(1.25, 1) == 1.2, 'round 1.25 to 1 decimal (bankers rounding)'
-assert round(1.35, 1) == 1.4, 'round 1.35 to 1 decimal'
-
-# === divmod() ===
-# Basic divmod operations
-assert divmod(17, 5) == (3, 2), 'divmod 17, 5'
-assert divmod(10, 3) == (3, 1), 'divmod 10, 3'
-assert divmod(9, 3) == (3, 0), 'divmod 9, 3'
-assert divmod(-10, 3) == (-4, 2), 'divmod -10, 3 (floor division)'
-assert divmod(10, -3) == (-4, -2), 'divmod 10, -3'
-assert divmod(-10, -3) == (3, -1), 'divmod -10, -3'
-
-# divmod with floats
-r = divmod(7.5, 2.5)
-assert r[0] == 3.0 and r[1] == 0.0, 'divmod floats'
-assert divmod(True, 2) == (0, 1), 'divmod accepts bool numerator'
-assert divmod(5, True) == (5, 0), 'divmod accepts bool denominator'
-
-# === pow() ===
-# Basic pow operations
-assert pow(2, 3) == 8, 'pow 2^3'
-assert pow(2, 0) == 1, 'pow x^0'
-assert pow(5, 1) == 5, 'pow x^1'
-assert pow(2, 10) == 1024, 'pow 2^10'
-
-# pow with negative exponent
-assert pow(2, -1) == 0.5, 'pow with negative exp'
-assert pow(4, -2) == 0.0625, 'pow 4^-2'
-
-# pow with floats
-assert pow(2.0, 3.0) == 8.0, 'pow with floats'
-assert pow(4.0, 0.5) == 2.0, 'pow float sqrt'
-
-# Three-argument pow (modular exponentiation)
-assert pow(2, 10, 1000) == 24, 'pow modular 2^10 % 1000'
-assert pow(3, 4, 5) == 1, 'pow modular 3^4 % 5'
-assert pow(7, 256, 13) == 9, 'pow modular large exp'
-
-# Modular exponentiation edge cases
-assert pow(2, 0, 5) == 1, 'pow x^0 mod n'
-assert pow(0, 5, 3) == 0, 'pow 0^n mod m'
-assert pow(True, 2) == 1, 'pow handles bool base'
-assert pow(2, True) == 2, 'pow handles bool exponent'
-assert pow(True, True) == 1, 'pow handles bool base and exponent'
-assert pow(True, -1) == 1.0, 'pow bool negative exponent works like int'
-
-threw = False
-try:
-    pow(0, -1)
-except ZeroDivisionError:
-    threw = True
-assert threw, 'pow(0, negative) raises ZeroDivisionError'
-
-threw = False
-try:
-    pow(0.0, -1)
-except ZeroDivisionError:
-    threw = True
-assert threw, 'pow(0.0, negative) raises ZeroDivisionError'