mspec 1.5.10 → 1.5.11

data/spec/expectations/should.rb

@@ -0,0 +1,71 @@
+$: << File.dirname(__FILE__) + '/../../lib'
+require 'mspec'
+
+# The purpose of these specs is to confirm that the #should
+# and #should_not methods are functioning appropriately. We
+# use a separate spec file that is invoked from the MSpec
+# specs but is run by MSpec. This avoids conflicting with
+# RSpec's #should and #should_not methods.
+
+class ShouldSpecsMonitor
+  def initialize
+    @called = 0
+  end
+
+  def expectation(state)
+    @called += 1
+  end
+
+  def finish
+    puts "I was called #{@called} times"
+  end
+end
+
+# Simplistic runner
+formatter = DottedFormatter.new
+formatter.register
+
+monitor = ShouldSpecsMonitor.new
+MSpec.register :expectation, monitor
+MSpec.register :finish, monitor
+
+at_exit { MSpec.actions :finish }
+
+MSpec.actions :start
+
+# Specs
+describe "MSpec expectation method #should" do
+  it "accepts a matcher" do
+    :sym.should be_kind_of(Symbol)
+  end
+
+  it "causes a failue to be recorded" do
+    1.should == 2
+  end
+
+  it "registers that an expectation has been encountered" do
+    # an empty example block causes an exception because
+    # no expectation was encountered
+  end
+
+  it "invokes the MSpec :expectation actions" do
+    1.should == 1
+  end
+end
+
+describe "MSpec expectation method #should_not" do
+  it "accepts a matcher" do
+    "sym".should_not be_kind_of(Symbol)
+  end
+
+  it "causes a failure to be recorded" do
+    1.should_not == 1
+  end
+
+  it "registers that an expectation has been encountered" do
+  end
+
+  it "invokes the MSpec :expectation actions" do
+    1.should_not == 2
+  end
+end

data/spec/expectations/should_spec.rb

