aquarium 0.1.0 → 0.1.5

data/spec/aquarium/aspects/join_point_spec.rb

@@ -25,37 +25,138 @@ describe Aquarium::Aspects::JoinPoint, "#initialize with invalid parameters" do
   end
 end
   
-describe Aquarium::Aspects::JoinPoint, "#initialize with invalid parameters" do
+describe Aquarium::Aspects::JoinPoint, "#initialize with parameters that specify class vs. instance methods" do
   it "should assume the :method_name refers to an instance method, by default." do
     jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split
-    jp.is_instance_method?.should be_true
+    jp.instance_method?.should be_true
+  end
+  
+  it "should treat the :method_name as refering to an instance method if :instance_method is specified as true." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :instance_method => true
+    jp.instance_method?.should be_true
+  end
+  
+  it "should treat the :method_name as refering to a class method if :instance_method is specified as false." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :instance_method => false
+    jp.instance_method?.should be_false
+  end
+
+  it "should treat the :method_name as refering to an instance method if :class_method is specified as false." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :class_method => false
+    jp.instance_method?.should be_true
+  end
+  
+  it "should treat the :method_name as refering to a class method if :class_method is specified as true." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :class_method => true
+    jp.instance_method?.should be_false
+  end
+  
+  it "should treat give precedence to :instance_method if appears with :class_method." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :instance_method => false, :class_method => true
+    jp.instance_method?.should be_false
+    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :instance_method => true, :class_method => false
+    jp.instance_method?.should be_true
+  end
+end
+  
+describe Aquarium::Aspects::JoinPoint, "#visibility" do
+  class ProtectionExample
+    def public_instance_m; end
+    protected
+    def protected_instance_m; end
+    private
+    def private_instance_m; end
+    def self.public_class_m; end
+    def self.private_class_m; end
+    private_class_method :private_class_m
+  end
+  
+  it "should return :public for public instance methods." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :public_instance_m
+    jp.visibility.should == :public
+  end
+  
+  it "should return :public for public instance methods, when only instance methods are specified." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :public_instance_m, :instance_method => true
+    jp.visibility.should == :public
+  end
+  
+  it "should return :public for public class methods, when only class methods are specified using :instance_method => false." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :public_class_m, :instance_method => false
+    jp.visibility.should == :public
+  end
+
+  it "should return :public for public instance methods, when only instance methods are specified using :class_method => false." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :public_instance_m, :class_method => false
+    jp.visibility.should == :public
+  end
+  
+  it "should return :public for public class methods, when only class methods are specified." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :public_class_m, :class_method => true
+    jp.visibility.should == :public
+  end
+
+  it "should return :protected for protected instance methods." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :protected_instance_m
+    jp.visibility.should == :protected
+  end
+  
+  it "should return :protected for protected instance methods, when only instance methods are specified." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :protected_instance_m, :instance_method => true
+    jp.visibility.should == :protected
+  end
+  
+  it "should return nil for protected class methods, when only class methods are specified using :instance_method => false." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :protected_class_method, :instance_method => false
+    jp.visibility.should == nil
+  end
+
+  it "should return :protected for protected instance methods, when only instance methods are specified using :class_method => false." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :protected_instance_m, :class_method => false
+    jp.visibility.should == :protected
+  end
+  
+  it "should return nil for protected class methods, when only class methods are specified." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :protected_class_method, :class_method => true
+    jp.visibility.should == nil
+  end
+
+  it "should return :private for private instance methods." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :private_instance_m
+    jp.visibility.should == :private
   end
   
-  it "should treat the :method_name as refering to an instance method if :is_instance_method is specified as true." do
-    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :is_instance_method => true
-    jp.is_instance_method?.should be_true
+  it "should return :private for private instance methods, when only instance methods are specified." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :private_instance_m, :instance_method => true
+    jp.visibility.should == :private
   end
   
-  it "should treat the :method_name as refering to a class method if :is_instance_method is specified as false." do
-    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :is_instance_method => false
-    jp.is_instance_method?.should be_false
+  it "should return :private for private class methods, when only class methods are specified using :instance_method => false." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :private_class_m, :instance_method => false
+    jp.visibility.should == :private
   end
 
-  it "should treat the :method_name as refering to an instance method if :is_class_method is specified as false." do
-    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :is_class_method => false
-    jp.is_instance_method?.should be_true
+  it "should return :private for private instance methods, when only instance methods are specified using :class_method => false." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :private_instance_m, :class_method => false
+    jp.visibility.should == :private
   end
   
