rr 0.10.10 → 0.10.11

data/spec/spec_helper.rb

@@ -29,82 +29,6 @@ class Spec::ExampleGroup
         define_method(name, &implementation)
       end
     end
-
-    define_method("normal strategy definition") do
-      describe "strategy definition" do
-        attr_reader :strategy_method_name
-
-        context "when passed a subject" do
-          it "returns a DoubleDefinitionCreatorProxy" do
-            double = call_strategy(subject).foobar
-            double.should be_instance_of(RR::DoubleDefinitions::DoubleDefinition)
-          end
-        end
-
-        context "when passed a method name and a definition_eval_block" do
-          it "raises an ArgumentError" do
-            lambda do
-              call_strategy(subject, :foobar) {}
-            end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
-          end
-        end
-      end
-    end
-
-    define_method("! strategy definition") do
-      describe "strategy definition" do
-        attr_reader :strategy_method_name
-
-        context "when not passed a method_name argument" do
-          it "returns a DoubleDefinitionCreatorProxy" do
-            call_strategy.should respond_to(:__subject__)
-          end
-
-          context "when passed a definition_eval_block argument" do
-            it "calls the definition_eval_block and passes in the DoubleDefinitionCreatorProxy" do
-              passed_in_proxy = nil
-              proxy = call_strategy do |proxy|
-                passed_in_proxy = proxy
-              end
-
-              passed_in_proxy.should == proxy
-            end
-          end
-        end
-
-        context "when passed a method_name argument" do
-          it "returns a DoubleDefinition" do
-            double_definition = call_strategy(:foobar)
-            double_definition.class.should == RR::DoubleDefinitions::DoubleDefinition
-          end
-
-          describe "the returned DoubleDefinition" do
-            it "has #subject set to an anonymous Object" do
-              double_definition = call_strategy(:foobar)
-              double_definition.subject.class.should == Object
-            end
-          end
-        end
-
-        context "when passed a method name and a definition_eval_block" do
-          it "raises an ArgumentError" do
-            lambda do
-              call_strategy(:foobar) {}
-            end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
-          end
-        end
-      end
-    end
-  end
-
-  def new_double(
-    double_injection=double_injection,
-    double_definition=RR::DoubleDefinitions::DoubleDefinition.new(creator = RR::DoubleDefinitions::DoubleDefinitionCreator.new, subject).with_any_args.any_number_of_times
-  )
-    RR::Double.new(
-      double_injection,
-      double_definition
-    )
   end
 
   def eigen(object)

data/spec/spy_verification_spec.rb

@@ -119,7 +119,7 @@ describe RR::SpyVerification do
 
     context "when the subject is expected where there is not DoubleInjection" do
       it "raises a DoubleInjectionNotFoundError" do
-        space.double_injection_exists?(subject, :method_that_does_not_exist).should be_false
+        ::RR::Injections::DoubleInjection.exists?(subject, :method_that_does_not_exist).should be_false
         lambda do
           received(subject).method_that_does_not_exist.call
         end.should raise_error(RR::Errors::SpyVerificationErrors::DoubleInjectionNotFoundError)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rr
 version: !ruby/object:Gem::Version 
-  version: 0.10.10
+  version: 0.10.11
 platform: ruby
 authors: 
 - Brian Takita
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-25 00:00:00 -08:00
+date: 2010-03-22 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -32,11 +32,12 @@ files:
 - lib/rr/adapters/rr_methods.rb
 - lib/rr/adapters/rspec.rb
 - lib/rr/adapters/test_unit.rb
+- lib/rr/blank_slate.rb
 - lib/rr/double.rb
-- lib/rr/double_definitions/child_double_definition_creator.rb
+- lib/rr/double_definitions/child_double_definition_create.rb
 - lib/rr/double_definitions/double_definition.rb
-- lib/rr/double_definitions/double_definition_creator.rb
-- lib/rr/double_definitions/double_definition_creator_proxy.rb
+- lib/rr/double_definitions/double_definition_create.rb
+- lib/rr/double_definitions/double_definition_create_blank_slate.rb
 - lib/rr/double_definitions/strategies/implementation/implementation_strategy.rb
 - lib/rr/double_definitions/strategies/implementation/proxy.rb
 - lib/rr/double_definitions/strategies/implementation/reimplementation.rb
@@ -97,7 +98,6 @@ files:
 - lib/rr/wildcard_matchers/range.rb
 - lib/rr/wildcard_matchers/regexp.rb
 - lib/rr/wildcard_matchers/satisfy.rb
-- ruby_19_spec.rb
 - spec/api/dont_allow/dont_allow_after_stub_spec.rb
 - spec/api/mock/mock_spec.rb
 - spec/api/proxy/proxy_spec.rb
@@ -113,12 +113,10 @@ files:
 - spec/rr/adapters/rr_methods_spec_helper.rb
 - spec/rr/adapters/rr_methods_times_matcher_spec.rb
 - spec/rr/double_definitions/child_double_definition_creator_spec.rb
