rbind 0.0.16 → 0.0.17

data/test/headers/cfunctions.h

@@ -0,0 +1,7 @@
+#ifndef RBIND_CFUNCTIONS_H
+#define RBIND_CFUNCTIONS_H
+
+void test1(int i){};
+int test2(int i){};
+
+#endif

data/test/headers/classes.hpp

@@ -0,0 +1,29 @@
+#ifndef RBIND_CLASSES_HPP
+#define RBIND_CLASSES_HPP
+
+
+struct TestClass
+{
+    TestClass(int i1,char c){};
+    void setB(bool val){};
+    void setF(float &val){};
+    void setF2(const float &val){};
+    void setD(double &val)const{};
+
+    void setS(TestClass other)const{};
+    void setS2(TestClass *other)const{};
+    void setS3(TestClass **other)const{};
+    void setS4(TestClass &other)const{};
+    void setS5(const TestClass &other)const{};
+    void setS6(const TestClass *other)const{};
+
+    TestClass getS(){};
+    TestClass* getS2(){};
+    TestClass& getS3(){};
+    const TestClass& getS4(){};
+
+    bool bfield;
+    int ifield;
+};
+
+#endif

data/test/headers/constants.hpp

@@ -0,0 +1,14 @@
+
+#ifndef RBIND_CONSTANTS_HPP
+#define RBIND_CONSTANTS_HPP
+
+const int INT_CONST = 11;
+const unsigned int UINT_CONST = 12;
+
+namespace ns_const
+{
+    const int INT_CONST2 = 11;
+    const unsigned int UINT_CONST2 = 12;
+}
+
+#endif

data/test/headers/enums.hpp

@@ -0,0 +1,22 @@
+
+#ifndef RBIND_ENUMS_HPP
+#define RBIND_ENUMS_HPP
+
+enum Test1
+{
+    VAL1 = 1,
+    VAL2,
+    VAL3
+};
+
+namespace ns_enum
+{
+    enum Test2
+    {
+        VAL1 = 1,
+        VAL2 = VAL1+3,
+        VAL3
+    };
+}
+
+#endif

data/test/headers/std_string.hpp

@@ -0,0 +1,26 @@
+
+#ifndef RBIND_STD_STRING_HPP
+#define RBIND_STD_STRING_HPP
+
+#include <string>
+#include <stdlib.h>
+
+class TestClass
+{
+    private:
+        std::string private_var;
+
+    public:
+        std::string public_var;
+
+        // basic types
+        void setValues(std::string str){};
+        void setValues1(std::string &str){};
+        void setValues2(std::string *str){};
+
+        std::string getString(){ return private_var;};
+        std::string &getString2(){ return private_var;};
+        std::string *getString3(){ return &private_var;};
+};
+
+#endif

data/test/headers/std_vector.hpp

@@ -0,0 +1,31 @@
+
+#ifndef RBIND_STD_VECTOR_HPP
+#define RBIND_STD_VECTOR_HPP
+
+#include <vector>
+#include <stdlib.h>
+
+class TestClass
+{
+    private:
+        std::vector<float> private_var;
+
+    public:
+        class MStruct{};
+        std::vector<int> public_var;
+
+        // basic types
+        void setValues(std::vector<int> ints){};
+        void setValues1(std::vector<int> &ints){};
+
+        void setValues2(const std::vector<unsigned int> uints){};
+        void setValues3(const std::vector<unsigned int*> &uints){};
+
+        void setValues4(std::vector<MStruct> objs){};
+        void setValues5(std::vector<MStruct*> objs){};
+        void setValues6(std::vector<MStruct**> objs){};
+
+        std::vector<float> &getFloats(){ return private_var;};
+};
+
+#endif

data/test/headers/structs.hpp

@@ -0,0 +1,34 @@
+#ifndef RBIND_STRUCTS_HPP
+#define RBIND_STRUCTS_HPP
+
+
+struct TestStruct
+{
+    TestStruct(int i1,char c){};
+    void setB(bool val){};
+    void setF(float &val){};
+    void setF2(const float &val){};
+    void setD(double &val)const{};
+
+    void setS(TestStruct other)const{};
+    void setS2(TestStruct *other)const{};
+    void setS3(TestStruct **other)const{};
+    void setS4(TestStruct &other)const{};
+    void setS5(const TestStruct &other)const{};
+
+    TestStruct getS(){};
+    TestStruct* getS2(){};
+    TestStruct& getS3(){};
+    const TestStruct& getS4(){};
+
+    bool bfield;
+    int ifield;
+};
+
+typedef struct
+{
+    int i;
+}TestStruct2;
+
+
+#endif

data/test/headers/templates.hpp

