rspec-core 2.0.0.a5 → 2.0.0.a6

data/spec/rspec/core/example_group_subject_spec.rb

@@ -1,45 +1,40 @@
 require 'spec_helper'
 
-def describe_double(describes=Object)
-  group = Rspec::Core::ExampleGroup.describe(describes) {}
-  remove_last_example_group_from_world
-  yield group if block_given?
-  group
-end
+module Rspec::Core
 
-describe Rspec::Core::ExampleGroupSubject do
+  describe ExampleGroupSubject do
 
-  describe "implicit subject" do
-    describe "with a class" do
-      it "returns an instance of the class" do
-        describe_double(Array).subject.call.should == []
+    describe "implicit subject" do
+      describe "with a class" do
+        it "returns an instance of the class" do
+          ExampleGroup.create(Array).subject.call.should == []
+        end
       end
-    end
-    
-    describe "with a Module" do
-      it "returns the Module" do
-        describe_double(Enumerable).subject.call.should == Enumerable
+      
+      describe "with a Module" do
+        it "returns the Module" do
+          ExampleGroup.create(Enumerable).subject.call.should == Enumerable
+        end
       end
-    end
-    
-    describe "with a string" do
-      it "return the string" do
-        describe_double("Foo").subject.call.should == 'Foo'
+      
+      describe "with a string" do
+        it "return the string" do
+          ExampleGroup.create("Foo").subject.call.should == 'Foo'
+        end
       end
-    end
 
-    describe "with a number" do
-      it "returns the number" do
-        describe_double(15).subject.call.should == 15
+      describe "with a number" do
+        it "returns the number" do
+          ExampleGroup.create(15).subject.call.should == 15
+        end
       end
+      
     end
     
-  end
-  
-   describe "explicit subject" do
+     describe "explicit subject" do
       describe "defined in a top level group" do
         it "replaces the implicit subject in that group" do
-          group = describe_double(Array)
+          group = ExampleGroup.create(Array)
           group.subject { [1,2,3] }
           group.subject.call.should == [1,2,3]
         end
@@ -47,7 +42,7 @@ describe Rspec::Core::ExampleGroupSubject do
 
       describe "defined in a top level group" do
         before do
-          @group = describe_double
+          @group = ExampleGroup.create
           @group.subject{ [4,5,6] }
         end
 
@@ -63,5 +58,5 @@ describe Rspec::Core::ExampleGroupSubject do
         end
       end
     end
-      
+  end
 end

data/spec/rspec/core/mocha_spec.rb

@@ -10,16 +10,14 @@ describe "Mocha Regression involving double reporting of errors" do
 
     use_formatter(formatter) do
 
-      disconnect_from_world do
-        group = Rspec::Core::ExampleGroup.describe("my favorite pony") do
-          example("showing a double fail") do
-            foo = "string"
-            foo.expects(:something)
-          end
-        end      
-        group.examples_to_run.replace(group.examples)
-        group.run(formatter)
-      end
+      group = Rspec::Core::ExampleGroup.create("my favorite pony") do
+        example("showing a double fail") do
+          foo = "string"
+          foo.expects(:something)
+        end
+      end      
+      group.examples_to_run.replace(group.examples)
+      group.run(formatter)
 
     end
 

data/spec/rspec/core/pending_example_spec.rb

@@ -9,7 +9,7 @@ end
 describe "an example" do
   context "with no block" do
     it "is listed as pending" do
-      group = isolated_example_group do
+      group = Rspec::Core::ExampleGroup.create('group') do
         it "has no block" 
       end
       group.run(stub('reporter').as_null_object)

data/spec/rspec/core/runner_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 describe Rspec::Core::Runner do
 
-  describe 'formatter' do
+  describe 'reporter' do
 
     it 'should return the configured formatter' do
-      Rspec::Core::Runner.new.formatter.should == Rspec::Core.configuration.formatter
+      Rspec::Core::Runner.new.reporter.should == Rspec::Core.configuration.formatter
     end
 
   end  

data/spec/rspec/core/shared_example_group_spec.rb

@@ -1,185 +1,176 @@
 require 'spec_helper'
 
-describe Rspec::Core::SharedExampleGroup do
+module Rspec::Core
 
-  it "should add the 'share_examples_for' method to the global namespace" do
-    Kernel.should respond_to(:share_examples_for)
-  end
-
-  it "should add the 'shared_examples_for' method to the global namespace" do
-    Kernel.should respond_to(:shared_examples_for)
-  end
+  describe SharedExampleGroup do
 
