riot 0.12.3 → 0.12.4

data/CHANGELOG

@@ -1,3 +1,8 @@
+== 0.12.4
+
+==== Adding Riot.plain! option for not printing output in color [c00lryguy,
+jaknowlden]
+
 == 0.12.3
 
 ==== Going nuts with context helpers: should_not, asserts/denies_topic arguments [achiu]

data/Rakefile

@@ -32,5 +32,3 @@ end
 desc "Run all of them fancy benchmarks, Howard!"
 task("test:benchmarks") { run_benchmarks("ruby") }
 
-#
-# Some monks like diamonds. I like gems.

data/lib/riot.rb

@@ -34,42 +34,54 @@ module Riot
   #
   # @return [Riot::Reporter] the reporter that was used
   def self.run
-    the_reporter = reporter.new
+    the_reporter = reporter.new(Riot.reporter_options)
     the_reporter.summarize do
       root_contexts.each { |ctx| ctx.run(the_reporter) }
     end unless root_contexts.empty?
     the_reporter
   end
 
+  # Options that configure how Riot will run.
+  # 
+  # @return [Hash] the options that tell Riot how to run
+  def self.options
+    @options ||= {
+      :silent => false,
+      :alone => false,
+      :reporter => Riot::StoryReporter,
+      :reporter_options => {:plain => false}
+    }
+  end
+
   # This means you don't want to see any output from Riot. A "quiet riot".
   def self.silently!
-    @silent = true
+    Riot.options[:silent] = true
   end
 
   # Reponds to whether Riot is reporting silently.
   #
   # @return [Boolean]
   def self.silently?
-    defined?(@silent) && @silent == true
+    Riot.options[:silent] == true
   end
 
   # This means you don't want Riot to run tests for you. You will execute Riot.run manually.
   def self.alone!
-    @alone = true
+    Riot.options[:alone] = true
   end
 
   # Responds to whether Riot will run +at_exit+ (false) or manually (true).
   #
   # @return [Boolean]
   def self.alone?
-    defined?(@alone) && @alone == true
+    Riot.options[:alone] == true
   end
 
   # Allows the reporter class to be changed. Do this before tests are started.
   #
   # @param [Class] reporter_class the Class that represents a {Riot::Reporter}
   def self.reporter=(reporter_class)
-    @reporter_class = reporter_class
+    Riot.options[:reporter] = reporter_class
   end
 
   # Returns the class for the reporter that is currently selected. If no reporter was explicitly selected,
@@ -77,11 +89,14 @@ module Riot
   #
   # @return [Class] the Class that represents a {Riot::Reporter}
   def self.reporter
-    if Riot.silently?
-      Riot::SilentReporter
-    else
-      (defined?(@reporter_class) && @reporter_class) || Riot::StoryReporter
-    end
+    Riot.silently? ? Riot::SilentReporter : Riot.options[:reporter]
+  end
+
+  # Returns the options that will be passed to the Reporter when it is created.
+  #
+  # @return [Hash] the Hash of current options
+  def self.reporter_options
+    Riot.options[:reporter_options]
   end
 
   # @todo make this a flag that DotMatrix and Story respect and cause them to print errors/failures
@@ -100,6 +115,11 @@ module Riot
     Riot.reporter = Riot::PrettyDotMatrixReporter
   end
 
+  # Tells Riot to turn color off in the output
+  def self.plain!
+    Riot.reporter_options[:plain] = true
+  end
+
   # Making sure to account for Riot being run as part of a larger rake task (or something similar).
   # If a child process exited with a failing status, probably don't want to run Riot tests; just exit
   # with the child status.
@@ -109,7 +129,6 @@ module Riot
       exit(status || run.success?)
     end
   end
-  
 end # Riot
 
 # A little bit of monkey-patch so we can have +context+ available anywhere.
@@ -130,3 +149,4 @@ class Array
     last.is_a?(::Hash) ? pop : {}
   end
 end
+

data/lib/riot/assertion_macro.rb

@@ -10,7 +10,7 @@ module Riot
   #
   #     asserts(:comments).empty?
   #     denies(:comments).empty?
-  # 
+  #
   # == Writing your own macros
   #
   # Macros are added by subclassing {AssertionMacro}. For example, here's
