nutshell-crm 0.0.1

data/vendor/bundle/gems/rspec-expectations-2.7.0/features/built_in_matchers/respond_to.feature

@@ -0,0 +1,78 @@
+Feature: respond_to matcher
+
+  Use the respond_to matcher to specify details of an object's interface.  In
+  its most basic form:
+
+    obj.should respond_to(:foo) # pass if obj.respond_to?(:foo)
+
+  You can specify that an object responds to multiple messages in a single
+  statement with multiple arguments passed to the matcher:
+    
+    obj.should respond_to(:foo, :bar) # passes if obj.respond_to?(:foo) && obj.respond_to?(:bar)
+
+  If the number of arguments accepted by the method is important to you,
+  you can specify that as well:
+
+    obj.should respond_to(:foo).with(1).argument
+    obj.should respond_to(:bar).with(2).arguments
+
+  Note that this matcher relies entirely upon #respond_to?.  If an object
+  dynamically responds to a message via #method_missing, but does not indicate
+  this via #respond_to?, then this matcher will give you false results.
+
+  Scenario: basic usage
+    Given a file named "respond_to_matcher_spec.rb" with:
+      """
+      describe "a string" do
+        it { should respond_to(:length) }
+        it { should respond_to(:hash, :class, :to_s) }
+        it { should_not respond_to(:to_model) }
+        it { should_not respond_to(:compact, :flatten) }
+
+        # deliberate failures
+        it { should respond_to(:to_model) }
+        it { should respond_to(:compact, :flatten) }
+        it { should_not respond_to(:length) }
+        it { should_not respond_to(:hash, :class, :to_s) }
+
+        # mixed examples--String responds to :length but not :flatten
+        # both specs should fail
+        it { should respond_to(:length, :flatten) }
+        it { should_not respond_to(:length, :flatten) }
+      end
+      """
+    When I run `rspec respond_to_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 10 examples, 6 failures                                    |
+      | expected "a string" to respond to :to_model                |
+      | expected "a string" to respond to :compact, :flatten       |
+      | expected "a string" not to respond to :length              |
+      | expected "a string" not to respond to :hash, :class, :to_s |
+      | expected "a string" to respond to :flatten                 |
+      | expected "a string" not to respond to :length              |
+
+  Scenario: specify arguments
+    Given a file named "respond_to_matcher_argument_checking_spec.rb" with:
+      """
+      describe 7 do
+        it { should respond_to(:zero?).with(0).arguments }
+        it { should_not respond_to(:zero?).with(1).argument }
+
+        it { should respond_to(:between?).with(2).arguments }
+        it { should_not respond_to(:between?).with(7).arguments }
+
+        # deliberate failures
+        it { should respond_to(:zero?).with(1).argument }
+        it { should_not respond_to(:zero?).with(0).arguments }
+
+        it { should respond_to(:between?).with(7).arguments }
+        it { should_not respond_to(:between?).with(2).arguments }
+      end
+      """
+    When I run `rspec respond_to_matcher_argument_checking_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                                  |
+      | expected 7 to respond to :zero? with 1 argument         |
+      | expected 7 not to respond to :zero? with 0 arguments    |
+      | expected 7 to respond to :between? with 7 arguments     |
+      | expected 7 not to respond to :between? with 2 arguments |

data/vendor/bundle/gems/rspec-expectations-2.7.0/features/built_in_matchers/satisfy.feature

