assert 2.14.0 → 2.15.0

data/test/unit/assertions_tests.rb

@@ -8,7 +8,7 @@ module Assert::Assertions
     setup do
       @context_class = Factory.modes_off_context_class
       @test = Factory.test
-      @context = @context_class.new(@test, @test.config)
+      @context = @context_class.new(@test, @test.config, proc{ |r| })
     end
     subject{ @context }
 

data/test/unit/config_helpers_tests.rb

@@ -0,0 +1,95 @@
+require 'assert'
+require 'assert/config_helpers'
+
+require 'assert/config'
+
+module Assert::ConfigHelpers
+
+  class UnitTests < Assert::Context
+    desc "Assert::ConfigHelpers"
+    setup do
+      @helpers_class = Class.new do
+        include Assert::ConfigHelpers
+
+        def config
+          # use the assert config since it has tests, contexts, etc
+          # also maybe use a fresh config that is empty
+          @config ||= [Assert.config, Assert::Config.new].choice
+        end
+      end
+      @helpers = @helpers_class.new
+    end
+    subject{ @helpers }
+
+    should have_imeths :runner_seed, :count, :tests?, :all_pass?
+    should have_imeths :run_time, :test_rate, :result_rate
+    should have_imeths :suite_contexts, :ordered_suite_contexts
+    should have_imeths :suite_files, :ordered_suite_files
+    should have_imeths :show_test_profile_info?, :show_test_verbose_info?
+    should have_imeths :ocurring_result_types
+
+    should "know its runner seed" do
+      assert_equal subject.config.runner_seed, subject.runner_seed
+    end
+
+    should "know how to count things on the suite" do
+      thing = [:pass, :fail, :results, :tests].choice
+      assert_equal subject.config.suite.count(thing), subject.count(thing)
+    end
+
+    should "know if it has tests or not" do
+      exp = subject.count(:tests) > 0
+      assert_equal exp, subject.tests?
+    end
+
+    should "know its formatted run time, test rate and result rate" do
+      format = '%.6f'
+
+      exp = format % subject.config.suite.run_time
+      assert_equal exp, subject.run_time(format)
+
+      exp = format % subject.config.suite.test_rate
+      assert_equal exp, subject.test_rate(format)
+
+      exp = format % subject.config.suite.result_rate
+      assert_equal exp, subject.result_rate(format)
+    end
+
+    should "know its suite contexts and ordered suite contexts" do
+      exp = subject.config.suite.tests.inject([]) do |contexts, test|
+        contexts << test.context_info.klass
+      end.uniq
+      assert_equal exp, subject.suite_contexts
+
+      exp = subject.suite_contexts.sort{ |a,b| a.to_s <=> b.to_s }
+      assert_equal exp, subject.ordered_suite_contexts
+    end
+
+    should "know its suite files and ordered suite files" do
+      exp = subject.config.suite.tests.inject([]) do |files, test|
+        files << test.context_info.file
+      end.uniq
+      assert_equal exp, subject.suite_files
+
+      exp = subject.suite_files.sort{ |a,b| a.to_s <=> b.to_s }
+      assert_equal exp, subject.ordered_suite_files
+    end
+
+    should "know whether to show test profile info" do
+      assert_equal !!subject.config.profile, subject.show_test_profile_info?
+    end
+
+    should "know whether to show verbose info" do
+      assert_equal !!subject.config.verbose, subject.show_test_verbose_info?
+    end
+
+    should "know what result types occur in a suite's results" do
+      exp = [:pass, :fail, :ignore, :skip, :error].select do |result_sym|
+        subject.count(result_sym) > 0
+      end
+      assert_equal exp, subject.ocurring_result_types
+    end
+
+  end
+
+end

data/test/unit/config_tests.rb

@@ -1,6 +1,10 @@
 require 'assert'
 require 'assert/config'
 
+require 'assert/default_view'
+require 'assert/runner'
+require 'assert/suite'
+
 class Assert::Config
 
   class UnitTests < Assert::Context
