hitimes 1.1.1-x86-mingw32 → 1.2.2-x86-mingw32

data/spec/paths_spec.rb

@@ -1,13 +1,11 @@
-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
-    Hitimes::Paths.root_dir.should == File.expand_path( File.join( File.dirname( __FILE__ ), ".." ) ) + ::File::SEPARATOR
+    Hitimes::Paths.root_dir.must_equal File.expand_path( File.join( File.dirname( __FILE__ ), ".." ) ) + ::File::SEPARATOR
   end
 
   it "can access the lib path of the project" do
-    Hitimes::Paths.lib_path.should == File.expand_path( File.join( File.dirname( __FILE__ ), "..", "lib" ) ) + ::File::SEPARATOR
+    Hitimes::Paths.lib_path.must_equal File.expand_path( File.join( File.dirname( __FILE__ ), "..", "lib" ) ) + ::File::SEPARATOR
   end
 end

data/spec/spec_helper.rb

@@ -1,5 +1,11 @@
-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"))
+gem 'minitest'
+require 'hitimes'
+require 'minitest/autorun'
+require 'minitest/pride'
 

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,64 +10,64 @@ 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.must_equal 0
+    @stats.min.must_equal 0.0
+    @stats.max.must_equal 0.0
+    @stats.sum.must_equal 0.0
+    @stats.rate.must_equal 0.0
   end
 
   it "calculates the mean correctly" do
-    @full_stats.mean.should == 2.0
+    @full_stats.mean.must_equal 2.0
   end
 
   it "calculates the rate correctly" do
-    @full_stats.rate.should == 0.5
+    @full_stats.rate.must_equal 0.5
   end
 
   it "tracks the maximum value" do
-    @full_stats.max.should == 3.0
+    @full_stats.max.must_equal 3.0
   end
 
   it "tracks the minimum value" do
-    @full_stats.min.should == 1.0
+    @full_stats.min.must_equal 1.0
   end
 
   it "tracks the count" do
-    @full_stats.count.should == 3
+    @full_stats.count.must_equal 3
   end
   
   it "tracks the sum" do
-    @full_stats.sum.should == 6.0
+    @full_stats.sum.must_equal 6.0
   end
 
   it "calculates the standard deviation" do
-    @full_stats.stddev.should == 1.0
+    @full_stats.stddev.must_equal 1.0
   end 
 
   it "calculates the sum of squares " do
-    @full_stats.sumsq.should == 14.0
+    @full_stats.sumsq.must_equal 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.must_equal ::Hitimes::Stats::STATS.size
+      h.keys.sort.must_equal ::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.must_equal 3
+      h.keys.sort.must_equal %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.must_equal 2
+      h.keys.sort.must_equal %w[ count rate ]
     end
 
     it "raises NoMethodError if an invalid stat is used" do
-      lambda { @full_stats.to_hash( "wibble" ) }.should raise_error( NoMethodError )
+      lambda { @full_stats.to_hash( "wibble" ) }.must_raise( NoMethodError )
     end
   end
 
@@ -77,24 +75,24 @@ 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.must_equal ::Hitimes::Stats::STATS.size
+      h.keys.sort.must_equal ::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.must_equal 3
+      h.keys.sort.must_equal %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.must_equal 2
+      h.keys.sort.must_equal %w[ count rate ]
     end
 
     it "raises NoMethodError if an invalid stat is used" do
-      lambda { @full_stats.to_json( "wibble" ) }.should raise_error( NoMethodError )
+      lambda { @full_stats.to_json( "wibble" ) }.must_raise( NoMethodError )
     end
   end
 end

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
@@ -8,147 +6,149 @@ describe Hitimes::TimedMetric do
   end
 
   it "knows if it is running or not" do
-    @tm.should_not be_running
+    @tm.running?.must_equal false
     @tm.start
-    @tm.should be_running
+    @tm.running?.must_equal true
     @tm.stop
-    @tm.should_not be_running
+    @tm.running?.must_equal false
   end
 
   it "#split returns the last duration and the timer is still running" do
     @tm.start
     d = @tm.split
-    @tm.should be_running
-    d.should > 0
-    @tm.count.should == 1
-    @tm.duration.should == d
+    @tm.running?.must_equal true
+    d.must_be :>, 0
+    @tm.count.must_equal 1
+    @tm.duration.must_equal 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.must_be :>, 0
+    @tm.stop.must_equal false
   end
 
   it "does not count a currently running interval as an interval in calculations" do
     @tm.start
-    @tm.count.should == 0
+    @tm.count.must_equal 0
     @tm.split
-    @tm.count.should == 1
+    @tm.count.must_equal 1
   end
 
   it "#split called on a stopped timer does nothing" do
     @tm.start
     @tm.stop
-    @tm.split.should == false
+    @tm.split.must_equal 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.must_be_close_to(0.05, 0.002)
   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.must_be_close_to(20.00, 0.5)
   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.must_be_close_to(0.05)
   end
 
   it "returns 0.0 for stddev if there is no data" do
