assert_statistically 0.1.1 → 0.2.0

data/CHANGELOG

@@ -1,2 +1,23 @@
-v0.0.1 (2007-07-17)
+v0.2.0 (2008-02-19)
+  * Please note that 0.2.0 is incompatible with 0.1.1.  Notably, there is no longer
+    a :sleep option.
+  * Added some documentation to the code.
+  * Can now pass a :before Proc and an :after Proc.  They will be passed the iteration number
+    and the number of successes thus far.  (This is how to restore the removed :sleep option.)
+  * Removed the :sleep option
+  * Changed the default message from 'assert_block (%d) failed' to
+    'Block returned false on iteration %d'
+  * Instead of an internal assert_block, the block is now called and the truth of the result is
+    used to determine success or failure.
+  * Now the test block can take two or zero parameters.  If two, the first one is the iteration number,
+    and the second one is the number of successes thus far.
+  * Changed the global $counter to the instance @counter in the unit tests.
+  * If min is not set, it now defaults to 1.
+  * If max is not set, it now defaults to the value of "of."
+  * Added a :short_circuit option (defaulting to true) that will break out of the loop as soon as
+    the conditions are met or are impossible to meet.
+  * Removed shebangs.
+  * Changed original version from 0.0.1 to 0.1.1 to match the gemspec.
+
+v0.1.1 (2007-07-17)
   * Birthday!

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2007 Zachary Holt
+Copyright (c) 2007,2008 Zachary Holt
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README

@@ -1,28 +1,8 @@
 Please see the MIT-LICENSE file for copyright and distribution information.
 
 assert_statistically is an addition to Test::Unit:TestCase that gives you a method
-called :assert_statistically, that wraps :assert_block, with some extra functionality.
+called :assert_statistically, that works like :assert_block, with some extra functionality.
 
-assert_statistically( :min => 3, :max => 6, :of => 10 ) do
-	some_method
-end
+Please see the code's documentation for more information.
 
-The above snippet will run the block (which simply calls :some_method) 10 times.  If
-it passes (as defined by assert_block) no fewer than 3 times and no more than 6 times,
-then the test "passes."
-
-:of defaults to 1
-:min defaults to :of
-:max defaults to 0 (0 is equal to no maximum)
-
-assert_statistically( :of => 10, :sleep => 3 ) do
-	some_method
-end
-
-The above snippet will run the block 10 times, sleeping 3 second between each run.
-
-Note that if the :sleep key "points" to something that responds to :call (e.g.,
-a Proc object), that something will have :call invoked on it, with a single parameter:
-a Hash containing values for the keys :min, :max, :index (the current iteration), and
-:passes (the number of times the test has passed thus far).  The result from that
-call will be passed to :sleep (so make it a number, eh?).
+Please note that 0.2.0 is incompatible with 0.1.1.  Notably, there is no longer a :sleep option.

data/lib/assert_statistically.rb

@@ -1,46 +1,109 @@
 module Test
   module Unit
     module Assertions
