aquarium 0.4.1 → 0.4.2

data/spec/aquarium/aspects/advice_spec.rb

@@ -6,15 +6,15 @@ include Aquarium::Aspects
 
 describe Advice, "#sort_by_priority_order" do
   it "should return an empty array for empty input" do
-    Aquarium::Aspects::Advice.sort_by_priority_order([]).should == []
+    Advice.sort_by_priority_order([]).should == []
   end
   
   it "should return a properly-sorted array for arbitrary input of valid advice kind symbols" do
-    Aquarium::Aspects::Advice.sort_by_priority_order([:after_raising, :after_returning, :before, :after, :around]).should == [:around, :before, :after, :after_returning, :after_raising]
+    Advice.sort_by_priority_order([:after_raising, :after_returning, :before, :after, :around]).should == [:around, :before, :after, :after_returning, :after_raising]
   end
   
   it "should accept strings for the advice kinds, but return sorted symbols" do
-    Aquarium::Aspects::Advice.sort_by_priority_order(["after_raising", "after_returning", "before", "after", "around"]).should == [:around, :before, :after, :after_returning, :after_raising]
+    Advice.sort_by_priority_order(["after_raising", "after_returning", "before", "after", "around"]).should == [:around, :before, :after, :after_returning, :after_raising]
   end
 end
 
@@ -53,16 +53,20 @@ describe Advice, "#invoke_original_join_point" do
   end
 end
 
+def should_raise_expected_exception_with_message message
+  begin
+    yield ; fail
+  rescue => e
+    e.message.should include(message)
+  end
+end
+
 describe Advice, "that raises an exception" do
   it "should add the kind of advice to the exception message." do
     aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_watchful_method} do |jp, obj, *args| 
       raise SpecExceptionForTesting.new("advice called with args: #{args.inspect}")
     end
-    begin
-      Watchful.new.public_watchful_method(:a1, :a2) || fail
-    rescue => e
-      e.message.should include("\"before\" advice")
-    end
+    should_raise_expected_exception_with_message("\"before\" advice") {Watchful.new.public_watchful_method(:a1, :a2)}
     aspect.unadvise
   end
 
@@ -70,11 +74,7 @@ describe Advice, "that raises an exception" do
     aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_watchful_method} do |jp, obj, *args| 
       raise "advice called with args: #{args.inspect}"
     end
-    begin
-      Watchful.new.public_watchful_method(:a1, :a2) || fail
-    rescue => e
-      e.message.should include("Watchful#public_watchful_method")
-    end
+    should_raise_expected_exception_with_message("Watchful#public_watchful_method") {Watchful.new.public_watchful_method(:a1, :a2)}
     aspect.unadvise
   end
 
@@ -82,29 +82,25 @@ describe Advice, "that raises an exception" do
     aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_class_watchful_method, :method_options => [:class]} do |jp, obj, *args| 
       raise "advice called with args: #{args.inspect}"
     end
-    begin
-      Watchful.public_class_watchful_method(:a1, :a2) || fail
-    rescue => e
-      e.message.should include("Watchful.public_class_watchful_method")
-    end
+    should_raise_expected_exception_with_message("Watchful.public_class_watchful_method") {Watchful.public_class_watchful_method(:a1, :a2)}
     aspect.unadvise
   end
 
   it "should rethrow an exception of the same type as the original exception." do
-    class MyException < Exception; end
+    class MyException1 < Exception; end
     aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_class_watchful_method, :method_options => [:class]} do |jp, obj, *args| 
-      raise MyException.new("advice called with args: #{args.inspect}")
+      raise MyException1.new("advice called with args: #{args.inspect}")
     end
-    lambda { Watchful.public_class_watchful_method :a1, :a2 }.should raise_error(MyException)
+    lambda { Watchful.public_class_watchful_method :a1, :a2 }.should raise_error(MyException1)
     aspect.unadvise
   end
 
   it "should rethrow an exception with the same backtrace as the original exception." do
-    class MyException < Exception; end
+    class MyException2 < Exception; end
     @backtrace = nil
     aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_class_watchful_method, :method_options => [:class]} do |jp, obj, *args| 
       begin
-        exception = MyException.new("advice called with args: #{args.inspect}")
+        exception = MyException2.new("advice called with args: #{args.inspect}")
         raise exception
       rescue Exception => e
         @backtrace = e.backtrace
@@ -112,7 +108,89 @@ describe Advice, "that raises an exception" do
       end
     end
     begin
