rbgccxml 0.9.1 → 1.0

data/test/functions_test.rb

@@ -1,49 +1,49 @@
 require "test_helper"
 
-context "Querying for functions" do
+describe "Querying for functions" do
 
-  setup do
-    @@functions_source ||= RbGCCXML.parse(full_dir("headers/functions.h")).namespaces("functions")
+  before(:all) do
+    @functions_source = RbGCCXML.parse(full_dir("headers/functions.h")).namespaces("functions")
   end
 
   specify "should be able to find all functions" do
-    @@functions_source.functions.length.should == 4
+    @functions_source.functions.length.should == 4
   end
 
   specify "can find functions by name" do
     # Short-hand finding does #find(:name => "")
-    test1 = @@functions_source.functions("test1")
-    test1.should.be.a.kind_of RbGCCXML::Function
+    test1 = @functions_source.functions("test1")
+    test1.should be_a_kind_of(RbGCCXML::Function)
     test1.name.should == "test1"
 
-    bool = @@functions_source.functions.find(:name => "bool_method")
-    bool.should.be.a.kind_of RbGCCXML::Function
+    bool = @functions_source.functions.find(:name => "bool_method")
+    bool.should be_a_kind_of(RbGCCXML::Function)
     bool.name.should == "bool_method"
   end
 
   specify "should not have a classes finder" do
-    test1 = @@functions_source.functions("test1")
-    should.raise RbGCCXML::NotQueryableException do
+    test1 = @functions_source.functions("test1")
+    lambda do
       test1.classes  
-    end
+    end.should raise_error(RbGCCXML::NotQueryableException)
   end
 
   specify "should not have a namespaces finder" do
-    test1 = @@functions_source.functions("test1")
-    should.raise RbGCCXML::NotQueryableException do
+    test1 = @functions_source.functions("test1")
+    lambda do
       test1.namespaces
-    end
+    end.should raise_error(RbGCCXML::NotQueryableException)
   end
 
   specify "should not have a functions finder" do
-    test1 = @@functions_source.functions("test1")
-    should.raise RbGCCXML::NotQueryableException do
-      test1.functions  
-    end
+    test1 = @functions_source.functions("test1")
+    lambda do
+      test1.functions
+    end.should raise_error(RbGCCXML::NotQueryableException)
   end
 
   specify "can get list of arguments" do
-    test1 = @@functions_source.functions("test1")
-    test1.arguments.length.should.equal 2
+    test1 = @functions_source.functions("test1")
+    test1.arguments.length.should == 2
   end
 end

data/test/methods_test.rb

@@ -1,42 +1,43 @@
 require "test_helper"
 
-context "Querying for class methods" do
-  setup do
-    @@adder_source ||= RbGCCXML.parse(full_dir("headers/Adder.h")).namespaces("classes")
+describe "Querying for class methods" do
+  before(:all) do
+    @adder_source = RbGCCXML.parse(full_dir("headers/Adder.h")).namespaces("classes")
   end
 
   specify "should be able to get the methods on a class" do
-    adder = @@adder_source.classes.find(:name => "Adder")
+    adder = @adder_source.classes.find(:name => "Adder")
     methods = adder.methods
 
     methods.size.should == 4
-    methods[0].name.should == "addIntegers"
-    methods[1].name.should == "addFloats"
-    methods[2].name.should == "addStrings"
-    methods[3].name.should == "getClassName"
+    found = methods.sort {|a, b| a.name <=> b.name}
+    found[0].name.should == "addFloats"
+    found[1].name.should == "addIntegers"
+    found[2].name.should == "addStrings"
+    found[3].name.should == "getClassName"
   end
 
   # The following are simplistic. functions_test tests the
   # finder options much more completely. This is just to test
   # that it works on Method objects fine
   specify "should be able to get methods by name" do
-    adder = @@adder_source.classes("Adder")
+    adder = @adder_source.classes("Adder")
     adder.methods("addIntegers").name.should == "addIntegers"
     adder.methods.find(:name => "addStrings").name.should == "addStrings"
   end
 
   specify "can search methods via arguments" do
-    adder = @@adder_source.classes("Adder")
+    adder = @adder_source.classes("Adder")
     adder.methods.find(:arguments => [:int, :int]).name.should == "addIntegers"
   end
 
   specify "can search methods via return type" do
-    adder = @@adder_source.classes("Adder")
+    adder = @adder_source.classes("Adder")
     adder.methods.find(:returns => :float).name.should == "addFloats"
   end
 
   specify "can search via all options (AND)" do
