Import test_bytes, test_builtin, test_types

New tests:
- test_bytes.py: 8 tests — literals, indexing, slicing, comparison, decode, methods
- test_builtin.py: 23 tests — abs, bool, chr/ord, divmod, hash, hex/oct/bin,
  id, int, isinstance, len, max/min, pow, range, repr, round, sorted, str,
  sum, type, zip, enumerate, map/filter, callable
- test_types.py: 21 tests, 1 skip — truth values, type checks, conversions
  (int, float, str, bool, list, tuple, set)

Total CPython test suites: 37

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jgarzik

Makefile

@@ -124,6 +124,12 @@ gen-cpython-tests:
 	@$(PYTHON) -m py_compile tests/cpython/test_property.py
 	@echo "Compiling tests/cpython/test_string.py..."
 	@$(PYTHON) -m py_compile tests/cpython/test_string.py
+	@echo "Compiling tests/cpython/test_bytes.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_bytes.py
+	@echo "Compiling tests/cpython/test_builtin.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_builtin.py
+	@echo "Compiling tests/cpython/test_types.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_types.py
 	@echo "Done."
 
 check-cpython: $(TARGET) gen-cpython-tests
@@ -195,3 +201,9 @@ check-cpython: $(TARGET) gen-cpython-tests
 	@./apython tests/cpython/__pycache__/test_property.cpython-312.pyc
 	@echo "Running CPython test_string.py..."
 	@./apython tests/cpython/__pycache__/test_string.cpython-312.pyc
+	@echo "Running CPython test_bytes.py..."
+	@./apython tests/cpython/__pycache__/test_bytes.cpython-312.pyc
+	@echo "Running CPython test_builtin.py..."
+	@./apython tests/cpython/__pycache__/test_builtin.cpython-312.pyc
+	@echo "Running CPython test_types.py..."
+	@./apython tests/cpython/__pycache__/test_types.cpython-312.pyc

tests/cpython/test_builtin.py

