assert 2.18.0 → 2.19.0

data/test/unit/default_runner_tests.rb

@@ -6,10 +6,7 @@ require "assert/runner"
 class Assert::DefaultRunner
   class UnitTests < Assert::Context
     desc "Assert::DefaultRunner"
-    setup do
-      @config = Factory.modes_off_config
-      @runner = Assert::DefaultRunner.new(@config)
-    end
-    subject{ @runner }
+
+    # This is tested implicitly by running Assert's test suite
   end
 end

data/test/unit/default_suite_tests.rb

@@ -6,89 +6,93 @@ require "assert/suite"
 class Assert::DefaultSuite
   class UnitTests < Assert::Context
     desc "Assert::DefaultSuite"
-    setup do
-      ci = Factory.context_info(Factory.modes_off_context_class)
-      @test = Factory.test(Factory.string, ci){ }
+    subject { unit_class }
 
-      @config = Factory.modes_off_config
-      @suite  = Assert::DefaultSuite.new(@config)
-    end
-    subject{ @suite }
+    let(:unit_class) { Assert::DefaultSuite }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject { unit_class.new(config1) }
+
+    let(:ci1)     { Factory.context_info(Factory.modes_off_context_class) }
+    let(:test1)   { Factory.test(Factory.string, ci1) { } }
+    let(:config1) { Factory.modes_off_config }
 
     should "be a Suite" do
-      assert_kind_of Assert::Suite, subject
+      assert_that(subject).is_kind_of(Assert::Suite)
     end
 
     should "default its test/result counts" do
-      assert_equal 0, subject.test_count
-      assert_equal 0, subject.result_count
-      assert_equal 0, subject.pass_result_count
-      assert_equal 0, subject.fail_result_count
-      assert_equal 0, subject.error_result_count
-      assert_equal 0, subject.skip_result_count
-      assert_equal 0, subject.ignore_result_count
+      assert_that(subject.test_count).equals(0)
+      assert_that(subject.result_count).equals(0)
+      assert_that(subject.pass_result_count).equals(0)
+      assert_that(subject.fail_result_count).equals(0)
+      assert_that(subject.error_result_count).equals(0)
+      assert_that(subject.skip_result_count).equals(0)
+      assert_that(subject.ignore_result_count).equals(0)
     end
 
     should "increment its test count on `before_test`" do
       subject.before_test(@test)
-      assert_equal 1, subject.test_count
+      assert_that(subject.test_count).equals(1)
     end
 
     should "increment its result counts on `on_result`" do
       subject.on_result(Factory.pass_result)
-      assert_equal 1, subject.result_count
-      assert_equal 1, subject.pass_result_count
-      assert_equal 0, subject.fail_result_count
-      assert_equal 0, subject.error_result_count
-      assert_equal 0, subject.skip_result_count
-      assert_equal 0, subject.ignore_result_count
+      assert_that(subject.result_count).equals(1)
+      assert_that(subject.pass_result_count).equals(1)
+      assert_that(subject.fail_result_count).equals(0)
+      assert_that(subject.error_result_count).equals(0)
+      assert_that(subject.skip_result_count).equals(0)
+      assert_that(subject.ignore_result_count).equals(0)
 
       subject.on_result(Factory.fail_result)
-      assert_equal 2, subject.result_count
-      assert_equal 1, subject.pass_result_count
-      assert_equal 1, subject.fail_result_count
-      assert_equal 0, subject.error_result_count
-      assert_equal 0, subject.skip_result_count
-      assert_equal 0, subject.ignore_result_count
+      assert_that(subject.result_count).equals(2)
+      assert_that(subject.pass_result_count).equals(1)
+      assert_that(subject.fail_result_count).equals(1)
+      assert_that(subject.error_result_count).equals(0)
+      assert_that(subject.skip_result_count).equals(0)
+      assert_that(subject.ignore_result_count).equals(0)
 
       subject.on_result(Factory.error_result)
-      assert_equal 3, subject.result_count
-      assert_equal 1, subject.pass_result_count
-      assert_equal 1, subject.fail_result_count
-      assert_equal 1, subject.error_result_count
-      assert_equal 0, subject.skip_result_count
-      assert_equal 0, subject.ignore_result_count
+      assert_that(subject.result_count).equals(3)
+      assert_that(subject.pass_result_count).equals(1)
+      assert_that(subject.fail_result_count).equals(1)
+      assert_that(subject.error_result_count).equals(1)
+      assert_that(subject.skip_result_count).equals(0)
+      assert_that(subject.ignore_result_count).equals(0)
 
       subject.on_result(Factory.skip_result)
