Test your AI Agents with the all-new Agent to Agent Testing Platform.Learn More

How to use initialize method of RSpec.Matchers Package

Best Spork_ruby code snippet using RSpec.Matchers.initialize

rspec-expectations@3.11.0.rbi

Source:rspec-expectations@3.11.0.rbi

...45  def enforce_block_expectation(matcher); end46  def supports_block_expectations?(matcher); end47end48class RSpec::Expectations::BlockSnippetExtractor49  def initialize(proc, method_name); end50  def body_content_lines; end51  def method_name; end52  def proc; end53  private54  def beginning_line_number; end55  def block_token_extractor; end56  def file_path; end57  def raw_body_lines; end58  def raw_body_snippet; end59  def source; end60  def source_location; end61  class << self62    def try_extracting_single_line_body_of(proc, method_name); end63  end64end65class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end66class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < ::Struct67  def beginning_line_number; end68  def beginning_line_number=(_); end69  def body_content_locations; end70  def method_call_location; end71  def method_name; end72  def method_name=(_); end73  def source; end74  def source=(_); end75  private76  def block_body_node; end77  def block_wrapper_node; end78  def candidate_block_wrapper_nodes; end79  def candidate_method_ident_nodes; end80  def method_ident_node; end81  def method_ident_node?(node); end82  class << self83    def [](*_arg0); end84    def inspect; end85    def members; end86    def new(*_arg0); end87  end88end89class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < ::Struct90  def initialize(*_arg0); end91  def beginning_line_number; end92  def beginning_line_number=(_); end93  def body_tokens; end94  def method_name; end95  def method_name=(_); end96  def source; end97  def source=(_); end98  def state; end99  private100  def after_beginning_of_args_state(token); end101  def after_beginning_of_body_state(token); end102  def after_method_call_state(token); end103  def after_opener_state(token); end104  def block_locator; end105  def correct_block?(body_tokens); end106  def finalize_pending_tokens!; end107  def finish!; end108  def finish_or_find_next_block_if_incorrect!; end109  def handle_closer_token(token); end110  def handle_opener_token(token); end111  def initial_state(token); end112  def invoke_state_handler(token); end113  def opener_token?(token); end114  def opener_token_stack; end115  def parse!; end116  def pending_tokens; end117  def pipe_token?(token); end118  class << self119    def [](*_arg0); end120    def inspect; end121    def members; end122    def new(*_arg0); end123  end124end125class RSpec::Expectations::BlockSnippetExtractor::Error < ::StandardError; end126class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end127class RSpec::Expectations::Configuration128  def initialize; end129  def add_should_and_should_not_to(*modules); end130  def backtrace_formatter; end131  def backtrace_formatter=(_arg0); end132  def color?; end133  def false_positives_handler; end134  def include_chain_clauses_in_custom_matcher_descriptions=(_arg0); end135  def include_chain_clauses_in_custom_matcher_descriptions?; end136  def max_formatted_output_length=(length); end137  def on_potential_false_positives; end138  def on_potential_false_positives=(behavior); end139  def reset_syntaxes_to_default; end140  def strict_predicate_matchers; end141  def strict_predicate_matchers=(flag); end142  def strict_predicate_matchers?; end143  def syntax; end144  def syntax=(values); end145  def warn_about_potential_false_positives=(boolean); end146  def warn_about_potential_false_positives?; end147end148RSpec::Expectations::Configuration::FALSE_POSITIVE_BEHAVIOURS = T.let(T.unsafe(nil), Hash)149module RSpec::Expectations::Configuration::NullBacktraceFormatter150  class << self151    def format_backtrace(backtrace); end152  end153end154module 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; end1261  def expected; end1262  def expected_as_array; end1263  def inspect; end1264  def name; end1265  def rescued_exception; end1266  private1267  def actual_arg_for(block); end1268  def method_missing(method, *args, &block); end1269  def respond_to_missing?(method, include_private = T.unsafe(nil)); end1270end1271RSpec::Matchers::DYNAMIC_MATCHER_REGEX = T.let(T.unsafe(nil), Regexp)1272module RSpec::Matchers::EnglishPhrasing1273  class << self1274    def list(obj); end1275    def split_words(sym); end1276  end1277end1278class RSpec::Matchers::ExpectedsForMultipleDiffs1279  def initialize(expected_list); end1280  def message_with_diff(message, differ, actual); end1281  private1282  def diffs(differ, actual); end1283  class << self1284    def for_many_matchers(matchers); end1285    def from(expected); end1286    private1287    def diff_label_for(matcher); end1288    def truncated(description); end1289  end1290end1291RSpec::Matchers::ExpectedsForMultipleDiffs::DEFAULT_DIFF_LABEL = T.let(T.unsafe(nil), String)1292RSpec::Matchers::ExpectedsForMultipleDiffs::DESCRIPTION_MAX_LENGTH = T.let(T.unsafe(nil), Integer)1293RSpec::Matchers::HAS_REGEX = T.let(T.unsafe(nil), Regexp)1294class RSpec::Matchers::MatcherDelegator1295  include ::RSpec::Matchers::Composable1296  def initialize(base_matcher); end1297  def base_matcher; end1298  def method_missing(*args, &block); end1299  private1300  def initialize_copy(other); end1301  def respond_to_missing?(name, include_all = T.unsafe(nil)); end1302end1303RSpec::SharedContext = RSpec::Core::SharedContext...