@@ -0,0 +1,147 @@
+"""Tests for builtin functions — adapted from CPython test_builtin.py"""
+
+import unittest
+
+
+class BuiltinTest(unittest.TestCase):
+
+    def test_abs(self):
+        self.assertEqual(abs(0), 0)
+        self.assertEqual(abs(-1), 1)
+        self.assertEqual(abs(1), 1)
+        self.assertAlmostEqual(abs(-1.5), 1.5)
+
+    def test_bool(self):
+        self.assertIs(bool(0), False)
+        self.assertIs(bool(1), True)
+        self.assertIs(bool(""), False)
+        self.assertIs(bool("x"), True)
+        self.assertIs(bool([]), False)
+        self.assertIs(bool([1]), True)
+        self.assertIs(bool(None), False)
+
+    def test_chr_ord(self):
+        self.assertEqual(chr(65), 'A')
+        self.assertEqual(chr(97), 'a')
+        self.assertEqual(ord('A'), 65)
+        self.assertEqual(ord('a'), 97)
+
+    def test_divmod(self):
+        self.assertEqual(divmod(7, 3), (2, 1))
+        self.assertEqual(divmod(-7, 3), (-3, 2))
+        self.assertEqual(divmod(7, -3), (-3, -2))
+
+    def test_hash(self):
+        self.assertEqual(hash(42), hash(42))
+        self.assertEqual(hash("hello"), hash("hello"))
+        self.assertIsInstance(hash(42), int)
+
+    def test_hex_oct_bin(self):
+        self.assertEqual(hex(255), '0xff')
+        self.assertEqual(hex(-1), '-0x1')
+        self.assertEqual(oct(8), '0o10')
+        self.assertEqual(bin(10), '0b1010')
+
+    def test_id(self):
+        a = [1, 2]
+        b = a
+        c = [1, 2]
+        self.assertEqual(id(a), id(b))
+        self.assertNotEqual(id(a), id(c))
+
+    def test_int(self):
+        self.assertEqual(int(), 0)
+        self.assertEqual(int(3.5), 3)
+        self.assertEqual(int("42"), 42)
+        self.assertEqual(int("-10"), -10)
+        self.assertEqual(int("ff", 16), 255)
+        self.assertEqual(int("10", 2), 2)
+
+    def test_isinstance_issubclass(self):
+        self.assertTrue(isinstance(1, int))
+        self.assertTrue(isinstance("x", str))
+        self.assertTrue(isinstance([], list))
+        self.assertTrue(issubclass(bool, int))
+        self.assertFalse(issubclass(str, int))
+
+    def test_len(self):
+        self.assertEqual(len([]), 0)
+        self.assertEqual(len([1, 2, 3]), 3)
+        self.assertEqual(len("hello"), 5)
+        self.assertEqual(len({}), 0)
+        self.assertEqual(len({1: 2}), 1)
+
+    def test_max_min(self):
+        self.assertEqual(max(1, 2, 3), 3)
+        self.assertEqual(min(1, 2, 3), 1)
+        self.assertEqual(max([1, 2, 3]), 3)
+        self.assertEqual(min([1, 2, 3]), 1)
+
+    def test_pow(self):
+        self.assertEqual(pow(2, 10), 1024)
+        self.assertEqual(pow(3, 3, 8), 3)
+
+    def test_range(self):
+        self.assertEqual(list(range(5)), [0, 1, 2, 3, 4])
+        self.assertEqual(list(range(1, 5)), [1, 2, 3, 4])
+        self.assertEqual(list(range(0, 10, 2)), [0, 2, 4, 6, 8])
+        self.assertEqual(list(range(5, 0, -1)), [5, 4, 3, 2, 1])
+
+    def test_repr(self):
+        self.assertEqual(repr(42), '42')
+        self.assertEqual(repr("hello"), "'hello'")
+        self.assertEqual(repr([1, 2]), '[1, 2]')
+        self.assertEqual(repr(None), 'None')
+
+    def test_round(self):
+        self.assertEqual(round(3.5), 4)
+        self.assertEqual(round(4.5), 4)  # banker's rounding
+        self.assertEqual(round(3.14159, 2), 3.14)
+
+    def test_sorted(self):
+        self.assertEqual(sorted([3, 1, 2]), [1, 2, 3])
+        self.assertEqual(sorted("cba"), ['a', 'b', 'c'])
+        self.assertEqual(sorted([3, 1, 2], reverse=True), [3, 2, 1])
+
+    def test_str(self):
+        self.assertEqual(str(42), '42')
+        self.assertEqual(str(3.14), '3.14')
+        self.assertEqual(str(True), 'True')
+        self.assertEqual(str(None), 'None')
+        self.assertEqual(str([1, 2]), '[1, 2]')
+
+    def test_sum(self):
+        self.assertEqual(sum([1, 2, 3]), 6)
+        self.assertEqual(sum([], 10), 10)
+        self.assertEqual(sum(range(10)), 45)
+
+    def test_type(self):
+        self.assertIs(type(42), int)
+        self.assertIs(type("x"), str)
+        self.assertIs(type([]), list)
+        self.assertIs(type({}), dict)
+        self.assertIs(type(()), tuple)
+        self.assertIs(type(True), bool)
+        self.assertIs(type(None), type(None))
+
+    def test_zip(self):
+        self.assertEqual(list(zip([1, 2], [3, 4])), [(1, 3), (2, 4)])
+        self.assertEqual(list(zip()), [])
+        self.assertEqual(list(zip([1])), [(1,)])
+
+    def test_enumerate(self):
+        self.assertEqual(list(enumerate('ab')), [(0, 'a'), (1, 'b')])
+        self.assertEqual(list(enumerate('ab', 5)), [(5, 'a'), (6, 'b')])
+
+    def test_map_filter(self):
+        self.assertEqual(list(map(str, [1, 2, 3])), ['1', '2', '3'])
+        self.assertEqual(list(filter(lambda x: x > 2, [1, 2, 3, 4])), [3, 4])
+
+    def test_callable(self):
+        self.assertTrue(callable(len))
+        self.assertTrue(callable(lambda: None))
+        self.assertFalse(callable(42))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/cpython/test_bytes.py