-      Watchful.public_class_watchful_method(:a1, :a2) || fail
+      Watchful.public_class_watchful_method(:a1, :a2) ; fail
+    rescue Exception => e
+      e.backtrace.should == @backtrace
+    end
+    aspect.unadvise
+  end
+end
+
+describe Advice, "#invoke_original_join_point that raises an exception" do
+  class InvokeOriginalJoinPointRaisingException
+    class IOJPRException < Exception; end
+    def raise_exception *args
+      raise IOJPRException.new(":raise_exception called with args: #{args.inspect}")
+    end
+    def self.class_raise_exception *args
+      raise IOJPRException.new(":class_raise_exception called with args: #{args.inspect}")
+    end
+  end
+  
+  it "should add the kind of advice to the exception message." do
+    aspect = Aspect.new :before, 
+    :pointcut => {:type => InvokeOriginalJoinPointRaisingException, :methods => :raise_exception} do |jp, obj, *args| 
+      jp.invoke_original_join_point
+    end
+    begin
+      InvokeOriginalJoinPointRaisingException.new.raise_exception(:a1, :a2) ; fail
+    rescue InvokeOriginalJoinPointRaisingException::IOJPRException => e
+      e.message.should include("\"before\" advice")
+    end
+    aspect.unadvise
+  end
+
+  it "should add the \"Class#method\" of the advised object's type and method to the exception message." do
+    aspect = Aspect.new :before, 
+      :pointcut => {:type => InvokeOriginalJoinPointRaisingException, :methods => :raise_exception} do |jp, obj, *args| 
+        jp.invoke_original_join_point
+    end
+    begin
+      InvokeOriginalJoinPointRaisingException.new.raise_exception(:a1, :a2) ; fail
+    rescue InvokeOriginalJoinPointRaisingException::IOJPRException => e
+      e.message.should include("InvokeOriginalJoinPointRaisingException#raise_exception")
+    end
+    aspect.unadvise
+  end
+
+  it "should add the \"Class.method\" of the advised type's class method to the exception message." do
+    aspect = Aspect.new :before, 
+      :pointcut => {:type => InvokeOriginalJoinPointRaisingException, :methods => :class_raise_exception, 
+      :method_options => [:class]} do |jp, obj, *args| 
+        jp.invoke_original_join_point
+    end
+    begin
+      InvokeOriginalJoinPointRaisingException.class_raise_exception(:a1, :a2) ; fail
+    rescue InvokeOriginalJoinPointRaisingException::IOJPRException => e
+      e.message.should include("InvokeOriginalJoinPointRaisingException.class_raise_exception")
+    end
+    aspect.unadvise
+  end
+
+  it "should rethrow an exception of the same type as the original exception." do
+    aspect = Aspect.new :before, 
+      :pointcut => {:type => InvokeOriginalJoinPointRaisingException, :methods => :class_raise_exception, 
+      :method_options => [:class]} do |jp, obj, *args| 
+        jp.invoke_original_join_point
+    end
+    lambda { InvokeOriginalJoinPointRaisingException.class_raise_exception :a1, :a2 }.should raise_error(InvokeOriginalJoinPointRaisingException::IOJPRException)
+    aspect.unadvise
+  end
+
+  it "should rethrow an exception with the same backtrace as the original exception." do
+    @backtrace = nil
+    aspect = Aspect.new :before, 
+      :pointcut => {:type => InvokeOriginalJoinPointRaisingException, :methods => :class_raise_exception, 
+      :method_options => [:class]} do |jp, obj, *args| 
+      begin
+        jp.invoke_original_join_point
+      rescue Exception => e
+        @backtrace = e.backtrace
+        raise e
+      end
+    end
+    begin
+      InvokeOriginalJoinPointRaisingException.class_raise_exception(:a1, :a2) ; fail
     rescue Exception => e
       e.backtrace.should == @backtrace
     end
@@ -120,19 +198,56 @@ describe Advice, "that raises an exception" do
   end
 end
 
+describe Advice, ".compare_advice_kinds with nil or UNKNOWN_ADVICE_KIND" do
+  it "should return 0 when comparing nil to nil" do
+    Advice.compare_advice_kinds(nil, nil).should == 0
+  end
+  it "should return 0 when comparing UNKNOWN_ADVICE_KIND to UNKNOWN_ADVICE_KIND" do
+    Advice.compare_advice_kinds(Advice::UNKNOWN_ADVICE_KIND, Advice::UNKNOWN_ADVICE_KIND).should == 0
+  end
+  it "should return 1 when comparing UNKNOWN_ADVICE_KIND to nil" do
+    Advice.compare_advice_kinds(Advice::UNKNOWN_ADVICE_KIND, nil).should == 1
+  end
+  it "should return -1 when comparing nil to UNKNOWN_ADVICE_KIND" do
+    Advice.compare_advice_kinds(nil, Advice::UNKNOWN_ADVICE_KIND).should == -1
+  end
+
+  Advice::KINDS_IN_PRIORITY_ORDER.each do |kind|
+    it "should return 1 when comparing :#{kind} to UNKNOWN_ADVICE_KIND" do
+      Advice.compare_advice_kinds(kind, Advice::UNKNOWN_ADVICE_KIND).should == 1
+    end
+  end
+  Advice::KINDS_IN_PRIORITY_ORDER.each do |kind|
+    it "should return -1 when comparing UNKNOWN_ADVICE_KIND to :#{kind}" do
+      Advice.compare_advice_kinds(Advice::UNKNOWN_ADVICE_KIND, kind).should == -1
+    end
+  end
+end
+  
+describe Advice, ".compare_advice_kinds between 'real' advice kinds" do
+  Advice::KINDS_IN_PRIORITY_ORDER.each do |kind1|
+    Advice::KINDS_IN_PRIORITY_ORDER.each do |kind2|
+      expected = Advice::KINDS_IN_PRIORITY_ORDER.index(kind1) <=> Advice::KINDS_IN_PRIORITY_ORDER.index(kind2)
+      it "should return #{expected} when comparing :#{kind1} to :#{kind2} (using priority order)" do
+        Advice.compare_advice_kinds(kind1, kind2).should == expected
+      end
+    end
+  end
+end
+
 describe AdviceChainNodeFactory, "#make_node" do
   it "should raise if an unknown advice kind is specified" do
