test-unit 3.4.2 → 3.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b0ea1c609f04e687f6b9c2bbc5d02efc79b1cf02516ddd36ff73a2cb974a2b0
-  data.tar.gz: 5110042334219485a6e99963685c6a51497509da5ec833516c0fa7a7a6eb0294
+  metadata.gz: 0f8ed035b9be7e1b2a3c92d767c8007d46e867131d7385e54b2096170d658226
+  data.tar.gz: 426871e1614d48c08de963123fb36654da1abf611d1b3ca005a952fc4c4dd66b
 SHA512:
-  metadata.gz: 7201589c5975139093ac4618f696ba4f40448f9d4da7e2d437545d3f105563aed379d382ce57fe09ac5b27aa41af235019befaf2a8d96d5dcc6d6609cc13798e
-  data.tar.gz: e65b33f3f9560ad8581987617520b03ccdd63d59d5354546663fc0898209b3bbcebdc471c2afca5c2112897d34ad6d933f7ef416f2d6ccaad805f45b0a17a24b
+  metadata.gz: 1ee530d7c01b91eee8ca71c62f6086ea3875c4fcf057ef5cd514896d633d4331f24ca5964a338622f7a80c747358cb85d4ae3996d30687b4f5f37d657d93f658
+  data.tar.gz: f0707e81dd0fa2f368759d0a61f1fae9dd764aeeb12e7e8c2cfd5b5f5fc0de76b13821154353fa1045b441a2a58f1d689a9530032c130ede1d3058d29f6d760b

data/README.md

@@ -1,7 +1,8 @@
 # test-unit
 