-    @tm.stddev.should == 0.0
+    @tm.stddev.must_equal 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.must_be_close_to(0.05, 0.01)
   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.must_be_close_to(0.05, 0.01)
   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.must_be_close_to(0.10, 0.01)
   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.must_be_close_to(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.must_be :>=, f1
+    @tm.sampling_start_time.must_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 )
+    (f2 - @tm.sampling_start_time).must_be :>, ( @tm.sampling_start_time - f1 )
   end
 
   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.must_be :>, f1
+    @tm.sampling_stop_time.must_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 )
+    (f2 - @tm.sampling_stop_time).must_be :<, ( @tm.sampling_stop_time - f1 )
   end
 
   it "can create an already running timer" do
     t = Hitimes::TimedMetric.now( 'already-running' )
-    t.should be_running
+    t.running?.must_equal true
   end
 
   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.must_be_close_to(0.15, 0.01)
+    t.count.must_equal 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.must_be_close_to(0.05, 0.002)
+    x.must_equal 42
   end
 
   describe "#to_hash" do
 
     it "has name value" do
       h = @tm.to_hash
-      h['name'].should == "test-timed-metric"
+      h['name'].must_equal "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'].must_equal Hash.new
+      h['additional_data'].size.must_equal 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'].must_be_close_to(0.45, 0.01)
     end
 
     fields = ::Hitimes::Stats::STATS.dup + %w[ name additional_data sampling_start_time sampling_stop_time ]
     fields.each do |f|
-      it "should have a value for #{f}" do
+      it "has a value for #{f}" do
         @tm.measure { sleep 0.001 }
         h = @tm.to_hash
-        h[f].should_not be_nil
+        h[f].wont_be_nil
       end
     end
   end 

data/spec/timed_value_metric_spec.rb

@@ -1,6 +1,4 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
-
-require 'hitimes/timed_value_metric'
+require 'spec_helper'
 
 describe Hitimes::TimedValueMetric do
   before( :each ) do
@@ -8,164 +6,165 @@ describe Hitimes::TimedValueMetric do
   end
 
   it "knows if it is running or not" do
-    @tm.should_not be_running
+    @tm.running?.must_equal false
     @tm.start
-    @tm.should be_running
+    @tm.running?.must_equal true
     @tm.stop( 1 )
-    @tm.should_not be_running
+    @tm.running?.must_equal false
   end
 
   it "#split returns the last duration and the timer is still running" do
     @tm.start
     d = @tm.split( 1 )
-    @tm.should be_running
-    d.should > 0
-    @tm.value_stats.count.should == 1
-    @tm.timed_stats.count.should == 1
-    @tm.duration.should == d
+    @tm.running?.must_equal true
+    d.must_be :>, 0
+    @tm.value_stats.count.must_equal 1
+    @tm.timed_stats.count.must_equal 1
+    @tm.duration.must_equal d
   end
 
   it "#stop returns false if called more than once in a row" do
     @tm.start
-    @tm.stop( 1 ).should > 0
-    @tm.stop( 1 ).should == false
+    @tm.stop( 1 ).must_be :>, 0
+    @tm.stop( 1 ).must_equal false
   end
 
   it "does not count a currently running interval as an interval in calculations" do
     @tm.start
-    @tm.value_stats.count.should == 0
-    @tm.timed_stats.count.should == 0
+    @tm.value_stats.count.must_equal 0
+    @tm.timed_stats.count.must_equal 0
     @tm.split( 1 )
-    @tm.value_stats.count.should == 1
-    @tm.timed_stats.count.should == 1
+    @tm.value_stats.count.must_equal 1
+    @tm.timed_stats.count.must_equal 1
   end
 
   it "#split called on a stopped timer does nothing" do
     @tm.start
     @tm.stop( 1 )
-    @tm.split( 1 ).should == false
+    @tm.split( 1 ).must_equal false
   end
 
   it "calculates the mean of the durations" do
     3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop(x) }
-    @tm.timed_stats.mean.should be_close( 0.05, 0.01 )
-    @tm.value_stats.mean.should == 1.00
+    @tm.timed_stats.mean.must_be_close_to(0.05, 0.01)
+    @tm.value_stats.mean.must_equal 1.00
   end
 
   it "calculates the rate of the counts " do
     5.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.rate.should be_close( 40.0, 0.2)
+    @tm.rate.must_be_close_to(40.0, 1.0)
   end
 
 
   it "calculates the stddev of the durations" do
-    3.times { |x| @tm.start ; sleep (0.05 * x) ; @tm.stop(x) }
-    @tm.timed_stats.stddev.should be_close( 0.05, 0.001) 
-    @tm.value_stats.stddev.should == 1.0
+    3.times { |x| @tm.start ; sleep(0.05 * x) ; @tm.stop(x) }
+    @tm.timed_stats.stddev.must_be_close_to(0.05, 0.001)
+    @tm.value_stats.stddev.must_equal 1.0
   end
 
   it "returns 0.0 for stddev if there is no data" do