-    lambda {Aquarium::Aspects::AdviceChainNodeFactory.make_node :advice_kind => :foo}.should raise_error(Aquarium::Utils::InvalidOptions)    
+    lambda {AdviceChainNodeFactory.make_node :advice_kind => :foo}.should raise_error(Aquarium::Utils::InvalidOptions)    
   end
 
   it "should return a node of the type corresponding to the input advice kind" do
-    Aquarium::Aspects::AdviceChainNodeFactory.make_node(:advice_kind => :no).kind_of?(Aquarium::Aspects::NoAdviceChainNode).should be_true
-    Aquarium::Aspects::AdviceChainNodeFactory.make_node(:advice_kind => :none).kind_of?(Aquarium::Aspects::NoAdviceChainNode).should be_true
-    Aquarium::Aspects::AdviceChainNodeFactory.make_node(:advice_kind => :before).kind_of?(Aquarium::Aspects::BeforeAdviceChainNode).should be_true
-    Aquarium::Aspects::AdviceChainNodeFactory.make_node(:advice_kind => :after).kind_of?(Aquarium::Aspects::AfterAdviceChainNode).should be_true
-    Aquarium::Aspects::AdviceChainNodeFactory.make_node(:advice_kind => :after_raising).kind_of?(Aquarium::Aspects::AfterRaisingAdviceChainNode).should be_true
-    Aquarium::Aspects::AdviceChainNodeFactory.make_node(:advice_kind => :after_returning).kind_of?(Aquarium::Aspects::AfterReturningAdviceChainNode).should be_true
-    Aquarium::Aspects::AdviceChainNodeFactory.make_node(:advice_kind => :around).kind_of?(Aquarium::Aspects::AroundAdviceChainNode).should be_true
+    AdviceChainNodeFactory.make_node(:advice_kind => :no).kind_of?(NoAdviceChainNode).should be_true
+    AdviceChainNodeFactory.make_node(:advice_kind => :none).kind_of?(NoAdviceChainNode).should be_true
+    AdviceChainNodeFactory.make_node(:advice_kind => :before).kind_of?(BeforeAdviceChainNode).should be_true
+    AdviceChainNodeFactory.make_node(:advice_kind => :after).kind_of?(AfterAdviceChainNode).should be_true
+    AdviceChainNodeFactory.make_node(:advice_kind => :after_raising).kind_of?(AfterRaisingAdviceChainNode).should be_true
+    AdviceChainNodeFactory.make_node(:advice_kind => :after_returning).kind_of?(AfterReturningAdviceChainNode).should be_true
+    AdviceChainNodeFactory.make_node(:advice_kind => :around).kind_of?(AroundAdviceChainNode).should be_true
   end
 end
 

data/spec/aquarium/aspects/aspect_invocation_spec.rb

@@ -1,13 +1,16 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 require File.dirname(__FILE__) + '/../spec_example_types'
+require File.dirname(__FILE__) + '/../utils/type_utils_sample_nested_types'
 require 'aquarium/aspects/aspect'
-require 'aquarium/aspects/dsl'
+require 'aquarium/dsl'
 require 'aquarium/utils/array_utils'
+require File.dirname(__FILE__) + '/../finders/pointcut_finder_spec_test_classes'
 
 require 'profiler'
 
 include Aquarium::Aspects
 include Aquarium::Utils::ArrayUtils
+include Aquarium::PointcutFinderTestClasses 
 
 
 def aspects_should_be_equal num_jps, aspect1, aspect2
@@ -132,18 +135,18 @@ describe Aspect, "methods" do
     it "should reject the :exceptions argument unless specified with :after_raising." do
       lambda { Aspect.new :before, :after, :exceptions => [Exception, String], :pointcut => @pointcut_opts, :noop => true }.should raise_error(Aquarium::Utils::InvalidOptions)
     end
-end
+  end
 
   describe Aspect, ".new (parameters that specify pointcuts)" do
     before :all do
       @pointcut_opts = {:type => Aquarium::AspectInvocationTestClass}
     end
     
-    it "should contain at least one of :method(s), :pointcut(s), :type(s), or :object(s)." do
+    it "should contain at least one of :method(s), :pointcut(s), :named_pointcut(s), :type(s), or :object(s)." do
       lambda {Aspect.new(:after, :ignore_no_matching_join_points => true) {true}}.should raise_error(Aquarium::Utils::InvalidOptions)
     end
 
-    it "should contain at least one of :pointcut(s), :type(s), or :object(s) unless :default_objects => object is given." do
+    it "should contain at least one of :pointcut(s), :named_pointcut(s), :type(s), or :object(s) unless :default_objects => object is given." do
       aspect = Aspect.new(:after, :default_objects => Aquarium::AspectInvocationTestClass.new, :method => :public_test_method, :noop => true) {true}
     end
 