@@ -1,129 +1,61 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require 'mspec/expectations/expectations'
-require 'mspec/matchers/base'
-require 'mspec/runner/mspec'
-
-class Object
-  alias_method :rspec_should,     :should
-  alias_method :rspec_should_not, :should_not
-end
-require 'mspec/expectations/should'
-class Object
-  alias_method :mspec_should,     :should
-  alias_method :mspec_should_not, :should_not
-  alias_method :should,           :rspec_should
-  alias_method :should_not,       :rspec_should_not
-end
-
-# Adapted from RSpec 1.0.8
-describe Object, "#should" do
-  before :each do
-    class Object; alias_method :should, :mspec_should; end
-
-    @state = mock("example state", :null_object => true)
-    context = mock("context state", :null_object => true)
-    context.stub!(:state).and_return(@state)
-    MSpec.stub!(:current).and_return(context)
-    MSpec.stub!(:actions)
-
-    @target = "target"
-    @matcher = mock("matcher", :null_object => true)
-  end
-
-  after :each do
-    class Object; alias_method :should, :rspec_should; end
-  end
-
-  it "accepts and interacts with a matcher" do
-    @matcher.should_receive(:matches?).with(@target).and_return(true)
-    @target.should @matcher
-  end
-
-  it "calls #failure_message when matcher #matches? returns false" do
-    @matcher.should_receive(:matches?).with(@target).and_return(false)
-    @matcher.should_receive(:failure_message).and_return(["expected", "actual"])
-    @target.should @matcher rescue nil
-  end
-
-  it "raises an ExpectationNotMetError when matcher #matches? returns false" do
-    @matcher.should_receive(:matches?).with(@target).and_return(false)
-    @matcher.should_receive(:failure_message).and_return(["expected", "actual"])
-    lambda {
-      @target.should @matcher
-    }.should raise_error(ExpectationNotMetError, "expected actual")
-  end
-
-  it "returns a PostiveOperatorMatcher instance when not passed a matcher" do
-    matcher = should
-    class Object; alias_method :should, :rspec_should; end
-    matcher.should be_instance_of(PositiveOperatorMatcher)
-  end
-
-  it "invokes the MSpec :expectation actions" do
-    MSpec.should_receive(:actions).with(:expectation, @state)
-    @target.should @matcher
-  end
-
-  it "registers that an expectation has been encountered" do
-    MSpec.should_receive(:expectation)
-    @target.should @matcher
-  end
-end
-
-describe Object, "#should_not" do
-  before :each do
-    class Object; alias_method :should,     :mspec_should; end
-    class Object; alias_method :should_not, :mspec_should_not; end
-
-    @state = mock("example state", :null_object => true)
-    context = mock("context state", :null_object => true)
-    context.stub!(:state).and_return(@state)
-    MSpec.stub!(:current).and_return(context)
-    MSpec.stub!(:actions)
-
-    @target = "target"
-    @matcher = mock("matcher", :null_object => true)
-  end
-
-  after :each do
-    class Object; alias_method :should,     :rspec_should; end
-    class Object; alias_method :should_not, :rspec_should_not; end
-  end
-
-  it "accepts and interacts with a matcher" do
-    @matcher.should_receive(:matches?).with(@target).and_return(false)
-    @target.should_not @matcher
-  end
-
-  it "calls #negative_failure_message when matcher.matches? returns true" do
-    @matcher.should_receive(:matches?).with(@target).and_return(true)
-    @matcher.should_receive(:negative_failure_message).and_return(["expected", "actual"])
-    @target.should_not @matcher rescue nil
-  end
-
-  it "raises an ExpectationNotMetError when matcher.matches? returns true" do
-    @matcher.should_receive(:matches?).with(@target).and_return(true)
-    @matcher.should_receive(:negative_failure_message).and_return(["expected", "actual"])
-    lambda {
-      @target.should_not @matcher
-    }.should raise_error(ExpectationNotMetError, "expected actual")
-  end
-
-  it "returns a NegativeOperatorMatcher instance when not passed a matcher" do
-    matcher = should_not nil
-    class Object; alias_method :should, :rspec_should; end
-    matcher.should be_instance_of(NegativeOperatorMatcher)
-  end
-
-  it "invokes the MSpec :expectation actions" do
-    MSpec.should_receive(:actions).with(:expectation, @state)
-    @matcher.should_receive(:negative_failure_message).and_return(["expected", "actual"])
-    @target.should_not @matcher rescue nil
-  end
-
-  it "registers that an expectation has been encountered" do
-    MSpec.should_receive(:expectation)
-    @matcher.should_receive(:negative_failure_message).and_return(["expected", "actual"])
-    @target.should_not @matcher rescue nil
+require 'rbconfig'
+
+describe MSpec do
+  before :all do
+    path = Config::CONFIG['bindir']
+    exe  = Config::CONFIG['ruby_install_name']
+    file = File.dirname(__FILE__) + '/should.rb'
+    @out = `#{path}/#{exe} #{file}`
+  end
+
+  describe "#should" do
+    it "records failures" do
+      @out.should =~ Regexp.new(Regexp.escape(%[
+1)
+MSpec expectation method #should causes a failue to be recorded FAILED
+Expected 1
+ to equal 2
+]))
+    end
+
+    it "raises exceptions for examples with no expectations" do
+      @out.should =~ Regexp.new(Regexp.escape(%[
+2)
+MSpec expectation method #should registers that an expectation has been encountered FAILED
+No behavior expectation was found in the example
+]))
+    end
+  end
+
+  describe "#should_not" do
+    it "records failures" do
+      @out.should =~ Regexp.new(Regexp.escape(%[
+3)
+MSpec expectation method #should_not causes a failure to be recorded FAILED
+Expected 1
+ not to equal 1
+]))
+    end
+
+    it "raises exceptions for examples with no expectations" do
+      @out.should =~ Regexp.new(Regexp.escape(%[
+4)
+MSpec expectation method #should_not registers that an expectation has been encountered FAILED
+No behavior expectation was found in the example
+]))
+    end
+  end
+
+  it "prints status information" do
+    @out.should =~ /\.FF\.\.FF\./
+  end
+
+  it "prints out a summary" do
+    @out.should =~ /0 files, 8 examples, 6 expectations, 4 failures, 0 errors/
+  end
+
+  it "records expectations" do
+    @out.should =~ /I was called 6 times/
   end
 end

data/spec/guards/endian_spec.rb

@@ -9,13 +9,13 @@ describe Object, "#big_endian" do
   end
 
   it "yields on big-endian platforms" do
-    @guard.stub!(:pattern).and_return([1])
+    @guard.stub!(:pattern).and_return([?\001])
     big_endian { ScratchPad.record :yield }
     ScratchPad.recorded.should == :yield
   end
 
   it "does not yield on little-endian platforms" do