-      assert_equal 4, subject.result_count
-      assert_equal 1, subject.pass_result_count
-      assert_equal 1, subject.fail_result_count
-      assert_equal 1, subject.error_result_count
-      assert_equal 1, subject.skip_result_count
-      assert_equal 0, subject.ignore_result_count
+      assert_that(subject.result_count).equals(4)
+      assert_that(subject.pass_result_count).equals(1)
+      assert_that(subject.fail_result_count).equals(1)
+      assert_that(subject.error_result_count).equals(1)
+      assert_that(subject.skip_result_count).equals(1)
+      assert_that(subject.ignore_result_count).equals(0)
 
       subject.on_result(Factory.ignore_result)
-      assert_equal 5, subject.result_count
-      assert_equal 1, subject.pass_result_count
-      assert_equal 1, subject.fail_result_count
-      assert_equal 1, subject.error_result_count
-      assert_equal 1, subject.skip_result_count
-      assert_equal 1, subject.ignore_result_count
+      assert_that(subject.result_count).equals(5)
+      assert_that(subject.pass_result_count).equals(1)
+      assert_that(subject.fail_result_count).equals(1)
+      assert_that(subject.error_result_count).equals(1)
+      assert_that(subject.skip_result_count).equals(1)
+      assert_that(subject.ignore_result_count).equals(1)
     end
 
     should "clear the run data on `on_start`" do
-      subject.before_test(@test)
+      subject.before_test(test1)
       subject.on_result(Factory.pass_result)
 
-      assert_equal 1, subject.test_count
-      assert_equal 1, subject.result_count
-      assert_equal 1, subject.pass_result_count
+      assert_that(subject.test_count).equals(1)
+      assert_that(subject.result_count).equals(1)
+      assert_that(subject.pass_result_count).equals(1)
 
       subject.on_start
 
-      assert_equal 0, subject.test_count
-      assert_equal 0, subject.result_count
-      assert_equal 0, subject.pass_result_count
+      assert_that(subject.test_count).equals(0)
+      assert_that(subject.result_count).equals(0)
+      assert_that(subject.pass_result_count).equals(0)
     end
   end
 end

data/test/unit/factory_tests.rb

@@ -6,13 +6,15 @@ require "much-factory"
 module Assert::Factory
   class UnitTests < Assert::Context
     desc "Assert::Factory"
-    subject{ Assert::Factory }
+    subject { unit_class }
+
+    let(:unit_class) { Assert::Factory }
 
     should "include and extend MuchFactory" do
-      assert_includes MuchFactory, subject
+      assert_that(subject).includes(MuchFactory)
 
       # https://stackoverflow.com/questions/5197166/ruby-get-a-list-of-extended-modules
-      assert_includes MuchFactory, subject_metaclass.included_modules
+      assert_that(subject_metaclass.included_modules).includes(MuchFactory)
     end
 
     private

data/test/unit/file_line_tests.rb

@@ -4,75 +4,73 @@ require "assert/file_line"
 class Assert::FileLine
   class UnitTests < Assert::Context
     desc "Assert::FileLine"
-    setup do
-      @file = "#{Factory.path}_tests.rb"
-      @line = Factory.integer.to_s
-    end
-    subject{ Assert::FileLine }
+    subject { unit_class }
+
+    let(:unit_class) { Assert::FileLine }
+
+    let(:file1) { "#{Factory.path}_tests.rb" }
+    let(:line1) { Factory.integer.to_s }
 
     should have_imeths :parse
 
     should "know how to parse and init from a file line path string" do
       file_line_path = [
-        "#{@file}:#{@line}",
-        "#{@file}:#{@line} #{Factory.string}"
+        "#{file1}:#{line1}",
+        "#{file1}:#{line1} #{Factory.string}"
       ].sample
       file_line = subject.parse(file_line_path)
 
-      assert_equal @file, file_line.file
-      assert_equal @line, file_line.line
+      assert_that(file_line.file).equals(file1)
+      assert_that(file_line.line).equals(line1)
     end
 
     should "handle parsing bad data gracefully" do
