assert 2.18.0 → 2.19.0

data/test/unit/runner_tests.rb

@@ -10,23 +10,25 @@ require "assert/view"
 class Assert::Runner
   class UnitTests < Assert::Context
     desc "Assert::Runner"
-    subject{ Assert::Runner }
+    subject { unit_class }
+
+    let(:unit_class) { Assert::Runner }
 
     should "include the config helpers" do
-      assert_includes Assert::ConfigHelpers, subject
+      assert_that(subject).includes(Assert::ConfigHelpers)
     end
   end
 
   class InitTests < UnitTests
     desc "when init"
-    setup do
-      @config = Factory.modes_off_config
-      @config.suite Assert::DefaultSuite.new(@config)
-      @config.view  Assert::View.new(@config, StringIO.new("", "w+"))
+    subject { unit_class.new(config1) }
 
-      @runner = Assert::Runner.new(@config)
+    setup do
+      config1.suite Assert::DefaultSuite.new(config1)
+      config1.view  Assert::View.new(config1, StringIO.new("", "w+"))
     end
-    subject{ @runner }
+
+    let(:config1) { Factory.modes_off_config }
 
     should have_readers :config
     should have_imeths :runner, :run
@@ -35,116 +37,114 @@ class Assert::Runner
     should have_imeths :before_test, :after_test, :on_result
 
     should "know its config" do
-      assert_equal @config, subject.config
+      assert_that(subject.config).equals(config1)
     end
 
     should "override the config helper's runner value with itself" do
-      assert_equal subject, subject.runner
+      assert_that(subject.runner).equals(subject)
     end
   end
 
   class RunTests < InitTests
     desc "and run"
-    setup do
-      @runner_class = Class.new(Assert::Runner) do
-        include CallbackMixin
-      end
-      suite_class  = Class.new(Assert::DefaultSuite){ include CallbackMixin }
-      view_class   = Class.new(Assert::View){ include CallbackMixin }
+    subject { runner_class1.new(config1) }
 
+    setup do
       @view_output = ""
 
-      @config.suite suite_class.new(@config)
-      @config.view  view_class.new(@config, StringIO.new(@view_output, "w+"))
+      suite_class = Class.new(Assert::DefaultSuite){ include CallbackMixin }
+      view_class  = Class.new(Assert::View){ include CallbackMixin }
 
-      @ci = Factory.context_info(Factory.modes_off_context_class)
-      @test = Factory.test("should pass", @ci){ assert(1==1) }
-      @config.suite.on_test(@test)
+      config1.suite suite_class.new(config1)
+      config1.view  view_class.new(config1, StringIO.new(@view_output, "w+"))
+      config1.suite.on_test(test1)
 
-      @runner = @runner_class.new(@config)
-      @result = @runner.run
+      @result_count = subject.run
     end
 
+    let(:runner_class1) { Class.new(unit_class) { include CallbackMixin } }
+    let(:ci1) { Factory.context_info(Factory.modes_off_context_class) }
+    let(:test1) { Factory.test("should pass", ci1){ assert(1==1) } }
+
     should "return the fail+error result count as an integer exit code" do
-      assert_equal 0, @result
+      assert_that(@result_count).equals(0)
 
       fail_count  = Factory.integer
       error_count = Factory.integer
       Assert.stub(subject, :fail_result_count){ fail_count }
       Assert.stub(subject, :error_result_count){ error_count }
-      Assert.stub(@test, :run){ } # no-op
-      result = @runner.run
+      Assert.stub(test1, :run){ } # no-op
+      result_count = subject.run
 
-      exp = fail_count + error_count
-      assert_equal exp, result
+      assert_that(result_count).equals(fail_count + error_count)
     end
 
     should "run all callbacks on itself, the suite and the view" do
       # itself
-      assert_true subject.on_start_called
-      assert_equal [@test], subject.before_test_called
-      assert_instance_of Assert::Result::Pass, subject.on_result_called.last
-      assert_equal [@test], subject.after_test_called
-      assert_true subject.on_finish_called
+      assert_that(subject.on_start_called).is_true
+      assert_that(subject.before_test_called).equals([test1])
+      assert_that(subject.on_result_called.last).is_instance_of(Assert::Result::Pass)
+      assert_that(subject.after_test_called).equals([test1])
+      assert_that(subject.on_finish_called).is_true
 
       # suite