-    @guard.stub!(:pattern).and_return([0])
+    @guard.stub!(:pattern).and_return([?\000])
     big_endian { ScratchPad.record :yield }
     ScratchPad.recorded.should_not == :yield
   end
@@ -26,7 +26,7 @@ describe Object, "#big_endian" do
   end
 
   it "calls #unregister even when an exception is raised in the guard block" do
-    @guard.stub!(:pattern).and_return([1])
+    @guard.stub!(:pattern).and_return([?\001])
     @guard.should_receive(:unregister)
     lambda do
       big_endian { raise Exception }
@@ -42,13 +42,13 @@ describe Object, "#little_endian" do
   end
 
   it "yields on little-endian platforms" do
-    @guard.stub!(:pattern).and_return([0])
+    @guard.stub!(:pattern).and_return([?\000])
     little_endian { ScratchPad.record :yield }
     ScratchPad.recorded.should == :yield
   end
 
   it "does not yield on big-endian platforms" do
-    @guard.stub!(:pattern).and_return([1])
+    @guard.stub!(:pattern).and_return([?\001])
     little_endian { ScratchPad.record :yield }
     ScratchPad.recorded.should_not == :yield
   end
@@ -59,7 +59,7 @@ describe Object, "#little_endian" do
   end
 
   it "calls #unregister even when an exception is raised in the guard block" do
-    @guard.stub!(:pattern).and_return([0])
+    @guard.stub!(:pattern).and_return([?\000])
     @guard.should_receive(:unregister)
     lambda do
       little_endian { raise Exception }

data/spec/helpers/flunk_spec.rb

@@ -9,11 +9,11 @@ describe Object, "#flunk" do
     MSpec.stub!(:current).and_return(mock("spec state", :null_object => true))
   end
 
-  it "raises an ExpectationNotMetError unconditionally" do
-    lambda { flunk }.should raise_error(ExpectationNotMetError)
+  it "raises an SpecExpectationNotMetError unconditionally" do
+    lambda { flunk }.should raise_error(SpecExpectationNotMetError)
   end
 
   it "accepts on argument for an optional message" do
-    lambda {flunk "test"}.should raise_error(ExpectationNotMetError)
+    lambda {flunk "test"}.should raise_error(SpecExpectationNotMetError)
   end
 end

data/spec/matchers/base_spec.rb

@@ -3,214 +3,223 @@ require 'mspec/expectations/expectations'
 require 'mspec/matchers/base'
 require 'time'
 
-describe PositiveOperatorMatcher, "== operator" do
-  it "raises an ExpectationNotMetError when expected == actual returns false" do
+describe SpecPositiveOperatorMatcher, "== operator" do
+  it "raises an SpecExpectationNotMetError when expected == actual returns false" do
     lambda {
-      PositiveOperatorMatcher.new(1) == 2
-    }.should raise_error(ExpectationNotMetError)
+      SpecPositiveOperatorMatcher.new(1) == 2
+    }.should raise_error(SpecExpectationNotMetError)
   end
 
   it "provides a failure message that 'Expected x to equal y'" do
-    Expectation.should_receive(:fail_with).with("Expected 1\n", "to equal 2\n")
-    PositiveOperatorMatcher.new(1) == 2
+    SpecExpectation.should_receive(:fail_with).with("Expected 1\n", "to equal 2\n")
+    SpecPositiveOperatorMatcher.new(1) == 2
   end
 
   it "does not raise an exception when expected == actual returns true" do
-    PositiveOperatorMatcher.new(1) == 1
+    SpecPositiveOperatorMatcher.new(1) == 1
   end
 end
 
-describe PositiveOperatorMatcher, "=~ operator" do
-  it "raises an ExpectationNotMetError when expected =~ actual returns false" do
+describe SpecPositiveOperatorMatcher, "=~ operator" do
+  it "raises an SpecExpectationNotMetError when expected =~ actual returns false" do
     lambda {
-      PositiveOperatorMatcher.new('real') =~ /fake/
-    }.should raise_error(ExpectationNotMetError)
+      SpecPositiveOperatorMatcher.new('real') =~ /fake/
+    }.should raise_error(SpecExpectationNotMetError)
   end
 
   it "provides a failure message that 'Expected \"x\" to match y'" do
