KaneAI - World’s First E2E Software Testing Agent.Book a Demo 
How to use failure_message method of RSpec.Matchers Package
Best Spork_ruby code snippet using RSpec.Matchers.failure_message
rspec-expectations@3.11.0.rbi
Source:rspec-expectations@3.11.0.rbi 
...153end154module RSpec::Expectations::ExpectationHelper155 class << self156 def check_message(msg); end157 def handle_failure(matcher, message, failure_message_method); end158 def modern_matcher_from(matcher); end159 def with_matcher(handler, matcher, message); end160 end161end162class RSpec::Expectations::ExpectationNotMetError < ::Exception; end163class RSpec::Expectations::ExpectationTarget164 include ::RSpec::Expectations::ExpectationTarget::InstanceMethods165 def initialize(value); end166 def target; end167 class << self168 def for(value, block); end169 end170end171module RSpec::Expectations::ExpectationTarget::InstanceMethods172 def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end173 def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end174 def to_not(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end175 private176 def prevent_operator_matchers(verb); end177end178module RSpec::Expectations::ExpectationTarget::UndefinedValue; end179class RSpec::Expectations::FailureAggregator180 def initialize(block_label, metadata); end181 def aggregate; end182 def block_label; end183 def call(failure, options); end184 def failures; end185 def metadata; end186 def other_errors; end187 private188 def assign_backtrace(failure); end189 def notify_aggregated_failures; end190end191RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter192class RSpec::Expectations::LegacyMatcherAdapter < ::RSpec::Matchers::MatcherDelegator193 def initialize(matcher); end194 class << self195 def wrap(matcher); end196 end197end198class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < ::RSpec::Expectations::LegacyMatcherAdapter199 def failure_message; end200 def failure_message_when_negated; end201 class << self202 def interface_matches?(matcher); end203 end204end205class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < ::RSpec::Expectations::LegacyMatcherAdapter206 def failure_message; end207 def failure_message_when_negated; end208 class << self209 def interface_matches?(matcher); end210 end211end212class RSpec::Expectations::MultipleExpectationsNotMetError < ::RSpec::Expectations::ExpectationNotMetError213 def initialize(failure_aggregator); end214 def aggregation_block_label; end215 def aggregation_metadata; end216 def all_exceptions; end217 def exception_count_description; end218 def failures; end219 def message; end220 def other_errors; end221 def summary; end222 private223 def backtrace_line(line); end224 def block_description; end225 def enumerated(exceptions, index_offset); end226 def enumerated_errors; end227 def enumerated_failures; end228 def exclusion_patterns; end229 def format_backtrace(backtrace); end230 def indentation; end231 def indented(failure_message, index); end232 def index_label(index); end233 def longest_index_label_width; end234 def pluralize(noun, count); end235 def width_of_label(index); end236end237class RSpec::Expectations::NegativeExpectationHandler238 class << self239 def does_not_match?(matcher, actual, &block); end240 def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end241 def opposite_should_method; end242 def should_method; end243 def verb; end244 end245end246class RSpec::Expectations::PositiveExpectationHandler247 class << self248 def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end249 def opposite_should_method; end250 def should_method; end251 def verb; end252 end253end254module RSpec::Expectations::Syntax255 private256 def default_should_host; end257 def disable_expect(syntax_host = T.unsafe(nil)); end258 def disable_should(syntax_host = T.unsafe(nil)); end259 def enable_expect(syntax_host = T.unsafe(nil)); end260 def enable_should(syntax_host = T.unsafe(nil)); end261 def expect_enabled?(syntax_host = T.unsafe(nil)); end262 def should_enabled?(syntax_host = T.unsafe(nil)); end263 def warn_about_should!; end264 def warn_about_should_unless_configured(method_name); end265 class << self266 def default_should_host; end267 def disable_expect(syntax_host = T.unsafe(nil)); end268 def disable_should(syntax_host = T.unsafe(nil)); end269 def enable_expect(syntax_host = T.unsafe(nil)); end270 def enable_should(syntax_host = T.unsafe(nil)); end271 def expect_enabled?(syntax_host = T.unsafe(nil)); end272 def should_enabled?(syntax_host = T.unsafe(nil)); end273 def warn_about_should!; end274 def warn_about_should_unless_configured(method_name); end275 end276end277class RSpec::Expectations::ValueExpectationTarget < ::RSpec::Expectations::ExpectationTarget278 def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end279 def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end280 private281 def enforce_value_expectation(matcher); end282 def supports_value_expectations?(matcher); end283end284module RSpec::Expectations::Version; end285RSpec::Expectations::Version::STRING = T.let(T.unsafe(nil), String)286RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)287module RSpec::Matchers288 extend ::RSpec::Matchers::DSL289 def a_block_changing(*args, &block); end290 def a_block_outputting(*args, &block); end291 def a_block_raising(*args, &block); end292 def a_block_throwing(*args, &block); end293 def a_block_yielding_control(*args, &block); end294 def a_block_yielding_successive_args(*args, &block); end295 def a_block_yielding_with_args(*args, &block); end296 def a_block_yielding_with_no_args(*args, &block); end297 def a_collection_containing_exactly(*args, &block); end298 def a_collection_ending_with(*args, &block); end299 def a_collection_including(*args, &block); end300 def a_collection_starting_with(*args, &block); end301 def a_falsey_value(*args, &block); end302 def a_falsy_value(*args, &block); end303 def a_hash_including(*args, &block); end304 def a_kind_of(*args, &block); end305 def a_nil_value(*args, &block); end306 def a_range_covering(*args, &block); end307 def a_string_ending_with(*args, &block); end308 def a_string_including(*args, &block); end309 def a_string_matching(*args, &block); end310 def a_string_starting_with(*args, &block); end311 def a_truthy_value(*args, &block); end312 def a_value(*args, &block); end313 def a_value_between(*args, &block); end314 def a_value_within(*args, &block); end315 def aggregate_failures(label = T.unsafe(nil), metadata = T.unsafe(nil), &block); end316 def all(expected); end317 def an_instance_of(*args, &block); end318 def an_object_eq_to(*args, &block); end319 def an_object_eql_to(*args, &block); end320 def an_object_equal_to(*args, &block); end321 def an_object_existing(*args, &block); end322 def an_object_having_attributes(*args, &block); end323 def an_object_matching(*args, &block); end324 def an_object_responding_to(*args, &block); end325 def an_object_satisfying(*args, &block); end326 def be(*args); end327 def be_a(klass); end328 def be_a_kind_of(expected); end329 def be_an(klass); end330 def be_an_instance_of(expected); end331 def be_between(min, max); end332 def be_falsey; end333 def be_falsy(*args, &block); end334 def be_instance_of(expected); end335 def be_kind_of(expected); end336 def be_nil; end337 def be_truthy; end338 def be_within(delta); end339 def change(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end340 def changing(*args, &block); end341 def contain_exactly(*items); end342 def containing_exactly(*args, &block); end343 def cover(*values); end344 def covering(*args, &block); end345 def end_with(*expected); end346 def ending_with(*args, &block); end347 def eq(expected); end348 def eq_to(*args, &block); end349 def eql(expected); end350 def eql_to(*args, &block); end351 def equal(expected); end352 def equal_to(*args, &block); end353 def exist(*args); end354 def existing(*args, &block); end355 def expect(value = T.unsafe(nil), &block); end356 def have_attributes(expected); end357 def having_attributes(*args, &block); end358 def include(*expected); end359 def including(*args, &block); end360 def match(expected); end361 def match_array(items); end362 def match_regex(*args, &block); end363 def matching(*args, &block); end364 def output(expected = T.unsafe(nil)); end365 def raise_error(error = T.unsafe(nil), message = T.unsafe(nil), &block); end366 def raise_exception(error = T.unsafe(nil), message = T.unsafe(nil), &block); end367 def raising(*args, &block); end368 def respond_to(*names); end369 def responding_to(*args, &block); end370 def satisfy(description = T.unsafe(nil), &block); end371 def satisfying(*args, &block); end372 def start_with(*expected); end373 def starting_with(*args, &block); end374 def throw_symbol(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end375 def throwing(*args, &block); end376 def within(*args, &block); end377 def yield_control; end378 def yield_successive_args(*args); end379 def yield_with_args(*args); end380 def yield_with_no_args; end381 def yielding_control(*args, &block); end382 def yielding_successive_args(*args, &block); end383 def yielding_with_args(*args, &block); end384 def yielding_with_no_args(*args, &block); end385 private386 def method_missing(method, *args, &block); end387 def respond_to_missing?(method, *_arg1); end388 class << self389 def alias_matcher(*args, &block); end390 def clear_generated_description; end391 def configuration; end392 def generated_description; end393 def is_a_describable_matcher?(obj); end394 def is_a_matcher?(obj); end395 def last_description; end396 def last_expectation_handler; end397 def last_expectation_handler=(_arg0); end398 def last_matcher; end399 def last_matcher=(_arg0); end400 end401end402class RSpec::Matchers::AliasedMatcher < ::RSpec::Matchers::MatcherDelegator403 def initialize(base_matcher, description_block); end404 def description; end405 def failure_message; end406 def failure_message_when_negated; end407 def method_missing(*_arg0); end408end409class RSpec::Matchers::AliasedMatcherWithOperatorSupport < ::RSpec::Matchers::AliasedMatcher; end410class RSpec::Matchers::AliasedNegatedMatcher < ::RSpec::Matchers::AliasedMatcher411 def does_not_match?(*args, &block); end412 def failure_message; end413 def failure_message_when_negated; end414 def matches?(*args, &block); end415 private416 def optimal_failure_message(same, inverted); end417end418RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages419RSpec::Matchers::BE_PREDICATE_REGEX = T.let(T.unsafe(nil), Regexp)420module RSpec::Matchers::BuiltIn; end421class RSpec::Matchers::BuiltIn::All < ::RSpec::Matchers::BuiltIn::BaseMatcher422 def initialize(matcher); end423 def description; end424 def does_not_match?(_actual); end425 def failed_objects; end426 def failure_message; end427 def matcher; end428 private429 def add_new_line_if_needed(message); end430 def failure_message_for_item(index, failure_message); end431 def indent_multiline_message(message); end432 def index_failed_objects; end433 def initialize_copy(other); end434 def iterable?; end435 def match(_expected, _actual); end436end437class RSpec::Matchers::BuiltIn::BaseMatcher438 include ::RSpec::Matchers::Composable439 include ::RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting440 include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages441 def initialize(expected = T.unsafe(nil)); end442 def actual; end443 def actual_formatted; end444 def description; end445 def diffable?; end446 def expected; end447 def expected_formatted; end448 def expects_call_stack_jump?; end449 def match_unless_raises(*exceptions); end450 def matcher_name; end451 def matcher_name=(_arg0); end452 def matches?(actual); end453 def present_ivars; end454 def rescued_exception; end455 def supports_block_expectations?; end456 def supports_value_expectations?; end457 private458 def assert_ivars(*expected_ivars); end459 class << self460 def matcher_name; end461 private462 def underscore(camel_cased_word); end463 end464end465module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages466 def failure_message; end467 def failure_message_when_negated; end468 class << self469 def has_default_failure_messages?(matcher); end470 end471end472module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting473 private474 def improve_hash_formatting(inspect_string); end475 class << self476 def improve_hash_formatting(inspect_string); end477 end478end479RSpec::Matchers::BuiltIn::BaseMatcher::UNDEFINED = T.let(T.unsafe(nil), Object)480class RSpec::Matchers::BuiltIn::Be < ::RSpec::Matchers::BuiltIn::BaseMatcher481 include ::RSpec::Matchers::BuiltIn::BeHelpers482 def initialize(*args); end483 def <(operand); end484 def <=(operand); end485 def ==(operand); end486 def ===(operand); end487 def =~(operand); end488 def >(operand); end489 def >=(operand); end490 def failure_message; end491 def failure_message_when_negated; end492 private493 def match(_, actual); end494end495class RSpec::Matchers::BuiltIn::BeAKindOf < ::RSpec::Matchers::BuiltIn::BaseMatcher496 private497 def match(expected, actual); end498end499class RSpec::Matchers::BuiltIn::BeAnInstanceOf < ::RSpec::Matchers::BuiltIn::BaseMatcher500 def description; end501 private502 def match(expected, actual); end503end504class RSpec::Matchers::BuiltIn::BeBetween < ::RSpec::Matchers::BuiltIn::BaseMatcher505 def initialize(min, max); end506 def description; end507 def exclusive; end508 def failure_message; end509 def inclusive; end510 def matches?(actual); end511 private512 def comparable?; end513 def compare; end514 def not_comparable_clause; end515end516class RSpec::Matchers::BuiltIn::BeComparedTo < ::RSpec::Matchers::BuiltIn::BaseMatcher517 include ::RSpec::Matchers::BuiltIn::BeHelpers518 def initialize(operand, operator); end519 def description; end520 def does_not_match?(actual); end521 def failure_message; end522 def failure_message_when_negated; end523 def matches?(actual); end524 private525 def perform_match(actual); end526end527class RSpec::Matchers::BuiltIn::BeFalsey < ::RSpec::Matchers::BuiltIn::BaseMatcher528 def failure_message; end529 def failure_message_when_negated; end530 private531 def match(_, actual); end532end533module RSpec::Matchers::BuiltIn::BeHelpers534 private535 def args_to_s; end536 def args_to_sentence; end537 def expected_to_sentence; end538 def inspected_args; end539 def parenthesize(string); end540end541class RSpec::Matchers::BuiltIn::BeNil < ::RSpec::Matchers::BuiltIn::BaseMatcher542 def failure_message; end543 def failure_message_when_negated; end544 private545 def match(_, actual); end546end547class RSpec::Matchers::BuiltIn::BePredicate < ::RSpec::Matchers::BuiltIn::DynamicPredicate548 private549 def failure_to_respond_explanation; end550 def predicate; end551 def predicate_accessible?; end552 def predicate_method_name; end553 def present_tense_predicate; end554end555RSpec::Matchers::BuiltIn::BePredicate::REGEX = T.let(T.unsafe(nil), Regexp)556class RSpec::Matchers::BuiltIn::BeTruthy < ::RSpec::Matchers::BuiltIn::BaseMatcher557 def failure_message; end558 def failure_message_when_negated; end559 private560 def match(_, actual); end561end562class RSpec::Matchers::BuiltIn::BeWithin < ::RSpec::Matchers::BuiltIn::BaseMatcher563 def initialize(delta); end564 def description; end565 def failure_message; end566 def failure_message_when_negated; end567 def matches?(actual); end568 def of(expected); end569 def percent_of(expected); end570 private571 def needs_expected; end572 def not_numeric_clause; end573 def numeric?; end574end575module RSpec::Matchers::BuiltIn::CaptureStderr576 class << self577 def capture(block); end578 def name; end579 end580end581module RSpec::Matchers::BuiltIn::CaptureStdout582 class << self583 def capture(block); end584 def name; end585 end586end587class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < ::Struct588 def capture(block); end589end590class RSpec::Matchers::BuiltIn::Change < ::RSpec::Matchers::BuiltIn::BaseMatcher591 def initialize(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end592 def by(expected_delta); end593 def by_at_least(minimum); end594 def by_at_most(maximum); end595 def description; end596 def does_not_match?(event_proc); end597 def failure_message; end598 def failure_message_when_negated; end599 def from(value); end600 def matches?(event_proc); end601 def supports_block_expectations?; end602 def supports_value_expectations?; end603 def to(value); end604 private605 def change_details; end606 def negative_failure_reason; end607 def perform_change(event_proc); end608 def positive_failure_reason; end609 def raise_block_syntax_error; end610end611class RSpec::Matchers::BuiltIn::ChangeDetails612 def initialize(matcher_name, receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end613 def actual_after; end614 def actual_delta; end615 def changed?; end616 def perform_change(event_proc); end617 def value_representation; end618 private619 def evaluate_value_proc; end620 def extract_value_block_snippet; end621 def message_notation(receiver, message); end622end623module RSpec::Matchers::BuiltIn::ChangeDetails::UNDEFINED; end624class RSpec::Matchers::BuiltIn::ChangeFromValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange625 def initialize(change_details, expected_before); end626 def does_not_match?(event_proc); end627 def failure_message_when_negated; end628 def to(value); end629 private630 def change_description; end631end632class RSpec::Matchers::BuiltIn::ChangeRelatively < ::RSpec::Matchers::BuiltIn::BaseMatcher633 def initialize(change_details, expected_delta, relativity, &comparer); end634 def description; end635 def does_not_match?(_event_proc); end636 def failure_message; end637 def matches?(event_proc); end638 def supports_block_expectations?; end639 def supports_value_expectations?; end640 private641 def failure_reason; end642end643class RSpec::Matchers::BuiltIn::ChangeToValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange644 def initialize(change_details, expected_after); end645 def does_not_match?(_event_proc); end646 def from(value); end647 private648 def change_description; end649end650class RSpec::Matchers::BuiltIn::Compound < ::RSpec::Matchers::BuiltIn::BaseMatcher651 def initialize(matcher_1, matcher_2); end652 def description; end653 def diffable?; end654 def does_not_match?(_actual); end655 def evaluator; end656 def expected; end657 def expects_call_stack_jump?; end658 def matcher_1; end659 def matcher_2; end660 def supports_block_expectations?; end661 def supports_value_expectations?; end662 protected663 def diffable_matcher_list; end664 private665 def compound_failure_message; end666 def diffable_matcher_list_for(matcher); end667 def indent_multiline_message(message); end668 def initialize_copy(other); end669 def match(_expected, actual); end670 def matcher_1_matches?; end671 def matcher_2_matches?; end672 def matcher_is_diffable?(matcher); end673 def matcher_supports_block_expectations?(matcher); end674 def matcher_supports_value_expectations?(matcher); end675end676class RSpec::Matchers::BuiltIn::Compound::And < ::RSpec::Matchers::BuiltIn::Compound677 def failure_message; end678 private679 def conjunction; end680 def match(*_arg0); end681end682class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator683 def initialize(actual, matcher_1, matcher_2); end684 def matcher_matches?(matcher); end685 private686 def inner_matcher_block(outer_args); end687 def order_block_matchers; end688 class << self689 def matcher_expects_call_stack_jump?(matcher); end690 end691end692class RSpec::Matchers::BuiltIn::Compound::Or < ::RSpec::Matchers::BuiltIn::Compound693 def failure_message; end694 private695 def conjunction; end696 def match(*_arg0); end697end698class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator699 def initialize(actual, *_arg1); end700 def matcher_matches?(matcher); end701end702class RSpec::Matchers::BuiltIn::ContainExactly < ::RSpec::Matchers::BuiltIn::BaseMatcher703 def description; end704 def failure_message; end705 def failure_message_when_negated; end706 private707 def actual_collection_line; end708 def best_solution; end709 def convert_actual_to_an_array; end710 def describe_collection(collection, surface_descriptions = T.unsafe(nil)); end711 def expected_collection_line; end712 def extra_elements_line; end713 def extra_items; end714 def generate_failure_message; end715 def match(_expected, _actual); end716 def match_when_sorted?; end717 def message_line(prefix, collection, surface_descriptions = T.unsafe(nil)); end718 def missing_elements_line; end719 def missing_items; end720 def pairings_maximizer; end721 def safe_sort(array); end722 def to_a_disallowed?(object); end723end724class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer725 def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end726 def actual_to_expected_matched_indexes; end727 def expected_to_actual_matched_indexes; end728 def find_best_solution; end729 def solution; end730 private731 def apply_pairing_to(indeterminates, original_matches, other_list_index); end732 def best_solution_for_pairing(expected_index, actual_index); end733 def categorize_indexes(indexes_to_categorize, other_indexes); end734 def reciprocal_single_match?(matches, index, other_list); end735end736class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution737 class << self738 def worse_than?(_other); end739 end740end741class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < ::Struct742 def +(derived_candidate_solution); end743 def candidate?; end744 def ideal?; end745 def indeterminate_actual_indexes; end746 def indeterminate_actual_indexes=(_); end747 def indeterminate_expected_indexes; end748 def indeterminate_expected_indexes=(_); end749 def unmatched_actual_indexes; end750 def unmatched_actual_indexes=(_); end751 def unmatched_expected_indexes; end752 def unmatched_expected_indexes=(_); end753 def unmatched_item_count; end754 def worse_than?(other); end755 class << self756 def [](*_arg0); end757 def inspect; end758 def members; end759 def new(*_arg0); end760 end761end762module RSpec::Matchers::BuiltIn::CountExpectation763 def at_least(number); end764 def at_most(number); end765 def exactly(number); end766 def once; end767 def thrice; end768 def times; end769 def twice; end770 protected771 def count_expectation_type; end772 def expected_count; end773 private774 def count_constraint_to_number(n); end775 def count_expectation_description; end776 def count_failure_reason(action); end777 def cover?(count, number); end778 def expected_count_matches?(actual_count); end779 def has_expected_count?; end780 def human_readable_count(count); end781 def human_readable_expectation_type; end782 def raise_impossible_count_expectation(count); end783 def raise_unsupported_count_expectation; end784 def set_expected_count(relativity, n); end785 def unsupported_count_expectation?(relativity); end786end787class RSpec::Matchers::BuiltIn::Cover < ::RSpec::Matchers::BuiltIn::BaseMatcher788 def initialize(*expected); end789 def does_not_match?(range); end790 def matches?(range); end791end792class RSpec::Matchers::BuiltIn::DynamicPredicate < ::RSpec::Matchers::BuiltIn::BaseMatcher793 include ::RSpec::Matchers::BuiltIn::BeHelpers794 def initialize(method_name, *args, &block); end795 def description; end796 def does_not_match?(actual, &block); end797 def failure_message; end798 def failure_message_when_negated; end799 def matches?(actual, &block); end800 private801 def expectation_of(value); end802 def failure_message_expecting(value); end803 def failure_to_respond_explanation; end804 def method_description; end805 def predicate_accessible?; end806 def predicate_matches?(value = T.unsafe(nil)); end807 def predicate_method_name; end808 def predicate_result; end809 def private_predicate?; end810 def root; end811 def validity_message; end812end813class RSpec::Matchers::BuiltIn::EndWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith814 private815 def element_matches?; end816 def subset_matches?; end817end818class RSpec::Matchers::BuiltIn::Eq < ::RSpec::Matchers::BuiltIn::BaseMatcher819 def description; end820 def diffable?; end821 def failure_message; end822 def failure_message_when_negated; end823 private824 def match(expected, actual); end825end826class RSpec::Matchers::BuiltIn::Eql < ::RSpec::Matchers::BuiltIn::BaseMatcher827 def diffable?; end828 def failure_message; end829 def failure_message_when_negated; end830 private831 def match(expected, actual); end832end833class RSpec::Matchers::BuiltIn::Equal < ::RSpec::Matchers::BuiltIn::BaseMatcher834 def diffable?; end835 def failure_message; end836 def failure_message_when_negated; end837 private838 def actual_inspected; end839 def detailed_failure_message; end840 def expected_is_a_literal_singleton?; end841 def inspect_object(o); end842 def match(expected, actual); end843 def simple_failure_message; end844end845RSpec::Matchers::BuiltIn::Equal::LITERAL_SINGLETONS = T.let(T.unsafe(nil), Array)846class RSpec::Matchers::BuiltIn::Exist < ::RSpec::Matchers::BuiltIn::BaseMatcher847 def initialize(*expected); end848 def does_not_match?(actual); end849 def failure_message; end850 def failure_message_when_negated; end851 def matches?(actual); end852end853class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < ::Struct854 def actual_exists?; end855 def valid_test?; end856 def validity_message; end857 private858 def deprecated(predicate, actual); end859 def existence_values; end860 def predicates; end861 def uniq_truthy_values; end862end863class RSpec::Matchers::BuiltIn::Has < ::RSpec::Matchers::BuiltIn::DynamicPredicate864 private865 def predicate; end866end867RSpec::Matchers::BuiltIn::Has::REGEX = T.let(T.unsafe(nil), Regexp)868class RSpec::Matchers::BuiltIn::HaveAttributes < ::RSpec::Matchers::BuiltIn::BaseMatcher869 def initialize(expected); end870 def actual; end871 def description; end872 def diffable?; end873 def does_not_match?(actual); end874 def failure_message; end875 def failure_message_when_negated; end876 def matches?(actual); end877 def respond_to_failed; end878 private879 def actual_has_attribute?(attribute_key, attribute_value); end880 def cache_all_values; end881 def formatted_values; end882 def perform_match(predicate); end883 def respond_to_attributes?; end884 def respond_to_failure_message_or; end885 def respond_to_matcher; end886end887class RSpec::Matchers::BuiltIn::Include < ::RSpec::Matchers::BuiltIn::BaseMatcher888 include ::RSpec::Matchers::BuiltIn::CountExpectation889 def initialize(*expecteds); end890 def description; end891 def diffable?; end892 def does_not_match?(actual); end893 def expected; end894 def expecteds; end895 def failure_message; end896 def failure_message_when_negated; end897 def matches?(actual); end898 private899 def actual_collection_includes?(expected_item); end900 def actual_hash_has_key?(expected_key); end901 def actual_hash_includes?(expected_key, expected_value); end902 def check_actual?(actual); end903 def check_expected_count?; end904 def comparing_hash_keys?(expected_item); end905 def comparing_hash_to_a_subset?(expected_item); end906 def convert_to_hash?(obj); end907 def count_enumerable(expected_item); end908 def count_inclusions; end909 def diff_would_wrongly_highlight_matched_item?; end910 def excluded_from_actual; end911 def format_failure_message(preposition); end912 def perform_match(&block); end913 def readable_list_of(items); end914end915class RSpec::Matchers::BuiltIn::Match < ::RSpec::Matchers::BuiltIn::BaseMatcher916 def initialize(expected); end917 def description; end918 def diffable?; end919 def with_captures(*captures); end920 private921 def can_safely_call_match?(expected, actual); end922 def match(expected, actual); end923 def match_captures(expected, actual); end924end925class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher926 def __delegate_operator(actual, operator, expected); end927end928module RSpec::Matchers::BuiltIn::NullCapture929 class << self930 def capture(_block); end931 def name; end932 end933end934class RSpec::Matchers::BuiltIn::OperatorMatcher935 def initialize(actual); end936 def !=(_expected); end937 def !~(_expected); end938 def <(expected); end939 def <=(expected); end940 def ==(expected); end941 def ===(expected); end942 def =~(expected); end943 def >(expected); end944 def >=(expected); end945 def description; end946 def fail_with_message(message); end947 private948 def eval_match(actual, operator, expected); end949 def has_non_generic_implementation_of?(op); end950 class << self951 def get(klass, operator); end952 def register(klass, operator, matcher); end953 def registry; end954 def unregister(klass, operator); end955 def use_custom_matcher_or_delegate(operator); end956 end957end958class RSpec::Matchers::BuiltIn::Output < ::RSpec::Matchers::BuiltIn::BaseMatcher959 def initialize(expected); end960 def description; end961 def diffable?; end962 def does_not_match?(block); end963 def failure_message; end964 def failure_message_when_negated; end965 def matches?(block); end966 def supports_block_expectations?; end967 def supports_value_expectations?; end968 def to_stderr; end969 def to_stderr_from_any_process; end970 def to_stdout; end971 def to_stdout_from_any_process; end972 private973 def actual_output_description; end974 def captured?; end975 def negative_failure_reason; end976 def positive_failure_reason; end977end978class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher979 def __delegate_operator(actual, operator, expected); end980end981class RSpec::Matchers::BuiltIn::RaiseError982 include ::RSpec::Matchers::Composable983 def initialize(expected_error_or_message, expected_message, &block); end984 def description; end985 def does_not_match?(given_proc); end986 def expects_call_stack_jump?; end987 def failure_message; end988 def failure_message_when_negated; end989 def matches?(given_proc, negative_expectation = T.unsafe(nil), &block); end990 def supports_block_expectations?; end991 def supports_value_expectations?; end992 def with_message(expected_message); end993 private994 def actual_error_message; end995 def block_matches?; end996 def error_and_message_match?; end997 def eval_block; end998 def expectation_matched?; end999 def expected_error; end1000 def expecting_specific_exception?; end1001 def format_backtrace(backtrace); end1002 def given_error; end1003 def handle_warning(message); end1004 def raise_message_already_set; end1005 def ready_to_eval_block?; end1006 def verify_message; end1007 def warn_about_bare_error!; end1008 def warn_about_bare_error?; end1009 def warn_about_negative_false_positive!(expression); end1010 def warn_about_nil_error!; end1011 def warn_about_nil_error?; end1012 def warn_for_negative_false_positives!; end1013 def warning; end1014end1015RSpec::Matchers::BuiltIn::RaiseError::UndefinedValue = T.let(T.unsafe(nil), Object)1016class RSpec::Matchers::BuiltIn::ReliableMatchData1017 def initialize(match_data); end1018 def captures; end1019 def names; end1020 protected1021 def match_data; end1022end1023class RSpec::Matchers::BuiltIn::RespondTo < ::RSpec::Matchers::BuiltIn::BaseMatcher1024 def initialize(*names); end1025 def and_any_keywords; end1026 def and_keywords(*keywords); end1027 def and_unlimited_arguments; end1028 def argument; end1029 def arguments; end1030 def description; end1031 def does_not_match?(actual); end1032 def failure_message; end1033 def failure_message_when_negated; end1034 def ignoring_method_signature_failure!; end1035 def matches?(actual); end1036 def with(n); end1037 def with_any_keywords; end1038 def with_keywords(*keywords); end1039 def with_unlimited_arguments; end1040 private1041 def find_failing_method_names(actual, filter_method); end1042 def matches_arity?(actual, name); end1043 def pp_names; end1044 def with_arity; end1045 def with_arity_string; end1046 def with_keywords_string; end1047end1048class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck1049 def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end1050 def matches?(actual, name); end1051 def method_signature_for(actual, name); end1052 def verifier_for(actual, name); end1053end1054class RSpec::Matchers::BuiltIn::Satisfy < ::RSpec::Matchers::BuiltIn::BaseMatcher1055 def initialize(description = T.unsafe(nil), &block); end1056 def description; end1057 def failure_message; end1058 def failure_message_when_negated; end1059 def matches?(actual, &block); end1060 private1061 def block_representation; end1062 def extract_block_snippet; end1063end1064class RSpec::Matchers::BuiltIn::SpecificValuesChange < ::RSpec::Matchers::BuiltIn::BaseMatcher1065 def initialize(change_details, from, to); end1066 def description; end1067 def failure_message; end1068 def matches?(event_proc); end1069 def supports_block_expectations?; end1070 def supports_value_expectations?; end1071 private1072 def after_value_failure; end1073 def before_value_failure; end1074 def did_change_failure; end1075 def did_not_change_failure; end1076 def matches_after?; end1077 def not_given_a_block_failure; end1078 def perform_change(event_proc); end1079end1080RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject1081RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith1082class RSpec::Matchers::BuiltIn::StartOrEndWith < ::RSpec::Matchers::BuiltIn::BaseMatcher1083 def initialize(*expected); end1084 def description; end1085 def failure_message; end1086 private1087 def match(_expected, actual); end1088 def subsets_comparable?; end1089end1090class RSpec::Matchers::BuiltIn::StartWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith1091 private1092 def element_matches?; end1093 def subset_matches?; end1094end1095class RSpec::Matchers::BuiltIn::ThrowSymbol1096 include ::RSpec::Matchers::Composable1097 def initialize(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end1098 def description; end1099 def does_not_match?(given_proc); end1100 def expects_call_stack_jump?; end1101 def failure_message; end1102 def failure_message_when_negated; end1103 def matches?(given_proc); end1104 def supports_block_expectations?; end1105 def supports_value_expectations?; end1106 private1107 def actual_result; end1108 def caught; end1109 def expected(symbol_desc = T.unsafe(nil)); end1110 def throw_description(symbol, arg); end1111end1112class RSpec::Matchers::BuiltIn::YieldControl < ::RSpec::Matchers::BuiltIn::BaseMatcher1113 include ::RSpec::Matchers::BuiltIn::CountExpectation1114 def does_not_match?(block); end1115 def failure_message; end1116 def failure_message_when_negated; end1117 def matches?(block); end1118 def supports_block_expectations?; end1119 def supports_value_expectations?; end1120 private1121 def failure_reason; end1122end1123class RSpec::Matchers::BuiltIn::YieldProbe1124 def initialize(block, &callback); end1125 def assert_used!; end1126 def assert_valid_expect_block!; end1127 def has_block?; end1128 def num_yields; end1129 def num_yields=(_arg0); end1130 def probe; end1131 def single_yield_args; end1132 def to_proc; end1133 def yielded_args; end1134 def yielded_args=(_arg0); end1135 def yielded_once?(matcher_name); end1136 class << self1137 def probe(block, &callback); end1138 end1139end1140class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher1141 def initialize(*args); end1142 def description; end1143 def does_not_match?(block); end1144 def failure_message; end1145 def failure_message_when_negated; end1146 def matches?(block); end1147 def supports_block_expectations?; end1148 def supports_value_expectations?; end1149 private1150 def expected_arg_description; end1151 def negative_failure_reason; end1152 def positive_failure_reason; end1153end1154class RSpec::Matchers::BuiltIn::YieldWithArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher1155 def initialize(*args); end1156 def description; end1157 def does_not_match?(block); end1158 def failure_message; end1159 def failure_message_when_negated; end1160 def matches?(block); end1161 def supports_block_expectations?; end1162 def supports_value_expectations?; end1163 private1164 def all_args_match?; end1165 def args_currently_match?; end1166 def expected_arg_description; end1167 def negative_failure_reason; end1168 def positive_failure_reason; end1169end1170class RSpec::Matchers::BuiltIn::YieldWithNoArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher1171 def does_not_match?(block); end1172 def failure_message; end1173 def failure_message_when_negated; end1174 def matches?(block); end1175 def supports_block_expectations?; end1176 def supports_value_expectations?; end1177 private1178 def negative_failure_reason; end1179 def positive_failure_reason; end1180end1181module RSpec::Matchers::Composable1182 def &(matcher); end1183 def ===(value); end1184 def and(matcher); end1185 def or(matcher); end1186 def |(matcher); end1187 private1188 def description_of(object); end1189 def should_enumerate?(item); end1190 def surface_descriptions_in(item); end1191 def unreadable_io?(object); end1192 def values_match?(expected, actual); end1193 def with_matchers_cloned(object); end1194 class << self1195 def should_enumerate?(item); end1196 def surface_descriptions_in(item); end1197 def unreadable_io?(object); end1198 end1199end1200class RSpec::Matchers::Composable::DescribableItem < ::Struct1201 def inspect; end1202 def item; end1203 def item=(_); end1204 def pretty_print(pp); end1205 class << self1206 def [](*_arg0); end1207 def inspect; end1208 def members; end1209 def new(*_arg0); end1210 end1211end1212module RSpec::Matchers::DSL1213 def alias_matcher(new_name, old_name, options = T.unsafe(nil), &description_override); end1214 def define(name, &declarations); end1215 def define_negated_matcher(negated_name, base_name, &description_override); end1216 def matcher(name, &declarations); end1217 private1218 def warn_about_block_args(name, declarations); end1219end1220module RSpec::Matchers::DSL::DefaultImplementations1221 include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages1222 def description; end1223 def diffable?; end1224 def expects_call_stack_jump?; end1225 def supports_block_expectations?; end1226 def supports_value_expectations?; end1227 private1228 def chained_method_clause_sentences; end1229end1230module RSpec::Matchers::DSL::Macros1231 def chain(method_name, *attr_names, &definition); end1232 def description(&definition); end1233 def diffable; end1234 def failure_message(&definition); end1235 def failure_message_when_negated(&definition); end1236 def match(options = T.unsafe(nil), &match_block); end1237 def match_unless_raises(expected_exception = T.unsafe(nil), &match_block); end1238 def match_when_negated(options = T.unsafe(nil), &match_block); end1239 def supports_block_expectations; end1240 private1241 def assign_attributes(attr_names); end1242 def define_user_override(method_name, user_def, &our_def); end1243end1244module RSpec::Matchers::DSL::Macros::Deprecated1245 def failure_message_for_should(&definition); end1246 def failure_message_for_should_not(&definition); end1247 def match_for_should(&definition); end1248 def match_for_should_not(&definition); end1249end1250RSpec::Matchers::DSL::Macros::RAISE_NOTIFIER = T.let(T.unsafe(nil), Proc)1251class RSpec::Matchers::DSL::Matcher1252 include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages1253 include ::RSpec::Matchers::DSL::DefaultImplementations1254 include ::RSpec::Matchers1255 include ::RSpec::Matchers::Composable1256 extend ::RSpec::Matchers::DSL::Macros1257 extend ::RSpec::Matchers::DSL::Macros::Deprecated1258 def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end1259 def actual; end1260 def block_arg; end...
rspec-expectations.rbi
Source:rspec-expectations.rbi
...180 def improve_hash_formatting(inspect_string); end181 def self.improve_hash_formatting(inspect_string); end182end183module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages184 def failure_message; end185 def failure_message_when_negated; end186 def self.has_default_failure_messages?(matcher); end187end188module RSpec::Matchers::DSL189 def alias_matcher(new_name, old_name, options = nil, &description_override); end190 def define(name, &declarations); end191 def define_negated_matcher(negated_name, base_name, &description_override); end192 def matcher(name, &declarations); end193 def warn_about_block_args(name, declarations); end194end195module RSpec::Matchers::DSL::Macros196 def assign_attributes(attr_names); end197 def chain(method_name, *attr_names, &definition); end198 def define_user_override(method_name, user_def, &our_def); end199 def description(&definition); end200 def diffable; end201 def failure_message(&definition); end202 def failure_message_when_negated(&definition); end203 def match(options = nil, &match_block); end204 def match_unless_raises(expected_exception = nil, &match_block); end205 def match_when_negated(options = nil, &match_block); end206 def supports_block_expectations; end207end208module RSpec::Matchers::DSL::Macros::Deprecated209 def failure_message_for_should(&definition); end210 def failure_message_for_should_not(&definition); end211 def match_for_should(&definition); end212 def match_for_should_not(&definition); end213end214module RSpec::Matchers::DSL::DefaultImplementations215 def chained_method_clause_sentences; end216 def description; end217 def diffable?; end218 def expects_call_stack_jump?; end219 def supports_block_expectations?; end220 include RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages221end222class RSpec::Matchers::DSL::Matcher223 def actual; end224 def actual_arg_for(block); end225 def block_arg; end226 def expected; end227 def expected_as_array; end228 def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end229 def inspect; end230 def method_missing(method, *args, &block); end231 def name; end232 def rescued_exception; end233 def respond_to_missing?(method, include_private = nil); end234 extend RSpec::Matchers::DSL::Macros235 extend RSpec::Matchers::DSL::Macros::Deprecated236 include RSpec::Matchers237 include RSpec::Matchers::Composable238 include RSpec::Matchers::DSL::DefaultImplementations239end240class RSpec::Matchers::MatcherDelegator241 def base_matcher; end242 def initialize(base_matcher); end243 def initialize_copy(other); end244 def method_missing(*args, &block); end245 def respond_to_missing?(name, include_all = nil); end246 include RSpec::Matchers::Composable247end248class RSpec::Matchers::AliasedMatcher < RSpec::Matchers::MatcherDelegator249 def description; end250 def failure_message; end251 def failure_message_when_negated; end252 def initialize(base_matcher, description_block); end253 def method_missing(*arg0); end254end255class RSpec::Matchers::AliasedMatcherWithOperatorSupport < RSpec::Matchers::AliasedMatcher256end257class RSpec::Matchers::AliasedNegatedMatcher < RSpec::Matchers::AliasedMatcher258 def does_not_match?(*args, &block); end259 def failure_message; end260 def failure_message_when_negated; end261 def matches?(*args, &block); end262 def optimal_failure_message(same, inverted); end263end264class RSpec::Matchers::ExpectedsForMultipleDiffs265 def diffs(differ, actual); end266 def initialize(expected_list); end267 def message_with_diff(message, differ, actual); end268 def self.diff_label_for(matcher); end269 def self.for_many_matchers(matchers); end270 def self.from(expected); end271 def self.truncated(description); end272end273module RSpec::Support274 def self.require_rspec_expectations(f); end275 def self.require_rspec_matchers(f); end276end277module RSpec::Expectations278 def self.configuration; end279 def self.differ; end280 def self.fail_with(message, expected = nil, actual = nil); end281end282class RSpec::Expectations::ExpectationTarget283 def initialize(value); end284 def self.for(value, block); end285 def target; end286 include RSpec::Expectations::ExpectationTarget::InstanceMethods287end288module RSpec::Expectations::ExpectationTarget::UndefinedValue289end290module RSpec::Expectations::ExpectationTarget::InstanceMethods291 def not_to(matcher = nil, message = nil, &block); end292 def prevent_operator_matchers(verb); end293 def to(matcher = nil, message = nil, &block); end294 def to_not(matcher = nil, message = nil, &block); end295end296class RSpec::Expectations::BlockExpectationTarget < RSpec::Expectations::ExpectationTarget297 def enforce_block_expectation(matcher); end298 def not_to(matcher, message = nil, &block); end299 def supports_block_expectations?(matcher); end300 def to(matcher, message = nil, &block); end301 def to_not(matcher, message = nil, &block); end302end303module RSpec::Expectations::Syntax304 def default_should_host; end305 def disable_expect(syntax_host = nil); end306 def disable_should(syntax_host = nil); end307 def enable_expect(syntax_host = nil); end308 def enable_should(syntax_host = nil); end309 def expect_enabled?(syntax_host = nil); end310 def self.default_should_host; end311 def self.disable_expect(syntax_host = nil); end312 def self.disable_should(syntax_host = nil); end313 def self.enable_expect(syntax_host = nil); end314 def self.enable_should(syntax_host = nil); end315 def self.expect_enabled?(syntax_host = nil); end316 def self.should_enabled?(syntax_host = nil); end317 def self.warn_about_should!; end318 def self.warn_about_should_unless_configured(method_name); end319 def should_enabled?(syntax_host = nil); end320 def warn_about_should!; end321 def warn_about_should_unless_configured(method_name); end322end323class BasicObject324 def should(matcher = nil, message = nil, &block); end325 def should_not(matcher = nil, message = nil, &block); end326end327class RSpec::Expectations::Configuration328 def add_should_and_should_not_to(*modules); end329 def backtrace_formatter; end330 def backtrace_formatter=(arg0); end331 def color?; end332 def false_positives_handler; end333 def include_chain_clauses_in_custom_matcher_descriptions=(arg0); end334 def include_chain_clauses_in_custom_matcher_descriptions?; end335 def initialize; end336 def max_formatted_output_length=(length); end337 def on_potential_false_positives; end338 def on_potential_false_positives=(behavior); end339 def reset_syntaxes_to_default; end340 def strict_predicate_matchers; end341 def strict_predicate_matchers=(flag); end342 def strict_predicate_matchers?; end343 def syntax; end344 def syntax=(values); end345 def warn_about_potential_false_positives=(boolean); end346 def warn_about_potential_false_positives?; end347end348module RSpec::Expectations::Configuration::NullBacktraceFormatter349 def self.format_backtrace(backtrace); end350end351class InvalidName___Class_0x00___Differ_2352end353module RSpec::Expectations::ExpectationHelper354 def self.check_message(msg); end355 def self.handle_failure(matcher, message, failure_message_method); end356 def self.modern_matcher_from(matcher); end357 def self.with_matcher(handler, matcher, message); end358end359class RSpec::Expectations::PositiveExpectationHandler360 def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end361 def self.opposite_should_method; end362 def self.should_method; end363 def self.verb; end364end365class RSpec::Expectations::NegativeExpectationHandler366 def self.does_not_match?(matcher, actual, &block); end367 def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end368 def self.opposite_should_method; end369 def self.should_method; end370 def self.verb; end371end372class RSpec::Expectations::LegacyMatcherAdapter < RSpec::Matchers::MatcherDelegator373 def initialize(matcher); end374 def self.wrap(matcher); end375end376class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < RSpec::Expectations::LegacyMatcherAdapter377 def failure_message; end378 def failure_message_when_negated; end379 def self.interface_matches?(matcher); end380end381class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < RSpec::Expectations::LegacyMatcherAdapter382 def failure_message; end383 def failure_message_when_negated; end384 def self.interface_matches?(matcher); end385end386module RSpec::Expectations::Version387end388class RSpec::Expectations::ExpectationNotMetError < Exception389end390class RSpec::Expectations::MultipleExpectationsNotMetError < RSpec::Expectations::ExpectationNotMetError391 def aggregation_block_label; end392 def aggregation_metadata; end393 def all_exceptions; end394 def backtrace_line(line); end395 def block_description; end396 def enumerated(exceptions, index_offset); end397 def enumerated_errors; end398 def enumerated_failures; end399 def exception_count_description; end400 def exclusion_patterns; end401 def failures; end402 def format_backtrace(backtrace); end403 def indentation; end404 def indented(failure_message, index); end405 def index_label(index); end406 def initialize(failure_aggregator); end407 def longest_index_label_width; end408 def message; end409 def other_errors; end410 def pluralize(noun, count); end411 def summary; end412 def width_of_label(index); end413end414class RSpec::Expectations::BlockSnippetExtractor415 def beginning_line_number; end416 def block_token_extractor; end417 def body_content_lines; end418 def file_path; end419 def initialize(proc, method_name); end420 def method_name; end421 def proc; end422 def raw_body_lines; end423 def raw_body_snippet; end424 def self.try_extracting_single_line_body_of(proc, method_name); end425 def source; end426 def source_location; end427end428class RSpec::Expectations::BlockSnippetExtractor::Error < StandardError429end430class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < RSpec::Expectations::BlockSnippetExtractor::Error431end432class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < RSpec::Expectations::BlockSnippetExtractor::Error433end434class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < Struct435 def after_beginning_of_args_state(token); end436 def after_beginning_of_body_state(token); end437 def after_method_call_state(token); end438 def after_opener_state(token); end439 def beginning_line_number; end440 def beginning_line_number=(_); end441 def block_locator; end442 def body_tokens; end443 def correct_block?(body_tokens); end444 def finalize_pending_tokens!; end445 def finish!; end446 def finish_or_find_next_block_if_incorrect!; end447 def handle_closer_token(token); end448 def handle_opener_token(token); end449 def initial_state(token); end450 def initialize(*arg0); end451 def invoke_state_handler(token); end452 def method_name; end453 def method_name=(_); end454 def opener_token?(token); end455 def opener_token_stack; end456 def parse!; end457 def pending_tokens; end458 def pipe_token?(token); end459 def self.[](*arg0); end460 def self.inspect; end461 def self.members; end462 def self.new(*arg0); end463 def source; end464 def source=(_); end465 def state; end466end467class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < Struct468 def beginning_line_number; end469 def beginning_line_number=(_); end470 def block_body_node; end471 def block_wrapper_node; end472 def body_content_locations; end473 def candidate_block_wrapper_nodes; end474 def candidate_method_ident_nodes; end475 def method_call_location; end476 def method_ident_node; end477 def method_ident_node?(node); end478 def method_name; end479 def method_name=(_); end480 def self.[](*arg0); end481 def self.inspect; end482 def self.members; end483 def self.new(*arg0); end484 def source; end485 def source=(_); end486end487class RSpec::Expectations::FailureAggregator488 def aggregate; end489 def assign_backtrace(failure); end490 def block_label; end491 def call(failure, options); end492 def failures; end493 def initialize(block_label, metadata); end494 def metadata; end495 def notify_aggregated_failures; end496 def other_errors; end497end498class RSpec::Matchers::BuiltIn::BeAKindOf < RSpec::Matchers::BuiltIn::BaseMatcher499 def match(expected, actual); end500end501class RSpec::Matchers::BuiltIn::BeAnInstanceOf < RSpec::Matchers::BuiltIn::BaseMatcher502 def description; end503 def match(expected, actual); end504end505class RSpec::Matchers::BuiltIn::BeBetween < RSpec::Matchers::BuiltIn::BaseMatcher506 def comparable?; end507 def compare; end508 def description; end509 def exclusive; end510 def failure_message; end511 def inclusive; end512 def initialize(min, max); end513 def matches?(actual); end514 def not_comparable_clause; end515end516class RSpec::Matchers::BuiltIn::BeTruthy < RSpec::Matchers::BuiltIn::BaseMatcher517 def failure_message; end518 def failure_message_when_negated; end519 def match(_, actual); end520end521class RSpec::Matchers::BuiltIn::BeFalsey < RSpec::Matchers::BuiltIn::BaseMatcher522 def failure_message; end523 def failure_message_when_negated; end524 def match(_, actual); end525end526class RSpec::Matchers::BuiltIn::BeNil < RSpec::Matchers::BuiltIn::BaseMatcher527 def failure_message; end528 def failure_message_when_negated; end529 def match(_, actual); end530end531module RSpec::Matchers::BuiltIn::BeHelpers532 def args_to_s; end533 def args_to_sentence; end534 def expected_to_sentence; end535 def inspected_args; end536 def parenthesize(string); end537end538class RSpec::Matchers::BuiltIn::Be < RSpec::Matchers::BuiltIn::BaseMatcher539 def <(operand); end540 def <=(operand); end541 def ==(operand); end542 def ===(operand); end543 def =~(operand); end544 def >(operand); end545 def >=(operand); end546 def failure_message; end547 def failure_message_when_negated; end548 def initialize(*args); end549 def match(_, actual); end550 include RSpec::Matchers::BuiltIn::BeHelpers551end552class RSpec::Matchers::BuiltIn::BeComparedTo < RSpec::Matchers::BuiltIn::BaseMatcher553 def description; end554 def does_not_match?(actual); end555 def failure_message; end556 def failure_message_when_negated; end557 def initialize(operand, operator); end558 def matches?(actual); end559 def perform_match(actual); end560 include RSpec::Matchers::BuiltIn::BeHelpers561end562class RSpec::Matchers::BuiltIn::DynamicPredicate < RSpec::Matchers::BuiltIn::BaseMatcher563 def description; end564 def does_not_match?(actual, &block); end565 def expectation_of(value); end566 def failure_message; end567 def failure_message_expecting(value); end568 def failure_message_when_negated; end569 def failure_to_respond_explanation; end570 def initialize(method_name, *args, &block); end571 def matches?(actual, &block); end572 def method_description; end573 def predicate_accessible?; end574 def predicate_matches?(value = nil); end575 def predicate_method_name; end576 def predicate_result; end577 def private_predicate?; end578 def root; end579 def validity_message; end580 include RSpec::Matchers::BuiltIn::BeHelpers581end582class RSpec::Matchers::BuiltIn::Has < RSpec::Matchers::BuiltIn::DynamicPredicate583 def predicate; end584end585class RSpec::Matchers::BuiltIn::BePredicate < RSpec::Matchers::BuiltIn::DynamicPredicate586 def failure_to_respond_explanation; end587 def predicate; end588 def predicate_accessible?; end589 def predicate_method_name; end590 def present_tense_predicate; end591end592class RSpec::Matchers::BuiltIn::BeWithin < RSpec::Matchers::BuiltIn::BaseMatcher593 def description; end594 def failure_message; end595 def failure_message_when_negated; end596 def initialize(delta); end597 def matches?(actual); end598 def needs_expected; end599 def not_numeric_clause; end600 def numeric?; end601 def of(expected); end602 def percent_of(expected); end603end604class RSpec::Matchers::BuiltIn::Change < RSpec::Matchers::BuiltIn::BaseMatcher605 def by(expected_delta); end606 def by_at_least(minimum); end607 def by_at_most(maximum); end608 def change_details; end609 def description; end610 def does_not_match?(event_proc); end611 def failure_message; end612 def failure_message_when_negated; end613 def from(value); end614 def initialize(receiver = nil, message = nil, &block); end615 def matches?(event_proc); end616 def negative_failure_reason; end617 def perform_change(event_proc); end618 def positive_failure_reason; end619 def raise_block_syntax_error; end620 def supports_block_expectations?; end621 def to(value); end622end623class RSpec::Matchers::BuiltIn::ChangeRelatively < RSpec::Matchers::BuiltIn::BaseMatcher624 def description; end625 def does_not_match?(_event_proc); end626 def failure_message; end627 def failure_reason; end628 def initialize(change_details, expected_delta, relativity, &comparer); end629 def matches?(event_proc); end630 def supports_block_expectations?; end631end632class RSpec::Matchers::BuiltIn::SpecificValuesChange < RSpec::Matchers::BuiltIn::BaseMatcher633 def after_value_failure; end634 def before_value_failure; end635 def description; end636 def did_change_failure; end637 def did_not_change_failure; end638 def failure_message; end639 def initialize(change_details, from, to); end640 def matches?(event_proc); end641 def matches_after?; end642 def not_given_a_block_failure; end643 def perform_change(event_proc); end644 def supports_block_expectations?; end645end646class RSpec::Matchers::BuiltIn::ChangeFromValue < RSpec::Matchers::BuiltIn::SpecificValuesChange647 def change_description; end648 def does_not_match?(event_proc); end649 def failure_message_when_negated; end650 def initialize(change_details, expected_before); end651 def to(value); end652end653class RSpec::Matchers::BuiltIn::ChangeToValue < RSpec::Matchers::BuiltIn::SpecificValuesChange654 def change_description; end655 def does_not_match?(_event_proc); end656 def from(value); end657 def initialize(change_details, expected_after); end658end659class RSpec::Matchers::BuiltIn::ChangeDetails660 def actual_after; end661 def actual_delta; end662 def changed?; end663 def evaluate_value_proc; end664 def extract_value_block_snippet; end665 def initialize(matcher_name, receiver = nil, message = nil, &block); end666 def message_notation(receiver, message); end667 def perform_change(event_proc); end668 def value_representation; end669end670class RSpec::Matchers::BuiltIn::Compound < RSpec::Matchers::BuiltIn::BaseMatcher671 def compound_failure_message; end672 def description; end673 def diffable?; end674 def diffable_matcher_list; end675 def diffable_matcher_list_for(matcher); end676 def does_not_match?(_actual); end677 def evaluator; end678 def expected; end679 def expects_call_stack_jump?; end680 def indent_multiline_message(message); end681 def initialize(matcher_1, matcher_2); end682 def initialize_copy(other); end683 def match(_expected, actual); end684 def matcher_1; end685 def matcher_1_matches?; end686 def matcher_2; end687 def matcher_2_matches?; end688 def matcher_is_diffable?(matcher); end689 def matcher_supports_block_expectations?(matcher); end690 def supports_block_expectations?; end691end692class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator693 def initialize(actual, *arg1); end694 def matcher_matches?(matcher); end695end696class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator697 def initialize(actual, matcher_1, matcher_2); end698 def inner_matcher_block(outer_args); end699 def matcher_matches?(matcher); end700 def order_block_matchers; end701 def self.matcher_expects_call_stack_jump?(matcher); end702end703class RSpec::Matchers::BuiltIn::Compound::And < RSpec::Matchers::BuiltIn::Compound704 def conjunction; end705 def failure_message; end706 def match(*arg0); end707end708class RSpec::Matchers::BuiltIn::Compound::Or < RSpec::Matchers::BuiltIn::Compound709 def conjunction; end710 def failure_message; end711 def match(*arg0); end712end713class RSpec::Matchers::BuiltIn::ContainExactly < RSpec::Matchers::BuiltIn::BaseMatcher714 def actual_collection_line; end715 def best_solution; end716 def convert_actual_to_an_array; end717 def describe_collection(collection, surface_descriptions = nil); end718 def description; end719 def expected_collection_line; end720 def extra_elements_line; end721 def extra_items; end722 def failure_message; end723 def failure_message_when_negated; end724 def generate_failure_message; end725 def match(_expected, _actual); end726 def match_when_sorted?; end727 def message_line(prefix, collection, surface_descriptions = nil); end728 def missing_elements_line; end729 def missing_items; end730 def pairings_maximizer; end731 def safe_sort(array); end732 def to_a_disallowed?(object); end733end734class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer735 def actual_to_expected_matched_indexes; end736 def apply_pairing_to(indeterminates, original_matches, other_list_index); end737 def best_solution_for_pairing(expected_index, actual_index); end738 def categorize_indexes(indexes_to_categorize, other_indexes); end739 def expected_to_actual_matched_indexes; end740 def find_best_solution; end741 def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end742 def reciprocal_single_match?(matches, index, other_list); end743 def solution; end744end745class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < Struct746 def +(derived_candidate_solution); end747 def candidate?; end748 def ideal?; end749 def indeterminate_actual_indexes; end750 def indeterminate_actual_indexes=(_); end751 def indeterminate_expected_indexes; end752 def indeterminate_expected_indexes=(_); end753 def self.[](*arg0); end754 def self.inspect; end755 def self.members; end756 def self.new(*arg0); end757 def unmatched_actual_indexes; end758 def unmatched_actual_indexes=(_); end759 def unmatched_expected_indexes; end760 def unmatched_expected_indexes=(_); end761 def unmatched_item_count; end762 def worse_than?(other); end763end764class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution765 def self.worse_than?(_other); end766end767class RSpec::Matchers::BuiltIn::Cover < RSpec::Matchers::BuiltIn::BaseMatcher768 def does_not_match?(range); end769 def initialize(*expected); end770 def matches?(range); end771end772class RSpec::Matchers::BuiltIn::StartOrEndWith < RSpec::Matchers::BuiltIn::BaseMatcher773 def description; end774 def failure_message; end775 def initialize(*expected); end776 def match(_expected, actual); end777 def subsets_comparable?; end778end779class RSpec::Matchers::BuiltIn::StartWith < RSpec::Matchers::BuiltIn::StartOrEndWith780 def element_matches?; end781 def subset_matches?; end782end783class RSpec::Matchers::BuiltIn::EndWith < RSpec::Matchers::BuiltIn::StartOrEndWith784 def element_matches?; end785 def subset_matches?; end786end787class RSpec::Matchers::BuiltIn::Eq < RSpec::Matchers::BuiltIn::BaseMatcher788 def description; end789 def diffable?; end790 def failure_message; end791 def failure_message_when_negated; end792 def match(expected, actual); end793end794class RSpec::Matchers::BuiltIn::Eql < RSpec::Matchers::BuiltIn::BaseMatcher795 def diffable?; end796 def failure_message; end797 def failure_message_when_negated; end798 def match(expected, actual); end799end800class RSpec::Matchers::BuiltIn::Equal < RSpec::Matchers::BuiltIn::BaseMatcher801 def actual_inspected; end802 def detailed_failure_message; end803 def diffable?; end804 def expected_is_a_literal_singleton?; end805 def failure_message; end806 def failure_message_when_negated; end807 def inspect_object(o); end808 def match(expected, actual); end809 def simple_failure_message; end810end811class RSpec::Matchers::BuiltIn::Exist < RSpec::Matchers::BuiltIn::BaseMatcher812 def does_not_match?(actual); end813 def failure_message; end814 def failure_message_when_negated; end815 def initialize(*expected); end816 def matches?(actual); end817end818class Anonymous_Struct_3 < Struct819 def actual; end820 def actual=(_); end821 def expected; end822 def expected=(_); end823 def self.[](*arg0); end824 def self.inspect; end825 def self.members; end826 def self.new(*arg0); end827end828class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < Anonymous_Struct_3829 def actual_exists?; end830 def deprecated(predicate, actual); end831 def existence_values; end832 def predicates; end833 def uniq_truthy_values; end834 def valid_test?; end835 def validity_message; end836end837class RSpec::Matchers::BuiltIn::HaveAttributes < RSpec::Matchers::BuiltIn::BaseMatcher838 def actual; end839 def actual_has_attribute?(attribute_key, attribute_value); end840 def cache_all_values; end841 def description; end842 def diffable?; end843 def does_not_match?(actual); end844 def failure_message; end845 def failure_message_when_negated; end846 def formatted_values; end847 def initialize(expected); end848 def matches?(actual); end849 def perform_match(predicate); end850 def respond_to_attributes?; end851 def respond_to_failed; end852 def respond_to_failure_message_or; end853 def respond_to_matcher; end854end855module RSpec::Matchers::BuiltIn::CountExpectation856 def at_least(number); end857 def at_most(number); end858 def count_constraint_to_number(n); end859 def count_expectation_description; end860 def count_expectation_type; end861 def count_failure_reason(action); end862 def cover?(count, number); end863 def exactly(number); end864 def expected_count; end865 def expected_count_matches?(actual_count); end866 def has_expected_count?; end867 def human_readable_count(count); end868 def human_readable_expectation_type; end869 def once; end870 def raise_impossible_count_expectation(count); end871 def raise_unsupported_count_expectation; end872 def set_expected_count(relativity, n); end873 def thrice; end874 def times; end875 def twice; end876 def unsupported_count_expectation?(relativity); end877end878class RSpec::Matchers::BuiltIn::Include < RSpec::Matchers::BuiltIn::BaseMatcher879 def actual_collection_includes?(expected_item); end880 def actual_hash_has_key?(expected_key); end881 def actual_hash_includes?(expected_key, expected_value); end882 def check_actual?(actual); end883 def check_expected_count?; end884 def comparing_hash_keys?(expected_item); end885 def comparing_hash_to_a_subset?(expected_item); end886 def convert_to_hash?(obj); end887 def count_enumerable(expected_item); end888 def count_inclusions; end889 def description; end890 def diff_would_wrongly_highlight_matched_item?; end891 def diffable?; end892 def does_not_match?(actual); end893 def excluded_from_actual; end894 def expected; end895 def expecteds; end896 def failure_message; end897 def failure_message_when_negated; end898 def format_failure_message(preposition); end899 def initialize(*expecteds); end900 def matches?(actual); end901 def perform_match(&block); end902 def readable_list_of(items); end903 include RSpec::Matchers::BuiltIn::CountExpectation904end905class RSpec::Matchers::BuiltIn::All < RSpec::Matchers::BuiltIn::BaseMatcher906 def add_new_line_if_needed(message); end907 def description; end908 def does_not_match?(_actual); end909 def failed_objects; end910 def failure_message; end911 def failure_message_for_item(index, failure_message); end912 def indent_multiline_message(message); end913 def index_failed_objects; end914 def initialize(matcher); end915 def initialize_copy(other); end916 def iterable?; end917 def match(_expected, _actual); end918 def matcher; end919end920class RSpec::Matchers::BuiltIn::Match < RSpec::Matchers::BuiltIn::BaseMatcher921 def can_safely_call_match?(expected, actual); end922 def description; end923 def diffable?; end924 def initialize(expected); end925 def match(expected, actual); end926 def match_captures(expected, actual); end927 def with_captures(*captures); end928end929class RSpec::Matchers::BuiltIn::ReliableMatchData930 def captures; end931 def initialize(match_data); end932 def match_data; end933 def names; end934end935class RSpec::Matchers::BuiltIn::OperatorMatcher936 def !=(_expected); end937 def !~(_expected); end938 def <(expected); end939 def <=(expected); end940 def ==(expected); end941 def ===(expected); end942 def =~(expected); end943 def >(expected); end944 def >=(expected); end945 def description; end946 def eval_match(actual, operator, expected); end947 def fail_with_message(message); end948 def has_non_generic_implementation_of?(op); end949 def initialize(actual); end950 def self.get(klass, operator); end951 def self.register(klass, operator, matcher); end952 def self.registry; end953 def self.unregister(klass, operator); end954 def self.use_custom_matcher_or_delegate(operator); end955end956class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher957 def __delegate_operator(actual, operator, expected); end958end959class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher960 def __delegate_operator(actual, operator, expected); end961end962class RSpec::Matchers::BuiltIn::Output < RSpec::Matchers::BuiltIn::BaseMatcher963 def actual_output_description; end964 def captured?; end965 def description; end966 def diffable?; end967 def does_not_match?(block); end968 def failure_message; end969 def failure_message_when_negated; end970 def initialize(expected); end971 def matches?(block); end972 def negative_failure_reason; end973 def positive_failure_reason; end974 def supports_block_expectations?; end975 def to_stderr; end976 def to_stderr_from_any_process; end977 def to_stdout; end978 def to_stdout_from_any_process; end979end980module RSpec::Matchers::BuiltIn::NullCapture981 def self.capture(_block); end982 def self.name; end983end984module RSpec::Matchers::BuiltIn::CaptureStdout985 def self.capture(block); end986 def self.name; end987end988module RSpec::Matchers::BuiltIn::CaptureStderr989 def self.capture(block); end990 def self.name; end991end992class Anonymous_Struct_4 < Struct993 def name; end994 def name=(_); end995 def self.[](*arg0); end996 def self.inspect; end997 def self.members; end998 def self.new(*arg0); end999 def stream; end1000 def stream=(_); end1001end1002class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < Anonymous_Struct_41003 def capture(block); end1004end1005class RSpec::Matchers::BuiltIn::RaiseError1006 def block_matches?; end1007 def description; end1008 def does_not_match?(given_proc); end1009 def error_and_message_match?; end1010 def eval_block; end1011 def expectation_matched?; end1012 def expected_error; end1013 def expecting_specific_exception?; end1014 def expects_call_stack_jump?; end1015 def failure_message; end1016 def failure_message_when_negated; end1017 def format_backtrace(backtrace); end1018 def given_error; end1019 def handle_warning(message); end1020 def initialize(expected_error_or_message, expected_message, &block); end1021 def matches?(given_proc, negative_expectation = nil, &block); end1022 def raise_message_already_set; end1023 def ready_to_eval_block?; end1024 def supports_block_expectations?; end1025 def verify_message; end1026 def warn_about_bare_error!; end1027 def warn_about_bare_error?; end1028 def warn_about_negative_false_positive!(expression); end1029 def warn_about_nil_error!; end1030 def warn_about_nil_error?; end1031 def warn_for_negative_false_positives!; end1032 def warning; end1033 def with_message(expected_message); end1034 include RSpec::Matchers::Composable1035end1036class RSpec::Matchers::BuiltIn::RespondTo < RSpec::Matchers::BuiltIn::BaseMatcher1037 def and_any_keywords; end1038 def and_keywords(*keywords); end1039 def and_unlimited_arguments; end1040 def argument; end1041 def arguments; end1042 def description; end1043 def does_not_match?(actual); end1044 def failure_message; end1045 def failure_message_when_negated; end1046 def find_failing_method_names(actual, filter_method); end1047 def ignoring_method_signature_failure!; end1048 def initialize(*names); end1049 def matches?(actual); end1050 def matches_arity?(actual, name); end1051 def pp_names; end1052 def with(n); end1053 def with_any_keywords; end1054 def with_arity; end1055 def with_arity_string; end1056 def with_keywords(*keywords); end1057 def with_keywords_string; end1058 def with_unlimited_arguments; end1059end1060class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck1061 def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end1062 def matches?(actual, name); end1063 def method_signature_for(actual, name); end1064 def verifier_for(actual, name); end1065end1066class RSpec::Matchers::BuiltIn::Satisfy < RSpec::Matchers::BuiltIn::BaseMatcher1067 def block_representation; end1068 def description; end1069 def extract_block_snippet; end1070 def failure_message; end1071 def failure_message_when_negated; end1072 def initialize(description = nil, &block); end1073 def matches?(actual, &block); end1074end1075class RSpec::Matchers::BuiltIn::ThrowSymbol1076 def actual_result; end1077 def caught; end1078 def description; end1079 def does_not_match?(given_proc); end1080 def expected(symbol_desc = nil); end1081 def expects_call_stack_jump?; end1082 def failure_message; end1083 def failure_message_when_negated; end1084 def initialize(expected_symbol = nil, expected_arg = nil); end1085 def matches?(given_proc); end1086 def supports_block_expectations?; end1087 def throw_description(symbol, arg); end1088 include RSpec::Matchers::Composable1089end1090class RSpec::Matchers::BuiltIn::YieldProbe1091 def assert_used!; end1092 def assert_valid_expect_block!; end1093 def has_block?; end1094 def initialize(block, &callback); end1095 def num_yields; end1096 def num_yields=(arg0); end1097 def probe; end1098 def self.probe(block, &callback); end1099 def single_yield_args; end1100 def to_proc; end1101 def yielded_args; end1102 def yielded_args=(arg0); end1103 def yielded_once?(matcher_name); end1104end1105class RSpec::Matchers::BuiltIn::YieldControl < RSpec::Matchers::BuiltIn::BaseMatcher1106 def does_not_match?(block); end1107 def failure_message; end1108 def failure_message_when_negated; end1109 def failure_reason; end1110 def matches?(block); end1111 def supports_block_expectations?; end1112 include RSpec::Matchers::BuiltIn::CountExpectation1113end1114class RSpec::Matchers::BuiltIn::YieldWithNoArgs < RSpec::Matchers::BuiltIn::BaseMatcher1115 def does_not_match?(block); end1116 def failure_message; end1117 def failure_message_when_negated; end1118 def matches?(block); end1119 def negative_failure_reason; end1120 def positive_failure_reason; end1121 def supports_block_expectations?; end1122end1123class RSpec::Matchers::BuiltIn::YieldWithArgs < RSpec::Matchers::BuiltIn::BaseMatcher1124 def all_args_match?; end1125 def args_currently_match?; end1126 def description; end1127 def does_not_match?(block); end1128 def expected_arg_description; end1129 def failure_message; end1130 def failure_message_when_negated; end1131 def initialize(*args); end1132 def matches?(block); end1133 def negative_failure_reason; end1134 def positive_failure_reason; end1135 def supports_block_expectations?; end1136end1137class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < RSpec::Matchers::BuiltIn::BaseMatcher1138 def description; end1139 def does_not_match?(block); end1140 def expected_arg_description; end1141 def failure_message; end1142 def failure_message_when_negated; end1143 def initialize(*args); end1144 def matches?(block); end1145 def negative_failure_reason; end1146 def positive_failure_reason; end1147 def supports_block_expectations?; end1148end...
failure_message
Using AI Code Generation
1 it { is_expected.to be_a_multiple_of(3) }2 it { is_expected.to be_a_multiple_of(3) }3 it { is_expected.to be_a_multiple_of(3) }
failure_message
Using AI Code Generation
1 it { is_expected.to be_a_multiple_of 3 }2 it { is_expected.to be_a_multiple_of 3 }3 it { is_expected.to be_a_multiple_of 3 }
failure_message
Using AI Code Generation
1 expect(6).to be_a_multiple_of(3)2 expect(5).not_to be_a_multiple_of(3)3 Failure/Error: expect(5).not_to be_a_multiple_of(3)4Finished in 0.00511 seconds (files took 0.11865 seconds to load)
failure_message
Using AI Code Generation
1 it { is_expected.to be_a_multiple_of(3) }2 it { is_expected.to be_a_multiple_of(3) }3 it { is_expected.to_not be_a_multiple_of(5) }4 it { is_expected.to_not be_a_multiple_of(5)
failure_message
Using AI Code Generation
1puts RSpec::Matchers.failure_message("Expected 1 to be 2")2puts RSpec::Matchers.failure_message("Expected 1 to be 2", "Custom message")3puts RSpec::Matchers.failure_message("Expected 1 to be 2", "Custom message") do4puts RSpec::Matchers.failure_message("Expected 1 to be 2", "Custom message") do5puts RSpec::Matchers.failure_message("Expected 1 to be 2", "Custom message") do6puts RSpec::Matchers.failure_message("Expected 1 to be 2", "Custom message") do7puts RSpec::Matchers.failure_message("Expected 1 to be 2", "Custom message") do
failure_message
Using AI Code Generation
1puts RSpec::Matchers.failure_message("Expected 1 to be 2")2puts RSpec::Matchers.failure_message("Expected 1 to be 2", "Custom message")3puts RSpec::Matchers.failure_message("Expected 1 to be 2", "Custom message") do4puts RSpec::Matchers.failure_message("Expected 1 to be 2", "Custom message") do5puts RSpec::Matchers.failure_message("Expected 1 to be 2", "Custom message") do6puts RSpec::Matchers.failure_message("Expected 1 to be 2", "Custom message") do7puts RSpec::Matchers.failure_message("Expected 1 to be 2", "Custom message") do
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run Spork_ruby automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Most used method in
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
