hitimes 1.1.1 → 1.2.0

data/spec/hitimes_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Hitimes do
+  it "can time a block of code" do
+    d = Hitimes.measure do
+      sleep 0.2
+    end
+    d.should be_within(0.02).of(0.2)
+  end
+
+  it "raises an error if measure is called with no block" do
+    lambda{ Hitimes.measure }.should raise_error( Hitimes::Error, /\ANo block given to Interval.measure\Z/ )
+  end
+end

data/spec/interval_spec.rb

@@ -1,11 +1,14 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
-
-require 'hitimes'
+require "spec_helper"
 
 describe Hitimes::Interval do
-  it "has a 0 duration when newly created" do
-    i = Hitimes::Interval.new   
-    i.duration == 0.0
+  it "raises an error if duration is called on a non-started interval" do
+    i = Hitimes::Interval.new
+    lambda{ i.duration }.should raise_error( Hitimes::Error, /\AAttempt to report a duration on an interval that has not started\Z/ )
+  end
+
+  it "raises an error if stop is called on a non-started interval" do
+    i = Hitimes::Interval.new
+    lambda { i.stop }.should raise_error( Hitimes::Error, /\AAttempt to stop an interval that has not started\Z/ )
   end
 
   it "knows if it has been started" do
@@ -37,11 +40,11 @@ describe Hitimes::Interval do
     d = Hitimes::Interval.measure do
       sleep 0.2
     end
-    d.should be_close(0.2, 0.02)
+    d.should be_within(0.02).of(0.2)
   end
 
   it "raises an error if measure is called with no block" do
-    lambda{ Hitimes::Interval.measure }.should raise_error( Hitimes::Error )
+    lambda{ Hitimes::Interval.measure }.should raise_error( Hitimes::Error, /\ANo block given to Interval.measure\Z/ )
   end
 
   it "creates an interval via #now" do
@@ -60,10 +63,10 @@ describe Hitimes::Interval do
 
   it "calling start multiple times on has no effect after the first call" do
     i = Hitimes::Interval.new
-    i.start.should == true
+    i.start.should be == true
     x = i.start_instant
-    i.start_instant.should > 0
-    i.start.should == false
+    i.start_instant.should be > 0
+    i.start.should be == false
     x.should == i.start_instant
   end
 
@@ -75,12 +78,12 @@ describe Hitimes::Interval do
 
   it "calling stop multiple times on has no effect after the first call" do
     i = Hitimes::Interval.new
-    i.start.should == true
+    i.start.should be == true
     i.stop
 
     x = i.stop_instant
-    i.stop_instant.should > 0
-    i.stop.should == false
+    i.stop_instant.should be > 0
+    i.stop.should be == false
     x.should == i.stop_instant
 
   end
@@ -90,14 +93,14 @@ describe Hitimes::Interval do
     i.start
     x = i.stop
     y = i.duration
-    i.stop.should == false
+    i.stop.should be == false
 
     z = i.duration
 
-    x.should == y
-    x.should == z
+    x.should be == y
+    x.should be == z
 
-    y.should == z
+    y.should be == z
   end
 
   it "can return how much time has elapsed from the start without stopping the interval" do
@@ -107,9 +110,9 @@ describe Hitimes::Interval do
     i.should be_running
     y = i.duration_so_far
     i.stop
-    x.should < y
-    x.should < i.duration
-    y.should < i.duration
+    x.should be < y
+    x.should be < i.duration
+    y.should be < i.duration
   end
 
   describe "#split" do

data/spec/metric_spec.rb

@@ -1,6 +1,4 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
-
-require 'hitimes/metric'
+require "spec_helper"
 
 describe Hitimes::Metric do
   before( :each ) do
@@ -8,22 +6,22 @@ describe Hitimes::Metric do
   end
 
   it 'has a name' do
-    @metric.name.should == "testing"
+    @metric.name.should be == "testing"
   end
 
   it "has associated data from initialization" do
     m = Hitimes::Metric.new( "more-data", 'foo' => 'bar', 'this' => 'that' )
