gistfile1.txt

build@build104:/mnt/repos/dchelimsky/rspec$ rake
(in /mnt/repos/dchelimsky/rspec)
Autotest::Rspecdiscovery
  adds the rspec autotest plugin
failed_results_re
  should match a failure
  should match a failure when matcher outputs multiple lines
  should match an Error
  should match an Error that doesn't end in Error
Autotest::Rspec
  adding spec.opts --options
    should return the command line option to add spec.opts if the options file exists
    should return an empty string if no spec.opts exists
  commands
    should make the appropriate test command
    should return a blank command for no files
  mappings
    should find the spec file for a given lib file
    should find the spec file if given a spec file
    should ignore files in spec dir that aren't specs
    should ignore untracked files (in @file)
  consolidating failures
    should return no failures if no failures were given in the output
    should return a hash with the spec filename => spec name for each failure or error
    should not include the subject file
  normalizing file names
    should ensure that a single file appears in files_to_test only once
ExampleGroupMethods
  #describe
    when creating an ExampleGroup
      should create a subclass of the ExampleGroup when passed a block
      should not inherit examples
      records the spec path
    when creating an example group with no description
      raises an ArgumentError
    when creating a SharedExampleGroup
      should create a SharedExampleGroup
  #context
    when creating an ExampleGroup
      should create a subclass of the ExampleGroup when passed a block
      should not inherit examples
      records the spec path
    when creating an example group with no description
      raises an ArgumentError
    when creating a SharedExampleGroup
      should create a SharedExampleGroup
  #example
    should add an example
    with no location supplied
      creates an ExampleProxy
        with a description
        with options
        with a default backtrace (DEPRECATED)
        with a default location
    with a location supplied
        with the supplied location as #backtrace (DEPRECATED)
        with the supplied location as #location
  #specify
    should add an example
    with no location supplied
      creates an ExampleProxy
        with a description
        with options
        with a default backtrace (DEPRECATED)
        with a default location
    with a location supplied
        with the supplied location as #backtrace (DEPRECATED)
        with the supplied location as #location
  #it
    should add an example
    with no location supplied
      creates an ExampleProxy
        with a description
        with options
        with a default backtrace (DEPRECATED)
        with a default location
    with a location supplied
        with the supplied location as #backtrace (DEPRECATED)
        with the supplied location as #location
  #xexample
    should NOT create an example
    should warn that the example is disabled
  #xit
    should NOT create an example
    should warn that the example is disabled
  #xspecify
    should NOT create an example
    should warn that the example is disabled
  #examples
    should have Examples
    should not include methods that begin with test (only when TU interop is loaded)
    should include methods that begin with should and has an arity of 0 in suite
    should not include methods that begin with test_ and has an arity > 0 in suite
    should not include methods that begin with should_ and has an arity > 0 in suite
    should run should_methods
  #set_description
    given a String
      .description should return the String passed into .set_description
      .described_type should provide nil as its type
    given a Class
      .description should return a String representation of that type (fully qualified) as its name
      .described_type should return the passed in type
    given a String and a Class
      .description should return String then space then Type
      .described_type should return the passed in type
    given a Class and a String (starting with an alpha char)
      .description should return the Type then space then String
    given a Class and a String (starting with a '.')
      .description should return the Type then String
    #set_description(Class, String starting with #)
      should return the Class then String
    #set_description(Class, String containing .)
      .description should return the Type then space then String
    #set_description(Class, String containing #)
      .description should return the Type then space then String
    #set_description(String, Type, String)
      .description should return the first String then space then Type then second String
    #set_description(Hash representing options)
      .location should expand the passed in :location option passed into the constructor
      .options should return all the options passed in
  #description
    should return the same description instance for each call
    should not add a space when description begins with #
    should not add a space when description begins with .
    should return the class name if nil
    should return the class name if nil
    is cached
  #description_parts
    should return an Array of the current class description args
    should return an Array of the description args from each class in the hierarchy
    caches the description parts
  #described_type
    should return passed in type
    should return #described_type of superclass when no passed in type
    is cached per example group
  #include
    should have accessible class methods from included module
  #number_of_examples
    should count number of examples
  #class_eval
    should allow constants to be defined
  #register
    should add ExampleGroup to set of ExampleGroups to be run
  #remove_example_group
    should remove ExampleGroup from set of ExampleGroups to be run
  #run
    given an example group with at least one example
      should call add_example_group
    given an example group with no examples
      should NOT call add_example_group (FAILED - 1)
  #matcher_class=
    should call new and matches? on the class used for matching examples
  #options
    should expose the options hash
  #before
    stores before(:each) blocks
    stores before(:all) blocks
    stores before(:suite) blocks
  #after
    stores after(:each) blocks (FAILED - 2)
    stores after(:all) blocks (FAILED - 3)
    stores after(:suite) blocks
  #run_before_all
    does not create an instance if before_all_parts are empty
  #run_after_all
    does not create an instance if after_all_parts are empty
  #examples_to_run
    runs only the example identified by a line number
    runs the example identified by a line number even if it's not the example line number
    runs all the examples in the group 
    doesn't run any examples in another group
  #let
    generates an instance method
    caches the value (FAILED - 4)
Spec::Example::Pending
  when no block is supplied
    raises an ExamplePendingError if no block is supplied
  when the supplied block fails
    raises an ExamplePendingError if a supplied block fails as expected
  when the supplied block fails with a mock
    raises an ExamplePendingError if a supplied block fails as expected with a mock
  when the supplied block passes
    raises a PendingExampleFixedError
Spec::Example::ExamplePendingError
  should have the message provided
Spec::Example::NotYetImplementedError
  should have the message 'Not Yet Implemented'
Spec::Example::ExampleGroupFactory
  #get
    should return the default ExampleGroup type for nil
    should return the default ExampleGroup for an unregistered non-nil value
    should return custom type if registered
    should get the custom type after setting the default
  #create_example_group
    should create a uniquely named class
    should create a Spec::Example::Example subclass by default
    should raise when no description is given
    should raise when no block is given
    should run registered ExampleGroups
    should not run unregistered ExampleGroups
    should create a type indicated by :location
    should create a type indicated by :location (with location generated by caller on windows)
    should create a type indicated by location for a path-like key
    should use the longest key that matches when creating a type indicated by location
    should favor the :type over the :location
    should register ExampleGroup by default
    should enable unregistering of ExampleGroups
    with :type => :default
      should create a Spec::Example::ExampleGroup
    with :type => :something_other_than_default
      should create the specified type
    with :shared => true
      should create and register a Spec::Example::SharedExampleGroup
  #create_shared_example_group
    registers a new shared example group
a helper method
  is available to examples in the same group
  from a nested group
    is available to examples in a nested group
predicate_matcher[method_on_object] = matcher_method
  is deprecated
  should match matcher_method if method_on_object returns true
  should not match matcher_method if method_on_object returns false
can access instance variables defined before(:each)
can access class variables (Ruby 1.8 only)
can access constants
can access methods defined in the Example Group
Spec::Example::ExampleGroupSubclass
  should run
Spec::Example::ExampleMatcher#matches?
  should match correct example_group and example
  should not match wrong example
  should not match wrong example_group
  should match example only
  should match example_group only
  should match example_group ending with before(:all)
  should escape regexp chars
  should match when example_group is modularized
Spec::Example::ExampleMatcher#matches? normal case
  matches when passed in example matches
  does not match when no passed in examples match
Spec::Example::ExampleMatcher#matches? where description has '::' in it
  matches when passed in example matches
  does not match when no passed in examples match
Spec::Example::ExampleMatchercalled with nil example
  does not puke
Spec::Example::ExampleMethods
  with an included module that is reopened
    should have reopened methods
  #should
    in an ExampleGroup with an implicit subject
      delegates matcher to the implied subject
    in an ExampleGroup using an explicit subject
      delegates matcher to the declared subject
    in an ExampleGroup using 'self' as an explicit subject
      delegates matcher to the ExampleGroup
  #should_not
    in an ExampleGroup with an implicit subject
      delegates matcher to the implied subject
    in an ExampleGroup using an explicit subject
      delegates matcher to the declared subject
    in an ExampleGroup using 'self' as an explicit subject
      delegates matcher to the ExampleGroup
#options
  should expose the options hash
#set_instance_variables_from_hash
  preserves the options
#description
  returns the supplied description
  returns the generated description if there is no description supplied
  warns if there is no supplied or generated description
#expect
  aliases #should with #to on the proc
  aliases #should_not with #to_not on the proc
Spec::Example::ExampleProxy
  #description
    provides the submitted description
  #update
    updates the description
  #options
    provides the submitted options
  #backtrace (DEPRECATED - use #location)
    is deprecated
    provides the location of the declaration of this group
  #location
    provides the location of the declaration of this group
Spec::Example::ExampleGroupvia a class definition
  should understand module scoping
  can access class variables in examples in Ruby 1.8
  can NOT access class variables in examples in Ruby 1.9
Spec::Example::ExampleGroupvia a class definition without a class variable
  should not retain class variables from other Example classes
Spec::Example::ExampleGroup#pending
  should raise a Pending error when its block fails
  should raise Spec::Example::PendingExampleFixedError when its block does not fail