@@ -163,7 +166,7 @@ end
       aspect.join_points_matched.each {|jp| jp.type_or_object.should_not == Aquarium::AspectInvocationTestClass}
     end
 
-    it "should ignore the :default_objects if at least one :pointcut is given and the :default_objects are objects." do
+    it "should ignore the :default_objects if at least one :pointcut is given even if the :default_objects => object are given." do
       object = Aquarium::AspectInvocationTestClass.new
       aspect = Aspect.new(:after, :default_objects => object, 
         :pointcut => {:type => Aquarium::AspectInvocationTestClass2, :method => :public_test_method}, :method => :public_test_method) {true}
@@ -171,7 +174,7 @@ end
       aspect.join_points_matched.each {|jp| jp.type_or_object.should_not == object}
     end
 
-    it "should ignore the :default_objects if at least one :pointcut is given and the :default_objects are types." do
+    it "should ignore the :default_objects if at least one :pointcut is given even if the :default_objects => type are given." do
       aspect = Aspect.new(:after, :default_objects => Aquarium::AspectInvocationTestClass, 
         :pointcut => {:type => Aquarium::AspectInvocationTestClass2, :method => :public_test_method}, :method => :public_test_method) {true}
       aspect.join_points_matched.size.should == 1
@@ -193,7 +196,7 @@ end
       aspect.join_points_matched.each {|jp| jp.type_or_object.should_not == Aquarium::AspectInvocationTestClass}
     end
 
-    [:type, :type_and_descendents, :type_and_ancestors].each do |type_key|
+    [:type, :type_and_descendents, :type_and_ancestors, :type_and_nested_types].each do |type_key|
       it "should ignore the :default_objects if at least one :#{type_key} is given and the :default_objects are objects." do
         object = Aquarium::AspectInvocationTestClass.new
         aspect = Aspect.new(:after, :default_objects => object, type_key => Aquarium::AspectInvocationTestClass2, :method => :public_test_method, :method => :public_test_method) {true}
@@ -220,7 +223,37 @@ end
     end
   end
 
+  describe Aspect, ".new (parameters that specify named constant and/or class variable pointcuts)" do
+    it "should contain at least one :types or TypeFinder synonym for :types." do
+      lambda {Aspect.new(:after, :named_pointcuts => {}, :noop => true) {true}}.should raise_error(Aquarium::Utils::InvalidOptions)
+      lambda {Aspect.new(:after, :named_pointcuts => {:types => all_pointcut_classes}, :noop => true) {true}}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    end
+
+    it "should ignore the :default_objects if at least one :named_pointcut is given even if the :default_objects => object are given." do
+      object = Aquarium::AspectInvocationTestClass.new
+      aspect = Aspect.new(:after, :default_objects => object, :named_pointcut => {:types => Aquarium::PointcutFinderTestClasses::PointcutClassVariableHolder1}) {true}
+      aspect.join_points_matched.size.should == 1
+      aspect.join_points_matched.each {|jp| jp.type_or_object.should_not == object}
+    end
+
+    it "should ignore the :default_objects if at least one :named_pointcut is given even if the :default_objects => type are given." do
+      aspect = Aspect.new(:after, :default_objects => Aquarium::AspectInvocationTestClass, :named_pointcut => {:types => Aquarium::PointcutFinderTestClasses::PointcutClassVariableHolder1}) {true}
+      aspect.join_points_matched.size.should == 1
+      aspect.join_points_matched.each {|jp| jp.type_or_object.should_not == Aquarium::AspectInvocationTestClass}
+    end
+
+    Aspect::CANONICAL_OPTIONS["named_pointcuts"].each do |key|
+      it "should accept :#{key} as a synonym for :named_pointcuts." do
+        lambda { Aspect.new :before, key.intern => {:types => Aquarium::PointcutFinderTestClasses.all_pointcut_classes}, :noop => true do; end }.should_not raise_error
+      end
+    end
 
+    it "should not contain :named_pointcut(s) and either :type(s) or :object(s)." do
+      lambda {Aspect.new(:after, :named_pointcuts => {:types => Aquarium::PointcutFinderTestClasses::PointcutClassVariableHolder1}, :type => Aquarium::AspectInvocationTestClass, :method => :public_test_method) {true}}.should raise_error(Aquarium::Utils::InvalidOptions)
+      lambda {Aspect.new(:after, :named_pointcuts => {:types => Aquarium::PointcutFinderTestClasses::PointcutClassVariableHolder1}, :object => Aquarium::AspectInvocationTestClass.new, :method => :public_test_method) {true}}.should raise_error(Aquarium::Utils::InvalidOptions)
+    end
+  end
+  
   describe Aspect, ".new with :types parameter" do
     it "should advise the specified types." do
       @advice_called = false
@@ -462,6 +495,27 @@ end
       do_type_spec
     end
 