-    m.additional_data['foo'].should == 'bar'
-    m.additional_data['this'].should == 'that'
+    m.additional_data['foo'].should be == 'bar'
+    m.additional_data['this'].should be == 'that'
     
     m = Hitimes::Metric.new( "more-data", { 'foo' => 'bar', 'this' => 'that' } )
-    m.additional_data['foo'].should == 'bar'
-    m.additional_data['this'].should == 'that'
+    m.additional_data['foo'].should be == 'bar'
+    m.additional_data['this'].should be == 'that'
   end
 
   it "initially has no sampling times" do
-    @metric.sampling_start_time.should == nil
-    @metric.sampling_stop_time.should == nil
+    @metric.sampling_start_time.should be == nil
+    @metric.sampling_stop_time.should be == nil
   end
 end
 

data/spec/mutex_stats_spec.rb

@@ -1,7 +1,4 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
-
-require 'hitimes'
-require 'hitimes/mutexed_stats'
+require 'spec_helper'
 
 describe Hitimes::MutexedStats do
   before( :each ) do
@@ -19,8 +16,13 @@ describe Hitimes::MutexedStats do
     return stats
   end
 
-  it "is unsafe normally" do
-    pending "not for MRI -- not interruptable in this C extension" do
+  if (not defined? RUBY_ENGINE) or (RUBY_ENGINE == "ruby") then
+    it "Hitimes::Stats is threadsafe" do
+      stats = run_with_scissors( ::Hitimes::Stats.new, @threads, @iters )
+      stats.count.should== @final_value
+    end
+  else
+    it "Hitimes::Stats is not threadsafe" do
       stats = run_with_scissors( ::Hitimes::Stats.new, @threads, @iters )
       stats.count.should_not == @final_value
     end

data/spec/paths_spec.rb

@@ -1,6 +1,4 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
-
-require 'hitimes/paths'
+require 'spec_helper'
 
 describe Hitimes::Paths do
   it "can access the root dir of the project" do

data/spec/spec_helper.rb

@@ -1,5 +1,9 @@
-require 'rubygems'
-require 'spec'
+if RUBY_VERSION >= '1.9.2' then
+  require 'simplecov'
+  puts "Using coverage!"
+  SimpleCov.start if ENV['COVERAGE']
+end
 
-$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'rspec/autorun'
+require 'hitimes'
 

data/spec/stats_spec.rb

@@ -1,6 +1,4 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
-
-require 'hitimes/stats'
+require 'spec_helper'
 require 'json'
 
 describe Hitimes::Stats do
@@ -12,60 +10,60 @@ describe Hitimes::Stats do
   end
 
   it "is initialized with 0 values" do
-    @stats.count.should == 0
-    @stats.min.should == 0.0
-    @stats.max.should == 0.0
-    @stats.sum.should == 0.0
-    @stats.rate.should == 0.0
+    @stats.count.should be == 0
+    @stats.min.should be == 0.0
+    @stats.max.should be == 0.0
+    @stats.sum.should be == 0.0
+    @stats.rate.should be == 0.0
   end
 
   it "calculates the mean correctly" do
-    @full_stats.mean.should == 2.0
+    @full_stats.mean.should be == 2.0
   end
 
   it "calculates the rate correctly" do
-    @full_stats.rate.should == 0.5
+    @full_stats.rate.should be == 0.5
   end
 
   it "tracks the maximum value" do
-    @full_stats.max.should == 3.0
+    @full_stats.max.should be == 3.0
   end
 
   it "tracks the minimum value" do
-    @full_stats.min.should == 1.0
+    @full_stats.min.should be == 1.0
   end
 
   it "tracks the count" do
-    @full_stats.count.should == 3
+    @full_stats.count.should be == 3
   end
   
   it "tracks the sum" do
-    @full_stats.sum.should == 6.0
+    @full_stats.sum.should be == 6.0
   end
 
   it "calculates the standard deviation" do
-    @full_stats.stddev.should == 1.0
+    @full_stats.stddev.should be == 1.0
   end 
 
   it "calculates the sum of squares " do
-    @full_stats.sumsq.should == 14.0
+    @full_stats.sumsq.should be == 14.0
   end 
 
   describe "#to_hash " do
     it "converts to a Hash" do
       h = @full_stats.to_hash