-      def assert_statistically( options={}, &blk )
+      ASSERT_STATISTICALLY_DEFAULT_FAILURE_MESSAGE = 'The block returned false on iteration %d'
+
+      # This method is used to determine whether we can short circuit and quit the
+      # iterations early.  It is called once before the "before" block (if any), and
+      # once before the "after" block (if any).  This means that if we can short circuit
+      # after the test block is called, but before the after block is called, we will.
+      # I.E., the after block will not be invoked in such a case.
+      def can_short_circuit?( range, completed, total, successes, short_circuit=true)
+        short_circuit && #first, be sure we can short circuit
+        (
+          # Are there enough successes, and is it impossible to get too many?
+          ( range.include?( successes ) && range.include?( total - completed + successes ) ) ||
+
+          # Are there too many successes?
+          successes > range.last ||
+
+          # Are there too few successes, and is it impossible to have enough?
+          total - completed + successes < range.first
+        )
+      end
+
+      # This is the main method of this library.
+      # It takes a hash of options and a block.
+      # Based on the options, the block will be run some number of times, possibly zero.
+      # If the criteria are met, assert_statistically is in a passing state.
+      # If assert_statistically enters a passing state and determines that it can never leave,
+      # it will be default short_circuit and run no more iterations.  You can override this
+      # behavior by passing :short_circuit => false in the options Hash.
+      # Other keys uses in the options Hash
+      #
+      # :message       => The message to report on failure.  Takes a %d string format directive,
+      #                   which is populated with the failing iteration number.
+      # :of            => The maximum number of times the test will be run (default = 1)
+      # :min           => The minimum number of times the test needs to pass (default = 1)
+      # :max           => The maximum number of times the test can pass (defaults to the value of of)
+      # :short_circuit => A flag determining whether to short circuit (defaults to true)
+      # :before        => An optional Proc that will be called before each iteration
+      # :after         => An optional Proc that will be called after each iteration
+      def assert_statistically( options={}, &test_block )
+        # If options is not a Hash, make it a hash, assuming that options.to_s is the message
         options = { :message => options.to_s } unless options.is_a?( Hash )
+
+        # The number of times to call the block; default is 1
         of = options[:of].to_i > 0 ? options[:of].to_i : 1
 
-        max = options[:max].to_i > 0 ? options[:max].to_i : 0
-        min = options[:min].to_i > 0 ? options[:min].to_i : 0
-        min = of if min == 0 && max == 0 || min > of
-        max = 0 if max > 0 && max < min
-        sleep_time = options[:sleep]
-        
-        message = options[:message].to_s.empty? ? 'assert_block (%d) failed' : options[:message].to_s
+        # Set min ; default is 1 (when :min is not present)
+        # Note that if you pass a :min <= 0, the assertion will always pass,
+        # unless max is less than min
+        # Note that :min => nil is the same as :min => 0
+        # Note that !defined( :min ) is the same as :min => 1
+        min = options.has_key?( :min ) && options[:min].respond_to?( :to_i ) ? options[:min].to_i : 1
+
+        # Set max ; default is :of
+        # Note that you can pass a :max > :of, in which case
+        # :min will be the only determinant of success
+        # (since you can't have more than :of succcesses in :of attempts)
+        max = options.has_key?( :max ) && options[:max].respond_to?( :to_i ) ? options[:max].to_i : of
+
+        # Fail if min is greater than max
+        raise AssertionFailedError.new( "Impossible range: [#{min}..#{max}]" ) if min > max
+
+        # Set short_circuit ; default is true
+        short_circuit = options.has_key?( :short_circuit ) && !options[:short_circuit] ? false : true
+
+        # Create the range within which the number of successful runs must fall
+        successful_range = Range.new( min, max )
+
+        # Set up the before and after blocks
+        before = options.has_key?( :before ) && options[:before].respond_to?( :call ) ? options[:before] : false
+        after = options.has_key?( :after ) && options[:after].respond_to?( :call ) ? options[:after] : false
+
+        # Set up the failure message
+        message = options[:message].to_s.empty? ? ASSERT_STATISTICALLY_DEFAULT_FAILURE_MESSAGE : options[:message].to_s
+
         final_message = ''
-        passes = 0
-        
+        successes = 0
+
         1.upto( of ) do |i|
-          begin
-            assert_block nil, &blk
-            passes += 1
-          rescue AssertionFailedError => e
-            final_message << "#{message % i}\n"
-          end
-          
-          unless sleep_time.nil?
-            if sleep_time.respond_to?( :call )
-              sleep sleep_time.call( :index => i, :passes => passes, :of => of, :min => min, :max => max )
-            elsif sleep_time.respond_to?( :to_f )
-              sleep sleep_time.to_f
-            end
-          end
-        end
+          # Check for short circuit eligibility (1 of 2)
+          break if can_short_circuit?( successful_range, i - 1, of, successes, short_circuit )
 
-        if min > 0
-          if max > 0
-            raise AssertionFailedError.new( final_message ) if passes < min || passes > max
+          # Call any before block
+          before.call( i, successes ) if before
+
+          # Call the test block
+          if test_block.call( i, successes )
+            successes += 1
           else