-      file_line = subject.parse(@file)
-      assert_equal @file, file_line.file
-      assert_equal "",    file_line.line
+      file_line = subject.parse(file1)
+      assert_that(file_line.file).equals(file1)
+      assert_that(file_line.line).equals("")
 
-      file_line = subject.parse(@line)
-      assert_equal @line, file_line.file
-      assert_equal "",    file_line.line
+      file_line = subject.parse(line1)
+      assert_that(file_line.file).equals(line1)
+      assert_that(file_line.line).equals("")
 
       file_line = subject.parse("")
-      assert_equal "", file_line.file
-      assert_equal "", file_line.line
+      assert_that(file_line.file).equals("")
+      assert_that(file_line.line).equals("")
 
       file_line = subject.parse(nil)
-      assert_equal "", file_line.file
-      assert_equal "", file_line.line
+      assert_that(file_line.file).equals("")
+      assert_that(file_line.line).equals("")
     end
   end
 
   class InitTests < UnitTests
     desc "when init"
-    setup do
-      @file_line = Assert::FileLine.new(@file, @line)
-    end
-    subject{ @file_line }
+    subject { unit_class.new(file1, line1) }
 
     should have_readers :file, :line
 
     should "know its file and line" do
-      assert_equal @file, subject.file
-      assert_equal @line, subject.line
+      assert_that(subject.file).equals(file1)
+      assert_that(subject.line).equals(line1)
 
-      file_line = Assert::FileLine.new(@file)
-      assert_equal @file, file_line.file
-      assert_equal "",    file_line.line
+      file_line = unit_class.new(file1)
+      assert_that(file_line.file).equals(file1)
+      assert_that(file_line.line).equals("")
 
-      file_line = Assert::FileLine.new
-      assert_equal "", file_line.file
-      assert_equal "", file_line.line
+      file_line = unit_class.new
+      assert_that(file_line.file).equals("")
+      assert_that(file_line.line).equals("")
     end
 
     should "know its string representation" do
-      assert_equal "#{subject.file}:#{subject.line}", subject.to_s
+      assert_that(subject.to_s).equals("#{subject.file}:#{subject.line}")
     end
 
     should "know if it is equal to another file line" do
-      yes = Assert::FileLine.new(@file, @line)
-      no = Assert::FileLine.new("#{Factory.path}_tests.rb", Factory.integer.to_s)
+      yes = unit_class.new(file1, line1)
+      no = unit_class.new("#{Factory.path}_tests.rb", Factory.integer.to_s)
 
-      assert_equal     yes, subject
+      assert_that(subject).equals(yes)
       assert_not_equal no,  subject
     end
   end

data/test/unit/macro_tests.rb

@@ -4,30 +4,34 @@ require "assert/macro"
 class Assert::Macro
   class UnitTests < Assert::Context
     desc "Assert::Macro"
-    setup do
-      @macro = Assert::Macro.new {}
-    end
-    subject { @macro }
+    subject { unit_class }
+
+    let(:unit_class) { Assert::Macro }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject { unit_class.new {} }
 
     should "have an accessor for its (optional) name" do
-      assert_respond_to :name, subject
-      assert_respond_to :name=, subject
+      assert_that(subject).responds_to(:name)
+      assert_that(subject).responds_to(:name=)
     end
 
     should "default its name if no given" do
-      assert_equal "run this macro", (Assert::Macro.new {}).name
+      assert_that((unit_class.new {}).name).equals("run this macro")
     end
 
     should "initialize with a given name" do
-      assert_equal "test", (Assert::Macro.new("test") {}).name
+      assert_that((unit_class.new("test") {}).name).equals("test")
     end
 
     should "be a Proc" do
-      assert_kind_of ::Proc, subject
+      assert_that(subject).is_kind_of(::Proc)
     end
 
     should "complain if you create a macro without a block" do
-      assert_raises(ArgumentError) { Assert::Macro.new }
+      assert_that { unit_class.new }.raises(ArgumentError)
     end
   end
 

data/test/unit/result_tests.rb

@@ -6,10 +6,11 @@ require "assert/file_line"
 module Assert::Result
   class UnitTests < Assert::Context
     desc "Assert::Result"
