def test_function_string_with_return():
    f = Function("test.hpp", "", "my_fun", "double")
    assert_multi_line_equal(
        str(f), lines(
            "Function 'my_fun'",
            "    Returns (double)"
        )
    )
def test_convert_to_docstring():
    assert_equal(convert_to_docstring(None), "")

    assert_multi_line_equal(
        convert_to_docstring(lines(
            "/**",
            " * This is a brief comment.",
            " */")),
        "This is a brief comment."
    )

    assert_multi_line_equal(
        convert_to_docstring("/// This is a brief comment."),
        "This is a brief comment."
    )

    assert_multi_line_equal(
        convert_to_docstring(lines(
            "/**",
            " * This is a brief comment.",
            " *",
            " * This is a detailed comment.",
            " */")
        ),
        lines(
            "This is a brief comment.",
            "",
            "This is a detailed comment.")
    )

    assert_multi_line_equal(
        convert_to_docstring(lines(
            "/**",
            " * This is a brief comment.",
            " * This is a detailed comment.",
            " */")
        ),
        lines(
            "This is a brief comment.",
            "",
            "This is a detailed comment.")
    )

    assert_multi_line_equal(
        convert_to_docstring(lines(
            "/**",
            " * This is a brief comment.",
            " * ",
            " * This is a detailed comment.",
            " * It contains mathematical equations, like 2 * 3 + 5 = 11.",
            " * It is important that it includes '*'. 5x * 3x*y = y*z!"
            " */")
        ),
        lines(
            "This is a brief comment.",
            "",
            "This is a detailed comment.",
            "It contains mathematical equations, like 2 * 3 + 5 = 11.",
            "It is important that it includes '*'. 5x * 3x*y = y*z!")
    )
def test_simple_function_def():
    method = MethodDefinition(
        "Testclass", "", "testfun", [], Includes(),
        "void", TypeInfo({}), Config()).make()
    assert_multi_line_equal(
        method,
        lines("cpdef testfun(Testclass self):",
              "    self.thisptr.testfun()")
    )
 def python_to_cpp(self):
     return lines(
         "cdef int %(python_argname)s_length = %(python_argname)s.shape[0]",
         "cdef cpp.VectorXd %(cpp_argname)s = cpp.VectorXd(%(python_argname)s_length)",
         "cdef int %(python_argname)s_idx",
         "for %(python_argname)s_idx in range(%(python_argname)s_length):",
         "    %(cpp_argname)s.data()[%(python_argname)s_idx] = %(python_argname)s[%(python_argname)s_idx]"
     ) % {"python_argname": self.python_argname,
          "cpp_argname": self.cpp_argname}
Exemple #5
0
def test_simple_function_def():
    method = MethodDefinition(
        "Testclass", "", "testfun", [], Includes(),
        "void", TypeInfo({}), Config()).make()
    assert_multi_line_equal(
        method,
        lines("cpdef testfun(Testclass self):",
              "    self.thisptr.testfun()")
    )
def test_make_header():
    assert_multi_line_equal(
        make_header("a b c d"),
        lines(
            "+" + "=" * 78 + "+",
            "| a b c d" + " " * 70 + "|",
            "+" + "=" * 78 + "+"
        )
    )
def test_template_class_string():
    c = TemplateClass("test.hpp", "", "MyTemplateClass")
    c.template_types.append("T")
    assert_multi_line_equal(
        str(c), lines(
            "TemplateClass 'MyTemplateClass' ('MyTemplateClass')",
            "    Template type 'T'"
        )
    )
 def return_output(self, copy=True):
     return lines(
         "cdef int size = result.rows()",
         "cdef int res_idx",
         "cdef np.ndarray[double, ndim=1] res = np.ndarray(shape=(size,))",
         "for res_idx in range(size):",
         "    res[res_idx] = result.get(res_idx)",
         "return res"
     )