-  it "should add the 'share_as' method to the global namespace" do
-    Kernel.should respond_to(:share_as)
-  end
+    it "should add the 'share_examples_for' method to the global namespace" do
+      Kernel.should respond_to(:share_examples_for)
+    end
 
-  it "should raise an ArgumentError when adding a second shared example group with the same name" do
-    group = isolated_example_group('example group')
-    group.share_examples_for('really important business value') { }
-    lambda do
-      group.share_examples_for('really important business value') { }
-    end.should raise_error(ArgumentError, "Shared example group 'really important business value' already exists")
-  end
+    it "should add the 'shared_examples_for' method to the global namespace" do
+      Kernel.should respond_to(:shared_examples_for)
+    end
 
-  describe "share_examples_for" do
+    it "should add the 'share_as' method to the global namespace" do
+      Kernel.should respond_to(:share_as)
+    end
 
-    it "should capture the given name and block in the Worlds collection of shared example groups" do
-      Rspec::Core.world.shared_example_groups.should_receive(:[]=).with(:foo, anything)
-      share_examples_for(:foo) { }
+    it "should raise an ArgumentError when adding a second shared example group with the same name" do
+      group = ExampleGroup.create('example group')
+      group.share_examples_for('really important business value') { }
+      lambda do
+        group.share_examples_for('really important business value') { }
+      end.should raise_error(ArgumentError, "Shared example group 'really important business value' already exists")
     end
 
-  end
+    describe "share_examples_for" do
 
-  describe "including shared example_groups using #it_should_behave_like" do
+      it "should capture the given name and block in the Worlds collection of shared example groups" do
+        Rspec::Core.world.shared_example_groups.should_receive(:[]=).with(:foo, anything)
+        share_examples_for(:foo) { }
+      end
 
-    def cleanup_shared_example_groups
-      original_shared_example_groups = Rspec::Core.world.shared_example_groups
-      yield if block_given?
-      Rspec::Core.world.shared_example_groups.replace(original_shared_example_groups)
     end
 
-    it "should module_eval any found shared example_groups" do
-      group = isolated_example_group('fake group')
-      block1 = lambda {}
-      block2 = lambda {
-        def extra_helper
-          'extra_helper'
-        end
-      }
-      Rspec::Core.world.stub!(:shared_example_groups).and_return({ :a => block1, :shared_example_group => block2 })
-      group.should_receive(:module_eval).once
-      group.it_should_behave_like :shared_example_group
-    end
+    describe "including shared example_groups using #it_should_behave_like" do
 
-    it "should make any shared example_group available at the correct level" do
-      group = isolated_example_group('fake group')
-      block = lambda {
-        def self.class_helper; end
-        def extra_helper; end
-      }
-      Rspec::Core.world.stub!(:shared_example_groups).and_return({ :shared_example_group => block })
-      group.it_should_behave_like :shared_example_group
-      with_ruby(1.8) do
-        group.instance_methods.should include('extra_helper')
-        group.singleton_methods.should include('class_helper')
+      def cleanup_shared_example_groups
+        original_shared_example_groups = Rspec::Core.world.shared_example_groups
+        yield if block_given?
+        Rspec::Core.world.shared_example_groups.replace(original_shared_example_groups)
       end
-      with_ruby(1.9) do
-        group.instance_methods.should include(:extra_helper)
-        group.singleton_methods.should include(:class_helper)
+
+      it "should make any shared example_group available at the correct level" do
+        group = ExampleGroup.create('fake group')
+        block = lambda {
+          def self.class_helper; end
+          def extra_helper; end
+        }
+        Rspec::Core.world.stub(:shared_example_groups).and_return({ :shared_example_group => block })
+        group.it_should_behave_like :shared_example_group
+        with_ruby(1.8) do
+          group.instance_methods.should include('extra_helper')
+          group.singleton_methods.should include('class_helper')
+        end
+        with_ruby(1.9) do
+          group.instance_methods.should include(:extra_helper)
+          group.singleton_methods.should include(:class_helper)
+        end
       end
-    end
 
-    it "should raise when named shared example_group can not be found" 
+      it "should raise when named shared example_group can not be found" 
 
-    it "adds examples to current example_group using it_should_behave_like" do
-      cleanup_shared_example_groups do
-        group = isolated_example_group("example_group") do
-          it("i was already here") {}
-        end
+      it "adds examples to current example_group using it_should_behave_like" do
+        cleanup_shared_example_groups do
+          group = ExampleGroup.create("example_group") do
+            it("i was already here") {}
+          end
 