-    setup do
-      @test = Factory.test("a test name")
-    end
-    subject{ Assert::Result }
+    subject { unit_class }
+
+    let(:unit_class) { Assert::Result }
+
+    let(:test1) { Factory.test("a test name") }
 
     should have_imeths :types, :new
 
@@ -21,40 +22,33 @@ module Assert::Result
         :skip   => Skip,
         :error  => Error
       }
-      assert_equal exp, subject.types
+      assert_that(subject.types).equals(exp)
 
-      assert_equal Base, subject.types[Factory.string]
+      assert_that(subject.types[Factory.string]).equals(Base)
     end
 
     should "create results from data hashes" do
       type = Assert::Result.types.keys.sample
       exp  = Assert::Result.types[type].new(:type => type)
-      assert_equal exp, Assert::Result.new(:type => type)
-    end
-
-    private
-
-    def build_backtrace
-      assert_lib_path = File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
-      (Factory.integer(3).times.map{ Factory.string } + [assert_lib_path]).shuffle
+      assert_that(Assert::Result.new(:type => type)).equals(exp)
     end
   end
 
-  class BaseTests < UnitTests
-    desc "Base"
-    setup do
-      @given_data = {
+  class InitBaseTests < UnitTests
+    desc "Base when init"
+    subject { Base.new(given_data1) }
+
+    let(:given_data1) {
+      {
         :type           => Factory.string,
         :name           => Factory.string,
         :test_name      => Factory.string,
         :test_file_line => Assert::FileLine.new(Factory.string, Factory.integer),
         :message        => Factory.string,
         :output         => Factory.text,
-        :backtrace      => Backtrace.new(build_backtrace)
+        :backtrace      => Backtrace.new(Factory.backtrace)
       }
-      @result = Base.new(@given_data)
-    end
-    subject{ @result }
+    }
 
     should have_cmeths :type, :name, :for_test
     should have_imeths :type, :name, :test_name, :test_file_line
@@ -63,69 +57,69 @@ module Assert::Result
     should have_imeths :backtrace, :trace
     should have_imeths :set_backtrace, :set_with_bt, :with_bt_set?
     should have_imeths :src_line, :file_line, :file_name, :line_num
-    should have_imeths *Assert::Result.types.keys.map{ |k| "#{k}?" }
+    should have_imeths(*Assert::Result.types.keys.map{ |k| "#{k}?" })
     should have_imeths :to_sym, :to_s
 
     should "know its class-level type/name" do
-      assert_equal :unknown, subject.class.type
-      assert_equal "",       subject.class.name
+      assert_that(subject.class.type).equals(:unknown)
+      assert_that(subject.class.name).equals("")
     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)
+      result  = Base.for_test(test1, message, bt)
 
       exp_backtrace = Backtrace.new(bt)
       exp_trace     = exp_backtrace.filtered.first.to_s
 
-      assert_equal @test.name,           result.test_name
-      assert_equal @test.file_line.to_s, result.test_id
+      assert_that(result.test_name).equals(test1.name)
+      assert_that(result.test_id).equals(test1.file_line.to_s)
 
-      assert_equal message,       result.message
-      assert_equal exp_backtrace, result.backtrace
-      assert_equal exp_trace,     result.trace
+      assert_that(result.message).equals(message)
+      assert_that(result.backtrace).equals(exp_backtrace)
+      assert_that(result.trace).equals(exp_trace)
 
-      assert_false result.with_bt_set?
+      assert_that(result.with_bt_set?).is_false
     end
 
     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[:test_file_line], subject.test_file_line
-      assert_equal @given_data[:message],        subject.message
-      assert_equal @given_data[:output],         subject.output
-      assert_equal @given_data[:backtrace],      subject.backtrace
+      assert_that(subject.type).equals(given_data1[:type].to_sym)
+      assert_that(subject.name).equals(given_data1[:name])
+      assert_that(subject.test_name).equals(given_data1[:test_name])
+      assert_that(subject.test_file_line).equals(given_data1[:test_file_line])
+      assert_that(subject.message).equals(given_data1[:message])
+      assert_that(subject.output).equals(given_data1[:output])
+      assert_that(subject.backtrace).equals(given_data1[:backtrace])
     end
 
     should "default its attrs" do
       result = Base.new({})
 
