test-unit 3.0.3 → 3.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a84889d7e64ada72e39b5d39465d56fca7041b25
-  data.tar.gz: 723b397f2691190b10b17e0ba71dafa3d5d3247e
+  metadata.gz: cf2bacf30a66a56af147ea9e94da6e0494a2651d
+  data.tar.gz: dc496f0ff48c039ce45d31d9b0aeda8c8fe3207c
 SHA512:
-  metadata.gz: 7cccaddea4b0ddc35b4984a82b0b6fbc637f76f427671efa6c4aeba33e6f7246ac191cc62db8ced399db8128f478557e84e1e27ad0c8fbe35c4a27b966807083
-  data.tar.gz: 64f04e97bd245dbcb02fece0633cd3cfc5cdf14877a5d75cadb817d7743d97db9f2fcab4ea1a918c4aa88a27ed7531116bd68b1085ef00ffd9826272e2dab3b0
+  metadata.gz: ea2f7f667dbc1ebb99e234c2634f2b8ed4651d1d56704a5ab800d4f0fd285d97309a4ed4920020ef37cdc4eb8316c114d75045e33ba20652ee04e4d565ae519b
+  data.tar.gz: c8301808c3e979ee04682074550643a7b0ae214bba5eb60f4c9808be7d86ff2faa7eaded9829e47e9f841fd76257d37bdb1b294163faad401bc9150fe4c1a671

data/doc/text/news.md

@@ -1,5 +1,19 @@
 # News
 
