mypy-dev 1.9.0.dev0__py3-none-any.whl

mypyc/test/test_emitwrapper.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import unittest
+
+from mypy.test.helpers import assert_string_arrays_equal
+from mypyc.codegen.emit import Emitter, EmitterContext, ReturnHandler
+from mypyc.codegen.emitwrapper import generate_arg_check
+from mypyc.ir.rtypes import int_rprimitive, list_rprimitive
+from mypyc.namegen import NameGenerator
+
+
+class TestArgCheck(unittest.TestCase):
+    def setUp(self) -> None:
+        self.context = EmitterContext(NameGenerator([["mod"]]))
+
+    def test_check_list(self) -> None:
+        emitter = Emitter(self.context)
+        generate_arg_check("x", list_rprimitive, emitter, ReturnHandler("NULL"))
+        lines = emitter.fragments
+        self.assert_lines(
+            [
+                "PyObject *arg_x;",
+                "if (likely(PyList_Check(obj_x)))",
+                "    arg_x = obj_x;",
+                "else {",
+                '    CPy_TypeError("list", obj_x);',
+                "    return NULL;",
+                "}",
+            ],
+            lines,
+        )
+
+    def test_check_int(self) -> None:
+        emitter = Emitter(self.context)
+        generate_arg_check("x", int_rprimitive, emitter, ReturnHandler("NULL"))
+        generate_arg_check("y", int_rprimitive, emitter, ReturnHandler("NULL"), optional=True)
+        lines = emitter.fragments
+        self.assert_lines(
+            [
+                "CPyTagged arg_x;",
+                "if (likely(PyLong_Check(obj_x)))",
+                "    arg_x = CPyTagged_BorrowFromObject(obj_x);",
+                "else {",
+                '    CPy_TypeError("int", obj_x); return NULL;',
+                "}",
+                "CPyTagged arg_y;",
+                "if (obj_y == NULL) {",
+                "    arg_y = CPY_INT_TAG;",
+                "} else if (likely(PyLong_Check(obj_y)))",
+                "    arg_y = CPyTagged_BorrowFromObject(obj_y);",
+                "else {",
+                '    CPy_TypeError("int", obj_y); return NULL;',
+                "}",
+            ],
+            lines,
+        )
+
+    def assert_lines(self, expected: list[str], actual: list[str]) -> None:
+        actual = [line.rstrip("\n") for line in actual]
+        assert_string_arrays_equal(expected, actual, "Invalid output")

mypyc/test/test_exceptions.py

@@ -0,0 +1,56 @@
+"""Test runner for exception handling transform test cases.
+
+The transform inserts exception handling branch operations to IR.
+"""
+
+from __future__ import annotations
+
+import os.path
+
+from mypy.errors import CompileError
+from mypy.test.config import test_temp_dir
+from mypy.test.data import DataDrivenTestCase
+from mypyc.analysis.blockfreq import frequently_executed_blocks
+from mypyc.common import TOP_LEVEL_NAME
+from mypyc.ir.pprint import format_func
+from mypyc.test.testutil import (
+    ICODE_GEN_BUILTINS,
+    MypycDataSuite,
+    assert_test_output,
+    build_ir_for_single_file,
+    remove_comment_lines,
+    use_custom_builtins,
+)
+from mypyc.transform.exceptions import insert_exception_handling
+from mypyc.transform.refcount import insert_ref_count_opcodes
+from mypyc.transform.uninit import insert_uninit_checks
+
+files = ["exceptions.test", "exceptions-freq.test"]
+
+
+class TestExceptionTransform(MypycDataSuite):
+    files = files
+    base_path = test_temp_dir
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        """Perform a runtime checking transformation test case."""
+        with use_custom_builtins(os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase):
+            expected_output = remove_comment_lines(testcase.output)
+            try:
+                ir = build_ir_for_single_file(testcase.input)
+            except CompileError as e:
+                actual = e.messages
+            else:
+                actual = []
+                for fn in ir:
+                    if fn.name == TOP_LEVEL_NAME and not testcase.name.endswith("_toplevel"):
+                        continue
+                    insert_uninit_checks(fn)
+                    insert_exception_handling(fn)
+                    insert_ref_count_opcodes(fn)
+                    actual.extend(format_func(fn))
+                    if testcase.name.endswith("_freq"):
+                        common = frequently_executed_blocks(fn.blocks[0])
+                        actual.append("hot blocks: %s" % sorted(b.label for b in common))
+
+            assert_test_output(testcase, actual, "Invalid source code output", expected_output)