-      assert_equal :unknown,                   result.type
-      assert_equal "",                         result.name
-      assert_equal "",                         result.test_name
-      assert_equal Assert::FileLine.parse(""), result.test_file_line
-      assert_equal "",                         result.message
-      assert_equal "",                         result.output
-      assert_equal Backtrace.new([]),          result.backtrace
-      assert_equal "",                         result.trace
+      assert_that(result.type).equals(:unknown)
+      assert_that(result.name).equals("")
+      assert_that(result.test_name).equals("")
+      assert_that(result.test_file_line).equals(Assert::FileLine.parse(""))
+      assert_that(result.message).equals("")
+      assert_that(result.output).equals("")
+      assert_that(result.backtrace).equals(Backtrace.new([]))
+      assert_that(result.trace).equals("")
     end
 
     should "know its test file line attrs" do
-      exp = @given_data[:test_file_line]
-      assert_equal exp.file,      subject.test_file_name
-      assert_equal exp.line.to_i, subject.test_line_num
-      assert_equal exp.to_s,      subject.test_id
+      exp = given_data1[:test_file_line]
+      assert_that(subject.test_file_name).equals(exp.file)
+      assert_that(subject.test_line_num).equals(exp.line.to_i)
+      assert_that(subject.test_id).equals(exp.to_s)
     end
 
     should "allow setting a new backtrace" do
-      new_bt        = build_backtrace
+      new_bt        = Factory.backtrace
       exp_backtrace = Backtrace.new(new_bt)
       exp_trace     = exp_backtrace.filtered.first.to_s
       subject.set_backtrace(new_bt)
-      assert_equal exp_backtrace, subject.backtrace
-      assert_equal exp_trace,     subject.trace
+      assert_that(subject.backtrace).equals(exp_backtrace)
+      assert_that(subject.trace).equals(exp_trace)
 
       # test that the first bt line is used if filtered is empty
       assert_lib_path = File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
@@ -133,46 +127,46 @@ module Assert::Result
       exp_backtrace   = Backtrace.new(new_bt)
       exp_trace       = exp_backtrace.first.to_s
       subject.set_backtrace(new_bt)
-      assert_equal exp_backtrace, subject.backtrace
-      assert_equal exp_trace,     subject.trace
+      assert_that(subject.backtrace).equals(exp_backtrace)
+      assert_that(subject.trace).equals(exp_trace)
     end
 
     should "allow setting a with bt backtrace and know if one has been set" do
-      assert_false subject.with_bt_set?
+      assert_that(subject.with_bt_set?).is_false
 
       orig_backtrace = subject.backtrace
-      with_bt        = build_backtrace
+      with_bt        = Factory.backtrace
 
       subject.set_with_bt(with_bt)
 
-      assert_true subject.with_bt_set?
-      assert_equal orig_backtrace, subject.backtrace
-      assert_equal with_bt.first,  subject.src_line
+      assert_that(subject.with_bt_set?).is_true
+      assert_that(subject.backtrace).equals(orig_backtrace)
+      assert_that(subject.src_line).equals(with_bt.first)
 
       exp = Backtrace.to_s(with_bt + [orig_backtrace.filtered.first])
-      assert_equal exp, subject.trace
+      assert_that(subject.trace).equals(exp)
     end
 
     should "know its src/file line attrs" do
-      new_bt = build_backtrace
+      new_bt = Factory.backtrace
       subject.set_backtrace(new_bt)
 
       exp = Backtrace.new(new_bt).filtered.first.to_s
-      assert_equal exp, subject.src_line
+      assert_that(subject.src_line).equals(exp)
 
       exp = Assert::FileLine.parse(subject.src_line)
-      assert_equal exp,           subject.file_line
-      assert_equal exp.file,      subject.file_name
-      assert_equal exp.line.to_i, subject.line_num
+      assert_that(subject.file_line).equals(exp)
+      assert_that(subject.file_name).equals(exp.file)
+      assert_that(subject.line_num).equals(exp.line.to_i)
 
       # test you get the same file line attrs using `set_with_bt`
       subject.set_with_bt(new_bt)
-      assert_equal new_bt.first.to_s, subject.src_line
+      assert_that(subject.src_line).equals(new_bt.first.to_s)
 
       exp = Assert::FileLine.parse(subject.src_line)