+## 3.0.4 - 2014-11-01 {#version-3-0-4}
+
+It's a minor update release.
+
+### Improvements
+
+  * Stopped to remove JRuby and Rubinius internal backtrace entries from
+    backtrace on failure/error.
+    [GitHub#82][Patch by Charles Oliver Nutter]
+
+### Thanks
+
+  * Charles Oliver Nutter
+
 ## 3.0.3 - 2014-10-29 {#version-3-0-3}
 
 It's a minor update release.

data/lib/test/unit/assertions.rb

@@ -525,7 +525,7 @@ EOT
       alias_method :refute_respond_to, :assert_not_respond_to
 
       ##
-      # Passes if +string+ =~ +pattern+.
+      # Passes if +pattern+ =~ +string+.
       #
       # @example
       #   assert_match(/\d+/, 'five, 6, seven')
@@ -537,8 +537,9 @@ EOT
             else
               pattern
           end
-          full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
-          assert_block(full_message) { string =~ pattern }
+          full_message = build_message(message, "<?> expected to be =~\n<?>.",
+                                       pattern, string)
+          assert_block(full_message) { pattern =~ string }
         end
       end
 

data/lib/test/unit/util/backtracefilter.rb

@@ -23,31 +23,19 @@ module Test
             split_entry[-1].sub(TESTUNIT_RB_FILE, '') == split_prefix[-1]
           end
 
-          jruby_internal_p = lambda do |entry|
-            entry.start_with?("org/jruby/")
-          end
-
-          rubinius_internal_p = lambda do |entry|
-            entry.start_with?("kernel/")
-          end
-
-          found_prefix = false
+          in_user_code = false
           new_backtrace = backtrace.reverse.reject do |entry|
             if test_unit_internal_p.call(entry)
-              found_prefix = true
+              in_user_code = true
               true
-            elsif found_prefix
-              jruby_internal_p.call(entry) or rubinius_internal_p.call(entry)
             else
-              true
+              not in_user_code
             end
           end.reverse
 
           if new_backtrace.empty?
             new_backtrace = backtrace.reject do |entry|
-              test_unit_internal_p.call(entry) or
-                jruby_internal_p.call(entry) or
-                rubinius_internal_p.call(entry)
+              test_unit_internal_p.call(entry)
             end
             new_backtrace = backtrace if new_backtrace.empty?
           end

data/lib/test/unit/version.rb

@@ -1,5 +1,5 @@
 module Test
   module Unit
-    VERSION = '3.0.3'
+    VERSION = '3.0.4'
   end
 end

data/test/test-assertions.rb

@@ -772,13 +772,13 @@ EOM
         check_nothing_fails {
           assert_match(/strin./, "string", "successful assert_match")
         }
-        check_fail(%Q{<"string"> expected to be =~\n</slin./>.}) {
+        check_fail(%Q{</slin./> expected to be =~\n<"string">.}) {
           assert_match(/slin./, "string")
         }
-        check_fail(%Q{<"string"> expected to be =~\n</strin\\./>.}) {
+        check_fail(%Q{</strin\\./> expected to be =~\n<"string">.}) {
           assert_match("strin.", "string")
         }
-        check_fail(%Q{failed assert_match.\n<"string"> expected to be =~\n</slin./>.}) {
+        check_fail(%Q{failed assert_match.\n</slin./> expected to be =~\n<"string">.}) {
           assert_match(/slin./, "string", "failed assert_match")
         }
       end

data/test/test-test-case.rb

@@ -1,5 +1,5 @@
 # Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2008-2013  Kouhei Sutou <kou@clear-code.com>
+# Copyright:: Copyright (c) 2008-2014  Kouhei Sutou <kou@clear-code.com>
 # Copyright:: Copyright (c) 2011  Haruka Yoshihara <yoshihara@clear-code.com>
 # Copyright:: Copyright (c) 2000-2002  Nathaniel Talbott
 # License:: Ruby license.
@@ -28,7 +28,9 @@ module Test
       def setup
         @tc_failure_error = Class.new(TestCase) do
           def test_failure
-            assert_block("failure") { false }
+            assert_block("failure") do
+              false
+            end
           end
           def test_error
             1 / 0
@@ -37,7 +39,9 @@ module Test
             nested
           end
           def nested
-            assert_block("nested"){false}
+            assert_block("nested") do
+              false
+            end
           end
           def return_passed?
             return passed?
@@ -49,82 +53,157 @@ module Test
         end
       end
 
+      def jruby_backtrace_entry?(entry)
+        entry.start_with?("org/jruby/")
+      end
+
+      def rubinius_backtrace_entry?(entry)
+        entry.start_with?("kernel/")
+      end
+
+      def normalize_location(location)
+        filtered_location = location.reject do |entry|
+          jruby_backtrace_entry?(entry) or
+            rubinius_backtrace_entry?(entry)
+        end
+        filtered_location.collect do |entry|
+          entry.sub(/:\d+:/, ":0:")
+        end
+      end
+
       def test_add_failed_assertion
         test_case = @tc_failure_error.new(:test_failure)
-        check("passed? should start out true", test_case.return_passed?)
+        assert do
+          test_case.passed?
+        end
+
         result = TestResult.new
-        called = false
-        result.add_listener(TestResult::FAULT) {
-          | fault |
-          check("Should have a Failure", fault.instance_of?(Failure))
-          check("The Failure should have the correct message", "failure" == fault.message)
-          check("The Failure should have the correct test_name (was <#{fault.test_name}>)", fault.test_name == "test_failure(TC_FailureError)")
-          r = /\A.*#{Regexp.escape(File.basename(__FILE__))}:\d+:in `test_failure'\Z/
-
-          location = fault.location
-          check("The location should be an array", location.kind_of?(Array))
-          check("The location should have two lines (was: <#{location.inspect}>)", location.size == 2)
-          check("The Failure should have the correct location (was <#{location[0].inspect}>, expected <#{r.inspect}>)", r =~ location[0])
-          called = true
-        }
+        faults = []
+        result.add_listener(TestResult::FAULT) do |fault|
+          faults << fault
+        end
         progress = []
-        test_case.run(result) { |*arguments| progress << arguments }
-        check("The failure should have triggered the listener", called)
-        check("The failure should have set passed?", !test_case.return_passed?)
-        check("The progress block should have been updated correctly",
-              [[TestCase::STARTED, test_case.name],
-               [TestCase::STARTED_OBJECT, test_case],
-               [TestCase::FINISHED, test_case.name],
-               [TestCase::FINISHED_OBJECT, test_case]] == progress)
+        test_case.run(result) do |*arguments|
+          progress << arguments
+        end
+        fault_details = faults.collect do |fault|
+          {
+            :class     => fault.class,
+            :message   => fault.message,
+            :test_name => fault.test_name,
+            :location  => normalize_location(fault.location),
+          }
+        end
+        assert_equal([
+                       {
+                         :class     => Failure,
+                         :message   => "failure",
+                         :test_name => "test_failure(TC_FailureError)",
+                         :location  => [
+                           "#{__FILE__}:0:in `test_failure'",
+                           "#{__FILE__}:0:in `#{__method__}'",
+                         ],
+                       },
+                     ],
+                     fault_details)
+
+        assert do
+          not test_case.passed?
+        end
+        assert_equal([
+                       [TestCase::STARTED,         test_case.name],
+                       [TestCase::STARTED_OBJECT,  test_case],
+                       [TestCase::FINISHED,        test_case.name],
+                       [TestCase::FINISHED_OBJECT, test_case],
+                     ],
+                     progress)
       end
 
       def test_add_failure_nested
         test_case = @tc_failure_error.new(:test_nested_failure)
-        check("passed? should start out true", test_case.return_passed?)
+        assert do
+          test_case.passed?
+        end
 
         result = TestResult.new
-        called = false
-        result.add_listener(TestResult::FAULT) {
-          | fault |
-          check("Should have a Failure", fault.instance_of?(Failure))
-          check("The Failure should have the correct message", "nested" == fault.message)
-          check("The Failure should have the correct test_name (was <#{fault.test_name}>)", fault.test_name == "test_nested_failure(TC_FailureError)")
-
-          location = fault.location
-          check("The location should be an array", location.kind_of?(Array))
-          check("The location should have the correct number of lines (was: <#{location.inspect}>)", location.size == 3)
-          check("The Failure should have the correct location (was <#{location[0].inspect}>)", /\A.*#{Regexp.escape(File.basename(__FILE__))}:\d+:in `nested'\Z/ =~ location[0])
-          check("The Failure should have the correct location (was <#{location[1].inspect}>)", /\A.*#{Regexp.escape(File.basename(__FILE__))}:\d+:in `test_nested_failure'\Z/ =~ location[1])
-          called = true
-        }
-        test_case.run(result){}
-        check("The failure should have triggered the listener", called)
+        faults = []
+        result.add_listener(TestResult::FAULT) do |fault|
+          faults << fault
+        end
+        test_case.run(result) do
+        end
+        fault_details = faults.collect do |fault|
+          {
+            :class     => fault.class,
+            :message   => fault.message,
+            :test_name => fault.test_name,
+            :location  => normalize_location(fault.location),
+          }
+        end
+        assert_equal([
+                       {
+                         :class     => Failure,
+                         :message   => "nested",
+                         :test_name => "test_nested_failure(TC_FailureError)",
+                         :location  => [
+                           "#{__FILE__}:0:in `nested'",
+                           "#{__FILE__}:0:in `test_nested_failure'",
+                           "#{__FILE__}:0:in `#{__method__}'",
+                         ],
+                       },
+                     ],
+                     fault_details)
+
+        assert do
+          not test_case.passed?
+        end
       end
-      
+
       def test_add_error
         test_case = @tc_failure_error.new(:test_error)
-        check("passed? should start out true", test_case.return_passed?)
+        assert do
+          test_case.passed?
+        end
+
         result = TestResult.new
-        called = false
-        result.add_listener(TestResult::FAULT) {
-          | fault |
-          check("Should have a TestError", fault.instance_of?(Error))
-          check("The Error should have the correct message", "ZeroDivisionError: divided by 0" == fault.message)
-          check("The Error should have the correct test_name", "test_error(TC_FailureError)" == fault.test_name)
-          check("The Error should have the correct exception", fault.exception.instance_of?(ZeroDivisionError))
-          called = true
-        }
-        test_case.run(result) {}
-        check("The error should have triggered the listener", called)
-        check("The error should have set passed?", !test_case.return_passed?)
+        faults = []
+        result.add_listener(TestResult::FAULT) do |fault|
+          faults << fault
+        end
+        test_case.run(result) do
+        end
+        fault_details = faults.collect do |fault|
+          {
+            :class     => fault.class,
+            :message   => fault.message,
+            :test_name => fault.test_name,
+            :location  => normalize_location(fault.location),
+          }
+        end
+        assert_equal([
+                       {
+                         :class     => Error,
+                         :message   => "ZeroDivisionError: divided by 0",
+                         :test_name => "test_error(TC_FailureError)",
+                         :location  => [
+                           "#{__FILE__}:0:in `test_error'",
+                           "#{__FILE__}:0:in `#{__method__}'",
+                         ],
+                       },
+                     ],
+                     fault_details)
+
+        assert do
+          not test_case.passed?
+        end
       end
 
-      def test_no_tests      
+      def test_no_tests
         suite = TestCase.suite
         check("Should have a test suite", suite.instance_of?(TestSuite))
         check("Should have one test", suite.size == 1)
         check("Should have the default test", suite.tests.first.name == "default_test(Test::Unit::TestCase)")
-        
+
         result = TestResult.new
         suite.run(result) {}
         check("Should have had one test run", result.run_count == 1)
@@ -153,19 +232,18 @@ module Test
             assert_block {true}
           end
         end
-      
+
         suite = tc.suite
         check("Should have a test suite", suite.instance_of?(TestSuite))
         check("Should have three tests", suite.size == 3)
-  
+
         result = TestResult.new
         suite.run(result) {}
         check("Should have had three test runs", result.run_count == 3)
         check("Should have had one test failure", result.failure_count == 1)
         check("Should have had one test error", result.error_count == 1)
       end
-      
-     
+
       def test_setup_teardown
         tc = Class.new(TestCase) do
           attr_reader(:setup_called, :teardown_called)
@@ -191,34 +269,34 @@ module Test
           end
         end
         result = TestResult.new
-  
+
         test = tc.new(:test_succeed)
         test.run(result) {}
         check("Should have called setup the correct number of times", test.setup_called)
         check("Should have called teardown the correct number of times", test.teardown_called)
-  
+
         test = tc.new(:test_fail)
         test.run(result) {}
         check("Should have called setup the correct number of times", test.setup_called)
         check("Should have called teardown the correct number of times", test.teardown_called)
-  
+
         test = tc.new(:test_error)
         test.run(result) {}
         check("Should have called setup the correct number of times", test.setup_called)
         check("Should have called teardown the correct number of times", test.teardown_called)
-  
+
         check("Should have had two test runs", result.run_count == 3)
         check("Should have had a test failure", result.failure_count == 1)
         check("Should have had a test error", result.error_count == 1)
       end
-      
+
       def test_assertion_failed_not_called
         tc = Class.new(TestCase) do
           def test_thing
             raise AssertionFailedError.new
           end
         end
-        
+
         suite = tc.suite
         check("Should have one test", suite.size == 1)
         result = TestResult.new
@@ -227,7 +305,7 @@ module Test
         check("Should have had one assertion failure", result.failure_count == 1)
         check("Should not have any assertion errors but had #{result.error_count}", result.error_count == 0)
       end
-      
+
       def test_equality
         tc1 = Class.new(TestCase) do
           def test_1
@@ -235,31 +313,30 @@ module Test
           def test_2
           end
         end
-        
+
         tc2 = Class.new(TestCase) do
           def test_1
           end
         end
-      
+
         test1 = tc1.new('test_1')
         test2 = tc1.new('test_1')
         check("Should be equal", test1 == test2)
         check("Should be equal", test2 == test1)
-        
+
         test1 = tc1.new('test_2')
         check("Should not be equal", test1 != test2)
         check("Should not be equal", test2 != test1)
-        
+
         test2 = tc1.new('test_2')
         check("Should be equal", test1 == test2)
         check("Should be equal", test2 == test1)
-        
+
         test1 = tc1.new('test_1')
         test2 = tc2.new('test_1')
         check("Should not be equal", test1 != test2)
         check("Should not be equal", test2 != test1)
 
-        
         check("Should not be equal", test1 != Object.new)
         check("Should not be equal", Object.new != test1)
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: test-unit
 version: !ruby/object:Gem::Version
-  version: 3.0.3
+  version: 3.0.4
 platform: ruby
 authors:
 - Kouhei Sutou
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-28 00:00:00.000000000 Z
+date: 2014-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: power_assert