rbplusplus 0.9.1 → 1.0

data/test/default_arguments_test.rb

@@ -1,54 +1,50 @@
 require 'test_helper'
 
-context "Default arguments properly exposed" do
-
-  def setup
-    if !defined?(@@defargs_built)
-      super
-      @@defargs_built = true 
-      Extension.new "defargs" do |e|
-        e.sources full_dir("headers/default_arguments.h")
-        e.writer_mode :single
-        node = e.namespace "default_args"
-
-        e.module "Inner" do |m|
-          m.includes node.functions("module_do")
-        end
-
-        node.classes("Directed").director
+describe "Default arguments properly exposed" do
+
+  before(:all) do
+    Extension.new "defargs" do |e|
+      e.sources full_dir("headers/default_arguments.h")
+      e.writer_mode :single
+      node = e.namespace "default_args"
+
+      e.module "Inner" do |m|
+        m.includes node.functions("module_do")
       end
 
-      require 'defargs'
+      node.classes("Directed").director
     end
+
+    require 'defargs'
   end
 
   specify "global functions" do
-    global_do(1, 4, 5).should.equal 20
-    global_do(1, 4).should.equal 40
-    global_do(1).should.equal 30
+    global_do(1, 4, 5).should == 20
+    global_do(1, 4).should == 40
+    global_do(1).should == 30
   end
 
   specify "module functions" do
-    Inner.module_do(5).should.equal 18
-    Inner.module_do(5, 5).should.equal 20
-    Inner.module_do(5, 5, 5).should.equal 15
+    Inner.module_do(5).should == 18
+    Inner.module_do(5, 5).should == 20
+    Inner.module_do(5, 5, 5).should == 15
   end
 
   specify "class instance methods" do
     tester = Tester.new
-    tester.concat("this", "that").should.equal "this-that"
-    tester.concat("this", "that", ";").should.equal "this;that"
+    tester.concat("this", "that").should == "this-that"
+    tester.concat("this", "that", ";").should == "this;that"
   end
 
   specify "class static methods" do
-    Tester.build("base").should.equal "basebasebase"
-    Tester.build("woot", 5).should.equal "wootwootwootwootwoot"
+    Tester.build("base").should == "basebasebase"
+    Tester.build("woot", 5).should == "wootwootwootwootwoot"
   end
 
   specify "director methods" do
     d = Directed.new
-    d.virtual_do(3).should.equal 30
-    d.virtual_do(3, 9).should.equal 27
+    d.virtual_do(3).should == 30
+    d.virtual_do(3, 9).should == 27
 
     class MyD < Directed
       def virtual_do(x, y = 10)
@@ -57,31 +53,31 @@ context "Default arguments properly exposed" do
     end
 
     myd = MyD.new
-    myd.virtual_do(10).should.equal 300
+    myd.virtual_do(10).should == 300
   end
 
   specify "throw argument error on bad types" do
-    should.raise TypeError do
+    lambda do
       global_do(1, "three")
-    end
+    end.should raise_error(TypeError)
   end
 
   # See MethodBase#fix_enumeration_value
   specify "properly handle incomplete enums in default values" do
-    modify(1).should.equal 11
-    modify(1, Ops::ADD).should.equal 11
-    modify(1, Ops::REMOVE).should.equal -9
+    modify(1).should == 11
+    modify(1, Ops::ADD).should == 11
+    modify(1, Ops::REMOVE).should == -9
   end
 
   # Ogre does this to handle some weird pass-back-enum-that-signals-error (Ogre::Frustum::isVisible)
   specify "properly handle incomplete enums arguments with straight integer default values" do
-    modify2(1).should.equal 1
-    modify2(1, Ops::ADD).should.equal 1
-    modify2(1, Ops::REMOVE).should.equal 1
+    modify2(1).should == 1
+    modify2(1, Ops::ADD).should == 1
+    modify2(1, Ops::REMOVE).should == 1
   end
 
-  xspecify "should properly handle argument type qualifiers like refs and consts" do
-    build_strings("I'd ").should.equal "I'd kick-it"
-    build_strings("You won't", " do it").should.equal "You won't do it"
-  end
+  specify "should properly handle argument type qualifiers like refs and consts" # do
+#    build_strings("I'd ").should == "I'd kick-it"
+#    build_strings("You won't", " do it").should == "You won't do it"
+#  end
 end

data/test/director_test.rb

@@ -2,32 +2,28 @@ require 'test_helper'
 
 context "Director proxy generation" do
 