-        group.examples.size.should == 1
+          group.examples.size.should == 1
 
-        group.share_examples_for('shared example_group') do
-          it("shared example") {}
-          it("shared example 2") {}
-        end
+          group.share_examples_for('shared example_group') do
+            it("shared example") {}
+            it("shared example 2") {}
+          end
 
-        group.it_should_behave_like("shared example_group")
+          group.it_should_behave_like("shared example_group")
 
-        group.examples.size.should == 3
+          group.examples.size.should == 3
+        end
       end
-    end
 
-    it "adds examples to from two shared groups" do
-      cleanup_shared_example_groups do
-        group = isolated_example_group("example_group") do |g|
-          g.it("i was already here") {}
-        end
+      it "adds examples to from two shared groups" do
+        cleanup_shared_example_groups do
+          group = ExampleGroup.create("example_group") do |g|
+            g.it("i was already here") {}
+          end
 
-        group.examples.size.should == 1
+          group.examples.size.should == 1
 
-        group.share_examples_for('test 2 shared groups') do
-          it("shared example") {}
-          it("shared example 2") {}
-        end
+          group.share_examples_for('test 2 shared groups') do
+            it("shared example") {}
+            it("shared example 2") {}
+          end
 
-        group.share_examples_for('test 2 shared groups 2') do
-          it("shared example 3") {}
-        end
+          group.share_examples_for('test 2 shared groups 2') do
+            it("shared example 3") {}
+          end
 
-        group.it_should_behave_like("test 2 shared groups")
-        group.it_should_behave_like("test 2 shared groups 2")
+          group.it_should_behave_like("test 2 shared groups")
+          group.it_should_behave_like("test 2 shared groups 2")
 
-        group.examples.size.should == 4
+          group.examples.size.should == 4
+        end
       end
-    end
 
-    share_as('Cornucopia') do
-      it "should do foo" do; end
-    end
+      share_as('Cornucopia') do
+        it "is plentiful" do
+          5.should == 4
+        end
+      end
 
-    pending "adds examples to current example_group using include", :compat => 'rspec-1.2' do
-      group = isolated_example_group('group') { include Cornucopia }
-      group.examples.length.should == 1
-    end
+      it "adds examples to current example_group using include", :compat => 'rspec-1.2' do
+        group = ExampleGroup.create('group') { include Cornucopia }
+        group.examples.length.should == 1
+        group.examples.first.metadata[:description].should == "is plentiful"
+      end
 
-    it "adds examples to current example_group using it_should_behave_like with a module" do
-      cleanup_shared_example_groups do
-        group = isolated_example_group("example_group")  {}
+      it "adds examples to current example_group using it_should_behave_like with a module" do
+        cleanup_shared_example_groups do
+          group = ExampleGroup.create("example_group")  {}
 
-        shared_foo = group.share_as(:FooShared) do
-          it("shared example") {}
-        end
+          shared_foo = group.share_as(:FooShared) do
+            it("shared example") {}
+          end
 
-        group.it_should_behave_like(::FooShared) 
+          group.it_should_behave_like(::FooShared) 
 
-        group.examples.size.should == 1
+          group.examples.size.should == 1
+        end
       end
-    end
 
-    describe "running shared examples" do
-      module RunningSharedExamplesJustForTesting; end
+      describe "running shared examples" do
+        module RunningSharedExamplesJustForTesting; end
+
+        share_examples_for("it runs shared examples") do
+          include RunningSharedExamplesJustForTesting
 
-      share_examples_for("it runs shared examples") do
-        include RunningSharedExamplesJustForTesting
+          def magic
+            @magic ||= {}
+          end
 
-        def magic
-          @magic ||= {}
+          before(:each) { magic[:before_each] = 'each' }
+          after(:each)  { magic[:after_each] = 'each' }
+          before(:all)  { magic[:before_all] = 'all' }
         end
 
-        before(:each) { magic[:before_each] = 'each' }
-        after(:each)  { magic[:after_each] = 'each' }
-        before(:all)  { magic[:before_all] = 'all' }
-      end
+        it_should_behave_like "it runs shared examples"
 
-      it_should_behave_like "it runs shared examples"
+        it "runs before(:each) from shared example_group", :compat => 'rspec-1.2' do
+          magic[:before_each].should == 'each'
+        end
 