@@ -0,0 +1,20 @@
+
+#ifndef RBIND_TEMPLATES_HPP
+#define RBIND_TEMPLATES_HPP
+
+template<typename T> class TemplateType
+{
+    public:
+        T field;
+
+    void setInt(int i){};
+    void setT(T val){};
+};
+
+class Test
+{
+    public:
+        void setType(TemplateType<int> type){};
+};
+
+#endif

data/test/test_clang_parser.rb

@@ -0,0 +1,146 @@
+require 'minitest/spec'
+require 'rbind'
+
+MiniTest::Unit.autorun
+describe Rbind::ClangParser do
+    before do
+    end
+
+    after do
+    end
+
+    describe "parse" do
+
+        it "must parse enums" do
+            next
+            file = File.join(File.dirname(__FILE__),'headers','enums.hpp')
+            parser = Rbind::ClangParser.new
+            parser.parse file
+            assert parser.Test1
+            assert_equal({"VAL1" => "1", "VAL2" => nil ,"VAL3" => nil},parser.Test1.values)
+
+            assert parser.ns_enum.Test2
+            assert_equal({"VAL1" => "1", "VAL2" => "VAL1+3" ,"VAL3" => nil},parser.ns_enum.Test2.values)
+        end
+
+        it "must parse constants" do
+            next
+            file = File.join(File.dirname(__FILE__),'headers','constants.hpp')
+            parser = Rbind::ClangParser.new
+            parser.parse file
+            assert parser.INT_CONST
+            assert_equal "11", parser.INT_CONST.default_value
+            assert_equal "int", parser.INT_CONST.type.full_name
+            assert_equal "12", parser.UINT_CONST.default_value
+            assert_equal "uint", parser.UINT_CONST.type.full_name
+
+            assert_equal "11", parser.ns_const.INT_CONST.default_value
+            assert_equal "int", parser.ns_const.INT_CONST.type.full_name
+            assert_equal "12", parser.ns_const.UINT_CONST.default_value
+            assert_equal "uint", parser.ns_const.UINT_CONST.type.full_name
+        end
+
+        it "must parse c functions" do
+            next
+            file = File.join(File.dirname(__FILE__),'headers','cfunctions.h')
+            parser = Rbind::ClangParser.new
+            parser.parse file
+
+            assert parser.test1
+            assert_equal "int",parser.test1.parameters[0].type.full_name
+            assert_equal "void",parser.test1.return_type.full_name
+
+            assert parser.test2
+            assert_equal "int",parser.test2.parameters[0].type.full_name
+            assert_equal "int",parser.test2.return_type.full_name
+        end
+
+        it "must parse structs" do
+            file = File.join(File.dirname(__FILE__),'headers','structs.hpp')
+            parser = Rbind::ClangParser.new
+            parser.parse file
+
+            assert_equal "TestStruct::TestStruct(int i1, char c)", parser.TestStruct.TestStruct.signature
+            assert_equal "void TestStruct::setB(bool val)", parser.TestStruct.setB.signature
+            assert_equal "void TestStruct::setF(float& val)", parser.TestStruct.setF.signature
+            assert_equal "void TestStruct::setF2(const float& val)", parser.TestStruct.setF2.signature
+            assert_equal "void TestStruct::setD(double& val)", parser.TestStruct.setD.signature
+            assert_equal "void TestStruct::setS(TestStruct other)", parser.TestStruct.setS.signature
+            assert_equal "void TestStruct::setS2(TestStruct* other)", parser.TestStruct.setS2.signature
+            assert_equal "void TestStruct::setS3(TestStruct** other)", parser.TestStruct.setS3.signature
+            assert_equal "void TestStruct::setS4(TestStruct& other)", parser.TestStruct.setS4.signature
+            assert_equal "void TestStruct::setS5(const TestStruct& other)", parser.TestStruct.setS5.signature
+            assert_equal "TestStruct TestStruct::getS()", parser.TestStruct.getS.signature
+            assert_equal "TestStruct* TestStruct::getS2()", parser.TestStruct.getS2.signature
+            assert_equal "TestStruct& TestStruct::getS3()", parser.TestStruct.getS3.signature
+            assert_equal "const TestStruct& TestStruct::getS4()", parser.TestStruct.getS4.signature
+            assert parser.TestStruct.attribute("bfield")
+            assert parser.TestStruct.attribute("ifield")
+            #TODO test csignature
+        end
+
+        it "must parse classes" do
+            next
+            file = File.join(File.dirname(__FILE__),'headers','classes.hpp')
+            parser = Rbind::ClangParser.new
+            parser.parse file
+
+            assert_equal "void TestClass::TestClass(int i1, char c)", parser.TestClass.TestClass.signature
+            assert_equal "void TestClass::setB(bool val)", parser.TestClass.setB.signature
+            assert_equal "void TestClass::setF(float& val)", parser.TestClass.setF.signature
+            assert_equal "void TestClass::setF2(const float& val)", parser.TestClass.setF2.signature
+            assert_equal "void TestClass::setD(double& val)", parser.TestClass.setD.signature
+            assert_equal "TestClass TestClass::setS(TestClass other)", parser.TestClass.setS.signature
+            assert_equal "TestClass TestClass::setS2(TestClass* other)", parser.TestClass.setS2.signature
+            assert_equal "TestClass TestClass::setS3(TestClass** other)", parser.TestClass.setS3.signature
+            assert_equal "TestClass TestClass::setS4(TestClass& other)", parser.TestClass.setS4.signature
+            assert_equal "TestClass TestClass::setS5(const TestClass& other)", parser.TestClass.setS5.signature
+            assert_equal "TestClass TestClass::setS6(const TestClass* other)", parser.TestClass.setS6.signature
+            assert_equal "TestClass TestClass::getS()", parser.TestClass.getS.signature
+            assert_equal "TestClass* TestClass::getS2()", parser.TestClass.getS2.signature
+            assert_equal "TestClass& TestClass::getS3()", parser.TestClass.getS3.signature
+            assert_equal "const TestClass& TestClass::getS4()", parser.TestClass.getS4.signature
+            assert parser.TestClass.attribute("bfield")
+            assert parser.TestClass.attribute("ifield")
+        end
+
+        it "must parse std vector types" do
+            next
+            file = File.join(File.dirname(__FILE__),'headers','std_vector.hpp')
+            parser = Rbind::ClangParser.new
+            parser.parse file
+
+            assert_equal "void TestClass::setValues(std::vector<int> ints)", parser.TestClass.setValues.signature
+            assert_equal "void TestClass::setValues1(std::vector<int>& ints)", parser.TestClass.setValues1.signature
+            assert_equal "void TestClass::setValues2(const std::vector<uint> uints)", parser.TestClass.setValues2.signature
+            assert_equal "void TestClass::setValues3(const std::vector<uint*>& uints)", parser.TestClass.setValues3.signature
+            assert_equal "void TestClass::setValues4(std::vector<TestClass::MStruct> objs)", parser.TestClass.setValues4.signature
+            assert_equal "void TestClass::setValues5(std::vector<TestClass::MStruct*> objs)", parser.TestClass.setValues5.signature
+            assert_equal "void TestClass::setValues6(std::vector<TestClass::MStruct**> objs)", parser.TestClass.setValues6.signature
+            assert_equal "std::vector<float>& TestClass::getFloats()", parser.TestClass.getFloats.signature
+        end
+
+        it "must parse std string types" do
+            file = File.join(File.dirname(__FILE__),'headers','std_string.hpp')
+            parser = Rbind::ClangParser.new
+            parser.add_type(Rbind::StdString.new("std::string",parser))
+            parser.type_alias["basic_string"] = parser.std.string
+            parser.parse file
+
+            assert_equal "void TestClass::setValues(std::string str)", parser.TestClass.setValues.signature
+            assert_equal "void TestClass::setValues1(std::string& str)", parser.TestClass.setValues1.signature
+            assert_equal "void TestClass::setValues2(std::string* str)", parser.TestClass.setValues2.signature
+            assert_equal "std::string TestClass::getString()", parser.TestClass.getString.signature
+            assert_equal "std::string& TestClass::getString2()", parser.TestClass.getString2.signature
+            assert_equal "std::string* TestClass::getString3()", parser.TestClass.getString3.signature
+        end
+
+        # this is not fully supported yet
+        #it "must parse templates" do
+        #    file = File.join(File.dirname(__FILE__),'headers','templates.hpp')
+        #    parser = Rbind::ClangParser.new
+        #    parser.parse file
+        #    #assert_equal("_test123",result)
+        #end
+    end
+end

