test-unit 3.5.3 → 3.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a763b935a0a7386519019ce4dc198a3ba9f0dd00f9f44a10cb887d48f2b9d2e
-  data.tar.gz: a7b94931289833bc8406c5b07421425110a37ff9a099c43257a83e9b3759a7f0
+  metadata.gz: 4afce440e8f42a765407acb64e5f6791802bf32bccdc81cd31b910fbc5e85b36
+  data.tar.gz: 2f80c85f0fccdf7080a28d5663238121e21e449c332fd1fbd336de77e6f58c08
 SHA512:
-  metadata.gz: c4cda5342ca0dee7d082e7a61c41a16e532a270848c5944cad33b04fac1cc4b4eaafc3952fba1e8035f2a2f23dd0ef71adf01262210c8f4df860ef155e92cefd
-  data.tar.gz: a28acd0a86eaab701fc1bcc4682e17d1ddd2298fa34e2e292fffe488995f257b728fb0aaedb9d9e0511316dd411b9d44a09d59084c91997e190fef55a2b3ce14
+  metadata.gz: 5a3aed37e966fb5756a9a6ee2db2a863254f4c49138ce21e0a642328beb24bf650850d00c9aac2b65b45885f4c0ea42aff5df3c9a6abcb5cce29659f538de539
+  data.tar.gz: 78cbacaa7f92f73e51fae1e3c0fc8de5105d6c8c5bc5cf9002f2350c7eaa7633f9a74dcdfed74791ff0bb8bea7b0d2661ee4ac03b607b22c8f91da35ea1665ef

data/README.md

