From 3b0e9577e762498389cbe2d4d1b7d4c9b29aaec3 Mon Sep 17 00:00:00 2001
From: David Chelimsky <dchelimsky@gmail.com>
Date: Sun, 2 Jan 2011 15:06:10 -0600
Subject: [PATCH] update expected output in cukes to align with changes in
 rspec-core

---
 features/built_in_matchers/be.feature        | 20 +++---
 features/built_in_matchers/operators.feature | 76 ++++++++++----------
 features/diffing.feature                     | 24 +++----
 3 files changed, 60 insertions(+), 60 deletions(-)

diff --git a/features/built_in_matchers/be.feature b/features/built_in_matchers/be.feature
index 0a4fb5686..8ad2889cc 100644
--- a/features/built_in_matchers/be.feature
+++ b/features/built_in_matchers/be.feature
@@ -83,28 +83,28 @@ Feature: "be" matchers
     Then the output should contain "10 examples, 5 failures"
     And the output should contain:
       """
-           expected: not nil
-                got: nil
+             expected: not nil
+                  got: nil
       """
     And the output should contain:
       """
-           expected: nil
-                got: false
+             expected: nil
+                  got: false
       """
     And the output should contain:
       """
-           expected: nil
-                got: true
+             expected: nil
+                  got: true
       """
     And the output should contain:
       """
-           expected: nil
-                got: 7
+             expected: nil
+                  got: 7
       """
     And the output should contain:
       """
-           expected: nil
-                got: "foo"
+             expected: nil
+                  got: "foo"
       """
 
   Scenario: be matcher
diff --git a/features/built_in_matchers/operators.feature b/features/built_in_matchers/operators.feature
index fc1ebb91b..6a748f950 100644
--- a/features/built_in_matchers/operators.feature
+++ b/features/built_in_matchers/operators.feature
@@ -51,38 +51,38 @@ Feature: operator matchers
       And the output should contain:
       """
            Failure/Error: it { should == 28 }
-           expected: 28
-                got: 18 (using ==)
+             expected: 28
+                  got: 18 (using ==)
       """
       And the output should contain:
       """
            Failure/Error: it { should be < 15 }
-           expected: < 15
-                got:   18
+             expected: < 15
+                  got:   18
       """
       And the output should contain:
       """
            Failure/Error: it { should be > 20 }
-           expected: > 20
-                got:   18
+             expected: > 20
+                  got:   18
       """
       And the output should contain:
       """
            Failure/Error: it { should be <= 17 }
-           expected: <= 17
-                got:    18
+             expected: <= 17
+                  got:    18
       """
       And the output should contain:
       """
            Failure/Error: it { should be >= 19 }
-           expected: >= 19
-                got:    18
+             expected: >= 19
+                  got:    18
       """
       And the output should contain:
       """
            Failure/Error: it { should_not == 18 }
-           expected not: == 18
-                    got:    18
+             expected not: == 18
+                      got:    18
       """
 
   Scenario: string operator matchers
@@ -124,56 +124,56 @@ Feature: operator matchers
       And the output should contain:
       """
            Failure/Error: it { should == "Peach" }
-           expected: "Peach"
-                got: "Strawberry" (using ==)
+             expected: "Peach"
+                  got: "Strawberry" (using ==)
       """
       And the output should contain:
       """
            Failure/Error: it { should be < "Cranberry" }
-           expected: < "Cranberry"
-                got:   "Strawberry"
+             expected: < "Cranberry"
+                  got:   "Strawberry"
       """
       And the output should contain:
       """
            Failure/Error: it { should be > "Zuchini" }
-           expected: > "Zuchini"
-                got:   "Strawberry"
+             expected: > "Zuchini"
+                  got:   "Strawberry"
       """
       And the output should contain:
       """
            Failure/Error: it { should be <= "Potato" }
-           expected: <= "Potato"
-                got:    "Strawberry"
+             expected: <= "Potato"
+                  got:    "Strawberry"
       """
       And the output should contain:
       """
            Failure/Error: it { should be >= "Tomato" }
-           expected: >= "Tomato"
-                got:    "Strawberry"
+             expected: >= "Tomato"
+                  got:    "Strawberry"
       """
       And the output should contain:
       """
            Failure/Error: it { should =~ /apple/ }
-           expected: /apple/
-                got: "Strawberry" (using =~)
+             expected: /apple/
+                  got: "Strawberry" (using =~)
       """
       And the output should contain:
       """
            Failure/Error: it { should_not == "Strawberry" }
-           expected not: == "Strawberry"
-                    got:    "Strawberry"
+             expected not: == "Strawberry"
+                      got:    "Strawberry"
       """
       And the output should contain:
       """
            Failure/Error: it { should_not =~ /berry/ }
-           expected not: =~ /berry/
-                    got:    "Strawberry"
+             expected not: =~ /berry/
+                      got:    "Strawberry"
       """
       And the output should contain:
       """
            Failure/Error: Symbol.should === subject
-           expected: "Strawberry"
-                got: Symbol (using ===)
+             expected: "Strawberry"
+                  got: Symbol (using ===)
       """
 
   Scenario: array operator matchers
@@ -201,21 +201,21 @@ Feature: operator matchers
       And the output should contain:
       """
            Failure/Error: it { should_not == [1, 2, 3] }
-           expected not: == [1, 2, 3]
-                    got:    [1, 2, 3]
+             expected not: == [1, 2, 3]
+                      got:    [1, 2, 3]
       """
       And the output should contain:
       """
            Failure/Error: it { should == [1, 3, 2] }
-           expected: [1, 3, 2]
-                got: [1, 2, 3] (using ==)
+             expected: [1, 3, 2]
+                  got: [1, 2, 3] (using ==)
       """
       And the output should contain:
       """
            Failure/Error: it { should =~ [1, 2, 1] }
-           expected collection contained:  [1, 1, 2]
-           actual collection contained:    [1, 2, 3]
-           the missing elements were:      [1]
-           the extra elements were:        [3]
+             expected collection contained:  [1, 1, 2]
+             actual collection contained:    [1, 2, 3]
+             the missing elements were:      [1]
+             the extra elements were:        [3]
       """
 
diff --git a/features/diffing.feature b/features/diffing.feature
index 05872c146..06a1b51d5 100644
--- a/features/diffing.feature
+++ b/features/diffing.feature
@@ -24,12 +24,12 @@ Feature: diffing
     When I run "rspec example_spec.rb"
     Then the output should contain:
       """
-           Diff:
-           @@ -1,4 +1,4 @@
-            this is the
-           -  expected
-           +  actual
-                string
+             Diff:
+             @@ -1,4 +1,4 @@
+              this is the
+             -  expected
+             +  actual
+                  string
       """
 
   Scenario: diff for a multiline string and a regexp
@@ -50,12 +50,12 @@ Feature: diffing
     When I run "rspec example_spec.rb"
     Then the output should contain:
       """
-           Diff:
-           @@ -1,2 +1,4 @@
-           -/expected/m
-           +this is the
-           +  actual
-           +    string
+             Diff:
+             @@ -1,2 +1,4 @@
+             -/expected/m
+             +this is the
+             +  actual
+             +    string
       """
 
   Scenario: no diff for a single line strings