@@ -18,7 +22,7 @@ class Assert::Config
     should have_imeths :debug, :apply
 
     should "default the view, suite, and runner" do
-      assert_kind_of Assert::View::DefaultView, subject.view
+      assert_kind_of Assert::DefaultView, subject.view
       assert_kind_of Assert::Suite,  subject.suite
       assert_kind_of Assert::Runner, subject.runner
     end

data/test/unit/context/test_dsl_tests.rb

@@ -17,10 +17,11 @@ module Assert::Context::TestDSL
       assert_equal 1, context_class.suite.tests.size
 
       exp_test_name = @test_desc
-      built_test = context_class.suite.tests.first
+      built_test    = context_class.suite.tests.first
+
       assert_kind_of Assert::Test, built_test
       assert_equal exp_test_name, built_test.name
-      assert_equal @test_block, built_test.code
+      assert_equal @test_block,   built_test.code
     end
 
     should "build a test using `should` with a desc and code block" do
@@ -30,10 +31,11 @@ module Assert::Context::TestDSL
       assert_equal 1, context_class.suite.tests.size
 
       exp_test_name = "should #{@test_desc}"
-      built_test = context_class.suite.tests.last
+      built_test    = context_class.suite.tests.last
+
       assert_kind_of Assert::Test, built_test
       assert_equal exp_test_name, built_test.name
-      assert_equal @test_block, built_test.code
+      assert_equal @test_block,   built_test.code
     end
 
     should "build a test that skips with no msg when `test_eventually` called" do
@@ -43,8 +45,9 @@ module Assert::Context::TestDSL
         context.instance_eval(&context.class.suite.tests.last.code)
       end
 
-      assert_equal 1, context.class.suite.tests.size
-      assert_equal "", err.message
+      assert_equal 1,      context.class.suite.tests.size
+      assert_equal 'TODO', err.message
+      assert_equal 1,      err.backtrace.size
     end
 
     should "build a test that skips with no msg  when `should_eventually` called" do
@@ -54,8 +57,9 @@ module Assert::Context::TestDSL
         context.instance_eval(&context.class.suite.tests.last.code)
       end
 
-      assert_equal 1, context.class.suite.tests.size
-      assert_equal "", err.message
+      assert_equal 1,      context.class.suite.tests.size
+      assert_equal 'TODO', err.message
+      assert_equal 1,      err.backtrace.size
     end
 
     should "skip with the msg \"TODO\" when `test` called with no block" do
@@ -65,8 +69,9 @@ module Assert::Context::TestDSL
         context.instance_eval(&context.class.suite.tests.last.code)
       end
 
-      assert_equal 1, context.class.suite.tests.size
-      assert_equal "TODO", err.message
+      assert_equal 1,      context.class.suite.tests.size
+      assert_equal 'TODO', err.message
+      assert_equal 1,      err.backtrace.size
     end
 
     should "skip with the msg \"TODO\" when `should` called with no block" do
@@ -76,8 +81,9 @@ module Assert::Context::TestDSL
         context.instance_eval(&context.class.suite.tests.last.code)
       end
 
-      assert_equal 1, context.class.suite.tests.size
-      assert_equal "TODO", err.message
+      assert_equal 1,      context.class.suite.tests.size
+      assert_equal 'TODO', err.message
+      assert_equal 1,      err.backtrace.size
     end
 
     should "skip with the msg \"TODO\" when `test_eventually` called with no block" do
@@ -87,8 +93,9 @@ module Assert::Context::TestDSL
         context.instance_eval(&context.class.suite.tests.last.code)
       end
 
-      assert_equal 1, context.class.suite.tests.size
-      assert_equal "TODO", err.message
+      assert_equal 1,      context.class.suite.tests.size
+      assert_equal 'TODO', err.message
+      assert_equal 1,      err.backtrace.size
     end
 
     should "skip with the msg \"TODO\" when `should_eventually` called with no block" do
@@ -98,8 +105,9 @@ module Assert::Context::TestDSL
         context.instance_eval(&context.class.suite.tests.last.code)
       end
 