-            raise AssertionFailedError.new( final_message ) if passes < min
+            final_message << "#{message % i}\n"
           end
-        else
-          raise AssertionFailedError.new( final_message ) if passes > max
+
+          # Check for short circuit eligibility (2 of 2)
+          break if can_short_circuit?( successful_range, i, of, successes, short_circuit )
+
+          # Call any after block
+          after.call( i, successes ) if after
         end
+
+        # Fail if the number of successes is not in the successful range
+        raise AssertionFailedError.new( final_message ) unless successful_range.include?( successes )
+
+        # Pass
+        true
       end
     end
   end

data/test/all_tests.rb

@@ -1,4 +1,3 @@
-#!/usr/local/bin/ruby
 dir = File.expand_path( File.dirname( __FILE__ ) )
 
 Dir[File.join( File.join( File.dirname( __FILE__ ), 'unit' ), "*_test.rb" )].each { |f| require f }

data/test/unit/assert_statistically_test.rb

@@ -1,4 +1,3 @@
-#!/usr/local/bin/ruby
 dir = File.expand_path( File.dirname( __FILE__ ) )
 
 require 'test/unit'
@@ -6,169 +5,483 @@ require "#{File.expand_path( File.dirname( __FILE__ ) )}/test_setup"
 
 class AssertStatisticallyTest < Test::Unit::TestCase
   def setup
-    $counter = 0
+    @counter = 0
   end
   def teardown
   end
 
