bnchmrkr 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 81543d9e532bbc61a99896b8019287a145dcd15b
-  data.tar.gz: 9272a8d8e1764d176f4e5b8d8e049a6e78f6c181
+  metadata.gz: 2f9a56d97f5184f42f18cd757cd07e102a6858a8
+  data.tar.gz: eb6d17fe537b8e9a1ab56a5f2999e6d49572acc3
 SHA512:
-  metadata.gz: a8ac397da4feaa130d033aa0d014faef00cc256bbbb5646f8f3b503a9fad1ac71b0f1c5e58f22c180e9009c25aadeda5e8e80c142a74455eeec0ab243b13a176
-  data.tar.gz: 717623a9113bb53a82ad04fdfd10271034cf13643eaae0b713405c3e47cfb8519dc471baeed90f9befa39939994c1dc224ae55c48cc6cbb5c266aaf820eddb53
+  metadata.gz: a8f9736fa5621e2663b6c84ba286c501bedf312eb9ec1bb06af97844c07ac580152672747733f7c04947674e37a52942e40d3b71aed53c2ea2d36b52aa8d78ed
+  data.tar.gz: 84dac7131ef08ec8512c57f6fc476558ddb5c20d947ebe960ea99011f8294095af90e9a43be3afd767a9ac2488062da9d3f1891024c65fc3239a2754bdb1c3eb

data/.reek

@@ -10,19 +10,42 @@ BooleanParameter:
 ControlParameter:
   enabled: false
 
+DataClump:
+  min_clump_size: 4
+
 DuplicateMethodCall:
   enabled: false
 
+# this is not a real thing
+FeatureEnvy:
+  enabled: false
+
+# this should have understanding of non-required parameters
+LongParameterList:
+  max_params: 5
+
 NestedIterators:
   max_allowed_nesting: 3
 
+# you don't know my life
+NilCheck:
+  enabled: false
+
 # more lacking context judgement - when _would_ you be ok with '!' ?
 PrimaDonnaMethod:
   enabled: false
 
 # this feels a bit arbitrary.. maybe would make more sense if was an average
 TooManyStatements:
-  max_statements: 15
+  max_statements: 30
+
+# see above
+TooManyInstanceVariables:
+  max_instance_variables: 20
+
+# see above
+TooManyMethods:
+  max_methods: 20
 
 # i don't name my exceptions specifically. that doesn't make me a bad person.
 UncommunicativeVariableName:

data/.travis.yml

@@ -7,4 +7,4 @@ notifications:
   email: false
 
 bundler_args: --without test --jobs 3 --retry 3
-script: bundle exec rake test reek build
+script: bundle exec rake test reek build install

data/Gemfile

@@ -2,9 +2,8 @@ ruby '2.0.0'
 
 source 'https://rubygems.org'
 
-gem 'rake', '~> 10.5.0', '>= 10.5.0'
-
 group :development do
+  gem 'rake', '~> 10.5.0', '>= 10.5.0'
   gem 'jeweler', '~> 2.0.1', '>= 2.0.1'
   gem 'reek', '~> 3.11', '>= 3.11'
   gem 'test-unit', '~> 3.0.0', '>= 3.0.0'

data/README.md

@@ -1,17 +1,28 @@
 # bnchmrkr
 