-      assert_equal 1, context.class.suite.tests.size
-      assert_equal "TODO", err.message
+      assert_equal 1,      context.class.suite.tests.size
+      assert_equal 'TODO', err.message
+      assert_equal 1,      err.backtrace.size
     end
 
     should "build a test from a macro using `test`" do
@@ -147,7 +155,7 @@ module Assert::Context::TestDSL
       context_class = Factory.modes_off_context_class &build_block
       context_info  = Factory.context_info(context_class)
       test = Factory.test("whatever", context_info)
-      context_class.new(test, test.config)
+      context_class.new(test, test.config, proc{ |r| })
     end
 
     def capture_err(err_class, &block)

data/test/unit/context_tests.rb

@@ -11,7 +11,9 @@ class Assert::Context
     setup do
       @test = Factory.test
       @context_class = @test.context_class
-      @context = @context_class.new(@test, @test.config)
+      @callback_result = nil
+      @result_callback = proc{ |result| @callback_result = result }
+      @context = @context_class.new(@test, @test.config, @result_callback)
     end
     subject{ @context }
 
@@ -42,7 +44,7 @@ class Assert::Context
     setup do
       @skip_msg = "I need to implement this in the future."
       begin; @context.skip(@skip_msg); rescue Exception => @exception; end
-      @result = Factory.skip_result("something", @exception)
+      @result = Factory.skip_result(@exception)
     end
     subject{ @result }
 
@@ -52,6 +54,19 @@ class Assert::Context
       assert_equal @skip_msg, subject.message
     end
 
+    should "not call the result callback" do
+      assert_nil @callback_result
+    end
+
+    should "use any given called from arg as the exception backtrace" do
+      assert_not_equal 1, @exception.backtrace.size
+
+      called_from = Factory.string
+      begin; @context.skip(@skip_msg, called_from); rescue Exception => exception; end
+      assert_equal 1,           exception.backtrace.size
+      assert_equal called_from, exception.backtrace.first
+    end
+
   end
 
   class IgnoreTests < UnitTests
@@ -67,6 +82,10 @@ class Assert::Context
       assert_equal @ignore_msg, subject.message
     end
 
+    should "call the result callback" do
+      assert_equal @result, @callback_result
+    end
+
   end
 
   class PassTests < UnitTests
@@ -82,6 +101,10 @@ class Assert::Context
       assert_equal @pass_msg, subject.message
     end
 
+    should "call the result callback" do
+      assert_equal @result, @callback_result
+    end
+
   end
 
   class FlunkTests < UnitTests
@@ -97,6 +120,10 @@ class Assert::Context
       assert_equal @flunk_msg, subject.message
     end
 
+    should "call the result callback" do
+      assert_equal @result, @callback_result
+    end
+
   end
 
   class FailTests < UnitTests
@@ -118,13 +145,17 @@ class Assert::Context
       assert_equal fail_msg, result.message
     end
 
+    should "call the result callback" do
+      assert_equal @result, @callback_result
+    end
+
   end
 
-  class HaltOnFailTests < FailTests
-    desc "when halting on fails"
+  class HaltOnFailTests < UnitTests
+    desc "failing when halting on fails"
     setup do
       @halt_config = Assert::Config.new(:halt_on_fail => true)
-      @context = @context_class.new(@test, @halt_config)
+      @context = @context_class.new(@test, @halt_config, @result_callback)
       @fail_msg = "something failed"
     end
     subject{ @result }
@@ -138,10 +169,14 @@ class Assert::Context
       assert_kind_of Assert::Result::TestFailure, err
       assert_equal @fail_msg, err.message
 
-      result = Assert::Result::Fail.new(Factory.test("something"), err)
+      result = Assert::Result::Fail.for_test(Factory.test("something"), err)
       assert_equal @fail_msg, result.message
     end
 
+    should "not call the result callback" do
+      assert_nil @callback_result
+    end
+
   end
 
   class AssertTests < UnitTests