-      assert_equal exp,           subject.file_line
-      assert_equal exp.file,      subject.file_name
-      assert_equal exp.line.to_i, subject.line_num
+      assert_that(subject.file_line).equals(exp)
+      assert_that(subject.file_name).equals(exp.file)
+      assert_that(subject.line_num).equals(exp.line.to_i)
 
       # test that the first bt line is used if filtered is empty
       assert_lib_path = File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
@@ -180,45 +174,45 @@ module Assert::Result
       subject.set_backtrace(new_bt)
 
       exp = new_bt.first.to_s
-      assert_equal exp, subject.src_line
+      assert_that(subject.src_line).equals(exp)
 
       exp = Assert::FileLine.parse(subject.src_line)
-      assert_equal exp,           subject.file_line
-      assert_equal exp.file,      subject.file_name
-      assert_equal exp.line.to_i, subject.line_num
+      assert_that(subject.file_line).equals(exp)
+      assert_that(subject.file_name).equals(exp.file)
+      assert_that(subject.line_num).equals(exp.line.to_i)
     end
 
     should "know if it is a certain type of result" do
       Assert::Result.types.keys.each do |type|
-        assert_false subject.send("#{type}?")
+        assert_that(subject.send("#{type}?")).is_false
         Assert.stub(subject, :type){ type }
-        assert_true subject.send("#{type}?")
+        assert_that(subject.send("#{type}?")).is_true
       end
     end
 
     should "know its symbol representation" do
-      assert_equal subject.type, subject.to_sym
+      assert_that(subject.to_sym).equals(subject.type)
     end
 
     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_that(str).includes(subject.name.upcase)
+      assert_that(str).includes(subject.test_name)
+      assert_that(str).includes(subject.message)
+      assert_that(str).includes(subject.trace)
 
-      assert_equal 3, str.split("\n").count
+      assert_that(str.split("\n").count).equals(3)
 
       Assert.stub(subject, :message){ "" }
       Assert.stub(subject, :trace){ "" }
 
-      assert_equal 1, subject.to_s.split("\n").count
+      assert_that(subject.to_s.split("\n").count).equals(1)
     end
 
     should "know if it is equal to another result" do
-      other = Assert::Result::Base.new(@given_data)
-      assert_equal other, subject
+      other = Assert::Result::Base.new(given_data1)
+      assert_that(subject).equals(other)
 
       Assert.stub(other, [:type, :message].sample){ Factory.string }
       assert_not_equal other, subject
@@ -229,209 +223,191 @@ module Assert::Result
             "@message=#{subject.message.inspect} "\
             "@file_line=#{subject.file_line.to_s.inspect} "\
             "@test_file_line=#{subject.test_file_line.to_s.inspect}>"
-      assert_equal exp, subject.inspect
+      assert_that(subject.inspect).equals(exp)
     end
   end
 
-  class PassTests < UnitTests
-    desc "Pass"
-    setup do
-      @result = Pass.new({})
-    end
-    subject { @result }
+  class InitPassTests < UnitTests
+    desc "Pass when init"
+    subject { Pass.new({}) }
 
     should "know its type/name" do
-      assert_equal :pass,  subject.type
-      assert_equal :pass,  subject.class.type
-      assert_equal "Pass", subject.class.name
+      assert_that(subject.type).equals(:pass)
+      assert_that(subject.class.type).equals(:pass)
+      assert_that(subject.class.name).equals("Pass")
     end
   end
 
-  class IgnoreTests < UnitTests
-    desc "Ignore"
-    setup do
-      @result = Ignore.new({})
-    end
-    subject { @result }
+  class InitIgnoreTests < UnitTests
+    desc "Ignore when init"
+    subject { Ignore.new({}) }
 
     should "know its type/name" do
-      assert_equal :ignore,  subject.type
-      assert_equal :ignore,  subject.class.type
-      assert_equal "Ignore", subject.class.name
+      assert_that(subject.type).equals(:ignore)
+      assert_that(subject.class.type).equals(:ignore)
+      assert_that(subject.class.name).equals("Ignore")
     end
   end
 
-  class HaltingTestResultErrorTests < UnitTests
-    desc "HaltingTestResultError"
-    subject{ HaltingTestResultError.new }
+  class InitHaltingTestResultErrorTests < UnitTests
+    desc "HaltingTestResultError when init"
+    subject { HaltingTestResultError.new }
 
     should have_accessors :assert_with_bt
 
     should "be a runtime error" do
