RSpec Results

 

 

Autotest::Rspec discovery
should add the rspec autotest plugin
Autotest::Rspec rspec_commands
should contain the various commands, ordered by preference
Autotest::Rspec selection of rspec command
should try to find the spec command if it exists in ./bin and use it above everything else
should otherwise select the default spec command in gem_dir/bin/spec
should raise an error if no spec command is found at all
Autotest::Rspec selection of rspec command (windows compatibility issues)
should use the ALT_SEPARATOR if it is non-nil (PENDING: autotest got re-worked so this is failing for the moment)
should not use the ALT_SEPATOR if it is nil
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
Autotest::Rspec
should make the apropriate test command
Autotest::Rspec test mappings
should map all filenames in spec/ which end in .rb
should map all names in lib which end in .rb to the corresponding ones in spec/
should find all files in spec/shares/* and the spec helper in spec/spec_helper
Autotest::Rspec handling results
should call hook(:red) if there are failures
should call hook(:green) if there are no failures
Autotest::Rspec handling failed results
should scan the output into a multi-dimensional array, consisting of the failing spec's name as the first element, and the failure as the second
Autotest::Rspec specs for a given file
should find the spec file for a given lib file
should find the spec file if given a spec file
should only find the file if the file is being tracked (in @file)
Autotest::Rspec 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
Spec::Example::Configuration#mock_with
should default mock framework to rspec
should let you set rspec mocking explicitly
should let you set mocha
should let you set flexmock
should let you set rr
should let you set an arbitrary adapter module
Spec::Example::Configuration#include
should include the submitted module in ExampleGroup subclasses
should let you define modules to be included for a specific type
should not include modules in a type they are not intended for
Spec::Example::Configuration#prepend_before
Special Example Group
calls prepend_before
prepends the before block on all instances of the passed in type
Spec::Example::Configuration#append_before
Special Example Group
calls append_before
calls append_before on the type
Spec::Example::Configuration#prepend_after
Special Example Group
calls prepend_after
prepends the after block on all instances of the passed in type
Spec::Example::Configuration#append_after
Special Example Group
calls append_after
calls append_after on the type
Spec::Example::ExampleGroupSubclass
should run
should have access to instance variables
should have access to class variables
should have access to constants
should have access to methods defined in the Example Group
Spec::Example::ExampleGroupSubclass
should run
Spec::Example::ExampleGroupFactory with :foobar registered as custom type
should #get the default ExampleGroup type when passed nil
should #get the default ExampleGroup for unregistered non-nil values
should #get custom type for :foobar
should #get the actual type when that is passed in
Spec::Example::ExampleGroupFactory#create_example_group
should create a uniquely named class
should create a Spec::Example::Example subclass by default
should create a Spec::Example::Example when :type => :default
should create a Spec::Example::Example when :type => :default
should create specified type when :type => :something_other_than_default
should create a type indicated by :spec_path
should create a type indicated by :spec_path (with spec_path generated by caller on windows)
should create and register a Spec::Example::Example if :shared => true
should favor the :type over the :spec_path
should register ExampleGroup by default
should enable unregistering of ExampleGroups
ExampleGroupMethods#describe
should create a subclass of the ExampleGroup when passed a block
should not inherit examples
ExampleGroupMethods#it
should should create an example instance
ExampleGroupMethods#xit
should NOT should create an example instance
should warn that it is disabled
ExampleGroupMethods#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
ExampleGroupMethods#set_description#set_description(String)
.description should return the String passed into .set_description
.described_type should provide nil as its type
ExampleGroupMethods#set_description#set_description(Type)
.description should return a String representation of that type (fully qualified) as its name
.described_type should return the passed in type
ExampleGroupMethods#set_description#set_description(String, Type)
.description should return String then space then Type
.described_type should return the passed in type
ExampleGroupMethods#set_description#set_description(Type, String not starting with a space)
.description should return the Type then space then String
ExampleGroupMethods#set_description#set_description(Type, String starting with .)
.description should return the Type then String
ExampleGroupMethods#set_description#set_description(Type, String containing .)
.description should return the Type then space then String
ExampleGroupMethods#set_description#set_description(Type, String starting with .)
should return the Type then String
ExampleGroupMethods#set_description#set_description(Type, String containing .)
.description should return the Type then space then String
ExampleGroupMethods#set_description#set_description(String, Type, String)
.description should return the first String then space then Type then second String
ExampleGroupMethods#set_description#set_description(Hash representing options)
.spec_path should expand the passed in :spec_path option passed into the constructor
.description_options should return all the options passed in
ExampleGroupMethods#description
should return the same description instance for each call
should not add a space when description_text begins with #
should not add a space when description_text begins with .
should return the class name if nil
should return the class name if nil
ExampleGroupMethods#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
ExampleGroupMethods#described_type
should return passed in type
should return #described_type of superclass when no passed in type
ExampleGroupMethods#remove_after
should unregister a given after(:each) block
ExampleGroupMethods#include
should have accessible class methods from included module
ExampleGroupMethods#number_of_examples
should count number of specs
ExampleGroupMethods#class_eval
should allow constants to be defined
ExampleGroupMethods#register
should add ExampleGroup to set of ExampleGroups to be run
ExampleGroupMethods#unregister
should remove ExampleGroup from set of ExampleGroups to be run
Spec::Example::ExampleGroup via a class definition
should understand module scoping
should allow class variables to be defined
Spec::Example::ExampleGroup via 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
Spec::Example::ExampleGroup#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 Spec::Example::ExampleGroup#run on dry run
should not run before(:all) or after(:all)
should not run example
Spec::Example::ExampleGroup#run 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 Spec::Example::ExampleGroup#run with specified examples Spec::Example::ExampleGroup#run when specified_examples matches only Example description
should not run the example
Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run with specified examples Spec::Example::ExampleGroup#run when specified_examples does not match an Example description
should not run the example
Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run with specified examples Spec::Example::ExampleGroup#run when specified_examples matches an Example description
should run only the example, when there in only one
should run only the one example
Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run with success
should send reporter add_example_group
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
should include any predicate_matchers included using configuration
should use a mock framework set up in config
Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run with pending example that has a failing assertion
should send example_pending to formatter
Spec::Example::ExampleGroup#run 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 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 Spec::Example::ExampleGroup#run when before(:each) fails
should add an example failure to the TestResult
should run after(:all)
Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run when any example fails
should add an example failure to the TestResult
should run after(:all)
Spec::Example::ExampleGroup#run 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 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 Spec::Example::ExampleGroup#run when failure in after(:all)
should add an example failure to the TestResult
should return false
Spec::Example::ExampleGroup subclasses
should have access to the described_type
should concat descriptions when nested
Enumerable
should be included in examples because it is a module
An Enumerable as a second argument
should be included in examples because it is a module
Enumerable as the parent of nested example groups
should be included in examples because it is a module (PENDING: need to make sure nested groups know the described type)
String
should not be included in examples because it is not a module
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
ExampleMethods with an included module that is reopened
should have repoened methods
Spec::Example::ExampleMethods lifecycle
#<Class:0x11c6ff0>
should use ExampleMethods callbacks
should pass before and after callbacks to all ExampleGroup subclasses
Spec::Example::ExampleMethods lifecycle run_with_description_capturing
should provide the generated description
should clear the global generated_description
Nested Example Groups
should run before(:all), before(:each), example, after(:each), after(:all) in order
Nested Example Groups nested example group
should run all before and after callbacks
Spec::Example::Pending
should raise an ExamplePendingError if no block is supplied
should raise an ExamplePendingError if a supplied block fails as expected
should raise a PendingExampleFixedError if a supplied block starts working
predicate_matcher[method_on_object] = matcher_method
should match matcher_method if method_on_object returns true
should not match matcher_method if method_on_object returns false
Spec::Example::ExampleGroup with :shared => true
should accept an optional options hash
should return all shared example_groups
should register as shared example_group
should not be shared when not configured as shared
should complain when adding a second shared example_group with the same description
should NOT complain when adding the same shared example_group instance again
should NOT complain when adding the same shared example_group again (i.e. file gets reloaded)
should NOT complain when adding the same shared example_group in same file with different absolute path
should complain when adding a different shared example_group with the same name in a different file with the same basename
should add examples to current example_group using it_should_behave_like
should add examples to current example_group using include
should add examples to current example_group using it_should_behave_like with a module
should run shared examples
should run setup and teardown 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
Grandparent ExampleGroup Parent ExampleGroup
should bar
Grandparent ExampleGroup Parent ExampleGroup Child ExampleGroup
should bam
Diff
should output unified diff of two strings
should output unified diff message of two arrays
should output unified diff message of two objects
Diff in context format
should output unified diff message of two objects
Object#should
should accept and interact with a matcher
should ask for a failure_message when matches? returns false
should raise error if it receives false directly
should raise error if it receives false (evaluated)
should raise error if it receives true
should raise error if it receives nil
should raise error if it receives no argument and it is not used as a left side of an operator (PENDING: Is it even possible to catch this?)
Object#should_not
should accept and interact with a matcher
should ask for a negative_failure_message when matches? returns true
should raise error if it receives false directly
should raise error if it receives false (evaluated)
should raise error if it receives true
should raise error if it receives nil
should raise error if it receives no argument and it is not used as a left side of an operator (PENDING: Is it even possible to catch this?)
Spec::Expectations#fail_with with no diff
should handle just a message
should handle an Array
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 not call differ if expected or actual are procs
should call differ if expected/actual are presented in an Array with message
Spec::Extensions::Main
should create an Options object
should respond to #describe
should respond to #context
should raise when no block given to describe
should raise when no description given to describe
should registered ExampleGroups by default
should not run unregistered ExampleGroups
should create a shared ExampleGroup with share_examples_for
Spec::Extensions::Main#share_as
should create a shared ExampleGroup
should create a constant that points to a Module
should bark if you pass it something not-constantizable
ExampleGroup with test/unit/interop with passing examples
should output 0 failures
should return an exit code of 0
ExampleGroup with test/unit/interop with failing examples
should output 1 failure
should return an exit code of 256
ExampleGroup with test/unit/interop with example that raises an error
should output 1 failure
should return an exit code of 256
Test::Unit::TestCase with passing test case
should output 0 failures
should return an exit code of 0
Test::Unit::TestCase with failing test case
should output 1 failure
should return an exit code of 256
Test::Unit::TestCase with test case that raises an error
should output 1 failure
should return an exit code of 256
TestSuiteAdapter
should pass
Spec::Matchers::BeClose
should match when value == target
should match when value < (target + delta)
should match when value > (target - delta)
should not match when value == (target - delta)
should not match when value < (target - delta)
should not match when value == (target + delta)
should not match when value > (target + delta)
should provide a useful failure message
should describe itself
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 does not respond to :predicate?
should_not be_predicate
should pass when actual returns false 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_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 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 change(actual, message)
should pass when actual is modified by the block
should fail when actual is not modified by the block
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
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
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 change{ block }.from(old).to(new)
should pass when #to comes before #from
should pass when #from comes before #to
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 be_few_words predicate should be transformed to 'be few words'
should preserve a proper prefix for be predicate
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
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)
Spec::Matchers::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::Equal
should match when actual.equal?(expected)
should not match when !actual.equal?(expected)
should describe itself
should provide message, expected and actual on #failure_message
should provide message, expected and actual on #negative_failure_message
should exist, within an example group
should pass if target exists
should fail if target does not exist
should pass if target doesn't exist
should exist, outside of an example group
should pass if target exists
Spec::Expectations::ExpectationMatcherHandler.handle_matcher
should ask the matcher if it matches
should explain when the matcher parameter is not a matcher
Spec::Expectations::NegativeExpectationMatcherHandler.handle_matcher
should explain when matcher does not support should_not
should ask the matcher if it matches
should explain when the matcher parameter is not a matcher
Spec::Expectations::ExpectationMatcherHandler
should handle submitted args
should handle the submitted block
should explain when matcher does not support should_not
should have_sym(*args)
should pass if #has_sym?(*args) returns true
should fail if #has_sym?(*args) returns false
should fail if target does not respond to #has_sym?
should_not have_sym(*args)
should pass if #has_sym?(*args) returns false
should fail if #has_sym?(*args) returns true
should fail if target does not respond to #has_sym?
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 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
should include(expected)
should pass if target includes expected
should fail if target does not include expected
should include(with, multiple, args)
should pass if target includes all items
should fail if target does not include any one of the items
should_not include(expected)
should pass if target does not include expected
should fail if target includes expected
should match(expected)
should pass when target (String) matches expected (Regexp)
should fail when target (String) does not match expected (Regexp)
should provide message, expected and actual on failure
should_not match(expected)
should pass when target (String) matches does not match (Regexp)
should fail when target (String) matches expected (Regexp)
should provide message, expected and actual on failure
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
be_close
change
eql
equal
have
have_exactly
have_at_least
have_at_most
include
match
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)
The anything() mock argument constraint matcher
should == #<Object:0x1838988>
should == Class
should == 1
should == "a string"
should == :a_symbol
The boolean() mock argument constraint matcher
should == true
should == false
should not == #<Object:0x182e834>
should not == Class
should not == 1
should not == "a string"
should not == :a_symbol
The an_instance_of() mock argument constraint matcher
should == "string"
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 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
should raise_error
should pass if anything is raised
should fail if nothing is raised
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 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
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_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 respond_to(:sym)
should pass if target responds to :sym
should fail target does not respond to :sym
should respond_to(message1, message2)
should pass if target responds to both messages
should fail target does not respond to first message
should fail target does not respond to second message
should fail target does not respond to either message
should_not respond_to(:sym)
should pass if target does not respond to :sym
should fail target responds to :sym
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
Spec::Matchers::SimpleMatcher
should match pass match arg to block
should provide a stock failure message
should provide a stock negative failure message
should provide a description
Spec::Matchers::ThrowSymbol (constructed with no Symbol)
should match if any Symbol is thrown
should not match if no Symbol is thrown
should provide a failure message
should provide a negative failure message
Spec::Matchers::ThrowSymbol (constructed with a Symbol)
should match if correct Symbol is thrown
should not match if no Symbol is thrown
should not match if correct Symbol is thrown
should provide a failure message when no Symbol is thrown
should provide a failure message when wrong Symbol is thrown
should provide a negative failure message
should only match NameErrors raised by uncaught throws
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
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
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
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
An RSpec Mock
should hide internals in its inspect representation
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 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)
A Partial Mock
should respect subclasses
should
Stubs should correctly restore module methods
1 - stub the open method
2 - use File.open to create example.txt
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
Bug report 8302:
class method is not restored correctly when proxied
instance method is not restored correctly when proxied
failing MockArgumentConstraints
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
failing deprecated MockArgumentConstraints
should reject non boolean
should reject non numeric
should reject non string
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
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
should report line number of expectation of unreceived message
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 dont match when method called
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 (PENDING: Used to pass (false positive). Which one is wrong, the spec or the actual behavior?)
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 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 temporarily replace a method stub on a non-mock
should assign stub return values
a mock message receiving a block
should call the block after #should_receive
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 #with
should call the block after #ordered
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
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
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 :should_receive with an options hash
should report the file and line submitted with :expected_from
should use the message supplied with :message
using a Partial Mock,
should name the class in the failure message
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
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::Methods handling argument constraints with DEPRECATED symbols
should accept true as boolean
should accept false as boolean
should accept fixnum as numeric
should accept float as numeric
should accept string as anything
should match string
should match no args against any_args
should match no args against no_args
Spec::Mocks::Methods handling argument constraints
should accept true as boolean()
should accept false as boolean()
should accept fixnum as an_instance_of(Numeric)
should accept float as an_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()
Spec::Mocks::Methods handling non-constraint 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
should match against a Matcher
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
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 method stub
should return expected value when expected message is received
should ignore when expected message is received
should ignore when message is received with args
should ignore when expected message is not received
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
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
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
The bin/spec script
should have no warnings
Spec::Runner::ClassAndArgumentsParser.parse
should use a single : to separate class names from arguments
should raise an error when passed an empty string
Spec::Runner::CommandLine.run
should run directory
should run file
should raise when file does not exist
should return true when in --generate-options mode
should dump even if Interrupt exception is occurred
should heckle when options have heckle_runner
should run examples backwards if options.reverse is true
should pass its ExampleGroup to the reporter
runs only selected Examples when options.examples is set
sets Spec.run to true
Spec::Runner::DrbCommandLine without running local server
should print error when there is no running local server
Spec::Runner::DrbCommandLine with local server
should run against local server
should output green colorized text when running with --colour option
should output red colorized text when running with -c option
ExecutionContext
should provide duck_type()
should violate when violated()
should provide mock()
should provide stub()
should add method stubs to stub()
Spec::Runner::Formatter::FailingExampleGroupsFormatter
should add example name for each failure
should delimit ExampleGroup superclass descriptions with :
should remove druby url, which is used by Spec::Distributed
Spec::Runner::Formatter::FailingExamplesFormatter
should add example name for each failure
Spec::Runner::Formatter::HtmlFormatter
should produce HTML identical to the one we designed manually with --diff
should produce HTML identical to the one we designed manually with --dry-run
Spec::Runner::Formatter::ProfileFormatter
should print a heading
should record the current time when starting a new example
should correctly record a passed example
should sort the results in descending order
should print the top 10 results
Spec::Runner::Formatter::ProgressBarFormatter
should produce line break on start dump
should produce standard summary without pending when pending has a 0 count
should produce standard summary
should push green dot for passing spec
should push red F for failure spec
should push magenta F for error spec
should push blue F for fixed pending spec
should push nothing on start
should ensure two ':' in the first backtrace
should dump pending
ProgressBarFormatter outputting to custom out
should not throw NoMethodError on output_to_tty?
Spec::Runner::Formatter::ProgressBarFormatter dry run
should not produce summary on dry run
Spec::Runner::Formatter::SnippetExtractor
should fall back on a default message when it doesn't understand a line
should fall back on a default message when it doesn't find the file
Spec::Runner::Formatter::TextMateFormatter functional spec using --diff
should produce HTML identical to the one we designed manually with --diff
Spec::Runner::Formatter::TextMateFormatter functional spec using --dry-run
should produce HTML identical to the one we designed manually with --dry-run
Spec::Runner::Formatter::SpecdocFormatter where ExampleGroup has no superclasss with a description
should produce standard summary without pending when pending has a 0 count
should produce standard summary
should push ExampleGroup name
when having an error, should push failing spec name and failure number
when having an expectation failure, should push failing spec name and failure number
should push nothing on start
should push nothing on start dump
should push passing spec name
should push pending example name and message
should dump pending
Spec::Runner::Formatter::SpecdocFormatter where ExampleGroup has two superclasses with a description
when having an error, should push failing spec name and failure number
when having an expectation failure, should push failing spec name and failure number
Spec::Runner::Formatter::Story::HtmlFormatter
should just be poked at
should create spans for params
should create spanes for params in regexp steps
should create a ul for collected_steps
Spec::Runner::Formatter::Story::PlainTextFormatter
should summarize the number of scenarios when the run ends
should summarize the number of successful scenarios when the run ends
should summarize the number of failed scenarios when the run ends
should end cleanly (no characters on the last line) with successes
should end cleanly (no characters on the last line) with failures
should end cleanly (no characters on the last line) with pending steps
should summarize the number of pending scenarios when the run ends
should only count the first failure in one scenario
should only count the first pending in one scenario
should only count a failure before the first pending in one scenario
should produce details of the first failure each failed scenario when the run ends
should produce details of each pending step when the run ends
should document a story title and narrative
should document a scenario name
should document a step by sentence-casing its name
should document additional givens using And
should document additional events using And
should document additional outcomes using And
should document a GivenScenario followed by a Given using And
should document steps with replaced params
should document regexp steps with replaced params
should append PENDING for the first pending step
should append PENDING for pending after already pending
should append FAILED for the first failiure
should append SKIPPED for the second failiure
should append SKIPPED for the a failiure after PENDING
should print some white space after each story
should print nothing for collected_steps
should ignore messages it doesn't care about
HeckleRunner
should heckle all methods in all classes in a module
should heckle all methods in a class
should fail heckling when the class is not found
should heckle specific method in a class (with #)
should heckle specific method in a class (with .)
Heckler
should say yes to tests_pass? if specs pass
should say no to tests_pass? if specs fail
Heckler
should run examples on tests_pass?
NoisyBacktraceTweaker
should leave anything in lib spec dir
should leave anything in spec dir
should leave bin spec
should not barf on nil backtrace
should clean up double slashes
OptionParser
should accept files to include
should accept dry run option
should eval and use custom formatter when none of the builtins
should support formatters with relative and absolute paths, even on windows
should not be verbose by default
should not use colour by default
should print help to stdout if no args (PENDING: A regression since 1.0.8)
should print help to stdout
should print instructions about how to require missing formatter
should print version to stdout
should require file when require specified
should support c option
should support queens colour option
should support us color option
should support single example with -e option
should support single example with -s option (will be removed when autotest supports -e)
should support single example with --example option
should read several example names from file if --example is given an existing file name
should read no examples if given an empty file
should use html formatter when format is h
should use html story formatter when format is h
should use html formatter when format is html
should use html story formatter when format is html
should use html formatter with explicit output when format is html:test.html
should use noisy backtrace tweaker with b option
should use noisy backtrace tweaker with backtrace option
should use quiet backtrace tweaker by default
should use progress bar formatter by default
should use specdoc formatter when format is s
should use specdoc formatter when format is specdoc
should support diff option when format is not specified
should use unified diff format option when format is unified
should use context diff format option when format is context
should use custom diff format option when format is a custom format
should print instructions about how to fix missing differ
should support --line to identify spec
should fail with error message if file is dir along with --line
should fail with error message if file does not exist along with --line
should fail with error message if more than one files are specified along with --line
should fail with error message if --example and --line are used simultaneously
should heckle when --heckle is specified (and platform is not windows)
should read options from file when --options is specified
should default the formatter to ProgressBarFormatter when using options file
should read spaced and multi-line options from file when --options is specified
should save config to file when --generate-options is specified
should save config to file when -G is specified
when --drb is specified, calls DrbCommandLine all of the other ARGV arguments
should reverse spec order when --reverse is specified
should set an mtime comparator when --loadby mtime
should use the standard runner by default
should use a custom runner when given
should use a custom runner with extra options
Spec::Runner::Options#examples
should default to empty array
Spec::Runner::Options#include_pattern
should default to '**/*.rb'
Spec::Runner::Options#files_to_load
should load files following pattern
should not load files not following pattern
should load files in directories not following pattern
should not load files in directories not following pattern
Spec::Runner::Options#backtrace_tweaker
should default to QuietBacktraceTweaker
Spec::Runner::Options#dry_run
should default to false
Spec::Runner::Options#context_lines
should default to 3
Spec::Runner::Options#parse_diff with nil
should make diff_format unified
should set Spec::Expectations.differ to be a default differ
Spec::Runner::Options#parse_diff with 'unified'
should make diff_format unified and uses default differ_class
should set Spec::Expectations.differ to be a default differ
Spec::Runner::Options#parse_diff with 'context'
should make diff_format context and uses default differ_class
should set Spec::Expectations.differ to be a default differ
Spec::Runner::Options#parse_diff with Custom::Differ
should use custom differ_class
should set Spec::Expectations.differ to be a default differ
Spec::Runner::Options#parse_diff with missing class name
should raise error
Spec::Runner::Options#parse_example
with argument thats not a file path, sets argument as the example
with argument that is a file path, sets examples to contents of the file
Spec::Runner::Options#examples_should_not_be_run
should cause #run_examples to return true and do nothing
Spec::Runner::Options#load_class
should raise error when not class name
Spec::Runner::Options#reporter
returns a Reporter
Spec::Runner::Options#add_example_group affecting passed in example_group
Some Examples
runs 1
runs 2
runs all examples when options.examples is nil
Some Examples
runs 1
runs 2
keeps all example_definitions when options.examples is empty
Spec::Runner::Options#add_example_group affecting example_group
adds example_group when example_group has example_definitions and is not shared
Spec::Runner::Options#remove_example_group
should remove the ExampleGroup from the list of ExampleGroups
Spec::Runner::Options#run_examples
should use the standard runner by default
should use a custom runner when given
should use a custom runner with extra options
Spec::Runner::Options#run_examples when there are examples
runs the Examples and outputs the result
sets #examples_run? to true
Spec::Runner::Options#run_examples when there are no examples
does not run Examples and does not output a result
sets #examples_run? to false
Spec::Runner::CommandLine
should not output twice
QuietBacktraceTweaker
should not barf on nil backtrace
should remove anything from textmate ruby bundle
should remove anything in lib spec dir
should remove mock_frameworks/rspec
should remove bin spec
should clean up double slashes
Spec::Runner::Reporter
should assign itself as the reporter to options
should tell formatter when example_group is added
should handle multiple example_groups with same name
should handle multiple examples with the same name
should push stats to formatter even with no data
should push time to formatter
Spec::Runner::Reporter Spec::Runner::Reporter reporting one passing example
should tell formatter example passed
should not delegate to backtrace tweaker
should account for passing example in stats
Spec::Runner::Reporter Spec::Runner::Reporter reporting one failing example
should tell formatter that example failed
should delegate to backtrace tweaker
should account for failing example in stats
Spec::Runner::Reporter Spec::Runner::Reporter reporting one pending example (ExamplePendingError)
should tell formatter example is pending
should account for pending example in stats
Spec::Runner::Reporter Spec::Runner::Reporter reporting one pending example (PendingExampleFixedError)
should tell formatter pending example is fixed
c
1
2
d
3
4
SpecParserSubject
5
SpecParserSubject described
6
SpecParserSubject described
7
described
8
SpecParser
should find spec name for 'specify' at same line
should find spec name for 'specify' at end of spec line
should find context for 'context' above all specs
should find spec name for 'it' at same line
should find spec name for 'it' at end of spec line
should find context for 'describe' above all specs
should find nearest example name between examples
should find nothing outside a context
should find context name for type
should find context and spec name for type
should find context and description for type
should find context and description and example for type
should find context and description for type with modifications
should find context and described and example for type with modifications
should find example group
should find example
Spec::Runner.configure
should yield global configuration
Spec::Story::Extensions::Main#run_story
should create a PlainTextStoryRunner with run_story
should yield the runner if arity == 1
should run in the runner if arity == 0
should tell the PlainTextStoryRunner to run with run_story
Spec::Story::Extensions::Main#steps_for
should have no steps for a non existent key
should create steps for a key
should append steps to steps_for a given key
Spec::Story::Extensions::Main#with_steps_for adding new steps
should result in a group containing pre-existing steps and newly defined steps
should not add its steps to the existing group
Spec::Story::Extensions::Main#with_steps_for running a story
should create a PlainTextStoryRunner with a path
should create a PlainTextStoryRunner with a path and options
should pass the group it creates to the runner's steps
should run a story
Kernel#Story
should delegate to ::Spec::Story::Runner.story_runner
Spec::Story::GivenScenario
should execute a scenario from the current story in its world
Spec::Story::Runner::PlainTextStoryRunner
should provide access to steps
should parse a story file
should build up a mediator with its own steps and the singleton story_runner
should build up a parser with the mediator
should tell the mediator to run the stories
should accept a block instead of a path
should tell you if you try to run with no path set
should pass options to the mediator
should provide access to its options
Spec::Story::Runner::ScenarioCollector
should construct scenarios with the supplied story
Spec::Story::Runner::ScenarioRunner
should run a scenario in its story
should allow scenarios to share methods
should notify listeners when a scenario starts
should notify listeners when a scenario succeeds
should notify listeners ONCE when a scenario raises an error
should notify listeners when a scenario is pending
Spec::Story::Runner::StoryMediator
should have no stories
should create two stories
should create a scenario
should create a given scenario step if one matches (PENDING: need to untangle the dark mysteries of the story runner - something needs to get stubbed here)
should create a given step if one matches
should create a pending step if no given step matches
should create a when step if one matches
should create a pending step if no when step matches
should create a then step if one matches
should create a pending step if no 'then' step matches
should pass options to the stories it creates
Spec::Story::Runner::StoryParser
should parse no lines
should ignore text before the first Story: begins
should create a story
should create a story when line has leading spaces
should add a one line narrative to the story
should add a multi line narrative to the story
should exclude blank lines from the narrative
should exclude Scenario from the narrative
Spec::Story::Runner::StoryParser in Story state
should create a second Story for Story
should include And in the narrative
should create a Scenario for Scenario
should include Given in the narrative
should include Given: in the narrative
should include When in the narrative
should include Then in the narrative
should include other in the story
Spec::Story::Runner::StoryParser in Scenario state
should create a Story for Story
should create a Scenario for Scenario
should raise for And
should create a Given for Given
should create a Given for Given:
should create a GivenScenario for GivenScenario
should create a GivenScenario for GivenScenario:
should transition to Given state after GivenScenario
should transition to Given state after GivenScenario:
should create a When for When
should create a When for When:
should create a Then for Then
should create a Then for Then:
should ignore other
Spec::Story::Runner::StoryParser in Given state
should create a Story for Story
should create a Scenario for Scenario
should create a second Given for Given
should create a second Given for And
should create a second Given for And:
should create a When for When
should create a When for When:
should create a Then for Then
should create a Then for Then:
should ignore other
Spec::Story::Runner::StoryParser in When state
should create a Story for Story
should create a Scenario for Scenario
should create Given for Given
should create Given for Given:
should create a second When for When
should create a second When for When:
should create a second When for And
should create a second When for And:
should create a Then for Then
should create a Then for Then:
should ignore other
Spec::Story::Runner::StoryParser in Then state
should create a Story for Story
should create a Scenario for Scenario
should create Given for Given
should create Given for Given:
should create When for When
should create When for When:
should create a Then for Then
should create a Then for Then:
should create a second Then for And
should create a second Then for And:
should ignore other
Spec::Story::Runner::StoryRunner
should collect all the stories
should gather all the scenarios in the stories
should run each scenario in a separate object
should use the provided world creator to create worlds
should notify listeners of the scenario count when the run starts
should notify listeners when a story starts
should notify listeners when the run ends
should run a story in an instance of a specified class
should pass initialization params through to the constructed instance
should find a scenario in the current story by name
should clean the steps between stories
Spec::Story::Runner module
should wire up a singleton StoryRunner
should set its options based on ARGV
should add a reporter to the runner classes
should add a documenter to the runner classes if one is specified
should add any registered listener to the runner classes
Spec::Story::Scenario
should not raise an error if no body is supplied
Spec::Story::StepGroup
should not find a matcher if empty
should create a given_scenario matcher
should create a given matcher
should create a when matcher
should create a them matcher
should add a matcher object
should add it matchers to another StepGroup (with one given)
should add it matchers to another StepGroup (with some of each type)
should append another collection
should append several other collections
should yield itself on initialization
should support defaults
should create a Given
should create a When
should create a Then
should create steps in a block
should clear itself
should tell you when it is empty
should tell you when it is not empty
should handle << nil
Spec::Story::StepMother
should store a step by name and type
should NOT raise an error if a step is missing
should create a default step which raises a pending error
should clear itself
should use assigned steps
Spec::Story::Step matching
should match a text string
should not match a text string that does not start the same
should not match a text string that does not end the same
should match a text string with a param
should not be greedy
should match a text string with 3 params
should match a text string with a param at the beginning
should match a text string with a param at the end
should not match a different string
should match a regexp
should match a regexp with a match group
should match a regexp with a named variable
should not match a non matching regexp
should not match a non matching regexp with a named variable
should not get bogged down by parens in strings
should match any option of an alteration
should match alteration as well as a variable
should match alteration as well as a named variable
should match alteration as well as a anonymous and named variable
Spec::Story::Step
should make complain with no block
should perform itself on an object
should perform itself with one parameter with match expression
should perform itself with one parameter without a match expression
should perform itself with 2 parameters
should perform itself when defined with a regexp with 2 parameters
Spec::Story::Story
should run itself in a given object
should not raise an error if no block is supplied
should raise when error raised running in another object
should use the steps it is told to using a StepGroup
should use the steps it is told to using a key
should use the steps it is told to using multiple keys
Spec::Story::World
should create an object that mixes in a World
should create a World from any object type
should pass arguments to #new when creating an object of a specified type that mixes in a world
should execute a Given, When or Then step
should interpret Given... And... as multiple givens
should interpret When... And... as multiple events
should interpret Then... And... as multiple outcomes
should reuse a given across scenarios
should reuse an event across scenarios
should reuse an outcome across scenarios
should preserve instance variables between steps within a scenario
should invoke a reused step in the new object instance
should collect a failure from a Given step
should collect a failure from a When step
should collect a failure from a Then step
should inform listeners when it runs a Given, When or Then step
should tell listeners but not execute the step in dry-run mode
should suppress listeners while it runs a GivenScenario
should interpret GivenScenario... And... as multiple givens
should provide rspec matchers
should use assigned matchers
Translator
should translate files
should translate context_setup do
should translate context_setup {foo}
should translate context ' to describe '
should translate context " to describe "
should translate spaces then context " to describe "
should not translate context=foo
should not translate context = foo
should not translate context = foo
should translate should_be_close
should translate should_not_raise
should translate should_throw
should not translate 0.9 should_not
should leave should_not_receive
should leave should_receive
should translate multi word predicates
should translate multi word predicates prefixed with be
should translate be(expected) to equal(expected)
should translate instance_of
should translate should_be <
should translate should_be <=
should translate should_be >=
should translate should_be >
should translate should_be_happy
should translate custom method taking regexp with parenthesis
should translate custom method taking regexp without parenthesis
should translate should_not_be_nil
should translate kind of
should translate should_be_true
should translate should_match on a regexp, in a var, in a block
should translate close_to without parens
should support symbol arguments
should support instance var arguments
should support lambdas as expecteds
should support fully qualified names
should translate redirects
should translate :any_args
should translate :anything
should translate :boolean
should translate :no_args
should translate :numeric
should translate :string
Special Example Group
calls prepend_before
Special Example Group
calls append_before
Special Example Group
calls prepend_after
Special Example Group
calls append_after
#<Class:0x11c6ff0>
should use ExampleMethods callbacks
A
a1
A B
b2
b3
Some Examples
runs 1
runs 2
Some Examples
runs 1
runs 2
Some Examples
uses this example_group