Spec::Example::ExampleGroup#run
  should not run when there are no examples
  should report the start of an example run
  should report the end of an example run
  when before_each fails
    should not run example block
    should run after_each
    should report failure location when in before_each
  Spec::Example::ExampleGroup#run on dry run
    should not run before(:all) or after(:all)
    should not run example
  Spec::Example::ExampleGroup#run with specified examples
    when specified_examples matches entire ExampleGroup
      should not run the Examples in the ExampleGroup
    Spec::Example::ExampleGroup#run when specified_examples matches only Example description
      should not run the example
    Spec::Example::ExampleGroup#run when specified_examples does not match an Example description
      should not run the example
    Spec::Example::ExampleGroup#run when specified_examples matches an Example description
      should run only the example
  Spec::Example::ExampleGroup#run with success
    should send reporter example_group_started
    should run example on run
    should run before(:all) block only once
    should run after(:all) block only once
    after(:all) should have access to all instance variables defined in before(:all)
    should copy instance variables from before(:all)'s execution context into spec's execution context
    should not add global before callbacks for untargetted example_group
    should add global before callbacks for targetted example_groups
    should order before callbacks from global to local
    should order after callbacks from local to global
    should have accessible instance methods from included module
    should include targetted modules included using configuration
  Spec::Example::ExampleGroup#run with pending example that has a failing assertion
    should send example_pending to formatter
  Spec::Example::ExampleGroup#run with pending example that does not have a failing assertion
    should add an example failure to the TestResult
    should send example_pending to formatter
  Spec::Example::ExampleGroup#run when before(:all) fails
    should add an example failure to the TestResult
    should not run any example
    should run ExampleGroup after(:all)
    should run example_group after(:all)
    should supply before(:all) as description
  Spec::Example::ExampleGroup#run when before(:each) fails
    should add an example failure to the TestResult
    should run after(:all)
  Spec::Example::ExampleGroup#run when any example fails
    should add an example failure to the TestResult
    should run after(:all)
  Spec::Example::ExampleGroup#run when first after(:each) block fails
    should add an example failure to the TestResult
    should run second after(:each) block
  Spec::Example::ExampleGroup#run when first before(:each) block fails
    should add an example failure to the TestResult
    should not run second before(:each)
  Spec::Example::ExampleGroup#run when failure in after(:all)
    should add an example failure to the TestResult
    should return false
Spec::Example::ExampleGroupsubclasses
  should have access to the described_type
  should concat descriptions when nested
Spec::Example::ExampleGroupProxy
  #description
    provides the example group's description
  #nested_descriptions
    provides the example group's nested_descriptions
  #filtered_description (DEPRECATED)
    is deprecated
    builds the description from the group's nested_descriptions
    filters out description parts that match the supplied regexp
  #examples
    provides a collection of example group proxies
  #backtrace (deprecated - use #location)
    provides the location of the declaration of this group
    warns deprecation
  #location
    provides the location of the declaration of this group
  #options
    provides the options passed to the example group declaration
    excludes :location
    excludes :scope
    preserves the original hash
implicit subject
  with a class
    returns an instance of the class
  with a Module
    returns the Module
  with a string
    return the string
  with a number
    returns the number
explicit subject
  defined in a top level group
    replaces the implicit subject in that group
    is available in a nested group (subclass)
    is available in a doubly nested group (subclass)