rspec-expectations.rbi

Source:rspec-expectations.rbi

...161  def diffable?; end162  def expected; end163  def expected_formatted; end164  def expects_call_stack_jump?; end165  def initialize(expected = nil); end166  def match_unless_raises(*exceptions); end167  def matcher_name; end168  def matcher_name=(arg0); end169  def matches?(actual); end170  def present_ivars; end171  def rescued_exception; end172  def self.matcher_name; end173  def self.underscore(camel_cased_word); end174  def supports_block_expectations?; end175  include RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages176  include RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting177  include RSpec::Matchers::Composable178end179module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting180  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 BasicObject324end325class RSpec::Expectations::Configuration326  def add_should_and_should_not_to(*modules); end327  def backtrace_formatter; end328  def backtrace_formatter=(arg0); end329  def color?; end330  def false_positives_handler; end331  def include_chain_clauses_in_custom_matcher_descriptions=(arg0); end332  def include_chain_clauses_in_custom_matcher_descriptions?; end333  def initialize; end334  def max_formatted_output_length=(length); end335  def on_potential_false_positives; end336  def on_potential_false_positives=(behavior); end337  def reset_syntaxes_to_default; end338  def strict_predicate_matchers; end339  def strict_predicate_matchers=(flag); end340  def strict_predicate_matchers?; end341  def syntax; end342  def syntax=(values); end343  def warn_about_potential_false_positives=(boolean); end344  def warn_about_potential_false_positives?; end345end346module RSpec::Expectations::Configuration::NullBacktraceFormatter347  def self.format_backtrace(backtrace); end348end349class InvalidName___Class_0x00___Differ_12350end351module RSpec::Expectations::ExpectationHelper352  def self.check_message(msg); end353  def self.handle_failure(matcher, message, failure_message_method); end354  def self.modern_matcher_from(matcher); end355  def self.with_matcher(handler, matcher, message); end356end357class RSpec::Expectations::PositiveExpectationHandler358  def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end359  def self.opposite_should_method; end360  def self.should_method; end361  def self.verb; end362end363class RSpec::Expectations::NegativeExpectationHandler364  def self.does_not_match?(matcher, actual, &block); end365  def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end366  def self.opposite_should_method; end367  def self.should_method; end368  def self.verb; end369end370class RSpec::Expectations::LegacyMatcherAdapter < RSpec::Matchers::MatcherDelegator371  def initialize(matcher); end372  def self.wrap(matcher); end373end374class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < RSpec::Expectations::LegacyMatcherAdapter375  def failure_message; end376  def failure_message_when_negated; end377  def self.interface_matches?(matcher); end378end379class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < RSpec::Expectations::LegacyMatcherAdapter380  def failure_message; end381  def failure_message_when_negated; end382  def self.interface_matches?(matcher); end383end384module RSpec::Expectations::Version385end386class RSpec::Expectations::ExpectationNotMetError < Exception387end388class RSpec::Expectations::MultipleExpectationsNotMetError < RSpec::Expectations::ExpectationNotMetError389  def aggregation_block_label; end390  def aggregation_metadata; end391  def all_exceptions; end392  def backtrace_line(line); end393  def block_description; end394  def enumerated(exceptions, index_offset); end395  def enumerated_errors; end396  def enumerated_failures; end397  def exception_count_description; end398  def exclusion_patterns; end399  def failures; end400  def format_backtrace(backtrace); end401  def indentation; end402  def indented(failure_message, index); end403  def index_label(index); end404  def initialize(failure_aggregator); end405  def longest_index_label_width; end406  def message; end407  def other_errors; end408  def pluralize(noun, count); end409  def summary; end410  def width_of_label(index); end411end412class RSpec::Expectations::BlockSnippetExtractor413  def beginning_line_number; end414  def block_token_extractor; end415  def body_content_lines; end416  def file_path; end417  def initialize(proc, method_name); end418  def method_name; end419  def proc; end420  def raw_body_lines; end421  def raw_body_snippet; end422  def self.try_extracting_single_line_body_of(proc, method_name); end423  def source; end424  def source_location; end425end426class RSpec::Expectations::BlockSnippetExtractor::Error < StandardError427end428class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < RSpec::Expectations::BlockSnippetExtractor::Error429end430class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < RSpec::Expectations::BlockSnippetExtractor::Error431end432class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < Struct433  def after_beginning_of_args_state(token); end434  def after_beginning_of_body_state(token); end435  def after_method_call_state(token); end436  def after_opener_state(token); end437  def beginning_line_number; end438  def beginning_line_number=(_); end439  def block_locator; end440  def body_tokens; end441  def correct_block?(body_tokens); end442  def finalize_pending_tokens!; end443  def finish!; end444  def finish_or_find_next_block_if_incorrect!; end445  def handle_closer_token(token); end446  def handle_opener_token(token); end447  def initial_state(token); end448  def initialize(*arg0); end449  def invoke_state_handler(token); end450  def method_name; end451  def method_name=(_); end452  def opener_token?(token); end453  def opener_token_stack; end454  def parse!; end455  def pending_tokens; end456  def pipe_token?(token); end457  def self.[](*arg0); end458  def self.inspect; end459  def self.members; end460  def self.new(*arg0); end461  def source; end462  def source=(_); end463  def state; end464end465class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < Struct466  def beginning_line_number; end467  def beginning_line_number=(_); end468  def block_body_node; end469  def block_wrapper_node; end470  def body_content_locations; end471  def candidate_block_wrapper_nodes; end472  def candidate_method_ident_nodes; end473  def method_call_location; end474  def method_ident_node; end475  def method_ident_node?(node); end476  def method_name; end477  def method_name=(_); end478  def self.[](*arg0); end479  def self.inspect; end480  def self.members; end481  def self.new(*arg0); end482  def source; end483  def source=(_); end484end485class RSpec::Expectations::FailureAggregator486  def aggregate; end487  def assign_backtrace(failure); end488  def block_label; end489  def call(failure, options); end490  def failures; end491  def initialize(block_label, metadata); end492  def metadata; end493  def notify_aggregated_failures; end494  def other_errors; end495end496class RSpec::Matchers::BuiltIn::BeAKindOf < RSpec::Matchers::BuiltIn::BaseMatcher497  def match(expected, actual); end498end499class RSpec::Matchers::BuiltIn::BeAnInstanceOf < RSpec::Matchers::BuiltIn::BaseMatcher500  def description; end501  def match(expected, actual); end502end503class RSpec::Matchers::BuiltIn::BeBetween < RSpec::Matchers::BuiltIn::BaseMatcher504  def comparable?; end505  def compare; end506  def description; end507  def exclusive; end508  def failure_message; end509  def inclusive; end510  def initialize(min, max); end511  def matches?(actual); end512  def not_comparable_clause; end513end514class RSpec::Matchers::BuiltIn::BeTruthy < RSpec::Matchers::BuiltIn::BaseMatcher515  def failure_message; end516  def failure_message_when_negated; end517  def match(_, actual); end518end519class RSpec::Matchers::BuiltIn::BeFalsey < RSpec::Matchers::BuiltIn::BaseMatcher520  def failure_message; end521  def failure_message_when_negated; end522  def match(_, actual); end523end524class RSpec::Matchers::BuiltIn::BeNil < RSpec::Matchers::BuiltIn::BaseMatcher525  def failure_message; end526  def failure_message_when_negated; end527  def match(_, actual); end528end529module RSpec::Matchers::BuiltIn::BeHelpers530  def args_to_s; end531  def args_to_sentence; end532  def expected_to_sentence; end533  def inspected_args; end534  def parenthesize(string); end535end536class RSpec::Matchers::BuiltIn::Be < RSpec::Matchers::BuiltIn::BaseMatcher537  def <(operand); end538  def <=(operand); end539  def ==(operand); end540  def ===(operand); end541  def =~(operand); end542  def >(operand); end543  def >=(operand); end544  def failure_message; end545  def failure_message_when_negated; end546  def initialize(*args); end547  def match(_, actual); end548  include RSpec::Matchers::BuiltIn::BeHelpers549end550class RSpec::Matchers::BuiltIn::BeComparedTo < RSpec::Matchers::BuiltIn::BaseMatcher551  def description; end552  def does_not_match?(actual); end553  def failure_message; end554  def failure_message_when_negated; end555  def initialize(operand, operator); end556  def matches?(actual); end557  def perform_match(actual); end558  include RSpec::Matchers::BuiltIn::BeHelpers559end560class RSpec::Matchers::BuiltIn::DynamicPredicate < RSpec::Matchers::BuiltIn::BaseMatcher561  def description; end562  def does_not_match?(actual, &block); end563  def expectation_of(value); end564  def failure_message; end565  def failure_message_expecting(value); end566  def failure_message_when_negated; end567  def failure_to_respond_explanation; end568  def initialize(method_name, *args, &block); end569  def matches?(actual, &block); end570  def method_description; end571  def predicate_accessible?; end572  def predicate_matches?(value = nil); end573  def predicate_method_name; end574  def predicate_result; end575  def private_predicate?; end576  def root; end577  def validity_message; end578  include RSpec::Matchers::BuiltIn::BeHelpers579end580class RSpec::Matchers::BuiltIn::Has < RSpec::Matchers::BuiltIn::DynamicPredicate581  def predicate; end582end583class RSpec::Matchers::BuiltIn::BePredicate < RSpec::Matchers::BuiltIn::DynamicPredicate584  def failure_to_respond_explanation; end585  def predicate; end586  def predicate_accessible?; end587  def predicate_method_name; end588  def present_tense_predicate; end589end590class RSpec::Matchers::BuiltIn::BeWithin < RSpec::Matchers::BuiltIn::BaseMatcher591  def description; end592  def failure_message; end593  def failure_message_when_negated; end594  def initialize(delta); end595  def matches?(actual); end596  def needs_expected; end597  def not_numeric_clause; end598  def numeric?; end599  def of(expected); end600  def percent_of(expected); end601end602class RSpec::Matchers::BuiltIn::Change < RSpec::Matchers::BuiltIn::BaseMatcher603  def by(expected_delta); end604  def by_at_least(minimum); end605  def by_at_most(maximum); end606  def change_details; end607  def description; end608  def does_not_match?(event_proc); end609  def failure_message; end610  def failure_message_when_negated; end611  def from(value); end612  def initialize(receiver = nil, message = nil, &block); end613  def matches?(event_proc); end614  def negative_failure_reason; end615  def perform_change(event_proc); end616  def positive_failure_reason; end617  def raise_block_syntax_error; end618  def supports_block_expectations?; end619  def to(value); end620end621class RSpec::Matchers::BuiltIn::ChangeRelatively < RSpec::Matchers::BuiltIn::BaseMatcher622  def description; end623  def does_not_match?(_event_proc); end624  def failure_message; end625  def failure_reason; end626  def initialize(change_details, expected_delta, relativity, &comparer); end627  def matches?(event_proc); end628  def supports_block_expectations?; end629end630class RSpec::Matchers::BuiltIn::SpecificValuesChange < RSpec::Matchers::BuiltIn::BaseMatcher631  def after_value_failure; end632  def before_value_failure; end633  def description; end634  def did_change_failure; end635  def did_not_change_failure; end636  def failure_message; end637  def initialize(change_details, from, to); end638  def matches?(event_proc); end639  def matches_after?; end640  def not_given_a_block_failure; end641  def perform_change(event_proc); end642  def supports_block_expectations?; end643end644class RSpec::Matchers::BuiltIn::ChangeFromValue < RSpec::Matchers::BuiltIn::SpecificValuesChange645  def change_description; end646  def does_not_match?(event_proc); end647  def failure_message_when_negated; end648  def initialize(change_details, expected_before); end649  def to(value); end650end651class RSpec::Matchers::BuiltIn::ChangeToValue < RSpec::Matchers::BuiltIn::SpecificValuesChange652  def change_description; end653  def does_not_match?(_event_proc); end654  def from(value); end655  def initialize(change_details, expected_after); end656end657class RSpec::Matchers::BuiltIn::ChangeDetails658  def actual_after; end659  def actual_delta; end660  def changed?; end661  def evaluate_value_proc; end662  def extract_value_block_snippet; end663  def initialize(matcher_name, receiver = nil, message = nil, &block); end664  def message_notation(receiver, message); end665  def perform_change(event_proc); end666  def value_representation; end667end668class RSpec::Matchers::BuiltIn::Compound < RSpec::Matchers::BuiltIn::BaseMatcher669  def compound_failure_message; end670  def description; end671  def diffable?; end672  def diffable_matcher_list; end673  def diffable_matcher_list_for(matcher); end674  def does_not_match?(_actual); end675  def evaluator; end676  def expected; end677  def expects_call_stack_jump?; end678  def indent_multiline_message(message); end679  def initialize(matcher_1, matcher_2); end680  def initialize_copy(other); end681  def match(_expected, actual); end682  def matcher_1; end683  def matcher_1_matches?; end684  def matcher_2; end685  def matcher_2_matches?; end686  def matcher_is_diffable?(matcher); end687  def matcher_supports_block_expectations?(matcher); end688  def supports_block_expectations?; end689end690class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator691  def initialize(actual, *arg1); end692  def matcher_matches?(matcher); end693end694class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator695  def initialize(actual, matcher_1, matcher_2); end696  def inner_matcher_block(outer_args); end697  def matcher_matches?(matcher); end698  def order_block_matchers; end699  def self.matcher_expects_call_stack_jump?(matcher); end700end701class RSpec::Matchers::BuiltIn::Compound::And < RSpec::Matchers::BuiltIn::Compound702  def conjunction; end703  def failure_message; end704  def match(*arg0); end705end706class RSpec::Matchers::BuiltIn::Compound::Or < RSpec::Matchers::BuiltIn::Compound707  def conjunction; end708  def failure_message; end709  def match(*arg0); end710end711class RSpec::Matchers::BuiltIn::ContainExactly < RSpec::Matchers::BuiltIn::BaseMatcher712  def actual_collection_line; end713  def best_solution; end714  def convert_actual_to_an_array; end715  def describe_collection(collection, surface_descriptions = nil); end716  def description; end717  def expected_collection_line; end718  def extra_elements_line; end719  def extra_items; end720  def failure_message; end721  def failure_message_when_negated; end722  def generate_failure_message; end723  def match(_expected, _actual); end724  def match_when_sorted?; end725  def message_line(prefix, collection, surface_descriptions = nil); end726  def missing_elements_line; end727  def missing_items; end728  def pairings_maximizer; end729  def safe_sort(array); end730  def to_a_disallowed?(object); end731end732class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer733  def actual_to_expected_matched_indexes; end734  def apply_pairing_to(indeterminates, original_matches, other_list_index); end735  def best_solution_for_pairing(expected_index, actual_index); end736  def categorize_indexes(indexes_to_categorize, other_indexes); end737  def expected_to_actual_matched_indexes; end738  def find_best_solution; end739  def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end740  def reciprocal_single_match?(matches, index, other_list); end741  def solution; end742end743class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < Struct744  def +(derived_candidate_solution); end745  def candidate?; end746  def ideal?; end747  def indeterminate_actual_indexes; end748  def indeterminate_actual_indexes=(_); end749  def indeterminate_expected_indexes; end750  def indeterminate_expected_indexes=(_); end751  def self.[](*arg0); end752  def self.inspect; end753  def self.members; end754  def self.new(*arg0); end755  def unmatched_actual_indexes; end756  def unmatched_actual_indexes=(_); end757  def unmatched_expected_indexes; end758  def unmatched_expected_indexes=(_); end759  def unmatched_item_count; end760  def worse_than?(other); end761end762class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution763  def self.worse_than?(_other); end764end765class RSpec::Matchers::BuiltIn::Cover < RSpec::Matchers::BuiltIn::BaseMatcher766  def does_not_match?(range); end767  def initialize(*expected); end768  def matches?(range); end769end770class RSpec::Matchers::BuiltIn::StartOrEndWith < RSpec::Matchers::BuiltIn::BaseMatcher771  def description; end772  def failure_message; end773  def initialize(*expected); end774  def match(_expected, actual); end775  def subsets_comparable?; end776end777class RSpec::Matchers::BuiltIn::StartWith < RSpec::Matchers::BuiltIn::StartOrEndWith778  def element_matches?; end779  def subset_matches?; end780end781class RSpec::Matchers::BuiltIn::EndWith < RSpec::Matchers::BuiltIn::StartOrEndWith782  def element_matches?; end783  def subset_matches?; end784end785class RSpec::Matchers::BuiltIn::Eq < RSpec::Matchers::BuiltIn::BaseMatcher786  def description; end787  def diffable?; end788  def failure_message; end789  def failure_message_when_negated; end790  def match(expected, actual); end791end792class RSpec::Matchers::BuiltIn::Eql < RSpec::Matchers::BuiltIn::BaseMatcher793  def diffable?; end794  def failure_message; end795  def failure_message_when_negated; end796  def match(expected, actual); end797end798class RSpec::Matchers::BuiltIn::Equal < RSpec::Matchers::BuiltIn::BaseMatcher799  def actual_inspected; end800  def detailed_failure_message; end801  def diffable?; end802  def expected_is_a_literal_singleton?; end803  def failure_message; end804  def failure_message_when_negated; end805  def inspect_object(o); end806  def match(expected, actual); end807  def simple_failure_message; end808end809class RSpec::Matchers::BuiltIn::Exist < RSpec::Matchers::BuiltIn::BaseMatcher810  def does_not_match?(actual); end811  def failure_message; end812  def failure_message_when_negated; end813  def initialize(*expected); end814  def matches?(actual); end815end816class Anonymous_Struct_13 < Struct817  def actual; end818  def actual=(_); end819  def expected; end820  def expected=(_); end821  def self.[](*arg0); end822  def self.inspect; end823  def self.members; end824  def self.new(*arg0); end825end826class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < Anonymous_Struct_13827  def actual_exists?; end828  def deprecated(predicate, actual); end829  def existence_values; end830  def predicates; end831  def uniq_truthy_values; end832  def valid_test?; end833  def validity_message; end834end835class RSpec::Matchers::BuiltIn::HaveAttributes < RSpec::Matchers::BuiltIn::BaseMatcher836  def actual; end837  def actual_has_attribute?(attribute_key, attribute_value); end838  def cache_all_values; end839  def description; end840  def diffable?; end841  def does_not_match?(actual); end842  def failure_message; end843  def failure_message_when_negated; end844  def formatted_values; end845  def initialize(expected); end846  def matches?(actual); end847  def perform_match(predicate); end848  def respond_to_attributes?; end849  def respond_to_failed; end850  def respond_to_failure_message_or; end851  def respond_to_matcher; end852end853module RSpec::Matchers::BuiltIn::CountExpectation854  def at_least(number); end855  def at_most(number); end856  def count_constraint_to_number(n); end857  def count_expectation_description; end858  def count_expectation_type; end859  def count_failure_reason(action); end860  def cover?(count, number); end861  def exactly(number); end862  def expected_count; end863  def expected_count_matches?(actual_count); end864  def has_expected_count?; end865  def human_readable_count(count); end866  def human_readable_expectation_type; end867  def once; end868  def raise_impossible_count_expectation(count); end869  def raise_unsupported_count_expectation; end870  def set_expected_count(relativity, n); end871  def thrice; end872  def times; end873  def twice; end874  def unsupported_count_expectation?(relativity); end875end876class RSpec::Matchers::BuiltIn::Include < RSpec::Matchers::BuiltIn::BaseMatcher877  def actual_collection_includes?(expected_item); end878  def actual_hash_has_key?(expected_key); end879  def actual_hash_includes?(expected_key, expected_value); end880  def check_actual?(actual); end881  def check_expected_count?; end882  def comparing_hash_keys?(expected_item); end883  def comparing_hash_to_a_subset?(expected_item); end884  def convert_to_hash?(obj); end885  def count_enumerable(expected_item); end886  def count_inclusions; end887  def description; end888  def diff_would_wrongly_highlight_matched_item?; end889  def diffable?; end890  def does_not_match?(actual); end891  def excluded_from_actual; end892  def expected; end893  def expecteds; end894  def failure_message; end895  def failure_message_when_negated; end896  def format_failure_message(preposition); end897  def initialize(*expecteds); end898  def matches?(actual); end899  def perform_match(&block); end900  def readable_list_of(items); end901  include RSpec::Matchers::BuiltIn::CountExpectation902end903class RSpec::Matchers::BuiltIn::All < RSpec::Matchers::BuiltIn::BaseMatcher904  def add_new_line_if_needed(message); end905  def description; end906  def does_not_match?(_actual); end907  def failed_objects; end908  def failure_message; end909  def failure_message_for_item(index, failure_message); end910  def indent_multiline_message(message); end911  def index_failed_objects; end912  def initialize(matcher); end913  def initialize_copy(other); end914  def iterable?; end915  def match(_expected, _actual); end916  def matcher; end917end918class RSpec::Matchers::BuiltIn::Match < RSpec::Matchers::BuiltIn::BaseMatcher919  def can_safely_call_match?(expected, actual); end920  def description; end921  def diffable?; end922  def initialize(expected); end923  def match(expected, actual); end924  def match_captures(expected, actual); end925  def with_captures(*captures); end926end927class RSpec::Matchers::BuiltIn::ReliableMatchData928  def captures; end929  def initialize(match_data); end930  def match_data; end931  def names; end932end933class RSpec::Matchers::BuiltIn::OperatorMatcher934  def !=(_expected); end935  def !~(_expected); end936  def <(expected); end937  def <=(expected); end938  def ==(expected); end939  def ===(expected); end940  def =~(expected); end941  def >(expected); end942  def >=(expected); end943  def description; end944  def eval_match(actual, operator, expected); end945  def fail_with_message(message); end946  def has_non_generic_implementation_of?(op); end947  def initialize(actual); end948  def self.get(klass, operator); end949  def self.register(klass, operator, matcher); end950  def self.registry; end951  def self.unregister(klass, operator); end952  def self.use_custom_matcher_or_delegate(operator); end953end954class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher955  def __delegate_operator(actual, operator, expected); end956end957class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher958  def __delegate_operator(actual, operator, expected); end959end960class RSpec::Matchers::BuiltIn::Output < RSpec::Matchers::BuiltIn::BaseMatcher961  def actual_output_description; end962  def captured?; end963  def description; end964  def diffable?; end965  def does_not_match?(block); end966  def failure_message; end967  def failure_message_when_negated; end968  def initialize(expected); end969  def matches?(block); end970  def negative_failure_reason; end971  def positive_failure_reason; end972  def supports_block_expectations?; end973  def to_stderr; end974  def to_stderr_from_any_process; end975  def to_stdout; end976  def to_stdout_from_any_process; end977end978module RSpec::Matchers::BuiltIn::NullCapture979  def self.capture(_block); end980  def self.name; end981end982module RSpec::Matchers::BuiltIn::CaptureStdout983  def self.capture(block); end984  def self.name; end985end986module RSpec::Matchers::BuiltIn::CaptureStderr987  def self.capture(block); end988  def self.name; end989end990class Anonymous_Struct_14 < Struct991  def name; end992  def name=(_); end993  def self.[](*arg0); end994  def self.inspect; end995  def self.members; end996  def self.new(*arg0); end997  def stream; end998  def stream=(_); end999end1000class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < Anonymous_Struct_141001  def capture(block); end1002end1003class RSpec::Matchers::BuiltIn::RaiseError1004  def block_matches?; end1005  def description; end1006  def does_not_match?(given_proc); end1007  def error_and_message_match?; end1008  def eval_block; end1009  def expectation_matched?; end1010  def expected_error; end1011  def expecting_specific_exception?; end1012  def expects_call_stack_jump?; end1013  def failure_message; end1014  def failure_message_when_negated; end1015  def format_backtrace(backtrace); end1016  def given_error; end1017  def handle_warning(message); end1018  def initialize(expected_error_or_message, expected_message, &block); end1019  def matches?(given_proc, negative_expectation = nil, &block); end1020  def raise_message_already_set; end1021  def ready_to_eval_block?; end1022  def supports_block_expectations?; end1023  def verify_message; end1024  def warn_about_bare_error!; end1025  def warn_about_bare_error?; end1026  def warn_about_negative_false_positive!(expression); end1027  def warn_about_nil_error!; end1028  def warn_about_nil_error?; end1029  def warn_for_negative_false_positives!; end1030  def warning; end1031  def with_message(expected_message); end1032  include RSpec::Matchers::Composable1033end1034class RSpec::Matchers::BuiltIn::RespondTo < RSpec::Matchers::BuiltIn::BaseMatcher1035  def and_any_keywords; end1036  def and_keywords(*keywords); end1037  def and_unlimited_arguments; end1038  def argument; end1039  def arguments; end1040  def description; end1041  def does_not_match?(actual); end1042  def failure_message; end1043  def failure_message_when_negated; end1044  def find_failing_method_names(actual, filter_method); end1045  def ignoring_method_signature_failure!; end1046  def initialize(*names); end1047  def matches?(actual); end1048  def matches_arity?(actual, name); end1049  def pp_names; end1050  def with(n); end1051  def with_any_keywords; end1052  def with_arity; end1053  def with_arity_string; end1054  def with_keywords(*keywords); end1055  def with_keywords_string; end1056  def with_unlimited_arguments; end1057end1058class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck1059  def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end1060  def matches?(actual, name); end1061  def method_signature_for(actual, name); end1062  def verifier_for(actual, name); end1063end1064class RSpec::Matchers::BuiltIn::Satisfy < RSpec::Matchers::BuiltIn::BaseMatcher1065  def block_representation; end1066  def description; end1067  def extract_block_snippet; end1068  def failure_message; end1069  def failure_message_when_negated; end1070  def initialize(description = nil, &block); end1071  def matches?(actual, &block); end1072end1073class RSpec::Matchers::BuiltIn::ThrowSymbol1074  def actual_result; end1075  def caught; end1076  def description; end1077  def does_not_match?(given_proc); end1078  def expected(symbol_desc = nil); end1079  def expects_call_stack_jump?; end1080  def failure_message; end1081  def failure_message_when_negated; end1082  def initialize(expected_symbol = nil, expected_arg = nil); end1083  def matches?(given_proc); end1084  def supports_block_expectations?; end1085  def throw_description(symbol, arg); end1086  include RSpec::Matchers::Composable1087end1088class RSpec::Matchers::BuiltIn::YieldProbe1089  def assert_used!; end1090  def assert_valid_expect_block!; end1091  def has_block?; end1092  def initialize(block, &callback); end1093  def num_yields; end1094  def num_yields=(arg0); end1095  def probe; end1096  def self.probe(block, &callback); end1097  def single_yield_args; end1098  def to_proc; end1099  def yielded_args; end1100  def yielded_args=(arg0); end1101  def yielded_once?(matcher_name); end1102end1103class RSpec::Matchers::BuiltIn::YieldControl < RSpec::Matchers::BuiltIn::BaseMatcher1104  def does_not_match?(block); end1105  def failure_message; end1106  def failure_message_when_negated; end1107  def failure_reason; end1108  def matches?(block); end1109  def supports_block_expectations?; end1110  include RSpec::Matchers::BuiltIn::CountExpectation1111end1112class RSpec::Matchers::BuiltIn::YieldWithNoArgs < RSpec::Matchers::BuiltIn::BaseMatcher1113  def does_not_match?(block); end1114  def failure_message; end1115  def failure_message_when_negated; end1116  def matches?(block); end1117  def negative_failure_reason; end1118  def positive_failure_reason; end1119  def supports_block_expectations?; end1120end1121class RSpec::Matchers::BuiltIn::YieldWithArgs < RSpec::Matchers::BuiltIn::BaseMatcher1122  def all_args_match?; end1123  def args_currently_match?; end1124  def description; end1125  def does_not_match?(block); end1126  def expected_arg_description; end1127  def failure_message; end1128  def failure_message_when_negated; end1129  def initialize(*args); end1130  def matches?(block); end1131  def negative_failure_reason; end1132  def positive_failure_reason; end1133  def supports_block_expectations?; end1134end1135class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < RSpec::Matchers::BuiltIn::BaseMatcher1136  def description; end1137  def does_not_match?(block); end1138  def expected_arg_description; end1139  def failure_message; end1140  def failure_message_when_negated; end1141  def initialize(*args); end1142  def matches?(block); end1143  def negative_failure_reason; end1144  def positive_failure_reason; end1145  def supports_block_expectations?; end1146end...

