delano-tryouts 0.7.0 → 0.7.1

data/CHANGES.txt

@@ -1,9 +1,14 @@
 TRYOUTS, CHANGES
 
 
-#### 0.6.4 (2009-06-25) ###############################
+#### 0.7.1 (2009-06-26) ###############################
 
-NOTE: command testing (:cli) is still disabled.
+* FIXED: Updated manifest in gemspec
+* CHANGE: :cli testing is disabled indefinitely
+* ADDED: Found Muggsy Bogues
+
+
+#### 0.7.0 (2009-06-25) ###############################
 
 * FIXED: Stash wasn't being displayed in the drill report
 * CHANGE: CLI is now formatted to be 80 characters wide. 
@@ -80,11 +85,11 @@ NOTE: command testing (:cli) is disabled.
 * ADDED: Drill stash!
 * ADDED: xdream and better handling for drills and dreams with no name
 
+
 #### 0.4.1 (2009-06-07) ###############################
 
 * CHANGE: The CLI output is no longer terrifyingly ugly
 
-
 #### 0.4.0 (2009-06-05) ###############################
 
 NOTE: Initial public release

data/lib/tryouts.rb

@@ -32,7 +32,7 @@ class Tryouts
   # Raised when there is a problem loading or parsing a Tryouts::Drill::Dream object
   class BadDreams < Exception; end
   
-  VERSION = "0.7.0"
+  VERSION = "0.7.1"
   
   require 'tryouts/mixins'
   require 'tryouts/tryout'

data/lib/tryouts/drill/sergeant/benchmark.rb

@@ -0,0 +1,51 @@
+
+
+
+
+class Tryouts; class Drill; module Sergeant
+  
+  # = Benchmark
+  # 
+  # The sergeant responsible for running benchmarks
+  #
+  class Benchmark
+    require 'benchmark'
+    
+    attr_reader :output
+    
+    # * +reps+ Number of times to execute drill (>= 0, <= 30). Default: 3
+    #
+    def initialize(reps=nil)
+      @reps = (1..30).include?(reps) ? reps : 5
+      @stats = Tryouts::Stats.new
+    end
+  
+    def run(block, context, &inline)
+      # A Proc object takes precedence over an inline block. 
+      runtime = (block.nil? ? inline : block)
+      response = Tryouts::Drill::Reality.new
+      if runtime.nil?
+        raise "We need a block to benchmark"
+      else
+        begin
+          
+          @reps.times do
+            run = ::Benchmark.realtime &runtime
+            @stats.sample run
+          end
+          
+          response.output = @stats
+          
+        rescue => e
+          puts e.message, e.backtrace if Tryouts.verbose > 2
+          response.output = false
+          response.etype = e.class
+          response.error = e.message
+          response.trace = e.backtrace
+        end
+      end
+      response
+    end
+    
+  end
+end; end; end

data/lib/tryouts/drill/sergeant/rbenchmark.rb