-      suite = @config.suite
-      assert_true suite.on_start_called
-      assert_equal [@test], suite.before_test_called
-      assert_instance_of Assert::Result::Pass, suite.on_result_called.last
-      assert_equal [@test], suite.after_test_called
-      assert_true suite.on_finish_called
+      suite = config1.suite
+      assert_that(suite.on_start_called).is_true
+      assert_that(suite.before_test_called).equals([test1])
+      assert_that(suite.on_result_called.last).is_instance_of(Assert::Result::Pass)
+      assert_that(suite.after_test_called).equals([test1])
+      assert_that(suite.on_finish_called).is_true
 
       # view
-      view = @config.view
-      assert_true view.on_start_called
-      assert_equal [@test], view.before_test_called
-      assert_instance_of Assert::Result::Pass, view.on_result_called.last
-      assert_equal [@test], view.after_test_called
-      assert_true view.on_finish_called
+      view = config1.view
+      assert_that(view.on_start_called).is_true
+      assert_that(view.before_test_called).equals([test1])
+      assert_that(view.on_result_called.last).is_instance_of(Assert::Result::Pass)
+      assert_that(view.after_test_called).equals([test1])
+      assert_that(view.on_finish_called).is_true
     end
 
     should "describe running the tests in random order if there are tests" do
       exp = "Running tests in random order, " \
             "seeded with \"#{subject.runner_seed}\"\n"
-      assert_includes exp, @view_output
+      assert_that(@view_output).includes(exp)
 
       @view_output.gsub!(/./, "")
-      @config.suite.clear_tests_to_run
+      config1.suite.clear_tests_to_run
       subject.run
-      assert_not_includes exp, @view_output
+      assert_that(@view_output).does_not_include(exp)
     end
 
     should "run only a single test if a single test is configured" do
-      test = Factory.test("should pass", @ci){ assert(1==1) }
-      @config.suite.clear_tests_to_run
-      @config.suite.on_test(test)
-      @config.single_test test.file_line.to_s
+      test = Factory.test("should pass", ci1){ assert(1==1) }
+      config1.suite.clear_tests_to_run
+      config1.suite.on_test(test)
+      config1.single_test test.file_line.to_s
 
-      runner = @runner_class.new(@config).tap(&:run)
-      assert_equal [test], runner.before_test_called
+      runner = runner_class1.new(config1).tap(&:run)
+      assert_that(runner.before_test_called).equals([test])
     end
 
     should "not run any tests if a single test is configured but can't be found" do
-      test = Factory.test("should pass", @ci){ assert(1==1) }
-      @config.suite.clear_tests_to_run
-      @config.suite.on_test(test)
-      @config.single_test Factory.string
+      test = Factory.test("should pass", ci1){ assert(1==1) }
+      config1.suite.clear_tests_to_run
+      config1.suite.on_test(test)
+      config1.single_test Factory.string
 
-      runner = @runner_class.new(@config).tap(&:run)
-      assert_nil runner.before_test_called
+      runner = runner_class1.new(config1).tap(&:run)
+      assert_that(runner.before_test_called).is_nil
     end
 
     should "describe running only a single test if a single test is configured" do
-      @config.suite.clear_tests_to_run
-      @config.suite.on_test(@test)
-      @config.single_test @test.file_line.to_s
+      config1.suite.clear_tests_to_run
+      config1.suite.on_test(test1)
+      config1.single_test test1.file_line.to_s
       @view_output.gsub!(/./, "")
       subject.run
 
       exp = "Running test: #{subject.single_test_file_line}, " \
             "seeded with \"#{subject.runner_seed}\"\n"
-      assert_includes exp, @view_output
+      assert_that(@view_output).includes(exp)
     end
   end
 

data/test/unit/suite_tests.rb

@@ -6,30 +6,24 @@ require "assert/test"
 require "test/support/inherited_stuff"
 
 class Assert::Suite
