require 'opal_filters'

OpalFilters.group("Bugs") do
  fails "and_call_original on a partial double warns when you override an existing implementation",  "RSpec received \"warning\" with unexpected arguments"
  fails "and_call_original on a partial double for singleton methods works for SimpleDelegator subclasses",  "can't define singleton"
  fails "#any_instance when stubbing behaves as 'every instance' handles freeze and duplication correctly",  "undefined method `concat' for \"foo\""
  fails "#any_instance when stubbing when the class has a prepended module allows stubbing a method that is not defined on the prepended module",  "method 'foo' not defined in"
  fails "#any_instance when stubbing when the class has a prepended module allows stubbing a chain starting with a method that is not defined on the prepended module",  "method 'foo' not defined in"
  fails "#any_instance when stubbing core ruby objects works with the non-standard constructor \"\"",  "Cannot proxy frozen objects. Symbols such as  cannot be mocked or stubbed."
  fails "#any_instance when stubbing core ruby objects works with the non-standard constructor ''",  "Cannot proxy frozen objects. Symbols such as  cannot be mocked or stubbed."
  fails "#any_instance setting a message expectation does not set the expectation on every instance",  "Cannot proxy frozen objects. Symbols such as non-related object cannot be mocked or stubbed."
  fails "#any_instance setting a message expectation when the class has a prepended module allows mocking a method that is not defined on the prepended module",  "method 'foo' not defined in "
  fails "#any_instance when resetting post-verification existing method with stubbing private methods restores a stubbed private method after the spec is run",  "expected: truthy value"
  fails "#any_instance when resetting post-verification existing method with expectations private methods restores a stubbed private method after the spec is run",  "expected: truthy value"
  fails "argument matchers matching kind_of handles a class thats overridden ===",  "Maximum call stack size exceeded"
  fails "argument matchers matching duck_type rejects goose when expecting a duck",  "expected RSpec::Mocks::MockExpectationError with a string including \"expected: (duck_type(:abs, :div)"
  fails "argument matchers matching hash_including fails hash_including with missing key",  "expected RSpec::Mocks::MockExpectationError with a string including \"expected: (hash_including(:a => "
  fails "argument matchers matching hash_excluding handles non matching instances nicely",  "expected RSpec::Mocks::MockExpectationError with a string including \"expected: (hash_not_including(:a"
  fails "argument matchers matching handling non-matcher arguments fails to matches against a hash submitted as a positional argument and received as keyword arguments in Ruby 3.0 or later",  "expected RSpec::Mocks::MockExpectationError with message matching /expected: \\(\\{(:a=>\\\"a\\\", :b=>\\\"b\\"
  fails "argument matchers matching handling non-matcher arguments fails for a hash w/ wrong values",  "expected RSpec::Mocks::MockExpectationError with message matching /expected: \\(\\{(:a=>\\\"b\\\", :c=>\\\"d\\"
  fails "argument matchers matching handling non-matcher arguments fails for a hash w/ wrong keys",  "expected RSpec::Mocks::MockExpectationError with message matching /expected: \\(\\{(:a=>\\\"b\\\", :c=>\\\"d\\"
  fails "argument matchers matching handling non-matcher arguments fails a class against an object of a different type",  "expected RSpec::Mocks::MockExpectationError but nothing was raised"
  fails "at_least fails if method is never called",  "expected /expected: at least 4 times.*received: 0 times/m, got #<RSpec::Mocks::MockExpectationError: "
  fails "at_least fails when called less than n times",  "expected /expected: at least 4 times.*received: 3 times/m, got #<RSpec::Mocks::MockExpectationError: "
  fails "at_least fails when at least once method is never called",  "expected /expected: at least 1 time.*received: 0 times/m, got #<RSpec::Mocks::MockExpectationError: ("
  fails "at_least fails when at least twice method is called once",  "expected /expected: at least 2 times.*received: 1 time/m, got #<RSpec::Mocks::MockExpectationError: ("
  fails "at_least fails when at least twice method is never called",  "expected /expected: at least 2 times.*received: 0 times/m, got #<RSpec::Mocks::MockExpectationError: "
  fails "at_least fails when at least thrice method is called less than three times",  "expected /expected: at least 3 times.*received: 2 times/m, got #<RSpec::Mocks::MockExpectationError: "
  fails "at_most fails fast when at_most(n) times method is called n plus 1 times",  "expected RSpec::Mocks::MockExpectationError with message matching /expected: at most 2 times.*receive"
  fails "at_most fails fast when at_most(n) times method is called n plus 1 time",  "expected RSpec::Mocks::MockExpectationError with message matching /expected: at most 1 time.*received"
  fails "at_most fails fast when at_most(:once) and is called twice",  "expected RSpec::Mocks::MockExpectationError with message matching /expected: at most 1 time.*received"
  fails "at_most fails fast when at_most(:twice) and is called three times",  "expected RSpec::Mocks::MockExpectationError with message matching /expected: at most 2 times.*receive"
  fails "at_most fails fast when at_most(:thrice) and is called four times",  "expected RSpec::Mocks::MockExpectationError with message matching /expected: at most 3 times.*receive"
  fails "Using rspec-mocks features in before(:all) blocks #stub_const raises an error with a useful message",  "expected nil to be a kind of RSpec::Mocks::OutsideOfExampleError"
  fails "Using rspec-mocks features in before(:all) blocks #stub_const does not stub the const",  "expected: falsey value"
  fails "Using rspec-mocks features in before(:all) blocks #hide_const(for an undefined const) raises an error with a useful message",  "expected nil to be a kind of RSpec::Mocks::OutsideOfExampleError"
  fails "Using rspec-mocks features in before(:all) blocks #hide_const(for a defined const) raises an error with a useful message",  "expected nil to be a kind of RSpec::Mocks::OutsideOfExampleError"
  fails "Using rspec-mocks features in before(:all) blocks allow(...).to receive_message_chain raises an error with a useful message",  "expected nil to be a kind of RSpec::Mocks::OutsideOfExampleError"
  fails "Using rspec-mocks features in before(:all) blocks #expect(...).to receive raises an error with a useful message",  "expected nil to be a kind of RSpec::Mocks::OutsideOfExampleError"
  fails "Using rspec-mocks features in before(:all) blocks #allow(...).to receive raises an error with a useful message",  "expected nil to be a kind of RSpec::Mocks::OutsideOfExampleError"
  fails "Using rspec-mocks features in before(:all) blocks #expect_any_instance_of(...).to receive raises an error with a useful message",  "expected nil to be a kind of RSpec::Mocks::OutsideOfExampleError"
  fails "Using rspec-mocks features in before(:all) blocks #allow_any_instance_of(...).to receive raises an error with a useful message",  "expected nil to be a kind of RSpec::Mocks::OutsideOfExampleError"
  fails "a double declaration with a block handed to: ordered returns the value of executing the block",  "Kernel received \"warn\" with unexpected arguments"
  fails "Combining implementation instructions warns when the inner implementation block is overridden",  "RSpec received \"warning\" with unexpected arguments"
  fails "RSpec::Mocks::Configuration configuring rspec-mocks directly behaves like configuring the syntax when configured to :should adds the should methods to every object",  "(BasicObject (class)).method_undefined(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring rspec-mocks directly behaves like configuring the syntax when configured to :should adds `any_instance` to every class",  "(BasicObject (class)).method_undefined(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring rspec-mocks directly behaves like configuring the syntax when configured to :should removes the expect methods from the example group context",  "expected #<RSpec::ExampleGroups::RSpecMocksConfiguration::ConfiguringRspecMocksDirectly::BehavesLikeC"
  fails "RSpec::Mocks::Configuration configuring rspec-mocks directly behaves like configuring the syntax when configured to :should reports that the syntax is :should",  "(BasicObject (class)).method_undefined(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring rspec-mocks directly behaves like configuring the syntax when configured to :should does not warn about the should syntax",  "(BasicObject (class)).method_undefined(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring rspec-mocks directly behaves like configuring the syntax when configured to :should is a no-op when configured a second time",  "(BasicObject (class)).method_undefined(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring rspec-mocks directly behaves like configuring the syntax when configured to [:should, :expect] adds the should methods to every object",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring rspec-mocks directly behaves like configuring the syntax when configured to [:should, :expect] adds `any_instance` to every class",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring rspec-mocks directly behaves like configuring the syntax when configured to [:should, :expect] adds the expect methods to the example group context",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring rspec-mocks directly behaves like configuring the syntax when configured to [:should, :expect] reports that both syntaxes are enabled",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring rspec-mocks directly behaves like configuring the syntax when configured to [:should, :expect] does not warn about the should syntax",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax defaults to enabling both the :should and :expect syntaxes",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax when configured to :expect removes the should methods from every object",  "expected #<Double (anonymous)> not to respond to \"stub\", \"should_not_receive\""
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax when configured to :expect removes `any_instance` from every class",  "expected #<Class:0x36d08> not to respond to \"any_instance\""
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax when configured to :should adds the should methods to every object",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax when configured to :should adds `any_instance` to every class",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax when configured to :should removes the expect methods from the example group context",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax when configured to :should reports that the syntax is :should",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax when configured to :should does not warn about the should syntax",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax when configured to :should is a no-op when configured a second time",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax when configured to [:should, :expect] adds the should methods to every object",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax when configured to [:should, :expect] adds `any_instance` to every class",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax when configured to [:should, :expect] adds the expect methods to the example group context",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax when configured to [:should, :expect] reports that both syntaxes are enabled",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Configuration configuring using the rspec-core config API behaves like configuring the syntax when configured to [:should, :expect] does not warn about the should syntax",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Diffs printed when arguments don't match with a non matcher object prints a diff of the strings for individual mismatched multi-line string arguments",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"double\\\"> received :foo with unexpected "
  fails "Diffs printed when arguments don't match with a non matcher object prints a diff of the args lists for multiple mismatched string arguments",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"double\\\"> received :foo with unexpected "
  fails "Diffs printed when arguments don't match with a non matcher object prints a diff with hash args",  "expected RSpec::Mocks::MockExpectationError with message matching /\\A#<Double \"double\"> received :foo"
  fails "Diffs printed when arguments don't match with a non matcher object prints a diff with an expected hash arg and a non-hash actual arg",  "expected RSpec::Mocks::MockExpectationError with message matching /-\\[\\{\"baz\"=>\"quz\",\\ \"foo\"=>\"bar\"\\}"
  fails "Diffs printed when arguments don't match with a non matcher object print a diff when keyword argument were expected but got an option hash (using splat)",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"double\\\"> received :foo with unexpected "
  fails "Diffs printed when arguments don't match with a non matcher object print a diff when keyword argument were expected but got an option hash (literal)",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"double\\\"> received :foo with unexpected "
  fails "Diffs printed when arguments don't match with a non matcher object prints a diff with array args",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"double\\\"> received :foo with unexpected "
  fails "Diffs printed when arguments don't match with a non matcher object that defines #description does not use the object's description for a non-matcher object that implements #description",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"double\\\"> received :foo with unexpected "
  fails "Diffs printed when arguments don't match with a matcher object that defines #description uses the object's description",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"double\\\"> received :foo with unexpected "
  fails "Diffs printed when arguments don't match with a matcher object that does not define #description for a matcher object that does not implement #description",  "(BasicObject (class)).method_added(\"inspect\")"
  fails "RSpec::Mocks::Double has method_missing as private",  "expected [] to include method \"method_missing\""
  fails "RSpec::Mocks::Double does not respond_to? method_missing (because it's private)",  "expected #<Double (anonymous)> not to respond to \"method_missing\""
  fails "RSpec::Mocks::Double uses 'Double' in failure messages",  "expected /#<Double \"name\"> received/, got #<RSpec::Mocks::MockExpectationError: (BasicObject (class))"
  fails "RSpec::Mocks::Double allows `class` to be stubbed even when `any_instance` has already been used",  "(BasicObject (class)).method_added(\"bar\")"
  fails "RSpec::Mocks::Double reports line number of expectation of unreceived message",  "expected \"rspec/support/caller_filter.rb:65:19:in `$$1'\" to match /double_spec.rb:78/"
  fails "RSpec::Mocks::Double reports line number of expectation of unreceived message after a message expectation after similar stub",  "expected \"rspec/support/caller_filter.rb:65:19:in `$$1'\" to match /double_spec.rb:89/"
  fails "RSpec::Mocks::Double raises exception if args don't match when method called",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"test double\\\"> received :something with "
  fails "RSpec::Mocks::Double raises exception if args don't match when method called even when the method is stubbed",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"test double\\\"> received :something with "
  fails "RSpec::Mocks::Double raises exception if args don't match when method called even when using null_object",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"test double\\\"> received :something with "
  fails "RSpec::Mocks::Double fails on no args if any args received",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"test double\\\"> received :something with "
  fails "RSpec::Mocks::Double fails when args are expected but none are received",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"test double\\\"> received :something with "
  fails "RSpec::Mocks::Double fails when calling yielding method with invalid kw args",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"test double\\\"> yielded |{:x=>1, :y=>2}| "
  fails "RSpec::Mocks::Double even when a similar expectation with different arguments exist raises exception if args don't match when method called, correctly reporting the offending arguments",  "expected RSpec::Mocks::MockExpectationError with \"#<Double \\\"test double\\\"> received :something with "
  fails "RSpec::Mocks::Double with a method that has a default argument raises an exception if the arguments don't match when the method is called, correctly reporting the offending arguments",  "expected RSpec::Mocks::MockExpectationError with a string starting with \"#<Double \\\"test double\\\"> re"
  fails "RSpec::Mocks::Double double created with no name does not use a name in a failure message",  "expected Exception with a string including \"#<Double (anonymous)> received\", got #<RSpec::Mocks::Mock"
  fails "RSpec::Mocks::Double with with a block with non-matching args fails",  "expected /received :foo with unexpected arguments/, got #<RSpec::Mocks::MockExpectationError: #<Doubl"
  fails "RSpec::Mocks::ErrorGenerator formatting arguments formats time objects with increased precision",  "expected RSpec::Mocks::MockExpectationError with a string including \"1969-12-31 19:01:40.000101\", got"
  fails "After a test double has been torn down for a class_double disallows previously mocked methods",  "undefined method `__disallow_further_usage!' for #<Module:0x3dbee>"
  fails "After a test double has been torn down for a class_double disallows previously stubbed methods",  "undefined method `__disallow_further_usage!' for #<Module:0x3dcc8>"
  fails "After a test double has been torn down for a class_double disallows stubbing new methods (with receive)",  "undefined method `__disallow_further_usage!' for #<Module:0x3dda2>"
  fails "After a test double has been torn down for a class_double disallows stubbing new methods (with receive_messages)",  "undefined method `__disallow_further_usage!' for #<Module:0x3de7c>"
  fails "After a test double has been torn down for a class_double disallows stubbing new message chains",  "undefined method `__disallow_further_usage!' for #<Module:0x3df56>"
  fails "After a test double has been torn down for a class_double disallows mocking new methods",  "undefined method `__disallow_further_usage!' for #<Module:0x3e030>"
  fails "After a test double has been torn down for a class_double disallows being turned into a null object",  "undefined method `__disallow_further_usage!' for #<Module:0x3e10a>"
  fails "After a test double has been torn down for a class_double disallows being checked for nullness",  "undefined method `__disallow_further_usage!' for #<Module:0x3e1e4>"
  fails "Failure notification includes the line of future expectation in the notification for an unreceived message",  "expected \"rspec/support/caller_filter.rb:65:19:in `$$1'\" to match /failure_notification_spec.rb:18/"
  fails "Failure notification when using `aggregate_failures` spy failures for unreceived messages are reported correctly",  "expected RSpec::Expectations::ExpectationNotMetError, got #<RSpec::Mocks::MockExpectationError: (Basi"
  fails "Failure notification when using `aggregate_failures` spy failures for messages received with unexpected args are reported correctly",  "expected RSpec::Expectations::ExpectationNotMetError, got #<NoMethodError: undefined method `aggregat"
  fails "Failure notification when using `aggregate_failures` failing negative expectations are only notified once",  "expected RSpec::Expectations::MultipleExpectationsNotMetError, got #<NoMethodError: undefined method "
  fails "Test doubles format well in failure messages `double` avoids sending `instance_variable_get` to the double as it may be stubbed",  "expected #<Double \"Book\"> to format in failures as \"#<Double \\\"Book\\\">\""
  fails "Test doubles format well in failure messages `double` with a name #<Double \"Name\">",  "expected #<Double \"Book\"> to format in failures as \"#<Double \\\"Book\\\">\""
  fails "Test doubles format well in failure messages `double` with a name formats the name as a symbol if that was how it was provided",  "expected #<Double \"book\"> to format in failures as \"#<Double :book>\""
  fails "Test doubles format well in failure messages `double` without a name #<Double (anonymous)>",  "expected #<Double (anonymous)> to format in failures as \"#<Double (anonymous)>\""
  fails "Test doubles format well in failure messages `instance_double(SomeClass)` avoids sending `instance_variable_get` to the double as it may be stubbed",  "expected #<InstanceDouble(LoadedClass) \"Book\"> to format in failures as \"#<InstanceDouble(LoadedClass"
  fails "Test doubles format well in failure messages `instance_double(SomeClass)` with a name #<InstanceDouble(SomeClass) \"Name\">",  "expected #<InstanceDouble(LoadedClass) \"Book\"> to format in failures as \"#<InstanceDouble(LoadedClass"
  fails "Test doubles format well in failure messages `instance_double(SomeClass)` without a name #<InstanceDouble(SomeClass) (anonymous)>",  "expected #<InstanceDouble(LoadedClass) (anonymous)> to format in failures as \"#<InstanceDouble(Loaded"
  fails "Test doubles format well in failure messages `class_double(SomeClass)` with a name #<ClassDouble(SomeClass) \"Name\">",  "expected #<ClassDouble(LoadedClass) \"constructor\"> to format in failures as \"#<ClassDouble(LoadedClas"
  fails "Test doubles format well in failure messages `class_double(SomeClass)` without a name #<ClassDouble(SomeClass) (anonymous)>",  "expected #<ClassDouble(LoadedClass) \"constructor\"> to format in failures as \"#<ClassDouble(LoadedClas"
  fails "Test doubles format well in failure messages `object_double([])` with a name #<ObjectDouble([]) \"Name\">",  "expected #<ObjectDouble([]) \"Name\"> to format in failures as \"#<ObjectDouble([]) \\\"Name\\\">\""
  fails "Test doubles format well in failure messages `object_double([])` without a name #<ObjectDouble([]) (anonymous)>",  "expected #<ObjectDouble([]) (anonymous)> to format in failures as \"#<ObjectDouble([]) (anonymous)>\""
  fails "RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher describes itself properly",  "expected: \"hash_not_including(:a=>5)\""
  fails "RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher describes itself properly",  "expected: \"hash_including(:a=>1)\""
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received forwards any block passed during method invocation to the `have_received` block",  "The message 'foo' was received by #<RSpec::Mocks::Double:264142 @__expired=false, @name=> but has alr"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received generates a useful description",  "expected: \"have received expected_method(:expected_args) 1 time\""
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received can generate a description after mocks have been torn down (e.g. when rspec-core requests it)",  "expected: \"have received expected_method(:expected_args) 1 time\""
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received produces an error message that matches the expected method if another method was called",  "The message 'foo' was received by #<RSpec::Mocks::Double:264646 @__expired=false, @name=> but has alr"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts when constrained by `with` when the message is received without any args matching includes unmatched args in the error message",  "expected RSpec::Expectations::ExpectationNotMetError with a string including \"expected: (:three)\", \"g"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts when constrained by `with` when constrained with grouped arguments `with` groups the \"got\" arguments based on the method call that included them",  "expected RSpec::Expectations::ExpectationNotMetError with a string including \"expected: (:four, :four"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts when constrained by `with` when constrained with grouped arguments `with` includes single arguments based on the method call that included them",  "expected RSpec::Expectations::ExpectationNotMetError with a string including \"expected: (:three, :fou"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts when constrained by `with` when constrained with grouped arguments `with` keeps the array combinations distinguished in the group",  "expected RSpec::Expectations::ExpectationNotMetError with a string including \"expected: (:one, :four)"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts when constrained by `with` when constrained with grouped arguments `with` does not group counts on repeated arguments for a single message",  "expected RSpec::Expectations::ExpectationNotMetError with a string including \"expected: (:one, :two, "
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts exactly fails when the message was received more times than expected",  "expected /expected: 1 time.*received: 3 times/m, got #<RSpec::Expectations::ExpectationNotMetError: ("
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts exactly fails when the message was received fewer times",  "expected /expected: 4 times.*received: 3 times/m, got #<RSpec::Expectations::ExpectationNotMetError: "
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts at_least fails when the message was received fewer times",  "expected /expected: at least 4 times.*received: 3 times/m, got #<RSpec::Expectations::ExpectationNotM"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts at_most fails when the message was received more times",  "expected /expected: at most 2 times.*received: 3 times/m, got #<RSpec::Expectations::ExpectationNotMe"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts once fails when the message was never received",  "expected /expected: 1 time.*received: 0 times/m, got #<RSpec::Expectations::ExpectationNotMetError: ("
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts once fails when the message was received twice",  "expected /expected: 1 time.*received: 2 times/m, got #<RSpec::Expectations::ExpectationNotMetError: ("
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts twice fails when the message was received once",  "expected /expected: 2 times.*received: 1 time/m, got #<RSpec::Expectations::ExpectationNotMetError: ("
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts twice fails when the message was received thrice",  "expected /expected: 2 times.*received: 3 times/m, got #<RSpec::Expectations::ExpectationNotMetError: "
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts thrice fails when the message was received less than three times",  "expected /expected: 3 times.*received: 2 times/m, got #<RSpec::Expectations::ExpectationNotMetError: "
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts thrice fails when the message was received more than three times",  "expected /expected: 3 times.*received: 4 times/m, got #<RSpec::Expectations::ExpectationNotMetError: "
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).not_to have_received fails when the double has received the given message",  "expected /expected: 0 times.*received: 1 time/m, got #<RSpec::Mocks::MockExpectationError: (Double \"d"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).not_to have_received notifies failures via rspec-support's failure notification system",  "expected \"(Double \\\"double\\\").expected_method(*(any args))\\n    expected: 0 times with any arguments\\"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).not_to have_received with fails when the given args match the args used with the message",  "expected /expected: 0 times.*received: 1 time/m, got #<RSpec::Mocks::MockExpectationError: (Double \"d"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received forwards any block passed during method invocation to the `have_received` block",  "The message 'foo' was received by #<RSpec::Mocks::Double:276222 @__expired=false, @name=> but has alr"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received generates a useful description",  "expected: \"have received expected_method(:expected_args) 1 time\""
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received can generate a description after mocks have been torn down (e.g. when rspec-core requests it)",  "expected: \"have received expected_method(:expected_args) 1 time\""
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received produces an error message that matches the expected method if another method was called",  "The message 'foo' was received by #<RSpec::Mocks::Double:276730 @__expired=false, @name=> but has alr"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts when constrained by `with` when the message is received without any args matching includes unmatched args in the error message",  "expected RSpec::Mocks::MockExpectationError with a string including \"expected: (:three)\", \"got:\", \"(:"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts when constrained by `with` when constrained with grouped arguments `with` groups the \"got\" arguments based on the method call that included them",  "expected RSpec::Mocks::MockExpectationError with a string including \"expected: (:four, :four)\", \"got:"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts when constrained by `with` when constrained with grouped arguments `with` includes single arguments based on the method call that included them",  "expected RSpec::Mocks::MockExpectationError with a string including \"expected: (:three, :four)\" and \""
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts when constrained by `with` when constrained with grouped arguments `with` keeps the array combinations distinguished in the group",  "expected RSpec::Mocks::MockExpectationError with a string including \"expected: (:one, :four)\", \"got:\""
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts when constrained by `with` when constrained with grouped arguments `with` does not group counts on repeated arguments for a single message",  "expected RSpec::Mocks::MockExpectationError with a string including \"expected: (:one, :two, :three)\","
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts exactly fails when the message was received more times than expected",  "expected /expected: 1 time.*received: 3 times/m, got #<RSpec::Mocks::MockExpectationError: (Double (a"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts exactly fails when the message was received fewer times",  "expected /expected: 4 times.*received: 3 times/m, got #<RSpec::Mocks::MockExpectationError: (Double ("
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts at_least fails when the message was received fewer times",  "expected /expected: at least 4 times.*received: 3 times/m, got #<RSpec::Mocks::MockExpectationError: "
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts at_most fails when the message was received more times",  "expected /expected: at most 2 times.*received: 3 times/m, got #<RSpec::Mocks::MockExpectationError: ("
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts once fails when the message was never received",  "expected /expected: 1 time.*received: 0 times/m, got #<RSpec::Mocks::MockExpectationError: (Double (a"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts once fails when the message was received twice",  "expected /expected: 1 time.*received: 2 times/m, got #<RSpec::Mocks::MockExpectationError: (Double (a"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts twice fails when the message was received once",  "expected /expected: 2 times.*received: 1 time/m, got #<RSpec::Mocks::MockExpectationError: (Double (a"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts twice fails when the message was received thrice",  "expected /expected: 2 times.*received: 3 times/m, got #<RSpec::Mocks::MockExpectationError: (Double ("
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts thrice fails when the message was received less than three times",  "expected /expected: 3 times.*received: 2 times/m, got #<RSpec::Mocks::MockExpectationError: (Double ("
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).to have_received counts thrice fails when the message was received more than three times",  "expected /expected: 3 times.*received: 4 times/m, got #<RSpec::Mocks::MockExpectationError: (Double ("
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).not_to have_received fails when the double has received the given message",  "expected /expected: 0 times.*received: 1 time/m, got #<RSpec::Mocks::MockExpectationError: (Double \"d"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).not_to have_received notifies failures via rspec-support's failure notification system",  "expected \"(Double \\\"double\\\").expected_method(*(any args))\\n    expected: 0 times with any arguments\\"
  fails "RSpec::Mocks::Matchers::HaveReceived expect(...).not_to have_received with fails when the given args match the args used with the message",  "expected /expected: 0 times.*received: 1 time/m, got #<RSpec::Mocks::MockExpectationError: (Double \"d"
  fails "receive_message_chain with only the expect syntax enabled works with allow_any_instance",  "(BasicObject (class)).method_added(\"to_a\")"
  fails "receive_message_chain with only the expect syntax enabled stubs already stubbed instances when using `allow_any_instance_of`",  "(BasicObject (class)).method_added(\"__foo_without_any_instance__\")"
  fails "receive_message_chain with only the expect syntax enabled affects previously stubbed instances when `expect_any_instance_of` is called",  "(BasicObject (class)).method_added(\"foo\")"
  fails "receive_message_chain with only the expect syntax enabled passes when with expect_any_instance_of is used and the entire chain is called",  "(BasicObject (class)).method_added(\"to_a\")"
  fails "receive_message_chain when the expect and should syntaxes are enabled stubs the message correctly",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "allow(...).to receive_messages(:a => 1, :b => 2) behaves like handles partially mocked objects correctly resets partially mocked objects correctly",  "(BasicObject (class)).method_added(\"a\")"
  fails "allow_any_instance_of(...).to receive_messages(:a => 1, :b => 2) allows the object to respond to multiple messages",  "(BasicObject (class)).method_added(\"a\")"
  fails "allow_any_instance_of(...).to receive_messages(:a => 1, :b => 2) updates stubs on instances with existing stubs",  "(BasicObject (class)).method_added(\"a\")"
  fails "expect(...).to receive_messages(:a => 1, :b => 2) fails with the correct location",  "expected \"rspec/support/caller_filter.rb:65:19:in `$$1'\" to match /\\/home\\/user\\/Code\\/opal\\/opal-rsp"
  fails "expect(...).to receive_messages(:a => 1, :b => 2) behaves like handles partially mocked objects correctly resets partially mocked objects correctly",  "(BasicObject (class)).method_added(\"a\")"
  fails "expect_any_instance_of(...).to receive_messages(:a => 1, :b => 2) sets up multiple expectations",  "(BasicObject (class)).method_added(\"a\")"
  fails "RSpec::Mocks::Matchers::Receive expectations/allowances on any instance recorders warns about allow(Klass.any_instance).to receive...",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Matchers::Receive expectations/allowances on any instance recorders includes the correct call site in the allow warning",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Matchers::Receive expectations/allowances on any instance recorders warns about expect(Klass.any_instance).to receive...",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Matchers::Receive expectations/allowances on any instance recorders includes the correct call site in the expect warning",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Matchers::Receive allow(...).to receive behaves like an expect syntax allowance behaves like a receive matcher allows the caller to constrain the received arguments",  "expected /received :foo with unexpected arguments/, got #<RSpec::Mocks::MockExpectationError: #<Doubl"
  fails "RSpec::Mocks::Matchers::Receive allow(...).to receive behaves like an expect syntax allowance behaves like a receive matcher allows the caller to constrain the received arguments by matcher",  "expected /expected.*\\(an instance of Float\\)/ but nothing was raised"
  fails "RSpec::Mocks::Matchers::Receive allow(...).to receive behaves like resets partial mocks cleanly removes the method double",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow(...).to receive behaves like resets partial mocks cleanly on a frozen object warns about being unable to remove the method double",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow(...).to receive behaves like resets partial mocks cleanly on a frozen object includes the spec location in the warning",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow(...).to receive ordered with receive counts is not supported",  "Kernel received \"warn\" with unexpected arguments"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance does not expect the message to be received",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher allows the caller to configure how the subject responds",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher allows the caller to constrain the received arguments",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher allows the caller to constrain the received arguments by matcher",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher allows chaining off a `do...end` block implementation to be provided",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher allows a `{ ... }` block implementation to be provided",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher gives precedence to a `{ ... }` block when both forms are provided since that form actually binds to `receive`",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher does support inherited matchers",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher does not get confused by messages being passed as strings and symbols",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher allows do...end blocks to be passed to the fluent interface methods without getting a warning",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher makes { } blocks trump do...end blocks when passed to a fluent interface method",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher without yielding receiver allows a `do...end` block implementation to be provided",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher without yielding receiver allows a `do...end` block implementation with keyword args to be provided",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher without yielding receiver allows a `do...end` block implementation with optional keyword args to be provided",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher without yielding receiver allows a `do...end` block implementation with optional keyword args to be provided",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like an expect syntax allowance behaves like a receive matcher without yielding receiver allows a `do...end` block implementation with required keyword args",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive allow_any_instance_of(...).to receive behaves like resets partial mocks of any instance cleanly removes the method double",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect(...).to receive behaves like an expect syntax expectation reports the line number of expectation of unreceived message",  "expected \"rspec/support/caller_filter.rb:65:19:in `$$1'\" to match /receive_spec.rb:216/"
  fails "RSpec::Mocks::Matchers::Receive expect(...).to receive behaves like an expect syntax expectation behaves like a receive matcher allows the caller to constrain the received arguments",  "expected /received :foo with unexpected arguments/, got #<RSpec::Mocks::MockExpectationError: #<Doubl"
  fails "RSpec::Mocks::Matchers::Receive expect(...).to receive behaves like an expect syntax expectation behaves like a receive matcher allows the caller to constrain the received arguments by matcher",  "expected /expected.*\\(an instance of Float\\)/ but nothing was raised"
  fails "RSpec::Mocks::Matchers::Receive expect(...).to receive behaves like an expect syntax expectation when a message is received the wrong number of times sets up a message expectation that formats argument matchers correctly",  "expected /received: 2 times with arguments: \\(anything, hash_including\\(:bar=>\"anything\"\\)\\)$/, got #"
  fails "RSpec::Mocks::Matchers::Receive expect(...).to receive behaves like resets partial mocks cleanly removes the method double",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect(...).to receive behaves like resets partial mocks cleanly on a frozen object warns about being unable to remove the method double",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect(...).to receive behaves like resets partial mocks cleanly on a frozen object includes the spec location in the warning",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect(...).to receive ordered with receive counts does not result in infinite recursion when `respond_to?` is stubbed",  "expected /received :respond_to\\? with unexpected arguments/, got #<RSpec::Mocks::MockExpectationError"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation sets up a message expectation that passes if the message is received",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation sets up a message expectation that fails if the message is not received",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation provides a useful matcher description",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation sets up a message expectation that formats argument matchers correctly",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher allows the caller to configure how the subject responds",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher allows the caller to constrain the received arguments",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher allows the caller to constrain the received arguments by matcher",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher allows chaining off a `do...end` block implementation to be provided",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher allows a `{ ... }` block implementation to be provided",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher gives precedence to a `{ ... }` block when both forms are provided since that form actually binds to `receive`",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher does support inherited matchers",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher does not get confused by messages being passed as strings and symbols",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher allows do...end blocks to be passed to the fluent interface methods without getting a warning",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher makes { } blocks trump do...end blocks when passed to a fluent interface method",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher without yielding receiver allows a `do...end` block implementation to be provided",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher without yielding receiver allows a `do...end` block implementation with keyword args to be provided",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher without yielding receiver allows a `do...end` block implementation with optional keyword args to be provided",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher without yielding receiver allows a `do...end` block implementation with optional keyword args to be provided",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like an expect syntax expectation behaves like a receive matcher without yielding receiver allows a `do...end` block implementation with required keyword args",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).to receive behaves like resets partial mocks of any instance cleanly removes the method double",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect(...).not_to receive behaves like an expect syntax negative expectation sets up a negative message expectation that fails if the message is received",  "expected RSpec::Mocks::MockExpectationError with message matching /expected: 0 times.*received: 1 tim"
  fails "RSpec::Mocks::Matchers::Receive expect(...).not_to receive behaves like an expect syntax negative expectation supports `to_not` as an alias for `not_to`",  "expected RSpec::Mocks::MockExpectationError with message matching /expected: 0 times.*received: 1 tim"
  fails "RSpec::Mocks::Matchers::Receive expect(...).not_to receive behaves like an expect syntax negative expectation allows the caller to constrain the received arguments",  "expected RSpec::Mocks::MockExpectationError with message matching /expected: 0 times.*received: 1 tim"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).not_to receive behaves like an expect syntax negative expectation sets up a negative message expectation that passes if the message is not received",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).not_to receive behaves like an expect syntax negative expectation sets up a negative message expectation that fails if the message is received",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).not_to receive behaves like an expect syntax negative expectation supports `to_not` as an alias for `not_to`",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).not_to receive behaves like an expect syntax negative expectation allows the caller to constrain the received arguments",  "(BasicObject (class)).method_added(\"foo\")"
  fails "RSpec::Mocks::Matchers::Receive expect_any_instance_of(...).not_to receive behaves like an expect syntax negative expectation prevents confusing double-negative expressions involving `never`",  "expected /trying to negate it again/, got #<RSpec::Mocks::MockExpectationError: (BasicObject (class))"
  fails "RSpec::Mocks::Matchers::Receive when used in a test framework without rspec-expectations cannot use `expect` with another matcher",  "expected /only the `receive`, `have_received` and `receive_messages` matchers are supported with `exp"
  fails "RSpec::Mocks::Matchers::Receive when used in a test framework without rspec-expectations can toggle the available syntax",  "(BasicObject (class)).method_added(\"eq\")"
  fails "RSpec::Mocks::Matchers::Receive when used in a test framework without rspec-expectations behaves like using rspec-mocks in another test framework can use the `expect` syntax",  "(BasicObject (class)).method_added(\"eq\")"
  fails "RSpec::Mocks::Matchers::Receive when used in a test framework without rspec-expectations behaves like using rspec-mocks in another test framework expects the method to be called when `expect` is used",  "(BasicObject (class)).method_added(\"eq\")"
  fails "RSpec::Mocks::MessageExpectation for a raw message expectation on a partial double",  "Cannot proxy frozen objects. Symbols such as partial double cannot be mocked or stubbed."
  fails "RSpec::Mocks::MessageExpectation for a message expectation constrained by `with`",  "Maximum call stack size exceeded"
  fails "Methods added to every object limits the number of methods that get added to all objects",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "an expectation set on nil issues a warning with file and line number information",  "(BasicObject (class)).method_added(\"foo\")"
  fails "an expectation set on nil issues a warning when the expectation is negative",  "(BasicObject (class)).method_undefined(\"foo\")"
  fails "an expectation set on nil does not issue a warning when expectations are set to be allowed",  "(BasicObject (class)).method_added(\"foo\")"
  fails "an expectation set on nil configured to allow expectation on nil does not issue a warning when expectations are set to be allowed",  "(BasicObject (class)).method_undefined(\"foo\")"
  fails "#allow_message_expectations_on_nil does not affect subsequent examples",  "(BasicObject (class)).method_added(\"foo\")"
  fails "a double _not_ acting as a null object says it does not respond to messages it doesn't understand",  "expected #<Double \"non-null object\"> not to respond to \"foo\""
  fails "a double acting as a null object continues to return self from an explicit expectation",  "The message 'foo' was received by #<RSpec::Mocks::Double:343818 @__expired=false, @name=null object> "
  fails "a double acting as a null object allows unexpected message sends using `send`",  "The message 'foo' was received by #<RSpec::Mocks::Double:344286 @__expired=false, @name=null object> "
  fails "a double acting as a null object allows unexpected message sends using `__send__`",  "The message 'foo' was received by #<RSpec::Mocks::Double:344360 @__expired=false, @name=null object> "
  fails "a double acting as a null object does not allow null objects to be used outside of examples",  "expected RSpec::Mocks::OutsideOfExampleError, got #<RSpec::Mocks::ExpiredTestDoubleError: #<Double \"n"
  fails "when using the :expect syntax still supports null object doubles",  "The message 'foo' was received by #<RSpec::Mocks::Double:345248 @__expired=false, @name=foo> but has "
  fails "A partial double allows `class` to be stubbed even when `any_instance` has already been used",  "(BasicObject (class)).method_added(\"__bar_without_any_instance__\")"
  fails "A partial double allows `respond_to?` to be stubbed",  "(BasicObject (class)).method_added(\"call\")"
  fails "A partial double uses reports nil in the error message",  "(BasicObject (class)).method_added(\"foobar\")"
  fails "Using a reopened file object as a partial mock allows `write` to be stubbed and reset",  "undefined method `reopen' for #<File:0x5545e @binary_flag=false @path=\"tmp/file_1\" @lineno=0 @fd=21 @"
  fails "Using a partial mock on a proxy object works properly",  "(BasicObject (class)).method_added(\"initialize\")"
  fails "Using a partial mock on a proxy object does not confuse the proxy and the proxied object",  "(BasicObject (class)).method_added(\"initialize\")"
  fails "Partially mocking an object that defines ==, after another mock has been defined does not raise an error when stubbing the object",  "(BasicObject (class)).method_added(\"val\")"
  fails "Method visibility when using partial mocks keeps public methods public",  "(BasicObject (class)).method_added(\"public_method\")"
  fails "Method visibility when using partial mocks keeps private methods private",  "(BasicObject (class)).method_added(\"public_method\")"
  fails "Method visibility when using partial mocks keeps protected methods protected",  "(BasicObject (class)).method_added(\"public_method\")"
  fails "when verify_partial_doubles configuration option is set allows valid methods to be expected",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set allows private methods to be expected",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set can be temporarily supressed",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set can be temporarily supressed and nested",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set temporarily supressing partial doubles does not affect normal verifying doubles",  "expected RSpec::Mocks::MockExpectationError, got #<NotImplementedError: String#<< not supported. Muta"
  fails "when verify_partial_doubles configuration option is set runs the before_verifying_double callbacks before verifying an expectation",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set runs the before_verifying_double callbacks before verifying an allowance",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set avoids deadlocks when a proxy is accessed from within a `before_verifying_doubles` callback",  "(BasicObject (class)).method_added(\"message\")"
  fails "when verify_partial_doubles configuration option is set does not allow a spy on unimplemented method",  "expected RSpec::Mocks::MockExpectationError with message matching /does not implement/, got #<RSpec::"
  fails "when verify_partial_doubles configuration option is set verifies arity range when matching arguments",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set allows a method defined with method_missing to be expected",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set allows valid methods to be expected on any_instance",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set allows private methods to be expected on any_instance expectation",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set runs the before_verifying_double callbacks on any_instance before verifying a double allowance",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set runs the before_verifying_double callbacks on any_instance before verifying a double",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set does not allow a non-existing method to be called on any_instance",  "expected RSpec::Mocks::MockExpectationError with message matching /does not implement/, got #<RSpec::"
  fails "when verify_partial_doubles configuration option is set does not allow missing methods to be called on any_instance",  "expected RSpec::Mocks::MockExpectationError with message matching /does not implement/, got #<RSpec::"
  fails "when verify_partial_doubles configuration option is set verifies arity range when receiving a message",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set allows the mock to raise an error with yield",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set allows stubbing and calls the stubbed implementation",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set for a class only runs the `before_verifying_doubles` callback for the class (not for superclasses)",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set for a class can be temporarily supressed",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set when `.new` is stubbed uses the method signature from `#initialize` for arg verification",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set when `.new` is stubbed on a class that has redefined `new` uses the method signature of the redefined `new` for arg verification",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set when `.new` is stubbed on a class that has undefined `new` prevents it from being stubbed",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set when `.new` is stubbed on a class with a private `new` uses the method signature from `#initialize` for arg verification",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set when `.new` is stubbed on a class with a twice-aliased `new` uses the method signature from `#initialize` for arg verification",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "when verify_partial_doubles configuration option is set when `.new` is stubbed on a class that has redefined `self.method` allows the stubbing of :new",  "(BasicObject (class)).method_added(\"implemented\")"
  fails "PartialDoubleUsingMocksDirectly fails when expected message is not received",  "(BasicObject (class)).method_added(\"existing_method\")"
  fails "PartialDoubleUsingMocksDirectly fails when message is received with incorrect args",  "(BasicObject (class)).method_added(\"existing_method\")"
  fails "PartialDoubleUsingMocksDirectly passes when expected message is received",  "(BasicObject (class)).method_added(\"existing_method\")"
  fails "PartialDoubleUsingMocksDirectly passes when message is received with correct args",  "(BasicObject (class)).method_added(\"existing_method\")"
  fails "PartialDoubleUsingMocksDirectly restores the original method if it existed",  "(BasicObject (class)).method_added(\"existing_method\")"
  fails "PartialDoubleUsingMocksDirectly with an instance method handled by method_missing restores the original behavior",  "(BasicObject (class)).method_added(\"existing_method\")"
  fails "PartialDoubleUsingMocksDirectly with a class method handled by method_missing restores the original behavior",  "(BasicObject (class)).method_added(\"existing_method\")"
  fails "Using the legacy should syntax #received_message? answers false for received_message? when no messages received",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #received_message? answers true for received_message? when message received",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #received_message? answers true for received_message? when message received with correct args",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #received_message? answers false for received_message? when message received with incorrect args",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #stub supports options",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #stub returns `nil` from all terminal actions to discourage further configuration",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #stub sets up a canned response",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #stub can stub multiple messages using a hash",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #stub raises an error with a useful message",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #stub_chain can stub a sequence of messages",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #stub_chain raises an error with a useful message",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #unstub raises an error with a useful message",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #unstub replaces the stubbed method with the original method",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #unstub removes all stubs with the supplied method name",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #unstub does not remove any expectations with the same method name",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #unstub restores the correct implementations when stubbed and unstubbed on a parent and child class",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #unstub raises a MockExpectationError if the method has not been stubbed",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #should_receive fails on verification if the message is not received",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #should_receive does not fail on verification if the message is received",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #should_receive can set a canned response",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #should_receive raises an error with a useful message",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #should_receive with an options hash reports the file and line submitted with :expected_from",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #should_receive with an options hash uses the message supplied with :message",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #should_receive with an options hash uses the message supplied with :message after a similar stub",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #should_not_receive returns a negative message expectation",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #should_not_receive fails when the message is received",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #should_not_receive does not fail on verification if the message is not received",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #should_not_receive raises an error with a useful message",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance raises an error with a useful message",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance adds a class to the current space",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance can stub a method",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance can mock a method",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance can get method objects for the fluent interface",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance affects previously stubbed instances when stubbing a method",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance affects previously stubbed instances when mocking a method",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #stub raises an error if 'stub' follows 'with'",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #stub raises an error if 'with' follows 'and_return'",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #stub raises an error if 'with' follows 'and_raise'",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #stub raises an error if 'with' follows 'and_yield'",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #stub behaves as 'every instance' handles `unstub` on subclasses",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #stub_chain raises an error if 'stub_chain' follows 'and_return'",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #stub_chain affects previously stubbed instances",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #stub_chain allows a chain of methods to be stubbed using #stub_chain given symbols representing the methods",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #stub_chain allows a chain of methods to be stubbed using #stub_chain given a hash as the last argument uses the value as the expected return value",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #stub_chain allows a chain of methods to be stubbed using #stub_chain given a string of '.' separated method names representing the chain",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #should_receive raises an error if 'should_receive' follows 'with'",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #should_not_receive fails if the method is called",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #should_not_receive passes if no method is called",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #should_not_receive passes if only a different method is called",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #should_not_receive prevents confusing double-negative expressions involving `never`",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #should_not_receive with constraints fails if the method is called with the specified parameters",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #should_not_receive with constraints passes if the method is called with different parameters",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #should_not_receive when used in combination with should_receive passes if only the expected message is received",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #unstub replaces the stubbed method with the original method",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #unstub removes all stubs with the supplied method name",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #unstub removes stubs even if they have already been invoked",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #unstub removes stubs from sub class after invokation when super class was originally stubbed",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #unstub removes stubs set directly on an instance",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #unstub does not remove message expectations set directly on an instance",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #unstub does not remove any expectations with the same method name",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #unstub raises a MockExpectationError if the method has not been stubbed",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "Using the legacy should syntax #any_instance invocation order #unstub does not get confused about string vs symbol usage for the message",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "with default syntax configuration it warns about should once, regardless of how many times it is called",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "with default syntax configuration includes the call site in the deprecation warning",  "#<RSpec::Core::Reporter:0x9c2 @configuration=#<RSpec::Core::Configuration:0x934 @start_time=2023-06-1"
  fails "when the should syntax is enabled on a non-default syntax host continues to warn about the should syntax",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::Space can be diffed in a failure when it has references to an error generator via a proxy",  "Cannot proxy frozen objects. Symbols such as  cannot be mocked or stubbed."
  fails "RSpec::Mocks::Space raises ArgumentError with message if object is frozen",  "expected ArgumentError with \"Cannot proxy frozen objects, rspec-mocks relies on proxies for method st"
  fails "RSpec::Mocks::Space#proxies_of(klass) returns proxies",  "Cannot proxy frozen objects. Symbols such as  cannot be mocked or stubbed."
  fails "RSpec::Mocks::Space#any_instance_recorder_for returns the recorder for the given class",  "expected not #<RSpec::Mocks::AnyInstance::Recorder:367240> => #<RSpec::Mocks::AnyInstance::Recorder:0"
  fails "the spy family of methods spy records called methods",  "The message 'foo' was received by #<RSpec::Mocks::Double:370686 @__expired=false, @name=> but has alr"
  fails "the spy family of methods instance_spy when passing a class object takes a class and a hash of method names and return values",  "(BasicObject (class)).method_added(\"foo\")"
  fails "the spy family of methods instance_spy when passing a class object behaves like a verifying spy with a foo method responds to methods on the verified object",  "(BasicObject (class)).method_added(\"foo\")"
  fails "the spy family of methods instance_spy when passing a class object behaves like a verifying spy with a foo method does not respond to methods that are not on the verified object",  "(BasicObject (class)).method_added(\"foo\")"
  fails "the spy family of methods instance_spy when passing a class object behaves like a verifying spy with a foo method records called methods",  "(BasicObject (class)).method_added(\"foo\")"
  fails "the spy family of methods instance_spy when passing a class object behaves like a verifying spy with a foo method fails fast when `have_received` is passed an undefined method name",  "expected RSpec::Mocks::MockExpectationError with a string including \"does not implement\", got #<RSpec"
  fails "the spy family of methods instance_spy when passing a class object behaves like a verifying spy with a foo method fails fast when negative `have_received` is passed an undefined method name",  "expected RSpec::Mocks::MockExpectationError with a string including \"does not implement\", got #<RSpec"
  fails "the spy family of methods instance_spy passing a class by string reference behaves like a verifying spy with a foo method records called methods",  "The message 'foo' was received by #<RSpec::Mocks::InstanceVerifyingDouble:372220 @doubled_module=#<RS"
  fails "the spy family of methods instance_spy passing a class by string reference behaves like a verifying spy with a foo method fails fast when `have_received` is passed an undefined method name",  "expected RSpec::Mocks::MockExpectationError with a string including \"does not implement\", got #<RSpec"
  fails "the spy family of methods instance_spy passing a class by string reference behaves like a verifying spy with a foo method fails fast when negative `have_received` is passed an undefined method name",  "expected RSpec::Mocks::MockExpectationError with a string including \"does not implement\" but nothing "
  fails "the spy family of methods object_spy takes an instance and a hash of method names and return values",  "(BasicObject (class)).method_added(\"foo\")"
  fails "the spy family of methods object_spy behaves like a verifying spy with a foo method responds to methods on the verified object",  "(BasicObject (class)).method_added(\"foo\")"
  fails "the spy family of methods object_spy behaves like a verifying spy with a foo method does not respond to methods that are not on the verified object",  "(BasicObject (class)).method_added(\"foo\")"
  fails "the spy family of methods object_spy behaves like a verifying spy with a foo method records called methods",  "(BasicObject (class)).method_added(\"foo\")"
  fails "the spy family of methods object_spy behaves like a verifying spy with a foo method fails fast when `have_received` is passed an undefined method name",  "expected RSpec::Mocks::MockExpectationError with a string including \"does not implement\", got #<RSpec"
  fails "the spy family of methods object_spy behaves like a verifying spy with a foo method fails fast when negative `have_received` is passed an undefined method name",  "expected RSpec::Mocks::MockExpectationError with a string including \"does not implement\", got #<RSpec"
  fails "the spy family of methods class_spy takes a class and a hash of method names and return values",  "undefined method `__disallow_further_usage!' for #<Module:0x5b398>"
  fails "the spy family of methods class_spy behaves like a verifying spy with a foo method records called methods",  "The message 'foo' was received by #<RSpec::Mocks::ClassVerifyingDouble:373960 @doubled_module=#<RSpec"
  fails "the spy family of methods class_spy behaves like a verifying spy with a foo method fails fast when `have_received` is passed an undefined method name",  "expected RSpec::Mocks::MockExpectationError with a string including \"does not implement\", got #<RSpec"
  fails "the spy family of methods class_spy behaves like a verifying spy with a foo method fails fast when negative `have_received` is passed an undefined method name",  "expected RSpec::Mocks::MockExpectationError with a string including \"does not implement\" but nothing "
  fails "A method stub instructs an instance to respond_to the message",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub instructs a class object to respond_to the message",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub ignores when expected message is received with no args",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub ignores when message is received with args",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub ignores when expected message is not received",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub handles multiple stubbed methods",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub is retained when stubbed object is `clone`d",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub is cleared when stubbed object when `dup`ed",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub remains private when it stubs a private instance method",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub remains private when it stubs a private class method",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub returns values in order to consecutive calls",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub keeps returning last value in consecutive calls",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub yields a specified object",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub yields multiple times with multiple calls to and_yield",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub yields a specified object and return another specified object",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub throws when told to",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub throws with argument when told to",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub overrides a pre-existing method",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub overrides a pre-existing stub",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub allows a stub and an expectation",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub using `and_return` returns declared value when message is received",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub using `with` determines which value is returned",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub using `with` allows differing arities",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub when the stubbed method is called does not call any methods on the passed args, since that could mutate them",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub stubbing with prepend handles stubbing prepended methods",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub stubbing with prepend handles stubbing prepended methods on a class's singleton class",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub stubbing with prepend handles stubbing prepended methods on an object's singleton class",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub stubbing with prepend does not unnecessarily prepend a module when the prepended module does not override the stubbed method",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub stubbing with prepend does not unnecessarily prepend a module when stubbing a method on a module extended onto itself",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub stubbing with prepend does not unnecessarily prepend a module when the module was included",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub stubbing with prepend reuses our prepend module so as not to keep mutating the ancestors",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub stubbing with prepend when multiple modules are prepended, only one of which overrides the stubbed method can still be stubbed and reset",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub stubbing with prepend when a module with a method override is prepended after reset can still be stubbed again",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset removes stubbed methods that didn't exist",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset restores existing instance methods",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset restores existing singleton methods with the appropriate context",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset restores existing private instance methods",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset restores existing class methods",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset restores existing aliased module_function methods",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset restores existing private class methods",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset does not remove existing methods that have been stubbed twice",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset correctly restores the visibility of methods whose visibility has been tweaked on the singleton class",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset correctly handles stubbing inherited mixed in class methods",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset with a prepended module (ruby 2.0.0+) restores prepended instance methods",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset with a prepended module (ruby 2.0.0+) restores non-prepended instance methods",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset with a prepended module (ruby 2.0.0+) restores prepended class methods",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub #rspec_reset with a prepended module (ruby 2.0.0+) restores prepended object singleton methods",  "(BasicObject (class)).method_added(\"existing_instance_method\")"
  fails "A method stub with args complains if called with no arg",  "expected /received :foo with unexpected arguments/, got #<RSpec::Mocks::MockExpectationError: #<Objec"
  fails "A method stub with args complains if called with other arg",  "expected /received :foo with unexpected arguments.*Please stub a default value/m, got #<RSpec::Mocks:"
  fails "expection set on previously stubbed method outputs arguments of similar calls",  "expected RSpec::Mocks::MockExpectationError with a string including \"#<Double \\\"double\\\"> received :f"
  fails "expection set on previously stubbed method handles concurrent validation of expectations",  "Thread creation not available"
  fails "expection set on previously stubbed method indicates the site of expectation in the stacktrace when outputing arguments of similar calls",  "Maximum call stack size exceeded"
  fails "RSpec::Mocks::TestDouble copies the `as_null_object` state when dup'd",  "The message 'foo' was received by #<RSpec::Mocks::Double:392330 @__expired=false, @name=> but has alr"
  fails "RSpec::Mocks::TestDouble copies the `as_null_object` state when clone'd",  "The message 'foo' was received by #<RSpec::Mocks::Double:392412 @__expired=false, @name=> but has alr"
  fails "RSpec::Mocks::TestDouble#freeze gives the correct call site for the warning",  "Kernel received \"warn\" with unexpected arguments"
  fails "RSpec::Mocks::TestDouble with syntax [\"should\", \"expect\"] stubs the methods passed in the stubs hash",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "RSpec::Mocks::TestDouble with syntax [\"should\"] stubs the methods passed in the stubs hash",  "(BasicObject (class)).method_added(\"should_receive\")"
  fails "a double receiving to_ary double without as_null_object doesn't respond to to_a",  "expected #<Double \"obj\"> not to respond to \"to_a\""
  fails "Constructing a verifying double instance doubles can be constructed with a struct",  "(BasicObject (class)).method_added(\"defined_method\")"
  fails "Constructing a verifying double instance doubles allows classes to be customised",  "(BasicObject (class)).method_added(\"some_method_defined_dynamically\")"
  fails "Constructing a verifying double instance doubles any_instance calls the callback for expect_any_instance_of",  "(BasicObject (class)).method_added(\"some_method_defined_dynamically\")"
  fails "Constructing a verifying double instance doubles any_instance calls the callback for allow_any_instance_of",  "(BasicObject (class)).method_added(\"some_method_defined_dynamically\")"
  fails "Expected argument verification (when `#with` is called) when doubling a loaded class for a method with keyword args fails to match against a hash submitted as a positional argument and received as keyword arguments in Ruby 3.0 or later",  "expected RSpec::Mocks::MockExpectationError with a string including \"expected: (1, {:optional_arg => "
  fails "An instance double with the doubled class loaded only allows instance methods that exist to be stubbed",  "expected RSpec::Mocks::MockExpectationError with message matching /does not implement the instance me"
  fails "An instance double with the doubled class loaded only allows instance methods that exist to be expected",  "expected RSpec::Mocks::MockExpectationError with message matching /(?:)/, got #<NotImplementedError: "
  fails "An instance double with the doubled class loaded suggests using `class_double` when a class method is stubbed",  "expected RSpec::Mocks::MockExpectationError with a string including \"Perhaps you meant to use `class_"
  fails "An instance double with the doubled class loaded doesn't suggest `class_double` when a non-class method is stubbed",  "expected RSpec::Mocks::MockExpectationError with a string excluding \"Perhaps you meant to use `class_"
  fails "An instance double with the doubled class loaded gives a descriptive error message for NoMethodError",  "expected NoMethodError with a string including \"InstanceDouble(LoadedClass)\", got #<RSpec::Mocks::Moc"
  fails "An instance double with the doubled class loaded does not allow dynamic methods to be expected",  "expected RSpec::Mocks::MockExpectationError with message matching /(?:)/, got #<NotImplementedError: "
  fails "An instance double with the doubled class loaded when the class const has been previously stubbed uses the original class to verify against for `instance_double('LoadedClass')`",  "expected RSpec::Mocks::MockExpectationError with message matching /(?:)/, got #<NotImplementedError: "
  fails "An instance double with the doubled class loaded when the class const has been previously stubbed uses the original class to verify against for `instance_double(LoadedClass)`",  "expected RSpec::Mocks::MockExpectationError with message matching /(?:)/, got #<NotImplementedError: "
  fails "An instance double with the doubled class loaded when given a class that has an overridden `#name` method properly verifies",  "expected RSpec::Mocks::MockExpectationError with message matching /(?:)/, got #<NotImplementedError: "
  fails "An instance double with the doubled class loaded for null objects only allows defined methods",  "expected RSpec::Mocks::MockExpectationError with message matching /(?:)/, got #<NotImplementedError: "
  fails "An instance double with the doubled class loaded for null objects includes the double's name in a private method error",  "expected NoMethodError with a string including \"private\" and \"InstanceDouble(LoadedClass)\" but nothin"
  fails "An instance double with the doubled class loaded for null objects reports that it responds to defined private methods when the appropriate arg is passed",  "expected false"
  fails "An instance double with the doubled class loaded for null objects reports that it responds to protected methods when the appropriate arg is passed",  "expected false"
  fails "An instance double with the doubled class not loaded includes the doubled module in errors for unexpected messages",  "expected RSpec::Mocks::MockExpectationError with a string including \"InstanceDouble(NonLoadedClass)\","
  fails "An instance double with the doubled class not loaded for null objects returns self from any message",  "Maximum call stack size exceeded"
  fails "Verified double naming instance_double behaves like a named verifying double when a name is given as a symbol is expected to include a meaningful name in the exception",  "expected #<InstanceDouble(LoadedClass) \"foo\"> to fail expectations as:"
  fails "Verified double naming instance_spy behaves like a named verifying double when a name is given as a symbol is expected to include a meaningful name in the exception",  "expected #<InstanceDouble(LoadedClass) \"foo\"> to fail expectations as:"
  fails "Verified double naming class_double behaves like a named verifying double when a name is given as a string is expected to include a meaningful name in the exception",  "expected #<Module:0x64310> to fail expectations as:"
  fails "Verified double naming class_double behaves like a named verifying double when a name is given as a symbol is expected to include a meaningful name in the exception",  "expected #<Module:0x643b4> to fail expectations as:"
  fails "Verified double naming class_double behaves like a named verifying double when no name is given is expected to include a meaningful name in the exception",  "expected #<Module:0x64458> to fail expectations as:"
  fails "Verified double naming class_spy behaves like a named verifying double when a name is given as a string is expected to include a meaningful name in the exception",  "expected #<Module:0x64532> to fail expectations as:"
  fails "Verified double naming class_spy behaves like a named verifying double when a name is given as a symbol is expected to include a meaningful name in the exception",  "expected #<Module:0x645dc> to fail expectations as:"
  fails "Verified double naming class_spy behaves like a named verifying double when no name is given is expected to include a meaningful name in the exception",  "expected #<Module:0x64686> to fail expectations as:"
  fails "Verified double naming object_double behaves like a named verifying double when a name is given as a symbol is expected to include a meaningful name in the exception",  "expected #<ObjectDouble(LoadedClass) \"foo\"> to fail expectations as:"
  fails "Verified double naming object_spy behaves like a named verifying double when a name is given as a symbol is expected to include a meaningful name in the exception",  "expected #<ObjectDouble(LoadedClass) \"foo\"> to fail expectations as:"
  fails "RSpec::Mocks.verify delegates to the space",  "undefined method `__disallow_further_usage!' for #<Module:0x64686>"
  fails "RSpec::Mocks.teardown resets method stubs",  "Cannot proxy frozen objects. Symbols such as foo cannot be mocked or stubbed."
  fails "RSpec::Mocks.teardown does not put rspec-mocks into an inconsistent state when called extra times",  "undefined method `__disallow_further_usage!' for #<Module:0x64686>"
  fails "RSpec::Mocks.with_temporary_scope tears down even if an error occurs",  "expected #<Object:0x656ba> not to respond to \"bar\""
  fails "RSpec::Mocks.with_temporary_scope in a before(:all) with a stubbed double does not allow the double to be used after the scope in before(:all)",  "Maximum call stack size exceeded"
  fails "RSpec::Mocks.with_temporary_scope in a before(:all) with an any_instance stub allows the stub to be used",  "(BasicObject (class)).method_added(\"sum_with\")"
  fails "RSpec::Mocks.with_temporary_scope in a before(:all) with an any_instance stub does not allow the double to be used in the examples",  "(BasicObject (class)).method_added(\"sum_with\")"
  fails "RSpec::Mocks.with_temporary_scope in a before(:all) with an any_instance stub does not allow the double to be used after the scope in before(:all)",  "(BasicObject (class)).method_added(\"sum_with\")"
end
