superacli 1.1.4 → 1.1.6

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

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

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

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

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

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

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

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

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

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

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

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

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