-    Expectation.should_receive(:fail_with).with("Expected \"real\"\n", "to match /fake/\n")
-    PositiveOperatorMatcher.new('real') =~ /fake/
+    SpecExpectation.should_receive(:fail_with).with(
+      "Expected \"real\"\n", "to match /fake/\n")
+    SpecPositiveOperatorMatcher.new('real') =~ /fake/
   end
 
   it "does not raise an exception when expected =~ actual returns true" do
-    PositiveOperatorMatcher.new('real') =~ /real/
+    SpecPositiveOperatorMatcher.new('real') =~ /real/
   end
 end
 
-describe PositiveOperatorMatcher, "> operator" do
-  it "raises an ExpectationNotMetError when expected > actual returns false" do
+describe SpecPositiveOperatorMatcher, "> operator" do
+  it "raises an SpecExpectationNotMetError when expected > actual returns false" do
     lambda {
-      PositiveOperatorMatcher.new(4) > 5
-    }.should raise_error(ExpectationNotMetError)
+      SpecPositiveOperatorMatcher.new(4) > 5
+    }.should raise_error(SpecExpectationNotMetError)
   end
 
   it "provides a failure message that 'Expected x to be greater than y'" do
-    Expectation.should_receive(:fail_with).with("Expected 4\n", "to be greater than 5\n")
-    PositiveOperatorMatcher.new(4) > 5
+    SpecExpectation.should_receive(:fail_with).with(
+      "Expected 4\n", "to be greater than 5\n")
+    SpecPositiveOperatorMatcher.new(4) > 5
   end
 
   it "does not raise an exception when expected > actual returns true" do
-    PositiveOperatorMatcher.new(5) > 4
+    SpecPositiveOperatorMatcher.new(5) > 4
   end
 end
 
-describe PositiveOperatorMatcher, ">= operator" do
-  it "raises an ExpectationNotMetError when expected >= actual returns false" do
+describe SpecPositiveOperatorMatcher, ">= operator" do
+  it "raises an SpecExpectationNotMetError when expected >= actual returns false" do
     lambda {
-      PositiveOperatorMatcher.new(4) >= 5
-    }.should raise_error(ExpectationNotMetError)
+      SpecPositiveOperatorMatcher.new(4) >= 5
+    }.should raise_error(SpecExpectationNotMetError)
   end
 
   it "provides a failure message that 'Expected x to be greater than or equal to y'" do
-    Expectation.should_receive(:fail_with).with("Expected 4\n", "to be greater than or equal to 5\n")
-    PositiveOperatorMatcher.new(4) >= 5
+    SpecExpectation.should_receive(:fail_with).with(
+      "Expected 4\n", "to be greater than or equal to 5\n")
+    SpecPositiveOperatorMatcher.new(4) >= 5
   end
 
   it "does not raise an exception when expected > actual returns true" do
-    PositiveOperatorMatcher.new(5) >= 4
-    PositiveOperatorMatcher.new(5) >= 5
+    SpecPositiveOperatorMatcher.new(5) >= 4
+    SpecPositiveOperatorMatcher.new(5) >= 5
   end
 end
 
-describe PositiveOperatorMatcher, "< operater" do
-  it "raises an ExpectationNotMetError when expected < actual returns false" do
+describe SpecPositiveOperatorMatcher, "< operater" do
+  it "raises an SpecExpectationNotMetError when expected < actual returns false" do
     lambda {
-      PositiveOperatorMatcher.new(5) < 4
-    }.should raise_error(ExpectationNotMetError)
+      SpecPositiveOperatorMatcher.new(5) < 4
+    }.should raise_error(SpecExpectationNotMetError)
   end
 
   it "provides a failure message that 'Expected x to be less than y'" do
-    Expectation.should_receive(:fail_with).with("Expected 5\n", "to be less than 4\n")
-    PositiveOperatorMatcher.new(5) < 4
+    SpecExpectation.should_receive(:fail_with).with("Expected 5\n", "to be less than 4\n")
+    SpecPositiveOperatorMatcher.new(5) < 4
   end
 
   it "does not raise an exception when expected < actual returns true" do
-    PositiveOperatorMatcher.new(4) < 5
+    SpecPositiveOperatorMatcher.new(4) < 5
   end
 end
 