@@ -0,0 +1,47 @@
+"""Tests for bytes — adapted from CPython test_bytes.py"""
+
+import unittest
+
+
+class BytesTest(unittest.TestCase):
+
+    def test_literal(self):
+        self.assertEqual(b"hello", b"hello")
+        self.assertEqual(b"", b"")
+
+    def test_len(self):
+        self.assertEqual(len(b""), 0)
+        self.assertEqual(len(b"hello"), 5)
+
+    def test_indexing(self):
+        b = b"hello"
+        self.assertEqual(b[0], 104)  # ord('h')
+        self.assertEqual(b[-1], 111)  # ord('o')
+
+    def test_slicing(self):
+        b = b"hello"
+        self.assertEqual(b[1:3], b"el")
+        self.assertEqual(b[:3], b"hel")
+        self.assertEqual(b[3:], b"lo")
+
+    def test_comparison(self):
+        self.assertTrue(b"abc" == b"abc")
+        self.assertTrue(b"abc" != b"abd")
+
+    def test_decode(self):
+        self.assertEqual(b"hello".decode(), "hello")
+
+    def test_iteration(self):
+        result = []
+        for x in b"abc":
+            result.append(x)
+        self.assertEqual(result, [97, 98, 99])
+
+    def test_methods(self):
+        self.assertTrue(b"hello".startswith(b"hel"))
+        self.assertTrue(b"hello".endswith(b"llo"))
+        self.assertEqual(b"hello".find(b"ll"), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/cpython/test_types.py

@@ -0,0 +1,132 @@
+"""Tests for type system basics — adapted from CPython test_types.py"""
+
+import unittest
+
+
+class TypeTest(unittest.TestCase):
+
+    def test_truth_values(self):
+        # Falsy values
+        self.assertFalse(bool(None))
+        self.assertFalse(bool(0))
+        self.assertFalse(bool(0.0))
+        self.assertFalse(bool(''))
+        self.assertFalse(bool([]))
+        self.assertFalse(bool(()))
+        self.assertFalse(bool({}))
+        self.assertFalse(bool(set()))
+        self.assertFalse(bool(False))
+        self.assertFalse(bool(b''))
+
+        # Truthy values
+        self.assertTrue(bool(1))
+        self.assertTrue(bool(-1))
+        self.assertTrue(bool(0.1))
+        self.assertTrue(bool('x'))
+        self.assertTrue(bool([0]))
+        self.assertTrue(bool((0,)))
+        self.assertTrue(bool({0: 0}))
+        self.assertTrue(bool({0}))
+        self.assertTrue(bool(True))
+        self.assertTrue(bool(b'x'))
+
+    def test_none_type(self):
+        self.assertIs(type(None), type(None))
+        self.assertEqual(repr(None), 'None')
+        self.assertEqual(str(None), 'None')
+
+    def test_int_type(self):
+        self.assertIs(type(1), int)
+        self.assertIs(type(True), bool)
+        self.assertTrue(issubclass(bool, int))
+
+    def test_float_type(self):
+        self.assertIs(type(1.0), float)
+
+    def test_str_type(self):
+        self.assertIs(type(""), str)
+
+    def test_list_type(self):
+        self.assertIs(type([]), list)
+
+    def test_dict_type(self):
+        self.assertIs(type({}), dict)
+
+    def test_tuple_type(self):
+        self.assertIs(type(()), tuple)
+
+    def test_set_type(self):
+        self.assertIs(type(set()), set)
+
+    def test_bytes_type(self):
+        self.assertIs(type(b""), bytes)
+
+    def test_function_type(self):
+        def f(): pass
+        self.assertEqual(type(f).__name__, 'function')
+
+    def test_method_type(self):
+        class C:
+            def f(self): pass
+        obj = C()
+        self.assertTrue(callable(obj.f))
+
+    def test_type_of_type(self):
+        self.assertIs(type(int), type)
+        self.assertIs(type(str), type)
+        self.assertIs(type(list), type)
+
+
+class ConversionTest(unittest.TestCase):
+
+    def test_int_conversions(self):
+        self.assertEqual(int(3.9), 3)
+        self.assertEqual(int(-3.9), -3)
+        self.assertEqual(int("100"), 100)
+        self.assertEqual(int("0xff", 16), 255)
+        self.assertEqual(int(True), 1)
+        self.assertEqual(int(False), 0)
+
+    def test_float_conversions(self):
+        self.assertEqual(float(3), 3.0)
+        self.assertEqual(float("3.14"), 3.14)
+        self.assertEqual(float(True), 1.0)
+        self.assertEqual(float(False), 0.0)
+
+    def test_str_conversions(self):
+        self.assertEqual(str(42), "42")
+        self.assertEqual(str(3.14), "3.14")
+        self.assertEqual(str(True), "True")
+        self.assertEqual(str(False), "False")
+        self.assertEqual(str(None), "None")
+        self.assertEqual(str([1, 2]), "[1, 2]")
+        self.assertEqual(str((1, 2)), "(1, 2)")
+
+    def test_bool_conversions(self):
+        self.assertIs(bool(0), False)
+        self.assertIs(bool(1), True)
+        self.assertIs(bool(""), False)
+        self.assertIs(bool("x"), True)
+
+    def test_list_conversions(self):
+        self.assertEqual(list("abc"), ['a', 'b', 'c'])
+        self.assertEqual(list((1, 2, 3)), [1, 2, 3])
+        self.assertEqual(list(range(3)), [0, 1, 2])
+        self.assertEqual(list({1, 2, 3}), sorted([1, 2, 3]))
+
+    def test_tuple_conversions(self):
+        self.assertEqual(tuple([1, 2, 3]), (1, 2, 3))
+        self.assertEqual(tuple("abc"), ('a', 'b', 'c'))
+        self.assertEqual(tuple(range(3)), (0, 1, 2))
+
+    def test_set_conversions(self):
+        self.assertEqual(set([1, 2, 2, 3]), {1, 2, 3})
+        self.assertEqual(frozenset([1, 2, 3]), frozenset({1, 2, 3}))
+
+    @unittest.skip("dict() from kwargs not implemented")
+    def test_dict_conversions(self):
+        pass
+
+
+if __name__ == "__main__":
+    unittest.main()