@@ -154,7 +189,7 @@ class Assert::Context
     should "return a pass result given a `true` assertion" do
       result = subject.assert(true, @fail_desc){ @what_failed }
       assert_kind_of Assert::Result::Pass, result
-      assert_nil result.message
+      assert_equal '', result.message
     end
 
     should "return a fail result given a `false` assertion" do
@@ -193,7 +228,7 @@ class Assert::Context
     should "return a pass result given a `false` assertion" do
       result = subject.assert_not(false, @fail_desc)
       assert_kind_of Assert::Result::Pass, result
-      assert_nil result.message
+      assert_equal '', result.message
     end
 
     should "return a fail result given a `true` assertion" do
@@ -225,7 +260,7 @@ class Assert::Context
       @context_class = Factory.modes_off_context_class do
         subject{ @something = expected }
       end
-      @context = @context_class.new(@test, @test.config)
+      @context = @context_class.new(@test, @test.config, proc{ |result| })
       @subject = @context.subject
     end
     subject{ @subject }
@@ -248,7 +283,7 @@ class Assert::Context
       begin
         @context.with_backtrace(@from_bt, &@from_block)
       rescue Assert::Result::TestSkipped => e
-        @test.results << Assert::Result::Skip.new(@test, e)
+        @test.results << Assert::Result::Skip.for_test(@test, e)
       end
 
       assert_equal 5, @test.results.size

data/test/unit/factory_tests.rb

@@ -63,6 +63,15 @@ module Assert::Factory
       assert_equal 1, subject.text(1).length
     end
 
+    should "return a random string using `slug`" do
+      assert_kind_of String, subject.slug
+      assert_equal 5, subject.slug.length
+    end
+
+    should "allow passing a maximum length using `slug`" do
+      assert_equal 1, subject.slug(1).length
+    end
+
     should "return a random hex string using `hex`" do
       assert_kind_of String, subject.hex
       assert_match /\A[0-9a-f]{10}\Z/, subject.hex
@@ -72,17 +81,6 @@ module Assert::Factory
       assert_equal 1, subject.hex(1).length
     end
 
-    should "return a random slug string using `slug`" do
-      assert_kind_of String, subject.slug
-      segments = subject.slug.split('-')
-      assert_equal 2, segments.size
-      segments.each{ |s| assert_match /\A[a-z]{4}\Z/, s }
-    end
-
-    should "allow passing a maximum length using `slug`" do
-      assert_equal 1, subject.slug(1).length
-    end
-
     should "return a random file name string using `file_name`" do
       assert_kind_of String, subject.file_name
       assert_match /\A[a-z]{6}\.[a-z]{3}\Z/, subject.file_name

data/test/unit/file_line_tests.rb

@@ -21,6 +21,20 @@ class Assert::FileLine
       assert_equal @line, file_line.line
     end
 
+    should "handle parsing bad data gracefully" do
+      file_line = subject.parse(@file)
+      assert_equal '', file_line.file
+      assert_equal '', file_line.line
+
+      file_line = subject.parse('')
+      assert_equal '', file_line.file
+      assert_equal '', file_line.line
+
+      file_line = subject.parse(nil)
+      assert_equal '', file_line.file
+      assert_equal '', file_line.line
+    end
+
   end
 
   class InitTests < UnitTests
@@ -35,6 +49,14 @@ class Assert::FileLine
     should "know its file and line" do
       assert_equal @file, subject.file
       assert_equal @line, subject.line
+
+      file_line = Assert::FileLine.new(@file)
+      assert_equal @file, file_line.file
+      assert_equal '',    file_line.line
+
+      file_line = Assert::FileLine.new
+      assert_equal '', file_line.file
+      assert_equal '', file_line.line
     end
 
     should "know its string representation" do

data/test/unit/result_tests.rb

@@ -3,277 +3,336 @@ require 'assert/result'
 
 module Assert::Result
 
-  class BacktraceTests < Assert::Context
-    desc "Assert::Result::Backtrace"
+  class UnitTests < Assert::Context
+    desc "Assert::Result"
     setup do