@@ -0,0 +1,31 @@
+Feature: satisfy matcher
+
+  The satisfy matcher is extremely flexible and can handle almost anything
+  you want to specify.  It passes if the block you provide returns true:
+
+    10.should satisfy { |v| v % 5 == 0 }
+    7.should_not satisfy { |v| v % 5 == 0 }
+
+  This flexibility comes at a cost, however: the failure message
+  ("expected [actual] to satisfy block") is not very descriptive
+  or helpful.  You will usually be better served by using one of
+  the other built-in matchers, or writing a custom matcher.
+
+  Scenario: basic usage
+    Given a file named "satisfy_matcher_spec.rb" with:
+      """
+      describe 10 do
+        it { should satisfy { |v| v > 5 } }
+        it { should_not satisfy { |v| v > 15 } }
+
+        # deliberate failures
+        it { should_not satisfy { |v| v > 5 } }
+        it { should satisfy { |v| v > 15 } }
+      end
+      """
+    When I run `rspec satisfy_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures           |
+      | expected 10 not to satisfy block |
+      | expected 10 to satisfy block     |
+

data/vendor/bundle/gems/rspec-expectations-2.7.0/features/built_in_matchers/throw_symbol.feature

@@ -0,0 +1,85 @@
+Feature: throw_symbol matcher
+
+  The throw_symbol matcher is used to specify that a block of code
+  throws a symbol.  The most basic form passes if any symbol is thrown:
+
+    expect { throw :foo }.to throw_symbol
+
+  You'll often want to specify that a particular symbol is thrown:
+
+    expect { throw :foo }.to throw_symbol(:foo)
+
+  If you care about the additional argument given to throw, you can
+  specify that as well:
+
+    expect { throw :foo, 7 }.to throw_symbol(:foo, 7)
+
+  Scenario: basic usage
+    Given a file named "throw_symbol_matcher_spec.rb" with:
+      """
+      describe "throw" do
+        specify { expect { throw :foo    }.to     throw_symbol }
+        specify { expect { throw :bar, 7 }.to     throw_symbol }
+        specify { expect { 5 + 5         }.to_not throw_symbol }
+
+        # deliberate failures
+        specify { expect { throw :foo    }.to_not throw_symbol }
+        specify { expect { throw :bar, 7 }.to_not throw_symbol }
+        specify { expect { 5 + 5         }.to     throw_symbol }
+      end
+      """
+    When I run `rspec throw_symbol_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 6 examples, 3 failures                      |
+      | expected no Symbol to be thrown, got :foo   |
+      | expected no Symbol to be thrown, got :bar   |
+      | expected a Symbol to be thrown, got nothing |
+
+  Scenario: specify thrown symbol
+    Given a file named "throw_symbol_matcher_spec.rb" with:
+      """
+      describe "throw symbol" do
+        specify { expect { throw :foo    }.to     throw_symbol(:foo) }
+        specify { expect { throw :foo, 7 }.to     throw_symbol(:foo) }
+        specify { expect { 5 + 5         }.to_not throw_symbol(:foo) }
+        specify { expect { throw :bar    }.to_not throw_symbol(:foo) }
+
+        # deliberate failures
+        specify { expect { throw :foo    }.to_not throw_symbol(:foo) }
+        specify { expect { throw :foo, 7 }.to_not throw_symbol(:foo) }
+        specify { expect { 5 + 5         }.to     throw_symbol(:foo) }
+        specify { expect { throw :bar    }.to     throw_symbol(:foo) }
+      end
+      """
+    When I run `rspec throw_symbol_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                          |
+      | expected :foo not to be thrown, got :foo        |
+      | expected :foo not to be thrown, got :foo with 7 |
+      | expected :foo to be thrown, got nothing         |
+      | expected :foo to be thrown, got :bar            |
+
+  Scenario: specify thrown symbol and argument
+    Given a file named "throw_symbol_argument_matcher_spec.rb" with:
+      """
+      describe "throw symbol with argument" do
+        specify { expect { throw :foo, 7 }.to     throw_symbol(:foo, 7) }
+        specify { expect { throw :foo, 8 }.to_not throw_symbol(:foo, 7) }
+        specify { expect { throw :bar, 7 }.to_not throw_symbol(:foo, 7) }
+        specify { expect { throw :foo    }.to_not throw_symbol(:foo, 7) }
+
+        # deliberate failures
+        specify { expect { throw :foo, 7 }.to_not throw_symbol(:foo, 7) }
+        specify { expect { throw :foo, 8 }.to     throw_symbol(:foo, 7) }
+        specify { expect { throw :bar, 7 }.to     throw_symbol(:foo, 7) }
+        specify { expect { throw :foo    }.to     throw_symbol(:foo, 7) }
+      end
+      """
+    When I run `rspec throw_symbol_argument_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                                       |
+      | expected :foo with 7 not to be thrown, got :foo with 7       |
+      | expected :foo with 7 to be thrown, got :foo with 8           |
+      | expected :foo with 7 to be thrown, got :bar                  |
+      | expected :foo with 7 to be thrown, got :foo with no argument |
+