+    it "should accept :type(s)_and_nested_types => T1, :methods => [m, ...]" do  
+      @types_option = :types_and_nested_types
+      @type_spec = Aquarium::AspectInvocationTestClass
+      @method_spec = [:public_test_method]
+      do_type_spec
+    end
+
+    it "should accept :type(s)_and_nested_types => [T1, ...], :methods => [m, ...]" do  
+      @types_option = :types_and_nested_types
+      @type_spec = [Aquarium::AspectInvocationTestClass]
+      @method_spec = [:public_test_method]
+      do_type_spec
+    end
+
+    it "should accept :type(s)_and_nested_types => /T1/, :methods => [m, ...]" do  
+      @types_option = :types_and_nested_types
+      @type_spec = /Aquarium::AspectInvocationTestClass/
+      @method_spec = [:public_test_method]
+      do_type_spec
+    end
+
     it "should accept :type(s) => ..., :methods => ..., :method_options => [:exclude_ancestor_methods] to exclude methods defined in ancestors" do  
       @type_spec = /Aquarium::AspectInvocationTestClass/
       @method_spec = /test_method/
@@ -885,6 +939,11 @@ end
       do_type_pointcut_spec
     end
 
+    it "should accept {:type(s)_and_nested_types => [T1, ...], :methods => /m/} " do  
+      @pointcut_hash = {:type_and_nested_types => [Aquarium::AspectInvocationTestClass], :methods => /test_method/}
+      do_type_pointcut_spec
+    end
+
     it "should accept {:type(s) => T1, :methods => [m, ...]} " do  
       @pointcut_hash = {:type => Aquarium::AspectInvocationTestClass, :methods => [:public_test_method]}
       do_type_pointcut_spec
@@ -910,6 +969,11 @@ end
       do_type_pointcut_spec
     end
 
+    it "should accept {:type(s)_and_nested_types => T1, :methods => /m/} " do  
+      @pointcut_hash = {:type_and_nested_types => Aquarium::AspectInvocationTestClass, :methods => /test_method/}
+      do_type_pointcut_spec
+    end
+
     it "should accept {:type(s) => /T1/, :methods => [m, ...]} " do  
       @pointcut_hash = {:type => /Aquarium::AspectInvocationTestClass/, :methods => [:public_test_method]}
       do_type_pointcut_spec
@@ -935,6 +999,11 @@ end
       do_type_pointcut_spec
     end
 
+    it "should accept {:type(s)_and_nested_types => /T1/, :methods => /m/} " do  
+      @pointcut_hash = {:type_and_nested_types => /Aquarium::AspectInvocationTestClass/, :methods => /test_method/}
+      do_type_pointcut_spec
+    end
+
     %w[public protected private].each do |protection|
       it "should accept {:type(s) => T1, :methods => /m/, :method_options =>[:instance, #{protection}]} " do  
         @protection = protection
@@ -1153,6 +1222,26 @@ end
       aspects_should_be_equal 1, @aspect1, @aspect2
     end
 
+    it "should advise equivalent join points when :type_and_nested_types => T and :method => m is used or :pointcut =>{:type_and_nested_types => T, :method => m} is used." do
+      @aspect1 = Aspect.new :after, :type_and_nested_types => Aquarium::AspectInvocationTestClass, :method => :public_test_method, &@advice
+      @aspect2 = Aspect.new :after, :pointcut => {:type_and_nested_types => Aquarium::AspectInvocationTestClass, :method => :public_test_method}, &@advice
+      aspects_should_be_equal 1, @aspect1, @aspect2
+    end
+
+    it "should advise equivalent join points when :type_and_nested_types => T and :method => m is used or :pointcut => pointcut is used, where pointcut matches :type_and_nested_types => T and :method => m." do
+      @aspect1 = Aspect.new :after, :type_and_nested_types => Aquarium::AspectInvocationTestClass, :method => :public_test_method, &@advice
+      pointcut = Aquarium::Aspects::Pointcut.new :type_and_nested_types => Aquarium::AspectInvocationTestClass, :method => :public_test_method
+      @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+      aspects_should_be_equal 1, @aspect1, @aspect2
+    end
+  
+    it "should advise equivalent join points when :pointcut =>{:type_and_nested_types => T, :method => m} is used or :pointcut => pointcut is used, where pointcut matches :type_and_nested_types => T and :method => m." do
+      @aspect1 = Aspect.new :after, :pointcut => {:type_and_nested_types => Aquarium::AspectInvocationTestClass, :method => :public_test_method}, &@advice
+      pointcut = Aquarium::Aspects::Pointcut.new :type_and_nested_types => Aquarium::AspectInvocationTestClass, :method => :public_test_method
+      @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+      aspects_should_be_equal 1, @aspect1, @aspect2
+    end
+
   end
 
   describe Aspect, ".new (with a :type(s) parameter and an :attributes(s) parameter or one of several equivalent :pointcut parameters)" do
@@ -1407,7 +1496,7 @@ end
   end
   
   describe Aspect, ".new (advice block to around advice with just the join_point parameter - Bug #19262)" do  
-    it "should work not raise an error" do
+    it "should not raise an error" do
       aspect = Aspect.new :around, :type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method do |jp|; jp.proceed; end
       Aquarium::AspectInvocationTestClass.new.public_test_method
       aspect.unadvise