-      @backtrace = Backtrace.new(caller)
+      @test = Factory.test("a test name")
     end
-    subject { @backtrace }
+    subject{ Assert::Result }
 
-    should have_instance_methods :to_s, :filtered
+    should have_imeths :types, :new
 
-    should "be an Array" do
-      assert_kind_of ::Array, subject
-    end
+    should "know its types" do
+      exp = {
+        :pass   => Pass,
+        :fail   => Fail,
+        :ignore => Ignore,
+        :skip   => Skip,
+        :error  => Error
+      }
+      assert_equal exp, subject.types
 
-    should "render as a string by joining on the newline" do
-      assert_equal subject.join("\n"), subject.to_s
+      assert_equal Base, subject.types[Factory.string]
     end
 
-    should "another backtrace when filtered" do
-      assert_kind_of Backtrace, subject
-    end
+    should "create results from data hashes" do
+      type   = Assert::Result.types.keys.choice
+      exp    = Assert::Result.types[type].new(:type => type)
 
-    should "default itself when created from nil" do
-      assert_equal ["No backtrace"], Backtrace.new
+      assert_equal exp, Assert::Result.new(:type => type)
     end
 
   end
 
-  class BaseTests < Assert::Context
-    desc "Assert::Result::Base"
+  class BaseTests < UnitTests
+    desc "Base"
     setup do
-      @test = Factory.test("a test name")
-      @result = Assert::Result::Base.new(@test, "a message", ["line 1", "line2"])
+      @given_data = {
+        :type      => Factory.string,
+        :name      => Factory.string,
+        :test_name => Factory.string,
+        :message   => Factory.string,
+        :backtrace => Backtrace.new(caller),
+        :trace     => Factory.string
+      }
+      @result = Base.new(@given_data)
     end
     subject{ @result }
 
-    should have_readers :test, :message, :backtrace
-    should have_imeths :test_name, :name, :to_sym, :to_s, :trace
-    should have_imeth :set_backtrace
+    should have_cmeths :type, :name, :for_test
+    should have_imeths :type, :name, :test_name, :message, :backtrace, :trace
+    should have_imeths *Assert::Result.types.keys.map{ |k| "#{k}?" }
+    should have_imeths :set_backtrace, :data, :to_sym, :to_s
 
-    Assert::Result.types.keys.each do |type|
-      should "respond to the instance method ##{type}?" do
-        assert_respond_to "#{type}?", subject
-      end
+    should "know its class-level type/name" do
+      assert_equal :unknown, subject.class.type
+      assert_equal '',       subject.class.name
+    end
 
-      should "not be #{type}" do
-        assert_equal false, subject.send("#{type}?")
-      end
+    should "know how to build a result for a given test" do
+      message = Factory.text
+      bt      = Factory.integer(3).times.map{ Factory.string }
+      result  = Base.for_test(@test, message, bt)
+
+      exp_backtrace = Backtrace.new(bt)
+      exp_trace     = exp_backtrace.filtered.first.to_s
+
+      assert_equal @test.name,    result.test_name
+      assert_equal message,       result.message
+      assert_equal exp_backtrace, result.backtrace
+      assert_equal exp_trace,     result.trace
     end
 
-    should "know its test" do
-      assert_equal @test, subject.test
+    should "use any given attrs" do
+      assert_equal @given_data[:type].to_sym, subject.type
+      assert_equal @given_data[:name],        subject.name
+      assert_equal @given_data[:test_name],   subject.test_name
+      assert_equal @given_data[:message],     subject.message
+      assert_equal @given_data[:backtrace],   subject.backtrace
+      assert_equal @given_data[:trace],       subject.trace
     end
 
-    should "nil out empty messages" do
-      assert_equal nil, Assert::Result::Base.new(@test, "").message
+    should "default its attrs" do
+      result = Base.new({})
+
+      assert_equal :unknown,          result.type
+      assert_equal '',                result.name
+      assert_equal '',                result.test_name
+      assert_equal '',                result.message
+      assert_equal Backtrace.new([]), result.backtrace
+      assert_equal '',                result.trace
     end
 