-  def setup
-    if !defined?(@@director_built)
-      super
-      @@director_built = true
-      Extension.new "director" do |e|
-        e.sources full_dir("headers/director.h")
-
-        node = e.namespace "director"
-
-        # As director is pretty complicated to get right
-        # automatically for now, we force-specify which
-        # classes to have directors set on.
-        %w(Worker MultiplyWorker BadNameClass VirtualWithArgs NoConstructor VBase VOne VTwo).each do |k|
-          node.classes(k).director
-        end
-
-        node.classes("Worker").methods("doProcessImpl").default_return_value(0)
-
-        klass = node.classes("BadNameClass")
-        klass.wrap_as("BetterNamedClass")
-        klass.methods("_is_x_ok_to_run").wrap_as("x_ok?")
-        klass.methods("__do_someProcessing").wrap_as("do_processing")
+  before(:all) do
+    Extension.new "director" do |e|
+      e.sources full_dir("headers/director.h")
+
+      node = e.namespace "director"
+
+      # As director is pretty complicated to get right
+      # automatically for now, we force-specify which
+      # classes to have directors set on.
+      %w(Worker MultiplyWorker BadNameClass VirtualWithArgs NoConstructor VBase VOne VTwo).each do |k|
+        node.classes(k).director
       end
 
-      require 'director'
+      node.classes("Worker").methods("doProcessImpl").default_return_value(0)
+
+      klass = node.classes("BadNameClass")
+      klass.wrap_as("BetterNamedClass")
+      klass.methods("_is_x_ok_to_run").wrap_as("x_ok?")
+      klass.methods("__do_someProcessing").wrap_as("do_processing")
     end
+
+    require 'director'
   end
 
   specify "polymorphic calls extend into Ruby" do
@@ -40,7 +36,7 @@ context "Director proxy generation" do
     h = Handler.new
     h.add_worker(MyWorker.new)
 
-    h.process_workers(5).should.equal 15
+    h.process_workers(5).should == 15
   end
 
   specify "super calls on pure virtual raise exception" do
@@ -50,9 +46,9 @@ context "Director proxy generation" do
       end
     end
 
-    should.raise NotImplementedError do
+    lambda do
       SuperBadWorker.new.process(10)
-    end
+    end.should raise_error(NotImplementedError)
   end
 
   specify "allows super calls to continue back into C++ classes" do
@@ -62,9 +58,9 @@ context "Director proxy generation" do
       end
     end
 
-    should.not.raise NotImplementedError do
-      SuperGoodWorker.new.do_something(10).should.equal 50
-    end
+    lambda do
+      SuperGoodWorker.new.do_something(10).should == 50
+    end.should_not raise_error(NotImplementedError)
   end
 
   specify "can specify a default return value in the wrapper" do
@@ -79,25 +75,25 @@ context "Director proxy generation" do
     end
 
     w = MyAwesomeWorker.new
-    w.do_process(3).should.equal 10
+    w.do_process(3).should == 10
 
     h = Handler.new
     h.add_worker(w)
 
-    h.process_workers(10).should.equal 18
+    h.process_workers(10).should == 18
   end
 
   specify "properly adds all constructor arguments" do
     v = VirtualWithArgs.new 14, true
-    v.process_a("hi").should.equal 16
-    v.process_b.should.be true
+    v.process_a("hi").should == 16
+    v.process_b.should be_true
   end
 
   specify "takes into account renamed methods / classes" do
     c = BetterNamedClass.new
-    assert !c.x_ok?
+    c.x_ok?.should_not be_true
 
-    c.do_processing.should.equal 14
+    c.do_processing.should == 14
   end
 
   specify "handles no constructors" do
@@ -105,7 +101,7 @@ context "Director proxy generation" do
     end
 
     n = MyThing.new
-    n.do_something.should.equal 4
+    n.do_something.should == 4
   end
 
   specify "only builds method wrappers for virtual methods" do
@@ -117,13 +113,13 @@ context "Director proxy generation" do
 
     # Super calls still work
     w = NumberWorker.new
-    w.get_number.should.equal 27
+    w.get_number.should == 27
 
     # But polymorphism stops in the C++
     h = Handler.new
     h.add_worker(w)
 
-    h.add_worker_numbers.should.equal 12
+    h.add_worker_numbers.should == 12
   end
 
   specify "Directors implement all pure virtual methods up the inheritance tree" do
@@ -131,21 +127,22 @@ context "Director proxy generation" do
     v1 = VOne.new
     v2 = VTwo.new
 
-    v1.method_one.should.equal "methodOne"
+    v1.method_one.should == "methodOne"
 