.its (to access subject's attributes)
  passes when expectation should pass
  fails when expectation should fail
Spec::Example::ExampleGroupwith :shared => true
  complains when adding a second shared example_group with the same description
  does NOT add the same group twice
  does NOT complain when adding the same shared example_group again (i.e. file gets reloaded)
  does NOT complain when adding the same shared example_group in same file with different absolute path
  complains when adding a different shared example_group with the same name in a different file with the same basename
  adds examples to current example_group using it_should_behave_like
  adds examples to from two shared groups
  adds examples to current example_group using include
  adds examples to current example_group using it_should_behave_like with a module
  runs shared examples
  runs before(:each) and after(:each) from shared example_group
  should run before(:all) and after(:all) only once from shared example_group
  should include modules, included into shared example_group, into current example_group
  should make methods defined in the shared example_group available in consuming example_group
  should raise when named shared example_group can not be found
  #register
    creates a new shared example group with the submitted args
    registers the shared example group
Grandparent ExampleGroup
  Parent ExampleGroup
    should bar
    Child ExampleGroup
      should bam
Nested Example Groups
  should run before(:all), before(:each), example, after(:each), after(:all) in order
  nested example group
    should run all before and after callbacks
  description options
    includes :location
    includes any other options
The bin/spec script
  should have no warnings (FAILED - 5)
  should show the help w/ no args
Object#should
  accepts and interacts with a matcher
  asks for a failure_message_for_should when matches? returns false
Object#should_not
  accepts and interacts with a matcher
  asks for a failure_message_for_should_not when matches? returns true
Diff
  should output unified diff of two strings
  should output unified diff message of two arrays
  should output a friendly message if comparing simple hashes
  should output a friendly message if comparing simple hashes that contain different keys
  should output diff message if the hash is complex (containing Array or Hash)
  should output unified diff message of two objects
Diff in context format
  should output unified diff message of two objects
Spec::Expectations::PositiveExpectationHandler
  #handle_matcher
    asks the matcher if it matches
    returns the match value
    calls failure_message_for_should if the matcher implements it
    calls fail if matcher.diffable?
    calls failure_message if the matcher does not implement failure_message_for_should
    appends the :or message in the options hash passed to should
Spec::Expectations::NegativeExpectationHandler
    asks the matcher if it doesn't match when the matcher responds to #does_not_match?
    asks the matcher if it matches when the matcher doesn't respond to #does_not_match?
    returns the match value
    calls failure_message_for_should_not if the matcher implements it
    calls negative_failure_message if the matcher does not implement failure_message_for_should_not
    calls fail if matcher.diffable?
    appends the :or message in the options hash passed to should
Spec::Expectations::PositiveExpectationHandler
  should handle submitted args
  should handle the submitted block
wrap_expectation
  should return true if there is no error
  should return false if there is an error
Spec::Expectations#fail_with with no diff
  should handle just a message
Spec::Expectations#fail_with with Array
  is deprecated
Spec::Expectations#fail_with with diff
  should not call differ if no expected/actual
  should call differ if expected/actual are presented separately
  should call differ if expected/actual are not strings
  should call differ if expected/actual are both hashes
  should not call differ if expected or actual are procs
Spec::Expectations#fail_with with a nil message
  should handle just a message
Spec::Rake::SpecTask
  should execute rake's ruby path by default
  should execute the command with system if ruby_cmd is specified
  should execute the ruby_cmd path if specified
  should produce a deprecation warning if the out option is used
  should produce an error if failure_message is set and the command fails
  should raise if fail_on_error is set and the command fails
  should not raise if fail_on_error is not set and the command fails
  with ENV['SPEC'] set
    should use the provided file list
  with the rcov option
    should create a clobber_rcov task
    should setup the clobber_rcov task to remove the rcov directory
    should make the clobber task depend on clobber_rcov
    should make the rcov task depend on clobber_rcov
    creates an rcov options list
Test::Unit::TestCase
  should find all Test::Unit test methods (FAILED - 6)
  with passing test case
    should output 0 failures
    should return an exit code of 0
  with failing test case
    should output 1 failure
    should return an exit code of 256 (FAILED - 7)
  with test case that raises an error
    should output 1 failure
    should return an exit code of 256
ExampleGroup with test/unit/interop
  with passing examples
    should output 0 failures (FAILED - 8)
    should return an exit code of 0
  with failing examples
    should output 1 failure (FAILED - 9)
    should return an exit code of 256
  with example that raises an error
    should output 1 failure
    should return an exit code of 256 (FAILED - 10)
  options hash
    should be exposed (FAILED - 11)
TestSuiteAdapter
  should pass
Spec::Runner
  .configure
    should yield global configuration
Spec::DSL::Main
  #describe
    should delegate to Spec::Example::ExampleGroupFactory.create_example_group
    raises with no description
  #context
    should delegate to Spec::Example::ExampleGroupFactory.create_example_group
    raises with no description
  #share_examples_for
    should create a shared ExampleGroup
  #shared_examples_for
    should create a shared ExampleGroup
  #describe; with RUBY_VERSION = 1.9
    includes an enclosing module into the block's scope
  #share_as
    registers a shared ExampleGroup
    creates a constant that points to a Module
    complains if you pass it a not-constantizable name
should change(actual, message)
  should pass when actual is modified by the block
  should fail when actual is not modified by the block
  provides a #description
should_not change(actual, message)
  should pass when actual is not modified by the block
  should fail when actual is not modified by the block
should change { block }
  should pass when actual is modified by the block
  should fail when actual is not modified by the block
  should warn if passed a block using do/end instead of {}
  provides a #description
should_not change { block }
  should pass when actual is modified by the block
  should fail when actual is not modified by the block
  should warn if passed a block using do/end instead of {}
should change(actual, message).by(expected)
  should pass when attribute is changed by expected amount
  should fail when the attribute is changed by unexpected amount
  should fail when the attribute is changed by unexpected amount in the opposite direction
should change{ block }.by(expected)
  should pass when attribute is changed by expected amount
  should fail when the attribute is changed by unexpected amount
  should fail when the attribute is changed by unexpected amount in the opposite direction
should change(actual, message).by_at_least(expected)
  should pass when attribute is changed by greater than the expected amount
  should pass when attribute is changed by the expected amount
  should fail when the attribute is changed by less than the expected amount
should change{ block }.by_at_least(expected)
  should pass when attribute is changed by greater than expected amount
  should pass when attribute is changed by the expected amount
  should fail when the attribute is changed by less than the unexpected amount
should change(actual, message).by_at_most(expected)
  should pass when attribute is changed by less than the expected amount
  should pass when attribute is changed by the expected amount
  should fail when the attribute is changed by greater than the expected amount
should change{ block }.by_at_most(expected)
  should pass when attribute is changed by less than expected amount
  should pass when attribute is changed by the expected amount
  should fail when the attribute is changed by greater than the unexpected amount
should change(actual, message).from(old)
  should pass when attribute is == to expected value before executing block
  should fail when attribute is not == to expected value before executing block
should change{ block }.from(old)
  should pass when attribute is == to expected value before executing block
  should fail when attribute is not == to expected value before executing block
should change(actual, message).to(new)
  should pass when attribute is == to expected value after executing block
  should fail when attribute is not == to expected value after executing block
should change{ block }.to(new)
  should pass when attribute is == to expected value after executing block
  should fail when attribute is not == to expected value after executing block
should change(actual, message).from(old).to(new)
  should pass when #to comes before #from
  should pass when #from comes before #to
  should show the correct messaging when #after and #to are different
  should show the correct messaging when #before and #from are different
should change{ block }.from(old).to(new)
  should pass when #to comes before #from
  should pass when #from comes before #to
Spec::Matchers::Change
  should work when the receiver has implemented #send
should ==
  should delegate message to target
  should return true on success
  should fail when target.==(actual) returns false
should_not ==
  should delegate message to target
  should return true on success
  should fail when target.==(actual) returns false
should ===
  should delegate message to target
  should fail when target.===(actual) returns false
should_not ===
  should delegate message to target
  should fail when target.===(actual) returns false
should =~
  should delegate message to target
  should fail when target.=~(actual) returns false
should_not =~
  should delegate message to target
  should fail when target.=~(actual) returns false
should >
  should pass if > passes
  should fail if > fails
should >=
  should pass if >= passes
  should fail if > fails
should <
  should pass if < passes
  should fail if > fails
should <=
  should pass if <= passes
  should fail if > fails
Spec::Matchers::PositiveOperatorMatcher
  should work when the target has implemented #send
Spec::Matchers::NegativeOperatorMatcher
  should work when the target has implemented #send
[actual.should] be_close(expected, delta)
  matches when actual == expected
  matches when actual < (expected + delta)
  matches when actual > (expected - delta)
  does not match when actual == (expected - delta)
  does not match when actual < (expected - delta)
  does not match when actual == (expected + delta)
  does not match when actual > (expected + delta)
  provides a failure message for should
  provides a failure message for should tno
  provides a description
Spec::Matchers::Matcher
  is not diffable by default
  is diffable when told to be
  provides expected
  provides actual
  supports helper methods
  supports fluent interface
  treats method missing normally for undeclared methods
  has access to other matchers
  lets you override the actual() in messages
  without overrides
    provides a default description
    provides a default failure message for #should
    provides a default failure message for #should_not
  with overrides
    does not hide result of match block when true
    does not hide result of match block when false
    overrides the description
    overrides the failure message for #should
    overrides the failure message for #should_not
  #new
    passes matches? arg to match block
    exposes arg submitted through #new to matcher block
  with no args
    matches
    describes
  with 1 arg
    matches
    describes
  with multiple args
    matches
    describes
  #match_unless_raises
    with a passing assertion
      passes as you would expect
      fails as you would expect
    with an unexpected error
      raises the error
The Spec::Matchers module gets included in the execution context of every spec.
This module should provide the following methods, each of which returns a Matcher object.
  be_true
  be_false
  be_nil
  be_arbitrary_predicate
  change
  have
  have_exactly
  have_at_least
  have_at_most
  raise_error
  satisfy
  throw_symbol
  respond_to
Spec::Matchers#method_missing
  should convert be_xyz to Be(:be_xyz)
  should convert have_xyz to Has(:have_xyz)
array.should =~ other_array
  should pass if target contains all items
  should pass if target contains all items out of order
  should fail if target includes extra items
  should fail if target is missing items
  should fail if target is missing items and has extra items
  should sort items in the error message if they all respond to <=>
  should not sort items in the error message if they don't all respond to <=>
  should accurately report extra elements when there are duplicates
  should accurately report missing elements when there are duplicates
should_not =~ [:with, :multiple, :args]
  should not be supported
#create
  is deprecated
#define
  creates a method that initializes a new matcher with the submitted name and expected arg
equal
  should match when actual.equal?(expected)
  should not match when !actual.equal?(expected)
  should describe itself
  should provide message on #failure_message
  should provide message on #negative_failure_message
actual.should be_a_kind_of(expected)
  passes if actual is instance of expected class
  passes if actual is instance of subclass of expected class
  fails with failure message for should unless actual is kind of expected class
  provides a description
actual.should_not be_a_kind_of(expected)
  fails with failure message for should_not if actual is kind of expected class
actual.should be_kind_of(expected)
  passes if actual is instance of expected class
  passes if actual is instance of subclass of expected class
  fails with failure message for should unless actual is kind of expected class
  provides a description
actual.should_not be_kind_of(expected)
  fails with failure message for should_not if actual is kind of expected class
should have_sym(*args)
  should pass if #has_sym?(*args) returns true
  should fail if #has_sym?(*args) returns false
  should fail if #has_sym?(*args) returns nil
  should fail if target does not respond to #has_sym?
  should reraise an exception thrown in #has_sym?(*args)
should_not have_sym(*args)
  should pass if #has_sym?(*args) returns false
  should pass if #has_sym?(*args) returns nil
  should fail if #has_sym?(*args) returns true
  should fail if target does not respond to #has_sym?
  should reraise an exception thrown in #has_sym?(*args)
should have_sym(&block)
  should pass when actual returns true for :has_sym?(&block)
  should fail when actual returns false for :has_sym?(&block)
  should fail when actual does not respond to :has_sym?
should_not have_sym(&block)
  should pass when actual returns false for :has_sym?(&block)
  should fail when actual returns true for :has_sym?(&block)
  should fail when actual does not respond to :has_sym?
should have_sym(*args, &block)
  should pass when actual returns true for :has_sym?(*args, &block)
  should fail when actual returns false for :has_sym?(*args, &block)
  should fail when actual does not respond to :has_sym?
should_not have_sym(*args, &block)
  should pass when actual returns false for :has_sym?(*args, &block)
  should fail when actual returns true for :has_sym?(*args, &block)
  should fail when actual does not respond to :has_sym?
has
  should work when the target implements #send
Spec::Matchers::ThrowSymbol
  with no args
    matches if any Symbol is thrown
    matches if any Symbol is thrown with an arg
    does not match if no Symbol is thrown
    provides a failure message
    provides a negative failure message
  with a symbol
    matches if correct Symbol is thrown
    matches if correct Symbol is thrown with an arg
    does not match if no Symbol is thrown
    does not match if correct Symbol is thrown
    provides a failure message when no Symbol is thrown
    provides a failure message when wrong Symbol is thrown
    provides a negative failure message
    should only match NameErrors raised by uncaught throws
    bubbles up errors other than NameError
  with a symbol and an arg
    matches if correct Symbol and args are thrown
    does not match if nothing is thrown
    does not match if other Symbol is thrown
    does not match if no arg is thrown
    does not match if wrong arg is thrown
    provides a failure message when no Symbol is thrown
    provides a failure message when wrong Symbol is thrown
    provides a negative failure message
    only matches NameErrors raised by uncaught throws
should raise_error
  should pass if anything is raised
  should fail if nothing is raised
should raise_error {|err| ... }
  passes if there is an error
  passes the error to the block
should_not raise_error
  should pass if nothing is raised
  should fail if anything is raised
should raise_error(message)
  should pass if RuntimeError is raised with the right message
  should pass if RuntimeError is raised with a matching message
  should pass if any other error is raised with the right message
  should fail if RuntimeError error is raised with the wrong message
  should fail if any other error is raised with the wrong message
should_not raise_error(message)
  should pass if RuntimeError error is raised with the different message
  should pass if any other error is raised with the wrong message
  should fail if RuntimeError is raised with message
  should fail if any other error is raised with message
should raise_error(NamedError)
  should pass if named error is raised
  should fail if nothing is raised
  should fail if another error is raised (NameError)
  should fail if another error is raised (NameError)
should_not raise_error(NamedError)
  should pass if nothing is raised
  should pass if another error is raised
  should fail if named error is raised
should raise_error(NamedError, error_message) with String
  should pass if named error is raised with same message
  should fail if nothing is raised
  should fail if incorrect error is raised
  should fail if correct error is raised with incorrect message
should raise_error(NamedError, error_message) { |err| ... }
  should yield exception if named error is raised with same message
  yielded block should be able to fail on it's own right
  should NOT yield exception if no error was thrown
  should not yield exception if error class is not matched
  should NOT yield exception if error message is not matched
should_not raise_error(NamedError, error_message) { |err| ... }
  should pass if nothing is raised
  should pass if a different error is raised
  should pass if same error is raised with different message
  should fail if named error is raised with same message
should_not raise_error(NamedError, error_message) with String
  should pass if nothing is raised
  should pass if a different error is raised
  should pass if same error is raised with different message
  should fail if named error is raised with same message
should raise_error(NamedError, error_message) with Regexp
  should pass if named error is raised with matching message
  should fail if nothing is raised
  should fail if incorrect error is raised
  should fail if correct error is raised with incorrect message
should_not raise_error(NamedError, error_message) with Regexp
  should pass if nothing is raised
  should pass if a different error is raised
  should pass if same error is raised with non-matching message
  should fail if named error is raised with matching message
should satisfy { block }
  should pass if block returns true
  should fail if block returns false
should_not satisfy { block }
  should pass if block returns false
  should fail if block returns true
should respond_to(:sym)
  passes if target responds to :sym
  fails if target does not respond to :sym
should respond_to(:sym).with(1).argument
  passes if target responds to :sym with 1 arg
  fails if target does not respond to :sym
  fails if :sym expects 0 args
  fails if :sym expects 2 args
should respond_to(message1, message2)
  passes if target responds to both messages
  fails if target does not respond to first message
  fails if target does not respond to second message
  fails if target does not respond to either message
should respond_to(:sym).with(2).arguments
  passes if target responds to :sym with 2 args
  fails if target does not respond to :sym
  fails if :sym expects 0 args
  fails if :sym expects 2 args
should_not respond_to(:sym)
  passes if target does not respond to :sym
  fails if target responds to :sym
should exist
  within an example group
    passes if target exists
    passes if target exists with args
    fails if target does not exist
    describes itself
    passes should_not exist if target doesn't exist
  outside of an example group
    should pass if target exists
should be_predicate
  should pass when actual returns true for :predicate?
  should pass when actual returns true for :predicates? (present tense)
  should fail when actual returns false for :predicate?
  should fail when actual returns false for :predicate?
  should fail when actual does not respond to :predicate?
  should fail on error other than NameError
  should fail on error other than NameError (with the present tense predicate)
should_not be_predicate
  should pass when actual returns false for :sym?
  should pass when actual returns nil for :sym?
  should fail when actual returns true for :sym?
  should fail when actual does not respond to :sym?
should be_predicate(*args)
  should pass when actual returns true for :predicate?(*args)
  should fail when actual returns false for :predicate?(*args)
  should fail when actual does not respond to :predicate?
should_not be_predicate(*args)
  should pass when actual returns false for :predicate?(*args)
  should fail when actual returns true for :predicate?(*args)
  should fail when actual does not respond to :predicate?
should be_predicate(&block)
  should pass when actual returns true for :predicate?(&block)
  should fail when actual returns false for :predicate?(&block)
  should fail when actual does not respond to :predicate?
should_not be_predicate(&block)
  should pass when actual returns false for :predicate?(&block)
  should fail when actual returns true for :predicate?(&block)
  should fail when actual does not respond to :predicate?
should be_predicate(*args, &block)
  should pass when actual returns true for :predicate?(*args, &block)
  should fail when actual returns false for :predicate?(*args, &block)
  should fail when actual does not respond to :predicate?
should_not be_predicate(*args, &block)
  should pass when actual returns false for :predicate?(*args, &block)
  should fail when actual returns true for :predicate?(*args, &block)
  should fail when actual does not respond to :predicate?
should be_true
  should pass when actual equal(true)
  should fail when actual equal(false)
should be_false
  should pass when actual equal(false)
  should fail when actual equal(true)
should be_nil
  should pass when actual is nil
  should fail when actual is not nil
should_not be_nil
  should pass when actual is not nil
  should fail when actual is nil
should be <
  should pass when < operator returns true
  should fail when < operator returns false
should be <=
  should pass when <= operator returns true
  should fail when <= operator returns false
should be >=
  should pass when >= operator returns true
  should fail when >= operator returns false
should be >
  should pass when > operator returns true
  should fail when > operator returns false
should be ==
  should pass when == operator returns true
  should fail when == operator returns false
should be ===
  should pass when === operator returns true
  should fail when === operator returns false
should_not with operators
  should coach user to stop using operators with should_not
should be
  should pass if actual is true or a set value
  should fail if actual is false
  should fail if actual is nil
should be(value)
  should pass if actual.equal?(value)
  should fail if !actual.equal?(value)
'should be' with operator
  should include 'be' in the description
arbitrary predicate with DelegateClass
  should access methods defined in the delegating class (LH[#48])
be_a, be_an
  should pass when class matches
  should fail when class does not match
be_an_instance_of
  passes when direct class matches
  fails when class is higher up hierarchy
eql
  should match when actual.eql?(expected)
  should not match when !actual.eql?(expected)
  should describe itself
  should provide message, expected and actual on #failure_message
  should provide message, expected and actual on #negative_failure_message
Spec::Matchers::Be
  called with should
    should have public instance method "failure_message_for_should"
    should have public instance method "failure_message"
  called with should not
    should have public instance method "failure_message_for_should_not"
    should have public instance method "negative_failure_message"
Spec::Matchers::Change
  called with should
    should have public instance method "failure_message_for_should"
    should have public instance method "failure_message"
  called with should not
    should have public instance method "failure_message_for_should_not"
    should have public instance method "negative_failure_message"
Spec::Matchers::Has
  called with should
    should have public instance method "failure_message_for_should"
    should have public instance method "failure_message"
  called with should not
    should have public instance method "failure_message_for_should_not"
    should have public instance method "negative_failure_message"
Spec::Matchers::Have
  called with should
    should have public instance method "failure_message_for_should"
    should have public instance method "failure_message"
  called with should not
    should have public instance method "failure_message_for_should_not"
    should have public instance method "negative_failure_message"
Spec::Matchers::MatchArray
  called with should
    should have public instance method "failure_message_for_should"
    should have public instance method "failure_message"
  called with should not
    should have public instance method "failure_message_for_should_not"
    should have public instance method "negative_failure_message"
Spec::Matchers::Matcher
  called with should
    should have public instance method "failure_message_for_should"
    should have public instance method "failure_message"
  called with should not
    should have public instance method "failure_message_for_should_not"
    should have public instance method "negative_failure_message"
Spec::Matchers::RaiseError
  called with should
    should have public instance method "failure_message_for_should"
    should have public instance method "failure_message"
  called with should not
    should have public instance method "failure_message_for_should_not"
    should have public instance method "negative_failure_message"
Spec::Matchers::RespondTo
  called with should
    should have public instance method "failure_message_for_should"
    should have public instance method "failure_message"
  called with should not
    should have public instance method "failure_message_for_should_not"
    should have public instance method "negative_failure_message"
Spec::Matchers::Satisfy
  called with should
    should have public instance method "failure_message_for_should"
    should have public instance method "failure_message"
  called with should not
    should have public instance method "failure_message_for_should_not"
    should have public instance method "negative_failure_message"
Spec::Matchers::SimpleMatcher
  called with should
    should have public instance method "failure_message_for_should"
    should have public instance method "failure_message"
  called with should not
    should have public instance method "failure_message_for_should_not"
    should have public instance method "negative_failure_message"
Spec::Matchers::ThrowSymbol
  called with should
    should have public instance method "failure_message_for_should"
    should have public instance method "failure_message"
  called with should not
    should have public instance method "failure_message_for_should_not"
    should have public instance method "negative_failure_message"
actual.should be_an_instance_of(expected)
  passes if actual is instance of expected class
  fails if actual is instance of subclass of expected class
  fails with failure message for should unless actual is instance of expected class
  provides a description
actual.should_not be_an_instance_of(expected)
  fails with failure message for should_not if actual is instance of expected class
actual.should be_instance_of(expected)
  passes if actual is instance of expected class
  fails if actual is instance of subclass of expected class
  fails with failure message for should unless actual is instance of expected class
  provides a description
actual.should_not be_instance_of(expected)
  fails with failure message for should_not if actual is instance of expected class
should have(n).items
  should pass if target has a collection of items with n members
  should convert :no to 0
  should fail if target has a collection of items with < n members
  should fail if target has a collection of items with > n members
should have(1).item when ActiveSupport::Inflector is defined
  should pluralize the collection name
should have(1).item when Inflector is defined
  should pluralize the collection name
should have(n).items where result responds to items but returns something other than a collection
  should provide a meaningful error
should_not have(n).items
  should pass if target has a collection of items with < n members
  should pass if target has a collection of items with > n members
  should fail if target has a collection of items with n members
should have_exactly(n).items
  should pass if target has a collection of items with n members
  should convert :no to 0
  should fail if target has a collection of items with < n members
  should fail if target has a collection of items with > n members
should have_at_least(n).items
  should pass if target has a collection of items with n members
  should pass if target has a collection of items with > n members
  should fail if target has a collection of items with < n members
  should provide educational negative failure messages
should have_at_most(n).items
  should pass if target has a collection of items with n members
  should fail if target has a collection of items with > n members
  should pass if target has a collection of items with < n members
  should provide educational negative failure messages
have(n).items(args, block)
  should pass args to target
  should pass block to target
have(n).items where target IS a collection
  should reference the number of items IN the collection
  should fail when the number of items IN the collection is not as expected
have(n).characters where target IS a String
  should pass if the length is correct
  should fail if the length is incorrect
have(n).things on an object which is not a collection nor contains one
  should fail
Spec::Matchers::Havefor a collection owner that implements #send
  should work in the straightforward case
  should work when doing automatic pluralization
  should blow up when the owner doesn't respond to that method
Spec::Matchers::Have
  should have method_missing as private
  should not respond_to? method_missing (because it's private)
  respond_to?
    should be true for a method which Have defines
    should be true for a method that it's superclass (Object) defines
    should be false for a method which neither Object nor nor Have defines
    should be false if the owner doesn't respond to the method
    should be true if the owner responds to the method
Matchers should be able to generate their own descriptions
  should == expected
  should not == expected
  should be empty (arbitrary predicate)
  should not be empty (arbitrary predicate)
  should be true
  should be false
  should be nil
  should be > n
  should be predicate arg1, arg2 and arg3
  should equal
  should_not equal
  should eql
  should not eql
  should have_key
  should have n items
  should have at least n items
  should have at most n items
  should include
  array.should =~ [1,2,3]
  should match
  should raise_error
  should raise_error with type
  should raise_error with type and message
  should respond_to
  should throw symbol
  should throw symbol (with named symbol)
a Matcher with no description
  should provide a helpful message when used in a string-less example block
Spec::Matchers::SimpleMatcher
  should pass match arg to block
  should provide a stock failure message
  should provide a stock negative failure message
  should provide the given description
  should fail if a wrapped 'should' fails
with arity of 2
  should provide the matcher so you can access its messages
  should support a custom failure message
  should complain when asked for a failure message if you don't give it a description or a message
  should support a custom negative failure message
  should complain when asked for a negative failure message if you don't give it a description or a message
  should support a custom description
  should tell you no description was provided when it doesn't receive one
should include(expected)
  should pass if target includes expected
  should pass if target is a Hash and has the expected as a key
  should fail if target does not include expected
should include(with, multiple, args)
  should pass if target includes all items
  should pass if target is a Hash including all items as keys
  should fail if target does not include any one of the items
  should pass if target is a Hash missing any item as a key
should_not include(expected)
  should pass if target does not include expected
  should pass if target is a Hash and does not have the expected as a key
  should fail if target includes expected
should include(:key => value)
  should pass if target is a Hash and includes the key/value pair
  should pass if target is a Hash and includes the key/value pair among others
  should fail if target is a Hash and has a different value for key
  should fail if target is a Hash and has a different key
should match(expected)
  should pass when target (String) matches expected (Regexp)
  should pass when target (String) matches expected (String)
  should fail when target (String) does not match expected (Regexp)
  should fail when target (String) does not match expected (String)
  should provide message, expected and actual on failure
should_not match(expected)
  should pass when target (String) matches does not match (Regexp)
  should pass when target (String) matches does not match (String)
  should fail when target (String) matches expected (Regexp)
  should fail when target (String) matches expected (String)
  should provide message, expected and actual on failure
Stubs should correctly restore module methods
  1 - stub the open method
  2 - use File.open to create example.txt
mock failure
  should tell you when it receives the right message with the wrong args
  should tell you when it receives the right message with the wrong args if you stub the method (PENDING: fix bug 15719)
stub implementation
  with no args
    execs the block when called
  with one arg
    execs the block with that arg when called
  with variable args
    execs the block when called
Spec::Mocks::ArgumentMatchers::AnyArgsMatcher
  represents itself nicely for failure messages
Spec::Mocks::ArgumentMatchers::AnyArgMatcher
  represents itself nicely for failure messages
A chained method stub
  returns expected value from chaining only one method call
  returns expected value from chaining two method calls
  returns expected value from chaining four method calls
  returns expected value from two chains with shared messages at the end
  returns expected value from two chains with shared messages at the beginning
Spec::Mocks::ArgumentMatchers::HashNotIncludingMatcher
  should describe itself properly
  passing
    should match a hash without the specified key
    should match a hash with the specified key, but different value
    should match a hash without the specified key, given as anything()
    should match an empty hash
    should match a hash without any of the specified keys
  failing
    should not match a non-hash
    should not match a hash with a specified key
    should not match a hash with the specified key/value pair
    should not match a hash with the specified key
    should not match a hash with one of the specified keys
    should not match a hash with some of the specified keys
    should not match a hash with one key/value pair included
should_receive
  should work when object lies about responding to a method
  should work when class lies about responding to a method
  should cleanup after itself
Mock
  when one example has an expectation (non-mock) inside the block passed to the mock
  then the next example should behave as expected instead of saying
at_most
  should fail when at most n times method is called n plus 1 times
  should fail when at most once method is called twice
  should fail when at most twice method is called three times
  should pass when at most n times method is called exactly n times
  should pass when at most n times method is called less than n times
  should pass when at most n times method is never called
  should pass when at most once method is called once
  should pass when at most once method is never called
  should pass when at most twice method is called once
  should pass when at most twice method is called twice
  should pass when at most twice method is never called
using a Partial Mock,
  should name the class in the failure message
  should name the class in the failure message when expectation is on class
  should not conflict with @options in the object
  should_not_receive should mock out the method
  should_not_receive should return a negative message expectation
  should_receive should mock out the method
  should_receive should handle a hash
  should_receive should handle an inner hash
  should_receive should return a message expectation
  should_receive should verify method was called
  should_receive should also take a String argument
  should_not_receive should also take a String argument
  should use report nil in the error message
Partially mocking an object that defines ==, after another mock has been defined
  should not raise an error when stubbing the object
Method visibility when using partial mocks
  should keep public methods public
  should keep private methods private
  should keep protected methods protected
Spec::Mocks::Methodshandling argument matchers
  should accept true as boolean()
  should accept false as boolean()
  should accept fixnum as kind_of(Numeric)
  should accept float as an_instance_of(Numeric)
  accepts fixnum as instance_of(Fixnum)
  should NOT accept fixnum as instance_of(Numeric)
  should NOT accept float as instance_of(Numeric)
  should accept string as anything()
  should match duck type with one method
  should match duck type with two methods
  should match no args against any_args()
  should match one arg against any_args()
  should match no args against no_args()
  should match hash with hash_including same hash
Spec::Mocks::Methodshandling block matchers
  should match arguments against RSpec expectations
Spec::Mocks::Methodshandling non-matcher arguments
  should match non special symbol (can be removed when deprecated symbols are removed)
  should match string against regexp
  should match regexp against regexp
  should match against a hash submitted and received by value
  should match against a hash submitted by reference and received by value
  should match against a hash submitted by value and received by reference
A Partial Mock
  should respect subclasses
  should
Spec::Mocks::Space
  should verify all mocks within
  should reset all mocks within
  should clear internal mocks on reset_all
  should only add an instance once
Spec::Mocks::Mock
  unstubbing a mock object with a stub
    should remove the stub
  unstubbing a real object with a stub
    should raise a NoMethodError if the message is called after unstubbing
    should only clear the stub specified
    should no longer respond_to? the method
    should unstub using a string (should convert the string to a symbol)
    should restore a previous method definition
    should have unstub as an alias of unstub!
    should raise a MockExpectationError if it is not stubbed
    should raise a MockExpectationError if it was already unstubbed
    should use the correct message name in the error
    should raise a MockExpectationError if the method is defined, but not stubbed
    should be able to restub a after unstubbing
    should remove only the first stub if multiple stubs have been defined
OnceCounts
  once should fail when called once with wrong args
  once should fail when called twice
  once should fail when not called
  once should pass when called once
  once should pass when called once with specified args
  once should pass when called once with unspecified args
Calling a method that catches StandardError
  still reports mock failures
An RSpec Mock
  should hide internals in its inspect representation
An object where respond_to? is true and does not have method
  should not raise an exception for Object
  should not raise an exception for mock
Spec::Mocks::Mock
  should have method_missing as private
  should not respond_to? method_missing (because it's private)
  should report line number of expectation of unreceived message
  should report line number of expectation of unreceived message after #should_receive after similar stub
  should pass when not receiving message specified as not to be received
  should pass when receiving message specified as not to be received with different args
  should fail when receiving message specified as not to be received
  should fail when receiving message specified as not to be received with args
  should pass when receiving message specified as not to be received with wrong args
  should allow block to calculate return values
  should allow parameter as return value
  should return nil if no return value set
  should raise exception if args don't match when method called
  should raise exception if args don't match when method called even when the method is stubbed
  should raise exception if args don't match when method called even when using null_object
  should fail if unexpected method called
  should use block for expectation if provided
  should fail if expectation block fails
  should fail right away when method defined as never is received
  should eventually fail when method defined as never is received
  should raise when told to
  should raise passed an Exception instance
  should raise RuntimeError with passed message
  should not raise when told to if args dont match
  should throw when told to
  should raise when explicit return and block constrained
  should ignore args on any args
  should fail on no args if any args received
  should fail when args are expected but none are received
  should return value from block by default
  should yield 0 args to blocks that take a variable number of arguments
  should yield 0 args multiple times to blocks that take a variable number of arguments
  should yield one arg to blocks that take a variable number of arguments
  should yield one arg 3 times consecutively to blocks that take a variable number of arguments
  should yield many args to blocks that take a variable number of arguments
  should yield many args 3 times consecutively to blocks that take a variable number of arguments
  should yield single value
  should yield single value 3 times consecutively
  should yield two values
  should yield two values 3 times consecutively
  should fail when calling yielding method with wrong arity
  should fail when calling yielding method consecutively with wrong arity
  should fail when calling yielding method without block
  should be able to mock send
  should be able to raise from method calling yielding mock
  should clear expectations after verify
  should restore objects to their original state on rspec_reset
  should work even after method_missing starts raising NameErrors instead of NoMethodErrors
  should temporarily replace a method stub on a mock
  should not require a different signature to replace a method stub
  should raise an error when a previously stubbed method has a negative expectation
  should temporarily replace a method stub on a non-mock
  should return the stubbed value when no new value specified
  should not mess with the stub's yielded values when also mocked
  should yield multiple values after a similar stub
  should assign stub return values
  deprecated #stub_everything method
    creates a mock that behaves as a null object
    provides deprecation warning
a mock message receiving a block
  should call the block after #should_receive
  should call the block after #should_receive after a similar stub
  should call the block after #once
  should call the block after #twice
  should call the block after #times
  should call the block after #any_number_of_times
  should call the block after #ordered
string representation generated by #to_s
  should not contain < because that might lead to invalid HTML in some situations
mock created with no name
  should not use a name in a failure message
  should respond to initially stubbed methods
==
  sends '== self' to the comparison object
PreciseCounts
  should fail when exactly n times method is called less than n times
  should fail when exactly n times method is never called
  should pass if exactly n times method is called exactly n times
  should pass multiple calls with different args and counts
  should pass mutiple calls with different args
stubbing a class method
  should work
  should restore the original method
PartialMockUsingMocksDirectly
  should fail when expected message is not received
  should fail when message is received with incorrect args
  should pass when expected message is received
  should pass when message is received with correct args
  should revert to original method if existed
Spec::Mocks::ArgumentMatchers::HashIncludingMatcher
  should describe itself properly
  passing
    should match the same hash
    should match a hash with extra stuff
    when matching against other matchers
      should match an int against anything()
      should match a string against anything()
    when passed only keys or keys mixed with key/value pairs
      should match if the key is present
      should match if more keys are present
      should match a string against a given key
      should match if passed one key and one key/value pair
      should match if passed many keys and one key/value pair
      should match if passed many keys and many key/value pairs
  failing
    should not match a non-hash
    should not match a hash with a missing key
    should not match a hash with a missing key
    should not match an empty hash with a given key
    should not match a hash with a missing key when one pair is matching
    should not match a hash with an incorrect value
    should not match when values are nil but keys are different
a mock
  should answer false for received_message? when no messages received
  should answer true for received_message? when message received
  should answer true for received_message? when message received with correct args
  should answer false for received_message? when message received with incorrect args
a mock acting as a NullObject
  should allow explicit expectation
  should fail verification when explicit exception not met
  should ignore unexpected methods
  should expected message with different args first
  should expected message with different args second
#null_object?
  should default to false
#as_null_object
  should set the object to null_object
Bug report 8302:
  class method is not restored correctly when proxied
  instance method is not restored correctly when proxied
Mock ordering
  should pass two calls in order
  should pass three calls in order
  should fail if second call comes first
  should fail if third call comes first
  should fail if third call comes second
  should ignore order of non ordered calls
  should pass when duplicates exist
AnyNumberOfTimes
  should pass if any number of times method is called many times
  should pass if any number of times method is called once
  should pass if any number of times method is not called
  should return the mocked value when called after a similar stub
Spec::Mocks::ArgumentExpectation
  should consider an object that responds to #matches? and #description to be a matcher
  should NOT consider an object that only responds to #matches? to be a matcher
A method stub
  should ignore when expected message is received
  should ignore when message is received with args
  should ignore when expected message is not received
  should handle multiple stubbed methods
  should clear itself when verified
  should return values in order to consecutive calls
  should keep returning last value in consecutive calls
  should revert to original instance method if there is one
  should revert to original class method if there is one
  should yield a specified object
  should yield multiple times with multiple calls to and_yield
  should yield a specified object and return another specified object
  should throw when told to
  should override a pre-existing stub
  should limit 
  calculates return value by executing block passed to #and_return
  using stub!
    should return expected value when expected message is received
  using stub
    should return expected value when expected message is received
A method stub with args
  should not complain if not called
  should not complain if called with arg
  should complain if called with no arg
  should complain if called with other arg
  should not complain if also mocked w/ different args
  should complain if also mocked w/ different args AND called w/ a 3rd set of args
  should support options
  should use 'Stub' in the failure message
calling :should_receive with an options hash
  should report the file and line submitted with :expected_from
  should use the message supplied with :message
  should use the message supplied with :message after a similar stub
failing MockArgumentMatchers
  should reject non boolean
  should reject non numeric
  should reject non string
  should reject goose when expecting a duck
  should fail if regexp does not match submitted string
  should fail if regexp does not match submitted regexp
  should fail for a hash w/ wrong values
  should fail for a hash w/ wrong keys
  should match against a Matcher
  should fail no_args with one arg
  should fail hash_including with missing key
  should fail with block matchers
double
  is an alias for stub and mock
  uses 'Double' in failure messages
a Mock expectation with multiple return values and no specified count
  should return values in order to consecutive calls
  should complain when there are too few calls
  should complain when there are too many calls
a Mock expectation with multiple return values with a specified count equal to the number of values
  should return values in order to consecutive calls
  should complain when there are too few calls
  should complain when there are too many calls
a Mock expectation with multiple return values specifying at_least less than the number of values
  should use last return value for subsequent calls
  should fail when called less than the specified number
a Mock expectation with multiple return values with a specified count larger than the number of values
  should use last return value for subsequent calls
  should fail when called less than the specified number
  should fail when called greater than the specified number
TwiceCounts
  twice should fail when call count is higher than expected
  twice should fail when call count is lower than expected
  twice should fail when called twice with wrong args on the first call
  twice should fail when called twice with wrong args on the second call
  twice should pass when called twice
  twice should pass when called twice with specified args
  twice should pass when called twice with unspecified args
Spec::Mocks::Mock
  #and_yield
    with eval context as block argument
      evaluates the supplied block as it is read
      passes an eval context object to the supplied block
      evaluates the block passed to the stubbed method in the context of the supplied eval context
      and no yielded arguments
        passes when expectations set on the eval context are met
        fails when expectations set on the eval context are not met
      and yielded arguments
        passes when expectations set on the eval context and yielded arguments are met
        fails when expectations set on the eval context and yielded arguments are not met
Example with stubbed and then called message
  fails if the message is expected and then subsequently not called again
  outputs arguments of all similar calls
an expectation set on nil
  should issue a warning with file and line number information
  should issue a warning when the expectation is negative
  should not issue a warning when expectations are set to be allowed
#allow_message_expectations_on_nil
when called in one example that doesn't end up setting an expectation on nil
should not effect the next exapmle ran
  should not effect subsequent examples
a message expectation on a base class object
  should correctly pick up message sent to it subclass (PENDING: fix for http://rspec.lighthouseapp.com/projects/5645/tickets/496)
at_least
  should fail if method is never called
  should fail when called less than n times
  should fail when at least once method is never called
  should fail when at least twice method is called once
  should fail when at least twice method is never called
  should pass when at least n times method is called exactly n times
  should pass when at least n times method is called n plus 1 times
  should pass when at least once method is called once
  should pass when at least once method is called twice
  should pass when at least twice method is called three times
  should pass when at least twice method is called twice
Spec::Runner::CommandLine.run
  should run directory (FAILED - 12)
  should run file (FAILED - 13)
  should raise when file does not exist
  should return true when in --generate-options mode
  should exit if Interrupt exception occurrs during the spec (FAILED - 14)
  should exit if Interrupt exception occurrs during an after(:each)
  should heckle when options have heckle_runner
  should run examples backwards if options.reverse is true
  should pass its ExampleGroup to the reporter (FAILED - 15)
  runs only selected Examples when options.examples is set (FAILED - 16)
OptionParser
/mnt/repos/dchelimsky/rspec/lib/spec/example/example_methods.rb:37:in `execute': execution expired (Timeout::Error)
	from /mnt/repos/dchelimsky/rspec/lib/spec/example/example_group_methods.rb:214:in `block in run_examples'
	from /mnt/repos/dchelimsky/rspec/lib/spec/example/example_group_methods.rb:212:in `each'
	from /mnt/repos/dchelimsky/rspec/lib/spec/example/example_group_methods.rb:212:in `run_examples'
	from /mnt/repos/dchelimsky/rspec/lib/spec/example/example_group_methods.rb:103:in `run'
	from /mnt/repos/dchelimsky/rspec/lib/spec/runner/example_group_runner.rb:23:in `block in run'
	from /mnt/repos/dchelimsky/rspec/lib/spec/runner/example_group_runner.rb:22:in `each'
	from /mnt/repos/dchelimsky/rspec/lib/spec/runner/example_group_runner.rb:22:in `run'
	from /mnt/repos/dchelimsky/rspec/lib/spec/runner/options.rb:152:in `run_examples'
	from /mnt/repos/dchelimsky/rspec/lib/spec/runner/command_line.rb:9:in `run'
	from /mnt/repos/dchelimsky/rspec/bin/spec:5:in `<main>'
rake aborted!
Command /home/build/.ruby_versions/ruby-1.9.1-p243/bin/ruby -I"spec:lib"  "/mnt/repos/dchelimsky/rspec/bin/spec" "spec/autotest/discover_spec.rb" "spec/autotest/failed_results_re_spec.rb" "spec/autotest/rspec_spec.rb" "spec/spec/example/example_group_methods_spec.rb" "spec/spec/example/pending_module_spec.rb" "spec/spec/example/example_group_factory_spec.rb" "spec/spec/example/helper_method_spec.rb" "spec/spec/example/predicate_matcher_spec.rb" "spec/spec/example/example_group_class_definition_spec.rb" "spec/spec/example/example_matcher_spec.rb" "spec/spec/example/example_methods_spec.rb" "spec/spec/example/example_proxy_spec.rb" "spec/spec/example/example_group_spec.rb" "spec/spec/example/example_group_proxy_spec.rb" "spec/spec/example/subject_spec.rb" "spec/spec/example/shared_example_group_spec.rb" "spec/spec/example/subclassing_example_group_spec.rb" "spec/spec/example/nested_example_group_spec.rb" "spec/spec/package/bin_spec_spec.rb" "spec/spec/expectations/extensions/kernel_spec.rb" "spec/spec/expectations/differs/default_spec.rb" "spec/spec/expectations/handler_spec.rb" "spec/spec/expectations/wrap_expectation_spec.rb" "spec/spec/expectations/fail_with_spec.rb" "spec/spec/rake/spectask_spec.rb" "spec/spec/interop/test/unit/testcase_spec.rb" "spec/spec/interop/test/unit/spec_spec.rb" "spec/spec/interop/test/unit/testsuite_adapter_spec.rb" "spec/spec/runner_spec.rb" "spec/spec/dsl/main_spec.rb" "spec/spec/matchers/change_spec.rb" "spec/spec/matchers/operator_matcher_spec.rb" "spec/spec/matchers/be_close_spec.rb" "spec/spec/matchers/matcher_spec.rb" "spec/spec/matchers/matcher_methods_spec.rb" "spec/spec/matchers/match_array_spec.rb" "spec/spec/matchers/dsl_spec.rb" "spec/spec/matchers/matchers_spec.rb" "spec/spec/matchers/equal_spec.rb" "spec/spec/matchers/be_kind_of_spec.rb" "spec/spec/matchers/has_spec.rb" "spec/spec/matchers/throw_symbol_spec.rb" "spec/spec/matchers/raise_error_spec.rb" "spec/spec/matchers/satisfy_spec.rb" "spec/spec/matchers/respond_to_spec.rb" "spec/spec/matchers/exist_spec.rb" "spec/spec/matchers/be_spec.rb" "spec/spec/matchers/eql_spec.rb" "spec/spec/matchers/compatibility_spec.rb" "spec/spec/matchers/be_instance_of_spec.rb" "spec/spec/matchers/have_spec.rb" "spec/spec/matchers/description_generation_spec.rb" "spec/spec/matchers/simple_matcher_spec.rb" "spec/spec/matchers/include_spec.rb" "spec/spec/matchers/match_spec.rb" "spec/spec/mocks/bug_report_7805_spec.rb" "spec/spec/mocks/bug_report_15719_spec.rb" "spec/spec/mocks/stub_implementation_spec.rb" "spec/spec/mocks/argument_matchers_spec.rb" "spec/spec/mocks/stub_chain_spec.rb" "spec/spec/mocks/hash_not_including_matcher_spec.rb" "spec/spec/mocks/bug_report_11545_spec.rb" "spec/spec/mocks/bug_report_10263_spec.rb" "spec/spec/mocks/at_most_spec.rb" "spec/spec/mocks/partial_mock_spec.rb" "spec/spec/mocks/passing_argument_matchers_spec.rb" "spec/spec/mocks/bug_report_7611_spec.rb" "spec/spec/mocks/mock_space_spec.rb" "spec/spec/mocks/unstub_spec.rb" "spec/spec/mocks/once_counts_spec.rb" "spec/spec/mocks/bug_report_830_spec.rb" "spec/spec/mocks/bug_report_10260_spec.rb" "spec/spec/mocks/bug_report_8165_spec.rb" "spec/spec/mocks/mock_spec.rb" "spec/spec/mocks/precise_counts_spec.rb" "spec/spec/mocks/bug_report_600_spec.rb" "spec/spec/mocks/partial_mock_using_mocks_directly_spec.rb" "spec/spec/mocks/hash_including_matcher_spec.rb" "spec/spec/mocks/record_messages_spec.rb" "spec/spec/mocks/null_object_mock_spec.rb" "spec/spec/mocks/bug_report_8302_spec.rb" "spec/spec/mocks/mock_ordering_spec.rb" "spec/spec/mocks/any_number_of_times_spec.rb" "spec/spec/mocks/argument_expectation_spec.rb" "spec/spec/mocks/stub_spec.rb" "spec/spec/mocks/options_hash_spec.rb" "spec/spec/mocks/failing_argument_matchers_spec.rb" "spec/spec/mocks/double_spec.rb" "spec/spec/mocks/multiple_return_value_spec.rb" "spec/spec/mocks/twice_counts_spec.rb" "spec/spec/mocks/and_yield_spec.rb" "spec/spec/mocks/stubbed_message_expectations_spec.rb" "spec/spec/mocks/nil_expectation_warning_spec.rb" "spec/spec/mocks/bug_report_496_spec.rb" "spec/spec/mocks/at_least_spec.rb" "spec/spec/runner/command_line_spec.rb" "spec/spec/runner/option_parser_spec.rb" "spec/spec/runner/output_one_time_spec.rb" "spec/spec/runner/reporter_spec.rb" "spec/spec/runner/options_spec.rb" "spec/spec/runner/resources/a_spec.rb" "spec/spec/runner/configuration_spec.rb" "spec/spec/runner/formatter/progress_bar_formatter_spec.rb" "spec/spec/runner/formatter/base_text_formatter_spec.rb" "spec/spec/runner/formatter/specdoc_formatter_spec.rb" "spec/spec/runner/formatter/profile_formatter_spec.rb" "spec/spec/runner/formatter/html_formatter_spec.rb" "spec/spec/runner/formatter/base_formatter_spec.rb" "spec/spec/runner/formatter/nested_text_formatter_spec.rb" "spec/spec/runner/formatter/failing_examples_formatter_spec.rb" "spec/spec/runner/formatter/text_mate_formatter_spec.rb" "spec/spec/runner/formatter/snippet_extractor_spec.rb" "spec/spec/runner/formatter/failing_example_groups_formatter_spec.rb" "spec/spec/runner/example_group_runner_spec.rb" "spec/spec/runner/class_and_argument_parser_spec.rb" "spec/spec/runner/quiet_backtrace_tweaker_spec.rb" "spec/spec/runner/heckler_spec.rb" "spec/spec/runner/drb_command_line_spec.rb" "spec/spec/runner/line_number_query_spec.rb" "spec/spec/runner/heckle_runner_spec.rb" "spec/spec/runner/noisy_backtrace_tweaker_spec.rb" --options spec/spec.opts failed

(See full trace by running task with --trace)
build@build104:/mnt/repos/dchelimsky/rspec$ rake > ~/rspec.log
/mnt/repos/dchelimsky/rspec/lib/spec/example/example_methods.rb:37:in `execute': execution expired (Timeout::Error)
	from /mnt/repos/dchelimsky/rspec/lib/spec/example/example_group_methods.rb:214:in `block in run_examples'
	from /mnt/repos/dchelimsky/rspec/lib/spec/example/example_group_methods.rb:212:in `each'
	from /mnt/repos/dchelimsky/rspec/lib/spec/example/example_group_methods.rb:212:in `run_examples'
	from /mnt/repos/dchelimsky/rspec/lib/spec/example/example_group_methods.rb:103:in `run'
	from /mnt/repos/dchelimsky/rspec/lib/spec/runner/example_group_runner.rb:23:in `block in run'
	from /mnt/repos/dchelimsky/rspec/lib/spec/runner/example_group_runner.rb:22:in `each'
	from /mnt/repos/dchelimsky/rspec/lib/spec/runner/example_group_runner.rb:22:in `run'
	from /mnt/repos/dchelimsky/rspec/lib/spec/runner/options.rb:152:in `run_examples'
	from /mnt/repos/dchelimsky/rspec/lib/spec/runner/command_line.rb:9:in `run'
	from /mnt/repos/dchelimsky/rspec/bin/spec:5:in `<main>'
rake aborted!
Command /home/build/.ruby_versions/ruby-1.9.1-p243/bin/ruby -I"spec:lib"  "/mnt/repos/dchelimsky/rspec/bin/spec" "spec/autotest/discover_spec.rb" "spec/autotest/failed_results_re_spec.rb" "spec/autotest/rspec_spec.rb" "spec/spec/example/example_group_methods_spec.rb" "spec/spec/example/pending_module_spec.rb" "spec/spec/example/example_group_factory_spec.rb" "spec/spec/example/helper_method_spec.rb" "spec/spec/example/predicate_matcher_spec.rb" "spec/spec/example/example_group_class_definition_spec.rb" "spec/spec/example/example_matcher_spec.rb" "spec/spec/example/example_methods_spec.rb" "spec/spec/example/example_proxy_spec.rb" "spec/spec/example/example_group_spec.rb" "spec/spec/example/example_group_proxy_spec.rb" "spec/spec/example/subject_spec.rb" "spec/spec/example/shared_example_group_spec.rb" "spec/spec/example/subclassing_example_group_spec.rb" "spec/spec/example/nested_example_group_spec.rb" "spec/spec/package/bin_spec_spec.rb" "spec/spec/expectations/extensions/kernel_spec.rb" "spec/spec/expectations/differs/default_spec.rb" "spec/spec/expectations/handler_spec.rb" "spec/spec/expectations/wrap_expectation_spec.rb" "spec/spec/expectations/fail_with_spec.rb" "spec/spec/rake/spectask_spec.rb" "spec/spec/interop/test/unit/testcase_spec.rb" "spec/spec/interop/test/unit/spec_spec.rb" "spec/spec/interop/test/unit/testsuite_adapter_spec.rb" "spec/spec/runner_spec.rb" "spec/spec/dsl/main_spec.rb" "spec/spec/matchers/change_spec.rb" "spec/spec/matchers/operator_matcher_spec.rb" "spec/spec/matchers/be_close_spec.rb" "spec/spec/matchers/matcher_spec.rb" "spec/spec/matchers/matcher_methods_spec.rb" "spec/spec/matchers/match_array_spec.rb" "spec/spec/matchers/dsl_spec.rb" "spec/spec/matchers/matchers_spec.rb" "spec/spec/matchers/equal_spec.rb" "spec/spec/matchers/be_kind_of_spec.rb" "spec/spec/matchers/has_spec.rb" "spec/spec/matchers/throw_symbol_spec.rb" "spec/spec/matchers/raise_error_spec.rb" "spec/spec/matchers/satisfy_spec.rb" "spec/spec/matchers/respond_to_spec.rb" "spec/spec/matchers/exist_spec.rb" "spec/spec/matchers/be_spec.rb" "spec/spec/matchers/eql_spec.rb" "spec/spec/matchers/compatibility_spec.rb" "spec/spec/matchers/be_instance_of_spec.rb" "spec/spec/matchers/have_spec.rb" "spec/spec/matchers/description_generation_spec.rb" "spec/spec/matchers/simple_matcher_spec.rb" "spec/spec/matchers/include_spec.rb" "spec/spec/matchers/match_spec.rb" "spec/spec/mocks/bug_report_7805_spec.rb" "spec/spec/mocks/bug_report_15719_spec.rb" "spec/spec/mocks/stub_implementation_spec.rb" "spec/spec/mocks/argument_matchers_spec.rb" "spec/spec/mocks/stub_chain_spec.rb" "spec/spec/mocks/hash_not_including_matcher_spec.rb" "spec/spec/mocks/bug_report_11545_spec.rb" "spec/spec/mocks/bug_report_10263_spec.rb" "spec/spec/mocks/at_most_spec.rb" "spec/spec/mocks/partial_mock_spec.rb" "spec/spec/mocks/passing_argument_matchers_spec.rb" "spec/spec/mocks/bug_report_7611_spec.rb" "spec/spec/mocks/mock_space_spec.rb" "spec/spec/mocks/unstub_spec.rb" "spec/spec/mocks/once_counts_spec.rb" "spec/spec/mocks/bug_report_830_spec.rb" "spec/spec/mocks/bug_report_10260_spec.rb" "spec/spec/mocks/bug_report_8165_spec.rb" "spec/spec/mocks/mock_spec.rb" "spec/spec/mocks/precise_counts_spec.rb" "spec/spec/mocks/bug_report_600_spec.rb" "spec/spec/mocks/partial_mock_using_mocks_directly_spec.rb" "spec/spec/mocks/hash_including_matcher_spec.rb" "spec/spec/mocks/record_messages_spec.rb" "spec/spec/mocks/null_object_mock_spec.rb" "spec/spec/mocks/bug_report_8302_spec.rb" "spec/spec/mocks/mock_ordering_spec.rb" "spec/spec/mocks/any_number_of_times_spec.rb" "spec/spec/mocks/argument_expectation_spec.rb" "spec/spec/mocks/stub_spec.rb" "spec/spec/mocks/options_hash_spec.rb" "spec/spec/mocks/failing_argument_matchers_spec.rb" "spec/spec/mocks/double_spec.rb" "spec/spec/mocks/multiple_return_value_spec.rb" "spec/spec/mocks/twice_counts_spec.rb" "spec/spec/mocks/and_yield_spec.rb" "spec/spec/mocks/stubbed_message_expectations_spec.rb" "spec/spec/mocks/nil_expectation_warning_spec.rb" "spec/spec/mocks/bug_report_496_spec.rb" "spec/spec/mocks/at_least_spec.rb" "spec/spec/runner/command_line_spec.rb" "spec/spec/runner/option_parser_spec.rb" "spec/spec/runner/output_one_time_spec.rb" "spec/spec/runner/reporter_spec.rb" "spec/spec/runner/options_spec.rb" "spec/spec/runner/resources/a_spec.rb" "spec/spec/runner/configuration_spec.rb" "spec/spec/runner/formatter/progress_bar_formatter_spec.rb" "spec/spec/runner/formatter/base_text_formatter_spec.rb" "spec/spec/runner/formatter/specdoc_formatter_spec.rb" "spec/spec/runner/formatter/profile_formatter_spec.rb" "spec/spec/runner/formatter/html_formatter_spec.rb" "spec/spec/runner/formatter/base_formatter_spec.rb" "spec/spec/runner/formatter/nested_text_formatter_spec.rb" "spec/spec/runner/formatter/failing_examples_formatter_spec.rb" "spec/spec/runner/formatter/text_mate_formatter_spec.rb" "spec/spec/runner/formatter/snippet_extractor_spec.rb" "spec/spec/runner/formatter/failing_example_groups_formatter_spec.rb" "spec/spec/runner/example_group_runner_spec.rb" "spec/spec/runner/class_and_argument_parser_spec.rb" "spec/spec/runner/quiet_backtrace_tweaker_spec.rb" "spec/spec/runner/heckler_spec.rb" "spec/spec/runner/drb_command_line_spec.rb" "spec/spec/runner/line_number_query_spec.rb" "spec/spec/runner/heckle_runner_spec.rb" "spec/spec/runner/noisy_backtrace_tweaker_spec.rb" --options spec/spec.opts failed

(See full trace by running task with --trace)
build@build104:/mnt/repos/dchelimsky/rspec$ cat /home/build/rspec.log 
(in /mnt/repos/dchelimsky/rspec)
Autotest::Rspecdiscovery
  adds the rspec autotest plugin
failed_results_re
  should match a failure
  should match a failure when matcher outputs multiple lines
  should match an Error
  should match an Error that doesn't end in Error
Autotest::Rspec
  adding spec.opts --options
    should return the command line option to add spec.opts if the options file exists
    should return an empty string if no spec.opts exists
  commands
    should make the appropriate test command
    should return a blank command for no files
  mappings
    should find the spec file for a given lib file
    should find the spec file if given a spec file
    should ignore files in spec dir that aren't specs
    should ignore untracked files (in @file)
  consolidating failures
    should return no failures if no failures were given in the output
    should return a hash with the spec filename => spec name for each failure or error
    should not include the subject file
  normalizing file names
    should ensure that a single file appears in files_to_test only once
ExampleGroupMethods
  #describe
    when creating an ExampleGroup
      should create a subclass of the ExampleGroup when passed a block
      should not inherit examples
      records the spec path
    when creating an example group with no description
      raises an ArgumentError
    when creating a SharedExampleGroup
      should create a SharedExampleGroup
  #context
    when creating an ExampleGroup
      should create a subclass of the ExampleGroup when passed a block
      should not inherit examples
      records the spec path
    when creating an example group with no description
      raises an ArgumentError
    when creating a SharedExampleGroup
      should create a SharedExampleGroup
  #example
    should add an example
    with no location supplied
      creates an ExampleProxy
        with a description
        with options (FAILED - 1)
        with a default backtrace (DEPRECATED)
        with a default location
    with a location supplied
        with the supplied location as #backtrace (DEPRECATED)
        with the supplied location as #location
  #specify
    should add an example
    with no location supplied
      creates an ExampleProxy
        with a description
        with options
        with a default backtrace (DEPRECATED)
        with a default location
    with a location supplied
        with the supplied location as #backtrace (DEPRECATED)
        with the supplied location as #location
  #it
    should add an example (FAILED - 2)
    with no location supplied
      creates an ExampleProxy
        with a description
        with options
        with a default backtrace (DEPRECATED)
        with a default location
    with a location supplied
        with the supplied location as #backtrace (DEPRECATED)
        with the supplied location as #location
  #xexample
    should NOT create an example
    should warn that the example is disabled
  #xit
    should NOT create an example
    should warn that the example is disabled
  #xspecify
build@build104:/mnt/repos/dchelimsky/rspec$