-
   class UnitTests < Assert::Context
     desc "Assert::Suite"
-    subject{ Assert::Suite }
+    subject { unit_class }
 
-    should "include the config helpers" do
-      assert_includes Assert::ConfigHelpers, subject
-    end
+    let(:unit_class) { Assert::Suite }
 
-    should "know its test method regex" do
-      assert_match     "test#{Factory.string}", subject::TEST_METHOD_REGEX
-      assert_not_match "#{Factory.string}test", subject::TEST_METHOD_REGEX
+    should "include the config helpers" do
+      assert_that(subject).includes(Assert::ConfigHelpers)
     end
   end
 
   class InitTests < UnitTests
     desc "when init"
-    setup do
-      @config = Factory.modes_off_config
-      @suite  = Assert::Suite.new(@config)
-    end
-    subject{ @suite }
+    subject { unit_class.new(config1) }
 
-    should have_readers :config, :test_methods, :setups, :teardowns
+    let(:config1) { Factory.modes_off_config }
+
+    should have_readers :config, :setups, :teardowns
     should have_accessors :start_time, :end_time
     should have_imeths :suite, :setup, :startup, :teardown, :shutdown
     should have_imeths :tests_to_run?, :tests_to_run_count, :clear_tests_to_run
@@ -43,34 +37,33 @@ class Assert::Suite
     should have_imeths :before_test, :after_test, :on_result
 
     should "know its config" do
-      assert_equal @config, subject.config
+      assert_that(subject.config).equals(config1)
     end
 
     should "default its attrs" do
-      assert_equal [], subject.test_methods
-      assert_equal [], subject.setups
-      assert_equal [], subject.teardowns
+      assert_that(subject.setups).equals([])
+      assert_that(subject.teardowns).equals([])
 
-      assert_equal subject.start_time, subject.end_time
+      assert_that(subject.end_time).equals(subject.start_time)
     end
 
     should "override the config helper's suite value with itself" do
-      assert_equal subject, subject.suite
+      assert_that(subject.suite).equals(subject)
     end
 
     should "not provide any test/result count implementations" do
-      assert_nil subject.test_count
-      assert_nil subject.pass_result_count
-      assert_nil subject.fail_result_count
-      assert_nil subject.error_result_count
-      assert_nil subject.skip_result_count
-      assert_nil subject.ignore_result_count
+      assert_that(subject.test_count).is_nil
+      assert_that(subject.pass_result_count).is_nil
+      assert_that(subject.fail_result_count).is_nil
+      assert_that(subject.error_result_count).is_nil
+      assert_that(subject.skip_result_count).is_nil
+      assert_that(subject.ignore_result_count).is_nil
     end
 
     should "know its run time and rates" do
-      assert_equal 0, subject.run_time
-      assert_equal 0, subject.test_rate
-      assert_equal 0, subject.result_rate
+      assert_that(subject.run_time).equals(0)
+      assert_that(subject.test_rate).equals(0)
+      assert_that(subject.result_rate).equals(0)
 
       time = Factory.integer(3).to_f
       subject.end_time = subject.start_time + time
@@ -78,67 +71,71 @@ class Assert::Suite
       Assert.stub(subject, :test_count){ count }
       Assert.stub(subject, :result_count){ count }
 
-      assert_equal time, subject.run_time
-      assert_equal (subject.test_count / subject.run_time),   subject.test_rate
-      assert_equal (subject.result_count / subject.run_time), subject.result_rate
+      assert_that(subject.run_time).equals(time)
+      assert_that(subject.test_rate).equals((subject.test_count / subject.run_time))
+      assert_that(subject.result_rate).equals((subject.result_count / subject.run_time))
     end
 
     should "add setup procs" do
       status = nil
-      @suite.setup{ status = "setups" }
-      @suite.startup{ status += " have been run" }
+      subject.setup{ status = "setups" }
+      subject.startup{ status += " have been run" }
 
-      assert_equal 2, subject.setups.count
+      assert_that(subject.setups.count).equals(2)
       subject.setups.each(&:call)
-      assert_equal "setups have been run", status
+      assert_that(status).equals("setups have been run")
     end
 
     should "add teardown procs" do
       status = nil