data/vendor/bundle/gems/rspec-expectations-2.7.0/features/built_in_matchers/types.feature

@@ -0,0 +1,114 @@
+Feature: specify types of objects
+
+  rspec-expectations includes two matchers to specify types of objects:
+
+    * obj.should be_kind_of(type): calls obj.kind_of?(type), which returns
+      true if type is in obj's class hierarchy or is a module and is
+      included in a class in obj's class hierarchy.
+    * obj.should be_instance_of(type): calls obj.instance_of?(type), which
+      returns true if and only if type if obj's class.
+
+  Both of these matchers have aliases:
+
+    * obj.should be_a_kind_of(type) # same as obj.should be_kind_of(type)
+    * obj.should be_a(type) # same as obj.should be_kind_of(type)
+    * obj.should be_an(type) # same as obj.should be_kind_of(type)
+    * obj.should be_an_instance_of(type) # same as obj.should be_instance_of(type)
+
+  Scenario: be_(a_)kind_of matcher
+    Given a file named "be_kind_of_matcher_spec.rb" with:
+      """
+      module MyModule; end
+
+      class Fixnum
+        include MyModule
+      end
+
+      describe 17 do
+        # the actual class
+        it { should be_kind_of(Fixnum) }
+        it { should be_a_kind_of(Fixnum) }
+        it { should be_a(Fixnum) }
+
+        # the superclass
+        it { should be_kind_of(Integer) }
+        it { should be_a_kind_of(Integer) }
+        it { should be_an(Integer) }
+
+        # an included module
+        it { should be_kind_of(MyModule) }
+        it { should be_a_kind_of(MyModule) }
+        it { should be_a(MyModule) }
+
+        # negative passing case
+        it { should_not be_kind_of(String) }
+        it { should_not be_a_kind_of(String) }
+        it { should_not be_a(String) }
+
+        # deliberate failures
+        it { should_not be_kind_of(Fixnum) }
+        it { should_not be_a_kind_of(Fixnum) }
+        it { should_not be_a(Fixnum) }
+        it { should_not be_kind_of(Integer) }
+        it { should_not be_a_kind_of(Integer) }
+        it { should_not be_an(Integer) }
+        it { should_not be_kind_of(MyModule) }
+        it { should_not be_a_kind_of(MyModule) }
+        it { should_not be_a(MyModule) }
+        it { should be_kind_of(String) }
+        it { should be_a_kind_of(String) }
+        it { should be_a(String) }
+      end
+      """
+    When I run `rspec be_kind_of_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 24 examples, 12 failures                 |
+      | expected 17 not to be a kind of Fixnum   |
+      | expected 17 not to be a kind of Integer  |
+      | expected 17 not to be a kind of MyModule |
+      | expected 17 to be a kind of String       |
+
+  Scenario: be_(an_)instance_of matcher
+    Given a file named "be_instance_of_matcher_spec.rb" with:
+      """
+      module MyModule; end
+
+      class Fixnum
+        include MyModule
+      end
+
+      describe 17 do
+        # the actual class
+        it { should be_instance_of(Fixnum) }
+        it { should be_an_instance_of(Fixnum) }
+
+        # the superclass
+        it { should_not be_instance_of(Integer) }
+        it { should_not be_an_instance_of(Integer) }
+
+        # an included module
+        it { should_not be_instance_of(MyModule) }
+        it { should_not be_an_instance_of(MyModule) }
+
+        # another class with no relation to the subject's hierarchy
+        it { should_not be_instance_of(String) }
+        it { should_not be_an_instance_of(String) }
+
+        # deliberate failures
+        it { should_not be_instance_of(Fixnum) }
+        it { should_not be_an_instance_of(Fixnum) }
+        it { should be_instance_of(Integer) }
+        it { should be_an_instance_of(Integer) }
+        it { should be_instance_of(MyModule) }
+        it { should be_an_instance_of(MyModule) }
+        it { should be_instance_of(String) }
+        it { should be_an_instance_of(String) }
+      end
+      """
+    When I run `rspec be_instance_of_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 16 examples, 8 failures                     |
+      | expected 17 not to be an instance of Fixnum |
+      | expected 17 to be an instance of Integer    |
+      | expected 17 to be an instance of MyModule   |
+      | expected 17 to be an instance of String     |