-    should "show only its class and message when inspected" do
-      exp = "#<#{subject.class}:#{'0x0%x' % (subject.object_id << 1)}"\
-            " @message=#{subject.message.inspect}>"
-      assert_equal exp, subject.inspect
+    should "know if it is a certain type of result" do
+      Assert::Result.types.keys.each do |type|
+        assert_false subject.send("#{type}?")
+        Assert.stub(subject, :type){ type }
+        assert_true subject.send("#{type}?")
+      end
     end
 
-    should "allow overriding the result backtrace with `set_backtrace`" do
-      subject.set_backtrace(['bt'])
+    should "allow setting a new backtrace" do
+      new_bt        = Factory.integer(3).times.map{ Factory.string }
+      exp_backtrace = Backtrace.new(new_bt)
+      exp_trace     = exp_backtrace.filtered.first.to_s
+
+      subject.set_backtrace(new_bt)
 
-      assert_kind_of Assert::Result::Backtrace, subject.backtrace
-      assert_equal ['bt'], subject.backtrace
+      assert_equal exp_backtrace, subject.backtrace
+      assert_equal exp_trace,     subject.trace
     end
 
-    should "include its test context name in the to_s" do
-      assert subject.to_s.include?(subject.test_name)
+    should "know its data" do
+      exp = {
+        :type      => subject.type,
+        :name      => subject.name,
+        :test_name => subject.test_name,
+        :message   => subject.message,
+        :backtrace => subject.backtrace,
+        :trace     => subject.trace,
+      }
+      assert_equal exp, subject.data
     end
 
-    should "include its test name in the to_s" do
-      assert subject.to_s.include?(subject.test_name)
+    should "know its symbol representation" do
+      assert_equal subject.type, subject.to_sym
     end
 
-    should "include its message in the to_s" do
-      assert subject.to_s.include?(subject.message)
+    should "know its string representation" do
+      str = subject.to_s
+
+      assert_includes subject.name.upcase, str
+      assert_includes subject.test_name,   str
+      assert_includes subject.message,     str
+      assert_includes subject.trace,       str
+
+      assert_equal 3, str.split("\n").count
+
+      Assert.stub(subject, :message){ '' }
+      Assert.stub(subject, :trace){ '' }
+
+      assert_equal 1, subject.to_s.split("\n").count
     end
 
-    should "include its trace in the to_s" do
-      assert subject.to_s.include?(subject.trace)
+    should "know if it is equal to another result" do
+      other = Assert::Result::Base.new(@given_data)
+      assert_equal other, subject
+
+      Assert.stub(other, [:type, :message].choice){ Factory.string }
+      assert_not_equal other, subject
     end
 
-    should "have a trace with the first filtered line of the backtrace" do
-      assert_equal subject.backtrace.filtered.first, subject.trace
+    should "show only its class and message when inspected" do
+      exp = "#<#{subject.class}:#{'0x0%x' % (subject.object_id << 1)}"\
+            " @message=#{subject.message.inspect}>"
+      assert_equal exp, subject.inspect
     end
+
   end
 
-  class PassTests < Assert::Context
-    desc "Assert::Result::Pass"
+  class PassTests < UnitTests
+    desc "Pass"
     setup do
-      @test = Factory.test("a test name")
-      @result = Assert::Result::Pass.new(@test, "passed", [])
+      @result = Pass.new({})
     end
     subject { @result }
 
-    should "pass?" do
-      assert_equal true, subject.pass?
+    should "know its type/name" do
+      assert_equal :pass,  subject.type
+      assert_equal :pass,  subject.class.type
+      assert_equal 'Pass', subject.class.name
     end
 
-    Assert::Result.types.keys.reject{|k| k == :pass}.each do |type|
-      should "not be #{type}?" do
-        assert_equal false, subject.send("#{type}?")
-      end
-    end
+  end
 
