tryouts 0.8.8 → 2.0.0

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

@@ -1,132 +0,0 @@
-
-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/drill.rb

@@ -1,224 +0,0 @@
-
-
-class Tryouts
-  
-  # = Drill
-  # 
-  # This class represents a drill. A drill is single test. 
-  #
-  class Drill
-    
-  require 'tryouts/drill/context'
-  require 'tryouts/drill/response'
-  require 'tryouts/drill/dream'
-  require 'tryouts/drill/reality'
-  require 'tryouts/drill/sergeant/cli'
-  require 'tryouts/drill/sergeant/api'
-  require 'tryouts/drill/sergeant/benchmark'
-  #require 'tryouts/drill/sergeant/rbenchmark'
-  
-  class NoSergeant < Tryouts::Exception; end
-  class UnknownFormat < Tryouts::Exception; end
-  
-    # A symbol specifying the drill type. One of: :cli, :api
-  attr_reader :dtype
-    # The name of the drill. This should match the name used in the dreams file. 
-  attr_reader :name
-    # A Proc object which contains the drill logic. 
-  attr_reader :drill
-    # A Sergeant object which executes the drill
-  attr_reader :sergeant
-    # An Array of Dream objects (the expected output of the test)
-  attr_reader :dreams
-    # A Reality object (the actual output of the test)
-  attr_reader :reality
-  
-  @@valid_dtypes = [:api, :cli, :benchmark]
-  
-  # * +name+ The display name of this drill
-  # * +dtype+ A Symbol representing the drill type. One of: :api, :benchmark
-  # * +args+ These are dependent on the drill type. See the Sergeant classes
-  # * +&drill+ The body of the drill. The return value of this block 
-  #   is compared to the exepected output of the dreams. 
-  #
-  # The DSL syntax:
-  # * dream OUTPUT
-  # * dream FORMAT, OUTPUT
-  # * dream FORMAT, OUTPUT, REPS      (benchmark only)
-  #
-  def initialize(name, dtype, *args, &drill)
-    @name, @dtype, @drill, @skip = name, dtype, drill, false
-    @dreams = []
-    
-    # We create a default empty reality but if the drill runs correctly
-    # this reality gets replaced with the return value from the drill.
-    @reality = Tryouts::Drill::Reality.new
-    
-    case @dtype 
-    when :cli
-      # For CLI drills, a block takes precedence over inline args. 
-      # A block will contain multiple shell commands (see Rye::Box#batch)
-      args = [] if dtype == :cli && drill.is_a?(Proc)
-      @sergeant = Tryouts::Drill::Sergeant::CLI.new *args
-    when :api
-      default_output = drill.nil? ? args.shift : nil
-      @sergeant = Tryouts::Drill::Sergeant::API.new default_output
-      unless args.empty?
-        if args.size == 1
-          dream_output, format = args.first, nil
-        else
-          dream_output, format = args[1], args[0]
-        end
-        @dreams << Tryouts::Drill::Dream.new(dream_output, format)
-      end
-    when :benchmark
-      if args.size == 1
-        reps = args.first
-      else
-        dream_output, format, reps = args[1], args[0], args[2]
-      end
-      @sergeant = Tryouts::Drill::Sergeant::Benchmark.new reps
-      @dreams << Tryouts::Drill::Dream.new(Hash, :class)
-      unless dream_output.nil?
-        @dreams << Tryouts::Drill::Dream.new(dream_output, format)
-      end
-    when :skip
-      @skip = true
-    else
-      raise NoSergeant, "Weird drill sergeant: #{@dtype}"
-    end
-    @clr = :red
-
-    
-  end
-  
-  def self.valid_dtypes; @@valid_dtypes; end
-  def self.valid_dtype?(t); @@valid_dtypes.member?(t); end
-  
-  def skip?; @skip; end
-  
-  def run(context=nil)
-    unless @dreams.empty?
-      @dreams.each { |d| d.execute_output_block }
-    end
-    begin
-      @reality = @sergeant.run @drill, context
-      # Store the stash from the drill block
-      @reality.stash = context.stash if context.respond_to? :stash
-      # If the drill block returned true we assume success if there's no dream
-      if @dreams.empty? && @reality.output == true
-        @dreams << Tryouts::Drill::Dream.new
-        @dreams.first.output = true
-      end
-    rescue => ex
-      @reality.ecode, @reality.etype = -2, ex.class
-      @reality.error, @reality.trace = ex.message, ex.backtrace
-    end  
-    self.success?
-  end
-  
-  def flag
-    if skip?
-      "SKIP"
-    elsif success? 
-      "PASS".color(@clr).bright 
-    else
-      note = @dreams.empty? ? '[nodream]' : ''
-      "FAIL #{note}".color(@clr).bright
-    end
-  end
-    
-  def info
-    out = StringIO.new
-    if Tryouts.verbose > 0
-      if @dtype == :benchmark
-        unless @reality.output.nil?
-          Sergeant::Benchmark.fields.each do |f|
-            s = @reality.output[f]
-            ar = [s.name, s.mean, s.min, s.max, s.sdev, s.sum]
-            pa = '%6s: %.4f (min:%.4f max:%.4f sdev:%.4f sum:%.4f)'.color(@clr)
-            out.puts pa % ar
-          end
-          ar = ['', @reality.output[:rtotal].mean]
-          out.puts '%8s%3.4f (run time)'.color(@clr) % ar
-        end
-      elsif @dtype == :cli
-        out.puts '%6s%s'.color(@clr) % ['', @reality.command]
-        output = @reality.output
-        output = output.join($/ + ' '*6) if output.kind_of?(Array)
-        out.puts '%6s%s'.color(@clr) % ['', output]
-      else
-        out.puts '%6s%s'.color(@clr) % ['', @reality.output.inspect]
-      end
-      unless @reality.stash.empty?
-        @reality.stash.each_pair do |n,v|
-          out.puts '%18s: %s'.color(@clr) % [n,v.inspect]
-        end
-      end
-    end
-    if Tryouts.verbose > 1
-
-      @dreams.each do |dream|
-        if dream != @reality
-          out.puts '%6s%s'.color(:red) % ['', dream.test_to_string(@reality)]
-        else
-          out.puts '%6s%s'.color(:green) % ["", dream.test_to_string(@reality)]
-        end
-      end  
-      out.puts
-    
-    end
-    out.rewind
-    out.read
-  end
-  
-  def report
-    return if skip?
-    out = StringIO.new
-    
-    out.puts '%12s'.color(:red) % '[nodream]' if @dreams.empty?
-    
-    @dreams.each do |dream|
-      next if dream == reality #? :normal : :red 
-      out.puts '%12s: %s'.color(@clr) % ["failed", dream.test_to_string(@reality)]
-      out.puts '%12s: %s' % ["drill", @reality.comparison_value(dream).inspect]
-      out.puts '%12s: %s' % ["dream", dream.comparison_value.inspect]
-      out.puts
-    end
-    
-    unless @reality.error.nil?
-      out.puts '%14s: %s' % [@reality.etype, @reality.error.to_s.split($/).join($/ + ' '*16)]
-    end
-    unless @reality.trace.nil?
-      trace = Tryouts.verbose > 1 ? @reality.trace : [@reality.trace.first]
-      out.puts '%14s  %s' % ['', trace.join($/ + ' '*16)]
-      out.puts
-    end
-    
-    out.rewind
-    out.read
-  end
-  
-  def has_error?
-    !@reality.error.nil?
-  end
-  
-  def success?
-    return false if @dreams.empty? && @reality.output != true
-    begin
-      @dreams.each { |d| return false unless d == @reality }
-    rescue => ex
-      puts ex.message, ex.backtrace if Tryouts.debug?
-      return false
-    end
-    @clr = :green
-    true
-  end
-  
-  
-  def add_dream(d); @dreams << d; end
-  def add_dreams(*d); @dreams += d; end
-  
-  private 
-    
-end; end