-i hate the name too, [but..](https://github.com/chorankates/bnchmrkr/issues/1)
+[![build status](https://travis-ci.org/chorankates/bnchmrkr.svg)](https://travis-ci.org/chorankates/bnchmrkr) [![Gem Version](https://badge.fury.io/rb/bnchmrkr.png)](https://rubygems.org/gems/bnchmrkr)
 
-Bnchmrkr (Benchmarker) is a tool to help benchmark different method implementations
+Bnchmrkr (Benchmarker) is a tool to help benchmark different method implementations in Ruby
 
 it is driven by [Benchmark](http://ruby-doc.org/stdlib-2.0.0/libdoc/benchmark/rdoc/Benchmark.html)
 
+i hate the name too, [but..](https://github.com/chorankates/bnchmrkr/issues/1)
+
+- [usage](#usage)
+  - [pre-built gem installation (stable)](#pre-built-gem-installation-stable)
+  - [from-source installation (latest)](#from-source-installation-latest)
+- [examples](#examples)
+  - [code](#code)
+  - [output](#output)
+  - [converting from < 0.1.1](#upgrading)
+- [methods](#methods)
+  - [Bnchmrkr](#bnchmrkr)
+  - [Bnchmrkr::Mark](#bnchmrkrmark)
+
 ## usage
 
 ### pre-built gem installation (stable)
 
-[![Gem Version](https://badge.fury.io/rb/bnchmrkr.png)](https://rubygems.org/gems/bnchmrkr)
-
 ```sh
 gem install bnchmrkr
 irb
@@ -22,8 +33,6 @@ irb(main):001:0> require 'bnchmrkr'
 
 ### from-source installation (latest)
 
-[![build status](https://travis-ci.org/chorankates/bnchmrkr.svg)](https://travis-ci.org/chorankates/bnchmrkr)
-
 ```sh
 git clone https://github.com/chorankates/bnchmrkr.git
 cd bnchmrkr
@@ -37,6 +46,8 @@ irb(main):001:0> require 'bnchmrkr'
 
 ## examples
 
+### code
+
 ```rb
 tester = Bnchmrkr.new({
   :count_to_1k   => lambda { 1.upto(1000).each   { |i| i } },
@@ -51,6 +62,8 @@ tester.benchmark!
 puts tester
 ```
 
+### output
+
 ```
 $ ruby examples/ls_vs_stat.rb
   fastest by type(ls) => 0.005704
@@ -76,16 +89,60 @@ overall:
           slowest => stat [0.076243]
 ```
 
-## instance methods
+### upgrading
+
+`Bnchmrkr` follows semantic versioning, which allowed a breaking change from versions `0.1.1` to `0.2.0`
+
+`0.2.0` significantly improves the API and implementation for `Bnchmrkr`, and while upgrading will require some client side changes, they shouldn't be too onerous:
+
+for the most part, you should be able to update the Hash lookup key with a method call of the same name,
+
+#### < 0.1.1
+```rb
+assert_equal(:iterative, tester.fastest_overall[:name])
+assert_equal(:recursive, tester.slowest_overall[:name])
+```
+
+#### >= 0.2.0
+```rb
+assert_equal(:iterative, tester.fastest_overall.name)
+assert_equal(:recursive, tester.slowest_overall.name)
+```
+
+## methods
+
+### `Bnchmrkr`
+```rb
+attr_reader :executions, :marks, :fastest, :slowest
+...
+def initialize(lambdas, executions = 100)
+def types
+def benchmark!
+def inspect
+def to_s
+def fastest_by_type(type, mode = :real)
+def slowest_by_type(type, mode = :real)
+def fastest_overall
+def slowest_overall
+def is_faster?(a, b, mode = :real)
+def is_slower?(a, b, mode = :real)
+def faster_by_result(a, b, percent = true, mode = :real)
+def faster_by_type(a, b, percent = true, mode = :real)
+def slower_by_type(a, b, percent = true)
+def slower_by_result(a, b, percent = true)
+def calculate_overall(mode = :real)
+```
+
+### `Bnchmrkr::Mark`
+```rb
+attr_reader :computed, :lambda, :name, :mode_precision
+attr_reader :fastest, :slowest, :mean, :median, :mode, :total
+...
+def initialize(name, lambda, mode_precision = 0)
+def add_measure(measure)
+def each(&block)
+def compute
+def inspect
+def reset_computations
+```
 ```
-  benchmark!
-  count
-  faster_by
-  fastest_by_type
-  fastest_overall
-  is_faster?
-  is_slower?
-  results
-  slowest_by_type
-  slowest_overall
-```

data/Rakefile

@@ -61,8 +61,13 @@ end
 
 Reek::Rake::Task.new do |t|
   t.config_file   = File.join(BASEDIR, '.reek')
-  t.source_files  = './**/*.rb'
+  t.source_files  = FileList.new('lib/**/*.rb', 'test/**/*.rb')
   t.reek_opts     = '--no-wiki-links'
   t.fail_on_error = false
   t.verbose       = true
+end
+
+desc 'install the gem'
+task :install do
+  sh 'gem install log4r-sequel'
 end

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/lib/bnchmrkr.rb

@@ -1,100 +1,105 @@
 #!/usr/bin/ruby
 
+$LOAD_PATH << sprintf('%s/../lib', File.dirname(__FILE__))
+require 'bnchmrkr/mark'
+
 require 'benchmark'
 
 # Bnchmrkr is a tool to help Benchmark.measure {} and compare different method implementations
 class Bnchmrkr
 
-  attr_reader :count, :results
-
-  def initialize(lambdas, count = 100)
+  UNCOMPUTED = :uncomputed
 
-    @count    = count
-    @results  = Hash.new
-    @lambdas  = lambdas
+  attr_reader :executions, :marks, :fastest, :slowest
 
-    @fastest = { :name => :unknown, :measure => 2 ** 10 } # TODO really need to find a better max int
-    @slowest = { :name => :unknown, :measure => 0 }
+  def initialize(lambdas, executions = 100)
+    @executions  = executions
+    @marks       = Hash.new
 
-    @cache = Hash.new
+    # TODO need to cache these computations and allow reseting similar to how Bnchmrkr::Mark works
+    @fastest = UNCOMPUTED
+    @slowest = UNCOMPUTED
 
-    @lambdas.each_pair do |name, l|
+    lambdas.each_pair do |name, l|
       unless name.class.eql?(Symbol) and l.class.eql?(Proc)
         raise ArgumentError.new(sprintf('expecting[Symbol,Proc], got[%s,%s]', name.class, l.class))
       end
+
+      @marks[name] = Bnchmrkr::Mark.new(name, l)
     end
 
-    raise ArgumentError.new(sprintf('expecting[Fixnum], got[%s]', count.class)) unless count.class.eql?(Fixnum)
+    raise ArgumentError.new(sprintf('expecting[Fixnum], got[%s]', executions.class)) unless executions.class.eql?(Fixnum)
 
   end
 
-  # return list of named lambdas known
+  # return list of named Bnchmrkr::Marks
   def types
-    @lambdas.keys
+    @marks.keys
   end
 
-  # 10 lines to actually do the work..
+  # < 10 lines to actually do the work..
   def benchmark!
-    @lambdas.each_pair do |name, l|
-      1.upto(@count).each do |round|
-        begin
-          measure = Benchmark.measure {
-            l.call
-          }
-          add_measure(name, measure)
-        rescue => e
-          add_measure(sprintf('%s-failed', name).to_sym, Benchmark.measure {})
-        end
+    @marks.each_pair do |_name, mark|
+      1.upto(@executions).each do |_execution|
+        measure = Benchmark.measure { mark.lambda.call }
+        mark.add_measure(measure)
       end
+
+      mark.compute # this is a safer place to do it than by computing on each measure, but still should consider putting this behind a flag
     end
 
+    calculate_overall
   end
 
-  ## :specific => fastest, slowest, mean, median, total per lambda
-  ## :overall  => fastest, slowest for all
   def inspect
-    { :overall  => calculate_overall, :specific => calculate_per_lambda }
+    {
+      :fastest => {
+        :name    => @fastest.name,
+        :fastest => @fastest.fastest.to_s.chomp,
+        :by      => self.faster_by_result(@fastest.fastest, @slowest.slowest),
+      },
+      :slowest => {
+        :name    => @slowest.name,
+        :slowest => @slowest.fastest.to_s.chomp,
+      },
+      :meta => {
+        :marks      => @marks.keys,
+        :executions => @executions,
+      },
+    }
   end
 
   # overly intricate output formatting of overall and specific results
   def to_s
     string     = String.new
     inspection = self.inspect
-    return string unless inspection.nil? or inspection.has_key?(:overall)
 
-    longest_key = inspection[:specific].keys.each { |i| i.length }.max.length + 5
+    longest_key = inspection.keys.each { |i| i.length }.max.length + 5
 
-    inspection[:specific].keys.each do |i|
+    inspection.keys.each do |i|
       string << sprintf('%s:%s', i, "\n")
-      inspection[:specific][i].keys.sort.each do |k|
-        string << sprintf("  %#{longest_key}s => %s%s", k, inspection[:specific][i][k], "\n")
+      inspection[i].keys.each do |k|
+        string << sprintf("  %#{longest_key}s => %s%s", k, inspection[i][k], "\n")
       end
     end
 
-    string << sprintf('overall:%s', "\n")
-    inspection[:overall].each_pair do |type, measure|
-      string << sprintf("  %#{longest_key}s => %s [%s]%s%s",
-                        type,
-                        measure[:name],
-                        measure[:measure],
-                        measure.has_key?(:faster_by) ? sprintf(' [faster by %s]', measure[:faster_by]) : '',
-                        "\n"
-      )
-    end
-
     string
   end
 
   # +type+ name of a lambda that is known
-  # find and return the fastest execution per lambda of +type+
-  def fastest_by_type(type)
-    results = @results
-    measures = Array.new
-
-    return nil unless results.has_key?(type)
-    results[type].collect { |r| measures << r.real}
+  # +mode+ method to use on the Bnchmrkr::Mark object ot compare (:real, :cstime, :cutime, :stime, :utime, :total)
+  # find and return the fastest Bnchrmrkr::Mark runtime per lambda of +type+
+  def fastest_by_type(type, mode = :real)
+    return UNCOMPUTED unless @marks.has_key?(type)
+    @marks[type].fastest.__send__(mode)
+  end
 
-    measures.sort.first
+  # +type+ name of a lambda that is known
+  # +mode+ method to use on the Bnchmrkr::Mark object ot compare (:real, :cstime, :cutime, :stime, :utime, :total)
+  # find and return the slowest Bnchrmrkr::Mark runtime per lambda of +type+
+  def slowest_by_type(type, mode = :real)
+    return UNCOMPUTED unless @marks.has_key?(type)
+    @marks[type].slowest.__send__(mode)
   end
 
   # find and return the fastest overall execution (regardless of lambda type)
@@ -103,18 +108,6 @@ class Bnchmrkr
     @fastest
   end
 
-  # +type+ name of a lambda that is known
-  # find and return the slowest execution per lambda of +type+
-  def slowest_by_type(type)
-    results  = @results
-    measures = Array.new
-
-    return nil unless results.has_key?(type)
-    results[type].collect { |r| measures << r.real }
-
-    measures.sort.last
-  end
-
   # find and return the slowest overall execution (regardless of lambda type)
   def slowest_overall
     calculate_overall
@@ -125,28 +118,31 @@ class Bnchmrkr
   # +b+ Symbol that represents a known lambda
   # +mode+ :fastest, :slowest, :mean, :median, :total
   # return boolean if a is faster than b, false if invalid
-  def is_faster?(a, b, mode = :total)
-    result = calculate_per_lambda
-    return false unless result.has_key?(a) and result.has_key?(b)
-    result[a][mode] < result[b][mode]
+  def is_faster?(a, b, mode = :real)
+    return false unless @marks.has_key?(a) and @marks.has_key?(b)
+    # TODO not sure that we're doing the right thing here.. the fastest fast run should always be faster than the slowest slow run.. but should we be comparing fastest fast with slowest fast?
+    @marks[a].fastest.__send__(mode) < @marks[b].fastest.__send__(mode)
   end
 
-  # +a+ {:name => name, :measure => measure}
-  # +b+ {:name => name, :measure => measure}
+  # +a+ Bnchmrkr::Mark
+  # +b+ Bnchmrkr::Mark
   # +mode+ :fastest, :slowest, :mean, :median, :total
   # return boolean if a is faster than b, false if invalid
-  def is_slower?(a, b, mode = :total)
+  def is_slower?(a, b, mode = :real)
     ! is_faster?(a, b, mode)
   end
 
-  # +a+ {:name => name, :measure => measure}
-  # +b+ {:name => name, :measure => measure}
+  # +a+ Bnchmrkr::Mark
+  # +b+ Bnchmrkr::Mark
   # +percent+ Boolean representing percent (String) or Float difference
   # return Float representing difference in measures, or false, if b is slower than a
-  def faster_by_result(a, b, percent = true)
-    return false if b[:measure] < a[:measure]
+  def faster_by_result(a, b, percent = true, mode = :real)
+    measure_a = a.__send__(mode)
+    measure_b = b.__send__(mode)
+
+    return false if measure_b < measure_a
 
-    faster = (b[:measure] - a[:measure]) / a[:measure]
+    faster = (measure_b - measure_a) / measure_a
     percent ? sprintf('%4f%', faster * 100) : faster
   end
 
@@ -154,9 +150,9 @@ class Bnchmrkr
   # +b+ Symbol representing name of known lambda type
   # +percent+ Boolean representing percent (String) or Float difference
   # return Float representing difference in measures, or false, if b is slower than a
-  def faster_by_type(a, b, percent = true)
-    fastest_a = fastest_by_type(a)
-    fastest_b = fastest_by_type(b)
+  def faster_by_type(a, b, percent = true, mode = :real)
+    fastest_a = fastest_by_type(a).__send__(mode)
+    fastest_b = fastest_by_type(b).__send__(mode)
 
     return false if fastest_b < fastest_a
 
@@ -174,63 +170,27 @@ class Bnchmrkr
 
   private
 
-  def add_measure(name, measure)
-    self.results[name] = Array.new unless self.results.has_key?(name)
-    self.results[name] << measure
-  end
-
-  # +mode_precision+ Fixnum indicating number of digits to consider during mode calculation, default to 0, which will use all signal
-  # from existing results, generate some statistics per lambda type
-  def calculate_per_lambda(mode_precision = 0)
-    hash = Hash.new
-
-    # TODO come up with way to not recompute unless contents have changed -- https://github.com/chorankates/bnchmrkr/issues/3
-
-    @results.each_pair do |name, measures|
-      hash[name]     = Hash.new
-      frequency_hash = Hash.new(0)
-      mode_candidate = { :frequency => 1, :operand => nil }
-      total = 0
-
-      sorted = measures.sort { |a,b| a.real <=> b.real }
-      measures.each do |measure|
-        operand = mode_precision.equal?(0) ? measure.real : measure.real.round(mode_precision)
-        frequency_hash[operand] += 1
+  # update fastest/slowest, return in a named Hash
+  def calculate_overall(mode = :real)
 
-        # i hate maths
-        if frequency_hash[operand] > mode_candidate[:frequency] and frequency_hash[operand] > 1
-          mode_candidate[:frequency] = frequency_hash[operand]
-          mode_candidate[:operand]   = operand
-        end
+    @marks.each_pair do |_name, mark|
+      if @fastest.eql?(:uncomputed) or mark.fastest.__send__(mode) < @fastest.fastest.__send__(mode)
+        @fastest = mark
       end
 
-      measures.collect {|m| total += m.real }
-      hash[name][:fastest] = sorted.first.real
-      hash[name][:slowest] = sorted.last.real
-      hash[name][:mean]    = sprintf('%5f', total / sorted.size).to_f
-      hash[name][:median]  = sorted[(sorted.size / 2)].real
-      # TODO need to handle the rare case that we have multiple modes -- https://github.com/chorankates/bnchmrkr/issues/4
-      hash[name][:mode]    = mode_candidate[:operand] # collect key name with highest value
-      hash[name][:total]   = sprintf('%5f', total).to_f
-    end
-
-    hash
-  end
-
-  # update fastest/slowest, return in a named Hash
-  def calculate_overall
-    calculate_per_lambda.each_pair do |name,results|
-      if results[:fastest] < @fastest[:measure]
-        @fastest = { :name => name, :measure => results[:fastest] }
+      if @slowest.eql?(:uncomputed) or mark.slowest.__send__(mode) > @slowest.slowest.__send__(mode)
+        @slowest = mark
       end
 
-      if results[:slowest] > @slowest[:measure]
-        @slowest = { :name => name, :measure => results[:slowest] }
-      end
     end
 
-    @fastest[:faster_by] = self.faster_by_result(@fastest, @slowest)
-    { :fastest => @fastest, :slowest => @slowest }
+    {
+      :fastest      => @fastest.fastest.__send__(mode),
+      :fastest_name => @fastest.name,
+      :slowest      => @slowest.slowest.__send__(mode),
+      :slowest_name => @slowest.name,
+      :faster_by    => self.faster_by_result(@fastest.fastest, @slowest.slowest)
+    }
   end
 
-end
+end

data/lib/bnchmrkr/mark.rb

@@ -0,0 +1,95 @@
+# oh ruby
+class Bnchmrkr; end
+
+# Bnchmrkr::Mark represents individual lambda runs within a Bnchmrkr run
+class Bnchmrkr::Mark
+  include Enumerable
+
+  attr_reader :computed, :lambda, :name, :mode_precision
+  attr_reader :fastest, :slowest, :mean, :median, :mode, :total
+
+  def initialize(name, lambda, mode_precision = 0)
+    @name      = name
+    @lambda    = lambda # TODO this name is going to cause problems
+    @measures  = Array.new
+
+    @mode_precision = mode_precision
+
+    reset_computations # initialize to known values
+  end
+
+  # +measure+ Benchmark.measure{} result
+  def add_measure(measure)
+    @measures << measure
+    reset_computations if @computed # as soon as a measure is added, previous computations are invalid
+  end
+
+  # allows Array-like behavior on the Array of measurements contained in a Bnchmrkr::Mark
+  def each(&block)
+    @measures.each(&block)
+  end
+
+  def compute
+    frequency_hash = Hash.new(0)
+    total          = 0
+
+    sorted = @measures.sort { |a,b| a.real <=> b.real }
+
+    @measures.each do |measure|
+      operand = @mode_precision.equal?(0) ? measure.real : measure.real.round(@mode_precision)
+      frequency_hash[operand] += 1
+    end
+
+    max_frequency  = frequency_hash.values.max
+    mode_candidate = frequency_hash.select{ |_operand, frequency| frequency.equal?(max_frequency) }.keys
+
+    if max_frequency.equal?(1)
+      mode = nil
+    else
+      mode = mode_candidate.size > 1 ? mode_candidate : mode_candidate.first
+    end
+
+    sorted.collect { |r| total += r.real }
+    @fastest = sorted.first
+    @slowest = sorted.last
+    @mean    = sprintf('%5f', total / sorted.size).to_f
+    @median  = sorted[(sorted.size / 2)]
+    @mode    = mode
+    @total   = sprintf('%5f', total).to_f
+
+    @computed = true
+  end
+
+  # a semi-fancy and somewhat fragile inspect method
+  ## try to compute if we haven't been, ensuring we always return a hash
+  def inspect
+    begin
+      self.compute unless @computed
+      {
+        :name    => @name,
+        :fastest => @fastest.real,
+        :slowest => @slowest.real,
+        :mean    => @mean,
+        :median  => @median,
+        :mode    => @mode,
+        :total   => @total,
+      }
+    rescue => e
+      { :name => @name, :computed => @computed }
+    end
+  end
+
+  private
+
+  # reset internal computed values, used when a new measure is added
+  def reset_computations
+    @computed = false
+    @fastest  = :uncomputed
+    @slowest  = :uncomputed
+    @mean     = :uncomputed
+    @median   = :uncomputed
+    @mode     = :uncomputed
+    @total    = :uncomputed
+  end
+
+end

data/test/examples/test_examples.rb

@@ -12,8 +12,10 @@ class TestExamples < Test::Unit::TestCase
     @files.each do |file|
       raw = `ruby #{file}`
 
-      assert_true($?.success?)
-      assert_not_nil(raw)
+      generic_failure_message = sprintf('[%s] returned [%s]: [%s]', File.basename(file), $?, raw)
+
+      assert_true($?.success?, generic_failure_message)
+      assert_not_nil(raw, generic_failure_message)
     end
   end
 

data/test/unit/test_contrived.rb

@@ -17,74 +17,85 @@ class TestContrived < Test::Unit::TestCase
   end
 
   def test_fastest
-    assert_equal(:count_to_1k, @tester.fastest_overall[:name])
-    assert_true(@tester.fastest_overall[:measure] < @tester.slowest_overall[:measure])
+    assert_equal(:count_to_1k, @tester.fastest_overall.name)
+    assert_true(@tester.fastest_overall.fastest.real < @tester.slowest_overall.slowest.real)
   end
 
   def test_slowest
     slowest_overall = @tester.slowest_overall
     fastest_overall = @tester.fastest_overall
 
-    assert_equal(:count_to_100k, slowest_overall[:name])
-    assert_true(slowest_overall[:measure] > fastest_overall[:measure])
+    generic_failure_message = sprintf('fast[%s] slow[%s]', fastest_overall, slowest_overall)
+
+    assert_equal(:count_to_100k, slowest_overall.name, generic_failure_message)
+    assert_true(slowest_overall.slowest.real > fastest_overall.fastest.real, generic_failure_message)
   end
 
   def test_speed_by_type
     @tester.types.each do |type|
-      slowest = @tester.slowest_by_type(type)
-      fastest = @tester.fastest_by_type(type)
+      slowest = @tester.slowest_by_type(type).real
+      fastest = @tester.fastest_by_type(type).real
+
+      generic_failure_message = sprintf('fast[%s] slow[%s]', fastest, slowest)
 
-      assert_true(slowest > fastest)
+      assert_true(slowest > fastest, generic_failure_message)
     end
   end
 
   def test_is_faster?
-    fast = @tester.fastest_overall[:name]
-    slow = @tester.slowest_overall[:name]
+    fast = @tester.fastest_overall.name
+    slow = @tester.slowest_overall.name
+
+    generic_failure_message = sprintf('fast[%s] slow[%s]', fast, slow)
 
     forward = @tester.is_faster?(fast, slow)
     reverse = @tester.is_faster?(slow, fast)
     equal   = @tester.is_faster?(fast, fast)
 
-    assert_not_equal(forward, reverse)
-    assert_true(forward)
-    assert_false(reverse)
-    assert_false(equal)
+    assert_not_equal(forward, reverse, generic_failure_message)
+    assert_true(forward, generic_failure_message)
+    assert_false(reverse, generic_failure_message)
+    assert_false(equal, generic_failure_message)
   end
 
   def test_is_slower?
-    fast = @tester.fastest_overall[:name]
-    slow = @tester.slowest_overall[:name]
+    fast = @tester.fastest_overall.name
+    slow = @tester.slowest_overall.name
+
+    generic_failure_message = sprintf('fast[%s] slow[%s]', fast, slow)
 
     forward = @tester.is_slower?(slow, fast)
     reverse = @tester.is_slower?(fast, slow)
     equal   = @tester.is_slower?(slow, slow)
 
-    assert_not_equal(forward, reverse)
-    assert_true(forward)
-    assert_false(reverse)
-    assert_true(equal) # ugh, this is misleading.. but is_slower? is boolean opposite of is_slower?
+    assert_not_equal(forward, reverse, generic_failure_message)
+    assert_true(forward, generic_failure_message)
+    assert_false(reverse, generic_failure_message)
+    assert_true(equal, sprintf('fast[%s] slow[%s]', fast, slow))
   end
 
   def test_faster_by_result
-    fast = @tester.fastest_overall
-    slow = @tester.slowest_overall
+    fast = @tester.fastest_overall.fastest
+    slow = @tester.slowest_overall.slowest
+
+    generic_failure_message = sprintf('fast[%s] slow[%s]', fast, slow)
 
-    assert_not_nil(@tester.faster_by_result(fast, slow, true))
-    assert_match(/\d+\.\d+%/, @tester.faster_by_result(fast, slow, true))
-    assert_true(@tester.faster_by_result(fast, slow, false).is_a?(Float))
-    assert_false(@tester.faster_by_result(slow, fast))
+    assert_not_nil(@tester.faster_by_result(fast, slow, true), generic_failure_message)
+    assert_match(/\d+\.\d+%/, @tester.faster_by_result(fast, slow, true), generic_failure_message)
+    assert_true(@tester.faster_by_result(fast, slow, false).is_a?(Float), generic_failure_message)
+    assert_false(@tester.faster_by_result(slow, fast), generic_failure_message)
   end
 
   def test_faster_by_type
-    fastest = @tester.fastest_overall[:name]
-    slowest = @tester.slowest_overall[:name]
+    fastest = @tester.fastest_overall.name
+    slowest = @tester.slowest_overall.name
 
-    assert_not_nil(@tester.faster_by_type(fastest, slowest, true))
-    assert_match(/\d+\.\d+%/, @tester.faster_by_type(fastest, slowest, true))
-    assert_true(@tester.faster_by_type(fastest, slowest, false).is_a?(Float))
-    assert_false(@tester.faster_by_type(slowest, fastest))
+    generic_failure_message = sprintf('fast[%s] slow[%s]', fastest, slowest)
 
+    assert_not_nil(@tester.faster_by_type(fastest, slowest, true), generic_failure_message)
+    assert_match(/\d+\.\d+%/, @tester.faster_by_type(fastest, slowest, true), generic_failure_message)
+    assert_true(@tester.faster_by_type(fastest, slowest, false).is_a?(Float), generic_failure_message)
+    assert_false(@tester.faster_by_type(slowest, fastest), generic_failure_message)
   end
 
 end

data/test/unit/test_exceptions.rb

@@ -6,17 +6,21 @@ class TestExceptions < Test::Unit::TestCase
 
   def setup; end
 
-  def test_lambdas_will_raise
+  def test_lambdas_will_raise # but we will catch them
+    symbol = :divbyzero
+
     tester = Bnchmrkr.new({
-      :divbyzero => lambda {
+      symbol => lambda {
         10 / 0
       },
     })
 
-    assert_nothing_raised do
+    e = assert_raise do
       tester.benchmark!
-      assert_true(tester.results.has_key?('divbyzero-failed'.to_sym))
     end
+
+    assert_true(tester.marks.has_key?(symbol))
+    assert_equal(ZeroDivisionError, e.class)
   end
 
   def test_lambdas_wont_raise_anyway
@@ -26,7 +30,7 @@ class TestExceptions < Test::Unit::TestCase
 
     assert_nothing_raised do
       tester.benchmark!
-      assert_true(tester.results.has_key?(:foo))
+      assert_true(tester.marks.has_key?(:foo))
     end
 
   end

data/test/unit/test_initialize.rb

@@ -19,6 +19,19 @@ class TestInitialize < Test::Unit::TestCase
 
   end
 
+  # TODO this is really testing Bnchmrkr::Mark objects
+  def test_initial_values
+
+    bnchmrkr = Bnchmrkr.new({:foo => lambda {}})
+
+    bnchmrkr.marks.each_pair do |name, m|
+      [ :fastest, :slowest, :mean, :median, :mode, :total ].each do |a|
+        assert_equal(:uncomputed, m.__send__(a), sprintf('failed[%s] for[%s]', a, name))
+      end
+    end
+
+  end
+
   def test_invalid
 
     # not a proc
@@ -49,8 +62,6 @@ class TestInitialize < Test::Unit::TestCase
       Bnchmrkr.new({:foo => :bar}, 1.1)
     end
 
-
-
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bnchmrkr
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Conor Horan-Kates
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-23 00:00:00.000000000 Z
+date: 2016-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -20,7 +20,7 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 10.5.0
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -106,6 +106,7 @@ files:
 - Rakefile
 - VERSION
 - lib/bnchmrkr.rb
+- lib/bnchmrkr/mark.rb
 - test/examples/test_examples.rb
 - test/unit/test_contrived.rb
 - test/unit/test_exceptions.rb
@@ -130,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: compare execution time