rbplusplus 0.9.1 → 1.0

data/test/functions_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-context "Extension with globally available functions" do
+describe "Extension with globally available functions" do
 
   specify "should make functions available" do
     Extension.new "functions" do |e|
@@ -10,17 +10,11 @@ context "Extension with globally available functions" do
 
     require 'functions'
 
-    should.not.raise NameError do
-      test1
-    end
+    lambda { test1 }.should_not raise_error(NameError)
 
-    should.not.raise NameError do
-      assert_in_delta 1.0, test2(2.0), 0.001
-    end
+    test2(2.0).should be_close(1.0, 0.001)
 
-    should.not.raise NameError do
-      test3(2, 4.2).should == 2
-    end
+    test3(2, 4.2).should == 2
   end
 
 end

data/test/generated/extconf.rb

@@ -7,7 +7,7 @@ def append_ld_flags(flags)
   with_ldflags("#{$LDFLAGS} #{flags.join(' ')}") { true }
 end
 
-$CPPFLAGS += " -I'/home/roelofs/projects/rbplusplus/test/generated'  "
+$CPPFLAGS += " -I'/Users/roelofs/Development/rbplusplus/test/generated'  "
 $LDFLAGS += "   "
 
 if RUBY_PLATFORM =~ /darwin/
@@ -22,4 +22,4 @@ if RUBY_PLATFORM =~ /darwin/
   append_ld_flags '-all_load'
 end
 
-create_makefile("defargs")
+create_makefile("ui")

data/test/headers/alloc_strats.h

@@ -18,7 +18,9 @@ namespace alloc_strats {
     public:
       NoConstructor* getConstructor() { return 0; }
 
-      Neither* getInstance() { return 0; }
+      static Neither* getInstance() { static Neither neither; return &neither; }
+
+      int process(int a, int b) { return a * b; }
   };
 }
 

data/test/headers/implicit_cast.h

@@ -0,0 +1,107 @@
+#ifndef __IMPLICIT_CAST_H__
+#define __IMPLICIT_CAST_H__
+
+namespace implicit_cast {
+
+  const int degree2Radians = (3.14 / 180.0);
+  const int radian2Degrees = (180.0 / 3.14);
+
+  class Radian;
+
+  class Degree
+  {
+    public:
+      explicit Degree(float d) : val_(d) {}
+      Degree(const Radian& r);
+
+      float valueDegrees() const { return val_; }
+      float valueRadians() const { return val_ * degree2Radians; }
+
+    private:
+      float val_;
+  };
+
+  class Radian
+  {
+    public:
+      explicit Radian(float r) : val_(r) {} 
+      Radian(const Degree& d) : val_(d.valueRadians()) {}
+
+      float valueRadians() const { return val_; }
+      float valueDegrees() const { return val_ * radian2Degrees; }
+
+    private:
+      float val_;
+  };
+
+  // Due to circular dependencies, need to define some
+  // methods down here
+  Degree::Degree(const Radian& r)
+  {
+    val_ = r.valueDegrees();
+  }
+
+  /**
+   * And now some methods that work w/ the above two classes
+   */
+  bool isAcute(Degree degree) {
+    return degree.valueDegrees() < 90;
+  }
+
+  bool isObtuse(Radian radian) {
+    return radian.valueDegrees() > 90 && radian.valueDegrees() <= 180;
+  }
+
+  bool isRight(Degree* degree) {
+    return degree->valueDegrees() == 90;
+  }
+
+  /**
+   * Classes to show how to turn off the implicit casting
+   */
+  class Explicit
+  {
+    public:
+      Explicit(float v) {
+        value = v;
+      }
+
+      Explicit(const Degree &d) {
+        value = d.valueDegrees();
+      }
+
+      Explicit(const Radian &r) {
+        value = r.valueDegrees();
+      }
+
+      float value;
+  };
+
+  float explicitValue(Explicit e) {
+    return e.value;
+  }
+
+  class NotImplicit
+  {
+    public:
+      NotImplicit(float v, int a) {
+        value = v * a;
+      }
+
+      NotImplicit(const Degree &d) {
+        value = d.valueDegrees();
+      }
+
+      NotImplicit(const Radian &r) {
+        value = r.valueDegrees();
+      }
+
+      float value;
+  };
+
+  float notImplicitValue(NotImplicit i) {
+    return i.value;
+  }
+}
+
+#endif

data/test/headers/to_from_ruby.h