initialize

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) }4  it { is_expected.to be_a_multiple_of(3) }5  it { is_expected.to be_a_multiple_of(3) }6  it { is_expected.to be_a_multiple_of(3) }

initialize

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) }4  it { is_expected.to be_a_multiple_of(3) }5  it { is_expected.to be_a_multiple_of(3) }

initialize

Using AI Code Generation

1    expect(str1).to equal_string(str2)2Finished in 0.0002 seconds (files took 0.10241 seconds to load)3    expect(str1).to equal_string(str2)4Finished in 0.0002 seconds (files took 0.10241 seconds to load)5    expect(str1).to equal_string(str2)6Finished in 0.0002 seconds (files took 0.10241 seconds to load)

initialize

Using AI Code Generation

1        expect { RSpec::Matchers.initialize }.to output("RSpec::Matchers is initialized").to_stdout2        expect { RSpec::Matchers.new }.to output("RSpec::Matchers is initialized").to_stdout3        expect { RSpec::Matchers.new }.to output("RSpec::Matchers is initialized").to_stdout4     Failure/Error: expect { RSpec::Matchers.new }.to output("RSpec::Matchers is initialized").to_stdout5Finished in 0.00664 seconds (files took 0.16644 seconds to load)6        expect { RSpec::Matchers.new }.to output("RSpec::Matchers is initialized").to_stdout7     Failure/Error: expect { RSpec::Matchers.new }.to output("RSpec::Matchers is initialized").to_stdout