def test_function_def_with_another_cppname():
    fun = FunctionDefinition("myFunInt", "", [], Includes(), "void", TypeInfo(),
                             Config(), cppname="myFun").make()
    assert_multi_line_equal(
        fun,
        lines(
            "cpdef my_fun_int():",
            "    cpp.myFun()"
        )
    )
def test_function_def():
    fun = FunctionDefinition("myFun", "", [], Includes(), "void", TypeInfo(),
                             Config()).make()
    assert_multi_line_equal(
        fun,
        lines(
            "cpdef my_fun():",
            "    cpp.myFun()"
        )
    )
def test_default_ctor_def():
    ctor = ConstructorDefinition("MyClass", "", [], Includes(), TypeInfo(),
                                 Config(), "MyClass").make()
    assert_multi_line_equal(
        ctor,
        lines(
            "def __init__(MyClass self):",
            "    self.thisptr = new cpp.MyClass()"
        )
    )
Exemple #12
0
def test_function_def_with_another_cppname():
    fun = FunctionDefinition("myFunInt", "", [], Includes(), "void", TypeInfo(),
                             Config(), cppname="myFun").make()
    assert_multi_line_equal(
        fun,
        lines(
            "cpdef my_fun_int():",
            "    cpp.myFun()"
        )
    )
def test_array_arg_function_def():
    method = MethodDefinition(
        "Testclass", "", "testfun", [Param("a", "double *"),
                                 Param("aSize", "unsigned int")],
        Includes(), "void", TypeInfo({}), Config()).make()
    assert_multi_line_equal(
        method,
        lines("cpdef testfun(Testclass self, np.ndarray[double, ndim=1] a):",
              "    self.thisptr.testfun(&a[0], a.shape[0])")
    )
Exemple #14
0
def test_function_def():
    fun = FunctionDefinition("myFun", "", [], Includes(), "void", TypeInfo(),
                             Config()).make()
    assert_multi_line_equal(
        fun,
        lines(
            "cpdef my_fun():",
            "    cpp.myFun()"
        )
    )
Exemple #15
0
def test_array_arg_function_def():
    method = MethodDefinition(
        "Testclass", "", "testfun", [Param("a", "double *"),
                                 Param("aSize", "unsigned int")],
        Includes(), "void", TypeInfo({}), Config()).make()
    assert_multi_line_equal(
        method,
        lines("cpdef testfun(Testclass self, np.ndarray[double, ndim=1] a):",
              "    self.thisptr.testfun(&a[0], a.shape[0])")
    )
Exemple #16
0
def test_default_ctor_def():
    ctor = ConstructorDefinition("MyClass", "", [], Includes(), TypeInfo(),
                                 Config(), "MyClass").make()
    assert_multi_line_equal(
        ctor,
        lines(
            "def __init__(MyClass self):",
            "    self.thisptr = new cpp.MyClass()"
        )
    )
Exemple #17
0
def test_comments():
    with cython_extension_from("comments.hpp"):
        from comments import MyClass, MyEnum
        assert_multi_line_equal(
            lines("This is a brief class description.",
                  "",
                  "    And this is a detailed description.",
                  "    "),
            MyClass.__doc__)
        assert_equal("Brief.", MyClass.method.__doc__.strip())
        assert_equal("Brief description of enum.", MyEnum.__doc__.strip())
def test_comments():
    with cython_extension_from("comments.hpp"):
        from comments import MyClass, MyEnum
        assert_multi_line_equal(
            lines("This is a brief class description.",
                  "    ",
                  "    And this is a detailed description.",
                  "    "),
            MyClass.__doc__)
        assert_equal("Brief.", MyClass.method.__doc__.strip())
        assert_equal("Brief description of enum.", MyEnum.__doc__.strip())