data/lib/tryouts/mixins.rb

@@ -1,37 +0,0 @@
-
-class Hash
-  
-  # A depth-first look to find the deepest point in the Hash. 
-  # The top level Hash is counted in the total so the final
-  # number is the depth of its children + 1. An example:
-  # 
-  #     ahash = { :level1 => { :level2 => {} } }
-  #     ahash.deepest_point  # => 3
-  #
-  def deepest_point(h=self, steps=0)
-    if h.is_a?(Hash)
-      steps += 1
-      h.each_pair do |n,possible_h|
-        ret = deepest_point(possible_h, steps)
-        steps = ret if steps < ret
-      end
-    else
-      return 0
-    end
-    steps
-  end
-  
-  unless method_defined?(:last)
-    # Ruby 1.9 doesn't have a Hash#last (but Tryouts::OrderedHash does). 
-    # It's used in Tryouts to return the most recently added instance of
-    # Tryouts to @@instances. 
-    #
-    # NOTE: This method is defined only when Hash.method_defined?(:last)
-    # returns false. 
-    def last
-      self[ self.keys.last ]
-    end
-  end
-  
-end
-

data/lib/tryouts/orderedhash.rb

@@ -1,199 +0,0 @@
-# AUTHOR
-#    jan molic /mig/at/1984/dot/cz/
-#
-# DESCRIPTION
-#    Hash with preserved order and some array-like extensions
-#    Public domain. 
-#
-# THANKS
-#    Andrew Johnson for his suggestions and fixes of Hash[],
-#    merge, to_a, inspect and shift
-class Tryouts::OrderedHash < ::Hash
-    attr_accessor :order
-
-    class << self
-        def [] *args
-          hsh = Tryouts::OrderedHash.new
-          if Hash === args[0]
-            hsh.replace args[0]
-          elsif (args.size % 2) != 0
-            raise ArgumentError, "odd number of elements for Hash"
-          else
-            0.step(args.size - 1, 2) do |a|
-              b = a + 1
-              hsh[args[a]] = args[b]
-            end
-          end
-          hsh
-        end
-    end
-    def initialize(*a, &b)
-      super
-      @order = []
-    end
-    def store_only a,b
-        store a,b
-    end
-    alias orig_store store    
-    def store a,b
-        @order.push a unless has_key? a
-        super a,b
-    end
-    alias []= store
-    def == hsh2
-        return false if @order != hsh2.order
-        super hsh2
-    end
-    def clear
-        @order = []
-        super
-    end
-    def delete key
-        @order.delete key
-        super
-    end
-    def each_key
-        @order.each { |k| yield k }
-        self
-    end
-    def each_value
-        @order.each { |k| yield self[k] }
-        self
-    end
-    def each
-        @order.each { |k| yield k,self[k] }
-        self
-    end
-    alias each_pair each    
-    def delete_if
-        @order.clone.each { |k| 
-            delete k if yield(k)
-        }
-        self
-    end
-    def values
-        ary = []
-        @order.each { |k| ary.push self[k] }
-        ary
-    end
-    def keys
-        @order
-    end
-    def first
-      {@order.first => self[@order.first]}
-    end
-    def last
-      {@order.last => self[@order.last]}
-    end
-    def invert
-        hsh2 = Hash.new    
-        @order.each { |k| hsh2[self[k]] = k }
-        hsh2
-    end
-    def reject &block
-        self.dup.delete_if &block
-    end
-    def reject! &block
-        hsh2 = reject &block
-        self == hsh2 ? nil : hsh2
-    end
-    def replace hsh2
-        @order = hsh2.keys 
-        super hsh2
-    end
-    def shift
-        key = @order.first
-        key ? [key,delete(key)] : super
-    end
-    def unshift k,v
-        unless self.include? k
-            @order.unshift k
-            orig_store(k,v)
-            true
-        else
-            false
-        end
-    end
-    def push k,v
-        unless self.include? k
-            @order.push k
-            orig_store(k,v)
-            true
-        else
-            false
-        end
-    end
-    def pop
-        key = @order.last
-        key ? [key,delete(key)] : nil
-    end
-    def to_a
-        ary = []
-        each { |k,v| ary << [k,v] }
-        ary
-    end
-    def to_s
-        self.to_a.to_s
-    end
-    def inspect
-        ary = []
-        each {|k,v| ary << k.inspect + "=>" + v.inspect}
-        '{' + ary.join(", ") + '}'
-    end
-    def update hsh2
-        hsh2.each { |k,v| self[k] = v }
-        self
-    end
-    alias :merge! update
-    def merge hsh2
-        ##self.dup update(hsh2)   ## 2009-05-12 -- delano
-        update hsh2               ## dup doesn't take an argument
-                                  ## and there's no need for it here
-    end
-    def select
-        ary = []
-        each { |k,v| ary << [k,v] if yield k,v }
-        ary
-    end
-    def class
-      Hash
-    end
-    def __class__
-      Tryouts::OrderedHash
-    end
-
-    attr_accessor "to_yaml_style"
-    def yaml_inline= bool
-      if respond_to?("to_yaml_style")
-        self.to_yaml_style = :inline
-      else
-        unless defined? @__yaml_inline_meth
-          @__yaml_inline_meth =
-            lambda {|opts|
-              YAML::quick_emit(object_id, opts) {|emitter|
-                emitter << '{ ' << map{|kv| kv.join ': '}.join(', ') << ' }'
-              }
-            }
-          class << self
-            def to_yaml opts = {}
-              begin
-                @__yaml_inline ? @__yaml_inline_meth[ opts ] : super
-              rescue
-                @to_yaml_style = :inline
-                super
-              end
-            end
-          end
-        end
-      end
-      @__yaml_inline = bool
-    end
-    def yaml_inline!() self.yaml_inline = true end
-
-    def each_with_index
-      @order.each_with_index { |k, index| yield k, self[k], index }
-      self
-    end
-end # class Tryouts::OrderedHash
-
-

data/lib/tryouts/stats.rb

@@ -1,96 +0,0 @@
-# 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, :name
-
-    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
-
-    def samples; @n; 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