-- spec/rr/double_definitions/double_definition_creator_proxy_spec.rb
-- spec/rr/double_definitions/double_definition_creator_spec.rb
-- spec/rr/double_definitions/double_definition_spec.rb
+- spec/rr/double_definitions/double_definition_create_blank_slate_spec.rb
+- spec/rr/double_definitions/double_definition_create_spec.rb
 - spec/rr/double_injection/double_injection_spec.rb
 - spec/rr/double_injection/double_injection_verify_spec.rb
-- spec/rr/double_spec.rb
 - spec/rr/errors/rr_error_spec.rb
 - spec/rr/expectations/any_argument_expectation_spec.rb
 - spec/rr/expectations/anything_argument_equality_expectation_spec.rb
@@ -135,7 +133,6 @@ files:
 - spec/rr/expectations/times_called_expectation/times_called_expectation_integer_spec.rb
 - spec/rr/expectations/times_called_expectation/times_called_expectation_proc_spec.rb
 - spec/rr/expectations/times_called_expectation/times_called_expectation_range_spec.rb
-- spec/rr/expectations/times_called_expectation/times_called_expectation_spec.rb
 - spec/rr/rspec/invocation_matcher_spec.rb
 - spec/rr/rspec/rspec_adapter_spec.rb
 - spec/rr/rspec/rspec_backtrace_tweaking_spec.rb

data/lib/rr/double_definitions/double_definition_creator_proxy.rb

@@ -1,37 +0,0 @@
-module RR
-  module DoubleDefinitions
-    class DoubleDefinitionCreatorProxy
-      class << self
-        def blank_slate_methods
-          instance_methods.each do |m|
-            unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == 'respond_to?' || m.to_s == 'method_missing' || m.to_s == 'instance_eval' || m.to_s == 'instance_exec'
-              alias_method "__blank_slated_#{m}", m
-              undef_method m
-            end
-          end
-        end
-      end
-
-      def initialize(creator, &block) #:nodoc:
-        @creator = creator
-        respond_to?(:class) ? self.class.blank_slate_methods : __blank_slated_class.blank_slate_methods
-
-        if block_given?
-          if block.arity == 1
-            yield(self)
-          else
-            respond_to?(:instance_eval) ? instance_eval(&block) : __blank_slated_instance_eval(&block)
-          end
-        end
-      end
-
-      def method_missing(method_name, *args, &block)
-        @creator.create(method_name, *args, &block)
-      end
-
-      def __creator__
-        @creator
-      end
-    end    
-  end
-end

data/ruby_19_spec.rb

@@ -1,12 +0,0 @@
-require 'rubygems'
-require 'spec'
-require 'rr'
-include RR::Adapters::Rspec
-
-mock( socket = Object.new )
-stub(socket).bind("", 3333)
-
-stub(UDPSocket).new { socket }
-
-UDPSocket.new.bind( "", 3333 )
-UDPSocket.new.bind( "", 3333 )

data/spec/rr/double_definitions/double_definition_creator_proxy_spec.rb

@@ -1,124 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
-
-module RR
-  module DoubleDefinitions
-    describe DoubleDefinitionCreatorProxy do
-      attr_reader :subject, :creator, :the_proxy
-      it_should_behave_like "Swapped Space"
-
-      before(:each) do
-        @subject = Object.new
-        @creator = DoubleDefinitionCreator.new
-        creator.mock(subject)
-      end
-
-      macro("initializes proxy with passed in creator") do
-        it "initializes proxy with passed in creator" do
-          class << the_proxy
-            attr_reader :creator
-          end
-          the_proxy.creator.should === creator
-        end
-      end
-
-      describe ".new" do
-        it "does not undefine object_id" do
-          the_proxy = DoubleDefinitionCreatorProxy.new(creator)
-          the_proxy.object_id.class.should == Fixnum
-        end
-
-        context "without block" do
-          before do
-            @the_proxy = DoubleDefinitionCreatorProxy.new(creator)
-          end
-
-          send "initializes proxy with passed in creator"
-
-          it "clears out all methods from proxy" do
-            proxy_subclass = Class.new(DoubleDefinitionCreatorProxy) do
-              def i_should_be_a_double
-              end
-            end
-            proxy_subclass.instance_methods.map {|m| m.to_s}.should include('i_should_be_a_double')
-
-            proxy = proxy_subclass.new(creator)
-            proxy.i_should_be_a_double.should be_instance_of(DoubleDefinition)
-          end
-        end
-
-        context "when passed a block" do
-          macro("calls the block to define the Doubles") do
-            send "initializes proxy with passed in creator"
-
-            it "creates double_injections" do
-              subject.foobar(1, 2).should == :one_two
-              subject.foobar(1).should == :one
-              subject.foobar(:something).should == :default
-              subject.baz.should == :baz_result
-            end
-
-            it "clears out all methods from proxy" do
-              proxy_subclass = Class.new(DoubleDefinitionCreatorProxy) do
-                def i_should_be_a_double
-                end
-              end
-              proxy_subclass.instance_methods.map {|m| m.to_s}.should include('i_should_be_a_double')
-
-              proxy_subclass.new(creator) do |m|
-                m.i_should_be_a_double.should be_instance_of(DoubleDefinition)
-              end
-            end
-          end
-
-          context "when the block has an arity of 1" do
-            attr_reader :passed_in_argument
-            before do
-              passed_in_argument = nil
-              block = lambda do |b|
-                passed_in_argument = b
-                b.foobar(1, 2) {:one_two}
-                b.foobar(1) {:one}
-                b.foobar.with_any_args {:default}
-                b.baz() {:baz_result}
-              end
-              block.arity.should == 1
-
-              @the_proxy = DoubleDefinitionCreatorProxy.new(creator, &block)
-              @passed_in_argument = passed_in_argument
-            end
-
-            send("calls the block to define the Doubles")
-
-            it "passes the self into the block" do
-              passed_in_argument.__creator__.should == creator
-            end
-          end
-
-          context "when the block has an arity of 0" do
-            attr_reader :self_value
-            before do
-              self_value = nil
-              block = lambda do ||
-                self_value = self
-                foobar(1, 2) {:one_two}
-                foobar(1) {:one}
-                foobar.with_any_args {:default}
-                baz() {:baz_result}
-              end
-              block.arity.should == 0
-
-              @the_proxy = DoubleDefinitionCreatorProxy.new(creator, &block)
-              @self_value = self_value
-            end
-
-            send("calls the block to define the Doubles")
-
-            it "evaluates the block with the context of self" do
-              self_value.__creator__.should == creator
-            end
-          end
-        end
-      end
-    end    
-  end
-end