data/vendor/bundle/gems/rspec-expectations-2.7.0/features/custom_matchers/access_running_example.feature

@@ -0,0 +1,53 @@
+Feature: access running example
+
+  In order to take advantage of services that are available
+    in my examples when I'm writing matchers
+  As a spec author
+  I want to call methods on the running example
+
+  If the method exists in the context of the example, it gets
+  called. If not, a NoMethodError is raised on the Matcher itself
+  (not the example).
+
+  Scenario: call method defined on example from matcher
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec::Matchers.define :bar do
+        match do |_|
+          foo == "foo"
+        end
+      end
+
+      describe "something" do
+        def foo
+          "foo"
+        end
+
+        it "does something" do
+          "foo".should bar
+        end
+      end
+      """
+    When I run `rspec ./example_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: call method _not_ defined on example from matcher
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec::Matchers.define :bar do
+        match do |_|
+          foo == "foo"
+        end
+      end
+
+      describe "something" do
+        it "does something" do
+          "foo".should bar
+        end
+      end
+      """
+    When I run `rspec ./example_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+    And the output should contain "undefined local variable"
+    And the output should contain "RSpec::Matchers::Matcher"
+    And the output should not contain "ExampleGroup"

data/vendor/bundle/gems/rspec-expectations-2.7.0/features/custom_matchers/define_diffable_matcher.feature

@@ -0,0 +1,27 @@
+Feature: define diffable matcher
+
+  When a matcher is defined as diffable, and the --diff
+  flag is set, the output will include a diff of the submitted
+  objects.
+
+  @wip
+  Scenario: define a diffable matcher
+    Given a file named "diffable_matcher_spec.rb" with:
+      """
+      RSpec::Matchers.define :be_just_like do |expected|
+        match do |actual|
+          actual == expected
+        end
+        
+        diffable
+      end
+
+      describe "this" do
+        it {should be_just_like("that")}
+      end
+      """
+    When I run `rspec ./diffable_matcher_spec.rb --diff`
+    Then the exit status should not be 0
+
+    And the output should contain "should be just like that"
+    And the output should contain "Diff:\n@@ -1,2 +1,2 @@\n-that\n+this"

data/vendor/bundle/gems/rspec-expectations-2.7.0/features/custom_matchers/define_matcher.feature

@@ -0,0 +1,340 @@
+Feature: define matcher
+
+  In order to express my domain clearly in my code examples
+  As an RSpec user
+  I want a shortcut to define custom matchers
+
+  Scenario: define a matcher with default messages
+    Given a file named "matcher_with_default_message_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+      end
+
+      describe 9 do
+        it {should be_a_multiple_of(3)}
+      end
+
+      describe 9 do
+        it {should_not be_a_multiple_of(4)}
+      end
+
+      # fail intentionally to generate expected output
+      describe 9 do
+        it {should be_a_multiple_of(4)}
+      end
+
+      # fail intentionally to generate expected output
+      describe 9 do
+        it {should_not be_a_multiple_of(3)}
+      end
+
+      """
+    When I run `rspec ./matcher_with_default_message_spec.rb --format documentation`
+    Then the exit status should not be 0
+
+    And the output should contain "should be a multiple of 3"
+    And the output should contain "should not be a multiple of 4"
+    And the output should contain "Failure/Error: it {should be_a_multiple_of(4)}"
+    And the output should contain "Failure/Error: it {should_not be_a_multiple_of(3)}"
+
+    And the output should contain "4 examples, 2 failures"
+    And the output should contain "expected 9 to be a multiple of 4"
+    And the output should contain "expected 9 not to be a multiple of 3"
+
+  Scenario: overriding the failure_message_for_should
+    Given a file named "matcher_with_failure_message_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+        failure_message_for_should do |actual|
+          "expected that #{actual} would be a multiple of #{expected}"
+        end
+      end
+
+      # fail intentionally to generate expected output
+      describe 9 do
+        it {should be_a_multiple_of(4)}
+      end
+      """
+    When I run `rspec ./matcher_with_failure_message_spec.rb`
+    Then the exit status should not be 0
+    And the stdout should contain "1 example, 1 failure"
+    And the stdout should contain "expected that 9 would be a multiple of 4"
+
+  Scenario: overriding the failure_message_for_should_not
+    Given a file named "matcher_with_failure_for_message_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+        failure_message_for_should_not do |actual|
+          "expected that #{actual} would not be a multiple of #{expected}"
+        end
+      end
+
+      # fail intentionally to generate expected output
+      describe 9 do
+        it {should_not be_a_multiple_of(3)}
+      end
+      """
+    When I run `rspec ./matcher_with_failure_for_message_spec.rb`
+    Then the exit status should not be 0
+    And the stdout should contain "1 example, 1 failure"
+    And the stdout should contain "expected that 9 would not be a multiple of 3"
+
+  Scenario: overriding the description
+    Given a file named "matcher_overriding_description_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+        description do
+          "be multiple of #{expected}"
+        end
+      end
+
+      describe 9 do
+        it {should be_a_multiple_of(3)}
+      end
+
+      describe 9 do
+        it {should_not be_a_multiple_of(4)}
+      end
+      """
+    When I run `rspec ./matcher_overriding_description_spec.rb --format documentation`
+    Then the exit status should be 0
+    And the stdout should contain "2 examples, 0 failures"
+    And the stdout should contain "should be multiple of 3"
+    And the stdout should contain "should not be multiple of 4"
+
+  Scenario: with no args
+    Given a file named "matcher_with_no_args_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :have_7_fingers do
+        match do |thing|
+          thing.fingers.length == 7
+        end
+      end
+
+      class Thing
+        def fingers; (1..7).collect {"finger"}; end
+      end
+
+      describe Thing do
+        it {should have_7_fingers}
+      end
+      """
+    When I run `rspec ./matcher_with_no_args_spec.rb --format documentation`
+    Then the exit status should be 0
+    And the stdout should contain "1 example, 0 failures"
+    And the stdout should contain "should have 7 fingers"
+
+  Scenario: with multiple args
+    Given a file named "matcher_with_multiple_args_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_the_sum_of do |a,b,c,d|
+        match do |sum|
+          a + b + c + d == sum
+        end
+      end
+
+      describe 10 do
+        it {should be_the_sum_of(1,2,3,4)}
+      end
+      """
+    When I run `rspec ./matcher_with_multiple_args_spec.rb --format documentation`
+    Then the exit status should be 0
+    And the stdout should contain "1 example, 0 failures"
+    And the stdout should contain "should be the sum of 1, 2, 3, and 4"
+
+  Scenario: with helper methods
+    Given a file named "matcher_with_internal_helper_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :have_same_elements_as do |sample|
+        match do |actual|
+          similar?(sample, actual)
+        end
+
+        def similar?(a, b)
+          a.sort == b.sort
+        end
+      end
+
+      describe "these two arrays" do
+        specify "should be similar" do
+          [1,2,3].should have_same_elements_as([2,3,1])
+        end
+      end
+      """
+    When I run `rspec ./matcher_with_internal_helper_spec.rb`
+    Then the exit status should be 0
+    And the stdout should contain "1 example, 0 failures"
+
+  Scenario: scoped in a module
+    Given a file named "scoped_matcher_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      module MyHelpers
+        extend RSpec::Matchers::DSL
+
+        matcher :be_just_like do |expected|
+          match {|actual| actual == expected}
+        end
+      end
+
+      describe "group with MyHelpers" do
+        include MyHelpers
+        it "has access to the defined matcher" do
+          5.should be_just_like(5)
+        end
+      end
+
+      describe "group without MyHelpers" do
+        it "does not have access to the defined matcher" do
+          expect do
+            5.should be_just_like(5)
+          end.to raise_exception
+        end
+      end
+      """
+
+    When I run `rspec ./scoped_matcher_spec.rb`
+    Then the stdout should contain "2 examples, 0 failures"
+
+  Scenario: scoped in an example group
+    Given a file named "scoped_matcher_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      describe "group with matcher" do
+        matcher :be_just_like do |expected|
+          match {|actual| actual == expected}
+        end
+
+        it "has access to the defined matcher" do
+          5.should be_just_like(5)
+        end
+
+        describe "nested group" do
+          it "has access to the defined matcher" do
+            5.should be_just_like(5)
+          end
+        end
+
+      end
+
+      describe "group without matcher" do
+        it "does not have access to the defined matcher" do
+          expect do
+            5.should be_just_like(5)
+          end.to raise_exception
+        end
+      end
+      """
+
+    When I run `rspec scoped_matcher_spec.rb`
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: matcher with separate logic for should and should_not
+    Given a file named "matcher_with_separate_should_not_logic_spec.rb" with:
+      """
+      RSpec::Matchers.define :contain do |*expected|
+        match_for_should do |actual|
+          expected.all? { |e| actual.include?(e) }
+        end
+
+        match_for_should_not do |actual|
+          expected.none? { |e| actual.include?(e) }
+        end
+      end
+
+      describe [1, 2, 3] do
+        it { should contain(1, 2) }
+        it { should_not contain(4, 5, 6) }
+
+        # deliberate failures
+        it { should contain(1, 4) }
+        it { should_not contain(1, 4) }
+      end
+      """
+    When I run `rspec matcher_with_separate_should_not_logic_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures                    |
+      | expected [1, 2, 3] to contain 1 and 4     |
+      | expected [1, 2, 3] not to contain 1 and 4 |
+
+  Scenario: use define_method to create a helper method with access to matcher params
+    Given a file named "define_method_spec.rb" with:
+      """
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        define_method :is_multiple? do |actual|
+          actual % expected == 0
+        end
+        match { |actual| is_multiple?(actual) }
+      end
+
+      describe 9 do
+        it { should be_a_multiple_of(3) }
+        it { should_not be_a_multiple_of(4) }
+
+        # deliberate failures
+        it { should be_a_multiple_of(2) }
+        it { should_not be_a_multiple_of(3) }
+      end
+      """
+    When I run `rspec define_method_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures               |
+      | expected 9 to be a multiple of 2     |
+      | expected 9 not to be a multiple of 3 |
+
+  Scenario: include a module with helper methods in the matcher
+    Given a file named "include_module_spec.rb" with:
+      """
+      module MatcherHelpers
+        def is_multiple?(actual, expected)
+          actual % expected == 0
+        end
+      end
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        include MatcherHelpers
+        match { |actual| is_multiple?(actual, expected) }
+      end
+
+      describe 9 do
+        it { should be_a_multiple_of(3) }
+        it { should_not be_a_multiple_of(4) }
+
+        # deliberate failures
+        it { should be_a_multiple_of(2) }
+        it { should_not be_a_multiple_of(3) }
+      end
+      """
+    When I run `rspec include_module_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures               |
+      | expected 9 to be a multiple of 2     |
+      | expected 9 not to be a multiple of 3 |