@@ -2,7 +2,6 @@
 
 [![Gem Version](https://badge.fury.io/rb/test-unit.png)](http://badge.fury.io/rb/test-unit)
 [![Build Status for Ruby 2.1+](https://github.com/test-unit/test-unit/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/test-unit/test-unit/actions/workflows/test.yml?query=branch%3Amaster+)
-[![Build Status for Ruby 1.9 and 2.0](https://travis-ci.com/test-unit/test-unit.svg?branch=master)](https://travis-ci.com/test-unit/test-unit)
 
 * http://test-unit.github.io/
 * https://github.com/test-unit/test-unit
@@ -16,6 +15,17 @@ principles. These were originally designed by Kent Beck, creator of extreme
 programming software development methodology, for Smalltalk's SUnit. It allows
 writing tests, checking results and automated testing in Ruby.
 
+test-unit ships as part of Ruby as a bundled gem. To check which version is included, see https://stdgems.org/test-unit/.
+It's only necessary to install the gem if you need a newer version.
+
+test-unit is the original Ruby unit testing library, and is still active.
+It is one of two unit testing libraries bundled with Ruby, the other being [minitest](https://github.com/seattlerb/minitest).
+
+When deciding which to use, consider:
+
+* test-unit is strict about backwards compatibility. A backwards-incompatible change would be considered a bug.
+* test-unit aims to support old Ruby versions, even if EOL.
+
 ## Features
 
 * test-unit 1.2.3 is the original test-unit, taken

data/doc/text/getting-started.md

@@ -243,4 +243,4 @@ end
 
 Let's read the official document.
 
-* [test-unit](http://test-unit.github.io/index.html)
+* [test-unit](https://test-unit.github.io/index.html)

data/doc/text/news.md

@@ -1,5 +1,21 @@
 # News
 
+## 3.5.4 - 2022-10-04 {#version-3-5-4}
+
+### Improvements
+
+  * Don't raise an error on `Test::Unit::TestCase.clone`.
+    [GitHub#210][Reported by David Marchaland]
+
+  * Added support for `BigDeciaml` in `assert_in_delta` family.
+    [GitHub#218][Patch by Kenta Murata]
+
+### Thanks
+
+  * David Marchaland
+
+  * Kenta Murata
+
 ## 3.5.3 - 2021-12-20 {#version-3-5-3}
 
 ### Improvements
@@ -1550,7 +1566,7 @@ Output improvement release!
   * use ~/.test-unit.yml as global configuration file.
   * add TAP runner. (--runner tap)
   * support colorized diff:
-    http://test-unit.github.io/color-diff.png
+    https://test-unit.github.io/color-diff.png
   * add Test::Unit::AutoRunner.default_runner= to specify default test runner.
 
 * 4 minor enhancements

data/lib/test/unit/assertions.rb

@@ -926,15 +926,37 @@ EOT
       #   assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
       def assert_in_delta(expected_float, actual_float, delta=0.001, message="")
         _wrap_assertion do
-          _assert_in_delta_validate_arguments(expected_float,
-                                              actual_float,
-                                              delta)
-          full_message = _assert_in_delta_message(expected_float,
-                                                  actual_float,
-                                                  delta,
-                                                  message)
+          begin
+            pass = delta >= (expected_float - actual_float).abs
+            assert_operator(delta, :>=, 0.0, "The delta should not be negative")
+            full_message = _assert_in_delta_message(expected_float,
+                                                    expected_float,
+                                                    actual_float,
+                                                    actual_float,
+                                                    delta,
+                                                    delta,
+                                                    message)
+          rescue Test::Unit::AssertionFailedError
+            # for the above assert_operator
+            raise
+          rescue
+            _assert_in_delta_validate_arguments(expected_float,
+                                                actual_float,
+                                                delta)
+            normalized_expected = expected_float.to_f
+            normalized_actual = actual_float.to_f
+            normalized_delta = delta.to_f
+            pass = (normalized_expected - normalized_actual).abs <= normalized_delta
+            full_message = _assert_in_delta_message(expected_float,
+                                                    normalized_expected,
+                                                    actual_float,
+                                                    normalized_actual,
+                                                    delta,
+                                                    normalized_delta,
+                                                    message)
+          end
           assert_block(full_message) do
-            (expected_float.to_f - actual_float.to_f).abs <= delta.to_f
+            pass
           end
         end
       end
@@ -951,13 +973,32 @@ EOT
           _assert_in_delta_validate_arguments(expected_float,
                                               actual_float,
                                               delta)
-          full_message = _assert_in_delta_message(expected_float,
-                                                  actual_float,
-                                                  delta,
-                                                  message,
-                                                  :negative_assertion => true)
+          begin
+            pass = (expected_float - actual_float).abs > delta
+            full_message = _assert_in_delta_message(expected_float,
+                                                    expected_float,
+                                                    actual_float,
+                                                    actual_float,
+                                                    delta,
+                                                    delta,
+                                                    message,
+                                                    :negative_assertion => true)
+          rescue
+            normalized_expected = expected_float.to_f
+            normalized_actual = actual_float.to_f
+            normalized_delta = delta.to_f
+            pass = (normalized_expected - normalized_actual).abs > normalized_delta
+            full_message = _assert_in_delta_message(expected_float,
+                                                    normalized_expected,
+                                                    actual_float,
+                                                    normalized_actual,
+                                                    delta,
+                                                    normalized_delta,
+                                                    message,
+                                                    :negative_assertion => true)
+          end
           assert_block(full_message) do
-            (expected_float.to_f - actual_float.to_f).abs > delta.to_f
+            pass
           end
         end
       end
@@ -984,7 +1025,9 @@ EOT
         assert_operator(delta, :>=, 0.0, "The delta should not be negative")
       end
 
-      def _assert_in_delta_message(expected_float, actual_float, delta,
+      def _assert_in_delta_message(expected_float, normalized_expected,
+                                   actual_float, normalized_actual,
+                                   delta, normalized_delta,
                                    message, options={})
         if options[:negative_assertion]
           format = <<-EOT
@@ -998,9 +1041,6 @@ EOT
 EOT
         end
         arguments = [expected_float, delta, actual_float]
-        normalized_expected = expected_float.to_f
-        normalized_actual = actual_float.to_f
-        normalized_delta = delta.to_f
         relation_format = nil
         relation_arguments = nil
         if normalized_actual < normalized_expected - normalized_delta
@@ -1049,22 +1089,52 @@ EOT
       def assert_in_epsilon(expected_float, actual_float, epsilon=0.001,
                             message="")
         _wrap_assertion do
-          _assert_in_epsilon_validate_arguments(expected_float,
-                                                actual_float,
-                                                epsilon)
-          full_message = _assert_in_epsilon_message(expected_float,
-                                                    actual_float,
-                                                    epsilon,
-                                                    message)
-          assert_block(full_message) do
-            normalized_expected_float = expected_float.to_f
-            if normalized_expected_float.zero?
-              delta = epsilon.to_f ** 2
+          begin
+            zero_p = expected_float.zero? rescue expected_float == 0
+            if zero_p
+              delta = epsilon ** 2
             else
-              delta = normalized_expected_float * epsilon.to_f
+              delta = expected_float * epsilon
             end
             delta = delta.abs
-            (normalized_expected_float - actual_float.to_f).abs <= delta
+            pass = (expected_float - actual_float).abs <= delta
+            assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
+            full_message = _assert_in_epsilon_message(expected_float,
+                                                      expected_float,
+                                                      actual_float,
+                                                      actual_float,
+                                                      epsilon,
+                                                      epsilon,
+                                                      delta,
+                                                      message)
+          rescue Test::Unit::AssertionFailedError
+            # for the above assert_operator
+            raise
+          rescue
+            _assert_in_epsilon_validate_arguments(expected_float,
+                                                  actual_float,
+                                                  epsilon)
+            normalized_expected = expected_float.to_f
+            normalized_actual = actual_float.to_f
+            normalized_epsilon = epsilon.to_f
+            if normalized_expected.zero?
+              delta = normalized_epsilon ** 2
+            else
+              delta = normalized_expected * normalized_epsilon
+            end
+            delta = delta.abs
+            full_message = _assert_in_epsilon_message(expected_float,
+                                                      normalized_expected,
+                                                      actual_float,
+                                                      normalized_actual,
+                                                      epsilon,
+                                                      normalized_epsilon,
+                                                      delta,
+                                                      message)
+            pass = (normalized_expected - normalized_actual).abs <= delta
+          end
+          assert_block(full_message) do
+            pass
           end
         end
       end
@@ -1080,18 +1150,43 @@ EOT
       def assert_not_in_epsilon(expected_float, actual_float, epsilon=0.001,
                                 message="")
         _wrap_assertion do
-          _assert_in_epsilon_validate_arguments(expected_float,
-                                                actual_float,
-                                                epsilon)
-          full_message = _assert_in_epsilon_message(expected_float,
-                                                    actual_float,
-                                                    epsilon,
-                                                    message,
-                                                    :negative_assertion => true)
+          begin
+            delta = expected_float * epsilon
+            pass = (expected_float - actual_float).abs > delta
+            assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
+            full_message = _assert_in_epsilon_message(expected_float,
+                                                      expected_float,
+                                                      actual_float,
+                                                      actual_float,
+                                                      epsilon,
+                                                      epsilon,
+                                                      delta,
+                                                      message,
+                                                      :negative_assertion => true)
+          rescue Test::Unit::AssertionFailedError
+            # for the above assert_operator
+            raise
+          rescue
+            _assert_in_epsilon_validate_arguments(expected_float,
+                                                  actual_float,
+                                                  epsilon)
+            normalized_expected = expected_float.to_f
+            normalized_actual = actual_float.to_f
+            normalized_epsilon = epsilon.to_f
+            delta = normalized_expected * normalized_epsilon
+            pass = (normalized_expected - normalized_actual).abs > delta
+            full_message = _assert_in_epsilon_message(expected_float,
+                                                      normalized_expected,
+                                                      actual_float,
+                                                      normalized_actual,
+                                                      epsilon,
+                                                      normalized_epsilon,
+                                                      delta,
+                                                      message,
+                                                      :negative_assertion => true)
+          end
           assert_block(full_message) do
-            normalized_expected_float = expected_float.to_f
-            delta = normalized_expected_float * epsilon.to_f
-            (normalized_expected_float - actual_float.to_f).abs > delta
+            pass
           end
         end
       end
@@ -1118,13 +1213,10 @@ EOT
         assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
       end
 
-      def _assert_in_epsilon_message(expected_float, actual_float, epsilon,
-                                     message, options={})
-        normalized_expected = expected_float.to_f
-        normalized_actual = actual_float.to_f
-        normalized_epsilon = epsilon.to_f
-        delta = normalized_expected * normalized_epsilon
-
+      def _assert_in_epsilon_message(expected_float, normalized_expected,
+                                     actual_float, normalized_actual,
+                                     epsilon, normalized_epsilon,
+                                     delta, message, options={})
         if options[:negative_assertion]
           format = <<-EOT
 <?> -/+ (<?> * <?>)[?] was expected to not include

data/lib/test/unit/attribute.rb

@@ -199,6 +199,7 @@ module Test
               ancestor.is_a?(Class) and
               ancestor < Test::Unit::Attribute
           end
+          return nil if @cached_parent_test.nil?
 
           @cached_parent_test_case.find_attribute(method_name, name, options)
         end

data/lib/test/unit/version.rb

@@ -1,5 +1,5 @@
 module Test
   module Unit
-    VERSION = "3.5.3"
+    VERSION = "3.5.4"
   end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: test-unit
 version: !ruby/object:Gem::Version
-  version: 3.5.3
+  version: 3.5.4
 platform: ruby
 authors:
 - Kouhei Sutou
 - Haruka Yoshihara
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-19 00:00:00.000000000 Z
+date: 2022-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: power_assert
@@ -95,7 +95,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: |
+description: |-
   test-unit (Test::Unit) is unit testing framework for Ruby, based on xUnit
   principles. These were originally designed by Kent Beck, creator of extreme
   programming software development methodology, for Smalltalk's SUnit. It allows
@@ -180,7 +180,7 @@ metadata:
   source_code_uri: https://github.com/test-unit/test-unit
   documentation_uri: https://test-unit.github.io/test-unit/en/
   bug_tracker_uri: https://github.com/test-unit/test-unit/issues
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -195,8 +195,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.0.dev
-signing_key: 
+rubygems_version: 3.4.0.dev
+signing_key:
 specification_version: 4
 summary: An xUnit family unit testing framework for Ruby.
 test_files: []