-      @suite.teardown{ status = "teardowns" }
-      @suite.shutdown{ status += " have been run" }
+      subject.teardown{ status = "teardowns" }
+      subject.shutdown{ status += " have been run" }
 
-      assert_equal 2, subject.teardowns.count
+      assert_that(subject.teardowns.count).equals(2)
       subject.teardowns.each(&:call)
-      assert_equal "teardowns have been run", status
+      assert_that(status).equals("teardowns have been run")
     end
   end
 
   class WithTestsLoadedTests < InitTests
     desc "with tests loaded"
+
     setup do
-      ci = proc{ Factory.context_info(Factory.modes_off_context_class) }
-      @tests = [
-        Factory.test("should nothing", ci.call){ },
-        Factory.test("should pass",    ci.call){ assert(1==1); refute(1==0) },
-        Factory.test("should fail",    ci.call){ ignore; assert(1==0); refute(1==1) },
-        Factory.test("should ignore",  ci.call){ ignore },
-        Factory.test("should skip",    ci.call){ skip; ignore; assert(1==1) },
-        Factory.test("should error",   ci.call){ raise Exception; ignore; assert(1==1) }
-      ]
-      @tests.each{ |test| @suite.on_test(test) }
+      tests1.each{ |test| subject.on_test(test) }
     end
 
+    let(:ci1) { proc{ Factory.context_info(Factory.modes_off_context_class) } }
+    let(:tests1) {
+      [
+        Factory.test("should nothing", ci1.call){ },
+        Factory.test("should pass",    ci1.call){ assert(1==1); refute(1==0) },
+        Factory.test("should fail",    ci1.call){ ignore; assert(1==0); refute(1==1) },
+        Factory.test("should ignore",  ci1.call){ ignore },
+        Factory.test("should skip",    ci1.call){ skip; ignore; assert(1==1) },
+        Factory.test("should error",   ci1.call){ raise Exception; ignore; assert(1==1) }
+      ]
+    }
+
     should "know its tests-to-run attrs" do
-      assert_equal @tests.size, subject.tests_to_run_count
-      assert_true subject.tests_to_run?
+      assert_that(subject.tests_to_run_count).equals(tests1.size)
+      assert_that(subject.tests_to_run?).is_true
 
       subject.clear_tests_to_run
 
-      assert_equal 0, subject.tests_to_run_count
-      assert_false subject.tests_to_run?
+      assert_that(subject.tests_to_run_count).equals(0)
+      assert_that(subject.tests_to_run?).is_false
     end
 
     should "find a test to run given a file line" do
-      test = @tests.sample
-      assert_same test, subject.find_test_to_run(test.file_line)
+      test = tests1.sample
+      assert_that(subject.find_test_to_run(test.file_line)).is(test)
     end
 
     should "know its sorted tests to run" do
       sorted_tests = subject.sorted_tests_to_run{ 1 }
-      assert_equal @tests.size, sorted_tests.size
-      assert_kind_of Assert::Test, sorted_tests.first
-      assert_same sorted_tests.first, subject.sorted_tests_to_run{ 1 }.first
+      assert_that(sorted_tests.size).equals(tests1.size)
+      assert_that(sorted_tests.first).is_kind_of(Assert::Test)
+      assert_that(subject.sorted_tests_to_run{ 1 }.first).is(sorted_tests.first)
     end
   end
 end

data/test/unit/test_tests.rb

@@ -8,121 +8,100 @@ require "assert/result"
 class Assert::Test
   class UnitTests < Assert::Context
     desc "Assert::Test"
-    setup do
-      @context_class = Factory.modes_off_context_class{ desc "context class" }
-      @context_info  = Factory.context_info(@context_class)
-      @config        = Factory.modes_off_config
-      @test_code     = proc{ assert(true) }
-    end
-    subject{ Assert::Test }
+    subject { unit_class }
+
+    let(:unit_class) { Assert::Test }
+
+    let(:context_class1) { Factory.modes_off_context_class { desc "context class" } }
+    let(:context_info1)  { Factory.context_info(context_class1) }
+    let(:config1)        { Factory.modes_off_config }
+    let(:test_code1)     { proc { assert(true) } }
 