-  def test_assert_statistically_block
+  def test_with_short_circuit_without_min_without_max_pass
+    # short_circuit is true by default
+    assert_statistically( :of => 10 ) do
+      @counter += 1
+      true
+    end
+    assert_equal 1, @counter, "Should have gone through the assertions 1 time"
+  end
+
+  def test_with_short_circuit_without_min_without_max_fail
+    # short_circuit is true by default
+    begin
+      assert_statistically( :of => 10 ) do
+        @counter += 1
+        false
+      end
+    rescue Test::Unit::AssertionFailedError
+    else
+      flunk "Was supposed to fail because it did not have any successes"
+    end
+    assert_equal 10, @counter, "Should have gone through the assertions 10 times"
+  end
+
+  def test_with_short_circuit_without_min_with_max_pass
+    # short_circuit is true by default
+    assert_statistically( :of => 10, :max => 3 ) do
+      @counter += 1
+      @counter == 6
+    end
+
+    assert_equal 8, @counter, "Should have gone through the assertions 8 times, because we have to know that we won't exceed the max"
+  end
+
+  def test_with_short_circuit_without_min_with_max_fail
+    # short_circuit is true by default
+    begin
+      assert_statistically( :of => 10, :max => 3 ) do
+        @counter += 1
+        true
+      end
+    rescue Test::Unit::AssertionFailedError
+    else
+      flunk "Was supposed to fail because it had too many successes"
+    end
+
+    assert_equal 4, @counter, "Should have gone through the assertions 4 times"
+  end
+
+  def test_with_short_circuit_with_min_without_max_pass
+    # short_circuit is true by default
+    assert_statistically( :of => 10, :min => 4 ) do
+      @counter += 1
+      true
+    end
+
+    assert_equal 4, @counter, "Should have gone through the assertions 4 times"
+  end
+
+  def test_with_short_circuit_with_min_without_max_fail
+    # short_circuit is true by default
+    begin
+      assert_statistically( :of => 10, :min => 4 ) do
+        @counter += 1
+        false
+      end
+    rescue Test::Unit::AssertionFailedError
+    else
+      flunk "Was supposed to fail because it did not have enough successes"
+    end
+
+    assert_equal 7, @counter, "Should have gone through the assertions 7 times"
+  end
+
+  def test_with_short_circuit_with_min_with_max_pass
+    # short_circuit is true by default
+    assert_statistically( :of => 10, :min => 2, :max => 4 ) do
+      @counter += 1
+      [5,6,7].include?( @counter )
+    end
+
+    assert_equal 9, @counter, "Should have gone through the assertions 9 times"
+  end
+
+  def test_with_short_circuit_with_min_with_max_fail_too_few
+    # short_circuit is true by default
+    begin
+      assert_statistically( :of => 10, :min => 2, :max => 4 ) do
+        @counter += 1
+        5 == @counter
+      end
+    rescue Test::Unit::AssertionFailedError
+    else
+      flunk "Was supposed to fail because it only had 1 success"
+    end
+
+    assert_equal 10, @counter, "Should have gone through the assertions 10 times"
+  end
+
+  def test_with_short_circuit_with_min_with_max_fail_too_many
+    # short_circuit is true by default
+    begin
+      assert_statistically( :of => 10, :min => 2, :max => 4 ) do
+        @counter += 1
+        true
+      end
+    rescue Test::Unit::AssertionFailedError
+    else
+      flunk "Was supposed to fail because it had 5 successes"
+    end
+
+    assert_equal 5, @counter, "Should have gone through the assertions 5 times"
+  end
+
+
+
+  def test_without_short_circuit_without_min_without_max_pass
+    # short_circuit is true by default
+    assert_statistically( :short_circuit => false, :of => 10 ) do
+      @counter += 1
+      true
+    end
+
+    assert_equal 10, @counter, "Should have gone through the assertions 10 times"
+  end
+
+  def test_without_short_circuit_without_min_without_max_fail
+    # short_circuit is true by default
+    begin
+      assert_statistically( :short_circuit => false, :of => 10 ) do
+        @counter += 1
+        false
+      end
+    rescue Test::Unit::AssertionFailedError
+    else
+      flunk "Was supposed to fail because it did not have any successes"
+    end
+
+    assert_equal 10, @counter, "Should have gone through the assertions 10 time"
+  end
+
+  def test_without_short_circuit_without_min_with_max_pass
+    # short_circuit is true by default
+    assert_statistically( :short_circuit => false, :of => 10, :max => 3 ) do
+      @counter += 1
+      @counter == 8
+    end
+
+    assert_equal 10, @counter, "Should have gone through the assertions 10 times"
+  end
+
+  def test_without_short_circuit_without_min_with_max_fail
+    # short_circuit is true by default
+    begin
+      assert_statistically( :short_circuit => false, :of => 10, :max => 3 ) do
+        @counter += 1
+        true
+      end
+    rescue Test::Unit::AssertionFailedError
+    else
+      flunk "Was supposed to fail because it had too many successes"
+    end
+
+    assert_equal 10, @counter, "Should have gone through the assertions 10 times"
+  end
+
+  def test_without_short_circuit_with_min_without_max_pass
+    # short_circuit is true by default
+    assert_statistically( :short_circuit => false, :of => 10, :min => 4 ) do
+      @counter += 1
+      true
+    end
+
+    assert_equal 10, @counter, "Should have gone through the assertions 10 times"
+  end
+
+  def test_without_short_circuit_with_min_without_max_fail
+    # short_circuit is true by default
+    begin
+      assert_statistically( :short_circuit => false, :of => 10, :min => 4 ) do
+        @counter += 1
+        false
+      end
+    rescue Test::Unit::AssertionFailedError
+    else
+      flunk "Was supposed to fail because it did not have enough successes"
+    end
+
+    assert_equal 10, @counter, "Should have gone through the assertions 10 times"
+  end
+
+  def test_without_short_circuit_with_min_with_max_pass
+    # short_circuit is true by default
+    assert_statistically( :short_circuit => false, :of => 10, :min => 2, :max => 4 ) do
+      @counter += 1
+      [5,6,7].include?( @counter )
+    end
+
+    assert_equal 10, @counter, "Should have gone through the assertions 10 times"
+  end
+
+  def test_without_short_circuit_with_min_with_max_fail_too_few
+    # short_circuit is true by default
+    begin
+      assert_statistically( :short_circuit => false, :of => 10, :min => 2, :max => 4 ) do
+        @counter += 1
+        5 == @counter
+      end
+    rescue Test::Unit::AssertionFailedError
+    else
+      flunk "Was supposed to fail because it only had 1 success"
+    end
+
+    assert_equal 10, @counter, "Should have gone through the assertions 10 times"
+  end
+
+  def test_without_short_circuit_with_min_with_max_fail_too_many
+    # short_circuit is true by default
+    begin
+      assert_statistically( :short_circuit => false, :of => 10, :min => 2, :max => 4 ) do
+        @counter += 1
+        true
+      end
+    rescue Test::Unit::AssertionFailedError
+    else
+      flunk "Was supposed to fail because it had 5 successes"
+    end
+
+    assert_equal 10, @counter, "Should have gone through the assertions 10 times"
+  end
+
+  def test_block
     assert_statistically( :min => 10, :of => 10 ) do