-      h.size.should == ::Hitimes::Stats::STATS.size
-      h.keys.sort.should == ::Hitimes::Stats::STATS
+      h.size.should be == ::Hitimes::Stats::STATS.size
+      h.keys.sort.should be == ::Hitimes::Stats::STATS
     end
 
     it "converts to a limited Hash if given arguments" do
       h = @full_stats.to_hash( "min", "max", "mean" )
-      h.size.should == 3
-      h.keys.sort.should == %w[ max mean min  ]
+      h.size.should be == 3
+      h.keys.sort.should be == %w[ max mean min  ]
 
       h = @full_stats.to_hash( %w[ count rate ] )
-      h.size.should == 2
-      h.keys.sort.should == %w[ count rate ]
+      h.size.should be == 2
+      h.keys.sort.should be == %w[ count rate ]
     end
 
     it "raises NoMethodError if an invalid stat is used" do
@@ -77,20 +75,20 @@ describe Hitimes::Stats do
     it "converts to a json string" do
       j = @full_stats.to_json
       h = JSON.parse( j )
-      h.size.should == ::Hitimes::Stats::STATS.size
-      h.keys.sort.should == ::Hitimes::Stats::STATS
+      h.size.should be == ::Hitimes::Stats::STATS.size
+      h.keys.sort.should be == ::Hitimes::Stats::STATS
     end
 
     it "converts to a limited Hash if given arguments" do
       j = @full_stats.to_json( "min", "max", "mean" )
       h = JSON.parse( j )
-      h.size.should == 3
-      h.keys.sort.should == %w[ max mean min  ]
+      h.size.should be == 3
+      h.keys.sort.should be == %w[ max mean min  ]
 
       j = @full_stats.to_json( %w[ count rate ] )
       h = JSON.parse( j )
-      h.size.should == 2
-      h.keys.sort.should == %w[ count rate ]
+      h.size.should be == 2
+      h.keys.sort.should be == %w[ count rate ]
     end
 
     it "raises NoMethodError if an invalid stat is used" do

data/spec/timed_metric_spec.rb

@@ -1,6 +1,4 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
-
-require 'hitimes/timed_metric'
+require 'spec_helper'
 
 describe Hitimes::TimedMetric do
   before( :each ) do
@@ -19,76 +17,76 @@ describe Hitimes::TimedMetric do
     @tm.start
     d = @tm.split
     @tm.should be_running
-    d.should > 0
-    @tm.count.should == 1
-    @tm.duration.should == d
+    d.should be > 0
+    @tm.count.should be == 1
+    @tm.duration.should be == d
   end
 
   it "#stop returns false if called more than once in a row" do
     @tm.start
-    @tm.stop.should > 0
-    @tm.stop.should == false
+    @tm.stop.should be > 0
+    @tm.stop.should be == false
   end
 
   it "does not count a currently running interval as an interval in calculations" do
     @tm.start
-    @tm.count.should == 0
+    @tm.count.should be == 0
     @tm.split
-    @tm.count.should == 1
+    @tm.count.should be == 1
   end
 
   it "#split called on a stopped timer does nothing" do
     @tm.start
     @tm.stop
-    @tm.split.should == false
+    @tm.split.should be == false
   end
 
   it "calculates the mean of the durations" do
     2.times { @tm.start ; sleep 0.05 ; @tm.stop }
-    @tm.mean.should be_close( 0.05, 0.01 )
+    @tm.mean.should be_within(0.01).of(0.05)
   end
 
   it "calculates the rate of the counts " do
     5.times { @tm.start ; sleep 0.05 ; @tm.stop }
-    @tm.rate.should be_close( 20.00, 0.1 )
+    @tm.rate.should be_within(1.0).of(20.00)
   end
 
 
   it "calculates the stddev of the durations" do
-    3.times { |x| @tm.start ; sleep (0.05 * x) ; @tm.stop }
-    @tm.stddev.should be_close( 0.05, 0.001) 
+    3.times { |x| @tm.start ; sleep(0.05 * x) ; @tm.stop }
+    @tm.stddev.should be_within(0.002).of( 0.05)
   end
 
   it "returns 0.0 for stddev if there is no data" do
