aquarium 0.1.0

data/spec/aquarium/finders/finder_result_spec.rb

@@ -0,0 +1,359 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require File.dirname(__FILE__) + '/../spec_example_classes'
+
+require 'aquarium/finders/finder_result'
+require 'aquarium/extensions/set'
+
+describe Aquarium::Finders::FinderResult, "#initialize" do
+  before do
+    @empty_set = Set.new
+  end
+
+  it "should create an empty finder result when no parameters are specified." do
+    result = Aquarium::Finders::FinderResult.new
+    result.matched.should == {}
+    result.not_matched.should == {}
+    result.empty?.should be_true
+  end
+  
+  it "should accept a value for the :not_matched parameter and convert it into a hash with the input value as the key and an empty set as the corresponding value" do
+    result = Aquarium::Finders::FinderResult.new :not_matched => :b
+    result.not_matched.should == {:b => @empty_set}
+  end
+  
+  it "should accept an array for the :not_matched parameter and convert it into a hash with the array values as the keys and empty sets as the corresponding values" do
+    result = Aquarium::Finders::FinderResult.new :not_matched => [:a, :b]
+    result.not_matched.should == {:a => @empty_set, :b => @empty_set}
+  end
+  
+  it "should accept a hash for the :not_matched parameter and convert the values in the hashd into sets, if necessary." do
+    result = Aquarium::Finders::FinderResult.new :not_matched => {:a => 'a', :b => 'b'}
+    result.not_matched.should == {:a => Set.new(['a']), :b => Set.new(['b'])}
+  end
+end  
+
+describe Aquarium::Finders::FinderResult, "#empty?" do
+  it "should be true if there are no matches." do
+    result = Aquarium::Finders::FinderResult.new
+    result.matched.should == {}
+    result.not_matched.should == {}
+    result.empty?.should be_true
+  end
+
+  it "should be true if there are no matches, even if there are not_matched values." do
+    result = Aquarium::Finders::FinderResult.new :not_matched => [:a, :b]
+    result.matched.should == {}
+    empty_set = Set.new
+    result.not_matched.should == {:a => empty_set, :b => empty_set}
+    result.empty?.should be_true
+  end
+end
+
+describe Aquarium::Finders::FinderResult, "#not_matched" do
+  before do
+    @empty_set = Set.new
+  end
+  
+  it "should return an empty hash for a default finder result." do
+    Aquarium::Finders::FinderResult.new.not_matched.should == {}
+  end
+
+  it "should return an empty hash if all the specified search items matched." do
+    result = Aquarium::Finders::FinderResult.new String =>["a", "b"], Hash => {:a => 'a'}
+    result.not_matched.should == {}
+  end
+
+  it "should return a hash containing as keys the items specified with the :not_matched key in the input hash and empty sets as the corresponding values in the hash." do
+    result = Aquarium::Finders::FinderResult.new :not_matched =>[String, Hash]
+    result.not_matched.size == 2
+    result.not_matched[String].should == @empty_set
+    result.not_matched[Hash].should == @empty_set
+  end
+end
+
+describe Aquarium::Finders::FinderResult, "#not_matched_keys" do
+  it "should return an empty array by default." do
+    Aquarium::Finders::FinderResult.new.not_matched_keys.should == []
+  end
+
+  it "should return an empty array if all the specified search items matched." do
+    result = Aquarium::Finders::FinderResult.new String =>["a", "b"], Hash => {:a => 'a'}
+    result.not_matched_keys.should == []
+  end
+
+  it "should return an array containing the items specified with the :not_matched key in the input hash." do
+    result = Aquarium::Finders::FinderResult.new :not_matched =>[String, Hash]
+    result.not_matched_keys.size == 2
+    result.not_matched_keys.include?(String).should be(true)
+    result.not_matched_keys.include?(Hash).should be(true)
+  end
+end
+
+describe Aquarium::Finders::FinderResult, "#matched" do
+  it "should return an empty hash for a new result." do
+    Aquarium::Finders::FinderResult.new.matched.should == {}
+  end
+
+  it "should return a hash of found search items where the found search items are the keys and arrays of corresponding objects are the corresponding values." do
+    result = Aquarium::Finders::FinderResult.new String => ["a", "b"], Hash => {:a => 'a'}
+    result.matched.size == 2
+    result.matched[String].should == Set.new(["a", "b"])
+    result.matched[Hash].should == Set.new([{:a => 'a'}])
+  end
+end
+
+describe Aquarium::Finders::FinderResult, "#matched_keys" do
+  it "should return an empty array by default." do
+    Aquarium::Finders::FinderResult.new.matched_keys.should == []
+  end
+
+  it "should return an empty array of found search items where the found search items are the keys and arrays of corresponding objects are the corresponding values." do
+    result = Aquarium::Finders::FinderResult.new String => ["a", "b"], Hash => {:a => 'a'}
+    result.matched_keys.size == 2
+    result.matched_keys.include?(String).should be(true)
+    result.matched_keys.include?(Hash).should be(true)
+  end
+end
+
+describe Aquarium::Finders::FinderResult, "#<<" do
+  it "should return self." do
+    result1 = Aquarium::Finders::FinderResult.new
+    result = result1 << Aquarium::Finders::FinderResult.new
+    result.object_id.should be_equal(result1.object_id )
+  end
+  
+  it "should merge the value of the other FinderResult#not_matched into self's not_matched value." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:a => 'a'}
+    result2 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b'}
+    result1 << result2
+    result1.not_matched.should == {:a => Set.new(['a']), :b => Set.new(['b'])}
+  end
+
+  it "should merge the value of the other FinderResult#matched into self's matched value." do
+    result1 = Aquarium::Finders::FinderResult.new :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    result1 << result2
+    result1.matched.should == {:a => Set.new([:a1, :a2]), :b => Set.new([:b1, :b2])}
+  end
+  
+  it "should remove not_matched items when the same item is added to matched items from the right-hand side FinderResult." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => :b3, :c => :c1}, :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    result1 << result2
+    result1.matched.should     == {:a => Set.new([:a1, :a2]), :b => Set.new([:b1, :b2])}
+    result1.not_matched.should == {:b => Set.new([:b3]), :c => Set.new([:c1])}
+  end    
+  
+  it "should remove not_matched items when the same item is added to matched items from the right-hand side FinderResult." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => :b1, :c => :c1}, :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    result1 << result2
+    result1.matched.should == {:a => Set.new([:a1, :a2]), :b => Set.new([:b1, :b2])}
+    result1.not_matched.should == {:b => Set.new([]), :c => Set.new([:c1])}
+  end    
+end
+
+describe "union of finder results", :shared => true do
+  it "should return a FinderResult equal to the second, non-empty FinderResult if the first FinderResult is empty." do
+    result1 = Aquarium::Finders::FinderResult.new
+    result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    result = result1.or result2
+    result.should eql(result2)
+  end
+  
+  it "should return a FinderResult equal to the first, non-empty FinderResult if the second FinderResult is empty." do
+    result1 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    result2 = Aquarium::Finders::FinderResult.new
+    result = result1.or result2
+    result.should eql(result1)
+  end
+  
+  it "should return a FinderResult that is the union of self and the second FinderResult." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b', :c => 'c'}, :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    result = result1.or result2
+    result.matched.should     == {:a => Set.new([:a1, :a2]), :b => Set.new([:b1, :b2])}
+    result.not_matched.should == {:b => Set.new(['b']), :c => Set.new(['c'])}
+  end    
+  
+  it "should be unitary." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b', :c => 'c'}, :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b', :c => 'c'}, :a => [:a1, :a2]
+    result = result1.or result2
+    result.should eql(result1)
+    result.should eql(result2)
+  end    
+
+  it "should be commutative." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b', :c => 'c'}, :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    result12 = result1.or result2
+    result21 = result2.or result1
+    result12.should eql(result21)
+  end    
+
+  it "should be associative." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b', :c => 'c'}, :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    result3 = Aquarium::Finders::FinderResult.new :c => [:c1, :c2]
+    result123a = (result1.or result2).or result3
+    result123b = result1.or(result2.or(result3))
+    result123a.should eql(result123b)
+  end    
+end
+
+describe Aquarium::Finders::FinderResult, "#union" do
+  it_should_behave_like "union of finder results"
+end
+describe Aquarium::Finders::FinderResult, "#or" do
+  it_should_behave_like "union of finder results"
+end
+
+describe "intersection of finder results", :shared => true do
+  it "should return an empty FinderResult if self is empty." do
+    result1 = Aquarium::Finders::FinderResult.new
+    result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    result = result1.and result2
+    result.should eql(result1)
+  end
+  
+  it "should return an empty FinderResult if the second FinderResult is empty." do
+    result1 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    result2 = Aquarium::Finders::FinderResult.new
+    result = result1.and result2
+    result.should eql(result2)
+  end
+  
+  it "should return an empty FinderResult if there is no overlap between the two FinderResults." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => :b3, :c => :c1}, :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    result = result1.and result2
+    result.matched.should     be_empty
+    result.not_matched.should be_empty
+  end    
+
+  it "should return a FinderResult that is the intersection of self and the second FinderResult." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => :b1, :c => :c1}, :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :not_matched => {:b => [:b1, :b2]}, :a => [:a1]
+    result = result1.and result2
+    result.matched.should     == {:a => Set.new([:a1])}
+    result.not_matched.should == {:b => Set.new([:b1])}
+  end    
+  
+  it "should be unitary." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b', :c => 'c'}, :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b', :c => 'c'}, :a => [:a1, :a2]
+    result = result1.and result2
+    result.should eql(result1)
+    result.should eql(result2)
+  end    
+
+  it "should be commutative." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => :b1, :c => :c1}, :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :not_matched => {:b => [:b1, :b2]}, :a => [:a1]
+    result12 = result1.and result2
+    result21 = result2.and result1
+    result12.should eql(result21)
+  end    
+
+  it "should be associative." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => :b1, :c => :c1}, :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :not_matched => {:b => [:b1, :b2]}, :a => [:a1]
+    result3 = Aquarium::Finders::FinderResult.new :not_matched => {:b => [:b1]}, :a => [:a1]
+    result123a = (result1.and result2).and result3
+    result123b = result1.and(result2.and(result3))
+    result123a.should eql(result123b)
+  end    
+end
+
+describe Aquarium::Finders::FinderResult, "#intersection" do
+  it_should_behave_like "intersection of finder results"
+end
+describe Aquarium::Finders::FinderResult, "#and" do
+  it_should_behave_like "intersection of finder results"
+end
+
+describe Aquarium::Finders::FinderResult, "#.append_matched" do
+  it "should not change self, if no arguments are specified." do
+    result1 = Aquarium::Finders::FinderResult.new :a => [:a1, :a2], :b => [:b1, :b2]
+    result1.append_matched 
+    result1.matched.should == {:a => Set.new([:a1, :a2]), :b => Set.new([:b1, :b2])}
+  end
+
+  it "should return the appended data when used with an empty finder result." do
+    result1 = Aquarium::Finders::FinderResult.new
+    result1.append_matched :a => [:a1, :a2], :b => [:b1, :b2]
+    result1.matched.should == {:a => Set.new([:a1, :a2]), :b => Set.new([:b1, :b2])}
+  end
+  
+  it "should append the input hash to the corresponding keys and values." do
+    result1 = Aquarium::Finders::FinderResult.new :a => [:a1, :a2], :b => [:b1, :b2]
+    result1.append_matched :a => [:a3, :a4], :b => [:b3], :c => [:c1, :c2]
+    result1.matched.should == {:a => Set.new([:a1, :a2, :a3, :a4]), :b => Set.new([:b1, :b2, :b3]), :c => Set.new([:c1, :c2])}
+  end
+
+  it "should accept single hash values as well as arrays of values." do
+    result1 = Aquarium::Finders::FinderResult.new :a => [:a1, :a2], :b => [:b1, :b2]
+    result1.append_matched :a => :a3, :b => :b3, :c => :c1
+    result1.matched.should == {:a => Set.new([:a1, :a2, :a3]), :b => Set.new([:b1, :b2, :b3]), :c => Set.new([:c1])}
+  end
+end
+
+describe Aquarium::Finders::FinderResult, "#.append_not_matched" do
+  it "should not change self, by default." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:a => [:a1, :a2], :b => [:b1, :b2]}
+    result1.append_not_matched
+    result1.not_matched.should == {:a => Set.new([:a1, :a2]), :b => Set.new([:b1, :b2])}
+  end
+
+  it "should work with a default (empty) result." do
+    result1 = Aquarium::Finders::FinderResult.new
+    result1.append_not_matched :a => [:a1, :a2], :b => [:b1, :b2]
+    result1.not_matched.should == {:a => Set.new([:a1, :a2]), :b => Set.new([:b1, :b2])}
+  end
+
+  it "should append the input hash to the corresponding keys and values." do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:a => [:a1, :a2], :b => [:b1, :b2]}
+    result1.append_not_matched :a => [:a3, :a4], :b => [:b3], :c => [:c1, :c2]
+    result1.not_matched.should == {:a => Set.new([:a1, :a2, :a3, :a4]), :b => Set.new([:b1, :b2, :b3]), :c => Set.new([:c1, :c2])}
+  end
+end
+
+describe "equality", :shared => true do
+  it "should return true for the same object." do
+    result = Aquarium::Finders::FinderResult.new
+    result.should be_eql(result)
+  end
+
+  it "should return true for two default objects." do
+    result1 = Aquarium::Finders::FinderResult.new
+    result2 = Aquarium::Finders::FinderResult.new
+    result1.should eql(result2)
+  end
+
+  it "should return false for two different objects that are equal and map to the same method." do
+    result1 = Aquarium::Finders::FinderResult.new ExampleParentClass.new => :a
+    result2 = Aquarium::Finders::FinderResult.new ExampleParentClass.new => :a
+    result1.should_not eql(result2)
+  end
+
+  it "should return true if a key has a single value that equals the value in a 1-element array for the same key in the other FinderResult." do
+    result1 = Aquarium::Finders::FinderResult.new :a => 'a',   :not_matched => {:b => 'b'}
+    result2 = Aquarium::Finders::FinderResult.new :a => ['a'], :not_matched => {:b => ['b']}
+    result1.should eql(result2)
+  end
+
+  it "should return false for two objects that are different." do
+    result1 = Aquarium::Finders::FinderResult.new :a => 'a'
+    result2 = Aquarium::Finders::FinderResult.new :b => 'b'
+    result1.should_not eql(result2)
+  end
+end
+
+describe Aquarium::Finders::FinderResult, "#eql?" do
+  it_should_behave_like "equality"
+end
+
+describe Aquarium::Finders::FinderResult, "#==" do
+  it_should_behave_like "equality"
+end