-    adder = @@adder_source.classes("Adder")
+    adder = @adder_source.classes("Adder")
     got = adder.methods.find(:returns => :int, :arguments => [nil, nil])
     got.name.should == "addIntegers"
   end
@@ -44,27 +45,27 @@ context "Querying for class methods" do
 end
 
 context "Properties on Methods" do
-  setup do
-    @@classes_source ||= RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
+  before(:all) do
+    @classes_source = RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
   end
 
   specify "should be able to tell if a given method is static or not" do
-    test1 = @@classes_source.classes("Test1")
-    assert test1.methods("staticMethod").static?
+    test1 = @classes_source.classes("Test1")
+    test1.methods("staticMethod").should be_static
 
-    test2 = @@classes_source.classes.find(:name => "Test2")
-    assert !test2.methods("func1").static?
+    test2 = @classes_source.classes.find(:name => "Test2")
+    test2.methods("func1").should_not be_static
   end
 
   specify "should be able to tell if a given method is virtual or not" do
-    test4 = @@classes_source.classes("Test4")
-    assert test4.methods("func1").virtual?
-    assert !test4.methods("func1").purely_virtual?
+    test4 = @classes_source.classes("Test4")
+    test4.methods("func1").should be_virtual
+    test4.methods("func1").should_not be_purely_virtual
     
-    assert test4.methods("func2").virtual?
-    assert !test4.methods("func2").purely_virtual?
+    test4.methods("func2").should be_virtual
+    test4.methods("func2").should_not be_purely_virtual
     
-    assert test4.methods("func3").virtual?
-    assert test4.methods("func3").purely_virtual?
+    test4.methods("func3").should be_virtual
+    test4.methods("func3").should be_purely_virtual
   end
 end

data/test/namespaces_test.rb

@@ -1,25 +1,25 @@
 require "test_helper"
 
-context "Querying for namespaces" do
+describe "Querying for namespaces" do
 
-  setup do
+  before do
     @source ||= RbGCCXML.parse(full_dir("headers/namespaces.h"))
   end
 
   specify "can find a namespace" do
     upper = @source.namespaces.find(:name => "upper")
-    upper.should.be.a.kind_of RbGCCXML::Namespace
+    upper.should be_a_kind_of(RbGCCXML::Namespace)
 
     inner1 = upper.namespaces("inner1")
-    inner1.should.be.a.kind_of RbGCCXML::Namespace
+    inner1.should be_a_kind_of(RbGCCXML::Namespace)
     inner1.name.should == "inner1"
 
     inner2 = upper.namespaces("inner2")
-    inner2.should.be.a.kind_of RbGCCXML::Namespace
+    inner2.should be_a_kind_of(RbGCCXML::Namespace)
     inner2.name.should == "inner2"
 
     nested = inner2.namespaces("nested")
-    nested.should.be.a.kind_of RbGCCXML::Namespace
+    nested.should be_a_kind_of(RbGCCXML::Namespace)
     nested.name.should == "nested"
   end
 end

data/test/node_test.rb

@@ -1,6 +1,6 @@
 require "test_helper"
 
-context "Qualified name generation" do
+describe "Qualified name generation" do
 
   specify "for namespaces" do
     source = RbGCCXML.parse(full_dir("headers/namespaces.h"))
@@ -41,25 +41,25 @@ context "Qualified name generation" do
 
 end
 
-context "Misc access methods" do
+describe "Misc access methods" do
 
   specify "can tell if something is public, protected, and private" do
     source = RbGCCXML.parse(full_dir("headers/misc.h"))
     access = source.namespaces("misc").classes("AccessSettings")
 
-    assert access.methods("privateMethod").private?
-    assert access.methods("protectedMethod").protected?
-    assert access.methods("publicMethod").public?
+    access.methods("privateMethod").should be_private
+    access.methods("protectedMethod").should be_protected
+    access.methods("publicMethod").should be_public
   end
 
   specify "can get the full file path of a node" do
     source = RbGCCXML.parse(full_dir("headers/enums.h")).namespaces("enums")
-    source.enumerations("TestEnum").file.should =~ "enums.h"
+    source.enumerations("TestEnum").file.should match(%r{enums.h})
   end
 
   specify "returns nil if no file node is found" do
     source = RbGCCXML.parse(full_dir("headers/enums.h")).namespaces("enums")
-    source.file.should.be nil
+    source.file.should be_nil
   end
 
 end

data/test/parser_test.rb

@@ -1,73 +1,73 @@
 require "test_helper"
 
-context "Default parsing configuration" do
+describe "Default parsing configuration" do
 
   specify "can parse a single header file" do