-      assert_kind_of RuntimeError, subject
+      assert_that(subject).is_kind_of(RuntimeError)
     end
   end
 
-  class TestFailureTests < UnitTests
-    desc "TestFailure"
-    subject{ TestFailure }
+  class InitTestFailureTests < UnitTests
+    desc "TestFailure when init"
+    subject { TestFailure.new }
 
     should "be a halting test result error" do
-      assert_kind_of HaltingTestResultError, subject.new
+      assert_that(subject).is_kind_of(HaltingTestResultError)
     end
   end
 
-  class FailTests < UnitTests
-    desc "Fail"
-    setup do
-      @result = Fail.new({})
-    end
-    subject { @result }
+  class InitFailTests < UnitTests
+    desc "Fail when init"
+    subject { Fail.new({}) }
 
     should "know its type/name" do
-      assert_equal :fail,  subject.type
-      assert_equal :fail,  subject.class.type
-      assert_equal "Fail", subject.class.name
+      assert_that(subject.type).equals(:fail)
+      assert_that(subject.class.type).equals(:fail)
+      assert_that(subject.class.name).equals("Fail")
     end
 
     should "allow creating for a test with TestFailure exceptions" do
       err = TestFailure.new
-      err.set_backtrace(build_backtrace)
-      result = Fail.for_test(@test, err)
+      err.set_backtrace(Factory.backtrace)
+      result = Fail.for_test(test1, err)
 
-      assert_equal err.message, result.message
+      assert_that(result.message).equals(err.message)
 
       err_backtrace = Backtrace.new(err.backtrace)
-      assert_equal err_backtrace, result.backtrace
+      assert_that(result.backtrace).equals(err_backtrace)
 
       # test assert with bt errors
-      err.assert_with_bt = build_backtrace
-      result = Fail.for_test(@test, err)
+      err.assert_with_bt = Factory.backtrace
+      result = Fail.for_test(test1, err)
 
-      assert_equal err.message,              result.message
-      assert_equal err.backtrace,            result.backtrace
-      assert_equal err.assert_with_bt.first, result.src_line
+      assert_that(result.message).equals(err.message)
+      assert_that(result.backtrace).equals(err.backtrace)
+      assert_that(result.src_line).equals(err.assert_with_bt.first)
 
       exp = Backtrace.to_s(err.assert_with_bt + [err_backtrace.filtered.first])
-      assert_equal exp, result.trace
+      assert_that(result.trace).equals(exp)
     end
 
     should "not allow creating for a test with non-TestFailure exceptions" do
-      assert_raises(ArgumentError){ Fail.for_test(@test, RuntimeError.new) }
+      assert_that { Fail.for_test(test1, RuntimeError.new) }.raises(ArgumentError)
     end
   end
 
-  class TestSkippedTests < UnitTests
-    desc "TestSkipped"
-    subject{ TestSkipped }
+  class InitTestSkippedTests < UnitTests
+    desc "TestSkipped when init"
+    subject { TestSkipped.new }
 
     should "be a halting test result error" do
-      assert_kind_of HaltingTestResultError, subject.new
+      assert_that(subject).is_kind_of(HaltingTestResultError)
     end
   end
 
-  class SkipTests < UnitTests
-    desc "Skip"
-    setup do
-      @result = Skip.new({})
-    end
-    subject { @result }
+  class InitSkipTests < UnitTests
+    desc "Skip when init"
+    subject { Skip.new({}) }
 
     should "know its type/name" do
-      assert_equal :skip,  subject.type
-      assert_equal :skip,  subject.class.type
-      assert_equal "Skip", subject.class.name
+      assert_that(subject.type).equals(:skip)
+      assert_that(subject.class.type).equals(:skip)
+      assert_that(subject.class.name).equals("Skip")
     end
 
     should "allow creating for a test with TestSkipped exceptions" do
       err = TestSkipped.new
-      err.set_backtrace(build_backtrace)
-      result = Skip.for_test(@test, err)
+      err.set_backtrace(Factory.backtrace)
+      result = Skip.for_test(test1, err)
 