-  it "should treat the :method_name as refering to a class method if :is_class_method is specified as true." do
-    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :is_class_method => true
-    jp.is_instance_method?.should be_false
+  it "should return :private for private class methods, when only class methods are specified." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :private_class_m, :class_method => true
+    jp.visibility.should == :private
   end
   
-  it "should treat give precedence to :is_instance_method if appears with :is_class_method." do
-    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :is_instance_method => false, :is_class_method => true
-    jp.is_instance_method?.should be_false
-    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :is_instance_method => true, :is_class_method => false
-    jp.is_instance_method?.should be_true
+  it "should return nil for non-existent methods." do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :foo
+    jp.visibility.should == nil
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :foo, :instance_method => true
+    jp.visibility.should == nil
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :foo, :instance_method => false
+    jp.visibility.should == nil
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :foo, :class_method => true
+    jp.visibility.should == nil
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :foo, :class_method => false
+    jp.visibility.should == nil
   end
 end
   

data/spec/aquarium/aspects/pointcut_spec.rb

@@ -11,8 +11,8 @@ def common_setup
   @pub_jp   = Aquarium::Aspects::JoinPoint.new :type => ClassWithPublicInstanceMethod,    :method_name => :public_instance_test_method
   @pro_jp   = Aquarium::Aspects::JoinPoint.new :type => ClassWithProtectedInstanceMethod, :method_name => :protected_instance_test_method
   @pri_jp   = Aquarium::Aspects::JoinPoint.new :type => ClassWithPrivateInstanceMethod,   :method_name => :private_instance_test_method
-  @cpub_jp  = Aquarium::Aspects::JoinPoint.new :type => ClassWithPublicClassMethod,       :method_name => :public_class_test_method, :is_class_method => true
-  @cpri_jp  = Aquarium::Aspects::JoinPoint.new :type => ClassWithPrivateClassMethod,      :method_name => :private_class_test_method, :is_class_method => true
+  @cpub_jp  = Aquarium::Aspects::JoinPoint.new :type => ClassWithPublicClassMethod,       :method_name => :public_class_test_method, :class_method => true
+  @cpri_jp  = Aquarium::Aspects::JoinPoint.new :type => ClassWithPrivateClassMethod,      :method_name => :private_class_test_method, :class_method => true
   @apro_jp  = Aquarium::Aspects::JoinPoint.new :type => ClassWithProtectedInstanceMethod, :method_name => :all
   @apri_jp  = Aquarium::Aspects::JoinPoint.new :type => ClassWithPrivateInstanceMethod,   :method_name => :all
   @acpub_jp = Aquarium::Aspects::JoinPoint.new :type => ClassWithPublicClassMethod,       :method_name => :all
@@ -146,6 +146,16 @@ describe Aquarium::Aspects::Pointcut, " (objects specified)" do
         Aquarium::Aspects::JoinPoint.new(:object => pro, :method_name => :protected_instance_test_method),
         Aquarium::Aspects::JoinPoint.new(:object => pub, :method_name => :public_instance_test_method)])
   end  
+  
+  it "does confuse strings specified with :objects as type names." do
+    string = "mystring"
+    lambda { Aquarium::Aspects::Pointcut.new :object => string, :methods => :capitalize }.should raise_error(NameError)
+  end  
+  
+  it "does confuse symbols specified with :objects as type names." do
+    symbol = :mystring
+    lambda { Aquarium::Aspects::Pointcut.new :object => symbol, :methods => :capitalize }.should raise_error(NameError)
+  end  
 end
 
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with public instance methods)" do
@@ -221,7 +231,7 @@ describe Aquarium::Aspects::Pointcut, " (types or objects specified with public
     pc = Aquarium::Aspects::Pointcut.new :objects => pub, :method_options => [:public, :class, :suppress_ancestor_methods]
     pc.join_points_matched.size.should == 0
     pc.join_points_not_matched.size.should == 1
-    pc.join_points_not_matched.should eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pub, :method_name => :all, :is_class_method => true)]))
+    pc.join_points_not_matched.should eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pub, :method_name => :all, :class_method => true)]))
   end
 end
 
@@ -239,7 +249,7 @@ describe Aquarium::Aspects::Pointcut, " (types or objects specified with private
   it "should support MethodFinder's :private and :class options for the specified objects, which will return no methods." do
     pri = ClassWithPrivateInstanceMethod.new
     pc = Aquarium::Aspects::Pointcut.new :objects => pri, :method_options => [:private, :class, :suppress_ancestor_methods]