@@ -26,7 +26,11 @@ namespace to_from_ruby {
   // Should also work with class methods
   class WrappedClass {
     public:
-      WrappedClass() {}
+      WrappedClass() { myType = new MyType(); }
+
+      ~WrappedClass() {
+        if(myType) { delete myType; }
+      }
 
       const MyType& getMyType(int value) {
         MyType *type = new MyType();
@@ -34,20 +38,23 @@ namespace to_from_ruby {
         return *type;
       }
       
-      const WrappedClass &overload() {
-        return *this;
+      const MyType &overload() {
+        return *myType;
       }
     
-      const WrappedClass &overload(int arg) {
-        return *this;
+      const MyType &overload(int arg) {
+        return *myType;
       }
+
+    private:
+      const MyType* myType;
   };
 
   /**
    * Some types, Rice already wraps for us. Make sure this doesn't cause
    * a compiler error
    */
-  void usingConstString(const std::string& in);
+  int usingConstString(const std::string& in);
   
   /* template tests */
   

data/test/headers/to_from_ruby_source.cpp

@@ -16,7 +16,7 @@ namespace to_from_ruby {
     return *type;
   };
 
-  void usingConstString(const std::string& in) {
-
+  int usingConstString(const std::string& in) {
+    return in.size();
   }
 }

data/test/implicit_cast_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+describe "Specify types to allow implicit casting" do
+
+  before(:all) do
+    Extension.new "implicit_cast" do |e|
+      e.sources full_dir("headers/implicit_cast.h")
+      e.writer_mode :single
+        
+      node = e.namespace "implicit_cast"
+
+      # Can flag individual constructors
+      node.classes("Explicit").constructors.
+        find(:arguments => ["const Radian&"]).implicit_casting(false)
+
+      # Or flag the class as a whole
+      node.classes("NotImplicit").implicit_casting(false)
+    end
+
+    require 'implicit_cast'
+  end
+
+  specify "proper constructor is exposed" do
+    Degree.new(14).value_degrees.should == 14
+    Radian.new(1).value_radians.should == 1
+  end
+
+  specify "can use Degree in place of Radian" do
+    is_obtuse(Degree.new(75)).should be_false
+  end
+
+  specify "can use Radian in place of Degree" do
+    is_acute(Radian.new(2.0)).should be_false
+  end
+
+  specify "pointers also work fine" do
+    is_right(Degree.new(90)).should be_true
+    is_right(Radian.new(2.0)).should be_false
+  end
+
+  specify "can turn off implicit cast wrapping for a given constructor" do
+    lambda do
+      explicit_value(Radian.new(60.0))
+    end.should raise_error
+
+    lambda do
+      e = Explicit.new(14.0)
+      explicit_value(e).should be_close(14.0, 0.001)
+    end.should_not raise_error
+  end
+
+  specify "can turn off implicit casting for an entire class" do
+    n = NotImplicit.new(10.0, 3)
+    
+    not_implicit_value(n).should be_close(30.0, 0.001)
+
+    lambda do
+      not_implicit_value(Degree.new(15.0))
+    end.should raise_error
+
+    lambda do
+      not_implicit_value(Radian.new(1.0))
+    end.should raise_error
+  end
+
+end
+

data/test/modules_test.rb

@@ -2,70 +2,69 @@ require 'test_helper'
 
 context "Extension with modules" do
 
-  def setup
-    if !defined?(@@modules_built)
-      super
-      @@modules_built = true 
-      Extension.new "modules" do |e|
-        e.sources [
-            full_dir("headers/Adder.h"),
-            full_dir("headers/functions.h"),
-            full_dir("headers/Subtracter.hpp")
-          ],
-          :include_source_files => [
-            full_dir("headers/Adder.h"),
-            full_dir("headers/Adder.cpp")
-          ]
-
-        e.writer_mode :single
-
-        e.module "Empty" do |m|
-        end
+  before(:all) do
+    Extension.new "modules" do |e|
+      e.sources [
+          full_dir("headers/Adder.h"),
+          full_dir("headers/functions.h"),
+          full_dir("headers/Subtracter.hpp")
+        ],
+        :include_source_files => [
+          full_dir("headers/Adder.h"),
+          full_dir("headers/Adder.cpp")
+        ]
 
-        # Can use without a block
-        wrapper = e.module "Wrapper"
-        node = wrapper.namespace "classes"
-        node.classes("Adder").disable_typedef_lookup
+      e.writer_mode :single
 
-        e.module "Functions" do |m|
-          m.namespace "functions"
-        end
+      e.module "Empty" do |m|
+      end
+
+      # Can use without a block
+      wrapper = e.module "Wrapper"
+      node = wrapper.namespace "classes"
+      node.classes("Adder").disable_typedef_lookup
+
+      e.module "Functions" do |m|
+        m.namespace "functions"
+      end
 
-        e.module "Nested" do |m|
-          m.module "Nested" do |n|
-            n.module "Inner" do |inner|
-              inner.namespace "subtracter"
-            end
+      e.module "Nested" do |m|
+        m.module "Nested" do |n|
+          n.module "Inner" do |inner|
+            inner.namespace "subtracter"
           end
         end
-
       end
 
-      require 'modules'
     end
+
+    require 'modules'
   end
 
   specify "should be able to generate a module definition" do
-    assert defined?(Empty)
+    lambda { Empty }.should_not raise_error(NameError)
+
     Empty.class.should == Module
   end
 
   specify "should wrap up C++ classes under the namespace as requested" do
-    assert !defined?(Adder)
-    assert defined?(Wrapper::Adder)
+    lambda { Adder }.should raise_error(NameError)
+    lambda { Wrapper::Adder }.should_not raise_error(NameError)
+
     a = Wrapper::Adder.new
     a.get_class_name.should == "Adder"
   end
 
   specify "should wrap up C++ functions in the module" do
-    assert defined?(Functions)
-    Functions::test2(2).should.be.close 1.0, 0.001
+    lambda { Functions }.should_not raise_error(NameError)
+    Functions::test2(2).should be_close(1.0, 0.001)
     Functions::test3(4, 6).should == 4
   end
 
   specify "should be able to nest modules and related definitions" do
-    assert !defined?(Subtracter)
-    assert defined?(Nested::Nested::Inner::Subtracter)
+    lambda { Subtracter }.should raise_error(NameError)
+    lambda { Nested::Nested::Inner::Subtracter }.should_not raise_error(NameError)
+
     s = Nested::Nested::Inner::Subtracter.new
     s.get_class_name.should == "Subtracter"
   end

data/test/nested_test.rb

@@ -1,26 +1,24 @@
 require 'test_helper'
 
 context "Wrapping Classes within classes" do
-  def setup
-    if !defined?(@@nested_built)
-      super
-      @@nested_built = true 
-      Extension.new "nested" do |e|
-        e.sources full_dir("headers/nested_classes.h")
-        node = e.namespace "classes"
-      end
-
-      require 'nested'
+  before(:all) do
+    Extension.new "nested" do |e|
+      e.sources full_dir("headers/nested_classes.h")
+      node = e.namespace "classes"
     end
+
+    require 'nested'
   end
 
   specify "should properly make nested classes available" do
-    assert defined?(TestClass) 
-    assert defined?(TestClass::InnerClass) 
-    assert defined?(TestClass::InnerClass::Inner2) 
+    lambda do 
+      Kernel.const_get(TestClass) 
+      Kernel.const_get(TestClass::InnerClass) 
+      Kernel.const_get(TestClass::InnerClass::Inner2) 
+    end.should_not raise_error(NameError)
 
-    TestClass.new.should.not.be.nil
-    TestClass::InnerClass.new.should.not.be.nil
-    TestClass::InnerClass::Inner2.new.should.not.be.nil
+    TestClass.new.should_not be_nil
+    TestClass::InnerClass.new.should_not be_nil
+    TestClass::InnerClass::Inner2.new.should_not be_nil
   end
 end

data/test/overloading_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-context "Extension with overloaded methods" do
+describe "Extension with overloaded methods" do
 
   specify "should have all functions available" do
     Extension.new "overload" do |e|
@@ -12,35 +12,32 @@ context "Extension with overloaded methods" do
       mathy.use_constructor(
         mathy.constructors.find(:arguments => [:int])
       )
+
+      mathy.methods("constMethod").find(:arguments => ["std::string"]).wrap_as("const_method_string")
     end
 
     require 'overload'
 
-    math = nil
-    should.not.raise NameError do
-      #Constructor overloading is broken in rice
-      #math = Mathy.new 
-      math = Mathy.new(1)
-    end
+    #Constructor overloading is broken in rice
+    #math = Mathy.new 
+    math = Mathy.new(1)
     
-    should.not.raise NameError do
-      math.times.should.equal 1
-      math.times_1(3).should.equal 3
-      math.times_2(3,2).should.equal 6
-      math.times_3(3,2,3).should.equal 18
-    end
+    math.times.should == 1
+    math.times_1(3).should == 3
+    math.times_2(3,2).should == 6
+    math.times_3(3,2,3).should == 18
     
-    should.not.raise NameError do
+    lambda do
       math.nothing_0
       math.nothing_1(1)
-    end
+    end.should_not raise_error(NameError)
 
     # Should properly handle const overloads as well
-    should.not.raise NameError do
-      math.const_method_0(1).should.equal 1
-      math.const_method_1(1).should.equal 2
-      math.const_method_2("love").should.equal 4
-    end
+    lambda do
+      math.const_method_0(1)
+      math.const_method_1(1)
+      math.const_method_string("love")
+    end.should_not raise_error(NameError)
 
   end
 

data/test/struct_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-context "Nested Struct" do
+describe "Nested Struct" do
 
   specify "should be accessible" do
     Extension.new "nested" do |e|
@@ -10,13 +10,11 @@ context "Nested Struct" do
 
     require 'nested'
 
-    should.not.raise NameError do
-      Klass::NestedStruct.new.one.should == 1
-    end
+    Klass::NestedStruct.new.one.should == 1
 
-    should.raise NameError do
+    lambda do
       Klass::PrivateNestedStruct.new
-    end
+    end.should raise_error(NameError)
   end
   
 end

data/test/subclass_test.rb

@@ -12,30 +12,28 @@ context "Extension with class hierachies" do
       # Rice doesn't support multiple-inheritance (neither does Ruby), so for now
       # until we can fake it, force people to specify
       node.classes("Multiple").use_superclass( node.classes("Base2") )
+
+      node.classes.implicit_casting(false)
     end
 
     require 'subclass'
 
     # Ignored superclasses should not cause problems with wrapped subclasses
-    should.not.raise NameError do
-      Base.new.one.should == Sub.new.one
-      Base.new.zero.should == Sub.new.zero
-    end
+    Base.new.one.should == Sub.new.one
+    Base.new.zero.should == Sub.new.zero
 
     # Template superclasses shouldn't cause problems
-    should.not.raise NameError do
-      TemplateSub.new.zero.should == TemplateSub.new.custom
-    end
+    TemplateSub.new.zero.should == TemplateSub.new.custom
 
-    should.not.raise NameError do
+    lambda do
       TemplatePtr.new.custom
-    end
+    end.should_not raise_error(NameError)
 
-    should.not.raise NameError do
+    lambda do
       Multiple.new
-    end
+    end.should_not raise_error(NameError)
 
-    Multiple.superclass.should.equal Base2
+    Multiple.superclass.should == Base2
   end
 
 end

data/test/test_helper.rb

@@ -2,28 +2,37 @@ $:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
 $:.unshift File.expand_path(File.dirname(__FILE__) + "/generated")
 
 require 'rubygems'
-require 'test/spec'
+require 'rspec'
 require 'rbplusplus'
-require 'mocha_standalone'
 
 include RbPlusPlus
 
-class Test::Unit::TestCase
-
+module FileDirectoryHelpers
   def full_dir(path)
     File.expand_path(File.join(File.dirname(__FILE__), path))
   end
+end
 
-  def setup
+module TestHelpers
+  def clear_info
     `rm -rf #{full_dir('generated')}/*`
-    Logger.stubs(:info)
-    Logger.stubs(:warn)
-    Logger.stubs(:error)
-    Logger.stubs(:debug)
   end
 
-  def teardown
-    RbGCCXML::XMLParsing.clear_cache
-    NodeCache.clear
+  def silence_logging
+    RbPlusPlus::Logger.silent!
+  end
+
+  def test_setup
+    clear_info
+    silence_logging
+  end
+end
+
+RSpec.configure do |config|
+  config.include(FileDirectoryHelpers)
+  config.include(TestHelpers)
+
+  config.before(:all) do
+    test_setup
   end
 end

data/test/to_from_ruby_test.rb

@@ -17,6 +17,12 @@ context "Properly build known required to_ruby and from_ruby methods" do
 
     c = WrappedClass.new
     c.get_my_type(17).value.should == 17
-    c.overload_0.class.should == c.overload_1(0).class
+
+    using_const_string("super_long").should == 10
+
+    # Running this gets a glibc double free error. Not sure if this is properly
+    # fixable outside of implementing call and return policies in Rice.
+#    c.overload_0.class.should == MyType
+#    c.overload_0.class.should == c.overload_1(0).class
   end
 end