-      $counter += 1
+      @counter += 1
       true
     end
-    assert_equal 10, $counter
+    assert_equal 10, @counter
+  end
+
+  def test_block_parameters
+    # Note that you can take the iteration we're on and the number of successes so
+    # far as parameters to the block
+    assert_statistically( :short_circuit => false, :of => 100 ) do |i,successes|
+      assert_equal successes, i / 2
+      i % 2 == 1
+    end
   end
 
-  def test_assert_statistically_block_sleep
+  def test_sleep
     t1 = Time.now
-    assert_statistically( :of => 5, :sleep => 0.5 ) do
-      $counter += 1
+    assert_statistically( :short_circuit => false, :of => 5, :after => lambda { sleep 0.5 } ) do
+      @counter += 1
       true
     end
     t2 = Time.now
     assert_in_delta 2.5, t2.to_f - t1.to_f, 0.2
-    assert_equal 5, $counter
+    assert_equal 5, @counter
+  end
 
-    $counter = 0
-    sleep_lambda = lambda { |o| $counter }
-    t1 = Time.now
-    assert_statistically( :of => 3, :sleep => sleep_lambda ) do
-      $counter += 1
+  def test_after_lambda
+    success = true
+    assert_statistically( :short_circuit => false, :of => 10, :after => lambda { @counter += 1 } ) do |i, successes|
+      # @counter should lag the iteration, because we invoked an after Proc
+      success &= ( @counter == i - 1 )
       true
     end
-    t2 = Time.now
-    assert_in_delta 6, t2.to_f - t1.to_f, 0.2
-    assert_equal 3, $counter
+    assert success
+    assert_equal 10, @counter
+  end
+
+  def test_before_lambda
+    success = true
+    assert_statistically( :short_circuit => false, :of => 10, :before => lambda { @counter += 1 } ) do |i, successes|
+      # @counter should equal the iteration, because we invoked a before Proc
+      success &= ( @counter == i )
+      true
+    end
+    assert success
+    assert_equal 10, @counter
   end
   
-  def test_assert_statistically_block_defaults
+  def test_block_defaults
     assert_statistically do
-      $counter += 1
+      @counter += 1
     end
-    assert_equal 1, $counter
+    assert_equal 1, @counter
   end
-  
-  def test_assert_statistically_block_min
-    assert_statistically( :min => 100 ) do
-      $counter += 1
+
+
+  def test_min_defaults_to_one
+    assert_statistically( :of => 10 ) do
+      @counter += 1
+      true
+    end
+    assert_equal 1, @counter
+  end
+
+  def test_min_can_be_set_to_zero
+    assert_statistically( :of => 10, :min => 0 ) do
+      @counter += 1
+      true
     end
-    assert_equal 1, $counter
+    assert_equal 0, @counter
+  end
 
+  def test_min_too_big_raises_exception
+    begin
+      assert_statistically( :min => 100, :of => 3 ) do
+        @counter += 1
+      end
+    rescue Test::Unit::AssertionFailedError => e
+      assert_match //, e.message
+    else
+      flunk "Should have raised an exception"
+    end
+  end
 
 
-    $counter = 0
+  def test_block_min
     begin
       assert_statistically( :min => 2, :of => 5 ) do