-    pc.join_points_not_matched.should eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pri, :method_name => :all, :is_class_method => true)]))
+    pc.join_points_not_matched.should eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pri, :method_name => :all, :class_method => true)]))
     pc.join_points_not_matched.size.should == 1
   end
 end
@@ -308,23 +318,23 @@ describe Aquarium::Aspects::Pointcut, " (types or objects specified with attribu
   end
   
   it "should match attribute specifications for types that are prefixed with @." do
-    pc = Aquarium::Aspects::Pointcut.new :types => "ClassWithAttribs", :attributes => [/^@attr/]
+    pc = Aquarium::Aspects::Pointcut.new :types => "ClassWithAttribs", :attributes => [/^@attr.*ClassWithAttribs/]
     pc.join_points_matched.should == @expected_for_types
   end
   
   it "should match attribute specifications for objects that are prefixed with @." do
-    pc = Aquarium::Aspects::Pointcut.new :object => @object_of_ClassWithAttribs, :attributes => [/^@attr/]
+    pc = Aquarium::Aspects::Pointcut.new :object => @object_of_ClassWithAttribs, :attributes => [/^@attr.*ClassWithAttribs/]
     pc.join_points_matched.should == @expected_for_objects
   end
   
   it "should match attribute specifications that are regular expressions of symbols." do
-    pc = Aquarium::Aspects::Pointcut.new :types => "ClassWithAttribs", :attributes => [/^:attr/]
+    pc = Aquarium::Aspects::Pointcut.new :types => "ClassWithAttribs", :attributes => [/^:attr.*ClassWithAttribs/]
     pc.join_points_matched.should == @expected_for_types
   end
   
   it "should match attribute specifications for objects that are regular expressions of symbols." do
     object = ClassWithAttribs.new
-    pc = Aquarium::Aspects::Pointcut.new :object => object, :attributes => [/^:attr/]
+    pc = Aquarium::Aspects::Pointcut.new :object => object, :attributes => [/^:attr.*ClassWithAttribs/]
     pc.join_points_matched.should == Set.new([
       Aquarium::Aspects::JoinPoint.new(:object => object, :method_name => :attrRW_ClassWithAttribs),
       Aquarium::Aspects::JoinPoint.new(:object => object, :method_name => :attrRW_ClassWithAttribs=),
@@ -333,13 +343,13 @@ describe Aquarium::Aspects::Pointcut, " (types or objects specified with attribu
   end
   
   it "should match public attribute readers and writers for types when both the :readers and :writers options are specified." do
-    pc = Aquarium::Aspects::Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:readers, :writers]
+    pc = Aquarium::Aspects::Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr.*ClassWithAttribs/], :attribute_options => [:readers, :writers]
     pc.join_points_matched.should == @expected_for_types
   end
   
   it "should match public attribute readers and writers for objects when both the :readers and :writers options are specified." do
     object = ClassWithAttribs.new
-    pc = Aquarium::Aspects::Pointcut.new :object => object, :attributes => [/^:attr/], :attribute_options => [:readers, :writers]
+    pc = Aquarium::Aspects::Pointcut.new :object => object, :attributes => [/^:attr.*ClassWithAttribs/], :attribute_options => [:readers, :writers]
     pc.join_points_matched.should == Set.new([
       Aquarium::Aspects::JoinPoint.new(:object => object, :method_name => :attrRW_ClassWithAttribs),
       Aquarium::Aspects::JoinPoint.new(:object => object, :method_name => :attrRW_ClassWithAttribs=),
@@ -348,7 +358,7 @@ describe Aquarium::Aspects::Pointcut, " (types or objects specified with attribu
   end
   
   it "should match public attribute readers for types only when the :readers option is specified." do
-    pc = Aquarium::Aspects::Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:readers]
+    pc = Aquarium::Aspects::Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr.*ClassWithAttribs/], :attribute_options => [:readers]
     pc.join_points_matched.should == Set.new([
       Aquarium::Aspects::JoinPoint.new(:type => "ClassWithAttribs", :method_name => :attrRW_ClassWithAttribs),
       Aquarium::Aspects::JoinPoint.new(:type => "ClassWithAttribs", :method_name => :attrR_ClassWithAttribs)])
@@ -356,14 +366,14 @@ describe Aquarium::Aspects::Pointcut, " (types or objects specified with attribu
   
   it "should match public attribute readers for objects only when the :readers option is specified." do
     object = ClassWithAttribs.new
