super_diff 0.1.0 → 0.2.0

data/spec/integration/rspec/raise_error_matcher_spec.rb

@@ -0,0 +1,350 @@
+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 "."
+            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
+          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 "."
+            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
+
+      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
+            },
+          )
+
+          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
+
+        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
+
+      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
+
+        it "produces the correct failure message when used in the negative" 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
+
+  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

data/spec/integration/rspec/respond_to_matcher_spec.rb

@@ -0,0 +1,994 @@
+require "spec_helper"
+
+# TODO: Update coloring here
+RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integration do
+  context "without any qualifiers" do
+    context "when a few number of methods are specified" do
+      it "produces the correct failure message when used in the positive" do
+        as_both_colored_and_uncolored do |color_enabled|
+          snippet = %|expect(double).to respond_to(:foo)|
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: snippet,
+            expectation: proc {
+              line do
+                plain "Expected "
+                beta %|#<Double (anonymous)>|
+                plain " to respond to "
+                alpha %|:foo|
+                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 = %|expect(double).not_to respond_to(:inspect)|
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: snippet,
+            expectation: proc {
+              line do
+                plain "Expected "
+                beta %|#<Double (anonymous)>|
+                plain " not to respond to "
+                alpha %|:inspect|
+                plain "."
+              end
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            in_color(color_enabled)
+        end
+      end
+    end
+
+    context "when a large number of methods are specified" 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(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :qux, :fizz, :buzz, :zing)
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :qux, :fizz, :buzz, :zing)|,
+            newline_before_expectation: true,
+            expectation: proc {
+              line do
+                plain "     Expected "
+                beta %|#<Double :something_really_long>|
+              end
+
+              line do
+                plain "to respond to "
+                alpha %|:foo|
+                plain ", "
+                alpha %|:bar|
+                plain ", "
+                alpha %|:baz|
+                plain ", "
+                alpha %|:qux|
+                plain ", "
+                alpha %|:fizz|
+                plain ", "
+                alpha %|:buzz|
+                plain " and "
+                alpha %|:zing|
+              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
+            class B
+              def some_really_long_method_and_stuff; end
+              def another_method_or_whatever; end
+            end
+
+            expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever)
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever)|,
+            newline_before_expectation: true,
+            expectation: proc {
+              line do
+                plain "         Expected "
+                beta %|#<B>|
+              end
+
+              line do
+                plain "not to respond to "
+                alpha %|:some_really_long_method_and_stuff|
+                plain " and "
+                alpha %|:another_method_or_whatever|
+              end
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            removing_object_ids.
+            in_color(color_enabled)
+        end
+      end
+    end
+  end
+
+  context "qualified with #with + #arguments" do
+    context "when a few number of methods are specified when used in the positive" do
+      it "produces the correct failure message" do
+        as_both_colored_and_uncolored do |color_enabled|
+          snippet = <<~TEST.strip
+            expect(double).to respond_to(:foo).with(3).arguments
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(double).to respond_to(:foo).with(3).arguments|,
+            expectation: proc {
+              line do
+                plain "Expected "
+                beta %|#<Double (anonymous)>|
+                plain " to respond to "
+                alpha %|:foo|
+                plain " with "
+                alpha %|3|
+                plain " arguments."
+              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
+            class B
+              def foo(bar, baz, qux); end
+            end
+
+            expect(B.new).not_to respond_to(:foo).with(3).arguments
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(B.new).not_to respond_to(:foo).with(3).arguments|,
+            expectation: proc {
+              line do
+                plain "Expected "
+                beta %|#<B>|
+                plain " not to respond to "
+                alpha %|:foo|
+                plain " with "
+                alpha %|3|
+                plain " arguments."
+              end
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            removing_object_ids.
+            in_color(color_enabled)
+        end
+      end
+    end
+
+    context "when a large number of methods are specified" 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(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :fizz, :buzz).with(3).arguments
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :fizz, :buzz).with(3).arguments|,
+            newline_before_expectation: true,
+            expectation: proc {
+              line do
+                plain "     Expected "
+                beta %|#<Double :something_really_long>|
+              end
+
+              line do
+                plain "to respond to "
+                alpha %|:foo|
+                plain ", "
+                alpha %|:bar|
+                plain ", "
+                alpha %|:baz|
+                plain ", "
+                alpha %|:fizz|
+                plain " and "
+                alpha %|:buzz|
+                plain " with "
+                alpha %|3|
+                plain " arguments"
+              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
+            class B
+              def some_really_long_method_and_stuff(foo, bar, baz); end
+              def another_method_or_whatever(foo, bar, baz); end
+            end
+
+            expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with(3).arguments
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with(3).arguments|,
+            newline_before_expectation: true,
+            expectation: proc {
+              line do
+                plain "         Expected "
+                beta %|#<B>|
+              end
+
+              line do
+                plain "not to respond to "
+                alpha %|:some_really_long_method_and_stuff|
+                plain " and "
+                alpha %|:another_method_or_whatever|
+                plain " with "
+                alpha %|3|
+                plain " arguments"
+              end
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            removing_object_ids.
+            in_color(color_enabled)
+        end
+      end
+    end
+  end
+
+  context "qualified with #with_keywords" do
+    context "when a few number of methods are specified" 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(double).to respond_to(:foo).with_keywords(:bar)
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(double).to respond_to(:foo).with_keywords(:bar)|,
+            expectation: proc {
+              line do
+                plain "Expected "
+                beta %|#<Double (anonymous)>|
+                plain " to respond to "
+                alpha %|:foo|
+                plain " with keyword "
+                alpha %|:bar|
+                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
+            class B
+              def foo(bar:); end
+            end
+
+            expect(B.new).not_to respond_to(:foo).with_keywords(:bar)
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(B.new).not_to respond_to(:foo).with_keywords(:bar)|,
+            expectation: proc {
+              line do
+                plain "Expected "
+                beta %|#<B>|
+                plain " not to respond to "
+                alpha %|:foo|
+                plain " with keyword "
+                alpha %|:bar|
+                plain "."
+              end
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            removing_object_ids.
+            in_color(color_enabled)
+        end
+      end
+    end
+
+    context "when a large number of methods are specified" 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(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :fizz, :buzz).with_keywords(:qux, :blargh)
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :fizz, :buzz).with_keywords(:qux, :blargh)|,
+            newline_before_expectation: true,
+            expectation: proc {
+              line do
+                plain "     Expected "
+                beta %|#<Double :something_really_long>|
+              end
+
+              line do
+                plain "to respond to "
+                alpha %|:foo|
+                plain ", "
+                alpha %|:bar|
+                plain ", "
+                alpha %|:baz|
+                plain ", "
+                alpha %|:fizz|
+                plain " and "
+                alpha %|:buzz|
+                plain " with keywords "
+                alpha %|:qux|
+                plain " and "
+                alpha %|:blargh|
+              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
+            class B
+              def some_really_long_method_and_stuff(foo:, bar:); end
+              def another_method_or_whatever(foo:, bar:); end
+            end
+
+            expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_keywords(:foo, :bar)
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_keywords(:foo, :bar)|,
+            newline_before_expectation: true,
+            expectation: proc {
+              line do
+                plain "         Expected "
+                beta %|#<B>|
+              end
+
+              line do
+                plain "not to respond to "
+                alpha %|:some_really_long_method_and_stuff|
+                plain " and "
+                alpha %|:another_method_or_whatever|
+                plain " with keywords "
+                alpha %|:foo|
+                plain " and "
+                alpha %|:bar|
+              end
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            removing_object_ids.
+            in_color(color_enabled)
+        end
+      end
+    end
+  end
+
+  context "qualified with #with_any_keywords" do
+    context "when a few number of methods are specified" 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(double).to respond_to(:foo).with_any_keywords
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(double).to respond_to(:foo).with_any_keywords|,
+            expectation: proc {
+              line do
+                plain "Expected "
+                beta %|#<Double (anonymous)>|
+                plain " to respond to "
+                alpha %|:foo|
+                plain " with "
+                alpha %|any|
+                plain " keywords."
+              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
+            class B
+              def foo(**options); end
+            end
+
+            expect(B.new).not_to respond_to(:foo).with_any_keywords
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(B.new).not_to respond_to(:foo).with_any_keywords|,
+            expectation: proc {
+              line do
+                plain "Expected "
+                beta %|#<B>|
+                plain " not to respond to "
+                alpha %|:foo|
+                plain " with "
+                alpha %|any|
+                plain " keywords."
+              end
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            removing_object_ids.
+            in_color(color_enabled)
+        end
+      end
+    end
+
+    context "when a large number of methods are specified" 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(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :qux, :fizz, :buzz).with_any_keywords
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :qux, :fizz, :buzz).with_any_keywords|,
+            newline_before_expectation: true,
+            expectation: proc {
+              line do
+                plain "     Expected "
+                beta %|#<Double :something_really_long>|
+              end
+
+              line do
+                plain "to respond to "
+                alpha %|:foo|
+                plain ", "
+                alpha %|:bar|
+                plain ", "
+                alpha %|:baz|
+                plain ", "
+                alpha %|:qux|
+                plain ", "
+                alpha %|:fizz|
+                plain " and "
+                alpha %|:buzz|
+                plain " with "
+                alpha %|any|
+                plain " keywords "
+              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
+            class B
+              def some_really_long_method_and_stuff(**options); end
+              def another_method_or_whatever(**options); end
+            end
+
+            expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_any_keywords
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_any_keywords|,
+            newline_before_expectation: true,
+            expectation: proc {
+              line do
+                plain "         Expected "
+                beta %|#<B>|
+              end
+
+              line do
+                plain "not to respond to "
+                alpha %|:some_really_long_method_and_stuff|
+                plain " and "
+                alpha %|:another_method_or_whatever|
+                plain " with "
+                alpha %|any|
+                plain " keywords "
+              end
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            removing_object_ids.
+            in_color(color_enabled)
+        end
+      end
+    end
+  end
+
+  context "qualified with #with_unlimited_arguments" do
+    context "when a few number of methods are specified" 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(double).to respond_to(:foo).with_unlimited_arguments
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(double).to respond_to(:foo).with_unlimited_arguments|,
+            expectation: proc {
+              line do
+                plain "Expected "
+                beta %|#<Double (anonymous)>|
+                plain " to respond to "
+                alpha %|:foo|
+                plain " with "
+                alpha %|unlimited|
+                plain " arguments."
+              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
+            class B
+              def foo(*args); end
+            end
+
+            expect(B.new).not_to respond_to(:foo).with_unlimited_arguments
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(B.new).not_to respond_to(:foo).with_unlimited_arguments|,
+            expectation: proc {
+              line do
+                plain "Expected "
+                beta %|#<B>|
+                plain " not to respond to "
+                alpha %|:foo|
+                plain " with "
+                alpha %|unlimited|
+                plain " arguments."
+              end
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            removing_object_ids.
+            in_color(color_enabled)
+        end
+      end
+    end
+
+    context "when a large number of methods are specified" 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(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_unlimited_arguments
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_unlimited_arguments|,
+            newline_before_expectation: true,
+            expectation: proc {
+              line do
+                plain "     Expected "
+                beta %|#<Double :something_really_long>|
+              end
+
+              line do
+                plain "to respond to "
+                alpha %|:foo|
+                plain ", "
+                alpha %|:bar|
+                plain " and "
+                alpha %|:baz|
+                plain " with "
+                alpha %|unlimited|
+                plain " arguments"
+              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
+            class B
+              def some_really_long_method_and_stuff(*args); end
+              def another_method_or_whatever(*args); end
+            end
+
+            expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_unlimited_arguments
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_unlimited_arguments|,
+            newline_before_expectation: true,
+            expectation: proc {
+              line do
+                plain "         Expected "
+                beta %|#<B>|
+              end
+
+              line do
+                plain "not to respond to "
+                alpha %|:some_really_long_method_and_stuff|
+                plain " and "
+                alpha %|:another_method_or_whatever|
+                plain " with "
+                alpha %|unlimited|
+                plain " arguments"
+              end
+            },
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            removing_object_ids.
+            in_color(color_enabled)
+        end
+      end
+    end
+  end
+
+  context "qualified with #with_any_keywords + #with_unlimited_arguments" 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(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_any_keywords.with_unlimited_arguments
+        TEST
+        program = make_plain_test_program(
+          snippet,
+          color_enabled: color_enabled,
+        )
+
+        expected_output = build_expected_output(
+          color_enabled: color_enabled,
+          snippet: %|expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_any_keywords.with_unlimited_arguments|,
+          newline_before_expectation: true,
+          expectation: proc {
+            line do
+              plain "     Expected "
+              beta %|#<Double :something_really_long>|
+            end
+
+            line do
+              plain "to respond to "
+              alpha %|:foo|
+              plain ", "
+              alpha %|:bar|
+              plain " and "
+              alpha %|:baz|
+              plain " with "
+              alpha %|any|
+              plain " keywords and "
+              alpha %|unlimited|
+              plain " arguments"
+            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
+          class B
+            def foo(*args, **options); end
+            def bar(*args, **options); end
+            def baz(*args, **options); end
+          end
+
+          expect(B.new).not_to respond_to(:foo, :bar, :baz).with_any_keywords.with_unlimited_arguments
+        TEST
+        program = make_plain_test_program(
+          snippet,
+          color_enabled: color_enabled,
+        )
+
+        expected_output = build_expected_output(
+          color_enabled: color_enabled,
+          snippet: %|expect(B.new).not_to respond_to(:foo, :bar, :baz).with_any_keywords.with_unlimited_arguments|,
+          newline_before_expectation: true,
+          expectation: proc {
+            line do
+              plain "         Expected "
+              beta %|#<B>|
+            end
+
+            line do
+              plain "not to respond to "
+              alpha %|:foo|
+              plain ", "
+              alpha %|:bar|
+              plain " and "
+              alpha %|:baz|
+              plain " with "
+              alpha %|any|
+              plain " keywords and "
+              alpha %|unlimited|
+              plain " arguments"
+            end
+          },
+        )
+
+        expect(program).
+          to produce_output_when_run(expected_output).
+          removing_object_ids.
+          in_color(color_enabled)
+      end
+    end
+  end
+
+  context "qualified with #with_keywords + #with_unlimited_arguments" 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(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_keywords(:qux, :blargh).with_unlimited_arguments
+        TEST
+        program = make_plain_test_program(
+          snippet,
+          color_enabled: color_enabled,
+        )
+
+        expected_output = build_expected_output(
+          color_enabled: color_enabled,
+          snippet: %|expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_keywords(:qux, :blargh).with_unlimited_arguments|,
+          newline_before_expectation: true,
+          expectation: proc {
+            line do
+              plain "     Expected "
+              beta %|#<Double :something_really_long>|
+            end
+
+            line do
+              plain "to respond to "
+              alpha %|:foo|
+              plain ", "
+              alpha %|:bar|
+              plain " and "
+              alpha %|:baz|
+              plain " with keywords "
+              alpha %|:qux|
+              plain " and "
+              alpha %|:blargh|
+              plain " and "
+              alpha %|unlimited|
+              plain " arguments"
+            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
+          class B
+            def foo(*args, qux:, blargh:); end
+            def bar(*args, qux:, blargh:); end
+            def baz(*args, qux:, blargh:); end
+          end
+
+          expect(B.new).not_to respond_to(:foo, :bar, :baz).with_keywords(:qux, :blargh).with_unlimited_arguments
+        TEST
+        program = make_plain_test_program(
+          snippet,
+          color_enabled: color_enabled,
+        )
+
+        expected_output = build_expected_output(
+          color_enabled: color_enabled,
+          snippet: %|expect(B.new).not_to respond_to(:foo, :bar, :baz).with_keywords(:qux, :blargh).with_unlimited_arguments|,
+          newline_before_expectation: true,
+          expectation: proc {
+            line do
+              plain "         Expected "
+              beta %|#<B>|
+            end
+
+            line do
+              plain "not to respond to "
+              alpha %|:foo|
+              plain ", "
+              alpha %|:bar|
+              plain " and "
+              alpha %|:baz|
+              plain " with keywords "
+              alpha %|:qux|
+              plain " and "
+              alpha %|:blargh|
+              plain " and "
+              alpha %|unlimited|
+              plain " arguments"
+            end
+          },
+        )
+
+        expect(program).
+          to produce_output_when_run(expected_output).
+          removing_object_ids.
+          in_color(color_enabled)
+      end
+    end
+  end
+end