b 1.0.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.swp
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in b.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec', :cli => '--color --format doc --fail-fast' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 moe@busyloop.net
+
+MIT License
+
+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.md

@@ -0,0 +1,82 @@
+# B::enchmark [![Build Status](https://travis-ci.org/busyloop/b.png?branch=master)](https://travis-ci.org/busyloop/b) [![Dependency Status](https://gemnasium.com/busyloop/b.png)](https://gemnasium.com/busyloop/b)
+
+A small, convenient benchmark-library.
+
+## Features
+
+* Sensible defaults and default-output
+
+* Displays relative performance; "B was 1.4x slower than A"
+
+* Returns benchmark-results as Array of Hashes (for easy integration with your unit-tests or CI)
+
+* Output can be customized with a simple Plugin-API (ships with plugins for TSV and HTML)
+ 
+* High precision (via [hitimes](https://github.com/copiousfreetime/hitimes))
+
+
+## Installation
+
+`gem install b`
+
+## Example
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'b'
+
+B.enchmark('Sleep "performance"', :rounds => 10, :compare => :mean) do
+  job '300ms' do
+    sleep 0.3
+  end
+
+  job '100ms' do
+    sleep 0.1
+  end
+
+  job '200ms' do
+    sleep 0.2
+  end
+end
+```
+
+### Output:
+
+```
+-- Sleep "performance" ---------------------------------------------------------------
+        rounds         r/s        mean         max         min    ± stddev      x mean 
+100ms       10        9.99      100.13      100.17      100.11        0.02        1.00 
+200ms       10        5.00      200.14      200.17      200.11        0.02        2.00 
+300ms       10        3.33      300.13      300.18      300.11        0.02        3.00 
+```
+
+## Getting started
+
+For advanced usage beyond the above example please look at the included demos:
+
+1. Run `ruby -r b/demo -e0`
+2. [demo.rb](https://github.com/busyloop/b/blob/master/lib/b/demo.rb)
+
+## License (MIT)
+
+Copyright (c) 2013 moe@busyloop.net
+
+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/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+task :default => :test
+
+RSpec::Core::RakeTask.new("test:spec") do |t|
+    t.pattern = 'spec/**/*_spec.rb'
+    t.rspec_opts = '--fail-fast -b -c -f documentation --tag ~benchmark'
+end
+
+desc 'Run full test suite'
+task :test => [ 'test:spec' ]

data/b.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'b/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "b"
+  gem.version       = B::VERSION
+  gem.authors       = ["Moe"]
+  gem.email         = ["moe@busyloop.net"]
+  gem.description   = %q{A small, convenient benchmark-library.}
+  gem.summary       = %q{A small, convenient benchmark-library.}
+  gem.homepage      = "https://github.com/busyloop/b"
+  gem.has_rdoc      = false
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'guard'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'stdiotrap'
+  gem.add_dependency 'hitimes'
+  gem.add_dependency 'blockenspiel'
+end

data/lib/b.rb

@@ -0,0 +1,128 @@
+require "b/version"
+require "b/output_plugins"
+require "hitimes"
+require "blockenspiel"
+
+module B
+  class SanityViolation < RuntimeError; end
+
+  DEFAULT_ROUNDS = 50
+
+  def self.enchmark(id='Untitled Benchmark', opts={}, &block)
+    opts = {:output => ConsoleWriter.new}.merge(opts)
+    opts[:parent] = opts[:output]
+    Blockenspiel.invoke(block, Enchmark.new(id, opts)).run!
+  end
+ 
+  # B::Ase
+  class Ase
+    include Blockenspiel::DSL
+    attr_reader :opts
+
+    dsl_methods false
+
+    def run!
+      @children.map {|c| c.run! unless c.nil?} unless @children.nil?
+      post_run if self.respond_to? :post_run
+      @children.map(&:to_h)
+    end
+
+    def register(job)
+      @parent.register(job) if @parent.respond_to? :register
+    end
+
+    def start(job)
+      @parent.start(job) if @parent.respond_to? :start
+    end
+
+    def finish(job)
+      @parent.finish(job) if @parent.respond_to? :finish
+    end
+  end
+
+  # B::Enchmark
+  class Enchmark < B::Ase
+    attr_reader :id
+
+    def job(id, opts={}, &block)
+      if opts[:rounds] and @compare
+        raise SanityViolation, "Can not override :rounds on job '#{id}' when comparing on :#{@compare}!"
+      end
+      if opts[:compare]
+        raise SanityViolation, "Can not override :compare in a job ('#{id}')"
+      end
+      opts = @opts.merge(opts)
+      (@children ||= []) << Job.new(self, id, opts, block)
+      self
+    end
+
+    dsl_methods false
+    def initialize(id, opts={})
+      @opts = {:rounds => DEFAULT_ROUNDS, :compare => nil}.merge(opts)
+      @parent = opts[:parent]
+      @id, @rounds, @compare = id, opts[:rounds], opts[:compare]
+      @buffer = []
+    end
+
+    def post_run
+      if @compare
+        @buffer.sort! do |a,b|
+          a.send(@compare) <=> b.send(@compare)
+        end
+      end
+      @buffer.each_with_index do |job, i|
+        if 0 == i
+          job.x = 1.0
+        else
+          job.x = job.send(@compare) / @buffer[0].send(@compare)
+        end
+      end
+      until @buffer.empty? do
+        @parent.start @buffer[0]
+        @parent.finish @buffer.shift
+      end
+    end
+
+    def start(job)
+      @compare.nil? ? super : @buffer << job
+    end
+
+    def finish(job)
+      super if @compare.nil?
+    end
+
+    # B::Enchmark::Job
+    class Job < B::Ase
+      ATTRIBUTES = [:group, :id, :rounds, :rate, :mean, :max, :min, :stddev, :x, :compare]
+      attr_reader *ATTRIBUTES
+      attr_writer :x
+
+      dsl_methods false
+      def initialize(parent, id, opts, block)
+        @opts = parent.opts.merge(opts)
+        @parent, @block, @group, @id, @rounds, @compare = parent, block, parent.id, id, @opts[:rounds], @opts[:compare]
+        @parent.register(self)
+      end
+
+      def run!
+        tm = Hitimes::TimedMetric.new(nil)
+        @parent.start self
+        @opts[:rounds].times do
+          tm.start
+          @block.call
+          tm.stop
+        end
+        @rate, @mean, @max, @min, @stddev = tm.rate, tm.mean, tm.max, tm.min, tm.stddev
+        finish self
+      end
+
+      def to_h
+        ATTRIBUTES.reduce({}) { |m,e|
+          m[e] = instance_variable_get('@'+e.to_s)
+          m
+        }
+      end
+    end
+  end
+end
+

data/lib/b/demo.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'b'
+
+puts "Source-code is here: #{__FILE__}"
+puts
+
+# Basic sleep benchmark
+results = B.enchmark("Nap time; output in milliseconds", :rounds => 3) do
+  job('sleep 0.1', :rounds => 10) { sleep 0.1 }
+  job('sleep 0.5') { sleep 0.5 }
+  job('sleep 1.0') { sleep 1.0 }
+end
+
+# Results are also returned as an Array of Hashes
+#puts results
+
+puts
+
+# Same as above but display results in seconds instead of ms.
+# HINT: You may also set :writer => nil if you want no output at all.
+cw = B::ConsoleWriter.new({:multiply=>1, :round=>6})
+result B.enchmark("Nap time; output in seconds", :output => cw, :rounds => 3) do
+  job('sleep 0.1', :rounds => 10) { sleep 0.1 }
+  job('sleep 0.5') { sleep 0.5 }
+  job('sleep 1.0') { sleep 1.0 }
+end
+
+#puts results
+puts
+
+# Fibonacci snippets taken from http://stackoverflow.com/questions/6418524/fibonacci-one-liner
+B.enchmark("Compare fibonacci implementations", :rounds => 500, :compare => :mean) do
+  job 'fibonacci lambda A' do
+    f = lambda { |x| x < 2 ? x : f.call(x-1) + f.call(x-2) }
+    (0..16).each { |i| f.call(i) }
+  end
+
+  job 'fibonacci lambda B' do
+    f = lambda { |n| (0..n).inject([1,0]) { |(a,b), _| [b, a+b] }[0] }
+    (0..16).each { |i| f.call(i) }
+  end
+
+  job 'fibonacci hash' do
+    f = Hash.new{ |h,k| h[k] = k < 2 ? k : h[k-1] + h[k-2] }
+    (0..16).each { |i| f[i] }
+  end
+end
+
+puts
+
+B.enchmark('Compare string-concat methods (50k per round)', :rounds => 10, :compare => :mean) do
+  job 'x = a << b << c' do
+    50_000.times do
+      a, b, c = 'a', 'b', 'c'
+      x = a << b << c
+    end
+  end
+
+  job 'x = "#{a}#{b}#{c}"' do
+    50_000.times do
+      a, b, c = 'a', 'b', 'c'
+      x = "#{a}#{b}#{c}"
+    end
+  end
+
+  job 'x = a+b+c' do
+    50_000.times do
+      a, b, c = 'a', 'b', 'c'
+      x = a+b+c
+    end
+  end
+end
+

data/lib/b/output_plugins.rb

@@ -0,0 +1,127 @@
+module B
+  # print results in TSV format
+  class TsvWriter
+    COLUMNS = [:group, :id, :rounds, :rate, :mean, :max, :min, :stddev, :x]
+    def initialize(out=$stdout)
+      @out = out
+      printf COLUMNS.join("\t") + "\n"
+    end
+
+    def finish(job)
+      printf COLUMNS.map { |c| job.send(c) }.join("\t") + "\n"
+    end
+
+    private
+    def printf(*a)
+      @out.printf *a
+    end
+  end
+
+  # print results as a HTML table
+  class HtmlWriter
+    COLUMNS = [:group, :id, :rounds, :rate, :mean, :max, :min, :stddev, :x]
+
+    def register(job)
+      @todo = (@todo||0) +1
+    end
+
+    def initialize(out=$stdout)
+      @out = out
+      printf "<table>\n<tr>"
+      COLUMNS.map { |c| printf "<th>#{c}</th>" }
+      printf "</tr>\n"
+    end
+
+    def finish(job)
+      @done = (@done||0) +1
+      printf "<tr>"
+      COLUMNS.map { |c| printf "<td>#{job.send(c)}</td>" }
+      printf "</tr>\n"
+
+      printf "</table>\n" if @done == @todo
+    end
+
+    private
+    def printf(*a)
+      @out.printf *a
+    end
+  end
+
+  # print results in human friendly tabular format
+  #
+  # usage hints:
+  # * set :multiply=>1 if you want output in seconds instead of milliseconds
+  # * increase :column_width if you see indendation issues with wide values
+  # * increase :max_label_width if you want to see more of your labels
+  #
+  class ConsoleWriter
+    C_ID, C_LABEL, C_WIDTH, C_ROUND, C_MUL = *(0..4)
+
+    def initialize(opts={})
+      @opts = opts = { :out => $stderr, :multiply => 1000, :round => 2, 
+                       :column_width => 11, :max_label_width => 20 }.merge(opts)
+
+      @out = opts[:out]
+      @max_label_width = opts[:max_label_width]
+
+      @columns = [
+        # C_ID    C_LABEL          C_WIDTH              C_ROUND       C_MUL
+        [:id,     '',                               -1,          nil,             nil],
+        [:rounds, 'rounds',                         -1,            0,               0],
+        [:rate,   'r/s',           opts[:column_width], opts[:round],               1],
+        [:mean,   'mean',          opts[:column_width], opts[:round], opts[:multiply]],
+        [:max,    'max',           opts[:column_width], opts[:round], opts[:multiply]],
+        [:min,    'min',           opts[:column_width], opts[:round], opts[:multiply]],
+        [:stddev, "\u00b1 stddev", opts[:column_width], opts[:round], opts[:multiply]]
+      ]
+
+    end
+
+    def register(job)
+      # adjust width of first column (label) to fit longest label
+      @columns[0][C_WIDTH] = [@columns[0][C_WIDTH], [job.id.length+2,@max_label_width].min].max
+      # adjust width of second column (rounds) to fit widest value
+      @columns[1][C_WIDTH] = [@columns[1][C_WIDTH], @columns[1][C_LABEL].length, job.rounds.to_s.length].max
+    end
+
+    def start(job)
+      if @header_printed.nil?
+        @header_printed = true
+
+        # add :x column if this is a comparison
+        if job.compare
+          @columns << [:x, "x #{job.compare}", @opts[:column_width], @opts[:round], 1]
+        end
+
+        # print header
+        header = '-' * (@columns.transpose[C_WIDTH].reduce(&:+) + @columns.length - 1)
+        header[2..3+job.group.length] = " #{job.group} "
+        printf header + "\n"
+        @columns.each_with_index do |col, i|
+          printf col[C_LABEL].rjust(col[C_WIDTH]) + ' '
+        end
+        printf "\n"
+      end
+      # print job.label
+      printf "#{job.id[0..@columns[0][C_WIDTH]-1].ljust(@columns[0][C_WIDTH])} "
+      # print rounds
+      printf "%#{@columns[1][C_WIDTH]}d ", job.send(:rounds)
+    end
+
+    def finish(job)
+      @columns.each_with_index do |col, i|
+        next if 2 > i # first two columns were already printed in start()
+        value = job.send(col[C_ID]) * col[C_MUL]
+
+        printf "%#{col[C_WIDTH]}.#{col[C_ROUND]}f ", value
+      end
+      printf "\n"
+    end
+
+    private
+    def printf(*a)
+      @opts[:out].printf *a
+    end
+  end
+end
+

data/lib/b/version.rb

@@ -0,0 +1,3 @@
+module B
+  VERSION = "1.0.0"
+end

data/spec/b_spec.rb

@@ -0,0 +1,244 @@
+require 'spec_helper'
+
+describe B do
+  describe :enchmark do
+    before (:each) do
+      StdioTrap.trap!
+    end
+
+    after (:each) do
+      StdioTrap.release!
+    end
+
+    describe 'with opts={}' do
+      let(:test_opts) { {} }
+      describe :job do
+        it 'raises SanityViolation when trying to override :compare' do
+          lambda {
+            B.enchmark do
+              job('a', {:compare => :min}) {}
+            end
+          }.should raise_error B::SanityViolation
+        end
+  
+        it 'is called B::DEFAULT_ROUNDS times by default' do
+          a = mock(:a)
+          a.should_receive(:call).exactly(B::DEFAULT_ROUNDS).times
+          B.enchmark do
+            job('a') { a.call }
+          end
+        end
+
+        it 'can override :rounds' do
+          a, b, c, d = mock(:a), mock(:b), mock(:c), mock(:d)
+          a.should_receive(:call).exactly(B::DEFAULT_ROUNDS).times
+          b.should_receive(:call).exactly(5).times
+          c.should_receive(:call).exactly(B::DEFAULT_ROUNDS).times
+          d.should_receive(:call).exactly(10).times
+          B.enchmark do
+            job('a')                { a.call }
+            job('b', :rounds => 5)  { b.call }
+            job('c')                { c.call }
+            job('d', :rounds => 10) { d.call }
+          end
+        end
+      end
+
+      describe "return value" do
+        it "is an Array of well-formed Hashes" do
+          results = B.enchmark do
+            job('a') {}
+            job('b') {}
+          end
+          results.length.should == 2
+          results.each do |h|
+            h.should be_a Hash
+            B::Enchmark::Job::ATTRIBUTES.each do |a|
+              h.should have_key a
+            end
+          end
+        end
+
+        it "retval[*][:x] is nil" do
+          results = B.enchmark do
+            job('a') {}
+            job('b') {}
+          end
+          results.each do |h|
+            B::Enchmark::Job::ATTRIBUTES.each do |a|
+              h[:x].should == nil
+            end
+          end
+        end
+
+        it "looks about correct (timing)" do
+          results = B.enchmark('', test_opts) do
+            job('a', :rounds => 2 ) { sleep 0.5 }
+            job('b', :rounds => 1 ) { sleep 1 }
+          end
+          results.length.should == 2
+
+          results[0][:rounds].should == 2
+          results[0][:mean].should be >= 0.5
+          results[0][:mean].should be <= 1.0
+
+          results[1][:rounds].should == 1
+          results[1][:mean].should be >= 1.0
+          results[1][:mean].should be <= 1.5
+        end
+      end
+
+      describe "stdout" do
+        it "is empty" do
+          B.enchmark do
+            job('a') {}
+          end
+          StdioTrap.stdout.should == ''
+        end
+      end
+
+      describe "stderr" do
+        it "looks like output from the default ConsoleWriter" do
+          B.enchmark do
+            job('a') {}
+          end
+          StdioTrap.stderr.should match /^-- Untitled Benchmark/
+          StdioTrap.stderr.should match /rounds/
+          StdioTrap.stderr.should match /stddev/
+          StdioTrap.stderr.lines.count.should == 3
+        end
+      end
+    end
+
+    describe 'with opts={:compare => :mean, :rounds => 1}' do
+      let(:test_opts) { {:compare => :mean, :rounds => 1} }
+
+      describe :job do
+        it 'raises SanityViolation when trying to override :compare' do
+          lambda {
+            B.enchmark('', test_opts) do
+              job('a', {:compare => :min}) {}
+            end
+          }.should raise_error B::SanityViolation
+        end
+
+        it 'raises SanityViolation when trying to override :rounds' do
+          lambda {
+            B.enchmark('', test_opts) do
+              job('a', :rounds => 2) {}
+            end
+          }.should raise_error B::SanityViolation
+        end
+      end
+
+      describe "return value" do
+        it "is an Array of well-formed Hashes" do
+          results = B.enchmark('', test_opts) do
+            job('a') {}
+            job('b') {}
+          end
+
+          results.length.should == 2
+          results.each do |h|
+            h.should be_a Hash
+            B::Enchmark::Job::ATTRIBUTES.each do |a|
+              h.should have_key a
+            end
+          end
+        end
+
+        it "retval[*][:x] is not nil" do
+          results = B.enchmark('', test_opts) do
+            job('a') {}
+            job('b') {}
+          end
+          results.each do |h|
+            B::Enchmark::Job::ATTRIBUTES.each do |a|
+              h.should_not == nil
+            end
+          end
+        end
+
+        it "is sorted on :mean (and :x)" do
+          results = B.enchmark('', test_opts) do
+            job('b') { sleep 0.3 }
+            job('a') { sleep 0.1 }
+            job('d') { sleep 0.9 }
+            job('c') { sleep 0.6 }
+          end
+          as_returned = results.collect {|e| [e[:mean], e[:id]]}
+          sorted = as_returned.sort_by {|e| e[0]}
+          sorted.collect {|e| e[1]}.should == ['a', 'b', 'c', 'd']
+
+          as_returned = results.collect {|e| [e[:x], e[:id]]}
+          sorted = as_returned.sort_by {|e| e[0]}
+          sorted.collect {|e| e[1]}.should == ['a', 'b', 'c', 'd']
+        end
+
+     end
+    end
+
+    describe 'with opts={:output => nil}' do
+      let(:test_opts) { { :output=> nil } }
+
+      it 'doesn\'t write to stdout nor stderr' do
+        B.enchmark('', test_opts) do
+          job('a') {}
+        end
+        StdioTrap.stdout.should == ''
+        StdioTrap.stderr.should == ''
+      end
+    end
+  end
+
+  describe 'TsvWriter' do
+    before (:each) do
+      StdioTrap.trap!
+      output = B::TsvWriter.new
+      B.enchmark('foobar', :output => output) do
+        job('a') {}
+      end
+      @stdio = StdioTrap.release!
+    end
+
+    describe "stdout" do
+      it "looks like output from TsvWriter" do
+        @stdio[:stdout].should match /^group\tid\trounds\trate\tmean\tmax\tmin\tstddev\tx\n/
+        @stdio[:stdout].split("\n")[1].should match /^foobar\t/
+        @stdio[:stdout].lines.count.should == 2
+      end
+    end
+
+    describe "stderr" do
+      it "is empty" do
+        @stdio[:stderr].should == ''
+      end
+    end
+  end
+
+  describe 'HtmlWriter' do
+    before (:each) do
+      StdioTrap.trap!
+      output = B::HtmlWriter.new
+      B.enchmark('foobar', :output => output) do
+        job('a') {}
+      end
+      @stdio = StdioTrap.release!
+    end
+
+    describe "stdout" do
+      it "looks like output from TsvWriter" do
+        @stdio[:stdout].should match /^<table>\n<tr><th>/
+        @stdio[:stdout].split("\n")[2].should match /^<tr><td>foobar<\/td>/
+        @stdio[:stdout].lines.count.should == 4
+      end
+    end
+
+    describe "stderr" do
+      it "is empty" do
+        @stdio[:stderr].should == ''
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'stdiotrap'
+require 'simplecov'
+SimpleCov.start
+
+require 'b'
+

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: b
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Moe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: stdiotrap
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hitimes
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: blockenspiel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A small, convenient benchmark-library.
+email:
+- moe@busyloop.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- b.gemspec
+- lib/b.rb
+- lib/b/demo.rb
+- lib/b/output_plugins.rb
+- lib/b/version.rb
+- spec/b_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/busyloop/b
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A small, convenient benchmark-library.
+test_files:
+- spec/b_spec.rb
+- spec/spec_helper.rb