data/spec/aquarium/finders/method_finder_spec.rb

@@ -0,0 +1,878 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require File.dirname(__FILE__) + '/../spec_example_classes'
+require 'aquarium/finders/method_finder'
+
+# :stopdoc:
+class Base
+  def mbase1
+  end
+  def mbase2
+  end
+end
+
+module M
+  def mmodule1
+  end
+  def mmodule2
+  end
+end
+
+class Derived < Base
+  include M
+  def mbase1
+  end
+  def mderived1
+  end
+  def mmodule1
+  end
+  def mmodule3
+  end
+end
+
+# :startdoc:
+
+def common_before
+  @test_classes = [
+    ClassWithPublicInstanceMethod, 
+    ClassWithProtectedInstanceMethod, 
+    ClassWithPrivateInstanceMethod, 
+    ClassWithPublicClassMethod, 
+    ClassWithPrivateClassMethod]
+  @pub = ClassWithPublicInstanceMethod.new
+  @pro = ClassWithProtectedInstanceMethod.new
+  @pri = ClassWithPrivateInstanceMethod.new
+  @cpub = ClassWithPublicClassMethod.new
+  @cpri = ClassWithPrivateClassMethod.new
+  @test_objects = [@pub, @pro, @pri, @cpub, @cpri]
+
+  @other_methods_expected = []
+  @empty_set = Set.new
+end
+
+describe Aquarium::Finders::MethodFinder, "#find (synonymous input parameters)" do
+  before(:each) do
+    common_before
+  end
+  
+  it "should accept options :types and :type, which are synonymous." do
+    expected = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods => [/^mbase/, /^mmodule/]
+    actual   = Aquarium::Finders::MethodFinder.new.find :type  => Derived, :methods => [/^mbase/, /^mmodule/]
+    actual.should == expected
+  end
+
+  it "should accept options :objects and :object, which are synonymous." do
+    child = Derived.new
+    expected = Aquarium::Finders::MethodFinder.new.find :objects => child, :methods => [/^mbase/, /^mmodule/]
+    actual   = Aquarium::Finders::MethodFinder.new.find :object  => child, :methods => [/^mbase/, /^mmodule/]
+    actual.should == expected
+  end
+
+  it "should accept options :methods and :method, which are synonymous." do
+    expected = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods => [/^mbase/, /^mmodule/]
+    actual   = Aquarium::Finders::MethodFinder.new.find :types => Derived, :method  => [/^mbase/, /^mmodule/]
+    actual.should == expected
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (invalid input parameters)" do
+  before(:each) do
+    common_before
+  end
+  
+  it "should raise if unrecognized option specified." do
+    lambda { Aquarium::Finders::MethodFinder.new.find :tpye => "x", :ojbect => "y", :mehtod => "foo"}.should raise_error(Aquarium::Utils::InvalidOptions)
+  end
+  
+  it "should raise if options include :singleton and :class, :public, :protected, or :private." do
+    lambda { Aquarium::Finders::MethodFinder.new.find :type => String, :method => "foo", :options => [:singleton, :class] }.should     raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aquarium::Finders::MethodFinder.new.find :type => String, :method => "foo", :options => [:singleton, :public] }.should    raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aquarium::Finders::MethodFinder.new.find :type => String, :method => "foo", :options => [:singleton, :protected] }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aquarium::Finders::MethodFinder.new.find :type => String, :method => "foo", :options => [:singleton, :private] }.should   raise_error(Aquarium::Utils::InvalidOptions)
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (input parameters that yield empty results)" do
+  before(:each) do
+    common_before
+  end
+  
+  it "should return empty FinderResult#matched and FinderResult#not_matched hashes by default." do
+    actual = Aquarium::Finders::MethodFinder.new.find
+    actual.matched.should == {}
+    actual.not_matched.should == {}
+  end
+
+  it "should return empty FinderResult#matched and FinderResult#not_matched hashes if no types are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [], :methods => /instance_test_method/
+    actual.matched.should == {}
+    actual.not_matched.should == {}
+  end
+  
+  it "should return empty FinderResult#matched and FinderResult#not_matched hashes if no objects are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => [], :methods => /instance_test_method/
+    actual.matched.should == {}
+    actual.not_matched.should == {}
+  end
+  
+  it "should return an empty FinderResult#matched hash and a FinderResult#not_matched hash with the specified types if no methods are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPublicInstanceMethod
+    actual.matched.should == {}
+    actual.not_matched.should == {ClassWithPublicInstanceMethod => @empty_set}
+  end
+end
+
+describe Aquarium::Finders::MethodFinder, "#find (input parameters specify no methods)" do
+  before(:each) do
+    common_before
+  end
+  
+  it "should return an empty FinderResult#matched hash and a FinderResult#not_matched hash with the specified objects if no methods are specified." do
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => pub
+    actual.matched.should == {}
+    actual.not_matched.should == {pub => @empty_set}
+  end
+  
+  it "should return an empty FinderResult#matched hash and a FinderResult#not_matched hash with the specified types if an empty methods list is specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPublicInstanceMethod, :methods => []
+    actual.matched.should == {}
+    actual.not_matched.should == {ClassWithPublicInstanceMethod => @empty_set}
+  end
+  
+  it "should return an empty FinderResult#matched hash and a FinderResult#not_matched hash with the specified objects if an empty methods list is specified." do
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => pub, :methods => []
+    actual.matched.should == {}
+    actual.not_matched.should == {pub => @empty_set}
+  end
+  
+  it "should return an empty FinderResult#matched hash and a FinderResult#not_matched hash with the specified types if an empty method name is specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPublicInstanceMethod, :methods => ""
+    actual.matched.should == {}
+    actual.not_matched.should == {ClassWithPublicInstanceMethod => Set.new([""])}
+  end
+  
+  it "should return an empty FinderResult#matched hash and a FinderResult#not_matched hash with the specified objects if an empty method name is specified." do
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => pub, :methods => ""
+    actual.matched.should == {}
+    actual.not_matched.should == {pub => Set.new([""])}
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (input parameters specify method regular expressions that match nothing)" do
+  before(:each) do
+    common_before
+  end
+  
+  it "should find no methods when searching with one type and with a regexp matching no methods." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPublicInstanceMethod, :methods => /no_matching_method/
+    actual.matched.should == {}
+    actual.not_matched[ClassWithPublicInstanceMethod].should == Set.new([/no_matching_method/])
+  end
+  
+  it "should find no methods when searching with one object and with a regexp matching no methods." do
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => pub, :methods => /no_matching_method/
+    actual.matched.should == {}
+    actual.not_matched[pub].should == Set.new([/no_matching_method/])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (input parameters specify method names that match nothing)" do
+  before(:each) do
+    common_before
+  end
+    
+  it "should find no methods when searching with a type and with a literal name matching no methods." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPublicInstanceMethod, :methods => "no_matching_method"
+    actual.matched.should == {}
+    actual.not_matched[ClassWithPublicInstanceMethod].should == Set.new(["no_matching_method"])
+  end
+  
+  it "should find no methods when searching with one object and with a literal name matching no methods." do
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => pub, :methods => "no_matching_method"
+    actual.matched.should == {}
+    actual.not_matched[pub].should == Set.new(["no_matching_method"])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (behavior for derived classes)" do
+  before(:each) do
+    common_before
+  end
+    
+  it "should find Base and Derived methods in the specified class, by default." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods => [/^mbase/, /^mmodule/]
+    actual.matched.size.should == 1
+    actual.matched[Derived].should == Set.new([:mbase1, :mbase2, :mmodule1, :mmodule2, :mmodule3])
+  end
+   
+  it "should find Base and Derived methods in the specified object, by default." do
+    child = Derived.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => child, :methods => [/^mbase/, /^mderived/, /^mmodule/]
+    actual.matched.size.should == 1
+    actual.matched[child].should == Set.new([:mbase1, :mbase2, :mderived1, :mmodule1, :mmodule2, :mmodule3])
+  end
+   
+  it "should find Derived methods only for a type when ancestor methods are suppressed, which also suppresses method overrides." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods => [/^mder/, /^mmod/], :options => [:suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[Derived].should == Set.new([:mderived1, :mmodule3])
+  end
+
+  it "should find Derived methods only for an object when ancestor methods are suppressed, which also suppresses method overrides." do
+    child = Derived.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => child, :methods => [/^mder/, /^mmodule/], :options => [:suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[child].should == Set.new([:mderived1, :mmodule3])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (searching for class methods)" do
+  before(:each) do
+    common_before
+  end
+  
+  it "should find all class methods matching a regular expression for types when :class is used." do
+    # Have to add some rspec methods to the expected lists!
+    rspec_expected = %w[received_message?]
+    expected = {}
+    expected[Kernel] = (rspec_expected + %w[chomp! chop! class_variable_defined? const_defined? respond_to?]).sort.map {|m| m.intern}
+    [Object, Module, Class].each do |clazz|
+      expected[clazz] = (rspec_expected + %w[class_variable_defined? const_defined? respond_to?]).sort.map {|m| m.intern}
+    end
+    class_array = [Kernel, Module, Object, Class]
+    actual = Aquarium::Finders::MethodFinder.new.find :types => class_array, :methods => [/^[cr].*\?$/, /^[cr].*\!$/], :options => :class
+    class_array.each do |c|
+      actual.matched[c].should == Set.new(expected[c])
+    end
+  end
+  
+  it "should find all public class methods in types when searching with the :all method specification and the :class option." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicClassMethod, ClassWithPrivateClassMethod], :methods => :all, :options => :class
+    actual.matched.size.should == 2
+    actual.not_matched.size.should == 0
+    actual.matched[ClassWithPublicClassMethod].should == Set.new(ClassWithPublicClassMethod.public_methods.sort.map{|m| m.intern})
+    actual.matched[ClassWithPrivateClassMethod].should == Set.new(ClassWithPrivateClassMethod.public_methods.sort.map{|m| m.intern})
+  end
+  
+  it "should find all public class methods in types, but not ancestors, when searching with the :all method specification and the :class and :suppress_ancestor_methods options." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicClassMethod, ClassWithPrivateClassMethod], :methods => :all, :options => [:class, :suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.not_matched.size.should == 1
+    actual.matched[ClassWithPublicClassMethod].should == Set.new([:public_class_test_method])
+    actual.not_matched[ClassWithPrivateClassMethod].should == Set.new([:all])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (searching for instance methods)" do
+  before(:each) do
+    common_before
+  end
+  
+  it "should find all public instance methods in types when searching with the :all method specification." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicInstanceMethod, ClassWithProtectedInstanceMethod, ClassWithPrivateInstanceMethod], :methods => :all
+    actual.matched.size.should == 3
+    [ClassWithPublicInstanceMethod, ClassWithProtectedInstanceMethod, ClassWithPrivateInstanceMethod].each do |c|
+      actual.matched[c].should == Set.new(c.public_instance_methods.sort.map {|m| m.intern})
+    end
+  end
+  
+  it "should find all public instance methods in objects when searching with the :all method specification." do
+    pub = ClassWithPublicInstanceMethod.new
+    pro = ClassWithProtectedInstanceMethod.new
+    pri = ClassWithPrivateInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => [pub, pro, pri], :methods => :all
+    actual.matched.size.should == 3
+    [pub, pro, pri].each do |c|
+      actual.matched[c].should == Set.new(c.public_methods.sort.map {|m| m.intern})
+    end
+  end
+  
+  it "should find only one instance method for a type when searching with a regexp matching one method." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPublicInstanceMethod, :methods => /instance_test_method/
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should find only one instance method for an object when searching with a regexp matching one method." do
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => pub, :methods => /instance_test_method/
+    actual.matched.size.should == 1
+    actual.matched[pub].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should find only one instance method for one class when searching with a one-class array and with a regexp matching one method." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicInstanceMethod], :methods => /instance_test_method/
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should find only one instance method for one object when searching with a one-object array and with a regexp matching one method." do
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => [pub], :methods => /instance_test_method/
+    actual.matched.size.should == 1
+    actual.matched[pub].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should find only one instance method for one class when searching with a one-class array and with a single-regexp array matching one method." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicInstanceMethod], :methods => [/instance_test_method/]
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should find only one instance method for one object when searching with a one-object array and with a single-regexp array matching one method." do
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => [pub], :methods => [/instance_test_method/]
+    actual.matched.size.should == 1
+    actual.matched[pub].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should find only one instance method for one class when searching with a one-class array and with the method's literal name." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicInstanceMethod], :methods => "public_instance_test_method"
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should find only one instance method for one object when searching with a one-object array and with the method's literal name." do
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => [pub], :methods => "public_instance_test_method"
+    actual.matched.size.should == 1
+    actual.matched[pub].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should find only one instance method for one class when searching with a one-class array and with the method's literal name in a single-element array." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicInstanceMethod], :methods => ["public_instance_test_method"]
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should find only one instance method for one object when searching with a one-object array and with the method's literal name in a single-element array." do
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => [pub], :methods => ["public_instance_test_method"]
+    actual.matched.size.should == 1
+    actual.matched[pub].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should find an instance method for each class when searching with a two-class array and with the methods' literal names." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicInstanceMethod, ClassWithPublicInstanceMethod2], :methods => ["public_instance_test_method", "public_instance_test_method2"]
+    actual.matched.size.should == 2
+    actual.matched[ClassWithPublicInstanceMethod].should  == Set.new([:public_instance_test_method])
+    actual.matched[ClassWithPublicInstanceMethod2].should == Set.new([:public_instance_test_method2])
+  end
+
+  it "should find an instance method for each object when searching with a two-object array and with the methods' literal names." do
+    pub  = ClassWithPublicInstanceMethod
+    pub2 = ClassWithPublicInstanceMethod2.new
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => [pub, pub2], :methods => ["public_instance_test_method", "public_instance_test_method2"]
+    actual.matched.size.should == 2
+    actual.matched[pub].should  == Set.new([:public_instance_test_method])
+    actual.matched[pub2].should == Set.new([:public_instance_test_method2])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (format of results)" do
+  before(:each) do
+    common_before
+  end
+  
+  it "should return found methods for a type as symbols." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPublicInstanceMethod, :methods => /instance_test_method/
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should return found methods for an object as symbols." do
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => pub, :methods => /instance_test_method/
+    actual.matched.size.should == 1
+    actual.matched[pub].should == Set.new([:public_instance_test_method])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (using :methods => :all)" do
+  before(:each) do
+    common_before
+  end
+  
+  it "should accept :all for the methods argument and find all methods for a type subject to the method options." do
+    actual = Aquarium::Finders::MethodFinder.new.find :type => ClassWithPublicInstanceMethod, :method => :all, :options => :suppress_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should accept :all for the methods argument and find all methods for an object subject to the method options." do
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => pub, :method => :all, :options => :suppress_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[pub].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should ignore other method arguments if :all is present." do
+    actual = Aquarium::Finders::MethodFinder.new.find :type => ClassWithPublicInstanceMethod, :method => [:all, :none, /.*foo.*/], :methods =>[/.*bar.*/, /^baz/], :options => :suppress_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => pub, :method => [:all, :none, /.*foo.*/], :methods =>[/.*bar.*/, /^baz/], :options => :suppress_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[pub].should == Set.new([:public_instance_test_method])
+  end
+  
+  it "should report [:all] as the not_matched value when :all is the method argument and no methods match, e.g., for :suppress_ancestor_methods." do
+    actual = Aquarium::Finders::MethodFinder.new.find :type => ClassWithPrivateInstanceMethod, :method => :all, :options => :suppress_ancestor_methods
+    actual.matched.size.should == 0
+    actual.not_matched[ClassWithPrivateInstanceMethod].should == Set.new([:all])
+    pri = ClassWithPrivateInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => pri, :method => :all, :options => :suppress_ancestor_methods
+    actual.matched.size.should == 0
+    actual.not_matched[pri].should == Set.new([:all])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (using :options => :suppress_ancestor_methods)" do
+  before(:each) do
+    common_before
+  end
+  
+  it "should suppress ancestor methods for types when :suppress_ancestor_methods is specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPublicInstanceMethod].should    == Set.new([:public_instance_test_method])
+    actual.not_matched.size.should == 4
+    actual.not_matched[ClassWithProtectedInstanceMethod].should == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateInstanceMethod].should   == Set.new([/test_method/])
+    actual.not_matched[ClassWithPublicClassMethod].should       == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateClassMethod].should      == Set.new([/test_method/])
+  end
+
+  it "should suppress ancestor methods for objects when :suppress_ancestor_methods is specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[@pub].should == Set.new([:public_instance_test_method])
+    actual.not_matched.size.should == 4
+    actual.not_matched[@pro].should  == Set.new([/test_method/])
+    actual.not_matched[@pri].should  == Set.new([/test_method/])
+    actual.not_matched[@cpub].should == Set.new([/test_method/])
+    actual.not_matched[@cpri].should == Set.new([/test_method/])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :instance])" do
+  before(:each) do
+    common_before
+  end
+
+  it "should find only public instance methods for types when :public, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
+    actual.not_matched.size.should == 4
+    actual.not_matched[ClassWithProtectedInstanceMethod].should == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateInstanceMethod].should   == Set.new([/test_method/])
+    actual.not_matched[ClassWithPublicClassMethod].should       == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateClassMethod].should      == Set.new([/test_method/])
+  end
+
+  it "should find only public instance methods for objects when :public, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[@pub].should == Set.new([:public_instance_test_method])
+    actual.not_matched.size.should == 4
+    actual.not_matched[@pro].should  == Set.new([/test_method/])
+    actual.not_matched[@pri].should  == Set.new([/test_method/])
+    actual.not_matched[@cpub].should == Set.new([/test_method/])
+    actual.not_matched[@cpri].should == Set.new([/test_method/])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (using :options => [:protected, :instance])" do
+  before(:each) do
+    common_before
+  end
+
+  it "should find only protected instance methods when :protected, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:protected, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[ClassWithProtectedInstanceMethod].should == Set.new([:protected_instance_test_method])
+    actual.not_matched.size.should == 4
+    actual.not_matched[ClassWithPublicInstanceMethod].should   == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateInstanceMethod].should  == Set.new([/test_method/])
+    actual.not_matched[ClassWithPublicClassMethod].should      == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateClassMethod].should     == Set.new([/test_method/])
+  end
+
+  it "should find only protected instance methods for objects when :protected, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:protected, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[@pro].should == Set.new([:protected_instance_test_method])
+    actual.not_matched.size.should == 4
+    actual.not_matched[@pub].should  == Set.new([/test_method/])
+    actual.not_matched[@pri].should  == Set.new([/test_method/])
+    actual.not_matched[@cpub].should == Set.new([/test_method/])
+    actual.not_matched[@cpri].should == Set.new([/test_method/])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (using :options => [:private, :instance])" do
+  before(:each) do
+    common_before
+  end
+
+  it "should find only private instance methods when :private, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:private, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPrivateInstanceMethod].should == Set.new([:private_instance_test_method])
+    actual.not_matched.size.should == 4
+    actual.not_matched[ClassWithPublicInstanceMethod].should    == Set.new([/test_method/])
+    actual.not_matched[ClassWithProtectedInstanceMethod].should == Set.new([/test_method/])
+    actual.not_matched[ClassWithPublicClassMethod].should       == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateClassMethod].should      == Set.new([/test_method/])
+  end
+
+  it "should find only private instance methods for objects when :private, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:private, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[@pri].should == Set.new([:private_instance_test_method])
+    actual.not_matched.size.should == 4
+    actual.not_matched[@pub].should  == Set.new([/test_method/])
+    actual.not_matched[@pro].should  == Set.new([/test_method/])
+    actual.not_matched[@cpub].should == Set.new([/test_method/])
+    actual.not_matched[@cpri].should == Set.new([/test_method/])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :class])" do
+  before(:each) do
+    common_before
+  end
+
+  it "should find only public class methods for types when :public, and :class are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :class, :suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPublicClassMethod].should == Set.new([:public_class_test_method])
+    actual.not_matched.size.should == 4
+    actual.not_matched[ClassWithPublicInstanceMethod].should    == Set.new([/test_method/])
+    actual.not_matched[ClassWithProtectedInstanceMethod].should == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateInstanceMethod].should   == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateClassMethod].should      == Set.new([/test_method/])
+  end
+
+  it "should find no public class methods for objects when :public, and :class are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :class, :suppress_ancestor_methods]
+    actual.matched.size.should == 0
+    actual.not_matched.size.should == 5
+    actual.not_matched[@pub].should  == Set.new([/test_method/])
+    actual.not_matched[@pro].should  == Set.new([/test_method/])
+    actual.not_matched[@pri].should  == Set.new([/test_method/])
+    actual.not_matched[@cpub].should == Set.new([/test_method/])
+    actual.not_matched[@cpri].should == Set.new([/test_method/])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (using :options => [:private, :class])" do
+  before(:each) do
+    common_before
+  end
+
+  it "should find only private class methods for types when :private, and :class are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:private, :class, :suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPrivateClassMethod].should == Set.new([:private_class_test_method])
+    actual.not_matched.size.should == 4
+    actual.not_matched[ClassWithPublicInstanceMethod].should    == Set.new([/test_method/])
+    actual.not_matched[ClassWithProtectedInstanceMethod].should == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateInstanceMethod].should   == Set.new([/test_method/])
+    actual.not_matched[ClassWithPublicClassMethod].should       == Set.new([/test_method/])
+  end
+
+  it "should find no private class methods for objects when :private, and :class are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:private, :class, :suppress_ancestor_methods]
+    actual.matched.size.should == 0
+    actual.not_matched.size.should == 5
+    actual.not_matched[@pub].should  == Set.new([/test_method/])
+    actual.not_matched[@pro].should  == Set.new([/test_method/])
+    actual.not_matched[@pri].should  == Set.new([/test_method/])
+    actual.not_matched[@cpub].should == Set.new([/test_method/])
+    actual.not_matched[@cpri].should == Set.new([/test_method/])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :protected, :instance])" do
+  before(:each) do
+    common_before
+  end
+
+  it "should find public and protected instance methods for types when :public, :protected, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :protected, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 2
+    actual.matched[ClassWithPublicInstanceMethod].should    == Set.new([:public_instance_test_method])
+    actual.matched[ClassWithProtectedInstanceMethod].should == Set.new([:protected_instance_test_method])
+    actual.not_matched.size.should == 3
+    actual.not_matched[ClassWithPrivateInstanceMethod].should   == Set.new([/test_method/])
+    actual.not_matched[ClassWithPublicClassMethod].should       == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateClassMethod].should      == Set.new([/test_method/])
+  end
+
+  it "should find public and protected instance methods for objects when :public, :protected, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :protected, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 2
+    actual.matched[@pub].should == Set.new([:public_instance_test_method])
+    actual.matched[@pro].should == Set.new([:protected_instance_test_method])
+    actual.not_matched.size.should == 3
+    actual.not_matched[@pri].should  == Set.new([/test_method/])
+    actual.not_matched[@cpub].should == Set.new([/test_method/])
+    actual.not_matched[@cpri].should == Set.new([/test_method/])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :;private, :instance])" do
+  before(:each) do
+    common_before
+  end
+
+  it "should find public and private instance methods when :public, :private, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :private, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 2
+    actual.matched[ClassWithPublicInstanceMethod].should  == Set.new([:public_instance_test_method])
+    actual.matched[ClassWithPrivateInstanceMethod].should == Set.new([:private_instance_test_method])
+    actual.not_matched.size.should == 3
+    actual.not_matched[ClassWithProtectedInstanceMethod].should == Set.new([/test_method/])
+    actual.not_matched[ClassWithPublicClassMethod].should       == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateClassMethod].should      == Set.new([/test_method/])
+  end
+
+  it "should find public and private instance methods for objects when :public, :private, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :private, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 2
+    actual.matched[@pub].should == Set.new([:public_instance_test_method])
+    actual.matched[@pri].should == Set.new([:private_instance_test_method])
+    actual.not_matched.size.should == 3
+    actual.not_matched[@pro].should  == Set.new([/test_method/])
+    actual.not_matched[@cpub].should == Set.new([/test_method/])
+    actual.not_matched[@cpri].should == Set.new([/test_method/])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (using :options => [:protected, :private, :instance])" do
+  before(:each) do
+    common_before
+  end
+
+  it "should find protected and private instance methods when :protected, :private, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:protected, :private, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 2
+    actual.matched[ClassWithProtectedInstanceMethod].should == Set.new([:protected_instance_test_method])
+    actual.matched[ClassWithPrivateInstanceMethod].should   == Set.new([:private_instance_test_method])
+    actual.not_matched.size.should == 3
+    actual.not_matched[ClassWithPublicInstanceMethod].should   == Set.new([/test_method/])
+    actual.not_matched[ClassWithPublicClassMethod].should      == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateClassMethod].should     == Set.new([/test_method/])
+  end
+
+  it "should find protected and private instance methods for objects when :protected, :private, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:protected, :private, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 2
+    actual.matched[@pro].should == Set.new([:protected_instance_test_method])
+    actual.matched[@pri].should == Set.new([:private_instance_test_method])
+    actual.not_matched.size.should == 3
+    actual.not_matched[@pub].should  == Set.new([/test_method/])
+    actual.not_matched[@cpub].should == Set.new([/test_method/])
+    actual.not_matched[@cpri].should == Set.new([/test_method/])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :class, :instance])" do
+  before(:each) do
+    common_before
+  end
+
+  it "should find public class and instance methods for types when :public, :class, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :class, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 2
+    actual.matched[ClassWithPublicInstanceMethod].should  == Set.new([:public_instance_test_method])
+    actual.matched[ClassWithPublicClassMethod].should     == Set.new([:public_class_test_method])
+    actual.not_matched.size.should == 3
+    actual.not_matched[ClassWithPrivateInstanceMethod].should    == Set.new([/test_method/])
+    actual.not_matched[ClassWithProtectedInstanceMethod].should  == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateClassMethod].should       == Set.new([/test_method/])
+  end
+
+  it "should find only public instance methods for objects even when :class is specified along with :public and :instance." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :class, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[@pub].should  == Set.new([:public_instance_test_method])
+    actual.not_matched.size.should == 4
+    actual.not_matched[@pro].should  == Set.new([/test_method/])
+    actual.not_matched[@pri].should  == Set.new([/test_method/])
+    actual.not_matched[@cpub].should == Set.new([/test_method/])
+    actual.not_matched[@cpri].should == Set.new([/test_method/])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :protected, :class, :instance])" do
+  before(:each) do
+    common_before
+  end
+
+  it "should find public and protected instance methods when :public, :protected, :class, and :instance are specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :protected, :class, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 3
+    actual.matched[ClassWithPublicInstanceMethod].should    == Set.new([:public_instance_test_method])
+    actual.matched[ClassWithPublicClassMethod].should       == Set.new([:public_class_test_method])
+    actual.matched[ClassWithProtectedInstanceMethod].should == Set.new([:protected_instance_test_method])
+    actual.not_matched.size.should == 2
+    actual.not_matched[ClassWithPrivateInstanceMethod].should  == Set.new([/test_method/])
+    actual.not_matched[ClassWithPrivateClassMethod].should     == Set.new([/test_method/])
+  end
+
+  it "should find only public and protected instance methods for objects even when :class is specified along with :public, :protected, :class, and :instance." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :protected, :class, :instance, :suppress_ancestor_methods]
+    actual.matched.size.should == 2
+    actual.matched[@pub].should  == Set.new([:public_instance_test_method])
+    actual.matched[@pro].should  == Set.new([:protected_instance_test_method])
+    actual.not_matched.size.should == 3
+    actual.not_matched[@pri].should  == Set.new([/test_method/])
+    actual.not_matched[@cpub].should == Set.new([/test_method/])
+    actual.not_matched[@cpri].should == Set.new([/test_method/])
+  end
+end
+
+describe "Aquarium::Finders::MethodFinder#find (looking for singleton methods)" do
+  before(:each) do
+    class Empty
+    end
+
+    @objectWithSingletonMethod = Empty.new
+    class << @objectWithSingletonMethod
+      def a_singleton_method
+      end
+    end
+    
+    class NotQuiteEmpty
+    end
+    class << NotQuiteEmpty
+      def a_class_singleton_method
+      end
+    end
+    @notQuiteEmpty = NotQuiteEmpty.new
+  end  
+
+  it "should find instance-level singleton methods for objects when :singleton is specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => [@notQuiteEmpty, @objectWithSingletonMethod], :methods => :all, :options => [:singleton]
+    actual.matched.size.should == 1
+    actual.matched[@objectWithSingletonMethod].should  == Set.new([:a_singleton_method])
+    actual.not_matched.size.should == 1
+    actual.not_matched[@notQuiteEmpty].should  == Set.new([:all])
+  end    
+
+  it "should find type-level singleton methods for types when :singleton is specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [NotQuiteEmpty, Empty], :methods => :all, :options => [:singleton, :suppress_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[NotQuiteEmpty].should  == Set.new([:a_class_singleton_method])
+    actual.not_matched.size.should == 1
+    actual.not_matched[Empty].should  == Set.new([:all])
+  end
+end
+
+describe "Aquarium::Finders::MethodFinder#find (looking for methods that end in non-alphanumeric characters)" do
+  class ClassWithFunkyMethodNames
+    def huh?; true; end
+    def yes!; true; end
+    def == other; false; end
+    def =~ other; false; end
+  end
+  
+  before(:each) do
+    @funky = ClassWithFunkyMethodNames.new
+  end  
+  
+  {'?' => :huh?, '!' => :yes!, '=' => :==, '~' => :=~}.each do |char, method|
+    it "should find instance methods for types when searching for names that end with a '#{char}' character using the method's name." do
+      actual = Aquarium::Finders::MethodFinder.new.find :type => ClassWithFunkyMethodNames, :methods => method
+      actual.matched.size.should == 1
+      actual.matched[ClassWithFunkyMethodNames].should  == Set.new([method])
+      actual.not_matched.size.should == 0
+    end    
+
+    it "should find instance methods for types when searching for names that end with a '#{char}' character using a regular expression." do
+      actual = Aquarium::Finders::MethodFinder.new.find :type => ClassWithFunkyMethodNames, :methods => /#{Regexp.escape(char)}$/
+      actual.matched.size.should >= 1
+      actual.matched[ClassWithFunkyMethodNames].should  include(method)
+      actual.not_matched.size.should == 0
+    end    
+
+    it "should find instance methods for objects when searching for names that end with a '#{char}' character using the method's name." do
+      actual = Aquarium::Finders::MethodFinder.new.find :object => @funky, :methods => method
+      actual.matched.size.should == 1
+      actual.matched[@funky].should  == Set.new([method])
+      actual.not_matched.size.should == 0
+    end    
+
+    it "should find instance methods for objects when searching for names that end with a '#{char}' character using a regular expression." do
+      actual = Aquarium::Finders::MethodFinder.new.find :object => @funky, :methods => /#{Regexp.escape(char)}$/
+      actual.matched.size.should >= 1
+      actual.matched[@funky].should  include(method)
+      actual.not_matched.size.should == 0
+    end    
+  end  
+end
+
+describe "Aquarium::Finders::MethodFinder#find_all_by" do
+  it "should accept :all for the methods argument." do
+    actual = Aquarium::Finders::MethodFinder.new.find_all_by ClassWithPublicInstanceMethod, :all, :suppress_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
+    actual.not_matched.size.should == 0
+    pub = ClassWithPublicInstanceMethod.new
+    actual = Aquarium::Finders::MethodFinder.new.find_all_by pub, :all, :suppress_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[pub].should == Set.new([:public_instance_test_method])
+    actual.not_matched.size.should == 0
+  end
+  
+  it "should behave like Aquarium::Finders::MethodFinder#find with an explicit parameter list rather than a hash." do
+    expected = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPrivateInstanceMethod, 
+      :methods => /test_method/, :options => [:private, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find_all_by ClassWithPrivateInstanceMethod, 
+      /test_method/, :private, :instance, :suppress_ancestor_methods
+    actual.should == expected
+
+    expected = Aquarium::Finders::MethodFinder.new.find :objects => @pub, 
+      :methods => /test_method/, :options => [:private, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find_all_by @pub, 
+      /test_method/, :private, :instance, :suppress_ancestor_methods
+    actual.should == expected
+
+    expected = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicInstanceMethod, ClassWithPrivateInstanceMethod], 
+      :methods => ["foo", /test_method/], :options => [:instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find_all_by [ClassWithPublicInstanceMethod, ClassWithPrivateInstanceMethod],
+      ["foo", /test_method/], :instance, :suppress_ancestor_methods
+    actual.should == expected
+
+    expected = Aquarium::Finders::MethodFinder.new.find :objects => [@pub, @pri], 
+      :methods => ["foo", /test_method/], :options => [:instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find_all_by [@pub, @pri],
+      ["foo", /test_method/], :instance, :suppress_ancestor_methods
+    actual.should == expected
+  end
+end
+  
+describe "Aquarium::Finders::MethodFinder.is_recognized_method_option" do
+
+  it "should be true for :public, :private, :protected, :instance, :class, and :suppress_ancestor_methods as strings or symbols." do
+    %w[public private protected instance class suppress_ancestor_methods].each do |s|
+      Aquarium::Finders::MethodFinder.is_recognized_method_option(s).should == true
+      Aquarium::Finders::MethodFinder.is_recognized_method_option(s.to_sym).should == true
+    end
+  end  
+
+  it "should be false for unknown options." do
+    %w[public2 wierd unknown string].each do |s|
+      Aquarium::Finders::MethodFinder.is_recognized_method_option(s).should == false
+      Aquarium::Finders::MethodFinder.is_recognized_method_option(s.to_sym).should == false
+    end
+  end
+end
+