-    pc = Aquarium::Aspects::Pointcut.new :object => object, :attributes => [/^:attr/], :attribute_options => [:readers]
+    pc = Aquarium::Aspects::Pointcut.new :object => object, :attributes => [/^:attr.*ClassWithAttribs/], :attribute_options => [:readers]
     pc.join_points_matched.should == Set.new([
       Aquarium::Aspects::JoinPoint.new(:object => object, :method_name => :attrRW_ClassWithAttribs),
       Aquarium::Aspects::JoinPoint.new(:object => object, :method_name => :attrR_ClassWithAttribs)])
   end
   
   it "should match public attribute writers for types only when the :writers option is specified." do
-    pc = Aquarium::Aspects::Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:writers]
+    pc = Aquarium::Aspects::Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr.*ClassWithAttribs/], :attribute_options => [:writers]
     pc.join_points_matched.should == Set.new([
       Aquarium::Aspects::JoinPoint.new(:type => "ClassWithAttribs", :method_name => :attrRW_ClassWithAttribs=),
       Aquarium::Aspects::JoinPoint.new(:type => "ClassWithAttribs", :method_name => :attrW_ClassWithAttribs=)])
@@ -371,7 +381,7 @@ describe Aquarium::Aspects::Pointcut, " (types or objects specified with attribu
   
   it "should match public attribute writers for objects only when the :writers option is specified." do
     object = ClassWithAttribs.new
-    pc = Aquarium::Aspects::Pointcut.new :object => object, :attributes => [/^:attr/], :attribute_options => [:writers]
+    pc = Aquarium::Aspects::Pointcut.new :object => object, :attributes => [/^:attr.*ClassWithAttribs/], :attribute_options => [:writers]
     pc.join_points_matched.should == Set.new([
       Aquarium::Aspects::JoinPoint.new(:object => object, :method_name => :attrRW_ClassWithAttribs=),
       Aquarium::Aspects::JoinPoint.new(:object => object, :method_name => :attrW_ClassWithAttribs=)])

data/spec/aquarium/extras/design_by_contract_spec.rb

@@ -3,6 +3,7 @@ require 'aquarium/extras/design_by_contract'
 
 describe Aquarium::Extras::DesignByContract, "precondition" do
   class PreCond
+    include Aquarium::Extras::DesignByContract   
     def action *args
     end
     
@@ -22,6 +23,7 @@ end
 
 describe Aquarium::Extras::DesignByContract, "postcondition" do
   class PostCond
+    include Aquarium::Extras::DesignByContract    
     def action *args
     end
     
@@ -43,6 +45,7 @@ end
 
 describe Aquarium::Extras::DesignByContract, "invariant" do
   class InvarCond
+    include Aquarium::Extras::DesignByContract    
     def initialize 
       @invar = 0
     end

data/spec/aquarium/finders/finder_result_spec.rb

@@ -119,7 +119,7 @@ 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 )
+    result.object_id.should == result1.object_id
   end
   
   it "should merge the value of the other FinderResult#not_matched into self's not_matched value." do

data/spec/aquarium/finders/method_finder_spec.rb

@@ -237,14 +237,13 @@ describe Aquarium::Finders::MethodFinder, "#find (searching for class methods)"
   
   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}
+    expected[Kernel] = [:chomp!, :chop!, :respond_to?]
     [Object, Module, Class].each do |clazz|
-      expected[clazz] = (rspec_expected + %w[class_variable_defined? const_defined? respond_to?]).sort.map {|m| m.intern}
+      expected[clazz] = [:respond_to?]
     end
     class_array = [Kernel, Module, Object, Class]
-    actual = Aquarium::Finders::MethodFinder.new.find :types => class_array, :methods => [/^[cr].*\?$/, /^[cr].*\!$/], :options => :class
+    actual = Aquarium::Finders::MethodFinder.new.find :types => class_array, :methods => [/^resp.*\?$/, /^ch.*\!$/], :options => :class
     class_array.each do |c|
       actual.matched[c].should == Set.new(expected[c])
     end

data/spec/aquarium/spec_example_classes.rb

@@ -1,4 +1,7 @@
 # :enddoc:
+
+require 'aquarium/aspects/dsl/aspect_dsl'
+
 # Declares classes, etc. that support several different module specs.
 class ExampleParentClass
   def == other
@@ -50,6 +53,7 @@ class ClassWithAttribs < ExampleParentClass
 end
 
 class Watchful 
+  include Aquarium::Aspects::DSL::AspectDSL
   class WatchfulError < Exception
     def initialize message = nil
       super

data/spec/aquarium/utils/method_utils_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
 require 'aquarium/utils/method_utils'
 