@@ -0,0 +1,132 @@
+
+require 'benchmark'
+
+
+class Tryouts; class Drill; module Sergeant
+
+  # = RBenchmark
+  #
+  # This is an implementation of Better-Benchmark:
+  # http://github.com/Pistos/better-benchmark/
+  #
+  # NOTE: It's a work in progress and currently not functioning
+  #
+  # See also: http://www.graphpad.com/articles/interpret/Analyzing_two_groups/wilcoxon_matched_pairs.htm
+  #
+  module RBenchmark
+    
+    VERSION = '0.7.0'
+
+    class ComparisonPartial
+      def initialize( block, options )
+        @block1 = block
+        @options = options
+      end
+
+      def with( &block2 )
+        times1 = []
+        times2 = []
+
+        (1..@options[ :iterations ]).each do |iteration|
+          if @options[ :verbose ]
+            $stdout.print "."; $stdout.flush
+          end
+
+          times1 << ::Benchmark.realtime do
+            @options[ :inner_iterations ].times do |i|
+              @block1.call( iteration )
+            end
+          end
+          times2 << ::Benchmark.realtime do
+            @options[ :inner_iterations ].times do |i|
+              block2.call( iteration )
+            end
+          end
+        end
+
+        r = RSRuby.instance
+        wilcox_result = r.wilcox_test( times1, times2 )
+
+        {
+          :results1 => {
+            :times => times1,
+            :mean => r.mean( times1 ),
+            :stddev => r.sd( times1 ),
+          },
+          :results2 => {
+            :times => times2,
+            :mean => r.mean( times2 ),
+            :stddev => r.sd( times2 ),
+          },
+          :p => wilcox_result[ 'p.value' ],
+          :W => wilcox_result[ 'statistic' ][ 'W' ],
+          :significant => (
+            wilcox_result[ 'p.value' ] < @options[ :required_significance ]
+          ),
+        }
+      end
+      alias to with
+    end
+
+    # Options:
+    # :iterations
+    # The number of times to execute the pair of blocks.
+    # :inner_iterations
+    # Used to increase the time taken per iteration.
+    # :required_significance
+    # Maximum allowed p value in order to declare the results statistically significant.
+    # :verbose
+    # Whether to print a dot for each iteration (as a sort of progress meter).
+    #
+    # To use better-benchmark properly, it is important to set :iterations and
+    # :inner_iterations properly. There are a few things to bear in mind:
+    #
+    # (1) Do not set :iterations too high. It should normally be in the range
+    # of 10-20, but can be lower. Over 25 should be considered too high.
+    # (2) Execution time for one run of the blocks under test should not be too
+    # small (or else random variance will muddle the results). Aim for at least
+    # 1.0 seconds per iteration.
+    # (3) Minimize the proportion of any warmup time (and cooldown time) of one
+    # block run.
+    #
+    # In order to achieve these goals, you will need to tweak :inner_iterations
+    # based on your situation. The exact number you should use will depend on
+    # the strength of the hardware (CPU, RAM, disk), and the amount of work done
+    # by the blocks. For code blocks that execute extremely rapidly, you may
+    # need hundreds of thousands of :inner_iterations.
+    def self.compare_realtime( options = {}, &block1 )
+      require 'rsruby'
+      
+      options[ :iterations ] ||= 20
+      options[ :inner_iterations ] ||= 1
+      options[ :required_significance ] ||= 0.01
+
+      if options[ :iterations ] > 30
+        warn "The number of iterations is set to #{options[ :iterations ]}. " +
+          "Using too many iterations may make the test results less reliable. " +
+          "It is recommended to increase the number of :inner_iterations instead."
+      end
+
+      ComparisonPartial.new( block1, options )
+    end
+
+    def self.report_on( result )
+      puts
+      puts( "Set 1 mean: %.3f s" % [ result[ :results1 ][ :mean ] ] )
+      puts( "Set 1 std dev: %.3f" % [ result[ :results1 ][ :stddev ] ] )
+      puts( "Set 2 mean: %.3f s" % [ result[ :results2 ][ :mean ] ] )
+      puts( "Set 2 std dev: %.3f" % [ result[ :results2 ][ :stddev ] ] )
+      puts "p.value: #{result[ :p ]}"
+      puts "W: #{result[ :W ]}"
+      puts(
+        "The difference (%+.1f%%) %s statistically significant." % [
+          ( ( result[ :results2 ][ :mean ] - result[ :results1 ][ :mean ] ) / result[ :results1 ][ :mean ] ) * 100,
+          result[ :significant ] ? 'IS' : 'IS NOT'
+        ]
+      )
+    end
+  end
+  
+end; end; end
+
+

data/lib/tryouts/stats.rb

@@ -0,0 +1,92 @@
+# Copyright (c) 2005 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
+# for more information.
+
+# Stolen from:
+# http://mongrel.rubyforge.org/browser/trunk/lib/mongrel/stats.rb
+#
+# A very simple little class for doing some basic fast statistics sampling.
+# You feed it either samples of numeric data you want measured or you call
+# Stats.tick to get it to add a time delta between the last time you called it.
+# When you're done either call sum, sumsq, n, min, max, mean or sd to get 
+# the information.  The other option is to just call dump and see everything.
+#
+# It does all of this very fast and doesn't take up any memory since the samples
+# are not stored but instead all the values are calculated on the fly.
+class Tryouts
+  class Stats
+    attr_reader :sum, :sumsq, :n, :min, :max
+
+    def initialize(name=:unknown)
+      @name = name
+      reset
+    end
+
+    # Resets the internal counters so you can start sampling again.
+    def reset
+      @sum = 0.0
+      @sumsq = 0.0
+      @last_time = Time.new
+      @n = 0.0
+      @min = 0.0
+      @max = 0.0
+    end
+
+    # Adds a sampling to the calculations.
+    def sample(s)
+      @sum += s
+      @sumsq += s * s
+      if @n == 0
+        @min = @max = s
+      else
+        @min = s if @min > s
+        @max = s if @max < s
+      end
+      (@n+=1).to_f
+    end
+
+    # Dump this Stats object with an optional additional message.
+    def dump(msg = "", out=STDERR)
+      out.puts "#{msg}: #{self.to_s}"
+    end
+
+    # Returns a common display (used by dump)
+    def to_s  
+    "[#{@name}]: SUM=%0.4f, SUMSQ=%0.4f, N=%0.4f, MEAN=%0.4f, SD=%0.4f, MIN=%0.4f, MAX=%0.4f" % [@sum, @sumsq, @n, mean, sd, @min, @max]
+    end
+
+
+    # Calculates and returns the mean for the data passed so far.
+    def mean
+      @sum / @n
+    end
+
+    # Calculates the standard deviation of the data so far.
+    def sdev
+      # (sqrt( ((s).sumsq - ( (s).sum * (s).sum / (s).n)) / ((s).n-1) ))
+      begin
+        Math.sqrt( (@sumsq - ( @sum * @sum / @n)) / (@n-1) ).to_f
+      rescue Errno::EDOM
+        0.0
+      end
+    end
+
+
+    # Adds a time delta between now and the last time you called this.  This
+    # will give you the average time between two activities.
+    # 
+    # An example is:
+    #
+    #  t = Stats.new("do_stuff")
+    #  10000.times { do_stuff(); t.tick }
+    #  t.dump("time")
+    #
+    def tick
+      now = Time.now
+      sample(now - @last_time)
+      @last_time = now
+    end
+  end
+end