@@ -1439,7 +1528,7 @@ end
     def doit3; end
   end  
 
-  describe Aspect, ".new (with a :type(s) parameter and an :exclude_type(s), and :exclude_type(s)_and_ancestors, or an :exclude_type(s)_and_descendents parameter)" do  
+  describe Aspect, ".new (with a :type(s) parameter and an :exclude_type(s), and :exclude_type(s)_and_ancestors, an :exclude_type(s)_and_descendents, or an :exclude_type(s)_and_nested_types parameter)" do  
     before :all do
       @included_types = [DontExclude1, DontExclude2]
       @excluded_types = [Exclude1, Exclude2]
@@ -1496,6 +1585,16 @@ end
       end
     end
 
+    it "should accept :type(s) => [T1, ...], :exclude_types_and_nested_types => [T2, ...] and exclude join points in the excluded types" do  
+      do_exclude_types :exclude_types_and_nested_types
+    end
+  
+    Aspect::CANONICAL_OPTIONS["exclude_types_and_nested_types"].each do |key|
+      it "should accept :#{key} as a synonym for :exclude_types_and_nested_types." do
+        lambda { Aspect.new :before, :types => @all_types, key.intern => @excluded_types, :methods => :doit, :noop => true do; end }.should_not raise_error
+      end
+    end
+
   end
 
 
@@ -1650,6 +1749,27 @@ end
     end
   end
   
+  describe Aspect, ".new (with a :type(s)_and_nested_types parameter and an :exclude_join_point(s) parameter)" do  
+    it "should accept :type(s)_and_nested_types => [T1, ...], :exclude_join_point(s) => [jps], where [jps] are the list of join points for the types and methods to exclude" do  
+      included_types = [ClassWithPublicInstanceMethod, ModuleWithPublicInstanceMethod]
+      excluded_join_point1 = JoinPoint.new :type => ClassWithPublicInstanceMethod, :method => :public_instance_test_method
+      excluded_join_point2 = JoinPoint.new :type => ModuleWithPublicInstanceMethod, :method => :public_instance_module_test_method
+      excluded_join_points = [excluded_join_point1, excluded_join_point2]
+      aspect = nil
+      advice_called = false
+      aspect = Aspect.new :before, :types_and_nested_types => included_types, :methods => :doit, 
+        :exclude_join_points => excluded_join_points, :ignore_no_matching_join_points => true do |jp, obj, *args|; advice_called = true; end
+
+      advice_called = false
+      ClassWithPublicInstanceMethod.new.public_instance_test_method
+      advice_called.should be_false
+      advice_called = false
+      ClassIncludingModuleWithPublicInstanceMethod.new.public_instance_module_test_method
+      advice_called.should be_false
+      aspect.unadvise
+    end
+  end
+  
   describe Aspect, ".new (with a :pointcut(s) parameter and an :exclude_join_point(s) parameter)" do  
     it "should accept :pointcut(s) => [P1, ...], :exclude_join_point(s) => [jps], where [jps] are the list of join points for the types and methods to exclude" do  
       included_types = [DontExclude1, DontExclude2]
@@ -1716,7 +1836,7 @@ end
   
     Aspect::CANONICAL_OPTIONS["exclude_pointcuts"].each do |key|
       it "should accept :#{key} as a synonym for :exclude_pointcuts." do
-        lambda {aspect = Aspect.new :before, :objects => @all_objects, :exclude_pointcuts => @excluded_pointcuts, :methods => :doit, :noop => true do; end}.should_not raise_error
+        lambda {aspect = Aspect.new :before, :objects => @all_objects, key.intern => @excluded_pointcuts, :methods => :doit, :noop => true do; end}.should_not raise_error
       end
     end
   end
@@ -1787,40 +1907,82 @@ end
     end
   end
 
-  describe Aspect, ".new (with type-based :pointcut(s) and :exclude_type(s) parameter)" do  
-    it "should accept :pointcut(s) => [P1, ...], :exclude_type(s) => [types], where join points with [types] are excluded" do  
-      included_types = [DontExclude1, DontExclude2]
-      excluded_types = [Exclude1, Exclude2]
-      pointcut1 = Pointcut.new :types => included_types, :method => :doit
-      pointcut2 = Pointcut.new :types => excluded_types, :method => :doit
+  describe Aspect, ".new (with a :pointcut(s) and an :exclude_named_pointcut(s) parameter)" do  
+    it "should accept :pointcut(s) => [P1, ...], :exclude_named_pointcut(s) => {...}, where any pointcuts matching the latter are excluded" do  
       aspect = nil
       advice_called = false
-      aspect = Aspect.new :before, :pointcuts => [pointcut1, pointcut2], :exclude_types => excluded_types do |jp, obj, *args|
+      aspect = Aspect.new :before, :pointcuts => Aquarium::PointcutFinderTestClasses.all_pointcuts, 
+        :exclude_named_pointcuts => {:matching => /POINTCUT/, :in_types => Aquarium::PointcutFinderTestClasses.all_pointcut_classes} do |jp, obj, *args|
         advice_called = true