-    should.not.raise do
+    lambda do
       RbGCCXML.parse(full_dir("headers/Adder.h"))
-    end
+    end.should_not raise_error
   end
 
   specify "can parse a glob" do
-    should.not.raise do
+    lambda do
       RbGCCXML.parse(full_dir("headers/*.hpp"))
-    end
+    end.should_not raise_error
   end
 
   specify "can parse all files in a directory" do
-    should.not.raise do
+    lambda do
       RbGCCXML.parse(full_dir("headers"),
                     :includes => full_dir("headers/include"),
                     :cxxflags => "-DMUST_BE_DEFINED")
-    end
+    end.should_not raise_error
   end
 
   specify "can take an array of files" do
     files = [full_dir("headers/Adder.h"),
               full_dir("headers/Subtracter.hpp")]
-    should.not.raise do
+    lambda do
       RbGCCXML.parse(files)
-    end
+    end.should_not raise_error
   end
 
   specify "can take an array of globs" do
     files = [full_dir("headers/*.h"),
               full_dir("headers/*.hpp")]
-    should.not.raise do
+    lambda do
       RbGCCXML.parse(files, :includes => full_dir("headers/include"))
-    end
+    end.should_not raise_error
   end
 
   specify "should throw an error if files aren't found" do
-    should.raise RbGCCXML::SourceNotFoundError do
+    lambda do
       RbGCCXML.parse(full_dir("headers/Broken.hcc"))
-    end
+    end.should raise_error(RbGCCXML::SourceNotFoundError)
 
-    should.raise RbGCCXML::SourceNotFoundError do
+    lambda do
       RbGCCXML.parse(full_dir("hockers"))
-    end
+    end.should raise_error(RbGCCXML::SourceNotFoundError)
 
-    should.raise RbGCCXML::SourceNotFoundError do
+    lambda do
       RbGCCXML.parse(full_dir("something/*"))
-    end
+    end.should raise_error(RbGCCXML::SourceNotFoundError)
 
-    should.raise RbGCCXML::SourceNotFoundError do
+    lambda do
       RbGCCXML.parse([full_dir("something/*"), full_dir("anotherthing/*")])
-    end
+    end.should raise_error(RbGCCXML::SourceNotFoundError)
   end
 end
 
-context "Configurable parsing configuration" do
+describe "Configurable parsing configuration" do
   specify "can give extra include directories for parsing" do
     found = RbGCCXML.parse full_dir("headers/with_includes.h"),
       :includes => full_dir("headers/include")
-    found.namespaces("code").should.not.be.nil
+    found.namespaces("code").should_not be_nil
   end
 
   specify "can be given extra cxxflags for parsing" do
-    should.not.raise do
+    lambda do
       RbGCCXML.parse full_dir("headers/requires_define.hxx"),
         :cxxflags => "-DMUST_BE_DEFINED"
-    end
+    end.should_not raise_error
   end
 end

data/test/query_results_test.rb

@@ -1,6 +1,6 @@
 require "test_helper"
 
-context "Managing Query results" do
+describe "Managing Query results" do
 
   class MyObj
     attr_accessor :call_me_called, :other_thingy_called
@@ -21,161 +21,164 @@ context "Managing Query results" do
     q = RbGCCXML::QueryResult.new  
     q << obj1 << obj2
 
-    should.not.raise NoMethodError do
+    lambda do
       q.call_me
       q.other_thingy
-    end
+    end.should_not raise_error(NoMethodError)
 
-    assert obj1.call_me_called
-    assert obj1.other_thingy_called
+    obj1.call_me_called.should_not be_nil
+    obj1.other_thingy_called.should_not be_nil
 
-    assert obj2.call_me_called
-    assert obj2.other_thingy_called
+    obj2.call_me_called.should_not be_nil
+    obj2.other_thingy_called.should_not be_nil
 
-    should.raise NoMethodError do
+    lambda do
       q.not_here
-    end
+    end.should raise_error(NoMethodError)
   end
 
   specify "should throw appropriately with an empty result set" do
-    should.raise NoMethodError do
+    lambda do
       RbGCCXML::QueryResult.new.some_method
-    end
+    end.should raise_error(NoMethodError)
   end
 
   specify "should error out with unknown keys" do
-    should.raise do
+    lambda do
       RbGCCXML::QueryResult.new.find(:key_bad => :hi_mom)
-    end
+    end.should raise_error
   end
 
 end
 
-context "QueryResult#find :name" do
+describe "QueryResult#find :name" do
 