@@ -18,7 +18,7 @@ module Riot
   #
   #     class EmptyMacro < AssertionMacro
   #       register :empty
-  #        
+  #
   #       def evaluate(actual)
   #         actual.length == 0 ? pass : fail(expected_message(actual).to_be_empty)
   #       end
@@ -70,7 +70,7 @@ module Riot
     # @return [Array[Symbol, String]]
     def pass(message=nil) [:pass, message.to_s]; end
 
-    # Returns a status tuple indicating the assertion failed and where it failed it if that can be 
+    # Returns a status tuple indicating the assertion failed and where it failed it if that can be
     # determined.
     #
     # @param [String] message the message to report with
@@ -136,6 +136,7 @@ require 'riot/assertion_macros/matches'
 require 'riot/assertion_macros/nil'
 require 'riot/assertion_macros/not_borat'
 require 'riot/assertion_macros/raises'
+require 'riot/assertion_macros/raises_kind_of'
 require 'riot/assertion_macros/respond_to'
 require 'riot/assertion_macros/same_elements'
 require 'riot/assertion_macros/size'

data/lib/riot/assertion_macros/raises_kind_of.rb

@@ -0,0 +1,76 @@
+module Riot
+  # Asserts that the test raises the expected exception, or one of its
+  # subclasses. Thus, the following assertions pass:
+  #   asserts("test") { raise My::Exception }.raises(My::Exception)
+  #   should("test") { raise My::Exception }.raises(My::Exception.superclass)
+  # The following, however, fails:
+  #   asserts("test") { raise My::Exception.superclass }.raises(My::Exception)
+  #
+  # You can also check to see if the provided message equals or matches your
+  # expectations. The message from the actual raised exception will be converted
+  # to a string before any comparison is executed.
+  #   asserts("test") { raise My::Exception, "Foo" }.raises(My::Exception, "Foo")
+  #   asserts("test") { raise My::Exception, "Foo Bar" }.raises(My::Exception, /Bar/)
+  #
+  # You can use the negative form to assert that no exception is raised at all:
+  #   denies("test") {
+  #     # do stuff
+  #   }.raises_kind_of Exception
+  #
+  # It can be used to check that a particular class of exception is not raised,
+  # in which case you should be aware that raising another kind of exception
+  # will *not* produce a failure.
+  #   denies("test") { raises ArgumentError }.raises_kind_of ArgumentError # fails
+  #   denies("test") { raises Class.new(ArgumentError) }.raises_kind_of ArgumentError # fails
+  #   denies("test") { raises "this doesn't work" }.raises_kind_of ArgumentError # passes
+  class RaisesKindOfMacro < AssertionMacro
+    register :raises_kind_of
+    expects_exception!
+
+    # (see Riot::AssertionMacro#evaluate)
+    # @param [Class] expected_class the expected Exception class
+    # @param [String, nil] expected_message an optional exception message or message partial
+    def evaluate(actual_exception, expected_class, expected_message=nil)
+      actual_message = actual_exception && actual_exception.message
+
+      if !actual_exception
+        fail new_message.expected_to_raise_kind_of(expected_class).but.raised_nothing
+      elsif !actual_exception.is_a?(expected_class)
+        fail new_message.expected_to_raise_kind_of(expected_class).not(actual_exception.class)
+      elsif expected_message && !(actual_message.to_s =~ %r[#{expected_message}])
+        fail expected_message(expected_message).for_message.not(actual_message)
+      else
+        message = new_message.raises_kind_of(expected_class)
+        pass(expected_message ? message.with_message(expected_message) : message)
+      end
+    end # evaluate
+
+    # (see Riot::AssertionMacro#devaluate)
+    # @param [Class] expected_class the unexpected Exception class
+    # @param [String, nil] expected_message an optional exception message or message partial
+    def devaluate(actual_exception, expected_class, expected_message=nil)
+      actual_message = actual_exception && actual_exception.message
+
+      if !actual_exception
+        pass new_message.raises_kind_of(expected_class)
+      elsif !actual_exception.is_a?(expected_class)
+        if expected_message && !(actual_message.to_s =~ %r[#{expected_message}])
+          pass new_message.raises_kind_of(expected_class).
+            with_message(expected_message)
+        else
+          pass new_message.raises_kind_of(expected_class)
+        end
+      else
+        message = new_message.expected_to_not_raise_kind_of(expected_class)
+
+        if expected_message
+          fail message.with_message(expected_message).but.
+            raised(actual_exception.class).
+            with_message(actual_exception.message)
+        else
+          fail message
+        end
+      end
+    end # devaluate
+  end # RaisesMacro
+end

data/lib/riot/reporter/dot_matrix.rb

@@ -1,12 +1,12 @@
 module Riot
 
-  # Outputs in the dot-notion almost everyone should be familiar with, "." implies pass, "F" implues a
+  # Outputs in the dot-notion almost everyone should be familiar with, "." implies pass, "F" implies a
   # failure, and "E" implies an error. If ansi-coloring is available, it is used. Error and failure messages
   # are buffered for output until the end.
   class DotMatrixReporter < IOReporter
     # Creates a new DotMatrixReporter and initializes the failure/error details buffer.
     # @param (see Riot::IOReporter#initialize)
-    def initialize(writer=STDOUT)
+    def initialize(*args)
       super
       @details = []
     end

data/lib/riot/reporter/io.rb

@@ -6,12 +6,16 @@ module Riot
   # This is an abstract class. You should use some other or define your own sub-class that knows how to
   # handle +pass+, +fail+, and +error+.
   class IOReporter < Reporter
+
     # Creates a new IOReporter. You can give it your own IO writer or it will default to +STDOUT+.
+    # If you want to specifically turn colorization off in the output, pass the +plain+ option.
     #
     # @param [IO] writer the writer to use for results
-    def initialize(writer=STDOUT)
+    # @param [Hash] options options for reporter
+    def initialize(*args)
       super()
-      @writer = writer
+      @options = (args.last.kind_of?(Hash) ? args.pop : {})
+      @writer = (args.shift || STDOUT)
     end
 
     # (see Riot::Reporter#results)
@@ -75,10 +79,14 @@ module Riot
     def yellow(str); with_color(33, str); end
     def green(str);  with_color(32, str); end
     
+    def plain?
+      (@options[:plain] || @options["plain"])
+    end
+
     # for color reference:
     # http://www.pixelbeat.org/docs/terminal_colours/
     def with_color(code,str)
-      "\e[#{code}m#{str}\e[0m"
+      plain? ? str : "\e[#{code}m#{str}\e[0m"
     end
   end # IOReporter
 

data/lib/riot/version.rb

@@ -1,4 +1,4 @@
 module Riot
-  VERSION = "0.12.3"
+  VERSION = "0.12.4"
 end
 

data/riot.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+$:.unshift(File.expand_path("../lib", __FILE__))
 require "riot/version"
 
 Gem::Specification.new do |s|

data/test/core/assertion_macros/raises_kind_of_test.rb

@@ -0,0 +1,89 @@
+require 'teststrap'
+
+class Whoops < Exception; end
+class SubWhoops < Whoops; end
+
+context "A raises_kind_of assertion macro" do
+  helper(:asserts_raises) { |o| Riot::Assertion.new("foo") { raise Whoops, o } }
+
+  assertion_test_passes("when expected exception is raised",
+                        "raises kind of Whoops") do
+    asserts_raises(nil).raises_kind_of(Whoops)
+  end
+
+  assertion_test_fails("when a superclass of the expected exception is raised",
+                       "expected to raise kind of SubWhoops, not Whoops") do
+    asserts_raises(nil).raises_kind_of(SubWhoops)
+  end
+
+  assertion_test_passes("when a subclass of the expected exception is raised",
+                        "raises kind of Exception") do
+    asserts_raises(nil).raises_kind_of(Exception)
+  end
+
+  assertion_test_fails("when nothing was raised",
+                       "expected to raise kind of Whoops, but raised nothing") do
+    assertion = Riot::Assertion.new("foo") { "barf" }.raises_kind_of(Whoops)
+  end
+
+  assertion_test_passes("when provided message equals expected message",
+                        %Q{raises kind of Whoops with message "Mom"}) do
+    asserts_raises('Mom').raises_kind_of(Whoops, 'Mom')
+  end
+
+  assertion_test_fails("when messages aren't equal",
+                       %Q{expected "Mom" for message, not "Dad"}) do
+    asserts_raises('Dad').raises_kind_of(Whoops, 'Mom')
+  end
+
+  assertion_test_passes("when provided message matches expected message",
+                        %Q{raises kind of Whoops with message /Mom/}) do
+    asserts_raises('Mom').raises_kind_of(Whoops, /Mom/)
+  end
+
+  assertion_test_fails("when messages don't match",
+                       %Q{expected /Mom/ for message, not "Dad"}) do
+    asserts_raises('Dad').raises_kind_of(Whoops, /Mom/)
+  end
+end # A raises_kind_of assertion macro
+
+context "A negative raises_kind_of assertion macro" do
+  helper(:deny_raises) { |o| Riot::Assertion.new("foo", true) { raise Whoops, o } }
+
+  assertion_test_fails("when expected exception is raised",
+                       "expected to not raise kind of Whoops") do
+    deny_raises(nil).raises_kind_of(Whoops)
+  end
+
+  assertion_test_fails("when a subclass of the expected exception is raised",
+                       "expected to not raise kind of Whoops") do
+    Riot::Assertion.new("foo", true) { raise SubWhoops }.raises_kind_of(Whoops)
+  end
+
+  assertion_test_passes("when unexpected exception is raised",
+                        "raises kind of SubWhoops") do
+    deny_raises(nil).raises_kind_of(SubWhoops)
+  end
+
+  assertion_test_passes("when nothing was raised", "raises kind of Whoops") do
+    Riot::Assertion.new("foo", true) { "barf" }.raises_kind_of(Whoops)
+  end
+
+  assertion_test_fails("when provided message equals expected message",
+                       'expected to not raise kind of Whoops with message "Mom", but raised Whoops with message "Mom"') do
+    deny_raises('Mom').raises_kind_of(Whoops, 'Mom')
+  end
+
+  assertion_test_passes("when messages and exception aren't equal",
+                        'raises kind of ArgumentError with message "Dad"') do
+    deny_raises('Mom').raises_kind_of(ArgumentError, 'Dad')
+  end
+
+  assertion_test_fails("when provided message matches expected message", 'expected to not raise kind of Whoops with message /Mom/, but raised Whoops with message "Mom"') do
+    deny_raises('Mom').raises_kind_of(Whoops, /Mom/)
+  end
+
+  assertion_test_fails("when messages don't match", "expected to not raise kind of Whoops with message /Mom/, but raised Whoops with message \"Dad\"") do
+    deny_raises('Dad').raises_kind_of(Whoops, /Mom/)
+  end
+end # A raises_kind_of assertion macro

data/test/core/reports/basic_reporter_test.rb

@@ -0,0 +1,66 @@
+require 'teststrap'
+
+context "A reporter" do
+  setup do
+    Class.new(Riot::Reporter) do
+      def pass(d, message) "passed(#{d}, #{message.inspect})"; end
+      def fail(d, message, line, file) "failed(#{d}, #{message} on line #{line} in file #{file})"; end
+      def error(d, e) "errored(#{d}, #{e})"; end
+      def results(time); end
+    end.new
+  end
+
+  # pass
+
+  asserts("pass count increase when :pass sent to #report") do
+    topic.report("", [:pass])
+    topic.passes
+  end.equals(1)
+
+  asserts("description sent to #pass") do
+    topic.report("hi mom", [:pass])
+  end.equals("passed(hi mom, nil)")
+
+  # fail
+
+  asserts("fail count increase when :fail sent to #report") do
+    topic.report("", [:fail, ""])
+    topic.failures
+  end.equals(1)
+
+  asserts("description, message, line and file sent to #fail") do
+    topic.report("hi mom", [:fail, "how are you", 4, "foo"])
+  end.equals("failed(hi mom, how are you on line 4 in file foo)")
+
+  # error
+
+  asserts("error count increase when :error sent to #report") do
+    topic.report("", [:error, ""])
+    topic.errors
+  end.equals(1)
+
+  asserts("description sent to #error") do
+    topic.report("break it down", [:error, "error time"])
+  end.equals("errored(break it down, error time)")
+
+  context "instance" do
+    setup { Riot::Reporter.new }
+    should("return self invoking new") { topic.new }.equals { topic }
+  end
+
+  context "with no errors or failures" do
+    hookup { topic.report("foo", [:pass, nil]) }
+    asserts(:success?)
+  end
+
+  context "with failures and no errors" do
+    hookup { topic.report("foo", [:fail, "blah"]) }
+    asserts(:success?).equals(false)
+  end
+
+  context "with errors and no failures" do
+    hookup { topic.report("foo", [:error, Exception.new("boogers")]) }
+    asserts(:success?).equals(false)
+  end
+end # A reporter
+

data/test/core/reports/dot_matrix_reporter_test.rb

@@ -0,0 +1,50 @@
+require 'teststrap'
+
+context "DotMatrixReporter" do
+  setup do
+    @out = StringIO.new
+    Riot::DotMatrixReporter.new(@out)
+  end
+
+  context "with a passing test" do
+    setup do
+      context = Riot::Context.new('whatever') do
+        asserts('true') { true }
+      end
+      context.run(topic)
+      @out.string
+    end
+    asserts_topic('puts a dot').matches('.')
+  end
+  
+  context 'with a failing test' do
+    setup do
+      Riot::Context.new('whatever') do
+        asserts('nope!') { false }
+      end.run(topic)
+      topic.results(100)
+      @out.string
+    end
+    
+    asserts_topic('puts an F').matches('F')
+    asserts_topic("puts the full context + assertion name").matches('whatever asserts nope!')
+    asserts_topic("puts the failure reason").matches(/Expected .* but got false instead/)
+  end
+  
+  context 'with an error test' do
+    setup do
+      Riot::Context.new('whatever') do
+        asserts('bang') { raise "BOOM" }
+      end.run(topic)
+      topic.results(100)
+      @out.string
+    end
+    
+    asserts_topic('puts an E').matches('E')
+    asserts_topic('puts the full context + assertion name').matches('whatever asserts bang')
+    asserts_topic('puts the exception message').matches('BOOM')
+    # <file path>:<one or more number><two newlines><anything till end of line><newline> is the last thing in the stack trace
+    asserts_topic('puts the filtered exception backtrace').matches(/#{__FILE__}:\d+:[^\n]*\n\n.*$\n\z/)
+  end
+end
+

data/test/core/reports/story_reporter_test.rb

@@ -0,0 +1,61 @@
+require 'teststrap'
+require 'stringio'
+
+context "StoryReporter" do
+  setup do
+    @out = StringIO.new
+    Riot::StoryReporter.new(@out)
+  end
+
+  asserts("success message is stripped if nil") do
+    topic.pass("foo", nil)
+    @out.string
+  end.matches(/\+ \e\[32mfoo\e\[0m\n/)
+
+  asserts("failure message excludes line info if none provided") do
+    @out.rewind
+    topic.fail("foo", "bar", nil, nil)
+    @out.string
+  end.matches(/\- \e\[33mfoo: bar\e\[0m\n/)
+
+  context 'reporting on an empty context' do
+    setup do
+      context = Riot::Context.new('empty context') do
+        context("a nested empty context") {}
+      end
+      context.run(topic)
+    end
+    should("not output context name") { @out.string }.empty
+  end
+
+  context "reporting on a non-empty context" do
+    setup do
+      context = Riot::Context.new('supercontext') do
+        asserts("truth") { true }
+      end
+      context.run(topic)
+    end
+
+    should('output context name') { @out.string }.matches(/supercontext/)
+    should('output name of passed assertion') { @out.string }.matches(/truth/)
+  end
+end # StoryReporter
+
+context "Plain StoryReporter" do
+  setup do
+    @out = StringIO.new
+    Riot::StoryReporter.new(@out, {"plain" => true})
+  end
+
+  asserts("success message is stripped if nil") do
+    topic.pass("foo", nil)
+    @out.string
+  end.matches(/\+ foo\n/)
+
+  asserts("failure message excludes line info if none provided") do
+    @out.rewind
+    topic.fail("foo", "bar", nil, nil)
+    @out.string
+  end.matches(/\- foo: bar\n/)
+end # Plain StoryReporter
+

data/test/teststrap.rb

@@ -35,3 +35,4 @@ class MockReporter < Riot::Reporter
   def error(description, e); end
   def results; end
 end
+

metadata

@@ -1,8 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: riot
 version: !ruby/object:Gem::Version 
+  hash: 39
   prerelease: 
-  version: 0.12.3
+  segments: 
+  - 0
+  - 12
+  - 4
+  version: 0.12.4
 platform: ruby
 authors: 
 - Justin 'Gus' Knowlden
@@ -10,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-10 00:00:00 -06:00
+date: 2011-05-28 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,6 +26,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :runtime
   version_requirements: *id001
@@ -55,6 +63,7 @@ files:
 - lib/riot/assertion_macros/nil.rb
 - lib/riot/assertion_macros/not_borat.rb
 - lib/riot/assertion_macros/raises.rb
+- lib/riot/assertion_macros/raises_kind_of.rb
 - lib/riot/assertion_macros/respond_to.rb
 - lib/riot/assertion_macros/same_elements.rb
 - lib/riot/assertion_macros/size.rb
@@ -89,6 +98,7 @@ files:
 - test/core/assertion_macros/matches_test.rb
 - test/core/assertion_macros/nil_test.rb
 - test/core/assertion_macros/not_borat_test.rb
+- test/core/assertion_macros/raises_kind_of_test.rb
 - test/core/assertion_macros/raises_test.rb
 - test/core/assertion_macros/respond_to_test.rb
 - test/core/assertion_macros/same_elements_test.rb
@@ -107,7 +117,9 @@ files:
 - test/core/context/using_describe_in_a_test.rb
 - test/core/middleware/chained_context_middleware_test.rb
 - test/core/middleware/context_middleware_test.rb
-- test/core/report_test.rb
+- test/core/reports/basic_reporter_test.rb
+- test/core/reports/dot_matrix_reporter_test.rb
+- test/core/reports/story_reporter_test.rb
 - test/core/runnable/assertion_macro_test.rb
 - test/core/runnable/assertion_test.rb
 - test/core/runnable/message_test.rb
@@ -131,17 +143,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: An extremely fast, expressive, and context-driven unit-testing framework. Protest the slow test.
@@ -161,6 +179,7 @@ test_files:
 - test/core/assertion_macros/matches_test.rb
 - test/core/assertion_macros/nil_test.rb
 - test/core/assertion_macros/not_borat_test.rb
+- test/core/assertion_macros/raises_kind_of_test.rb
 - test/core/assertion_macros/raises_test.rb
 - test/core/assertion_macros/respond_to_test.rb
 - test/core/assertion_macros/same_elements_test.rb
@@ -179,7 +198,9 @@ test_files:
 - test/core/context/using_describe_in_a_test.rb
 - test/core/middleware/chained_context_middleware_test.rb
 - test/core/middleware/context_middleware_test.rb
-- test/core/report_test.rb
+- test/core/reports/basic_reporter_test.rb
+- test/core/reports/dot_matrix_reporter_test.rb
+- test/core/reports/story_reporter_test.rb
 - test/core/runnable/assertion_macro_test.rb
 - test/core/runnable/assertion_test.rb
 - test/core/runnable/message_test.rb

data/test/core/report_test.rb

@@ -1,158 +0,0 @@
-require 'teststrap'
-
-context "A reporter" do
-  setup do
-    Class.new(Riot::Reporter) do
-      def pass(d, message) "passed(#{d}, #{message.inspect})"; end
-      def fail(d, message, line, file) "failed(#{d}, #{message} on line #{line} in file #{file})"; end
-      def error(d, e) "errored(#{d}, #{e})"; end
-      def results(time); end
-    end.new
-  end
-
-  # pass
-
-  asserts("pass count increase when :pass sent to #report") do
-    topic.report("", [:pass])
-    topic.passes
-  end.equals(1)
-
-  asserts("description sent to #pass") do
-    topic.report("hi mom", [:pass])
-  end.equals("passed(hi mom, nil)")
-
-  # fail
-
-  asserts("fail count increase when :fail sent to #report") do
-    topic.report("", [:fail, ""])
-    topic.failures
-  end.equals(1)
-
-  asserts("description, message, line and file sent to #fail") do
-    topic.report("hi mom", [:fail, "how are you", 4, "foo"])
-  end.equals("failed(hi mom, how are you on line 4 in file foo)")
-
-  # error
-
-  asserts("error count increase when :error sent to #report") do
-    topic.report("", [:error, ""])
-    topic.errors
-  end.equals(1)
-
-  asserts("description sent to #error") do
-    topic.report("break it down", [:error, "error time"])
-  end.equals("errored(break it down, error time)")
-
-  context "instance" do
-    setup { Riot::Reporter.new }
-    should("return self invoking new") { topic.new }.equals { topic }
-  end
-
-  context "with no errors or failures" do
-    hookup { topic.report("foo", [:pass, nil]) }
-    asserts(:success?)
-  end
-
-  context "with failures and no errors" do
-    hookup { topic.report("foo", [:fail, "blah"]) }
-    asserts(:success?).equals(false)
-  end
-
-  context "with errors and no failures" do
-    hookup { topic.report("foo", [:error, Exception.new("boogers")]) }
-    asserts(:success?).equals(false)
-  end
-end # A reporter
-
-require 'stringio'
-context "StoryReporter" do
-  setup do
-    @out = StringIO.new
-    Riot::StoryReporter.new(@out)
-  end
-
-  asserts("success message is stripped if nil") do
-    topic.pass("foo", nil)
-    @out.string
-    # ColorHelper.uncolored(@out.string)
-  end.matches(/\+ \e\[32mfoo\e\[0m\n/)
-  # end.equals("  + foo\n")
-
-  asserts("failure message excludes line info if none provided") do
-    @out.rewind
-    topic.fail("foo", "bar", nil, nil)
-    @out.string
-    # ColorHelper.uncolored(@out.string)
-  end.matches(/\- \e\[33mfoo: bar\e\[0m\n/)
-  # end.equals("  - foo: bar\n")
-
-  context 'reporting on an empty context' do
-    setup do
-      context = Riot::Context.new('empty context') do
-        context("a nested empty context") {}
-      end
-      context.run(topic)
-    end
-    should("not output context name") { @out.string }.empty
-  end
-
-  context "reporting on a non-empty context" do
-    setup do
-      context = Riot::Context.new('supercontext') do
-        asserts("truth") { true }
-      end
-      context.run(topic)
-    end
-
-    should('output context name') { @out.string }.matches(/supercontext/)
-    should('output name of passed assertion') { @out.string }.matches(/truth/)
-  end
-end
-
-context "DotMatrixReporter" do
-  setup do
-    @out = StringIO.new
-    Riot::DotMatrixReporter.new(@out)
-  end
-
-  context "with a passing test" do
-    setup do
-      context = Riot::Context.new('whatever') do
-        asserts('true') { true }
-      end
-      context.run(topic)
-      @out.string
-    end
-    asserts_topic('puts a dot').matches('.')
-  end
-  
-  context 'with a failing test' do
-    setup do
-      Riot::Context.new('whatever') do
-        asserts('nope!') { false }
-      end.run(topic)
-      topic.results(100)
-      @out.string
-    end
-    
-    asserts_topic('puts an F').matches('F')
-    asserts_topic("puts the full context + assertion name").matches('whatever asserts nope!')
-    asserts_topic("puts the failure reason").matches(/Expected .* but got false instead/)
-  end
-  
-  context 'with an error test' do
-    setup do
-      Riot::Context.new('whatever') do
-        asserts('bang') { raise "BOOM" }
-      end.run(topic)
-      topic.results(100)
-      @out.string
-    end
-    
-    asserts_topic('puts an E').matches('E')
-    asserts_topic('puts the full context + assertion name').matches('whatever asserts bang')
-    asserts_topic('puts the exception message').matches('BOOM')
-    # <file path>:<one or more number><two newlines><anything till end of line><newline> is the last thing in the stack trace
-    asserts_topic('puts the filtered exception backtrace').matches(/#{__FILE__}:\d+:[^\n]*\n\n.*$\n\z/)
-  end
-end