data/test/test_generator_ruby.rb

@@ -72,8 +72,3 @@ describe Rbind::GeneratorRuby do
         end
     end
 end
-            #assert(@service.names.include?("Local/dummy"))
-            #assert_equal(@task,@service.get("dummy"))
-            #assert_raises(Orocos::NotFound) do
-            #    @service.get("foo")
-            #end

data/test/test_roperation.rb

@@ -0,0 +1,144 @@
+require 'minitest/spec'
+require 'rbind'
+
+MiniTest::Unit.autorun
+describe Rbind::ROperation do
+    before do
+        @root = Rbind::RNamespace.new
+        @root.add_default_types
+    end
+
+    after do
+    end
+
+    describe "signature" do
+        it "must generate a correct signature for simple methods" do
+            op = @root.add_operation("testOperation")
+            assert_equal "void testOperation()", op.to_s
+
+            op = @root.add_operation("testOperation2") do |op|
+                op.return_type = int
+            end
+            assert_equal "int testOperation2()", op.to_s
+
+            op = @root.add_operation("testOperation3") do |op|
+                op.add_parameter("para") do |p|
+                    p.type = int
+                end
+            end
+            assert_equal "void testOperation3(int para)", op.to_s
+
+            op = @root.add_operation("testOperation4") do |op|
+                op.add_parameter("para") do |p|
+                    p.type = int.to_ptr
+                end
+                op.return_type = char.to_ref
+            end
+            assert_equal "char& testOperation4(int* para)", op.to_s
+        end
+
+        it "must generate a correct signature for complex methods" do
+            @root.add_type Rbind::RClass.new("MStruct")
+            @root.add_type Rbind::StdVector.new("std::vector")
+
+            op = @root.add_operation("testOperation") do |op|
+                op.add_parameter("para") do |p|
+                    p.type = type("MStruct").to_ptr
+                end
+                op.add_parameter("para2") do |p|
+                    p.type = type("MStruct")
+                end
+                op.return_type = int
+            end
+            assert_equal "int testOperation(MStruct* para, MStruct para2)", op.to_s
+
+            op = @root.add_operation("testOperation2") do |op|
+                op.add_parameter("para") do |p|
+                    p.type = type("std::vector<MStruct*>").to_ptr.to_const
+                    p.default_value = "0"
+                end
+            end
+            assert_equal "void testOperation2(const std::vector<MStruct*>* para = 0)", op.to_s
+        end
+    end
+
+    describe "csignature" do
+        it "must generate a correct csignature for simple methods" do
+            op = @root.add_operation("testOperation")
+            assert_equal "void rbind_testOperation()", op.csignature
+
+            op = @root.add_operation("testOperation2") do |op|
+                op.return_type = int
+            end
+            assert_equal "int rbind_testOperation2()", op.csignature
+
+            op = @root.add_operation("testOperation3") do |op|
+                op.add_parameter("para") do |p|
+                    p.type = int
+                end
+            end
+            assert_equal "void rbind_testOperation3(int para)", op.csignature
+
+            op = @root.add_operation("testOperation4") do |op|
+                op.add_parameter("para") do |p|
+                    p.type = int.to_ptr
+                end
+                op.return_type = char.to_ref
+            end
+            assert_equal "char& rbind_testOperation4(int* para)", op.csignature
+        end
+
+        it "must generate a correct csignature for complex methods" do
+            @root.add_type Rbind::RClass.new("MStruct")
+            @root.add_type Rbind::StdVector.new("std::vector")
+
+            op = @root.add_operation("testOperation") do |op|
+                op.add_parameter("para") do |p|
+                    p.type = type("MStruct").to_ptr
+                end
+                op.add_parameter("para2") do |p|
+                    p.type = type("MStruct")
+                end
+                op.return_type = int
+            end
+            assert_equal "int rbind_testOperation(rbind_MStruct* para, rbind_MStruct* para2)", op.csignature
+
+            op = @root.add_operation("testOperation2") do |op|
+                op.add_parameter("para") do |p|
+                    p.type = type("std::vector<MStruct*>").to_ptr.to_const
+                    p.default_value = "0"
+                end
+            end
+            assert_equal "void rbind_testOperation2(const rbind_std_vector_MStruct_ptr* para)", op.csignature
+
+            op = @root.add_operation("testOperation3") do |op|
+                op.add_parameter("para") do |p|
+                    p.type = type("std::vector<MStruct*>").to_ref.to_const
+                    p.default_value = "0"
+                end
+            end
+            assert_equal "void rbind_testOperation3(const rbind_std_vector_MStruct_ptr* para)", op.csignature
+
+            op = @root.add_operation("testOperation4") do |op|
+                op.return_type = type("std::vector<MStruct*>").to_ref
+            end
+            assert_equal "rbind_std_vector_MStruct_ptr* rbind_testOperation4()", op.csignature
+        end
+
+        it "must enumerate overloaded methods" do
+            # rbind does not care if two methods have the exact same signature
+            op = @root.add_operation("testOperation")
+            assert_equal "void rbind_testOperation()", op.csignature
+
+            op = @root.add_operation("testOperation")
+            assert_equal "void rbind_testOperation2()", op.csignature
+
+            op = @root.add_operation("testOperation")
+            assert_equal "void rbind_testOperation3()", op.csignature
+
+            op = @root.add_operation("testOperation3")
+            assert_equal "void rbind_testOperation31()", op.csignature
+        end
+    end
+end
+