-      it "runs before(:each) from shared example_group", :compat => 'rspec-1.2' do
-        magic[:before_each].should == 'each'
-      end
+        it "runs after(:each) from shared example_group", :compat => 'rspec-1.2' 
 
-      it "runs after(:each) from shared example_group", :compat => 'rspec-1.2' 
+        it "should run before(:all) only once from shared example_group", :compat => 'rspec-1.2' do
+          magic[:before_all].should == 'all'
+        end
 
-      it "should run before(:all) only once from shared example_group", :compat => 'rspec-1.2' do
-        magic[:before_all].should == 'all'
-      end
+        it "should run after(:all) only once from shared example_group", :compat => 'rspec-1.2' 
 
-      it "should run after(:all) only once from shared example_group", :compat => 'rspec-1.2' 
+        it "should include modules, included into shared example_group, into current example_group", :compat => 'rspec-1.2' do
+          running_example.example_group.included_modules.should include(RunningSharedExamplesJustForTesting)
+        end
 
-      it "should include modules, included into shared example_group, into current example_group", :compat => 'rspec-1.2' do
-        running_example.example_group.included_modules.should include(RunningSharedExamplesJustForTesting)
-      end
+        it "should make methods defined in the shared example_group available in consuming example_group", :compat => 'rspec-1.2' do
+          magic.should be_a(Hash)
+        end
 
-      it "should make methods defined in the shared example_group available in consuming example_group", :compat => 'rspec-1.2' do
-        # TODO: Consider should have_method(...) simple matcher
-        with_ruby('1.8') { running_example.example_group.methods.should include('magic') }
-        with_ruby('1.9') { running_example.example_group.methods.should include(:magic) }
       end
 
     end
 
   end
 
-
 end

data/spec/rspec/core/world_spec.rb

@@ -3,146 +3,141 @@ require 'spec_helper'
 class Bar; end
 class Foo; end
 
-describe Rspec::Core::World do
-  
-  before do
-    @world = Rspec::Core::World.new
-    Rspec::Core.stub(:world).and_return(@world)
-  end
+module Rspec::Core
 
-  describe "example groups" do
-  
-    it "should contain all defined example groups" do
-      disconnect_from_world do
-        example_group = Rspec::Core::ExampleGroup.describe(Bar, 'Empty Example Group') { }
-        @world.example_groups.should include(example_group)       
-      end
-    end
-  
-  end
-  
-  describe "applying inclusion filters" do
-  
-    before(:all) do
-      options_1 = { :foo => 1, :color => 'blue', :feature => 'reporting' }
-      options_2 = { :pending => true, :feature => 'reporting'  }
-      options_3 = { :array => [1,2,3,4], :color => 'blue' }      
-      @bg1 = Rspec::Core::ExampleGroup.describe(Bar, "find group-1", options_1) { }
-      @bg2 = Rspec::Core::ExampleGroup.describe(Bar, "find group-2", options_2) { }
-      @bg3 = Rspec::Core::ExampleGroup.describe(Bar, "find group-3", options_3) { }
-      @bg4 = Rspec::Core::ExampleGroup.describe(Foo, "find these examples") do
-        it('I have no options') {}
-        it("this is awesome", :awesome => true) {}
-        it("this is too", :awesome => true) {}
-        it("not so awesome", :awesome => false) {}
-        it("I also have no options") {}
-      end
-      @example_groups = [@bg1, @bg2, @bg3, @bg4]
-    end
+  describe World do
     
-    after(:all) do
-      Rspec::Core.world.example_groups.delete(@bg1)
-      Rspec::Core.world.example_groups.delete(@bg2)
-      Rspec::Core.world.example_groups.delete(@bg3)
-      Rspec::Core.world.example_groups.delete(@bg4)
-    end
-  
-    it "finds no groups when given no search parameters" do
-      @world.apply_inclusion_filters([]).should == []
-    end
-  
-    it "finds matching groups when filtering on :describes (described class or module)" do
-      @world.apply_inclusion_filters(@example_groups, :example_group => { :describes => Bar }).should == [@bg1, @bg2, @bg3]
-    end
-    
-    it "finds matching groups when filtering on :description with text" do
-      @world.apply_inclusion_filters(@example_groups, :example_group => { :description => 'find group-1' }).should == [@bg1]
-    end
-    
-    it "finds matching groups when filtering on :description with a lambda" do
-      @world.apply_inclusion_filters(@example_groups, :example_group => { :description => lambda { |v| v.include?('-1') || v.include?('-3') } }).should == [@bg1, @bg3]
+    before do
+      @world = Rspec::Core::World.new
+      Rspec::Core.stub(:world).and_return(@world)
     end
