super_diff 0.3.0 → 0.4.0

data/spec/integration/rspec/match_array_matcher_spec.rb

@@ -0,0 +1,372 @@
+require "spec_helper"
+
+RSpec.describe "Integration with RSpec's #match_array matcher", type: :integration do
+  context "when a few number of values are given" do
+    it "produces the correct failure message when used in the positive" do
+      as_both_colored_and_uncolored do |color_enabled|
+        snippet = <<~TEST.strip
+          expected = ["Einie", "Marty"]
+          actual = ["Marty", "Jennifer", "Doc"]
+          expect(actual).to match_array(expected)
+        TEST
+        program = make_plain_test_program(
+          snippet,
+          color_enabled: color_enabled,
+        )
+
+        expected_output = build_expected_output(
+          color_enabled: color_enabled,
+          snippet: %|expect(actual).to match_array(expected)|,
+          expectation: proc {
+            line do
+              plain "Expected "
+              beta %|["Marty", "Jennifer", "Doc"]|
+              plain " to match array with "
+              alpha %|"Einie"|
+              plain " and "
+              alpha %|"Marty"|
+              plain "."
+            end
+          },
+          diff: proc {
+            plain_line %|  [|
+            plain_line %|    "Marty",|
+            plain_line %|    "Jennifer",|
+            plain_line %|    "Doc",|
+            alpha_line %|-   "Einie"|
+            plain_line %|  ]|
+          },
+        )
+
+        expect(program).
+          to produce_output_when_run(expected_output).
+          in_color(color_enabled)
+      end
+    end
+
+    it "produces the correct failure message when used in the negative" do
+      as_both_colored_and_uncolored do |color_enabled|
+        snippet = <<~TEST.strip
+          values = ["Einie", "Marty"]
+          expect(values).not_to match_array(values)
+        TEST
+        program = make_plain_test_program(
+          snippet,
+          color_enabled: color_enabled,
+        )
+
+        expected_output = build_expected_output(
+          color_enabled: color_enabled,
+          snippet: %|expect(values).not_to match_array(values)|,
+          expectation: proc {
+            line do
+              plain "Expected "
+              beta %|["Einie", "Marty"]|
+              plain " not to match array with "
+              alpha %|"Einie"|
+              plain " and "
+              alpha %|"Marty"|
+              plain "."
+            end
+          },
+        )
+
+        expect(program).
+          to produce_output_when_run(expected_output).
+          in_color(color_enabled)
+      end
+    end
+  end
+
+  context "when a large number of values are given" do
+    context "and they are only simple strings" do
+      it "produces the correct failure message when used in the positive" do
+        as_both_colored_and_uncolored do |color_enabled|
+          snippet = <<~TEST.strip
+            expected = [
+              "Doc Brown",
+              "Marty McFly",
+              "Biff Tannen",
+              "George McFly",
+              "Lorraine McFly"
+            ]
+            actual = [
+              "Marty McFly",
+              "Doc Brown",
+              "Einie",
+              "Lorraine McFly"
+            ]
+            expect(actual).to match_array(expected)
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(actual).to match_array(expected)|,
+            expectation: proc {
+              line do
+                plain "           Expected "
+                beta %|["Marty McFly", "Doc Brown", "Einie", "Lorraine McFly"]|
+              end
+
+              line do
+                plain "to match array with "
+                alpha %|"Doc Brown"|
+                plain ", "
+                alpha %|"Marty McFly"|
+                plain ", "
+                alpha %|"Biff Tannen"|
+                plain ", "
+                alpha %|"George McFly"|
+                plain " and "
+                alpha %|"Lorraine McFly"|
+              end
+            },
+            diff: proc {
+              plain_line %|  [|
+              plain_line %|    "Marty McFly",|
+              plain_line %|    "Doc Brown",|
+              plain_line %|    "Einie",|
+              plain_line %|    "Lorraine McFly",|
+              alpha_line %|-   "Biff Tannen",|
+              alpha_line %|-   "George McFly"|
+              plain_line %|  ]|
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            in_color(color_enabled)
+        end
+      end
+
+      it "produces the correct failure message when used in the negative" do
+        as_both_colored_and_uncolored do |color_enabled|
+          snippet = <<~TEST.strip
+            values = [
+              "Marty McFly",
+              "Doc Brown",
+              "Einie",
+              "Lorraine McFly"
+            ]
+            expect(values).not_to match_array(values)
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(values).not_to match_array(values)|,
+            newline_before_expectation: true,
+            expectation: proc {
+              line do
+                plain "               Expected "
+                beta %|["Marty McFly", "Doc Brown", "Einie", "Lorraine McFly"]|
+              end
+
+              line do
+                plain "not to match array with "
+                alpha %|"Marty McFly"|
+                plain ", "
+                alpha %|"Doc Brown"|
+                plain ", "
+                alpha %|"Einie"|
+                plain " and "
+                alpha %|"Lorraine McFly"|
+              end
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            in_color(color_enabled)
+        end
+      end
+    end
+
+    context "and some of them are regexen" do
+      it "produces the correct failure message when used in the positive" do
+        as_both_colored_and_uncolored do |color_enabled|
+          snippet = <<~TEST
+            expected = [
+              / Brown$/,
+              "Marty McFly",
+              "Biff Tannen",
+              /Georg McFly/,
+              /Lorrain McFly/
+            ]
+            actual = [
+              "Marty McFly",
+              "Doc Brown",
+              "Einie",
+              "Lorraine McFly"
+            ]
+            expect(actual).to match_array(expected)
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(actual).to match_array(expected)|,
+            expectation: proc {
+              line do
+                plain "           Expected "
+                beta %|["Marty McFly", "Doc Brown", "Einie", "Lorraine McFly"]|
+              end
+
+              line do
+                plain "to match array with "
+                alpha %|/ Brown$/|
+                plain ", "
+                alpha %|"Marty McFly"|
+                plain ", "
+                alpha %|"Biff Tannen"|
+                plain ", "
+                alpha %|/Georg McFly/|
+                plain " and "
+                alpha %|/Lorrain McFly/|
+              end
+            },
+            diff: proc {
+              plain_line %|  [|
+              plain_line %|    "Marty McFly",|
+              plain_line %|    "Doc Brown",|
+              plain_line %|    "Einie",|
+              plain_line %|    "Lorraine McFly",|
+              alpha_line %|-   "Biff Tannen",|
+              alpha_line %|-   /Georg McFly/,|
+              alpha_line %|-   /Lorrain McFly/|
+              plain_line %|  ]|
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            in_color(color_enabled)
+        end
+      end
+
+      it "produces the correct failure message when used in the negative" do
+        as_both_colored_and_uncolored do |color_enabled|
+          snippet = <<~TEST
+            values = [
+              / Brown$/,
+              "Marty McFly",
+              "Biff Tannen",
+              /Georg McFly/,
+              /Lorrain McFly/
+            ]
+            expect(values).not_to match_array(values)
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(values).not_to match_array(values)|,
+            newline_before_expectation: true,
+            expectation: proc {
+              line do
+                plain "               Expected "
+                # rubocop:disable Metrics/LineLength
+                beta %|[/ Brown$/, "Marty McFly", "Biff Tannen", /Georg McFly/, /Lorrain McFly/]|
+                # rubocop:enable Metrics/LineLength
+              end
+
+              line do
+                plain "not to match array with "
+                alpha %|/ Brown$/|
+                plain ", "
+                alpha %|"Marty McFly"|
+                plain ", "
+                alpha %|"Biff Tannen"|
+                plain ", "
+                alpha %|/Georg McFly/|
+                plain " and "
+                alpha %|/Lorrain McFly/|
+              end
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            in_color(color_enabled)
+        end
+      end
+    end
+
+    context "and some of them are fuzzy objects" do
+      it "produces the correct failure message" do
+        as_both_colored_and_uncolored do |color_enabled|
+          snippet = <<~TEST.strip
+            expected = [
+              a_hash_including(foo: "bar"),
+              a_collection_containing_exactly("zing"),
+              an_object_having_attributes(baz: "qux"),
+            ]
+            actual = [
+              { foo: "bar" },
+              double(baz: "qux"),
+              { blargh: "riddle" }
+            ]
+            expect(actual).to match_array(expected)
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(actual).to match_array(expected)|,
+            expectation: proc {
+              line do
+                plain "           Expected "
+                # rubocop:disable Metrics/LineLength
+                beta %|[{ foo: "bar" }, #<Double (anonymous)>, { blargh: "riddle" }]|
+                # rubocop:enable Metrics/LineLength
+              end
+
+              line do
+                plain "to match array with "
+                alpha %|#<a hash including (foo: "bar")>|
+                plain ", "
+                alpha %|#<a collection containing exactly ("zing")>|
+                plain " and "
+                alpha %|#<an object having attributes (baz: "qux")>|
+              end
+            },
+            diff: proc {
+              plain_line %|  [|
+              plain_line %|    {|
+              plain_line %|      foo: "bar"|
+              plain_line %|    },|
+              plain_line %|    #<Double (anonymous)>,|
+              plain_line %|    {|
+              plain_line %|      blargh: "riddle"|
+              plain_line %|    },|
+              alpha_line %|-   #<a collection containing exactly (|
+              alpha_line %|-     "zing"|
+              alpha_line %|-   )>|
+              plain_line %|  ]|
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            in_color(color_enabled)
+        end
+      end
+    end
+  end
+end

data/spec/integration/rspec/match_matcher_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
-  context "when the expected value is a partial hash" do
+  context "when the expected value is a hash-including-<something>" do
     context "that is small" do
       it "produces the correct failure message when used in the positive" do
         as_both_colored_and_uncolored do |color_enabled|
@@ -172,7 +172,7 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
     end
   end
 
-  context "when the expected value includes a partial hash" do
+  context "when the expected value includes a hash-including-<something>" do
     context "and the corresponding actual value is a hash" do
       it "produces the correct failure message when used in the positive" do
         as_both_colored_and_uncolored do |color_enabled|
@@ -341,7 +341,7 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
     end
   end
 
-  context "when the expected value is a partial array" do
+  context "when the expected value is a collection-including-<something>" do
     context "that is small" do
       it "produces the correct failure message when used in the positive" do
         as_both_colored_and_uncolored do |color_enabled|
@@ -498,7 +498,7 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
     end
   end
 
-  context "when the expected value includes a partial array" do
+  context "when the expected value includes a collection-including-<something>" do
     context "and the corresponding actual value is an array" do
       it "produces the correct failure message when used in the positive" do
         as_both_colored_and_uncolored do |color_enabled|
@@ -647,7 +647,7 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
     end
   end
 
-  context "when the expected value is a partial object" do
+  context "when the expected value is an object-having-attributes" do
     context "that is small" do
       it "produces the correct failure message when used in the positive" do
         as_both_colored_and_uncolored do |color_enabled|
@@ -830,7 +830,7 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
     end
   end
 
-  context "when the expected value includes a partial object" do
+  context "when the expected value includes an object-having-attributes" do
     it "produces the correct failure message when used in the positive" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
@@ -953,7 +953,7 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
     end
   end
 
-  context "when the expected value is an order-independent array" do
+  context "when the expected value is a collection-containing-exactly-<something>" do
     context "that is small" do
       it "produces the correct failure message when used in the positive" do
         as_both_colored_and_uncolored do |color_enabled|
@@ -1108,7 +1108,7 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
     end
   end
 
-  context "when the expected value includes an order-independent array" do
+  context "when the expected value includes a collection-containing-exactly-<something>" do
     context "and the corresponding actual value is an array" do
       it "produces the correct failure message when used in the positive" do
         as_both_colored_and_uncolored do |color_enabled|

data/spec/integration/rspec/raise_error_matcher_spec.rb

@@ -2,138 +2,113 @@ require "spec_helper"
 
 RSpec.describe "Integration with RSpec's #raise_error matcher", type: :integration do
   context "given only an exception class" do
-    it "produces the correct failure message when used in the positive" do
-      as_both_colored_and_uncolored do |color_enabled|
-        snippet = <<~TEST.strip
-          expect { raise StandardError.new('boo') }.to raise_error(RuntimeError)
-        TEST
-        program = make_plain_test_program(
-          snippet,
-          color_enabled: color_enabled,
-        )
-
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect { raise StandardError.new('boo') }.to raise_error(RuntimeError)|,
-          expectation: proc {
-            line do
-              plain "Expected raised exception "
-              beta  %|#<StandardError "boo">|
-              plain " to match "
-              alpha %|#<RuntimeError>|
-              plain "."
+    context "when used in the positive" do
+      context "when the block raises a different error than what is given" do
+        context "when the message is short" do
+          it "produces the correct failure message" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expect { raise StandardError.new('boo') }.to raise_error(RuntimeError)
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect { raise StandardError.new('boo') }.to raise_error(RuntimeError)|,
+                expectation: proc {
+                  line do
+                    plain "Expected raised exception "
+                    beta  %|#<StandardError "boo">|
+                    plain " to match "
+                    alpha %|#<RuntimeError>|
+                    plain "."
+                  end
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
             end
-          },
-        )
-
-        expect(program).
-          to produce_output_when_run(expected_output).
-          in_color(color_enabled)
-      end
-    end
+          end
+        end
 
-    it "produces the correct failure message when used in the negative" do
-      as_both_colored_and_uncolored do |color_enabled|
-        snippet = <<~TEST.strip
-          expect { raise StandardError.new('boo') }.not_to raise_error(StandardError)
-        TEST
-        program = make_plain_test_program(
-          snippet,
-          color_enabled: color_enabled,
-        )
-
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect { raise StandardError.new('boo') }.not_to raise_error(StandardError)|,
-          expectation: proc {
-            line do
-              plain "Expected raised exception "
-              beta  %|#<StandardError "boo">|
-              plain " not to match "
-              alpha %|#<StandardError>|
-              plain "."
+        context "when the message is long" do
+          it "produces the correct failure message" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expect { raise StandardError.new('this is a super super super long message') }.to raise_error(RuntimeError)
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect { raise StandardError.new('this is a super super super long message') }.to raise_error(RuntimeError)|,
+                newline_before_expectation: true,
+                expectation: proc {
+                  line do
+                    plain "Expected raised exception "
+                    beta  %|#<StandardError "this is a super super super long message">|
+                  end
+
+                  line do
+                    plain "                 to match "
+                    alpha %|#<RuntimeError>|
+                  end
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
             end
-          },
-        )
-
-        expect(program).
-          to produce_output_when_run(expected_output).
-          in_color(color_enabled)
-      end
-    end
-  end
-
-  context "with only a message (and assuming a RuntimeError)" do
-    context "when the message is short" do
-      it "produces the correct failure message when used in the positive" do
-        as_both_colored_and_uncolored do |color_enabled|
-          snippet = <<~TEST.strip
-            expect { raise 'boo' }.to raise_error('hell')
-          TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect { raise 'boo' }.to raise_error('hell')|,
-            expectation: proc {
-              line do
-                plain "Expected raised exception "
-                beta  %|#<RuntimeError "boo">|
-                plain " to match "
-                alpha %|#<Exception "hell">|
-                plain "."
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
+          end
         end
       end
 
-      it "produces the correct failure message when used in the negative" do
-        as_both_colored_and_uncolored do |color_enabled|
-          snippet = <<~TEST.strip
-            expect { raise 'boo' }.not_to raise_error('boo')
-          TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect { raise 'boo' }.not_to raise_error('boo')|,
-            expectation: proc {
-              line do
-                plain "Expected raised exception "
-                beta  %|#<RuntimeError "boo">|
-                plain " not to match "
-                alpha %|#<Exception "boo">|
-                plain "."
-              end
-            },
-          )
+      context "when the block raises no error" do
+        it "produces the correct failure message" do
+          as_both_colored_and_uncolored do |color_enabled|
+            snippet = <<~TEST.strip
+              expect { }.to raise_error(RuntimeError)
+            TEST
+            program = make_plain_test_program(
+              snippet,
+              color_enabled: color_enabled,
+            )
 
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
+            expected_output = build_expected_output(
+              color_enabled: color_enabled,
+              snippet: %|expect { }.to raise_error(RuntimeError)|,
+              expectation: proc {
+                line do
+                  plain "Expected block to raise error "
+                  alpha %|#<RuntimeError>|
+                  plain "."
+                end
+              },
+            )
+
+            expect(program).
+              to produce_output_when_run(expected_output).
+              in_color(color_enabled)
+          end
         end
       end
     end
 
-    context "when the message is long" do
-      context "but contains no line breaks" do
-        it "produces the correct failure message when used in the positive" do
+    context "when used in the negative" do
+      context "when the message is short" do
+        it "produces the correct failure message" do
           as_both_colored_and_uncolored do |color_enabled|
             snippet = <<~TEST.strip
-              actual_message = "some really really really long message"
-              expected_message = "whatever"
-              expect { raise(actual_message) }.to raise_error(expected_message)
+              expect { raise StandardError.new('boo') }.not_to raise_error(StandardError)
             TEST
             program = make_plain_test_program(
               snippet,
@@ -142,17 +117,14 @@ RSpec.describe "Integration with RSpec's #raise_error matcher", type: :integrati
 
             expected_output = build_expected_output(
               color_enabled: color_enabled,
-              snippet: %|expect { raise(actual_message) }.to raise_error(expected_message)|,
-              newline_before_expectation: true,
+              snippet: %|expect { raise StandardError.new('boo') }.not_to raise_error(StandardError)|,
               expectation: proc {
                 line do
                   plain "Expected raised exception "
-                  beta  %|#<RuntimeError "some really really really long message">|
-                end
-
-                line do
-                  plain "                 to match "
-                  alpha %|#<Exception "whatever">|
+                  beta  %|#<StandardError "boo">|
+                  plain " not to match "
+                  alpha %|#<StandardError>|
+                  plain "."
                 end
               },
             )
@@ -162,12 +134,13 @@ RSpec.describe "Integration with RSpec's #raise_error matcher", type: :integrati
               in_color(color_enabled)
           end
         end
+      end
 
-        it "produces the correct failure message when used in the negative" do
+      context "when the message is long" do
+        it "produces the correct failure message" do
           as_both_colored_and_uncolored do |color_enabled|
             snippet = <<~TEST.strip
-              message = "some really long message"
-              expect { raise(message) }.not_to raise_error(message)
+              expect { raise StandardError.new('this is a super super long message') }.not_to raise_error(StandardError)
             TEST
             program = make_plain_test_program(
               snippet,
@@ -176,17 +149,17 @@ RSpec.describe "Integration with RSpec's #raise_error matcher", type: :integrati
 
             expected_output = build_expected_output(
               color_enabled: color_enabled,
-              snippet: %|expect { raise(message) }.not_to raise_error(message)|,
+              snippet: %|expect { raise StandardError.new('this is a super super long message') }.not_to raise_error(StandardError)|,
               newline_before_expectation: true,
               expectation: proc {
                 line do
                   plain "Expected raised exception "
-                  beta  %|#<RuntimeError "some really long message">|
+                  beta  %|#<StandardError "this is a super super long message">|
                 end
 
                 line do
                   plain "             not to match "
-                  alpha %|#<Exception "some really long message">|
+                  alpha %|#<StandardError>|
                 end
               },
             )
@@ -197,20 +170,244 @@ RSpec.describe "Integration with RSpec's #raise_error matcher", type: :integrati
           end
         end
       end
+    end
+  end
+
+  context "with only a message (and assuming a RuntimeError)" do
+    context "when used in the positive" do
+      context "when the block raises a different error than what is given" do
+        context "when the message is short" do
+          it "produces the correct failure message" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expect { raise 'boo' }.to raise_error('hell')
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect { raise 'boo' }.to raise_error('hell')|,
+                expectation: proc {
+                  line do
+                    plain "Expected raised exception "
+                    beta  %|#<RuntimeError "boo">|
+                    plain " to match "
+                    alpha %|#<Exception "hell">|
+                    plain "."
+                  end
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+
+        context "when the message is long" do
+          context "but contains no line breaks" do
+            it "produces the correct failure message when used in the positive" do
+              as_both_colored_and_uncolored do |color_enabled|
+                snippet = <<~TEST.strip
+                  actual_message = "some really really really long message"
+                  expected_message = "whatever"
+                  expect { raise(actual_message) }.to raise_error(expected_message)
+                TEST
+                program = make_plain_test_program(
+                  snippet,
+                  color_enabled: color_enabled,
+                )
+
+                expected_output = build_expected_output(
+                  color_enabled: color_enabled,
+                  snippet: %|expect { raise(actual_message) }.to raise_error(expected_message)|,
+                  newline_before_expectation: true,
+                  expectation: proc {
+                    line do
+                      plain "Expected raised exception "
+                      beta  %|#<RuntimeError "some really really really long message">|
+                    end
+
+                    line do
+                      plain "                 to match "
+                      alpha %|#<Exception "whatever">|
+                    end
+                  },
+                )
+
+                expect(program).
+                  to produce_output_when_run(expected_output).
+                  in_color(color_enabled)
+              end
+            end
+          end
+
+          context "but contains line breaks" do
+            it "produces the correct failure message when used in the positive" do
+              as_both_colored_and_uncolored do |color_enabled|
+                snippet = <<~TEST.strip
+                  actual_message = <<\~MESSAGE.rstrip
+                    This is fun
+                    So is this
+                  MESSAGE
+                  expected_message = <<\~MESSAGE.rstrip
+                    This is fun
+                    And so is this
+                  MESSAGE
+                  expect { raise(actual_message) }.to raise_error(expected_message)
+                TEST
+                program = make_plain_test_program(
+                  snippet,
+                  color_enabled: color_enabled,
+                )
+
+                expected_output = build_expected_output(
+                  color_enabled: color_enabled,
+                  snippet: %|expect { raise(actual_message) }.to raise_error(expected_message)|,
+                  expectation: proc {
+                    line do
+                      plain "Expected raised exception "
+                      beta  %|#<RuntimeError "This is fun\\nSo is this">|
+                    end
+
+                    line do
+                      plain "                 to match "
+                      alpha %|#<Exception "This is fun\\nAnd so is this">|
+                    end
+                  },
+                  diff: proc {
+                    plain_line %|  This is fun\\n|
+                    alpha_line %|- And so is this|
+                    beta_line  %|+ So is this|
+                  },
+                )
+
+                expect(program).
+                  to produce_output_when_run(expected_output).
+                  in_color(color_enabled)
+              end
+            end
+          end
+        end
+      end
+
+      context "when the block raises no error" do
+        context "when the message is short" do
+          it "produces the correct failure message" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expect { }.to raise_error('hell')
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect { }.to raise_error('hell')|,
+                expectation: proc {
+                  line do
+                    plain "Expected block to raise error "
+                    alpha %|#<Exception "hell">|
+                    plain "."
+                  end
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+
+        end
+
+        context "when the message is long" do
+          context "but contains no line breaks" do
+            it "produces the correct failure message" do
+              as_both_colored_and_uncolored do |color_enabled|
+                snippet = <<~TEST.strip
+                  expect { }.to raise_error("this is a super super super super super super long message")
+                TEST
+                program = make_plain_test_program(
+                  snippet,
+                  color_enabled: color_enabled,
+                )
+
+                expected_output = build_expected_output(
+                  color_enabled: color_enabled,
+                  snippet: %|expect { }.to raise_error("this is a super super super super super super long message")|,
+                  newline_before_expectation: true,
+                  expectation: proc {
+                    line do
+                      plain "      Expected "
+                      plain "block"
+                    end
+
+                    line do
+                      plain "to raise error "
+                      alpha %|#<Exception "this is a super super super super super super long message">|
+                    end
+                  },
+                )
+
+                expect(program).
+                  to produce_output_when_run(expected_output).
+                  in_color(color_enabled)
+              end
+            end
+          end
+
+          context "but contains line breaks" do
+            it "produces the correct failure message when used in the negative" do
+              as_both_colored_and_uncolored do |color_enabled|
+                snippet = <<~TEST.strip
+                  message = "some really long message"
+                  expect { raise(message) }.not_to raise_error(message)
+                TEST
+                program = make_plain_test_program(
+                  snippet,
+                  color_enabled: color_enabled,
+                )
+
+                expected_output = build_expected_output(
+                  color_enabled: color_enabled,
+                  snippet: %|expect { raise(message) }.not_to raise_error(message)|,
+                  newline_before_expectation: true,
+                  expectation: proc {
+                    line do
+                      plain "Expected raised exception "
+                      beta  %|#<RuntimeError "some really long message">|
+                    end
+
+                    line do
+                      plain "             not to match "
+                      alpha %|#<Exception "some really long message">|
+                    end
+                  },
+                )
+
+                expect(program).
+                  to produce_output_when_run(expected_output).
+                  in_color(color_enabled)
+              end
+            end
+          end
+        end
+      end
+    end
 
-      context "but contains line breaks" do
-        it "produces the correct failure message when used in the positive" do
+    context "when used in the negative" do
+      context "when the message is short" do
+        it "produces the correct failure message" do
           as_both_colored_and_uncolored do |color_enabled|
             snippet = <<~TEST.strip
-              actual_message = <<\~MESSAGE.rstrip
-                This is fun
-                So is this
-              MESSAGE
-              expected_message = <<\~MESSAGE.rstrip
-                This is fun
-                And so is this
-              MESSAGE
-              expect { raise(actual_message) }.to raise_error(expected_message)
+              expect { raise 'boo' }.not_to raise_error('boo')
             TEST
             program = make_plain_test_program(
               snippet,
@@ -219,23 +416,270 @@ RSpec.describe "Integration with RSpec's #raise_error matcher", type: :integrati
 
             expected_output = build_expected_output(
               color_enabled: color_enabled,
-              snippet: %|expect { raise(actual_message) }.to raise_error(expected_message)|,
+              snippet: %|expect { raise 'boo' }.not_to raise_error('boo')|,
               expectation: proc {
                 line do
                   plain "Expected raised exception "
-                  beta  %|#<RuntimeError "This is fun\\nSo is this">|
+                  beta  %|#<RuntimeError "boo">|
+                  plain " not to match "
+                  alpha %|#<Exception "boo">|
+                  plain "."
                 end
+              },
+            )
+
+            expect(program).
+              to produce_output_when_run(expected_output).
+              in_color(color_enabled)
+          end
+        end
+      end
 
+      context "when the message is long" do
+        context "but contains no line breaks" do
+          it "produces the correct failure message" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                message = "some really long message"
+                expect { raise(message) }.not_to raise_error(message)
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect { raise(message) }.not_to raise_error(message)|,
+                newline_before_expectation: true,
+                expectation: proc {
+                  line do
+                    plain "Expected raised exception "
+                    beta  %|#<RuntimeError "some really long message">|
+                  end
+
+                  line do
+                    plain "             not to match "
+                    alpha %|#<Exception "some really long message">|
+                  end
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+
+        context "but contains line breaks" do
+          it "produces the correct failure message" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                message = <<\~MESSAGE.rstrip
+                  This is fun
+                  So is this
+                MESSAGE
+                expect { raise(message) }.not_to raise_error(message)
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect { raise(message) }.not_to raise_error(message)|,
+                newline_before_expectation: true,
+                expectation: proc {
+                  line do
+                    plain "Expected raised exception "
+                    beta  %|#<RuntimeError "This is fun\\nSo is this">|
+                  end
+
+                  line do
+                    plain "             not to match "
+                    alpha %|#<Exception "This is fun\\nSo is this">|
+                  end
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context "with both an exception and a message" do
+    context "when used in the positive" do
+      context "when the block raises a different error than what is given" do
+        context "when the message is short" do
+          it "produces the correct failure message" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                block = -> { raise StandardError.new('a') }
+                expect(&block).to raise_error(RuntimeError, 'b')
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect(&block).to raise_error(RuntimeError, 'b')|,
+                expectation: proc {
+                  line do
+                    plain "Expected raised exception "
+                    beta  %|#<StandardError "a">|
+                    plain " to match "
+                    alpha %|#<RuntimeError "b">|
+                    plain "."
+                  end
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+
+        context "when the message is long" do
+          it "produces the correct failure message" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                block = -> { raise StandardError.new('this is a long message') }
+                expect(&block).to raise_error(RuntimeError, 'this is another long message')
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect(&block).to raise_error(RuntimeError, 'this is another long message')|,
+                newline_before_expectation: true,
+                expectation: proc {
+                  line do
+                    plain "Expected raised exception "
+                    beta  %|#<StandardError "this is a long message">|
+                  end
+
+                  line do
+                    plain "                 to match "
+                    alpha %|#<RuntimeError "this is another long message">|
+                  end
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+      end
+
+      context "when the block raises no error" do
+        context "when the message is short" do
+          it "produces the correct failure message" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expect { }.to raise_error(RuntimeError, 'b')
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect { }.to raise_error(RuntimeError, 'b')|,
+                expectation: proc {
+                  line do
+                    plain "Expected block to raise error "
+                    alpha %|#<RuntimeError "b">|
+                    plain "."
+                  end
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+
+        context "when the message is long" do
+          it "produces the correct failure message" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expect { }.to raise_error(RuntimeError, 'this is a super super super super super super long message')
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect { }.to raise_error(RuntimeError, 'this is a super super super super super super long message')|,
+                newline_before_expectation: true,
+                expectation: proc {
+                  line do
+                    plain "      Expected "
+                    plain "block"
+                  end
+
+                  line do
+                    plain "to raise error "
+                    alpha %|#<RuntimeError "this is a super super super super super super long message">|
+                  end
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+      end
+    end
+
+    context "when used in the negative" do
+      context "when the message is short" do
+        it "produces the correct failure message" do
+          as_both_colored_and_uncolored do |color_enabled|
+            snippet = <<~TEST.strip
+              block = -> { raise StandardError.new('a') }
+              expect(&block).not_to raise_error(StandardError, 'a')
+            TEST
+            program = make_plain_test_program(
+              snippet,
+              color_enabled: color_enabled,
+            )
+
+            expected_output = build_expected_output(
+              color_enabled: color_enabled,
+              snippet: %|expect(&block).not_to raise_error(StandardError, 'a')|,
+              expectation: proc {
                 line do
-                  plain "                 to match "
-                  alpha %|#<Exception "This is fun\\nAnd so is this">|
+                  plain "Expected raised exception "
+                  beta  %|#<StandardError "a">|
+                  plain " not to match "
+                  alpha %|#<StandardError "a">|
+                  plain "."
                 end
               },
-              diff: proc {
-                plain_line %|  This is fun\\n|
-                alpha_line %|- And so is this|
-                beta_line  %|+ So is this|
-              },
             )
 
             expect(program).
@@ -243,15 +687,14 @@ RSpec.describe "Integration with RSpec's #raise_error matcher", type: :integrati
               in_color(color_enabled)
           end
         end
+      end
 
-        it "produces the correct failure message when used in the negative" do
+      context "when the message is long" do
+        it "produces the correct failure message" do
           as_both_colored_and_uncolored do |color_enabled|
             snippet = <<~TEST.strip
-              message = <<\~MESSAGE.rstrip
-                This is fun
-                So is this
-              MESSAGE
-              expect { raise(message) }.not_to raise_error(message)
+              block = -> { raise StandardError.new('this is a long message') }
+              expect(&block).not_to raise_error(StandardError, 'this is a long message')
             TEST
             program = make_plain_test_program(
               snippet,
@@ -260,17 +703,17 @@ RSpec.describe "Integration with RSpec's #raise_error matcher", type: :integrati
 
             expected_output = build_expected_output(
               color_enabled: color_enabled,
-              snippet: %|expect { raise(message) }.not_to raise_error(message)|,
+              snippet: %|expect(&block).not_to raise_error(StandardError, 'this is a long message')|,
               newline_before_expectation: true,
               expectation: proc {
                 line do
                   plain "Expected raised exception "
-                  beta  %|#<RuntimeError "This is fun\\nSo is this">|
+                  beta  %|#<StandardError "this is a long message">|
                 end
 
                 line do
                   plain "             not to match "
-                  alpha %|#<Exception "This is fun\\nSo is this">|
+                  alpha %|#<StandardError "this is a long message">|
                 end
               },
             )
@@ -283,68 +726,4 @@ RSpec.describe "Integration with RSpec's #raise_error matcher", type: :integrati
       end
     end
   end
-
-  context "with both an exception and a message" do
-    it "produces the correct failure message when used in the positive" do
-      as_both_colored_and_uncolored do |color_enabled|
-        snippet = <<~TEST.strip
-          block = -> { raise StandardError.new('a') }
-          expect(&block).to raise_error(RuntimeError, 'b')
-        TEST
-        program = make_plain_test_program(
-          snippet,
-          color_enabled: color_enabled,
-        )
-
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect(&block).to raise_error(RuntimeError, 'b')|,
-          expectation: proc {
-            line do
-              plain "Expected raised exception "
-              beta  %|#<StandardError "a">|
-              plain " to match "
-              alpha %|#<RuntimeError "b">|
-              plain "."
-            end
-          },
-        )
-
-        expect(program).
-          to produce_output_when_run(expected_output).
-          in_color(color_enabled)
-      end
-    end
-
-    it "produces the correct failure message when used in the negative" do
-      as_both_colored_and_uncolored do |color_enabled|
-        snippet = <<~TEST.strip
-          block = -> { raise StandardError.new('a') }
-          expect(&block).not_to raise_error(StandardError, 'a')
-        TEST
-        program = make_plain_test_program(
-          snippet,
-          color_enabled: color_enabled,
-        )
-
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect(&block).not_to raise_error(StandardError, 'a')|,
-          expectation: proc {
-            line do
-              plain "Expected raised exception "
-              beta  %|#<StandardError "a">|
-              plain " not to match "
-              alpha %|#<StandardError "a">|
-              plain "."
-            end
-          },
-        )
-
-        expect(program).
-          to produce_output_when_run(expected_output).
-          in_color(color_enabled)
-      end
-    end
-  end
 end