-    should "know its to_sym" do
-      assert_equal :pass, subject.to_sym
+  class IgnoreTests < UnitTests
+    desc "Ignore"
+    setup do
+      @result = Ignore.new({})
     end
+    subject { @result }
 
-    should "know its name" do
-      assert_equal "Pass", subject.name
+    should "know its type/name" do
+      assert_equal :ignore,  subject.type
+      assert_equal :ignore,  subject.class.type
+      assert_equal 'Ignore', subject.class.name
     end
 
-    should "include PASS in its to_s" do
-      assert subject.to_s.include?("PASS")
+  end
+
+  class TestFailureTests < UnitTests
+    desc "TestFailure"
+    subject{ TestFailure }
+
+    should "be a runtime error" do
+      assert_kind_of RuntimeError, subject.new
     end
 
   end
 
-  class IgnoreTests < Assert::Context
-    desc "Assert::Result::Ignore"
+  class FailTests < UnitTests
+    desc "Fail"
     setup do
-      @test = Factory.test("a test name")
-      @result = Assert::Result::Ignore.new(@test, "ignored", [])
+      @result = Fail.new({})
     end
     subject { @result }
 
-    should "ignore?" do
-      assert_equal true, subject.ignore?
+    should "know its type/name" do
+      assert_equal :fail,  subject.type
+      assert_equal :fail,  subject.class.type
+      assert_equal 'Fail', subject.class.name
     end
 
-    Assert::Result.types.keys.reject{|k| k == :ignore}.each do |type|
-      should "not be #{type}?" do
-        assert_equal false, subject.send("#{type}?")
-      end
-    end
+    should "allow creating for a test with TestFailure exceptions" do
+      err = TestFailure.new
+      err.set_backtrace(caller)
+      result = Fail.for_test(@test, err)
 
-    should "know its to_sym" do
-      assert_equal :ignore, subject.to_sym
+      assert_equal err.message, result.message
+
+      exp_bt = Backtrace.new(err.backtrace)
+      assert_equal exp_bt, result.backtrace
     end
 
-    should "know its name" do
-      assert_equal "Ignore", subject.name
+    should "not allow creating for a test with non-TestFailure exceptions" do
+      assert_raises(ArgumentError){ Fail.for_test(@test, RuntimeError.new) }
     end
 
-    should "include IGNORE in its to_s" do
-      assert subject.to_s.include?("IGNORE")
+  end
+
+  class TestSkippedTests < UnitTests
+    desc "TestSkipped"
+    subject{ TestSkipped }
+
+    should "be a runtime error" do
+      assert_kind_of RuntimeError, subject.new
     end
 
   end
 
-  class FailTests < Assert::Context
-    desc "Assert::Result::Fail"
+  class SkipTests < UnitTests
+    desc "Skip"
     setup do
-      @test = Factory.test("a test name")
-      @result = Assert::Result::Fail.new(@test, "failed", [])
+      @result = Skip.new({})
     end
     subject { @result }
 
-    should "use a runtime error (TestFailure) for controlling flow" do
-      assert_kind_of RuntimeError, Assert::Result::TestFailure.new
-    end
-
-    should "fail?" do
-      assert_equal true, subject.fail?
+    should "know its type/name" do
+      assert_equal :skip,  subject.type
+      assert_equal :skip,  subject.class.type
+      assert_equal 'Skip', subject.class.name
     end
 
-    Assert::Result.types.keys.reject{|k| k == :fail}.each do |type|
-      should "not be #{type}?" do
-        assert_equal false, subject.send("#{type}?")
-      end
-    end
+    should "allow creating for a test with TestSkipped exceptions" do
+      err = TestSkipped.new
+      err.set_backtrace(caller)
+      result = Skip.for_test(@test, err)
 
-    should "know its to_sym" do
-      assert_equal :fail, subject.to_sym
-    end
+      assert_equal err.message, result.message
 
-    should "know its name" do
-      assert_equal "Fail", subject.name
+      exp_bt = Backtrace.new(err.backtrace)
+      assert_equal exp_bt, result.backtrace
     end
 