def test_template_function_string():
    m = TemplateFunction("test.hpp", "", "my_template_fun", "void")
    m.nodes.append(Param("t", "T"))
    m.template_types.append("T")
    assert_multi_line_equal(
        str(m), lines(
            "TemplateFunction 'my_template_fun'",
            "    Parameter (T) t",
            "    Template type 'T'"
        )
    )
 def python_to_cpp(self):
     return lines(
         "cdef int %(python_argname)s_length = %(python_argname)s.shape[0]",
         "cdef cpp.VectorXd %(cpp_argname)s = cpp.VectorXd(%(python_argname)s_length)",
         "cdef int %(python_argname)s_idx",
         "for %(python_argname)s_idx in range(%(python_argname)s_length):",
         "    %(cpp_argname)s.data()[%(python_argname)s_idx] = %(python_argname)s[%(python_argname)s_idx]"
     ) % {
         "python_argname": self.python_argname,
         "cpp_argname": self.cpp_argname
     }
def test_template_method_string():
    m = TemplateMethod("my_template_method", "void", "MyClass")
    m.nodes.append(Param("t", "T"))
    m.template_types.append("T")
    assert_multi_line_equal(
        str(m), lines(
            "TemplateMethod 'my_template_method'",
            "    Parameter (T) t",
            "    Template type 'T'"
        )
    )
def test_setter_definition():
    field = Field("myField", "double", "MyClass")
    setter = SetterDefinition(
        "MyClass", field, Includes(), TypeInfo(), Config()).make()
    assert_multi_line_equal(
        setter,
        lines(
            "cpdef set_my_field(MyClass self, double myField):",
            "    cdef double cpp_myField = myField",
            "    self.thisptr.myField = cpp_myField"
        )
    )
def test_getter_definition():
    field = Field("myField", "double", "MyClass")
    getter = GetterDefinition(
        "MyClass", field, Includes(), TypeInfo(), Config()).make()
    assert_multi_line_equal(
        getter,
        lines(
            "cpdef get_my_field(MyClass self):",
            "    cdef double result = self.thisptr.myField",
            "    return result"
        )
    )
Exemple #24
0
def test_setter_definition():
    field = Field("myField", "double", "MyClass")
    setter = SetterDefinition(
        "MyClass", field, Includes(), TypeInfo(), Config()).make()
    assert_multi_line_equal(
        setter,
        lines(
            "cpdef __set_my_field(MyClass self, double myField):",
            "    cdef double cpp_myField = myField",
            "    self.thisptr.myField = cpp_myField"
        )
    )
Exemple #25
0
def test_getter_definition():
    field = Field("myField", "double", "MyClass")
    getter = GetterDefinition(
        "MyClass", field, Includes(), TypeInfo(), Config()).make()
    assert_multi_line_equal(
        getter,
        lines(
            "cpdef __get_my_field(MyClass self):",
            "    cdef double result = self.thisptr.myField",
            "    return result",
            ""
        )
    )
def test_typedef_decl():
    typedef = Typedef("test.hpp", "", "MyType", "double")
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_typedef(typedef)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    ctypedef double MyType"
        )
    )
Exemple #27
0
def test_typedef_decl():
    typedef = Typedef("test.hpp", "", "MyType", "double")
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_typedef(typedef)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    ctypedef double MyType"
        )
    )
Exemple #28
0
def test_class_decl():
    clazz = Clazz("test.hpp", "", "MyClass")
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_clazz(clazz)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    cdef cppclass MyClass:",
            "        pass"
        )
    )
def test_class_decl():
    clazz = Clazz("test.hpp", "", "MyClass")
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_clazz(clazz)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    cdef cppclass MyClass:",
            "        pass"
        )
    )
def test_function_decl():
    fun = Function("test.hpp", "", "myFun", "void")
    ignored_fun = Function("test.hpp", "", "myFun", "void")
    ignored_fun.ignored = True
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_function(fun)
    exporter.visit_function(ignored_fun)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    void myFun() except +"
        )
    )