initialize

Using AI Code Generation

1RSpec::Matchers.new("test").my_method2RSpec::Matchers.my_method("test")3RSpec::Matchers.new.my_method("test")4RSpec::Matchers.my_method("test")5RSpec::Matchers.new.my_method("test")6RSpec::Matchers.my_method("test")7RSpec::Matchers.new.my_method("test")8RSpec::Matchers.my_method("test")9RSpec::Matchers.new.my_method("test")10RSpec::Matchers.my_method("test")11RSpec::Matchers.new.my_method("test")12RSpec::Matchers.my_method("test")13RSpec::Matchers.new.my_method("test")

initialize

Using AI Code Generation

1 expect(Foo.new).to be_a Foo2 expect(Foo.new).to be_a(Foo)3 expect(Foo.new).to be_a Foo

initialize

Using AI Code Generation

1    expect(str1).to equal_string(str2)2Finished in 0.0002 seconds (files took 0.10241 seconds to load)3    expect(str1).to equal_string(str2)4Finished in 0.0002 seconds (files took 0.10241 seconds to load)5    expect(str1).to equal_string(str2)6Finished in 0.0002 seconds (files took 0.10241 seconds to load)

initialize

Using AI Code Generation

1        expect { RSpec::Matchers.initialize }.to output("RSpec::Matchers is initialized").to_stdout2        expect { RSpec::Matchers.new }.to output("RSpec::Matchers is initialized").to_stdout3        expect { RSpec::Matchers.new }.to output("RSpec::Matchers is initialized").to_stdout4     Failure/Error: expect { RSpec::Matchers.new }.to output("RSpec::Matchers is initialized").to_stdout5Finished in 0.00664 seconds (files took 0.16644 seconds to load)6        expect { RSpec::Matchers.new }.to output("RSpec::Matchers is initialized").to_stdout7     Failure/Error: expect { RSpec::Matchers.new }.to output("RSpec::Matchers is initialized").to_stdout