-    should "include FAIL in its to_s" do
-      assert subject.to_s.include?("FAIL")
+    should "not allow creating for a test with non-TestSkipped exceptions" do
+      assert_raises(ArgumentError){ Skip.for_test(@test, RuntimeError.new) }
     end
 
   end
 
-  class SkipTests < Assert::Context
-    desc "Assert::Result::Skip"
+  class ErrorTests < UnitTests
+    desc "Error"
     setup do
-      @test = Factory.test("a test name")
-      @exception = nil
-      begin
-        raise TestSkipped, "test ski["
-      rescue Exception => err
-        @exception = err
-      end
-      @result = Assert::Result::Skip.new(@test, @exception)
+      @result = Error.new({})
     end
     subject { @result }
 
-    should "use a runtime error (TestSkipped) for controlling flow" do
-      assert_kind_of RuntimeError, Assert::Result::TestSkipped.new
+    should "know its class-level type/name" do
+      assert_equal :error,  subject.class.type
+      assert_equal 'Error', subject.class.name
     end
 
-    should "skip?" do
-      assert_equal true, subject.skip?
-    end
+    should "allow creating for a test with exceptions" do
+      err = Exception.new
+      err.set_backtrace(caller)
+      result = Error.for_test(@test, err)
 
-    Assert::Result.types.keys.reject{|k| k == :skip}.each do |type|
-      should "not be #{type}?" do
-        assert_equal false, subject.send("#{type}?")
-      end
-    end
-
-    should "know its to_sym" do
-      assert_equal :skip, subject.to_sym
-    end
+      exp_msg = "#{err.message} (#{err.class.name})"
+      assert_equal exp_msg, result.message
 
-    should "know its name" do
-      assert_equal "Skip", subject.name
+      exp_bt = Backtrace.new(err.backtrace)
+      assert_equal exp_bt,      result.backtrace
+      assert_equal exp_bt.to_s, result.trace
     end
 
-    should "include SKIP in its to_s" do
-      assert subject.to_s.include?("SKIP")
+    should "not allow creating for a test without an exception" do
+      assert_raises(ArgumentError){ Error.for_test(@test, Factory.string) }
     end
 
   end
 
-  class ErrorTests < Assert::Context
-    desc "Assert::Result::Error"
+  class BacktraceTests < UnitTests
+    desc "Backtrace"
     setup do
-      @test = Factory.test("a test name")
-      @exception = nil
-      begin
-        raise Exception, "test error"
-      rescue Exception => err
-        @exception = err
-      end
-      @result = Assert::Result::Error.new(@test, @exception)
+      @backtrace = Backtrace.new(caller)
     end
-    subject { @result }
+    subject { @backtrace }
 
-    should "error?" do
-      assert_equal true, subject.error?
+    should have_cmeths :parse
+    should have_imeths :to_s, :filtered
+
+    should "be parseable from its string representation" do
+      assert_equal subject, Backtrace.parse(subject.to_s)
     end
 
-    Assert::Result.types.keys.reject{|k| k == :error}.each do |type|
-      should "not be #{type}?" do
-        assert_equal false, subject.send("#{type}?")
-      end
+    should "be an Array" do
+      assert_kind_of ::Array, subject
     end
 
-    should "know its to_sym" do
-      assert_equal :error, subject.to_sym
+    should "know its DELIM" do
+      assert_equal "\n", Backtrace::DELIM
     end
 
-    should "know its name" do
-      assert_equal "Error", subject.name
+    should "render as a string by joining on the newline" do
+      assert_equal subject.join(Backtrace::DELIM), subject.to_s
     end
 
-    should "include ERRORED in its to_s" do
-      assert subject.to_s.include?("ERROR")
+    should "another backtrace when filtered" do
+      assert_kind_of Backtrace, subject
     end
 
-    should "have a trace created from the original exception's unfiltered backtrace" do
-      assert_equal @exception.backtrace.join("\n"), subject.trace
+    should "default itself when created from nil" do
+      assert_equal ["No backtrace"], Backtrace.new
     end
 
   end