-  setup do
-    @@query_source ||= RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
+  before(:all) do
+    @query_source = RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
   end
 
   specify "can find by regular name" do
-    func = @@query_source.functions.find(:name => "test4")
-    func.should.be.a.kind_of RbGCCXML::Function
+    func = @query_source.functions.find(:name => "test4")
+    func.should be_a_kind_of(RbGCCXML::Function)
     func.name.should == "test4"
   end
 
   specify "can find names by regex" do
-    bool = @@query_source.functions.find(:name => /bool/)
-    bool.should.be.a.kind_of RbGCCXML::Function
+    bool = @query_source.functions.find(:name => /bool/)
+    bool.should be_a_kind_of(RbGCCXML::Function)
     bool.name.should == "bool_method"
   end
 
 end
 
-context "QueryResult#find :arguments" do
+describe "QueryResult#find :arguments" do
 
-  setup do
-    @@query_source ||= RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
+  before(:all) do
+    @query_source = RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
   end
 
   specify "no arguments" do
-    funcs = @@query_source.functions.find(:arguments => [])
-    assert funcs.detect {|f| f.name == "test1" }
-    assert funcs.detect {|f| f.name == "bool_method" }
+    funcs = @query_source.functions.find(:arguments => [])
+    funcs.detect {|f| f.name == "test1" }.should_not be_nil
+    funcs.detect {|f| f.name == "bool_method" }.should_not be_nil
   end
 
   specify "multiple arguments" do
     # If we find just one result, we get it back
-    func = @@query_source.functions.find(:arguments => [:int])
-    assert func.is_a?(RbGCCXML::Function)
+    func = @query_source.functions.find(:arguments => [:int])
+    func.should be_a_kind_of(RbGCCXML::Function)
     func.name.should == "test2"
 
-    func = @@query_source.functions.find(:arguments => [:int, :float])
-    assert func.is_a?(RbGCCXML::Function)
+    func = @query_source.functions.find(:arguments => [:int, :float])
+    func.should be_a_kind_of(RbGCCXML::Function)
     func.name.should == "test3"
   end
 
   specify "when searching arguments, can xspecify catch-all" do
-    funcs = @@query_source.functions.find(:arguments => [:int, nil])
+    funcs = @query_source.functions.find(:arguments => [:int, nil])
     funcs.size.should == 2
-    assert funcs.detect {|f| f.name == "test3" }
-    assert funcs.detect {|f| f.name == "test4" }
+    funcs.detect {|f| f.name == "test3" }.should_not be_nil
+    funcs.detect {|f| f.name == "test4" }.should_not be_nil
   end
 
   specify "works when using custom defined types" do
-    func = @@query_source.functions.find(:arguments => ["MyType"])
-    func.name.should.equal "testMyTypeArgs"
+    func = @query_source.functions.find(:arguments => ["MyType"])
+    func.name.should == "testMyTypeArgs"
   end
 
   specify "works with pointers and references" do
-    func = @@query_source.functions.find(:arguments => ["MyType*"])
-    func.length.should.equal 2
+    func = @query_source.functions.find(:arguments => ["MyType*"])
+    func.length.should == 2
 
-    func = @@query_source.functions.find(:arguments => ["MyType&"])
+    func = @query_source.functions.find(:arguments => ["MyType&"])
     func.name.should == "testMyTypeArgsRef"
   end
 
   specify "works with qualified names" do
-    func = @@query_source.functions.find(:arguments => ["query::MyType"])
-    func.name.should.equal "testMyTypeArgs"
+    func = @query_source.functions.find(:arguments => ["query::MyType"])
+    func.name.should == "testMyTypeArgs"
 
-    func = @@query_source.functions.find(:arguments => ["::query::MyType"])
-    func.name.should.equal "testMyTypeArgs"
+    func = @query_source.functions.find(:arguments => ["::query::MyType"])
+    func.name.should == "testMyTypeArgs"
   end
 
   specify "works with qualifiers like const" do
-    func = @@query_source.functions.find(:arguments => ["const MyType*"])
+    func = @query_source.functions.find(:arguments => ["const MyType* const"])
+    func.name.should == "testConstMyTypeArgsConstPtr"
+
+    func = @query_source.functions.find(:arguments => ["MyType* const"])
+    func.name.should == "testConstMyTypeArgsConstPtr"
+
+    func = @query_source.functions.find(:arguments => ["const MyType*"])
     func.name.should == "testMyTypeArgsConstPtr"
   end
 end
 
-context "QueryResult#find :returns" do
+describe "QueryResult#find :returns" do
 