-    @tm.stddev.should == 0.0
+    @tm.stddev.should be == 0.0
   end
 
   it "keeps track of the min value" do
     2.times { @tm.start ; sleep 0.05 ; @tm.stop }
-    @tm.min.should be_close( 0.05, 0.002 )
+    @tm.min.should be_within( 0.002 ).of(0.05)
   end
 
   it "keeps track of the max value" do
     2.times { @tm.start ; sleep 0.05 ; @tm.stop }
-    @tm.max.should be_close( 0.05, 0.002 )
+    @tm.max.should be_within( 0.002 ).of(0.05)
   end
 
   it "keeps track of the sum value" do
     2.times { @tm.start ; sleep 0.05 ; @tm.stop }
-    @tm.sum.should be_close( 0.10, 0.002 )
+    @tm.sum.should be_within( 0.005 ).of(0.10)
   end
-  
+
   it "keeps track of the sum of squars value" do
     3.times { @tm.start ; sleep 0.05 ; @tm.stop }
-    @tm.sumsq.should be_close( 0.0075, 0.0001 )
+    @tm.sumsq.should be_within(0.001).of(0.0075)
   end
 
   it "keeps track of the minimum start time of all the intervals" do
     f1 = Time.now.gmtime.to_f * 1_000_000
     5.times { @tm.start ; sleep 0.05 ; @tm.stop }
     f2 = Time.now.gmtime.to_f * 1_000_000
-    @tm.sampling_start_time.should >= f1
-    @tm.sampling_start_time.should < f2
+    @tm.sampling_start_time.should be >= f1
+    @tm.sampling_start_time.should be < f2
     # distance from now to start time should be greater than the distance from
     # the start to the min start_time
     (f2 - @tm.sampling_start_time).should > ( @tm.sampling_start_time - f1 )
@@ -96,10 +94,12 @@ describe Hitimes::TimedMetric do
 
   it "keeps track of the last stop time of all the intervals" do
     f1 = Time.now.gmtime.to_f * 1_000_000
+    sleep 0.01
     5.times { @tm.start ; sleep 0.05 ; @tm.stop }
+    sleep 0.01
     f2 = Time.now.gmtime.to_f * 1_000_000
-    @tm.sampling_stop_time.should > f1
-    @tm.sampling_stop_time.should <= f2
+    @tm.sampling_stop_time.should be > f1
+    @tm.sampling_stop_time.should be <= f2
     # distance from now to max stop time time should be less than the distance
     # from the start to the max stop time
     (f2 - @tm.sampling_stop_time).should < ( @tm.sampling_stop_time - f1 )
@@ -113,34 +113,34 @@ describe Hitimes::TimedMetric do
   it "can measure a block of code from an instance" do
     t = Hitimes::TimedMetric.new( 'measure a block' )
     3.times { t.measure { sleep 0.05 } }
-    t.duration.should be_close( 0.15, 0.001 )
-    t.count.should == 3
+    t.duration.should be_within(0.01).of(0.15)
+    t.count.should be == 3
   end
 
   it "returns the value of the block when measuring" do
     t = Hitimes::TimedMetric.new( 'measure a block' )
     x = t.measure { sleep 0.05; 42 }
-    t.duration.should be_close( 0.05, 0.001 )
-    x.should == 42
+    t.duration.should be_within(0.002).of(0.05)
+    x.should be == 42
   end
 
   describe "#to_hash" do
 
     it "has name value" do
       h = @tm.to_hash
-      h['name'].should == "test-timed-metric"
+      h['name'].should be == "test-timed-metric"
     end
 
     it "has an empty hash for additional_data" do
       h = @tm.to_hash
-      h['additional_data'].should == Hash.new
-      h['additional_data'].size.should == 0
+      h['additional_data'].should be == Hash.new
+      h['additional_data'].size.should be == 0
     end
 
     it "has the right sum" do
       10.times { |x| @tm.measure { sleep 0.01*x  } }
       h = @tm.to_hash
-      h['sum'].should be_close( 0.45, 0.003 )
+      h['sum'].should be_within( 0.01).of(0.45)
     end
 
     fields = ::Hitimes::Stats::STATS.dup + %w[ name additional_data sampling_start_time sampling_stop_time ]