-    @tm.timed_stats.stddev.should == 0.0
-    @tm.value_stats.stddev.should == 0.0
+    @tm.timed_stats.stddev.must_equal 0.0
+    @tm.value_stats.stddev.must_equal 0.0
   end
 
   it "keeps track of the min value" do
     3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.timed_stats.min.should be_close( 0.05, 0.001 )
-    @tm.value_stats.min.should == 0
+    @tm.timed_stats.min.must_be_close_to( 0.05, 0.003 )
+    @tm.value_stats.min.must_equal 0
   end
 
   it "keeps track of the max value" do
     3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.timed_stats.max.should be_close( 0.05, 0.001) 
-    @tm.value_stats.max.should == 2
+    @tm.timed_stats.max.must_be_close_to( 0.05, 0.003 )
+    @tm.value_stats.max.must_equal 2
   end
 
   it "keeps track of the sum value" do
     3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.timed_stats.sum.should be_close( 0.15, 0.01 )
-    @tm.value_stats.sum.should == 3
+    @tm.timed_stats.sum.must_be_close_to( 0.15, 0.01 )
+    @tm.value_stats.sum.must_equal 3
   end
   
   it "keeps track of the sum of squares value" do
     3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.timed_stats.sumsq.should be_close( 0.0075, 0.0001 )
-    @tm.value_stats.sumsq.should == 5
+    @tm.timed_stats.sumsq.must_be_close_to(0.0075, 0.0005)
+    @tm.value_stats.sumsq.must_equal 5
   end
 
   it "keeps track of the minimum start time of all the intervals" do
     f1 = Time.now.gmtime.to_f * 1000000
     5.times { @tm.start ; sleep 0.05 ; @tm.stop( 1 ) }
     f2 = Time.now.gmtime.to_f * 1000000
-    @tm.sampling_start_time.should >= f1
-    @tm.sampling_start_time.should < f2
+    @tm.sampling_start_time.must_be :>=, f1
+    @tm.sampling_start_time.must_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 )
+    (f2 - @tm.sampling_start_time).must_be :>, ( @tm.sampling_start_time - f1 )
   end
 
   it "keeps track of the last stop time of all the intervals" do
-    f1 = Time.now.gmtime.to_f * 1000000
+    f1 = Time.now.gmtime.to_f * 1_000_000
     5.times { @tm.start ; sleep 0.05 ; @tm.stop( 1 ) }
-    f2 = Time.now.gmtime.to_f * 1000000
-    @tm.sampling_stop_time.should > f1
-    @tm.sampling_stop_time.should <= f2
+    sleep 0.05
+    f2 = Time.now.gmtime.to_f * 1_000_000
+    @tm.sampling_stop_time.must_be :>, f1
+    @tm.sampling_stop_time.must_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 )
+    (f2 - @tm.sampling_stop_time).must_be :<, ( @tm.sampling_stop_time - f1 )
   end
 
   it "can create an already running timer" do
     t = Hitimes::TimedValueMetric.now( 'already-running' )
-    t.should be_running
+    t.running?.must_equal true
   end
 
   it "can measure a block of code from an instance" do
     t = Hitimes::TimedValueMetric.new( 'measure a block' )
     3.times { t.measure( 1 ) { sleep 0.05 } }
-    t.duration.should be_close( 0.15, 0.001 )
-    t.timed_stats.count.should == 3
-    t.value_stats.count.should == 3
+    t.duration.must_be_close_to(0.15, 0.004)
+    t.timed_stats.count.must_equal 3
+    t.value_stats.count.must_equal 3
   end
 
   it "returns the value of the block when measuring" do
     t = Hitimes::TimedValueMetric.new( 'measure a block' )
     x = t.measure( 42 ) { sleep 0.05; 42 }
-    t.duration.should be_close( 0.05, 0.001 )
-    x.should == 42
+    t.duration.must_be_close_to(0.05, 0.002)
+    x.must_equal 42
   end
 
   describe "#to_hash" do
 
     it "has name value" do
       h = @tm.to_hash
-      h['name'].should == "test-timed-value-metric"
+      h['name'].must_equal "test-timed-value-metric"
     end
 
     it "has an empty has for additional_data" do
       h = @tm.to_hash
-      h['additional_data'].should == Hash.new
-      h['additional_data'].size.should == 0
+      h['additional_data'].must_equal Hash.new
+      h['additional_data'].size.must_equal 0
     end
 
     it "has a rate" do
       5.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
       h = @tm.to_hash
-      h['rate'].should be_close( 40.0, 0.3 )
+      h['rate'].must_be_close_to(40.0, 1.0)
     end
 
     it "has a unit_count" do
       5.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
       h = @tm.to_hash
-      h['unit_count'].should ==  10
+      h['unit_count'].must_equal  10
     end
 
     fields = %w[ name additional_data sampling_start_time sampling_stop_time value_stats timed_stats rate unit_count ]
     fields.each do |f|
-      it "should have a value for #{f}" do
+      it "has a value for #{f}" do
         3.times { |x| @tm.measure(x) { sleep 0.001 } }
         h = @tm.to_hash
-        h[f].should_not be_nil
+        h[f].wont_be_nil
       end
     end
   end