Exemple #31
0
def test_function_decl():
    fun = Function("test.hpp", "", "myFun", "void")
    ignored_fun = Function("test.hpp", "", "myFun", "void")
    ignored_fun.ignored = True
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_function(fun)
    exporter.visit_function(ignored_fun)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    void myFun() except +"
        )
    )
Exemple #32
0
def test_enum_decl():
    enum = Enum("test.hpp", "", "MyEnum")
    enum.constants.append("one")
    enum.constants.append("two")
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_enum(enum)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    cdef enum MyEnum:",
            "        one",
            "        two"
        )
    )
def test_enum_decl():
    enum = Enum("test.hpp", "", "MyEnum")
    enum.constants.append("one")
    enum.constants.append("two")
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_enum(enum)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    cdef enum MyEnum:",
            "        one",
            "        two"
        )
    )
Exemple #34
0
def test_field_decl():
    clazz = Clazz("test.hpp", "", "MyClass")
    field = Field("myField", "double", "MyClass")
    ignored_field = Field("myField", "double", "MyClass")
    ignored_field.ignored = True
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_field(field)
    exporter.visit_field(ignored_field)
    exporter.visit_clazz(clazz)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    cdef cppclass MyClass:",
            "        double myField"
        )
    )
Exemple #35
0
def test_ctor_decl():
    clazz = Clazz("test.hpp", "", "MyClass")
    ctor = Constructor("MyClass")
    ignored_ctor = Constructor("MyClass")
    ignored_ctor.ignored = True
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_constructor(ctor)
    exporter.visit_constructor(ignored_ctor)
    exporter.visit_clazz(clazz)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    cdef cppclass MyClass:",
            "        MyClass()"
        )
    )
def test_ctor_decl():
    clazz = Clazz("test.hpp", "", "MyClass")
    ctor = Constructor("MyClass")
    ignored_ctor = Constructor("MyClass")
    ignored_ctor.ignored = True
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_constructor(ctor)
    exporter.visit_constructor(ignored_ctor)
    exporter.visit_clazz(clazz)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    cdef cppclass MyClass:",
            "        MyClass()"
        )
    )
def test_field_decl():
    clazz = Clazz("test.hpp", "", "MyClass")
    field = Field("myField", "double", "MyClass")
    ignored_field = Field("myField", "double", "MyClass")
    ignored_field.ignored = True
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_field(field)
    exporter.visit_field(ignored_field)
    exporter.visit_clazz(clazz)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    cdef cppclass MyClass:",
            "        double myField"
        )
    )
Exemple #38
0
def test_method_decl():
    clazz = Clazz("test.hpp", "", "MyClass")
    method = Method("myMethod", "void", "MyClass")
    ignored_method = Method("", "", "")
    ignored_method.ignored = True
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_param(Param("myParam", "double"))
    exporter.visit_method(method)
    exporter.visit_method(ignored_method)
    exporter.visit_clazz(clazz)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    cdef cppclass MyClass:",
            "        void myMethod(double myParam) except +"
        )
    )
def test_method_decl():
    clazz = Clazz("test.hpp", "", "MyClass")
    method = Method("myMethod", "void", "MyClass")
    ignored_method = Method("", "", "")
    ignored_method.ignored = True
    exporter = CythonDeclarationExporter(Includes(), Config())
    exporter.visit_param(Param("myParam", "double"))
    exporter.visit_method(method)
    exporter.visit_method(ignored_method)
    exporter.visit_clazz(clazz)
    exporter.visit_ast(None)
    decl = exporter.export()
    assert_multi_line_equal(
        decl.strip(),
        lines(
            "cdef extern from \"test.hpp\" namespace \"\":",
            "    cdef cppclass MyClass:",
            "        void myMethod(double myParam) except +"
        )
    )