-    should have_imeths :name_file_line_context_data, :for_block, :for_method
+    should have_imeths :name_file_line_context_data, :for_block
 
     should "know how to build the name and file line given context" do
       test_name = Factory.string
-      data = subject.name_file_line_context_data(@context_info, test_name)
+      data = subject.name_file_line_context_data(context_info1, test_name)
 
-      exp = @context_info.test_name(test_name)
-      assert_equal exp, data[:name]
+      exp = context_info1.test_name(test_name)
+      assert_that(data[:name]).equals(exp)
 
-      exp = @context_info.called_from
-      assert_equal exp, data[:file_line]
+      exp = context_info1.called_from
+      assert_that(data[:file_line]).equals(exp)
     end
 
     should "build tests for a block" do
       name = Factory.string
-      test = subject.for_block(name, @context_info, @config, &@test_code)
+      test = subject.for_block(name, context_info1, config1, &test_code1)
 
-      exp = Assert::FileLine.parse(@context_info.called_from)
-      assert_equal exp, test.file_line
+      exp = Assert::FileLine.parse(context_info1.called_from)
+      assert_that(test.file_line).equals(exp)
 
-      exp = @context_info.test_name(name)
-      assert_equal exp, test.name
+      exp = context_info1.test_name(name)
+      assert_that(test.name).equals(exp)
 
-      assert_equal @context_info, test.context_info
-      assert_equal @config,       test.config
-      assert_equal @test_code,    test.code
-    end
-
-    should "build tests for a method" do
-      meth = "a_test_method"
-      test = subject.for_method(meth, @context_info, @config)
-
-      exp = Assert::FileLine.parse(@context_info.called_from)
-      assert_equal exp, test.file_line
-
-      exp = @context_info.test_name(meth)
-      assert_equal exp, test.name
-
-      assert_equal @context_info, test.context_info
-      assert_equal @config,       test.config
-
-      assert_kind_of Proc, test.code
-      self.instance_eval(&test.code)
-      assert_true @a_test_method_called
-    end
-
-    def a_test_method
-      @a_test_method_called = true
+      assert_that(test.context_info).equals(context_info1)
+      assert_that(test.config).equals(config1)
+      assert_that(test.code).equals(test_code1)
     end
   end
 
   class InitWithDataTests < UnitTests
     desc "when init with data"