-        $counter += 1
-        $counter < 3
+        @counter += 1
+        @counter < 3
       end
-    rescue
+    rescue Test::Unit::AssertionFailedError
       flunk "Should not have failed"
     end
-    assert_equal 5, $counter
+    assert_equal 2, @counter
 
 
-    $counter = 0
+    @counter = 0
     begin
       assert_statistically( :min => 2, :of => 5 ) do
-        $counter += 1
-        $counter < 2
+        @counter += 1
+        @counter < 2
       end
-    rescue
+    rescue Test::Unit::AssertionFailedError
     else
       flunk "Should have failed"
     end
-    assert_equal 5, $counter
+    assert_equal 5, @counter
   end
 
 
-  def test_assert_statistically_block_max
-    assert_statistically( :max => 100 ) do
-      $counter += 1
+  def test_block_max_defaults_to_of
+    assert_statistically( :max => 100, :of => 4, :short_circuit => false ) do
+      @counter += 1
     end
-    assert_equal 1, $counter
+    assert_equal 4, @counter
+  end
 
+  def test_max_too_small_raises_exception
+    begin
+      assert_statistically( :max => -1, :of => 4 ) do
+        @counter += 1
+      end
+    rescue Test::Unit::AssertionFailedError
+    else
+      flunk "Should have failed"
+    end
+  end
 
-    $counter = 0
+  def test_max
+    @counter = 0
     begin
       assert_statistically( :max => 3, :of => 5 ) do
-        $counter += 1
-        $counter < 3
+        @counter += 1
+        @counter < 3
       end
-    rescue
+    rescue Test::Unit::AssertionFailedError
       flunk "Should not have failed"
     end
-    assert_equal 5, $counter
+    assert_equal 4, @counter
 
 
-    $counter = 0
+    @counter = 0
     begin
       assert_statistically( :max => 2, :of => 5 ) do
-        $counter += 1
-        $counter < 4
+        @counter += 1
+        @counter < 4
       end
-    rescue
+    rescue Test::Unit::AssertionFailedError
     else
       flunk "Should have failed"
     end
-    assert_equal 5, $counter
+    assert_equal 3, @counter
   end
 
-
-  def test_assert_statistically_block_min_and_max
-    assert_statistically( :max => 100, :min => 100 ) do
-      $counter += 1
+  def test_block_min_and_max
+    begin
+      assert_statistically( :max => 100, :min => 100 ) do
+        @counter += 1
+      end
+    rescue Test::Unit::AssertionFailedError
+    else
+      flunk "Should have failed because the min is higher than of"
     end
-    assert_equal 1, $counter
+    assert_equal 0, @counter
 
 
-    $counter = 0
+    @counter = 0
     begin
       assert_statistically( :min => 2, :max => 3, :of => 5 ) do
-        $counter += 1
-        $counter == 1
+        @counter += 1
+        @counter == 1
       end
-    rescue
+    rescue Test::Unit::AssertionFailedError
     else
-      flunk "Should have failed"
+      flunk "Should have failed because @counter is one only once"
     end
-    assert_equal 5, $counter
+    assert_equal 5, @counter
 
 
-    $counter = 0
+    @counter = 0
     begin
       assert_statistically( :min => 2, :max => 3, :of => 5 ) do
-        $counter += 1
-        $counter < 5
+        @counter += 1
+        @counter < 5
       end
-    rescue
+    rescue Test::Unit::AssertionFailedError
     else
-      flunk "Should have failed"
+      flunk "Should have failed because it passes 4 times, which is greater than the max"
     end
-    assert_equal 5, $counter
+    assert_equal 4, @counter
 
-    $counter = 0
+    @counter = 0
     begin
       assert_statistically( :min => 2, :max => 3, :of => 5 ) do
-        $counter += 1
-        $counter < 3
+        @counter += 1
+        @counter < 3
       end
-    rescue
+    rescue Test::Unit::AssertionFailedError
       flunk "Should not have failed"
     end
-    assert_equal 5, $counter
+    assert_equal 4, @counter
   end
 
+  def test_block_failure_message
+    begin
+      assert_statistically( :of => 2, :min => 2 ) do
+        @counter += 1
+        @counter == 1
+      end
+    rescue Test::Unit::AssertionFailedError
+      assert_equal 'Test::Unit::AssertionFailedError', $!.class.name
+      assert_equal "The block returned false on iteration 2\n", $!.message
+    else
+      flunk "Was supposed to raise a Test::Unit::AssertionFailedError"
+    end
+
 
-  
-  def test_assert_statistically_block_failure
+    @counter = 0
+    begin
+      assert_statistically( :of => 2, :min => 2, :message => 'Number %d failed' ) do
+        @counter += 1
+        @counter == 1
+      end
+    rescue Test::Unit::AssertionFailedError
+      assert_equal 'Test::Unit::AssertionFailedError', $!.class.name
+      assert_equal "Number 2 failed\n", $!.message
+    else
+      flunk "Was supposed to raise a Test::Unit::AssertionFailedError"
+    end
+  end
+
+  def test_block_failure
     begin
       assert_statistically( :of => 2 ) do
         false
       end
-    rescue
+    rescue Test::Unit::AssertionFailedError
       assert_equal 'Test::Unit::AssertionFailedError', $!.class.name
-      assert_equal "assert_block (1) failed\nassert_block (2) failed\n", $!.message
+      assert_equal "The block returned false on iteration 1\nThe block returned false on iteration 2\n", $!.message
     else
       flunk "Was supposed to raise a Test::Unit::AssertionFailedError"
     end

data/test/unit/test_setup.rb

@@ -1,4 +1,2 @@
-#!/usr/local/bin/ruby
-
 dir = File.expand_path( File::dirname( __FILE__ ) )
 require "#{dir}/../../lib/assert_statistically.rb"

metadata

@@ -1,56 +1,63 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
-specification_version: 1
 name: assert_statistically
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2007-07-17 00:00:00 -07:00
-summary: Unit::Test::Assertions addition that allows you to run assert_blocks many times in one pass
-require_paths: 
-- lib
-email: z@wzph.com
-homepage: 
-rubyforge_project: statistically
-description: assert_statistically is an addition to Unit::Test::Assertions that wraps assert_block.  You can set a number of times to run the block, a minimum and maximum number of times that the block must pass, a message for failure, and an amount of time to sleep between each run of the block.  Alternately, you can pass a Proc object to be called to determine the amount of time to sleep between each block.  The Proc object will be passed a single Hash containing all the relevant information.
-autorequire: assert_statistically
-default_executable: 
-bindir: bin
-has_rdoc: false
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.2.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
-- Zachary Holt
-files: 
-- lib/assert_statistically.rb
-- test/all_tests.rb
-- test/unit/assert_statistically_test.rb
-- test/unit/test_setup.rb
+- Zach Holt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-02-19 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: assert_statistically is an addition to Unit::Test::Assertions that functions like assert_block.  You can set a number of times to run the block, a minimum and maximum number of times that the block must pass, a message for failure, and a Proc to run before and after each run of the block.
+email: z@wzph.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
 - README
 - MIT-LICENSE
 - CHANGELOG
-test_files: 
+files: 
+- lib/assert_statistically.rb
 - test/all_tests.rb
 - test/unit/assert_statistically_test.rb
 - test/unit/test_setup.rb
-rdoc_options: []
-
-extra_rdoc_files: 
 - README
 - MIT-LICENSE
 - CHANGELOG
-executables: []
-
-extensions: []
+has_rdoc: true
+homepage: http://statistically.rubyforge.org
+post_install_message: 
+rdoc_options: []
 
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
-
+rubyforge_project: statistically
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Unit::Test::Assertions addition that allows you to run assert_blocks many times in one pass
+test_files: 
+- test/all_tests.rb
+- test/unit/assert_statistically_test.rb
+- test/unit/test_setup.rb