mypyc/test/test_external.py

@@ -0,0 +1,49 @@
+"""Test cases that run tests as subprocesses."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+
+base_dir = os.path.join(os.path.dirname(__file__), "..", "..")
+
+
+class TestExternal(unittest.TestCase):
+    # TODO: Get this to work on Windows.
+    # (Or don't. It is probably not a good use of time.)
+    @unittest.skipIf(sys.platform.startswith("win"), "rt tests don't work on windows")
+    def test_c_unit_test(self) -> None:
+        """Run C unit tests in a subprocess."""
+        cppflags: list[str] = []
+        env = os.environ.copy()
+        if sys.platform == "darwin":
+            cppflags += ["-mmacosx-version-min=10.10", "-stdlib=libc++"]
+        env["CPPFLAGS"] = " ".join(cppflags)
+        # Build Python wrapper for C unit tests.
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            status = subprocess.check_call(
+                [
+                    sys.executable,
+                    "setup.py",
+                    "build_ext",
+                    f"--build-lib={tmpdir}",
+                    f"--build-temp={tmpdir}",
+                ],
+                env=env,
+                cwd=os.path.join(base_dir, "mypyc", "lib-rt"),
+            )
+            # Run C unit tests.
+            env = os.environ.copy()
+            if "GTEST_COLOR" not in os.environ:
+                env["GTEST_COLOR"] = "yes"  # Use fancy colors
+            status = subprocess.call(
+                [sys.executable, "-c", "import sys, test_capi; sys.exit(test_capi.run_tests())"],
+                env=env,
+                cwd=tmpdir,
+            )
+            if status != 0:
+                raise AssertionError("make test: C unit test failure")

mypyc/test/test_irbuild.py

@@ -0,0 +1,87 @@
+"""Test cases for IR generation."""
+
+from __future__ import annotations
+
+import os.path
+import sys
+
+from mypy.errors import CompileError
+from mypy.test.config import test_temp_dir
+from mypy.test.data import DataDrivenTestCase
+from mypyc.common import TOP_LEVEL_NAME
+from mypyc.ir.pprint import format_func
+from mypyc.test.testutil import (
+    ICODE_GEN_BUILTINS,
+    MypycDataSuite,
+    assert_test_output,
+    build_ir_for_single_file,
+    infer_ir_build_options_from_test_name,
+    remove_comment_lines,
+    replace_word_size,
+    use_custom_builtins,
+)
+
+files = [
+    "irbuild-basic.test",
+    "irbuild-int.test",
+    "irbuild-bool.test",
+    "irbuild-lists.test",
+    "irbuild-tuple.test",
+    "irbuild-dict.test",
+    "irbuild-set.test",
+    "irbuild-str.test",
+    "irbuild-bytes.test",
+    "irbuild-float.test",
+    "irbuild-statements.test",
+    "irbuild-nested.test",
+    "irbuild-classes.test",
+    "irbuild-optional.test",
+    "irbuild-any.test",
+    "irbuild-generics.test",
+    "irbuild-try.test",
+    "irbuild-strip-asserts.test",
+    "irbuild-i64.test",
+    "irbuild-i32.test",
+    "irbuild-i16.test",
+    "irbuild-u8.test",
+    "irbuild-vectorcall.test",
+    "irbuild-unreachable.test",
+    "irbuild-isinstance.test",
+    "irbuild-dunders.test",
+    "irbuild-singledispatch.test",
+    "irbuild-constant-fold.test",
+    "irbuild-glue-methods.test",
+    "irbuild-math.test",
+]
+
+if sys.version_info >= (3, 10):
+    files.append("irbuild-match.test")
+
+
+class TestGenOps(MypycDataSuite):
+    files = files
+    base_path = test_temp_dir
+    optional_out = True
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        """Perform a runtime checking transformation test case."""
+        options = infer_ir_build_options_from_test_name(testcase.name)
+        if options is None:
+            # Skipped test case
+            return
+        with use_custom_builtins(os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase):
+            expected_output = remove_comment_lines(testcase.output)
+            expected_output = replace_word_size(expected_output)
+            name = testcase.name
+            try:
+                ir = build_ir_for_single_file(testcase.input, options)
+            except CompileError as e:
+                actual = e.messages
+            else:
+                actual = []
+                for fn in ir:
+                    if fn.name == TOP_LEVEL_NAME and not name.endswith("_toplevel"):
+                        continue
+                    actual.extend(format_func(fn))
+
+            assert_test_output(testcase, actual, "Invalid source code output", expected_output)

mypyc/test/test_ircheck.py

@@ -0,0 +1,199 @@
+from __future__ import annotations
+
+import unittest
+
+from mypyc.analysis.ircheck import FnError, can_coerce_to, check_func_ir
+from mypyc.ir.class_ir import ClassIR
+from mypyc.ir.func_ir import FuncDecl, FuncIR, FuncSignature
+from mypyc.ir.ops import (
+    Assign,
+    BasicBlock,
+    Goto,
+    Integer,
+    LoadAddress,
+    LoadLiteral,
+    Op,
+    Register,
+    Return,
+)
+from mypyc.ir.pprint import format_func
+from mypyc.ir.rtypes import (
+    RInstance,
+    RType,
+    RUnion,
+    bytes_rprimitive,
+    int32_rprimitive,
+    int64_rprimitive,
+    none_rprimitive,
+    object_rprimitive,
+    pointer_rprimitive,
+    str_rprimitive,
+)
+
+
+def assert_has_error(fn: FuncIR, error: FnError) -> None:
+    errors = check_func_ir(fn)
+    assert errors == [error]
+
+
+def assert_no_errors(fn: FuncIR) -> None:
+    assert not check_func_ir(fn)
+
+
+NONE_VALUE = Integer(0, rtype=none_rprimitive)
+
+
+class TestIrcheck(unittest.TestCase):
+    def setUp(self) -> None:
+        self.label = 0
+
+    def basic_block(self, ops: list[Op]) -> BasicBlock:
+        self.label += 1
+        block = BasicBlock(self.label)
+        block.ops = ops
+        return block
+
+    def func_decl(self, name: str, ret_type: RType | None = None) -> FuncDecl:
+        if ret_type is None:
+            ret_type = none_rprimitive
+        return FuncDecl(
+            name=name,
+            class_name=None,
+            module_name="module",
+            sig=FuncSignature(args=[], ret_type=ret_type),
+        )
+
+    def test_valid_fn(self) -> None:
+        assert_no_errors(
+            FuncIR(
+                decl=self.func_decl(name="func_1"),
+                arg_regs=[],
+                blocks=[self.basic_block(ops=[Return(value=NONE_VALUE)])],
+            )
+        )
+
+    def test_block_not_terminated_empty_block(self) -> None:
+        block = self.basic_block([])
+        fn = FuncIR(decl=self.func_decl(name="func_1"), arg_regs=[], blocks=[block])
+        assert_has_error(fn, FnError(source=block, desc="Block not terminated"))
+
+    def test_valid_goto(self) -> None:
+        block_1 = self.basic_block([Return(value=NONE_VALUE)])
+        block_2 = self.basic_block([Goto(label=block_1)])
+        fn = FuncIR(decl=self.func_decl(name="func_1"), arg_regs=[], blocks=[block_1, block_2])
+        assert_no_errors(fn)
+
+    def test_invalid_goto(self) -> None:
+        block_1 = self.basic_block([Return(value=NONE_VALUE)])
+        goto = Goto(label=block_1)
+        block_2 = self.basic_block([goto])
+        fn = FuncIR(
+            decl=self.func_decl(name="func_1"),
+            arg_regs=[],
+            # block_1 omitted
+            blocks=[block_2],
+        )
+        assert_has_error(fn, FnError(source=goto, desc="Invalid control operation target: 1"))
+
+    def test_invalid_register_source(self) -> None:
+        ret = Return(value=Register(type=none_rprimitive, name="r1"))
+        block = self.basic_block([ret])
+        fn = FuncIR(decl=self.func_decl(name="func_1"), arg_regs=[], blocks=[block])
+        assert_has_error(fn, FnError(source=ret, desc="Invalid op reference to register 'r1'"))
+
+    def test_invalid_op_source(self) -> None:
+        ret = Return(value=LoadLiteral(value="foo", rtype=str_rprimitive))
+        block = self.basic_block([ret])
+        fn = FuncIR(decl=self.func_decl(name="func_1"), arg_regs=[], blocks=[block])
+        assert_has_error(
+            fn, FnError(source=ret, desc="Invalid op reference to op of type LoadLiteral")
+        )
+
+    def test_invalid_return_type(self) -> None:
+        ret = Return(value=Integer(value=5, rtype=int32_rprimitive))
+        fn = FuncIR(
+            decl=self.func_decl(name="func_1", ret_type=int64_rprimitive),
+            arg_regs=[],
+            blocks=[self.basic_block([ret])],
+        )
+        assert_has_error(
+            fn, FnError(source=ret, desc="Cannot coerce source type i32 to dest type i64")
+        )
+
+    def test_invalid_assign(self) -> None:
+        arg_reg = Register(type=int64_rprimitive, name="r1")
+        assign = Assign(dest=arg_reg, src=Integer(value=5, rtype=int32_rprimitive))
+        ret = Return(value=NONE_VALUE)
+        fn = FuncIR(
+            decl=self.func_decl(name="func_1"),
+            arg_regs=[arg_reg],
+            blocks=[self.basic_block([assign, ret])],
+        )
+        assert_has_error(
+            fn, FnError(source=assign, desc="Cannot coerce source type i32 to dest type i64")
+        )
+
+    def test_can_coerce_to(self) -> None:
+        cls = ClassIR(name="Cls", module_name="cls")
+        valid_cases = [
+            (int64_rprimitive, int64_rprimitive),
+            (str_rprimitive, str_rprimitive),
+            (str_rprimitive, object_rprimitive),
+            (object_rprimitive, str_rprimitive),
+            (RUnion([bytes_rprimitive, str_rprimitive]), str_rprimitive),
+            (str_rprimitive, RUnion([bytes_rprimitive, str_rprimitive])),
+            (RInstance(cls), object_rprimitive),
+        ]
+
+        invalid_cases = [
+            (int64_rprimitive, int32_rprimitive),
+            (RInstance(cls), str_rprimitive),
+            (str_rprimitive, bytes_rprimitive),
+        ]
+
+        for src, dest in valid_cases:
+            assert can_coerce_to(src, dest)
+        for src, dest in invalid_cases:
+            assert not can_coerce_to(src, dest)
+
+    def test_duplicate_op(self) -> None:
+        arg_reg = Register(type=int32_rprimitive, name="r1")
+        assign = Assign(dest=arg_reg, src=Integer(value=5, rtype=int32_rprimitive))
+        block = self.basic_block([assign, assign, Return(value=NONE_VALUE)])
+        fn = FuncIR(decl=self.func_decl(name="func_1"), arg_regs=[], blocks=[block])
+        assert_has_error(fn, FnError(source=assign, desc="Func has a duplicate op"))
+
+    def test_pprint(self) -> None:
+        block_1 = self.basic_block([Return(value=NONE_VALUE)])
+        goto = Goto(label=block_1)
+        block_2 = self.basic_block([goto])
+        fn = FuncIR(
+            decl=self.func_decl(name="func_1"),
+            arg_regs=[],
+            # block_1 omitted
+            blocks=[block_2],
+        )
+        errors = [(goto, "Invalid control operation target: 1")]
+        formatted = format_func(fn, errors)
+        assert formatted == [
+            "def func_1():",
+            "L0:",
+            "    goto L1",
+            "  ERR: Invalid control operation target: 1",
+        ]
+
+    def test_load_address_declares_register(self) -> None:
+        rx = Register(str_rprimitive, "x")
+        ry = Register(pointer_rprimitive, "y")
+        load_addr = LoadAddress(pointer_rprimitive, rx)
+        assert_no_errors(
+            FuncIR(
+                decl=self.func_decl(name="func_1"),
+                arg_regs=[],
+                blocks=[
+                    self.basic_block(
+                        ops=[load_addr, Assign(ry, load_addr), Return(value=NONE_VALUE)]
+                    )
+                ],
+            )
+        )

mypyc/test/test_literals.py

@@ -0,0 +1,90 @@
+"""Test code geneneration for literals."""
+
+from __future__ import annotations
+
+import unittest
+
+from mypyc.codegen.literals import (
+    Literals,
+    _encode_bytes_values,
+    _encode_int_values,
+    _encode_str_values,
+    format_str_literal,
+)
+
+
+class TestLiterals(unittest.TestCase):
+    def test_format_str_literal(self) -> None:
+        assert format_str_literal("") == b"\x00"
+        assert format_str_literal("xyz") == b"\x03xyz"
+        assert format_str_literal("x" * 127) == b"\x7f" + b"x" * 127
+        assert format_str_literal("x" * 128) == b"\x81\x00" + b"x" * 128
+        assert format_str_literal("x" * 131) == b"\x81\x03" + b"x" * 131
+
+    def test_encode_str_values(self) -> None:
+        assert _encode_str_values({}) == [b""]
+        assert _encode_str_values({"foo": 0}) == [b"\x01\x03foo", b""]
+        assert _encode_str_values({"foo": 0, "b": 1}) == [b"\x02\x03foo\x01b", b""]
+        assert _encode_str_values({"foo": 0, "x" * 70: 1}) == [
+            b"\x01\x03foo",
+            bytes([1, 70]) + b"x" * 70,
+            b"",
+        ]
+        assert _encode_str_values({"y" * 100: 0}) == [bytes([1, 100]) + b"y" * 100, b""]
+
+    def test_encode_bytes_values(self) -> None:
+        assert _encode_bytes_values({}) == [b""]
+        assert _encode_bytes_values({b"foo": 0}) == [b"\x01\x03foo", b""]
+        assert _encode_bytes_values({b"foo": 0, b"b": 1}) == [b"\x02\x03foo\x01b", b""]
+        assert _encode_bytes_values({b"foo": 0, b"x" * 70: 1}) == [
+            b"\x01\x03foo",
+            bytes([1, 70]) + b"x" * 70,
+            b"",
+        ]
+        assert _encode_bytes_values({b"y" * 100: 0}) == [bytes([1, 100]) + b"y" * 100, b""]
+
+    def test_encode_int_values(self) -> None:
+        assert _encode_int_values({}) == [b""]
+        assert _encode_int_values({123: 0}) == [b"\x01123", b""]
+        assert _encode_int_values({123: 0, 9: 1}) == [b"\x02123\x009", b""]
+        assert _encode_int_values({123: 0, 45: 1, 5 * 10**70: 2}) == [
+            b"\x02123\x0045",
+            b"\x015" + b"0" * 70,
+            b"",
+        ]
+        assert _encode_int_values({6 * 10**100: 0}) == [b"\x016" + b"0" * 100, b""]
+
+    def test_simple_literal_index(self) -> None:
+        lit = Literals()
+        lit.record_literal(1)
+        lit.record_literal("y")
+        lit.record_literal(True)
+        lit.record_literal(None)
+        lit.record_literal(False)
+        assert lit.literal_index(None) == 0
+        assert lit.literal_index(False) == 1
+        assert lit.literal_index(True) == 2
+        assert lit.literal_index("y") == 3
+        assert lit.literal_index(1) == 4
+
+    def test_tuple_literal(self) -> None:
+        lit = Literals()
+        lit.record_literal((1, "y", None, (b"a", "b")))
+        lit.record_literal((b"a", "b"))
+        lit.record_literal(())
+        assert lit.literal_index((b"a", "b")) == 7
+        assert lit.literal_index((1, "y", None, (b"a", "b"))) == 8
+        assert lit.literal_index(()) == 9
+        print(lit.encoded_tuple_values())
+        assert lit.encoded_tuple_values() == [
+            "3",  # Number of tuples
+            "2",
+            "5",
+            "4",  # First tuple (length=2)
+            "4",
+            "6",
+            "3",
+            "0",
+            "7",  # Second tuple (length=4)
+            "0",  # Third tuple (length=0)
+        ]

mypyc/test/test_namegen.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import unittest
+
+from mypyc.namegen import (
+    NameGenerator,
+    candidate_suffixes,
+    exported_name,
+    make_module_translation_map,
+)
+
+
+class TestNameGen(unittest.TestCase):
+    def test_candidate_suffixes(self) -> None:
+        assert candidate_suffixes("foo") == ["", "foo."]
+        assert candidate_suffixes("foo.bar") == ["", "bar.", "foo.bar."]
+
+    def test_exported_name(self) -> None:
+        assert exported_name("foo") == "foo"
+        assert exported_name("foo.bar") == "foo___bar"
+
+    def test_make_module_translation_map(self) -> None:
+        assert make_module_translation_map(["foo", "bar"]) == {"foo": "foo.", "bar": "bar."}
+        assert make_module_translation_map(["foo.bar", "foo.baz"]) == {
+            "foo.bar": "bar.",
+            "foo.baz": "baz.",
+        }
+        assert make_module_translation_map(["zar", "foo.bar", "foo.baz"]) == {
+            "foo.bar": "bar.",
+            "foo.baz": "baz.",
+            "zar": "zar.",
+        }
+        assert make_module_translation_map(["foo.bar", "fu.bar", "foo.baz"]) == {
+            "foo.bar": "foo.bar.",
+            "fu.bar": "fu.bar.",
+            "foo.baz": "baz.",
+        }
+
+    def test_name_generator(self) -> None:
+        g = NameGenerator([["foo", "foo.zar"]])
+        assert g.private_name("foo", "f") == "foo___f"
+        assert g.private_name("foo", "C.x.y") == "foo___C___x___y"
+        assert g.private_name("foo", "C.x.y") == "foo___C___x___y"
+        assert g.private_name("foo.zar", "C.x.y") == "zar___C___x___y"
+        assert g.private_name("foo", "C.x_y") == "foo___C___x_y"
+        assert g.private_name("foo", "C_x_y") == "foo___C_x_y"
+        assert g.private_name("foo", "C_x_y") == "foo___C_x_y"
+        assert g.private_name("foo", "___") == "foo______3_"

mypyc/test/test_pprint.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import unittest
+
+from mypyc.ir.ops import Assign, BasicBlock, Integer, IntOp, Op, Register, Unreachable
+from mypyc.ir.pprint import generate_names_for_ir
+from mypyc.ir.rtypes import int_rprimitive
+
+
+def register(name: str) -> Register:
+    return Register(int_rprimitive, "foo", is_arg=True)
+
+
+def make_block(ops: list[Op]) -> BasicBlock:
+    block = BasicBlock()
+    block.ops.extend(ops)
+    return block
+
+
+class TestGenerateNames(unittest.TestCase):
+    def test_empty(self) -> None:
+        assert generate_names_for_ir([], []) == {}
+
+    def test_arg(self) -> None:
+        reg = register("foo")
+        assert generate_names_for_ir([reg], []) == {reg: "foo"}
+
+    def test_int_op(self) -> None:
+        n1 = Integer(2)
+        n2 = Integer(4)
+        op1 = IntOp(int_rprimitive, n1, n2, IntOp.ADD)
+        op2 = IntOp(int_rprimitive, op1, n2, IntOp.ADD)
+        block = make_block([op1, op2, Unreachable()])
+        assert generate_names_for_ir([], [block]) == {op1: "r0", op2: "r1"}
+
+    def test_assign(self) -> None:
+        reg = register("foo")
+        n = Integer(2)
+        op1 = Assign(reg, n)
+        op2 = Assign(reg, n)
+        block = make_block([op1, op2])
+        assert generate_names_for_ir([reg], [block]) == {reg: "foo"}

mypyc/test/test_rarray.py

@@ -0,0 +1,48 @@
+"""Unit tests for RArray types."""
+
+from __future__ import annotations
+
+import unittest
+
+from mypyc.common import PLATFORM_SIZE
+from mypyc.ir.rtypes import (
+    RArray,
+    bool_rprimitive,
+    compute_rtype_alignment,
+    compute_rtype_size,
+    int_rprimitive,
+)
+
+
+class TestRArray(unittest.TestCase):
+    def test_basics(self) -> None:
+        a = RArray(int_rprimitive, 10)
+        assert a.item_type == int_rprimitive
+        assert a.length == 10
+
+    def test_str_conversion(self) -> None:
+        a = RArray(int_rprimitive, 10)
+        assert str(a) == "int[10]"
+        assert repr(a) == "<RArray <RPrimitive builtins.int>[10]>"
+
+    def test_eq(self) -> None:
+        a = RArray(int_rprimitive, 10)
+        assert a == RArray(int_rprimitive, 10)
+        assert a != RArray(bool_rprimitive, 10)
+        assert a != RArray(int_rprimitive, 9)
+
+    def test_hash(self) -> None:
+        assert hash(RArray(int_rprimitive, 10)) == hash(RArray(int_rprimitive, 10))
+        assert hash(RArray(bool_rprimitive, 5)) == hash(RArray(bool_rprimitive, 5))
+
+    def test_alignment(self) -> None:
+        a = RArray(int_rprimitive, 10)
+        assert compute_rtype_alignment(a) == PLATFORM_SIZE
+        b = RArray(bool_rprimitive, 55)
+        assert compute_rtype_alignment(b) == 1
+
+    def test_size(self) -> None:
+        a = RArray(int_rprimitive, 9)
+        assert compute_rtype_size(a) == 9 * PLATFORM_SIZE
+        b = RArray(bool_rprimitive, 3)
+        assert compute_rtype_size(b) == 3