data/tryouts.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
 	s.name = "tryouts"
   s.rubyforge_project = "tryouts"
-	s.version = "0.7.0"
+	s.version = "0.7.1"
 	s.summary = "Tryouts are high-level tests for your Ruby code. May all your dreams come true!"
 	s.description = s.summary
 	s.author = "Delano Mandelbaum"
@@ -48,12 +48,20 @@
   lib/tryouts/drill/context.rb
   lib/tryouts/drill/response.rb
   lib/tryouts/drill/sergeant/api.rb
+  lib/tryouts/drill/sergeant/benchmark.rb
   lib/tryouts/drill/sergeant/cli.rb
+  lib/tryouts/drill/sergeant/rbenchmark.rb
   lib/tryouts/mixins.rb
   lib/tryouts/mixins/hash.rb
   lib/tryouts/orderedhash.rb
+  lib/tryouts/stats.rb
   lib/tryouts/tryout.rb
   tryouts.gemspec
+  tryouts/01_mixins_tryouts.rb
+  tryouts/10_syntax_tryouts.rb
+  tryouts/20_cli_tryouts.rb
+  tryouts/50_class_context_tryouts.rb
+  tryouts/standalone_test.rb
   )
   
   s.has_rdoc = true

data/tryouts/01_mixins_tryouts.rb

@@ -0,0 +1,26 @@
+
+library :tryouts, File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+group "Mixins"
+
+
+
+test_hash = { 
+  :level1 => { 
+    :level2 => {}, 
+    :apples => 1 
+   }, 
+  :help => [1, :a, 900001, Object.new, Hash],
+  :oranges => 90 
+}
+
+
+tryouts "Hash" do
+  setup do
+    
+  end
+  
+  drill "knows the deepest point", test_hash.deepest_point, 3
+  drill "has a last method", {}, :last, :respond_to?
+
+end

data/tryouts/10_syntax_tryouts.rb

@@ -0,0 +1,40 @@
+
+tryout "DSL Syntax", :api do
+  
+  dream 4770744
+  drill "can specify dream above the drill" do
+    4770744
+  end
+  
+  dream Array, :class
+  drill "can pass based on output object class" do
+    [1,2,3]
+  end
+  
+  dream NameError, :exception
+  drill "can pass based on exception class" do
+    bad_method_call
+  end
+  
+  drill "dreamless drills that return true will pass" do
+    true
+  end
+  
+  drill "inline true values will pass too", true
+  drill "can specify inline return values", :food, :food
+  drill "can specify match format", 'mahir', /..hi./i, :match
+  
+  dream "big"
+  dream String, :class
+  dream /\Ab.g\z/, :match
+  drill "can handle multiple dreams" do
+    "big"
+  end
+  
+  drill "can specify gt (>) format", 2, 1, :gt
+  drill "can specify gte (>=) format", 2, 2, :gte
+  drill "can specify lt (<) format", 1, 2, :lt
+  drill "can specify lte (<=) format", 2, 2, :lte
+  
+  drill "can run arbitrary formats", [3,1,2], [1,2,3], :sort
+end

data/tryouts/20_cli_tryouts.rb