Exemple #40
0
def test_convert_to_docstring():
    assert_equal(convert_to_docstring(None), "")

    assert_multi_line_equal(
        convert_to_docstring(lines("/** This is a brief comment */")),
        "This is a brief comment.")

    assert_multi_line_equal(
        convert_to_docstring(lines("/**", " * This is a brief comment.",
                                   " */")), "This is a brief comment.")

    assert_multi_line_equal(
        convert_to_docstring("/// This is a brief comment."),
        "This is a brief comment.")

    assert_multi_line_equal(
        convert_to_docstring(
            lines("/**", " * This is a brief comment.", " *",
                  " * This is a detailed comment.", " */")),
        lines("This is a brief comment.", "", "This is a detailed comment."))

    assert_multi_line_equal(
        convert_to_docstring(
            lines("/**", " * This is a brief comment.",
                  " * This is a detailed comment.", " */")),
        lines("This is a brief comment.", "", "This is a detailed comment."))

    assert_multi_line_equal(
        convert_to_docstring(
            lines(
                "/**", " * This is a brief comment.", " * ",
                " * This is a detailed comment.",
                " * It contains mathematical equations, like 2 * 3 + 5 = 11.",
                " * It is important that it includes '*'. 5x * 3x*y = y*z!"
                " */")),
        lines("This is a brief comment.", "", "This is a detailed comment.",
              "It contains mathematical equations, like 2 * 3 + 5 = 11.",
              "It is important that it includes '*'. 5x * 3x*y = y*z!"))
def test_class_string_with_members():
    c = Clazz("test.hpp", "", "MyClass")

    ctor = Constructor("MyClass")
    ctor.nodes.append(Param("a", "double"))
    c.nodes.append(ctor)

    method = Method("my_method", "int", "MyClass")
    method.nodes.append(Param("b", "int"))
    c.nodes.append(method)

    field = Field("my_field", "bool", "MyClass")
    c.nodes.append(field)

    assert_multi_line_equal(
        str(c), lines(
            "Class 'MyClass' ('MyClass')",
            "    Constructor '__init__'",
            "        Parameter (double) a",
            "    Method 'my_method'",
            "        Parameter (int) b",
            "        Returns (int)",
            "    Field (bool) my_field"
        ))
def test_ast_string_with_function():
    ast = Ast()
    ast.nodes.append(Function("test.hpp", "", "fun", "void"))
    assert_multi_line_equal(str(ast), lines("AST", "    Function 'fun'"))
 def return_output(self, copy=True):
     return lines(
         "cdef int size = result.rows()", "cdef int res_idx",
         "cdef np.ndarray[double, ndim=1] res = np.ndarray(shape=(size,))",
         "for res_idx in range(size):",
         "    res[res_idx] = result.get(res_idx)", "return res")
Exemple #44
0
def test_indent_block():
    block = lines("a", "", "b")
    indented_block = indent_block(block, 1)
    assert_multi_line_equal(indented_block, lines("    a", "", "    b"))
Exemple #45
0
def test_make_header():
    assert_multi_line_equal(
        make_header("a b c d"),
        lines("+" + "=" * 78 + "+", "| a b c d" + " " * 70 + "|",
              "+" + "=" * 78 + "+"))
def test_indent_block():
    block = lines("a", "", "b")
    indented_block = indent_block(block, 1)
    assert_multi_line_equal(indented_block, lines("    a", "", "    b"))
def test_ast_string_with_enum():
    ast = Ast()
    ast.nodes.append(Enum("test.hpp", "", "MyEnum"))
    assert_multi_line_equal(str(ast), lines("AST", "    Enum 'MyEnum'"))
def test_ast_string_with_typedef():
    ast = Ast()
    ast.nodes.append(Typedef("test.hpp", "", "MyTypedef", "double"))
    assert_multi_line_equal(
        str(ast), lines("AST", "    Typedef (double) MyTypedef"))
def test_ast_string_with_class():
    ast = Ast()
    ast.nodes.append(Clazz("test.hpp", "bla", "MyClass"))
    assert_multi_line_equal(
        str(ast), lines(
            "AST", "    Class 'MyClass' ('MyClass') (namespace: 'bla')"))