-    should.raise NotImplementedError do
+    lambda do
       v1.method_two
-    end
-    should.raise NotImplementedError do
+    end.should raise_error(NotImplementedError)
+
+    lambda do
       v1.method_three
-    end
+    end.should raise_error(NotImplementedError)
 
-    v2.method_one.should.equal "methodOne"
-    v2.method_two.should.equal "methodTwo"
+    v2.method_one.should == "methodOne"
+    v2.method_two.should == "methodTwo"
 
-    should.raise NotImplementedError do
+    lambda do
       v2.method_three
-    end
+    end.should raise_error(NotImplementedError)
   end
 
   specify "handles superclasses of the class with virtual methods" do
@@ -158,21 +155,22 @@ context "Director proxy generation" do
     h = Handler.new
 
     h.add_worker(MultiplyWorker.new)
-    h.process_workers(5).should.equal 10
+    h.process_workers(5).should == 10
 
     h.add_worker(QuadWorker.new)
-    h.process_workers(5).should.equal 40
+    h.process_workers(5).should == 40
   end
 
   specify "multiple files writer properly handles directors and nested nodes" do
-    assert defined?(Worker::ZeeEnum)
-    assert defined?(Worker::ZeeEnum::VALUE)
-    Worker::ZeeEnum::VALUE.to_i.should.equal 4
+    lambda { Worker::ZeeEnum }.should_not raise_error(NameError)
+    lambda { Worker::ZeeEnum::VALUE }.should_not raise_error(NameError)
+
+    Worker::ZeeEnum::VALUE.to_i.should == 4
   end
 
   specify "inheritance types are registered properly" do
     two = VTwo.new
-    VBase::process(two).should.equal "methodTwo"
+    VBase::process(two).should == "methodTwo"
   end
 
 end

data/test/enumerations_test.rb

@@ -1,27 +1,23 @@
 require 'test_helper'
 
-context "Wrapping enumerations" do
-
-  def setup
-    if !defined?(@@enums_built)
-      super
-      @@enums_built = true 
-      Extension.new "enums" do |e|
-        e.sources full_dir("headers/enums.h")
-        e.namespace "enums"
-        e.writer_mode :single
-
-        e.module "Mod" do |m|
-          m.namespace "inner"
-        end
-      end
+describe "Wrapping enumerations" do
+
+  before(:all) do
+    Extension.new "enums" do |e|
+      e.sources full_dir("headers/enums.h")
+      e.namespace "enums"
+      e.writer_mode :single
 
-      require 'enums'
+      e.module "Mod" do |m|
+        m.namespace "inner"
+      end
     end
+
+    require 'enums'
   end
 
   specify "should wrap up enums properly" do
-    assert defined?(TestEnum)
+    lambda { TestEnum }.should_not raise_error(NameError)
 
     TestEnum::VALUE1.to_i.should == 0
     TestEnum::VALUE2.to_i.should == 1
@@ -29,12 +25,12 @@ context "Wrapping enumerations" do
   end
   
   specify "should only wrap public enums" do
-    assert !defined?(Tester::NotWrapped)
-    assert !defined?(Tester::AlsoNotWrapped)
+    lambda { Tester::NotWrapped }.should raise_error(NameError)
+    lambda { Tester::AlsoNotWrapped }.should raise_error(NameError)
   end
 
   specify "should wrap up enumerations at proper nesting" do
-    assert defined?(Tester::MyEnum)
+    lambda { Tester::TestEnum }.should_not raise_error(NameError)
 
     Tester::MyEnum::I_LIKE_MONEY.to_i.should == 3
     Tester::MyEnum::YOU_LIKE_MONEY_TOO.to_i.should == 4
@@ -42,7 +38,7 @@ context "Wrapping enumerations" do
   end
 
   specify "should work in user-defined modules" do
-    assert defined?(Mod::InnerEnum)
+    lambda { Mod::InnerEnum }.should_not raise_error(NameError)
 
     Mod::InnerEnum::INNER_1.to_i.should == 0
     Mod::InnerEnum::INNER_2.to_i.should == 1
@@ -52,9 +48,9 @@ context "Wrapping enumerations" do
     what_test_enum(TestEnum::VALUE1).should == "We gots enum 0";
 
     # Types should be adhered to
-    should.raise RuntimeError do
+    lambda do
       what_test_enum(Mod::InnerEnum::INNER_1)
-    end
+    end.should raise_error(RuntimeError)
 
     t = Tester.new
     t.get_enum_description(Tester::MyEnum::YOU_LIKE_MONEY_TOO).should == "You like money!"
