jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

jaclang/vendor/mypyc/test/test_emitwrapper.py

@@ -1,60 +0,0 @@
-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")

jaclang/vendor/mypyc/test/test_exceptions.py

@@ -1,56 +0,0 @@
-"""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)

jaclang/vendor/mypyc/test/test_external.py

@@ -1,49 +0,0 @@
-"""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")

jaclang/vendor/mypyc/test/test_irbuild.py

@@ -1,87 +0,0 @@
-"""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)

jaclang/vendor/mypyc/test/test_ircheck.py

@@ -1,199 +0,0 @@
-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)]
-                    )
-                ],
-            )
-        )

jaclang/vendor/mypyc/test/test_literals.py

@@ -1,90 +0,0 @@
-"""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)
-        ]

jaclang/vendor/mypyc/test/test_lowering.py

@@ -1,56 +0,0 @@
-"""Runner for lowering transform tests."""
-
-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.common import TOP_LEVEL_NAME
-from mypyc.ir.pprint import format_func
-from mypyc.options import CompilerOptions
-from mypyc.test.testutil import (
-    ICODE_GEN_BUILTINS,
-    MypycDataSuite,
-    assert_test_output,
-    build_ir_for_single_file,
-    remove_comment_lines,
-    replace_word_size,
-    use_custom_builtins,
-)
-from mypyc.transform.exceptions import insert_exception_handling
-from mypyc.transform.flag_elimination import do_flag_elimination
-from mypyc.transform.lower import lower_ir
-from mypyc.transform.refcount import insert_ref_count_opcodes
-from mypyc.transform.uninit import insert_uninit_checks
-
-
-class TestLowering(MypycDataSuite):
-    files = ["lowering-int.test", "lowering-list.test"]
-    base_path = test_temp_dir
-
-    def run_case(self, testcase: DataDrivenTestCase) -> None:
-        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)
-            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
-                    options = CompilerOptions()
-                    # Lowering happens after exception handling and ref count opcodes have
-                    # been added. Any changes must maintain reference counting semantics.
-                    insert_uninit_checks(fn)
-                    insert_exception_handling(fn)
-                    insert_ref_count_opcodes(fn)
-                    lower_ir(fn, options)
-                    do_flag_elimination(fn, options)
-                    actual.extend(format_func(fn))
-
-            assert_test_output(testcase, actual, "Invalid source code output", expected_output)

jaclang/vendor/mypyc/test/test_namegen.py

@@ -1,48 +0,0 @@
-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_"