-describe "Aquarium::Utils::MethodUtils.method_args_to_hash" do
+describe Aquarium::Utils::MethodUtils, ".method_args_to_hash" do
 
   it "should return an empty hash for no arguments." do
     Aquarium::Utils::MethodUtils.method_args_to_hash().should == {}
@@ -47,4 +47,127 @@ describe "Aquarium::Utils::MethodUtils.method_args_to_hash" do
     Aquarium::Utils::MethodUtils.method_args_to_hash(:x, :y, :a =>'a', :b => 'b'){|a| a.to_s.capitalize}.should == {:a => 'a', :b => 'b', :x => 'X', :y => 'Y'}
   end
     
+end
+
+describe Aquarium::Utils::MethodUtils, ".visibility" do
+  class ProtectionExample
+    def public_instance_m; end
+    protected
+    def protected_instance_m; end
+    private
+    def private_instance_m; end
+    def self.public_class_m; end
+    def self.private_class_m; end
+    private_class_method :private_class_m
+  end
+  
+  it "should return :public for public class methods on a class" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :public_class_m).should == :public
+  end
+  it "should return :public for public class methods on a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :public_class_m, :class_method_only).should == :public
+  end
+  it "should return nil for public class methods on a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :public_class_m, :instance_method_only).should == nil
+  end
+
+  it "should return :public for public instance methods on a class" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :public_instance_m).should == :public
+  end
+  it "should return nil for public instance methods on a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :public_instance_m, :class_method_only).should == nil
+  end
+  it "should return :public for public instance methods on a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :public_instance_m, :instance_method_only).should == :public
+  end
+
+  it "should return nil for public class methods on an instance of a class" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :public_class_m).should == nil
+  end
+  it "should return nil for public class methods on an instance of a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :public_class_m, :class_method_only).should == nil
+  end
+  it "should return nil for public class methods on an instance of a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :public_class_m, :instance_method_only).should == nil
+  end
+
+  it "should return :public for public instance methods on an instance of a class" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :public_instance_m).should == :public    
+  end
+  it "should return nil for public instance methods on an instance of a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :public_instance_m, :class_method_only).should == nil
+  end
+  it "should return :public for public instance methods on an instance of a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :public_instance_m, :instance_method_only).should == :public    
+  end
+  
+  it "should return :protected for protected instance methods on a class" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :protected_instance_m).should == :protected
+  end
+  it "should return nil for protected instance methods on a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :protected_instance_m, :class_method_only).should == nil
+  end
+  it "should return :protected for protected instance methods on a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :protected_instance_m, :instance_method_only).should == :protected
+  end
+
+  it "should return :protected for protected instance methods on an instance of a class" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :protected_instance_m).should == :protected    
+  end
+  it "should return nil for protected instance methods on an instance of a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :protected_instance_m, :class_method_only).should == nil
+  end
+  it "should return :protected for protected instance methods on an instance of a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :protected_instance_m, :instance_method_only).should == :protected
+  end
+  
+  it "should return :private for private class methods on a class" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :private_class_m).should == :private #expected_private
+  end
+  it "should return :private for private class methods on a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :private_class_m, :class_method_only).should == :private #expected_private
+  end
+  it "should return nil for private class methods on a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :private_class_m, :instance_method_only).should == nil
+  end
+
+  it "should return :private for private instance methods on a class" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :private_instance_m).should == :private
+  end
+  it "should return nil for private instance methods on a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :private_instance_m, :class_method_only).should == nil
+  end
+  it "should return :private for private instance methods on a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :private_instance_m, :instance_method_only).should == :private
+  end
+
+  it "should return nil for private class methods on an instance of a class" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :private_class_m).should == nil
+  end
+  it "should return nil for private class methods on an instance of a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :private_class_m, :class_method_only).should == nil
+  end
+  it "should return nil for private class methods on an instance of a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :private_class_m, :instance_method_only).should == nil
+  end
+
+  it "should return :private for private instance methods on an instance of a class" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :private_instance_m).should == :private    
+  end
+  it "should return nil for private instance methods on an instance of a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :private_instance_m, :class_method_only).should == nil
+  end
+  it "should return :private for private instance methods on an instance of a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :private_instance_m, :instance_method_only).should == :private    
+  end
+  
+  it "should return nil for an unknown method" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :nonexistent_method).should == nil    
+  end
+  it "should return nil for an unknown method when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :nonexistent_method, :class_method_only).should == nil    
+  end
+  it "should return nil for an unknown method when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :nonexistent_method, :instance_method_only).should == nil    
+  end
 end