-        excluded_types.should_not include(jp.target_type)
+        Aquarium::PointcutFinderTestClasses.all_constants_pointcut_classes.should_not include(jp.target_type)
       end 
+      Aquarium::PointcutFinderTestClasses.all_class_variables_pointcut_classes.each do |type|
+        advice_called = false
+        type.new.doit
+        advice_called.should be_true
+      end
+      Aquarium::PointcutFinderTestClasses.all_constants_pointcut_classes.each do |type|
+        advice_called = false
+        type.new.doit
+        advice_called.should_not be_true
+      end
+      aspect.unadvise
+    end
 
-      included_types.each do |type|
+    Aspect::CANONICAL_OPTIONS["exclude_named_pointcuts"].each do |key|
+      it "should accept :#{key} as a synonym for :exclude_named_pointcuts." do
+        lambda {aspect = Aspect.new :before,  :pointcuts => Aquarium::PointcutFinderTestClasses.all_pointcuts, 
+          key.intern => {:matching => /POINTCUT/, :in_types => Aquarium::PointcutFinderTestClasses.all_pointcut_classes},
+          :noop => true do; end}.should_not raise_error
+      end
+    end
+  end
+  
+  describe Aspect, ".new (with type-based :pointcut(s) and :exclude_type(s) parameter)" do 
+    before :all do
+      @included_types = [DontExclude1, DontExclude2]
+      @excluded_types = [Exclude1, Exclude2]
+      @pointcut1 = Pointcut.new :types => @included_types, :method => :doit
+      @pointcut2 = Pointcut.new :types => @excluded_types, :method => :doit
+    end
+       
+    it "should accept :pointcut(s) => [P1, ...], :exclude_type(s) => [types], where join points with [types] are excluded" do  
+      advice_called = false
+      aspect = Aspect.new :before, :pointcuts => [@pointcut1, @pointcut2], :exclude_types => @excluded_types do |jp, obj, *args|
+        advice_called = true
+        @excluded_types.should_not include(jp.target_type)
+      end 
+
+      @included_types.each do |type|
         advice_called = false
         type.new(1).doit
         advice_called.should be_true
       end
-      excluded_types.each do |type|
+      @excluded_types.each do |type|
         advice_called = false
         type.new(1).doit
         advice_called.should_not be_true
       end
       aspect.unadvise
     end
+
+    Aspect::CANONICAL_OPTIONS["exclude_types"].each do |key|
+      it "should accept :#{key} as a synonym for :exclude_types." do
+        lambda {aspect = Aspect.new :before,  :pointcuts => [@pointcut1, @pointcut2], key.intern => @excluded_types,
+          :noop => true do; end}.should_not raise_error
+      end
+    end
   end
 
   describe Aspect, ".new (with type-based :pointcut(s) and :exclude_type(s)_and_ancestors parameter)" do  
+    before :all do
+      @excluded_types = [ClassWithPublicInstanceMethod, ModuleWithPublicInstanceMethod]
+      @types = @excluded_types + [ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod]
+      @pointcut1 = Pointcut.new :types => @types, :method => :all, :method_options => [:exclude_ancestor_methods]
+    end
+    
     it "should accept :pointcut(s) => [P1, ...], :exclude_type(s)_and_ancestors => [types], where join points with [types] are excluded" do  
-      excluded_types = [ClassWithPublicInstanceMethod, ModuleWithPublicInstanceMethod]
-      types = excluded_types + [ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod]
-      pointcut1 = Pointcut.new :types => types, :method => :all, :method_options => [:exclude_ancestor_methods]
-      advice_called = false
-      aspect = Aspect.new :before, :pointcuts => pointcut1, :exclude_types_and_ancestors => excluded_types do |jp, obj, *args|; end
+      aspect = Aspect.new :before, :pointcuts => @pointcut1, :exclude_types_and_ancestors => @excluded_types do |jp, obj, *args|; end
       aspect.pointcuts.each do |pc|
         pc.join_points_matched.each do |jp|
           jp.target_type.should == ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod
@@ -1828,48 +1990,95 @@ end
       end
       aspect.unadvise
     end
+
+    Aspect::CANONICAL_OPTIONS["exclude_types_and_ancestors"].each do |key|
+      it "should accept :#{key} as a synonym for :exclude_types_and_ancestors." do
+        lambda {aspect = Aspect.new :before,  :pointcuts => @pointcut1, key.intern => @excluded_types,
+          :noop => true do; end}.should_not raise_error
+      end
+    end
   end
 
   describe Aspect, ".new (with type-based :pointcut(s) and :exclude_type(s)_and_descendents parameter)" do  
+    before :all do
+      @excluded_types = [ClassWithPublicInstanceMethod, ModuleWithPublicInstanceMethod]
+      @types = @excluded_types + [ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod]
+      @pointcut1 = Pointcut.new :types => @types, :method => :all, :method_options => [:exclude_ancestor_methods]
+    end
     it "should accept :pointcut(s) => [P1, ...], :exclude_type(s)_and_descendents => [types], where join points with [types] are excluded" do  