data/spec/rr/double_definitions/double_definition_spec.rb

@@ -1,1168 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
-
-module RR
-  module DoubleDefinitions
-    describe DoubleDefinition do
-      attr_reader :subject, :double_definition_creator, :double, :definition
-
-      it_should_behave_like "Swapped Space"
-
-      before do
-        @subject = Object.new
-        add_original_method
-        @double_definition_creator = DoubleDefinitionCreator.new
-        @definition = double_definition_creator.stub(subject).foobar
-        @double = definition.double
-      end      
-
-      def add_original_method
-        def subject.foobar(a, b)
-          :original_return_value
-        end
-      end
-      
-      describe "#root_subject" do
-        it "returns #double_definition_creator.root_subject" do
-          definition.root_subject.should == definition.double_definition_creator.root_subject
-          definition.root_subject.should == subject
-        end
-      end
-
-      describe "DefinitionConstructionMethods" do
-        macro("DoubleDefinition where #double_definition_creator is a Reimplementation") do
-          before do
-            definition.double_definition_creator.implementation_strategy.class.should == Strategies::Implementation::Reimplementation
-            call_double_injection
-          end
-        end
-
-        macro("DoubleDefinition where #double_definition_creator is a Proxy") do
-          before do
-            definition.double_definition_creator.proxy
-            definition.double_definition_creator.implementation_strategy.class.should == Strategies::Implementation::Proxy
-            call_double_injection
-          end
-        end
-
-        describe "#with" do
-          macro("#with") do
-            it "returns DoubleDefinition" do
-              definition.with(1).should === definition
-            end
-
-            it "sets an ArgumentEqualityExpectation" do
-              definition.should be_exact_match(1, 2)
-              definition.should_not be_exact_match(2)
-            end
-          end
-
-          context "when not passed a block" do
-            before do
-              definition.with(1, 2)
-              subject.foobar(1, 2)
-            end
-
-            send "#with"
-          end
-
-          context "when passed a block" do
-            def call_double_injection
-              actual_args = nil
-              definition.with(1, 2) do |*args|
-                actual_args = args
-                :new_return_value
-              end
-              subject.foobar(1, 2)
-              @return_value = subject.foobar(1, 2)
-              @args = actual_args
-            end
-
-            context "when #double_definition_creator.implementation_strategy is a Reimplementation" do
-              send "DoubleDefinition where #double_definition_creator is a Reimplementation"
-              send "#with"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [1, 2]
-                end
-              end
-            end
-
-            context "when #double_definition_creator.implementation_strategy is a Proxy" do
-              send "DoubleDefinition where #double_definition_creator is a Proxy"
-              send "#with"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [:original_return_value]
-                end
-              end
-            end
-          end
-        end
-
-        describe "#with_any_args" do
-          macro "#with_any_args" do
-            it "returns DoubleDefinition" do
-              definition.with_no_args.should === definition
-            end
-
-            it "sets an AnyArgumentExpectation" do
-              definition.should_not be_exact_match(1)
-              definition.should be_wildcard_match(1)
-            end
-          end
-
-          context "when not passed a block" do
-            before do
-              definition.with_any_args
-            end
-
-            send "#with_any_args"
-          end
-
-          context "when passed a block" do
-            def call_double_injection
-              actual_args = nil
-              definition.with_any_args do |*args|
-                actual_args = args
-                :new_return_value
-              end
-              @return_value = subject.foobar(1, 2)
-              @args = actual_args
-            end
-
-            context "when #double_definition_creator.implementation_strategy is a Reimplementation" do
-              send "DoubleDefinition where #double_definition_creator is a Reimplementation"
-              send "#with_any_args"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [1, 2]
-                end
-              end
-            end
-
-            context "when #double_definition_creator.implementation_strategy is a Proxy" do
-              send "DoubleDefinition where #double_definition_creator is a Proxy"
-              send "#with_any_args"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [:original_return_value]
-                end
-              end
-            end
-          end
-        end
-
-        describe "#with_no_args" do
-          macro "#with_no_args" do
-            it "returns DoubleDefinition" do
-              definition.with_no_args.should === definition
-            end
-
-            it "sets an ArgumentEqualityExpectation with no arguments" do
-              definition.argument_expectation.should == RR::Expectations::ArgumentEqualityExpectation.new()
-            end
-          end
-
-          def add_original_method
-            def subject.foobar()
-              :original_return_value
-            end
-          end
-
-          context "when not passed a block" do
-            before do
-              definition.with_no_args
-            end
-
-            send "#with_no_args"
-          end
-
-          context "when passed a block" do
-            def call_double_injection
-              actual_args = nil
-              definition.with_no_args do |*args|
-                actual_args = args
-                :new_return_value
-              end
-              @return_value = subject.foobar
-              @args = actual_args
-            end
-
-            context "when #double_definition_creator.implementation_strategy is a Reimplementation" do
-              send "DoubleDefinition where #double_definition_creator is a Reimplementation"
-              send "#with_no_args"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == []
-                end
-              end
-            end
-
-            context "when #double_definition_creator.implementation_strategy is a Proxy" do
-              send "DoubleDefinition where #double_definition_creator is a Proxy"
-              send "#with_no_args"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [:original_return_value]
-                end
-              end
-            end
-          end
-        end
-
-        describe "#never" do
-          it "returns DoubleDefinition" do
-            definition.never.should === definition
-          end
-
-          it "sets up a Times Called Expectation with 0" do
-            definition.with_any_args
-            definition.never
-            lambda {subject.foobar}.should raise_error(RR::Errors::TimesCalledError)
-          end
-
-          describe "#subject.method_name being called" do
-            it "raises a TimesCalledError" do
-              definition.with_any_args.never
-              lambda {subject.foobar}.should raise_error(RR::Errors::TimesCalledError)
-            end
-          end
-        end
-
-        describe "#once" do
-          macro "#once" do
-            it "returns DoubleDefinition" do
-              definition.once.should === definition
-            end
-
-            it "sets up a Times Called Expectation with 1" do
-              lambda {subject.foobar}.should raise_error(RR::Errors::TimesCalledError)
-            end
-          end
-
-          context "when not passed a block" do
-            before do
-              definition.with_any_args.once
-              subject.foobar(1, 2)
-            end
-
-            send "#once"
-          end
-
-          context "when passed a block" do
-            def call_double_injection
-              actual_args = nil
-              definition.with_any_args.once do |*args|
-                actual_args = args
-                :new_return_value
-              end
-              @return_value = subject.foobar(1, 2)
-              @args = actual_args
-            end
-
-            context "with returns block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Reimplementation"
-              send "#once"
-
-              describe "#subject.method_name being called with any arguments" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [1, 2]
-                end
-              end
-            end
-
-            context "with after_call block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Proxy"
-              send "#once"
-
-              describe "#subject.method_name being called with any arguments" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [:original_return_value]
-                end
-              end
-            end
-          end
-        end
-
-        describe "#twice" do
-          macro "#twice" do
-            it "returns DoubleDefinition" do
-              definition.twice.should === definition
-            end
-
-            it "sets up a Times Called Expectation with 2" do
-              definition.twice.with_any_args
-              lambda {subject.foobar(1, 2)}.should raise_error(RR::Errors::TimesCalledError)
-            end
-          end
-
-          context "when not passed a block" do
-            before do
-              definition.with_any_args.twice
-              subject.foobar(1, 2)
-              subject.foobar(1, 2)
-            end
-
-            send "#twice"
-          end
-
-          context "when passed a block" do
-            def call_double_injection
-              actual_args = nil
-              definition.with_any_args.twice do |*args|
-                actual_args = args
-                :new_return_value
-              end
-              subject.foobar(1, 2)
-              @return_value = subject.foobar(1, 2)
-              @args = actual_args
-            end
-
-            context "with returns block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Reimplementation"
-              send "#twice"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [1, 2]
-                end
-              end
-            end
-
-            context "with after_call block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Proxy"
-              send "#twice"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [:original_return_value]
-                end
-              end
-            end
-          end
-        end
-
-        describe "#at_least" do
-          macro "#at_least" do
-            it "returns DoubleDefinition" do
-              definition.with_any_args.at_least(2).should === definition
-            end
-
-            it "sets up a Times Called Expectation with 1" do
-              definition.times_matcher.should == RR::TimesCalledMatchers::AtLeastMatcher.new(2)
-            end
-          end
-
-          context "when not passed a block" do
-            before do
-              definition.with_any_args.at_least(2)
-              subject.foobar(1, 2)
-            end
-
-            send "#at_least"
-          end
-
-          context "when passed a block" do
-            def call_double_injection
-              actual_args = nil
-              definition.with_any_args.at_least(2) do |*args|
-                actual_args = args
-                :new_return_value
-              end
-              subject.foobar(1, 2)
-              @return_value = subject.foobar(1, 2)
-              @args = actual_args
-            end
-
-            context "with returns block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Reimplementation"
-              send "#at_least"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [1, 2]
-                end
-              end
-            end
-
-            context "with after_call block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Proxy"
-              send "#at_least"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [:original_return_value]
-                end
-              end
-            end
-          end
-        end
-
-        describe "#at_most" do
-          macro "#at_most" do
-            it "returns DoubleDefinition" do
-              definition.with_any_args.at_most(2).should === definition
-            end
-
-            it "sets up a Times Called Expectation with 1" do
-              lambda do
-                subject.foobar
-              end.should raise_error(RR::Errors::TimesCalledError, "foobar()\nCalled 3 times.\nExpected at most 2 times.")
-            end
-          end
-
-          context "when not passed a block" do
-            before do
-              definition.with_any_args.at_most(2)
-              subject.foobar(1, 2)
-              subject.foobar(1, 2)
-            end
-
-            send "#at_most"
-          end
-
-          context "when passed a block" do
-            def call_double_injection
-              actual_args = nil
-              definition.with_any_args.at_most(2) do |*args|
-                actual_args = args
-                :new_return_value
-              end
-              subject.foobar(1, 2)
-              @return_value = subject.foobar(1, 2)
-              @args = actual_args
-            end
-
-            context "with returns block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Reimplementation"
-              send "#at_most"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [1, 2]
-                end
-              end
-            end
-
-            context "with after_call block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Proxy"
-              send "#at_most"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [:original_return_value]
-                end
-              end
-            end
-          end
-        end
-
-        describe "#times" do
-          macro "#times" do
-            it "returns DoubleDefinition" do
-              definition.times(3).should === definition
-            end
-
-            it "sets up a Times Called Expectation with passed in times" do
-              lambda {subject.foobar(1, 2)}.should raise_error(RR::Errors::TimesCalledError)
-            end
-          end
-
-          context "when not passed a block" do
-            before do
-              definition.with(1, 2).times(3)
-              subject.foobar(1, 2)
-              subject.foobar(1, 2)
-              subject.foobar(1, 2)
-            end
-
-            send "#times"
-          end
-
-          context "when passed a block" do
-            def call_double_injection
-              actual_args = nil
-              definition.with(1, 2).times(3) do |*args|
-                actual_args = args
-                :new_return_value
-              end
-              subject.foobar(1, 2)
-              subject.foobar(1, 2)
-              @return_value = subject.foobar(1, 2)
-              @args = actual_args
-            end
-
-            context "with returns block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Reimplementation"
-              send "#times"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [1, 2]
-                end
-              end
-            end
-
-            context "with after_call block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Proxy"
-              send "#times"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [:original_return_value]
-                end
-              end
-            end
-          end
-        end
-
-        describe "#any_number_of_times" do
-          macro "#any_number_of_times" do
-            it "returns DoubleDefinition" do
-              definition.any_number_of_times.should === definition
-            end
-
-            it "sets up a Times Called Expectation with AnyTimes matcher" do
-              definition.times_matcher.should == RR::TimesCalledMatchers::AnyTimesMatcher.new
-            end
-          end
-
-          context "when not passed a block" do
-            before do
-              definition.with(1, 2).any_number_of_times
-              subject.foobar(1, 2)
-            end
-
-            send "#any_number_of_times"
-          end
-
-          context "when passed a block" do
-            def call_double_injection
-              actual_args = nil
-              definition.with(1, 2).any_number_of_times do |*args|
-                actual_args = args
-                :new_return_value
-              end
-              subject.foobar(1, 2)
-              @return_value = subject.foobar(1, 2)
-              @args = actual_args
-            end
-
-            context "with returns block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Reimplementation"
-              send "#any_number_of_times"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [1, 2]
-                end
-              end
-            end
-
-            context "with after_call block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Proxy"
-              send "#any_number_of_times"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [:original_return_value]
-                end
-              end
-            end
-          end
-        end
-
-        describe "#ordered" do
-          macro "#ordered" do
-            it "adds itself to the ordered doubles list" do
-              definition.ordered
-              RR::Space.instance.ordered_doubles.should include(double)
-            end
-
-            it "does not double_injection add itself" do
-              definition.ordered
-              RR::Space.instance.ordered_doubles.should == [double]
-            end
-
-            it "sets ordered? to true" do
-              definition.should be_ordered
-            end
-
-            context "when there is no Double" do
-              it "raises a DoubleDefinitionError" do
-                definition.double = nil
-                lambda do
-                  definition.ordered
-                end.should raise_error(
-                  RR::Errors::DoubleDefinitionError,
-                  "Double Definitions must have a dedicated Double to be ordered. " <<
-                  "For example, using instance_of does not allow ordered to be used. " <<
-                  "proxy the class's #new method instead."
-                )
-              end
-            end
-          end
-
-          context "when not passed a block" do
-            before do
-              definition.with(1, 2).once.ordered
-              subject.foobar(1, 2)
-            end
-
-            send "#ordered"
-          end
-
-          context "when passed a block" do
-            def call_double_injection
-              actual_args = nil
-              definition.with(1, 2).once.ordered do |*args|
-                actual_args = args
-                :new_return_value
-              end
-              @return_value = subject.foobar(1, 2)
-              @args = actual_args
-            end
-
-            context "with returns block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Reimplementation"
-              send "#ordered"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [1, 2]
-                end
-              end
-            end
-
-            context "with after_call block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Proxy"
-              send "#ordered"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [:original_return_value]
-                end
-              end
-            end
-          end
-        end
-
-        describe "#yields" do
-          macro "#yields" do
-            it "returns DoubleDefinition" do
-              definition.yields(:baz).should === definition
-            end
-
-            context "when there is a no returns value set" do
-              it "yields the passed in argument to the call block" do
-                @passed_in_block_arg.should == :baz
-              end
-            end
-          end
-
-          context "when not passed a block" do
-            before do
-              definition.with(1, 2).once.yields(:baz)
-              passed_in_block_arg = nil
-              subject.foobar(1, 2) do |arg|
-                passed_in_block_arg = arg
-              end
-              @passed_in_block_arg = passed_in_block_arg
-            end
-
-            send "#yields"
-          end
-
-          context "when passed a block" do
-            def call_double_injection
-              actual_args = nil
-              definition.with(1, 2).once.yields(:baz) do |*args|
-                actual_args = args
-                :new_return_value
-              end
-              passed_in_block_arg = nil
-              @block = lambda do |arg|
-                passed_in_block_arg = arg
-              end
-              @return_value = subject.foobar(1, 2, &@block)
-              @passed_in_block_arg = passed_in_block_arg
-
-              @args = actual_args
-            end
-
-            context "with returns block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Reimplementation"
-              send "#yields"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                end
-
-                it "passes an array of the args with the block appended as a RR::ProcFromBlock around the original block" do
-                  @args.length.should == 3
-                  @args[0..1].should == [1, 2]
-                  @args[2].should be_instance_of(RR::ProcFromBlock)
-                  @block.should == Proc.new(&@block)
-                  @args[2].should == @block
-                end
-              end
-            end
-
-            context "with after_call block_callback_strategy" do
-              send "DoubleDefinition where #double_definition_creator is a Proxy"
-              send "#yields"
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the block" do
-                  @return_value.should == :new_return_value
-                  @args.should == [:original_return_value]
-                end
-              end
-            end
-          end
-        end
-
-        describe "#after_call" do
-          context "when passed a block" do
-            it "returns DoubleDefinition" do
-              definition.after_call {}.should === definition
-            end
-
-            describe "#subject.method_name being called" do
-              it "calls the block with the return value of the implementation" do
-                return_value = {:original => :value}
-                definition.with_any_args.returns(return_value).after_call do |value|
-                  value[:foo] = :bar
-                  value
-                end
-
-                actual_value = subject.foobar
-                actual_value.should === return_value
-                actual_value.should == {:original => :value, :foo => :bar}
-              end
-
-              context "when the return value of the #after_call_proc is a DoubleDefinition" do
-                it "returns the #subject of the DoubleDefinition" do
-                  return_value = Object.new
-                  inner_double_definition = nil
-                  definition.with_any_args.returns(return_value).after_call do |value|
-                    inner_double_definition = mock(value).inner_method(1) {:baz}
-                  end
-
-                  foobar_return_value = subject.foobar
-                  foobar_return_value.should == inner_double_definition.subject
-                  foobar_return_value.inner_method(1).should == :baz
-                end
-              end
-
-              context "when the return value of the #after_call_proc is a DoubleDefinitionCreatorProxy" do
-                it "returns the #__subject__ of the DoubleDefinitionCreatorProxy" do
-                  return_value = Object.new
-                  inner_double_proxy = nil
-                  definition.with_any_args.returns(return_value).after_call do |value|
-                    inner_double_proxy = mock(value)
-                  end
-
-                  foobar_return_value = subject.foobar
-                  foobar_return_value.should == inner_double_proxy.__creator__.subject
-                end
-              end
-
-              context "when the return value of the #after_call_proc is an Object" do
-                it "returns the return value of the #after_call_proc" do
-                  return_value = :returns_value
-                  definition.with_any_args.returns(return_value).after_call do |value|
-                    :after_call_proc
-                  end
-
-                  actual_value = subject.foobar
-                  actual_value.should == :after_call_proc
-                end
-              end
-            end
-          end
-
-          context "when not passed a block" do
-            it "raises an ArgumentError" do
-              lambda do
-                definition.after_call
-              end.should raise_error(ArgumentError, "after_call expects a block")
-            end
-          end
-        end
-
-        describe "#returns" do
-          it "returns DoubleDefinition" do
-            definition.returns {:baz}.should === definition
-            definition.returns(:baz).should === definition
-          end
-
-          context "when passed neither an argument nor a block" do
-            describe "#subject.method_name being called" do
-              it "returns nil" do
-                definition.with_any_args.returns
-                subject.foobar.should be_nil
-              end
-            end
-          end
-
-          context "when passed a block" do
-            describe "#subject.method_name being called" do
-              it "returns the return value of the block" do
-                definition.with_any_args.returns {:baz}
-                subject.foobar.should == :baz
-              end
-            end
-          end
-
-          context "when passed an argument" do
-            describe "#subject.method_name being called" do
-              it "returns the passed-in argument" do
-                definition.returns(:baz).with_no_args
-                subject.foobar.should == :baz
-              end
-            end
-
-            context "when the argument is false" do
-              describe "#subject.method_name being called" do
-                it "returns false" do
-                  definition.returns(false).with_any_args
-                  subject.foobar.should == false
-                end
-              end
-            end
-          end
-
-          context "when passed both an argument and a block" do
-            it "raises an error" do
-              lambda do
-                definition.returns(:baz) {:another}
-              end.should raise_error(ArgumentError, "returns cannot accept both an argument and a block")
-            end
-          end
-        end
-
-        describe "#implemented_by" do
-          it "returns the DoubleDefinition" do
-            definition.implemented_by(lambda{:baz}).should === definition
-          end
-
-          context "when passed a Proc" do
-            describe "#subject.method_name being called" do
-              it "returns the return value of the passed-in Proc" do
-                definition.implemented_by(lambda{:baz}).with_no_args
-                subject.foobar.should == :baz
-              end
-            end
-          end
-
-          context "when passed a Method" do
-            it "sets the implementation to the passed in method" do
-              class << subject
-                remove_method :foobar
-                def foobar(a, b)
-                  [b, a]
-                end
-              end
-              definition.implemented_by(subject.method(:foobar))
-              subject.foobar(1, 2).should == [2, 1]
-            end
-          end
-        end
-
-        describe "#verbose" do
-          it "sets the verbose? to true" do
-            definition.should_not be_verbose
-            definition.verbose
-            definition.should be_verbose
-          end
-        end
-
-        describe "#verify_method_signature" do
-          it "sets #verify_method_signature? to true" do
-            definition.verify_method_signature?.should be_false
-            definition.verify_method_signature
-            definition.verify_method_signature?.should be_true
-          end
-
-          it "returns self" do
-            definition.verify_method_signature.should == definition
-          end
-        end
-      end
-
-      describe "NestedDoubleCreationMethods" do
-        attr_reader :child_double_definition_creator
-        after do
-          RR.verify(ChildDoubleDefinitionCreator)
-          RR.verify(child_double_definition_creator)
-        end
-
-        describe "#mock" do
-          it "instantiates a ChildDoubleDefinitionCreator with self and delegates to its #mock method with the passed-in arguments and block" do
-            child_subject = Object.new
-            child_double_definition_creator = nil
-            mock.proxy(ChildDoubleDefinitionCreator).new(definition) do |child_double_definition_creator|
-              mock.proxy(child_double_definition_creator).mock(child_subject, :baz)
-              child_double_definition_creator = child_double_definition_creator
-            end
-
-            definition.mock(child_subject, :baz)
-            @child_double_definition_creator = child_double_definition_creator
-          end
-        end
-
-        describe "#mock!" do
-          it "instantiates a ChildDoubleDefinitionCreator with self and delegates to its #mock! method with the passed-in arguments and block" do
-            child_double_definition_creator = nil
-            mock.proxy(ChildDoubleDefinitionCreator).new(definition) do |child_double_definition_creator|
-              mock.proxy(child_double_definition_creator).mock!(:baz)
-              child_double_definition_creator = child_double_definition_creator
-            end
-
-            definition.mock!(:baz)
-            @child_double_definition_creator = child_double_definition_creator
-          end
-        end
-
-        describe "#stub" do
-          it "instantiates a ChildDoubleDefinitionCreator with self and delegates to its #stub method with the passed-in arguments and block" do
-            child_subject = Object.new
-            child_double_definition_creator = nil
-            mock.proxy(ChildDoubleDefinitionCreator).new(definition) do |child_double_definition_creator|
-              mock.proxy(child_double_definition_creator).stub(child_subject, :baz)
-              child_double_definition_creator = child_double_definition_creator
-            end
-
-            definition.stub(child_subject, :baz)
-            @child_double_definition_creator = child_double_definition_creator
-          end
-        end
-
-        describe "#stub!" do
-          it "instantiates a ChildDoubleDefinitionCreator with self and delegates to its #stub! method with the passed-in arguments and block" do
-            child_double_definition_creator = nil
-            mock.proxy(ChildDoubleDefinitionCreator).new(definition) do |child_double_definition_creator|
-              mock.proxy(child_double_definition_creator).stub!(:baz)
-              child_double_definition_creator = child_double_definition_creator
-            end
-
-            definition.stub!(:baz)
-            @child_double_definition_creator = child_double_definition_creator
-          end
-        end
-
-        describe "#dont_allow" do
-          it "instantiates a ChildDoubleDefinitionCreator with self and delegates to its #dont_allow method with the passed-in arguments and block" do
-            child_subject = Object.new
-            child_double_definition_creator = nil
-            mock.proxy(ChildDoubleDefinitionCreator).new(definition) do |child_double_definition_creator|
-              mock.proxy(child_double_definition_creator).dont_allow(child_subject, :baz)
-              child_double_definition_creator = child_double_definition_creator
-            end
-
-            definition.dont_allow(child_subject, :baz)
-            @child_double_definition_creator = child_double_definition_creator
-          end
-        end
-
-        describe "#dont_allow!" do
-          it "instantiates a ChildDoubleDefinitionCreator with self and delegates to its #dont_allow! method with the passed-in arguments and block" do
-            child_double_definition_creator = nil
-            mock.proxy(ChildDoubleDefinitionCreator).new(definition) do |child_double_definition_creator|
-              mock.proxy(child_double_definition_creator).dont_allow!(:baz)
-              child_double_definition_creator = child_double_definition_creator
-            end
-
-            definition.dont_allow!(:baz)
-            @child_double_definition_creator = child_double_definition_creator
-          end
-        end
-
-        describe "#proxy" do
-          it "instantiates a ChildDoubleDefinitionCreator with self and delegates to its #proxy method with the passed-in arguments and block" do
-            child_subject = Object.new
-            child_double_definition_creator = nil
-            mock.proxy(ChildDoubleDefinitionCreator).new(definition) do |child_double_definition_creator|
-              mock.proxy(child_double_definition_creator).proxy(DoubleDefinitionCreator::NO_SUBJECT, nil)
-              child_double_definition_creator = child_double_definition_creator
-            end
-
-            definition.proxy.mock(child_subject)
-            @child_double_definition_creator = child_double_definition_creator
-          end
-        end
-
-        describe "#proxy!" do
-          it "raises a DoubleDefinitionError" do
-            lambda do
-              definition.proxy!(:baz)
-            end.should raise_error(RR::Errors::DoubleDefinitionError)
-          end
-        end
-
-        describe "#strong" do
-          it "instantiates a ChildDoubleDefinitionCreator with self and delegates to its #strong method with the passed-in arguments and block" do
-            child_subject = Object.new
-            child_double_definition_creator = nil
-            mock.proxy(ChildDoubleDefinitionCreator).new(definition) do |child_double_definition_creator|
-              mock.proxy(child_double_definition_creator).strong(DoubleDefinitionCreator::NO_SUBJECT, nil)
-              child_double_definition_creator = child_double_definition_creator
-            end
-
-            definition.strong.mock(child_subject)
-            @child_double_definition_creator = child_double_definition_creator
-          end
-        end
-
-        describe "#strong!" do
-          it "raises a DoubleDefinitionError" do
-            lambda do
-              definition.strong!(:baz)
-            end.should raise_error(RR::Errors::DoubleDefinitionError)
-          end
-        end
-      end
-
-      describe "StateQueryMethods" do
-        describe "#ordered?" do
-          it "defaults to false" do
-            definition.should_not be_ordered
-          end
-        end
-
-        describe "#exact_match?" do
-          context "when no argument_expectation set" do
-            it "raises a DoubleDefinitionError" do
-              definition.argument_expectation = nil
-              lambda do
-                definition.exact_match?
-              end.should raise_error(RR::Errors::DoubleDefinitionError)
-            end
-          end
-
-          context "when arguments are not an exact match" do
-            it "returns false" do
-              definition.with(1, 2, 3)
-              definition.should_not be_exact_match(1, 2)
-              definition.should_not be_exact_match(1)
-              definition.should_not be_exact_match()
-              definition.should_not be_exact_match("does not match")
-            end
-          end
-
-          context "when arguments are an exact match" do
-            it "returns true" do
-              definition.with(1, 2, 3)
-              definition.should be_exact_match(1, 2, 3)
-            end
-          end
-        end
-
-        describe "#wildcard_match?" do
-          context "when no #argument_expectation is set" do
-            it "raises a DoubleDefinitionError" do
-              definition.argument_expectation = nil
-              lambda do
-                definition.wildcard_match?
-              end.should raise_error(RR::Errors::DoubleDefinitionError)
-            end
-          end
-
-          context "when arguments are an exact match" do
-            it "returns true" do
-              definition.with(1, 2, 3)
-              definition.should be_wildcard_match(1, 2, 3)
-              definition.should_not be_wildcard_match(1, 2)
-              definition.should_not be_wildcard_match(1)
-              definition.should_not be_wildcard_match()
-              definition.should_not be_wildcard_match("does not match")
-            end
-          end
-
-          context "when with_any_args" do
-            it "returns true" do
-              definition.with_any_args
-
-              definition.should be_wildcard_match(1, 2, 3)
-              definition.should be_wildcard_match(1, 2)
-              definition.should be_wildcard_match(1)
-              definition.should be_wildcard_match()
-              definition.should be_wildcard_match("does not match")
-            end
-          end
-        end
-
-        describe "#terminal?" do
-          context "when times_matcher's terminal? is true" do
-            it "returns true" do
-              definition.once
-              definition.times_matcher.should be_terminal
-              definition.should be_terminal
-            end
-          end
-
-          context "when times_matcher's terminal? is false" do
-            it "returns false" do
-              definition.any_number_of_times
-              definition.times_matcher.should_not be_terminal
-              definition.should_not be_terminal
-            end
-          end
-
-          context "when there is not times_matcher" do
-            it "raises a DoubleDefinitionError" do
-              definition.times_matcher = nil
-              lambda do
-                definition.terminal?
-              end.should raise_error(RR::Errors::DoubleDefinitionError)
-            end
-          end
-        end
-
-        describe "#expected_arguments" do
-          context "when there is a argument expectation" do
-            it "returns argument expectation's expected_arguments" do
-              definition.with(1, 2)
-              definition.expected_arguments.should == [1, 2]
-            end
-          end
-
-          context "when there is no argument expectation" do
-            it "returns an empty array" do
-              definition.argument_expectation = nil
-              definition.expected_arguments.should == []
-            end
-          end
-        end
-      end
-    end
-  end
-end