-  setup do
-    @@query_source ||= RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
+  before(:all) do
+    @query_source = RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
   end
 
   specify "by return type" do
-    funcs = @@query_source.functions.find(:returns => :void)
-    assert funcs.detect {|f| f.name == "test1" }
-    assert funcs.detect {|f| f.name == "test2" }
-    assert funcs.detect {|f| f.name == "test3" }
+    funcs = @query_source.functions.find(:returns => :void)
+    funcs.detect {|f| f.name == "test1" }.should_not be_nil
+    funcs.detect {|f| f.name == "test2" }.should_not be_nil
+    funcs.detect {|f| f.name == "test3" }.should_not be_nil
   end
 
   specify "works with custom defined types" do
-    func = @@query_source.functions.find(:returns => "MyType")
-    func.length.should.equal 2
+    func = @query_source.functions.find(:returns => "MyType")
+    func.length.should == 2
   end
 
   specify "work with qualified names" do
-    func = @@query_source.functions.find(:returns => "query::MyType")
-    func.length.should.equal 2
+    func = @query_source.functions.find(:returns => "query::MyType")
+    func.length.should == 2
 
-    func = @@query_source.functions.find(:returns => "::query::MyType")
-    func.length.should.equal 2
+    func = @query_source.functions.find(:returns => "::query::MyType")
+    func.length.should == 2
   end
 
   specify "works with pointers and references" do
-    func = @@query_source.functions.find(:returns => "MyType*")
+    func = @query_source.functions.find(:returns => "MyType*")
     func.name.should == "testMyTypePtr"
 
-    func = @@query_source.functions.find(:returns => "MyType&")
+    func = @query_source.functions.find(:returns => "MyType&")
     func.name.should == "testMyTypeRef"
   end
 
   specify "works with type modifiers (const)" do
-    func = @@query_source.functions.find(:returns => "const MyType")
+    func = @query_source.functions.find(:returns => "const MyType")
     func.name.should == "testMyTypeConst"
   end
 end
 
-context "QueryResult#find access type" do
-
-  setup do
-    @@query_source ||= RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
-  end
+describe "QueryResult#find access type" do
 
   specify "can find according to public / private / protected" do
-    klass = @@query_source.classes("AccessTester")
+    @query_source = RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
+    klass = @query_source.classes("AccessTester")
     m = klass.methods.find(:access => :public)
     m.name.should == "publicMethod"
 
@@ -188,42 +191,39 @@ context "QueryResult#find access type" do
 
 end
 
-context "QueryResult#find multiple options" do
-
-  setup do
-    @@query_source ||= RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
-  end
+describe "QueryResult#find multiple options" do
 
   specify "by both return type and arguments (AND form, not OR)" do
-    func = @@query_source.functions.find(:returns => :int, :arguments => [nil, nil])
-    assert func.is_a?(RbGCCXML::Function)
+    @query_source = RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
+    func = @query_source.functions.find(:returns => :int, :arguments => [nil, nil])
+    func.should be_a_kind_of(RbGCCXML::Function)
     func.name.should == "test4"
   end
 
 end
 
-context "QueryResult#find :all - Flag full source search" do
+describe "QueryResult#find :all - Flag full source search" do
 
-  setup do
-    @@query_source ||= RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
+  before(:all) do
+    @query_source = RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
   end
 
   specify "can find all :names regardless of nesting" do
-    func = @@query_source.functions.find(:all, :name => "nestedFunction")
+    func = @query_source.functions.find(:all, :name => "nestedFunction")
     func.name.should == "nestedFunction"
   end
 
   specify "can find according to :arguments" do
-    func = @@query_source.functions.find(:all, :arguments => ["MyType", "MyType"])
+    func = @query_source.functions.find(:all, :arguments => ["MyType", "MyType"])
     func.name.should == "nestedMyTypeArg"
   end
   
   specify "can find according to :returns " do
-    funcs = @@query_source.functions.find(:all, :returns => "MyType")
+    funcs = @query_source.functions.find(:all, :returns => "MyType")
     funcs.size.should == 3
-    assert funcs.detect {|f| f.name == "nestedMyTypeReturns"}
-    assert funcs.detect {|f| f.name == "testMyType"}
-    assert funcs.detect {|f| f.name == "testMyTypeConst"}
+    funcs.detect {|f| f.name == "nestedMyTypeReturns"}.should_not be_nil
+    funcs.detect {|f| f.name == "testMyType"}.should_not be_nil
+    funcs.detect {|f| f.name == "testMyTypeConst"}.should_not be_nil
   end
 
 end