@@ -67,26 +63,26 @@ context "Wrapping enumerations" do
   end
 
   specify "anonymous enumerations' values are added as constants to the parent class" do
-    assert defined?(Tester::ANON_ENUM_VAL1)
-    assert defined?(Tester::ANON_ENUM_VAL2)
-    assert defined?(Tester::ANON_ENUM_VAL3)
-    assert defined?(Tester::ANON_ENUM_VAL4)
-
-    Tester::ANON_ENUM_VAL1.should.equal 1
-    Tester::ANON_ENUM_VAL2.should.equal 2
-    Tester::ANON_ENUM_VAL3.should.equal 5
-    Tester::ANON_ENUM_VAL4.should.equal 3
+    lambda { Tester::ANON_ENUM_VAL1 }.should_not raise_error(NameError)
+    lambda { Tester::ANON_ENUM_VAL2 }.should_not raise_error(NameError)
+    lambda { Tester::ANON_ENUM_VAL3 }.should_not raise_error(NameError)
+    lambda { Tester::ANON_ENUM_VAL4 }.should_not raise_error(NameError)
+
+    Tester::ANON_ENUM_VAL1.should == 1
+    Tester::ANON_ENUM_VAL2.should == 2
+    Tester::ANON_ENUM_VAL3.should == 5
+    Tester::ANON_ENUM_VAL4.should == 3
   end
 
   specify "top-level anonymous enumerations' values are added to the global scope" do
-    assert defined?(OUTER_ANON_1)
-    assert defined?(OUTER_ANON_2)
-    assert defined?(FOURTY_TWO)
-    assert defined?(SEPERATE_OUTER_VALUE)
-
-    OUTER_ANON_1.should.equal 0
-    OUTER_ANON_2.should.equal 1
-    FOURTY_TWO.should.equal 42
-    SEPERATE_OUTER_VALUE.should.equal 14
+    lambda { OUTER_ANON_1 }.should_not raise_error(NameError)
+    lambda { OUTER_ANON_2 }.should_not raise_error(NameError)
+    lambda { FOURTY_TWO }.should_not raise_error(NameError)
+    lambda { SEPERATE_OUTER_VALUE }.should_not raise_error(NameError)
+
+    OUTER_ANON_1.should == 0
+    OUTER_ANON_2.should == 1
+    FOURTY_TWO.should == 42
+    SEPERATE_OUTER_VALUE.should == 14
   end
 end

data/test/extension_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-context "Ruby Extension creation" do
+describe "Ruby Extension creation" do
 
   specify "should create a valid Ruby extension" do
     Extension.new "ext_test" do |e|
@@ -8,9 +8,9 @@ context "Ruby Extension creation" do
       e.writer_mode :single
     end
 
-    should.not.raise LoadError do
-      require("ext_test")
-    end
+    lambda do
+      require "ext_test"
+    end.should_not raise_error(LoadError)
   end
 
   specify "should create a valid Ruby extension without a block" do
@@ -22,13 +22,13 @@ context "Ruby Extension creation" do
     e.write
     e.compile
 
-    should.not.raise LoadError do
-      require("ext_test")
-    end
+    lambda do
+      require "ext_test"
+    end.should_not raise_error(LoadError)
   end
 
   specify "should properly build working dir as deep as needed" do
-    should.not.raise Errno::ENOENT do
+    lambda do
       path = File.join(File.expand_path(File.dirname(__FILE__)), "generated", "path1", "path2")
       Extension.new "extension" do |e|
         e.sources full_dir("headers/empty.h")
@@ -36,8 +36,8 @@ context "Ruby Extension creation" do
         e.writer_mode :single
       end
 
-      assert File.exists?(File.join(path, "extconf.rb"))
-    end
+      File.exists?(File.join(path, "extconf.rb")).should be_true
+    end.should_not raise_error(Errno::ENOENT)
   end
 end
 

data/test/file_writers_test.rb

@@ -1,8 +1,8 @@
 require 'test_helper'
 
-context "Multiple file writer (default)" do
+describe "Multiple file writer (default)" do
 
-  setup do
+  before(:each) do
     @working_dir = File.expand_path(File.dirname(__FILE__) + "/generated")
 
     e = Extension.new "adder"
@@ -20,7 +20,7 @@ context "Multiple file writer (default)" do
 
   specify "should properly split up code into multiple files" do
     files = Dir["#{@working_dir}/*"]