@@ -0,0 +1,46 @@
+
+TRYOUTS_HOME = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+MOCKOUT_PATH = File.join(TRYOUTS_HOME, "bin", "mockout")
+
+##group "mockout cli"
+##command :mockout, MOCKOUT_PATH
+##dreams File.join(GYMNASIUM_HOME, 'mockoutcli_dreams.rb')
+##
+##tryout "Common Usage" do
+##  drill     "No args",            :info
+##  drill "YAML Output", :f, :yaml, :info
+##  drill "JSON Output", :f, :json, :info
+##end
+##
+##tryout "inline dream that passes", :cli, :mockout do
+##  output = ["we expect mockout to", "echo these lines back"]
+##
+##  # $ bin/mockout sergeant -e "we expect mockout to" "echo these lines back"
+##  drill "echo arguments", :info, :e, output[0], output[1]
+##  dream "echo arguments", output
+##end
+##
+##tryout "inline dream that fails", :cli, :mockout do
+##  dream "echo arguments", "The dream does"
+##  drill "echo arguments", :info, :e, "not match reality"
+##end
+##
+##
+##dreams "Common Usage" do
+##  dream "No Comman" do
+##    output inline(%Q{
+##    Date:                                   2009-02-16
+##  Owners:            greg, rupaul, telly, prince kinko
+## Players:            d-bam, alberta, birds, condor man
+##    })
+##  end
+##  dream "YAML Output" do
+##    format :to_yaml
+##    output ({
+##      "Date" => "2009-02-16",
+##      "Players" => ["d-bam", "alberta", "birds", "condor man"],
+##      "Owners" => ["greg", "rupaul", "telly", "prince kinko"]
+##    })
+##  end
+##end
+

data/tryouts/50_class_context_tryouts.rb

@@ -0,0 +1,30 @@
+
+group "Class context tests"
+
+tryout "Setting class variables", :api do
+  setup do
+    class ::Olivia; end
+    @@from_setup = Olivia.new  # NOTE: module_eval seems to solve this problem
+    @from_setup = true
+  end
+  
+  drill "can't access class var created in setup (1.9 only)", NameError, :exception do
+    @@from_setup
+  end
+  
+  drill "can access class var created in setup (1.8 only)", 'Olivia' do
+    @@from_setup.class.to_s
+  end
+  
+  drill "create class var", 'Olivia'  do
+    @@from_drill = Olivia.new
+    @@from_drill.class.to_s
+  end
+  
+  drill "can access class var created in drill", 'Olivia' do
+    @@from_drill.class.to_s
+  end
+  
+  dream /\w\d\w \d\w\d/, :match
+  drill "Knows where Santa Claus lives", 'H0H 0H0'
+end

data/tryouts/standalone_test.rb

@@ -0,0 +1,37 @@
+## Tryouts - Standalone Test
+#
+# This tryout is intended to be run on its own, 
+# without the tryouts exectuable. That's why it's
+# named _test.rb, so tryouts won't see it. It uses
+# the same dreams as MockoutCLI. 
+# 
+# Usage: ruby tryouts/standalone_test.rb
+#
+ 
+TRYOUTS_HOME = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+TRYOUTS_LIB  = File.join(TRYOUTS_HOME, 'lib')
+MOCKOUT_PATH = File.join(TRYOUTS_HOME, 'bin', 'mockout')
+$:.unshift TRYOUTS_LIB # Put our local lib in first place
+
+require 'tryouts'
+
+class StandaloneCLI < Tryouts
+  command :mockout, MOCKOUT_PATH
+  #dreams File.join(TRYOUTS_HOME, 'tryouts', 'mockoutcli_dreams.rb')
+
+  tryout "common usage" do
+    drill  'no command'
+    drill     'no args',             :sergeant
+    drill 'yaml output', :f, 'yaml', :sergeant
+    drill 'json output', :f, 'json', :sergeant
+  end
+
+  tryout "inline dream will pass", :cli, :mockout do
+    output = ['we expect mockout to', 'echo these lines back']
+    dream output
+    # $ bin/mockout sergeant -e 'we expect mockout to' 'echo these lines back'
+    drill 'echo arguments', :sergeant, :e, *output  
+  end
+end
+
+StandaloneCLI.run

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: delano-tryouts
 version: !ruby/object:Gem::Version 
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -65,12 +65,20 @@ files:
 - lib/tryouts/drill/context.rb
 - lib/tryouts/drill/response.rb
 - lib/tryouts/drill/sergeant/api.rb
+- lib/tryouts/drill/sergeant/benchmark.rb
 - lib/tryouts/drill/sergeant/cli.rb
+- lib/tryouts/drill/sergeant/rbenchmark.rb
 - lib/tryouts/mixins.rb
 - lib/tryouts/mixins/hash.rb
 - lib/tryouts/orderedhash.rb
+- lib/tryouts/stats.rb
 - lib/tryouts/tryout.rb
 - tryouts.gemspec
+- tryouts/01_mixins_tryouts.rb
+- tryouts/10_syntax_tryouts.rb
+- tryouts/20_cli_tryouts.rb
+- tryouts/50_class_context_tryouts.rb
+- tryouts/standalone_test.rb
 has_rdoc: true
 homepage: http://github.com/delano/tryouts
 post_install_message: