assert_statistically 0.1.1

data/CHANGELOG

@@ -0,0 +1,2 @@
+v0.0.1 (2007-07-17)
+  * Birthday!

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Zachary Holt
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,28 @@
+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.
+
+assert_statistically( :min => 3, :max => 6, :of => 10 ) do
+	some_method
+end
+
+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?).

data/lib/assert_statistically.rb

@@ -0,0 +1,47 @@
+module Test
+  module Unit
+    module Assertions
+      def assert_statistically( options={}, &blk )
+        options = { :message => options.to_s } unless options.is_a?( Hash )
+        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
+        final_message = ''
+        passes = 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
+
+        if min > 0
+          if max > 0
+            raise AssertionFailedError.new( final_message ) if passes < min || passes > max
+          else
+            raise AssertionFailedError.new( final_message ) if passes < min
+          end
+        else
+          raise AssertionFailedError.new( final_message ) if passes > max
+        end
+      end
+    end
+  end
+end

data/test/all_tests.rb

@@ -0,0 +1,4 @@
+#!/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

@@ -0,0 +1,176 @@
+#!/usr/local/bin/ruby
+dir = File.expand_path( File.dirname( __FILE__ ) )
+
+require 'test/unit'
+require "#{File.expand_path( File.dirname( __FILE__ ) )}/test_setup"
+
+class AssertStatisticallyTest < Test::Unit::TestCase
+  def setup
+    $counter = 0
+  end
+  def teardown
+  end
+
+  def test_assert_statistically_block
+    assert_statistically( :min => 10, :of => 10 ) do
+      $counter += 1
+      true
+    end
+    assert_equal 10, $counter
+  end
+
+  def test_assert_statistically_block_sleep
+    t1 = Time.now
+    assert_statistically( :of => 5, :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
+
+    $counter = 0
+    sleep_lambda = lambda { |o| $counter }
+    t1 = Time.now
+    assert_statistically( :of => 3, :sleep => sleep_lambda ) do
+      $counter += 1
+      true
+    end
+    t2 = Time.now
+    assert_in_delta 6, t2.to_f - t1.to_f, 0.2
+    assert_equal 3, $counter
+  end
+  
+  def test_assert_statistically_block_defaults
+    assert_statistically do
+      $counter += 1
+    end
+    assert_equal 1, $counter
+  end
+  
+  def test_assert_statistically_block_min
+    assert_statistically( :min => 100 ) do
+      $counter += 1
+    end
+    assert_equal 1, $counter
+
+
+
+    $counter = 0
+    begin
+      assert_statistically( :min => 2, :of => 5 ) do
+        $counter += 1
+        $counter < 3
+      end
+    rescue
+      flunk "Should not have failed"
+    end
+    assert_equal 5, $counter
+
+
+    $counter = 0
+    begin
+      assert_statistically( :min => 2, :of => 5 ) do
+        $counter += 1
+        $counter < 2
+      end
+    rescue
+    else
+      flunk "Should have failed"
+    end
+    assert_equal 5, $counter
+  end
+
+
+  def test_assert_statistically_block_max
+    assert_statistically( :max => 100 ) do
+      $counter += 1
+    end
+    assert_equal 1, $counter
+
+
+    $counter = 0
+    begin
+      assert_statistically( :max => 3, :of => 5 ) do
+        $counter += 1
+        $counter < 3
+      end
+    rescue
+      flunk "Should not have failed"
+    end
+    assert_equal 5, $counter
+
+
+    $counter = 0
+    begin
+      assert_statistically( :max => 2, :of => 5 ) do
+        $counter += 1
+        $counter < 4
+      end
+    rescue
+    else
+      flunk "Should have failed"
+    end
+    assert_equal 5, $counter
+  end
+
+
+  def test_assert_statistically_block_min_and_max
+    assert_statistically( :max => 100, :min => 100 ) do
+      $counter += 1
+    end
+    assert_equal 1, $counter
+
+
+    $counter = 0
+    begin
+      assert_statistically( :min => 2, :max => 3, :of => 5 ) do
+        $counter += 1
+        $counter == 1
+      end
+    rescue
+    else
+      flunk "Should have failed"
+    end
+    assert_equal 5, $counter
+
+
+    $counter = 0
+    begin
+      assert_statistically( :min => 2, :max => 3, :of => 5 ) do
+        $counter += 1
+        $counter < 5
+      end
+    rescue
+    else
+      flunk "Should have failed"
+    end
+    assert_equal 5, $counter
+
+    $counter = 0
+    begin
+      assert_statistically( :min => 2, :max => 3, :of => 5 ) do
+        $counter += 1
+        $counter < 3
+      end
+    rescue
+      flunk "Should not have failed"
+    end
+    assert_equal 5, $counter
+  end
+
+
+  
+  def test_assert_statistically_block_failure
+    begin
+      assert_statistically( :of => 2 ) do
+        false
+      end
+    rescue
+      assert_equal 'Test::Unit::AssertionFailedError', $!.class.name
+      assert_equal "assert_block (1) failed\nassert_block (2) failed\n", $!.message
+    else
+      flunk "Was supposed to raise a Test::Unit::AssertionFailedError"
+    end
+  end
+end

data/test/unit/test_setup.rb

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

metadata

@@ -0,0 +1,56 @@
+--- !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: 
+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
+- README
+- MIT-LICENSE
+- CHANGELOG
+test_files: 
+- 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: []
+
+requirements: []
+
+dependencies: []
+