+
+    describe "example_groups" do
     
-    it "finds matching groups when filtering on :description with a regular expression" do
-      @world.apply_inclusion_filters(@example_groups, :example_group => { :description => /find group/ }).should == [@bg1, @bg2, @bg3]
-    end
+      it "should contain all defined example groups" do
+        group = Rspec::Core::ExampleGroup.describe("group") {}
+        @world.example_groups.should include(group)
+      end
     
-    it "finds one group when searching for :pending => true" do
-      @world.apply_inclusion_filters(@example_groups, :pending => true ).should == [@bg2]
-    end
-  
-    it "finds matching groups when filtering on arbitrary metadata with a number" do
-      @world.apply_inclusion_filters(@example_groups, :foo => 1 ).should == [@bg1]
     end
     
-    it "finds matching groups when filtering on arbitrary metadata with an array" do
-      @world.apply_inclusion_filters(@example_groups, :array => [1,2,3,4]).should == [@bg3]
-    end
-  
-    it "finds no groups when filtering on arbitrary metadata with an array but the arrays do not match" do
-      @world.apply_inclusion_filters(@example_groups, :array => [4,3,2,1]).should be_empty
-    end    
-  
-    it "finds matching examples when filtering on arbitrary metadata" do
-      @world.apply_inclusion_filters(@bg4.examples, :awesome => true).should == [@bg4.examples[1], @bg4.examples[2]]
-    end
+    describe "applying inclusion filters" do
     
-  end
-  
-  describe "applying exclusion filters" do
+      before(:all) do
+        options_1 = { :foo => 1, :color => 'blue', :feature => 'reporting' }
+        options_2 = { :pending => true, :feature => 'reporting'  }
+        options_3 = { :array => [1,2,3,4], :color => 'blue' }      
+        @bg1 = Rspec::Core::ExampleGroup.describe(Bar, "find group-1", options_1) { }
+        @bg2 = Rspec::Core::ExampleGroup.describe(Bar, "find group-2", options_2) { }
+        @bg3 = Rspec::Core::ExampleGroup.describe(Bar, "find group-3", options_3) { }
+        @bg4 = Rspec::Core::ExampleGroup.describe(Foo, "find these examples") do
+          it('I have no options') {}
+          it("this is awesome", :awesome => true) {}
+          it("this is too", :awesome => true) {}
+          it("not so awesome", :awesome => false) {}
+          it("I also have no options") {}
+        end
+        @example_groups = [@bg1, @bg2, @bg3, @bg4]
+      end
+      
+      it "finds no groups when given no search parameters" do
+        @world.apply_inclusion_filters([]).should == []
+      end
     
-    it "should find nothing if all describes match the exclusion filter" do
-      options = { :network_access => true }      
+      it "finds matching groups when filtering on :describes (described class or module)" do
+        @world.apply_inclusion_filters(@example_groups, :example_group => { :describes => Bar }).should == [@bg1, @bg2, @bg3]
+      end
       
-      group1 = isolated_example_group(Bar, "find group-1", options) do
-        it("foo") {}
-        it("bar") {}
+      it "finds matching groups when filtering on :description with text" do
+        @world.apply_inclusion_filters(@example_groups, :example_group => { :description => 'find group-1' }).should == [@bg1]
       end
       
-      @world.apply_exclusion_filters(group1.examples, :network_access => true).should == []
+      it "finds matching groups when filtering on :description with a lambda" do
+        @world.apply_inclusion_filters(@example_groups, :example_group => { :description => lambda { |v| v.include?('-1') || v.include?('-3') } }).should == [@bg1, @bg3]
+      end
       
-      group2 = isolated_example_group(Bar, "find group-1") do
-        it("foo", :network_access => true) {}
-        it("bar") {}
+      it "finds matching groups when filtering on :description with a regular expression" do
+        @world.apply_inclusion_filters(@example_groups, :example_group => { :description => /find group/ }).should == [@bg1, @bg2, @bg3]
       end
       