-describe PositiveOperatorMatcher, "<= operater" do
-  it "raises an ExpectationNotMetError when expected < actual returns false" do
+describe SpecPositiveOperatorMatcher, "<= operater" do
+  it "raises an SpecExpectationNotMetError when expected < actual returns false" do
     lambda {
-      PositiveOperatorMatcher.new(5) <= 4
-    }.should raise_error(ExpectationNotMetError)
+      SpecPositiveOperatorMatcher.new(5) <= 4
+    }.should raise_error(SpecExpectationNotMetError)
   end
 
   it "provides a failure message that 'Expected x to be less than or equal to y'" do
-    Expectation.should_receive(:fail_with).with("Expected 5\n", "to be less than or equal to 4\n")
-    PositiveOperatorMatcher.new(5) <= 4
+    SpecExpectation.should_receive(:fail_with).with(
+      "Expected 5\n", "to be less than or equal to 4\n")
+    SpecPositiveOperatorMatcher.new(5) <= 4
   end
 
   it "does not raise an exception when expected < actual returns true" do
-    PositiveOperatorMatcher.new(4) <= 5
-    PositiveOperatorMatcher.new(4) <= 4
+    SpecPositiveOperatorMatcher.new(4) <= 5
+    SpecPositiveOperatorMatcher.new(4) <= 4
   end
 end
 
-describe NegativeOperatorMatcher, "== operator" do
-  it "raises an ExpectationNotMetError when expected == actual returns true" do
+describe SpecNegativeOperatorMatcher, "== operator" do
+  it "raises an SpecExpectationNotMetError when expected == actual returns true" do
     lambda {
-      NegativeOperatorMatcher.new(1) == 1
-    }.should raise_error(ExpectationNotMetError)
+      SpecNegativeOperatorMatcher.new(1) == 1
+    }.should raise_error(SpecExpectationNotMetError)
   end
 
   it "provides a failure message that 'Expected x not to equal y'" do
-    Expectation.should_receive(:fail_with).with("Expected 1\n", "not to equal 1\n")
-    NegativeOperatorMatcher.new(1) == 1
+    SpecExpectation.should_receive(:fail_with).with("Expected 1\n", "not to equal 1\n")
+    SpecNegativeOperatorMatcher.new(1) == 1
   end
 
   it "does not raise an exception when expected == actual returns false" do
-    NegativeOperatorMatcher.new(1) == 2
+    SpecNegativeOperatorMatcher.new(1) == 2
   end
 end
 
-describe NegativeOperatorMatcher, "=~ operator" do
-  it "raises an ExpectationNotMetError when expected =~ actual returns true" do
+describe SpecNegativeOperatorMatcher, "=~ operator" do
+  it "raises an SpecExpectationNotMetError when expected =~ actual returns true" do
     lambda {
-      NegativeOperatorMatcher.new('real') =~ /real/
-    }.should raise_error(ExpectationNotMetError)
+      SpecNegativeOperatorMatcher.new('real') =~ /real/
+    }.should raise_error(SpecExpectationNotMetError)
   end
 
   it "provides a failure message that 'Expected \"x\" not to match /y/'" do
-    Expectation.should_receive(:fail_with).with("Expected \"real\"\n", "not to match /real/\n")
-    NegativeOperatorMatcher.new('real') =~ /real/
+    SpecExpectation.should_receive(:fail_with).with(
+      "Expected \"real\"\n", "not to match /real/\n")
+    SpecNegativeOperatorMatcher.new('real') =~ /real/
   end
 
   it "does not raise an exception when expected =~ actual returns false" do
-    NegativeOperatorMatcher.new('real') =~ /fake/
+    SpecNegativeOperatorMatcher.new('real') =~ /fake/
   end
 end
 
-describe NegativeOperatorMatcher, "< operator" do
-  it "raises an ExpectationNotMetError when expected < actual returns true" do
+describe SpecNegativeOperatorMatcher, "< operator" do
+  it "raises an SpecExpectationNotMetError when expected < actual returns true" do
     lambda {
-      NegativeOperatorMatcher.new(4) < 5
-    }.should raise_error(ExpectationNotMetError)
+      SpecNegativeOperatorMatcher.new(4) < 5
+    }.should raise_error(SpecExpectationNotMetError)
   end
 
   it "provides a failure message that 'Expected x not to be less than y'" do
-    Expectation.should_receive(:fail_with).with("Expected 4\n", "not to be less than 5\n")
-    NegativeOperatorMatcher.new(4) < 5
+    SpecExpectation.should_receive(:fail_with).with(
+      "Expected 4\n", "not to be less than 5\n")
+    SpecNegativeOperatorMatcher.new(4) < 5
   end
 
   it "does not raise an exception when expected < actual returns false" do