-    files.size.should == 12
+    files.size.should == 10
 
     %w(
       extconf.rb
@@ -32,28 +32,24 @@ context "Multiple file writer (default)" do
       _classes_IntAdder.rb.hpp
       _classes_ShouldFindMe.rb.hpp
       _classes_ShouldFindMe.rb.cpp
-      _rbpp_custom.rb.hpp
-      _rbpp_custom.rb.cpp
       adder.rb.cpp
     ).each do |wants|
-      assert_not_nil files.find {|got| File.basename(got) == wants }, "Didn't find #{wants}"
+      files.find {|got| File.basename(got) == wants }.should_not be_nil
     end
   end
 
 end
 
-context "Multiple file writer with to_from_ruby" do
+describe "Multiple file writer works with global _rbpp_custom" do
 
-  setup do
+  before(:each) do
     @working_dir = File.expand_path(File.dirname(__FILE__) + "/generated")
 
-    e = Extension.new "to_from_ruby"
+    e = Extension.new "enums"
     e.working_dir = @working_dir
-    e.sources full_dir("headers/to_from_ruby.h"),
-      :include_paths => full_dir("headers"),
-      :include_source_files => full_dir("headers/to_from_ruby_source.cpp")
+    e.sources full_dir("headers/enums.h")
 
-    e.namespace "to_from_ruby"
+    e.namespace "enums"
 
     e.build
     e.write
@@ -67,15 +63,15 @@ context "Multiple file writer with to_from_ruby" do
       _rbpp_custom.rb.hpp
       _rbpp_custom.rb.cpp
     ).each do |wants|
-      assert_not_nil files.find {|got| File.basename(got) == wants }, "Didn't find #{wants}"
+      files.find {|got| File.basename(got) == wants }.should_not be_nil
     end
   end
 
 end
 
-context "Single file writer" do
+describe "Single file writer" do
 
-  setup do
+  before(:each) do
     @working_dir = File.expand_path(File.dirname(__FILE__) + "/generated")
 
     e = Extension.new "adder"
@@ -99,15 +95,15 @@ context "Single file writer" do
       extconf.rb
       adder.rb.cpp
     ).each do |wants|
-      assert_not_nil files.find {|got| File.basename(got) == wants }, "Didn't find #{wants}"
+      files.find {|got| File.basename(got) == wants }.should_not be_nil
     end
   end
 
 end
 
-context "Single file writer with to_from_ruby" do
+describe "Single file writer with to_from_ruby" do
 
-  setup do
+  before(:each) do
     Extension.new "to_from_ruby" do |e|
       e.sources full_dir("headers/to_from_ruby.h"),
         :include_paths => full_dir("headers"),
@@ -120,8 +116,8 @@ context "Single file writer with to_from_ruby" do
   end
 
   specify "should have compiled properly" do
-    should.not.raise LoadError do
+    lambda do
       require 'to_from_ruby'
-    end
+    end.should_not raise_error(LoadError)
   end
 end

data/test/function_pointer_test.rb

@@ -1,18 +1,14 @@
 require 'test_helper'
 
-context "properly handles and wraps function pointer arguments" do
-
-  def setup
-    if !defined?(@@function_pointers)
-      super
-      @@function_pointers = true 
-      Extension.new "function_pointers" do |e|
-        e.sources full_dir("headers/function_pointers.h")
-        node = e.namespace "function_pointers"
-      end
-
-      require 'function_pointers'
+describe "properly handles and wraps function pointer arguments" do
+
+  before(:all) do
+    Extension.new "function_pointers" do |e|
+      e.sources full_dir("headers/function_pointers.h")
+      node = e.namespace "function_pointers"
     end
+
+    require 'function_pointers'
   end
 
   specify "no arguments, no return" do
@@ -24,7 +20,7 @@ context "properly handles and wraps function pointer arguments" do
 
     call_callback
 
-    assert proc_called
+    proc_called.should be_true
   end
 
   specify "arguments, no return" do

data/test/function_pointers_classes_test.rb

@@ -1,18 +1,14 @@
 require 'test_helper'
 
-context "Function pointers into class methods" do
+describe "Function pointers into class methods" do
 
-  def setup
-    if !defined?(@@function_pointers_class)
-      super
-      @@function_pointers_class = true 
-      Extension.new "function_pointers_class" do |e|
-        e.sources full_dir("headers/function_pointers_class.h")
-        node = e.namespace "function_pointers_class"
-      end
-
-      require 'function_pointers_class'
+  before(:all) do
+    Extension.new "function_pointers_class" do |e|
+      e.sources full_dir("headers/function_pointers_class.h")
+      node = e.namespace "function_pointers_class"
     end
+
+    require 'function_pointers_class'
   end