-    setup do
-      @file_line = Assert::FileLine.new(Factory.string, Factory.integer.to_s)
-      @meta_data = {
-        :file_line => @file_line.to_s,
+    subject { unit_class.new(meta_data1.merge(run_data1)) }
+
+    let(:file_line1) { Assert::FileLine.new(Factory.string, Factory.integer.to_s) }
+    let(:meta_data1) {
+      {
+        :file_line => file_line1.to_s,
         :name      => Factory.string,
         :output    => Factory.string,
         :run_time  => Factory.float(1.0),
       }
-
-      @run_data = {
-        :context_info => @context_info,
-        :config       => @config,
-        :code         => @test_code
+    }
+    let(:run_data1) {
+      {
+        :context_info => context_info1,
+        :config       => config1,
+        :code         => test_code1
       }
-
-      @test = Assert::Test.new(@meta_data.merge(@run_data))
-    end
-    subject{ @test }
+    }
 
     should have_imeths :file_line, :file_name, :line_num
     should have_imeths :name, :output, :run_time
     should have_imeths :context_info, :context_class, :config, :code, :run
 
     should "use any given attrs" do
-      assert_equal @file_line,             subject.file_line
-      assert_equal @meta_data[:name],      subject.name
-      assert_equal @meta_data[:output],    subject.output
-      assert_equal @meta_data[:run_time],  subject.run_time
+      assert_that(subject.file_line).equals(file_line1)
+      assert_that(subject.name).equals(meta_data1[:name])
+      assert_that(subject.output).equals(meta_data1[:output])
+      assert_that(subject.run_time).equals(meta_data1[:run_time])
 
-      assert_equal @context_info, subject.context_info
-      assert_equal @config,       subject.config
-      assert_equal @test_code,    subject.code
+      assert_that(subject.context_info).equals(context_info1)
+      assert_that(subject.config).equals(config1)
+      assert_that(subject.code).equals(test_code1)
     end
 
     should "default its attrs" do
-      test = Assert::Test.new
+      test = unit_class.new
 
-      assert_equal Assert::FileLine.parse(""), test.file_line
-      assert_equal "", test.name
-      assert_equal "", test.output
-      assert_equal 0,  test.run_time
+      assert_that(test.file_line).equals(Assert::FileLine.parse(""))
+      assert_that(test.name).equals("")
+      assert_that(test.output).equals("")
+      assert_that(test.run_time).equals(0)
 
-      assert_nil test.context_info
-      assert_nil test.config
-      assert_nil test.code
+      assert_that(test.context_info).is_nil
+      assert_that(test.config).is_nil
+      assert_that(test.code).is_nil
     end
 
     should "know its context class" do
-      assert_equal @context_class, subject.context_class
+      assert_that(subject.context_class).equals(context_class1)
     end
 
     should "know its file line attrs" do
-      assert_equal subject.file_line.file,      subject.file_name
-      assert_equal subject.file_line.line.to_i, subject.line_num
+      assert_that(subject.file_name).equals(subject.file_line.file)
+      assert_that(subject.line_num).equals(subject.file_line.line.to_i)
     end
 
     should "have a custom inspect that only shows limited attributes" do
@@ -130,58 +109,60 @@ class Assert::Test
         "@#{method}=#{subject.send(method).inspect}"
       end.join(" ")
       exp = "#<#{subject.class}:#{"0x0%x" % (subject.object_id << 1)} #{attrs}>"
-      assert_equal exp, subject.inspect
+      assert_that(subject.inspect).equals(exp)
     end
   end
 
   class PassFailIgnoreHandlingTests < UnitTests
     include Assert::Test::TestHelpers
 
-    setup do
-      @test = Factory.test("pass fail ignore test", @context_info) do
+    subject {
+      Factory.test("pass fail ignore test", context_info1) do
         ignore("something")
         assert(true)
         assert(false)
       end
-      @test.context_class.setup do
+    }
+
+    setup do
+      subject.context_class.setup do
         ignore("something")
         assert(true)
         assert(false)
       end
-      @test.context_class.teardown do
+      subject.context_class.teardown do
         ignore("something")
         assert(true)
         assert(false)
       end
-      @test.run(&test_run_callback)
+      subject.run(&test_run_callback)
     end
-    subject{ @test }
 
     should "capture results in the test and any setups/teardowns" do
-      assert_equal 9, test_run_results.size
+      assert_that(test_run_results.size).equals(9)
       test_run_results.each do |result|
-        assert_kind_of Assert::Result::Base, result
+        assert_that(result).is_kind_of(Assert::Result::Base)
       end
     end
 
     should "capture pass results in the test and any setups/teardowns" do
-      assert_equal 3, test_run_results(:pass).size
+      assert_that(test_run_results(:pass).size).equals(3)
       test_run_results(:pass).each do |result|
-        assert_kind_of Assert::Result::Pass, result
+        assert_that(result).is_kind_of(Assert::Result::Pass)
       end
     end
 
     should "capture fail results in the test and any setups/teardowns" do
-      assert_equal 3, test_run_results(:fail).size
+      assert_that(test_run_results(:fail).size).equals(3)
       test_run_results(:fail).each do |result|
-        assert_kind_of Assert::Result::Fail, result
+        assert_that(result).is_kind_of(Assert::Result::Fail)
       end
     end
 
     should "capture ignore results in the test and any setups/teardowns" do
-      assert_equal 3, test_run_results(:ignore).size
+      assert_that(test_run_results(:ignore).size).equals(3)
       test_run_results(:ignore).each do |result|
-        assert_kind_of Assert::Result::Ignore, result
+        assert_that(result).is_kind_of(Assert::Result::Ignore)
       end
     end
   end
@@ -192,7 +173,7 @@ class Assert::Test
     desc "when in halt-on-fail mode"
 
     should "capture fail results" do
-      test = Factory.test("halt-on-fail test", @context_info) do
+      test = Factory.test("halt-on-fail test", context_info1) do
         raise Assert::Result::TestFailure
       end
       test.run(&test_run_callback)
@@ -201,7 +182,7 @@ class Assert::Test
     end
 
     should "capture fails in the context setup" do
-      test = Factory.test("setup halt-on-fail test", @context_info){ }
+      test = Factory.test("setup halt-on-fail test", context_info1){ }
       test.context_class.setup{ raise Assert::Result::TestFailure }
       test.run(&test_run_callback)
 
@@ -209,7 +190,7 @@ class Assert::Test
     end
 
     should "capture fails in the context teardown" do
-      test = Factory.test("teardown halt-on-fail test", @context_info){ }
+      test = Factory.test("teardown halt-on-fail test", context_info1){ }
       test.context_class.teardown{ raise Assert::Result::TestFailure }
       test.run(&test_run_callback)
 
@@ -220,9 +201,9 @@ class Assert::Test
 
     def assert_failed(test)
       with_backtrace(caller) do
-        assert_equal 1, test_run_result_count, "too many/few fail results"
+        assert_that(test_run_result_count).equals(1, "too many/few fail results")
         test_run_results.each do |result|
-          assert_kind_of Assert::Result::Fail, result, "not a fail result"
+          assert_that(result).is_kind_of(Assert::Result::Fail, "not a fail result")
         end
       end
     end
@@ -232,14 +213,14 @@ class Assert::Test
     include Assert::Test::TestHelpers
 
     should "capture skip results" do
-      test = Factory.test("skip test", @context_info){ skip }
+      test = Factory.test("skip test", context_info1){ skip }
       test.run(&test_run_callback)
 
       assert_skipped(test)
     end
 
     should "capture skips in the context setup" do
-      test = Factory.test("setup skip test", @context_info){ }
+      test = Factory.test("setup skip test", context_info1){ }
       test.context_class.setup{ skip }
       test.run(&test_run_callback)
 
@@ -247,7 +228,7 @@ class Assert::Test
     end
 
     should "capture skips in the context teardown" do
-      test = Factory.test("teardown skip test", @context_info){ }
+      test = Factory.test("teardown skip test", context_info1){ }
       test.context_class.teardown{ skip }
       test.run(&test_run_callback)
 
@@ -258,9 +239,9 @@ class Assert::Test
 
     def assert_skipped(test)
       with_backtrace(caller) do
-        assert_equal 1, test_run_result_count, "too many/few skip results"
+        assert_that(test_run_result_count).equals(1, "too many/few skip results")
         test_run_results.each do |result|
-          assert_kind_of Assert::Result::Skip, result, "not a skip result"
+          assert_that(result).is_kind_of(Assert::Result::Skip, "not a skip result")
         end
       end
     end
@@ -270,7 +251,7 @@ class Assert::Test
     include Assert::Test::TestHelpers
 
     should "capture error results" do
-      test = Factory.test("error test", @context_info) do
+      test = Factory.test("error test", context_info1) do
         raise StandardError, "WHAT"
       end
       test.run(&test_run_callback)
@@ -279,7 +260,7 @@ class Assert::Test
     end
 
     should "capture errors in the context setup" do
-      test = Factory.test("setup error test", @context_info){ }
+      test = Factory.test("setup error test", context_info1){ }
       test.context_class.setup{ raise "an error" }
       test.run(&test_run_callback)
 
@@ -287,7 +268,7 @@ class Assert::Test
     end
 
     should "capture errors in the context teardown" do
-      test = Factory.test("teardown error test", @context_info){ }
+      test = Factory.test("teardown error test", context_info1){ }
       test.context_class.teardown{ raise "an error" }
       test.run(&test_run_callback)
 
@@ -298,100 +279,98 @@ class Assert::Test
 
     def assert_errored(test)
       with_backtrace(caller) do
-        assert_equal 1, test_run_result_count, "too many/few error results"
+        assert_that(test_run_result_count).equals(1, "too many/few error results")
         test_run_results.each do |result|
-          assert_kind_of Assert::Result::Error, result, "not an error result"
+          assert_that(result).is_kind_of(Assert::Result::Error, "not an error result")
         end
       end
     end
   end
 
   class SignalExceptionHandlingTests < UnitTests
-
     should "raise any signal exceptions and not capture as an error" do
-      test = Factory.test("signal test", @context_info) do
+      test = Factory.test("signal test", context_info1) do
         raise SignalException, "USR1"
       end
 
-      assert_raises(SignalException){ test.run }
+      assert_that { test.run }.raises(SignalException)
     end
 
     should "raises signal exceptions in the context setup" do
-      test = Factory.test("setup signal test", @context_info){ }
+      test = Factory.test("setup signal test", context_info1){ }
       test.context_class.setup{ raise SignalException, "INT" }
 
-      assert_raises(SignalException){ test.run }
+      assert_that { test.run }.raises(SignalException)
     end
 
     should "raises signal exceptions in the context teardown" do
-      test = Factory.test("teardown signal test", @context_info){ }
+      test = Factory.test("teardown signal test", context_info1){ }
       test.context_class.teardown{ raise SignalException, "TERM" }
 
-      assert_raises(SignalException){ test.run }
+      assert_that { test.run }.raises(SignalException)
     end
   end
 
   class ComparingTests < UnitTests
     desc "<=> another test"
-    setup do
-      @test = Factory.test("mmm")
-    end
-    subject{ @test }
+    subject { Factory.test("mmm") }
 
     should "return 1 with a test named 'aaa' (greater than it)" do
-      result = @test <=> Factory.test("aaa")
-      assert_equal(1, result)
+      assert_that(subject <=> Factory.test("aaa")).equals(1)
     end
 
     should "return 0 with a test named the same" do
-      result = @test <=> Factory.test(@test.name)
-      assert_equal(0, result)
+      assert_that(subject <=> Factory.test(subject.name)).equals(0)
     end
 
     should "return -1 with a test named 'zzz' (less than it)" do
-      result = @test <=> Factory.test("zzz")
-      assert_equal(-1, result)
+      assert_that(subject <=> Factory.test("zzz")).equals(-1)
     end
   end
 
   class CaptureOutTests < UnitTests
     desc "when capturing std out"
-    setup do
-      @capture_config = Assert::Config.new(:capture_output => true)
-      @test = Factory.test("stdout", @capture_config) do
+    subject {
+      Factory.test("stdout", capture_config1) do
         puts "std out from the test"
         assert true
       end
-    end
+    }
+
+    let(:capture_config1) { Assert::Config.new(:capture_output => true) }
 
     should "capture any io from the test" do
-      @test.run
-      assert_equal "std out from the test\n", @test.output
+      subject.run
+      assert_that(subject.output).equals("std out from the test\n")
     end
   end
 
   class FullCaptureOutTests < CaptureOutTests
     desc "across setup, teardown, and meth calls"
-    setup do
-      @test = Factory.test("fullstdouttest", @capture_config) do
+    subject {
+      Factory.test("fullstdouttest", capture_config1) do
         puts "std out from the test"
         assert a_method_an_assert_calls
       end
-      @test.context_class.setup{ puts "std out from the setup" }
-      @test.context_class.teardown{ puts "std out from the teardown" }
-      @test.context_class.send(:define_method, "a_method_an_assert_calls") do
+    }
+
+    setup do
+      subject.context_class.setup{ puts "std out from the setup" }
+      subject.context_class.teardown{ puts "std out from the teardown" }
+      subject.context_class.send(:define_method, "a_method_an_assert_calls") do
         puts "std out from a method an assert called"
       end
     end
 
     should "collect all stdout in the output accessor" do
-      @test.run
-
-      exp_out = "std out from the setup\n"\
-                "std out from the test\n"\
-                "std out from a method an assert called\n"\
-                "std out from the teardown\n"
-      assert_equal(exp_out, @test.output)
+      subject.run
+
+      exp_out =
+        "std out from the setup\n"\
+        "std out from the test\n"\
+        "std out from a method an assert called\n"\
+        "std out from the teardown\n"
+      assert_that(subject.output).equals(exp_out)
     end
   end
 end