-      @world.apply_exclusion_filters(group2.examples, :network_access => true).should == [group2.examples.last]
-  
-    end
+      it "finds one group when searching for :pending => true" do
+        @world.apply_inclusion_filters(@example_groups, :pending => true ).should == [@bg2]
+      end
+    
+      it "finds matching groups when filtering on arbitrary metadata with a number" do
+        @world.apply_inclusion_filters(@example_groups, :foo => 1 ).should == [@bg1]
+      end
+      
+      it "finds matching groups when filtering on arbitrary metadata with an array" do
+        @world.apply_inclusion_filters(@example_groups, :array => [1,2,3,4]).should == [@bg3]
+      end
+    
+      it "finds no groups when filtering on arbitrary metadata with an array but the arrays do not match" do
+        @world.apply_inclusion_filters(@example_groups, :array => [4,3,2,1]).should be_empty
+      end    
     
-    it "should find nothing if a regexp matches the exclusion filter" do
-      group = isolated_example_group(Bar, "find group-1", :name => "exclude me with a regex", :another => "foo") do
-        it("foo") {}
-        it("bar") {}
+      it "finds matching examples when filtering on arbitrary metadata" do
+        @world.apply_inclusion_filters(@bg4.examples, :awesome => true).should == [@bg4.examples[1], @bg4.examples[2]]
       end
-      @world.apply_exclusion_filters(group.examples, :name => /exclude/).should == []
-      @world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo").should == []
-      @world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo", :example_group => {
-        :describes => lambda { |b| b == Bar } } ).should == []
       
-      @world.apply_exclusion_filters(group.examples, :name => /exclude not/).should == group.examples
-      @world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo").should == group.examples
-      @world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo1").should == group.examples
     end
     
-  end
-  
-  describe "filtering example groups" do
+    describe "applying exclusion filters" do
+      
+      it "should find nothing if all describes match the exclusion filter" do
+        options = { :network_access => true }      
+        
+        group1 = ExampleGroup.create(Bar, "find group-1", options) do
+          it("foo") {}
+          it("bar") {}
+        end
+        
+        @world.apply_exclusion_filters(group1.examples, :network_access => true).should == []
+        
+        group2 = ExampleGroup.create(Bar, "find group-1") do
+          it("foo", :network_access => true) {}
+          it("bar") {}
+        end
+        
+        @world.apply_exclusion_filters(group2.examples, :network_access => true).should == [group2.examples.last]
     
-    it "should run matches" do
-      @group1 = isolated_example_group(Bar, "find these examples") do
-        it('I have no options',       :color => :red, :awesome => true) {}
-        it("I also have no options",  :color => :red, :awesome => true) {}
-        it("not so awesome",          :color => :red, :awesome => false) {}
       end
-      Rspec::Core.world.stub(:exclusion_filter).and_return({ :awesome => false })
-      Rspec::Core.world.stub(:filter).and_return({ :color => :red })
-      Rspec::Core.world.stub(:example_groups).and_return([@group1])
-      filtered_example_groups = @world.filter_example_groups
-      filtered_example_groups.should == [@group1]
-      @group1.examples_to_run.should == @group1.examples[0..1]      
+      
+      it "should find nothing if a regexp matches the exclusion filter" do
+        group = ExampleGroup.create(Bar, "find group-1", :name => "exclude me with a regex", :another => "foo") do
+          it("foo") {}
+          it("bar") {}
+        end
+        @world.apply_exclusion_filters(group.examples, :name => /exclude/).should == []
+        @world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo").should == []
+        @world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo", :example_group => {
+          :describes => lambda { |b| b == Bar } } ).should == []
+        
+        @world.apply_exclusion_filters(group.examples, :name => /exclude not/).should == group.examples
+        @world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo").should == group.examples
+        @world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo1").should == group.examples
+      end
+      
     end
     
+    describe "filtering example groups" do
+      
+      it "should run matches" do
+        @group1 = ExampleGroup.create(Bar, "find these examples") do
+          it('I have no options',       :color => :red, :awesome => true) {}
+          it("I also have no options",  :color => :red, :awesome => true) {}
+          it("not so awesome",          :color => :red, :awesome => false) {}
+        end
+        Rspec::Core.world.stub(:exclusion_filter).and_return({ :awesome => false })
+        Rspec::Core.world.stub(:filter).and_return({ :color => :red })
+        Rspec::Core.world.stub(:example_groups).and_return([@group1])
+        filtered_example_groups = @world.filter_example_groups
+        filtered_example_groups.should == [@group1]
+        @group1.examples_to_run.should == @group1.examples[0..1]      
+      end
+      
+    end
+
   end
 
 end