-      excluded_types = [ClassWithPublicInstanceMethod, ModuleWithPublicInstanceMethod]
-      types = excluded_types + [ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod]
-      pointcut1 = Pointcut.new :types => types, :method => :all, :method_options => [:exclude_ancestor_methods]
-      advice_called = false
-      aspect = Aspect.new :before, :pointcuts => pointcut1, :exclude_types_and_descendents => excluded_types, :ignore_no_matching_join_points => true do |jp, obj, *args|; end
+      aspect = Aspect.new :before, :pointcuts => @pointcut1, :exclude_types_and_descendents => @excluded_types, 
+        :ignore_no_matching_join_points => true do |jp, obj, *args|; end
       aspect.pointcuts.size.should == 0
       aspect.unadvise
     end
+
+    Aspect::CANONICAL_OPTIONS["exclude_types_and_descendents"].each do |key|
+      it "should accept :#{key} as a synonym for :exclude_types_and_descendents." do
+        lambda {aspect = Aspect.new :before, :pointcuts => @pointcut1, key.intern => @excluded_types,
+          :ignore_no_matching_join_points => true, :noop => true do; end}.should_not raise_error
+      end
+    end
+  end
+
+  describe Aspect, ".new (with type-based :pointcut(s) and :exclude_type(s)_and_nested_types parameter)" do  
+    before :all do
+      @excluded_types = [ClassWithPublicInstanceMethod, ModuleWithPublicInstanceMethod]
+      @types = @excluded_types + [ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod]
+      @pointcut1 = Pointcut.new :types => @types, :method => :all, :method_options => [:exclude_ancestor_methods]
+    end
+    it "should accept :pointcut(s) => [P1, ...], :exclude_type(s)_and_nested_types => [types], where join points with [types] are excluded" do  
+      aspect = Aspect.new :before, :pointcuts => @pointcut1, :exclude_types_and_nested_types => @excluded_types, 
+        :ignore_no_matching_join_points => true do |jp, obj, *args|; end
+      aspect.pointcuts.size.should == 1
+      aspect.unadvise
+    end
+
+    Aspect::CANONICAL_OPTIONS["exclude_types_and_nested_types"].each do |key|
+      it "should accept :#{key} as a synonym for :exclude_types_and_nested_types." do
+        lambda {aspect = Aspect.new :before, :pointcuts => @pointcut1, key.intern => @excluded_types,
+          :ignore_no_matching_join_points => true, :noop => true do; end}.should_not raise_error
+      end
+    end
   end
 
-  describe Aspect, ".new (with object-based :pointcut(s) and :exclude_object(s) or :exclude_method(s) parameter)" do  
+  describe Aspect, ".new (with object-based :pointcut(s) and :exclude_object(s) parameter)" do  
+    before :all do
+      @dontExclude1 = DontExclude1.new(1)
+      @dontExclude2 = DontExclude1.new(2)
+      @exclude1 = DontExclude1.new(3)
+      @exclude2 = DontExclude1.new(4)
+      @included_objects = [@dontExclude1, @dontExclude2]
+      @excluded_objects = [@exclude1, @exclude2]
+      @pointcut1 = Pointcut.new :objects => @included_objects, :method => :doit
+      @pointcut2 = Pointcut.new :objects => @excluded_objects, :method => :doit
+    end
+    
     it "should accept :pointcut(s) => [P1, ...], :exclude_object(s) => [objects], where join points with [objects] are excluded" do  
-      dontExclude1 = DontExclude1.new(1)
-      dontExclude2 = DontExclude1.new(2)
-      exclude1 = DontExclude1.new(3)
-      exclude2 = DontExclude1.new(4)
-      included_objects = [dontExclude1, dontExclude2]
-      excluded_objects = [exclude1, exclude2]
-      pointcut1 = Pointcut.new :objects => included_objects, :method => :doit
-      pointcut2 = Pointcut.new :objects => excluded_objects, :method => :doit
       aspect = nil
       advice_called = false
-      aspect = Aspect.new :before, :pointcuts => [pointcut1, pointcut2], :exclude_objects => excluded_objects do |jp, obj, *args|
+      aspect = Aspect.new :before, :pointcuts => [@pointcut1, @pointcut2], :exclude_objects => @excluded_objects do |jp, obj, *args|
         advice_called = true
-        excluded_objects.should_not include(obj)
+        @excluded_objects.should_not include(obj)
       end 
-      included_objects.each do |object|
+      @included_objects.each do |object|
         advice_called = false
         object.doit
         advice_called.should be_true
       end
-      excluded_objects.each do |object|
+      @excluded_objects.each do |object|
         advice_called = false
         object.doit
         advice_called.should_not be_true
       end
       aspect.unadvise
     end
+
+    Aspect::CANONICAL_OPTIONS["exclude_objects"].each do |key|
+      it "should accept :#{key} as a synonym for :exclude_objects." do
+        lambda {aspect = Aspect.new :before, :pointcuts => [@pointcut1, @pointcut2], key.intern => @excluded_objects,
+          :noop => true do; end}.should_not raise_error
+      end
+    end
   end
 
   describe Aspect, ".new (with :method(s) and :exclude_method(s) parameter)" do