-    NegativeOperatorMatcher.new(5) < 4
+    SpecNegativeOperatorMatcher.new(5) < 4
   end
 end
 
-describe NegativeOperatorMatcher, "<= operator" do
-  it "raises an ExpectationNotMetError when expected <= actual returns true" do
+describe SpecNegativeOperatorMatcher, "<= operator" do
+  it "raises an SpecExpectationNotMetError when expected <= actual returns true" do
     lambda {
-      NegativeOperatorMatcher.new(4) <= 5
-    }.should raise_error(ExpectationNotMetError)
+      SpecNegativeOperatorMatcher.new(4) <= 5
+    }.should raise_error(SpecExpectationNotMetError)
     lambda {
-      NegativeOperatorMatcher.new(5) <= 5
-    }.should raise_error(ExpectationNotMetError)
+      SpecNegativeOperatorMatcher.new(5) <= 5
+    }.should raise_error(SpecExpectationNotMetError)
   end
 
   it "provides a failure message that 'Expected x not to be less than or equal to y'" do
-    Expectation.should_receive(:fail_with).with("Expected 4\n", "not to be less than or equal to 5\n")
-    NegativeOperatorMatcher.new(4) <= 5
+    SpecExpectation.should_receive(:fail_with).with(
+      "Expected 4\n", "not to be less than or equal to 5\n")
+    SpecNegativeOperatorMatcher.new(4) <= 5
   end
 
   it "does not raise an exception when expected <= actual returns false" do
-    NegativeOperatorMatcher.new(5) <= 4
+    SpecNegativeOperatorMatcher.new(5) <= 4
   end
 end
 
-describe NegativeOperatorMatcher, "> operator" do
-  it "raises an ExpectationNotMetError when expected > actual returns true" do
+describe SpecNegativeOperatorMatcher, "> operator" do
+  it "raises an SpecExpectationNotMetError when expected > actual returns true" do
     lambda {
-      NegativeOperatorMatcher.new(5) > 4
-    }.should raise_error(ExpectationNotMetError)
+      SpecNegativeOperatorMatcher.new(5) > 4
+    }.should raise_error(SpecExpectationNotMetError)
   end
 
   it "provides a failure message that 'Expected x not to be greater than y'" do
-    Expectation.should_receive(:fail_with).with("Expected 5\n", "not to be greater than 4\n")
-    NegativeOperatorMatcher.new(5) > 4
+    SpecExpectation.should_receive(:fail_with).with(
+      "Expected 5\n", "not to be greater than 4\n")
+    SpecNegativeOperatorMatcher.new(5) > 4
   end
 
   it "does not raise an exception when expected > actual returns false" do
-    NegativeOperatorMatcher.new(4) > 5
+    SpecNegativeOperatorMatcher.new(4) > 5
   end
 end
 
-describe NegativeOperatorMatcher, ">= operator" do
-  it "raises an ExpectationNotMetError when expected >= actual returns true" do
+describe SpecNegativeOperatorMatcher, ">= operator" do
+  it "raises an SpecExpectationNotMetError when expected >= actual returns true" do
     lambda {
-      NegativeOperatorMatcher.new(5) >= 4
-    }.should raise_error(ExpectationNotMetError)
+      SpecNegativeOperatorMatcher.new(5) >= 4
+    }.should raise_error(SpecExpectationNotMetError)
     lambda {
-      NegativeOperatorMatcher.new(5) >= 5
-    }.should raise_error(ExpectationNotMetError)
+      SpecNegativeOperatorMatcher.new(5) >= 5
+    }.should raise_error(SpecExpectationNotMetError)
   end
 
   it "provides a failure message that 'Expected x not to be greater than or equal to y'" do
-    Expectation.should_receive(:fail_with).with("Expected 5\n", "not to be greater than or equal to 4\n")
-    NegativeOperatorMatcher.new(5) >= 4
+    SpecExpectation.should_receive(:fail_with).with(
+      "Expected 5\n", "not to be greater than or equal to 4\n")
+    SpecNegativeOperatorMatcher.new(5) >= 4
   end
 
   it "does not raise an exception when expected >= actual returns false" do
-    NegativeOperatorMatcher.new(4) >= 5
+    SpecNegativeOperatorMatcher.new(4) >= 5
   end
 end