initialize

Using AI Code Generation

1RSpec::Matchers.new("test").my_method2RSpec::Matchers.my_method("test")3RSpec::Matchers.new.my_method("test")4RSpec::Matchers.my_method("test")5RSpec::Matchers.new.my_method("test")6RSpec::Matchers.my_method("test")7RSpec::Matchers.new.my_method("test")8RSpec::Matchers.my_method("test")9RSpec::Matchers.new.my_method("test")10RSpec::Matchers.my_method("test")11RSpec::Matchers.new.my_method("test")12RSpec::Matchers.my_method("test")13RSpec::Matchers.new.my_method("test")

initialize

Using AI Code Generation

1    expect(str1).to equal_string(str2)2Finished in 0.0002 seconds (files took 0.10241 seconds to load)3    expect(str1).to equal_string(str2)4Finished in 0.0002 seconds (files took 0.10241 seconds to load)5    expect(str1).to equal_string(str2)6Finished in 0.0002 seconds (files took 0.10241 seconds to load)

initialize

Using AI Code Generation

1RSpec::Matchers.new("test").my_method2RSpec::Matchers.my_method("test")3RSpec::Matchers.new.my_method("test")4RSpec::Matchers.my_method("test")5RSpec::Matchers.new.my_method("test")6RSpec::Matchers.my_method("test")7RSpec::Matchers.new.my_method("test")8RSpec::Matchers.my_method("test")9RSpec::Matchers.new.my_method("test")10RSpec::Matchers.my_method("test")11RSpec::Matchers.new.my_method("test")12RSpec::Matchers.my_method("test")13RSpec::Matchers.new.my_method("test")

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.