-[![](https://badge.fury.io/rb/test-unit.svg)](http://badge.fury.io/rb/test-unit)
-[![](https://travis-ci.org/test-unit/test-unit.svg?branch=master)](https://travis-ci.org/test-unit/test-unit)
+[![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
@@ -24,7 +25,7 @@ writing tests, checking results and automated testing in Ruby.
   to radically change very soon).
 
 * test-unit will be improved actively and may break
-  compatiblity with test-unit 1.2.3. (We will not hope it
+  compatibility with test-unit 1.2.3. (We will not hope it
   if it isn't needed.)
 
 * Some features exist as separated gems like GUI test

data/Rakefile

@@ -24,7 +24,6 @@ require "packnga"
 task :default => :test
 
 base_dir = File.dirname(__FILE__)
-html_base_dir = File.join(base_dir, "doc", "html")
 
 helper = Bundler::GemHelper.new(base_dir)
 def helper.version_tag
@@ -53,14 +52,6 @@ def rake(*arguments)
   ruby($0, *arguments)
 end
 
-namespace :html do
-  desc "Publish HTML to Web site."
-  task :publish do
-    # FIXME Do nothing for now
-    #rsync_to_rubyforge(spec, "#{html_base_dir}/", "")
-  end
-end
-
 task :test do
   ruby("test/run-test.rb")
 end

data/doc/text/getting-started.md

@@ -239,7 +239,7 @@ module Sub
 end
 ~~~
 
-## 7. For more inforomation
+## 7. For more information
 
 Let's read the official document.
 

data/doc/text/news.md

@@ -1,5 +1,57 @@
 # News
 
+## 3.4.6 - 2021-09-11 {#version-3-4-6}
+
+### Improvements
+
+  * Added support for tests that use Ractor. Use
+    `Test::Unit::TestCase.ractor` to declare that these tests use
+    Ractor.
+
+  * Added `--debug-on-failure` option.
+
+## 3.4.5 - 2021-09-04 {#version-3-4-5}
+
+### Improvements
+
+  * Added more metadata to gemspec.
+    [GitHub#183][Patch by Kenichi Kamiya]
+
+  * Removed needless files from gem.
+    [GitHub#184][Patch by Kenichi Kamiya]
+
+  * Updated documents.
+    [GitHub#191][GitHub#192][GitHub#193][GitHub#199][GitHub#200]
+    [GitHub#201][Patch by Kenichi Kamiya]
+
+  * Added `assert_nothing_leaked_memory`.
+
+### Fixes
+
+  * Fixed typos in documents.
+    [GitHub#189][GitHub#190][GitHub#195][GitHub#197][Patch by Kenichi Kamiya]
+
+### Thanks
+
+  * Kenichi Kamiya
+
+## 3.4.4 - 2021-06-04 {#version-3-4-4}
+
+### Improvements
+
+  * Renamed `assert_all?` to `assert_all`. `assert_all?` is deprecated
+    but is available.
+
+## 3.4.3 - 2021-06-04 {#version-3-4-3}
+
+### Improvements
+
+  * Stopped to change result value of `Test::Unit::TestCase#include`.
+
+  * Added `assert_all?`.
+
+  * Added support for `assert_raise_with_message`.
+
 ## 3.4.2 - 2021-05-30 {#version-3-4-2}
 
 ### Improvements

data/lib/test/unit/assertion-failed-error.rb

@@ -9,6 +9,17 @@ module Test
 
     # Thrown by Test::Unit::Assertions when an assertion fails.
     class AssertionFailedError < StandardError
+      class << self
+        @debug_on_failure = false
+        def debug_on_failure=(boolean)
+          @debug_on_failure = boolean
+        end
+
+        def debug_on_failure?
+          @debug_on_failure
+        end
+      end
+
       attr_accessor :expected, :actual, :user_message
       attr_accessor :inspected_expected, :inspected_actual
       def initialize(message=nil, options=nil)
@@ -19,6 +30,30 @@ module Test
         @inspected_actual = options[:inspected_actual]
         @user_message = options[:user_message]
         super(message)
+        debug_on_failure
+      end
+
+      private
+      def debug_on_failure
+        return unless self.class.debug_on_failure?
+
+        begin
+          require "debug"
+        rescue LoadError
+          return
+        end
+
+        return unless binding.respond_to?(:break)
+
+        frames = caller(0)
+        pre = nil
+        Util::BacktraceFilter.filter_backtrace(frames).each do |location|
+          frame_index = frames.index(location)
+          next if frame_index.nil?
+          pre = "frame #{frame_index}"
+          break
+        end
+        binding.break(pre: pre)
       end
     end
   end

data/lib/test/unit/assertions.rb

@@ -5,6 +5,7 @@
 
 require 'test/unit/assertion-failed-error'
 require 'test/unit/util/backtracefilter'
+require 'test/unit/util/memory-usage'
 require 'test/unit/util/method-owner-finder'
 require 'test/unit/diff'
 
@@ -43,7 +44,7 @@ module Test
 
       ##
       # The assertion upon which all other assertions are based. Passes if the
-      # block yields true.
+      # block yields not false nor nil.
       #
       # @example
       #   assert_block "Couldn't do the thing" do
@@ -289,6 +290,71 @@ EOT
       # Just for minitest compatibility. :<
       alias_method :assert_raises, :assert_raise
 
+      # Passes if the block raises `expected_exception` with
+      # `expected_message`. `expected_message` can be a `String` or
+      # `Regexp`.
+      #
+      # @example Pass pattern: String
+      #   assert_raise_with_message(RuntimeError, "Boom!!!") do
+      #     raise "Boom!!!"
+      #   end # -> pass
+      #
+      # @example Pass pattern: Regexp
+      #   assert_raise_with_message(RuntimeError, /!!!/) do
+      #     raise "Boom!!!"
+      #   end # -> pass
+      #
+      # @example Failure pattern: Exception class isn't matched
+      #   assert_raise_with_message(RuntimeError, "Boom!!!") do
+      #     raise ArgumentError, "Boom!!!"
+      #   end # -> failure
+      #
+      # @example Failure pattern: Exception message isn't matched
+      #   assert_raise_with_message(RuntimeError, "Boom!!!") do
+      #     raise "Hello"
+      #   end # -> failure
+      #
+      # @since 3.4.3
+      def assert_raise_with_message(expected_exception_class,
+                                    expected_message,
+                                    message=nil,
+                                    &block)
+        assert_expected_exception = Proc.new do |*_args|
+          _message, assert_exception_helper, actual_exception = _args
+          diff = AssertionMessage.delayed_diff([
+                                                 expected_exception_class,
+                                                 expected_message,
+                                               ],
+                                               [
+                                                 actual_exception.class,
+                                                 actual_exception.message,
+                                               ])
+          full_message = build_message(message,
+                                       "<?>(<?>) exception expected but was\n" +
+                                       "<?>(<?>).?",
+                                       expected_exception_class,
+                                       expected_message,
+                                       actual_exception.class,
+                                       actual_exception.message,
+                                       diff)
+          begin
+            assert_block(full_message) do
+              assert_exception_helper.expected?(actual_exception) and
+                expected_message === actual_exception.message
+            end
+          rescue AssertionFailedError => failure
+            _set_failed_information(failure,
+                                    expected_exception_class,
+                                    actual_exception)
+            raise failure # For JRuby. :<
+          end
+          actual_exception
+        end
+        args = [expected_exception_class]
+        args << message if message
+        _assert_raise(assert_expected_exception, *args, &block)
+      end
+
       ##
       # Passes if the block raises one of the given
       # exceptions or sub exceptions of the given exceptions.
@@ -389,7 +455,7 @@ EOT
       alias_method :refute_instance_of, :assert_not_instance_of
 
       ##
-      # Passes if `object` is nil.
+      # Passes if `object`.nil?.
       #
       # @example
       #   assert_nil [1, 2].uniq!
@@ -562,7 +628,7 @@ EOT
       ##
       # Compares the `object1` with `object2` using `operator`.
       #
-      # Passes if object1.__send__(operator, object2) is true.
+      # Passes if object1.__send__(operator, object2) is not false nor nil.
       #
       # @example
       #   assert_operator 5, :>=, 4
@@ -582,7 +648,7 @@ EOT
       ##
       # Compares the `object1` with `object2` using `operator`.
       #
-      # Passes if object1.__send__(operator, object2) is not true.
+      # Passes if object1.__send__(operator, object2) is false or nil.
       #
       # @example
       #   assert_not_operator(5, :<, 4) # => pass
@@ -722,7 +788,7 @@ EOT
       alias_method :refute_match, :assert_not_match
 
       ##
-      # Deprecated. Use #assert_not_match instead.
+      # @deprecated Use {#assert_not_match} instead.
       #
       # Passes if `regexp` !~ `string`
       #
@@ -1112,7 +1178,7 @@ EOT
 
       public
       ##
-      # Passes if the method send returns a true value.
+      # Passes if the method `__send__` returns not false nor nil.
       #
       # `send_array` is composed of:
       # * A receiver
@@ -1152,7 +1218,7 @@ EOT
       end
 
       ##
-      # Passes if the method send doesn't return a true value.
+      # Passes if the method `__send__` returns false or nil.
       #
       # `send_array` is composed of:
       # * A receiver
@@ -1202,7 +1268,7 @@ EOT
           assert_block(build_message(message,
                                      "<true> or <false> expected but was\n<?>",
                                      actual)) do
-            [true, false].include?(actual)
+            true == actual || false == actual
           end
         end
       end
@@ -1218,7 +1284,7 @@ EOT
           assert_block(build_message(message,
                                      "<true> expected but was\n<?>",
                                      actual)) do
-            actual == true
+            true == actual
           end
         end
       end
@@ -1234,14 +1300,14 @@ EOT
           assert_block(build_message(message,
                                      "<false> expected but was\n<?>",
                                      actual)) do
-            actual == false
+            false == actual
           end
         end
       end
 
       ##
       # Passes if expression "`expected` `operator`
-      # `actual`" is true.
+      # `actual`" is not false nor nil.
       #
       # @example
       #   assert_compare(1, "<", 10)  # -> pass
@@ -1370,7 +1436,7 @@ EOT
       end
 
       ##
-      # Passes if `object`.`predicate` is _true_.
+      # Passes if `object`.`predicate` is not false nor nil.
       #
       # @example
       #   assert_predicate([], :empty?)  # -> pass
@@ -1392,7 +1458,7 @@ EOT
       end
 
       ##
-      # Passes if `object`.`predicate` is not _true_.
+      # Passes if `object`.`predicate` is false or nil.
       #
       # @example
       #   assert_not_predicate([1], :empty?) # -> pass
@@ -1612,6 +1678,133 @@ EOT
       # @since 3.0.0
       alias_method :refute_empty, :assert_not_empty
 
+      # @overload assert_all(collection, message=nil, &block)
+      #
+      #   Asserts that all `block.call(item)` where `item` is each
+      #   item in `collection` are not false nor nil.
+      #
+      #   If `collection` is empty, this assertion is always passed
+      #   with any `block`.
+      #
+      #   @example Pass patterns
+      #     assert_all([1, 2, 3]) {|item| item > 0} # => pass
+      #     assert_all([1, 2, 3], &:positive?)      # => pass
+      #     assert_all([]) {|item| false}           # => pass
+      #
+      #   @example Failure pattern
+      #     assert_all([0, 1, 2], &:zero?) # => failure
+      #
+      #   @param [#each] collection The check target.
+      #   @param [String] message The additional user message. It is
+      #     showed when the assertion is failed.
+      #   @yield [Object] Give each item in `collection` to the block.
+      #   @yieldreturn [Object] The checked object.
+      #   @return [void]
+      #
+      # @since 3.4.4
+      def assert_all(collection, message=nil)
+        _wrap_assertion do
+          failed = false
+          result = {}
+          collection.each do |item|
+            element_result = yield(item)
+            failed = true unless element_result
+            result[item] = element_result
+          end
+          format = <<-FORMAT
+<?> was expected to be all true values with the given block but was
+<?>
+          FORMAT
+          full_message = build_message(message,
+                                       format,
+                                       collection,
+                                       result)
+          assert_block(full_message) do
+            not failed
+          end
+        end
+      end
+
+      # Just for Ruby's tool/lib/test/unit compatibility.
+      #
+      # @since 3.4.3
+      alias_method :assert_all?, :assert_all
+
+      # @overload assert_nothing_leaked_memory(max_increasable_size, target=:physical, message=nil, &block)
+      #
+      #   Asserts that increased memory usage by `block.call` is less
+      #   than `max_increasable_size`. `GC.start` is called before and
+      #   after `block.call`.
+      #
+      #   This assertion may be fragile. Because memory usage is
+      #   depends on the current Ruby process's memory
+      #   usage. Launching a new Ruby process for this will produce
+      #   more stable result but we need to specify target code as
+      #   `String` instead of block for the approach. We choose easy
+      #   to write API approach rather than more stable result
+      #   approach for this case.
+      #
+      #   @example Pass pattern
+      #     require "objspace"
+      #     size_per_object = ObjectSpace.memsize_of("Hello")
+      #     # If memory isn't leaked, physical memory of almost created objects
+      #     # (1000 - 10 objects) must be freed.
+      #     assert_nothing_leaked_memory(size_per_object * 10) do
+      #       1_000.times do
+      #         "Hello".dup
+      #       end
+      #     end # => pass
+      #
+      #   @example Failure pattern
+      #     require "objspace"
+      #     size_per_object = ObjectSpace.memsize_of("Hello")
+      #     strings = []
+      #     assert_nothing_leaked_memory(size_per_object * 10) do
+      #       10_000.times do
+      #         # Created objects aren't GC-ed because they are referred.
+      #         strings << "Hello".dup
+      #       end
+      #     end # => failure
+      #
+      #   @param target [:physical, :virtual] which memory usage is
+      #     used for comparing. `:physical` means physical memory usage
+      #     also known as Resident Set Size (RSS). `:virtual` means
+      #     virtual memory usage.
+      #   @yield [] do anything you want to measure memory usage
+      #     in the block.
+      #   @yieldreturn [void]
+      #   @return [void]
+      #
+      # @since 3.4.5
+      def assert_nothing_leaked_memory(max_increasable_size,
+                                       target=:physical,
+                                       message=nil)
+        _wrap_assertion do
+          GC.start
+          before = Util::MemoryUsage.new
+          unless before.collected?
+            omit("memory usage collection isn't supported on this platform")
+          end
+          yield
+          GC.start
+          after = Util::MemoryUsage.new
+          before_value = before.__send__(target)
+          after_value = after.__send__(target)
+          actual_increased_size = after_value - before_value
+          template = <<-TEMPLATE
+<?> was expected to be less than
+<?>.
+          TEMPLATE
+          full_message = build_message(message,
+                                       template,
+                                       actual_increased_size,
+                                       max_increasable_size)
+          assert_block(full_message) do
+            actual_increased_size < max_increasable_size
+          end
+        end
+      end
+
       ##
       # Builds a failure message.  `user_message` is added before the
       # `template` and `arguments` replaces the '?'s positionally in