-      assert_equal err.message, result.message
+      assert_that(result.message).equals(err.message)
 
       err_backtrace = Backtrace.new(err.backtrace)
-      assert_equal err_backtrace, result.backtrace
+      assert_that(result.backtrace).equals(err_backtrace)
 
       # test assert with bt errors
-      err.assert_with_bt = build_backtrace
-      result = Skip.for_test(@test, err)
+      err.assert_with_bt = Factory.backtrace
+      result = Skip.for_test(test1, err)
 
-      assert_equal err.message,              result.message
-      assert_equal err.backtrace,            result.backtrace
-      assert_equal err.assert_with_bt.first, result.src_line
+      assert_that(result.message).equals(err.message)
+      assert_that(result.backtrace).equals(err.backtrace)
+      assert_that(result.src_line).equals(err.assert_with_bt.first)
 
       exp = Backtrace.to_s(err.assert_with_bt + [err_backtrace.filtered.first])
-      assert_equal exp, result.trace
+      assert_that(result.trace).equals(exp)
     end
 
     should "not allow creating for a test with non-TestSkipped exceptions" do
-      assert_raises(ArgumentError){ Skip.for_test(@test, RuntimeError.new) }
+      assert_that { Skip.for_test(test1, RuntimeError.new) }.raises(ArgumentError)
     end
   end
 
-  class ErrorTests < UnitTests
-    desc "Error"
-    setup do
-      @result = Error.new({})
-    end
-    subject { @result }
+  class InitErrorTests < UnitTests
+    desc "Error when init"
+    subject { Error.new({}) }
 
     should "know its class-level type/name" do
-      assert_equal :error,  subject.class.type
-      assert_equal "Error", subject.class.name
+      assert_that(subject.class.type).equals(:error)
+      assert_that(subject.class.name).equals("Error")
     end
 
     should "allow creating for a test with exceptions" do
       err = Exception.new
-      err.set_backtrace(build_backtrace)
-      result = Error.for_test(@test, err)
+      err.set_backtrace(Factory.backtrace)
+      result = Error.for_test(test1, err)
 
       exp_msg = "#{err.message} (#{err.class.name})"
-      assert_equal exp_msg, result.message
+      assert_that(result.message).equals(exp_msg)
 
       exp_bt = Backtrace.new(err.backtrace)
-      assert_equal exp_bt,                 result.backtrace
-      assert_equal Backtrace.to_s(exp_bt), result.trace
+      assert_that(result.backtrace).equals(exp_bt)
+      assert_that(result.trace).equals(Backtrace.to_s(exp_bt))
     end
 
     should "not allow creating for a test without an exception" do
-      assert_raises(ArgumentError){ Error.for_test(@test, Factory.string) }
+      assert_that { Error.for_test(test1, Factory.string) }.raises(ArgumentError)
     end
   end
 
-  class BacktraceTests < UnitTests
-    desc "Backtrace"
-    setup do
-      @backtrace = Backtrace.new(build_backtrace)
-    end
-    subject { @backtrace }
+  class InitBacktraceTests < UnitTests
+    desc "Backtrace when init"
+    subject { Backtrace.new(Factory.backtrace) }
 
     should have_cmeths :parse, :to_s
     should have_imeths :filtered
 
     should "be parseable from its string representation" do
-      assert_equal subject, Backtrace.parse(Backtrace.to_s(subject))
+      assert_that(Backtrace.parse(Backtrace.to_s(subject))).equals(subject)
     end
 
     should "render as a string by joining on the newline" do
-      assert_equal subject.join(Backtrace::DELIM), Backtrace.to_s(subject)
+      assert_that(Backtrace.to_s(subject)).equals(subject.join(Backtrace::DELIM))
     end
 
     should "be an Array" do
-      assert_kind_of ::Array, subject
+      assert_that(subject).is_kind_of(::Array)
     end
 
     should "know its DELIM" do
-      assert_equal "\n", Backtrace::DELIM
+      assert_that(Backtrace::DELIM).equals("\n")
     end
 
     should "another backtrace when filtered" do
-      assert_kind_of Backtrace, subject
+      assert_that(subject).is_kind_of(Backtrace)
     end
 
     should "default itself when created from nil" do
-      assert_equal ["No backtrace"], Backtrace.new
+      assert_that(Backtrace.new).equals(["No backtrace"])
     end
   end
 end