hitimes 1.3.1 → 2.0.0

data/spec/timed_metric_spec.rb

@@ -6,90 +6,90 @@ describe Hitimes::TimedMetric do
   end
 
   it "knows if it is running or not" do
-    @tm.running?.must_equal false
+    _(@tm.running?).must_equal false
     @tm.start
-    @tm.running?.must_equal true
+    _(@tm.running?).must_equal true
     @tm.stop
-    @tm.running?.must_equal false
+    _(@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.running?.must_equal true
-    d.must_be :>, 0
-    @tm.count.must_equal 1
-    @tm.duration.must_equal 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.must_be :>, 0
-    @tm.stop.must_equal 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.must_equal 0
+    _(@tm.count).must_equal 0
     @tm.split
-    @tm.count.must_equal 1
+    _(@tm.count).must_equal 1
   end
 
   it "#split called on a stopped timer does nothing" do
     @tm.start
     @tm.stop
-    @tm.split.must_equal 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.must_be_close_to(0.05, 0.002)
+    _(@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.must_be_close_to(20.00, 0.5)
+    _(@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.must_be_close_to(0.05)
+    _(@tm.stddev).must_be_close_to(0.05)
   end
 
   it "returns 0.0 for stddev if there is no data" do
-    @tm.stddev.must_equal 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.must_be_close_to(0.05, 0.01)
+    _(@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.must_be_close_to(0.05, 0.01)
+    _(@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.must_be_close_to(0.10, 0.01)
+    _(@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.must_be_close_to(0.0075)
+    _(@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.must_be :>=, f1
-    @tm.sampling_start_time.must_be :<, 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).must_be :>, ( @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
@@ -98,49 +98,49 @@ describe Hitimes::TimedMetric do
     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.must_be :>, f1
-    @tm.sampling_stop_time.must_be :<=, 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).must_be :<, ( @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.running?.must_equal true
+    _(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.must_be_close_to(0.15, 0.01)
-    t.count.must_equal 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.must_be_close_to(0.05, 0.002)
-    x.must_equal 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'].must_equal "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'].must_equal Hash.new
-      h['additional_data'].size.must_equal 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'].must_be_close_to(0.45, 0.01)
+      _(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 ]
@@ -148,7 +148,7 @@ describe Hitimes::TimedMetric do
       it "has a value for #{f}" do
         @tm.measure { sleep 0.001 }
         h = @tm.to_hash
-        h[f].wont_be_nil
+        _(h[f]).wont_be_nil
       end
     end
   end 

data/spec/timed_value_metric_spec.rb

@@ -6,100 +6,100 @@ describe Hitimes::TimedValueMetric do
   end
 
   it "knows if it is running or not" do
-    @tm.running?.must_equal false
+    _(@tm.running?).must_equal false
     @tm.start
-    @tm.running?.must_equal true
+    _(@tm.running?).must_equal true
     @tm.stop( 1 )
-    @tm.running?.must_equal false
+    _(@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.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
+    _(@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 ).must_be :>, 0
-    @tm.stop( 1 ).must_equal 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.must_equal 0
-    @tm.timed_stats.count.must_equal 0
+    _(@tm.value_stats.count).must_equal 0
+    _(@tm.timed_stats.count).must_equal 0
     @tm.split( 1 )
-    @tm.value_stats.count.must_equal 1
-    @tm.timed_stats.count.must_equal 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 ).must_equal 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.must_be_close_to(0.05, 0.01)
-    @tm.value_stats.mean.must_equal 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.must_be_close_to(40.0, 1.0)
+    _(@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.must_be_close_to(0.05, 0.001)
-    @tm.value_stats.stddev.must_equal 1.0
+    _(@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.must_equal 0.0
-    @tm.value_stats.stddev.must_equal 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.must_be_close_to( 0.05, 0.003 )
-    @tm.value_stats.min.must_equal 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.must_be_close_to( 0.05, 0.003 )
-    @tm.value_stats.max.must_equal 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.must_be_close_to( 0.15, 0.01 )
-    @tm.value_stats.sum.must_equal 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.must_be_close_to(0.0075, 0.0005)
-    @tm.value_stats.sumsq.must_equal 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.must_be :>=, f1
-    @tm.sampling_start_time.must_be :<, 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).must_be :>, ( @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
@@ -107,56 +107,56 @@ describe Hitimes::TimedValueMetric do
     5.times { @tm.start ; sleep 0.05 ; @tm.stop( 1 ) }
     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
+    _(@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).must_be :<, ( @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.running?.must_equal true
+    _(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.must_be_close_to(0.15, 0.004)
-    t.timed_stats.count.must_equal 3
-    t.value_stats.count.must_equal 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.must_be_close_to(0.05, 0.002)
-    x.must_equal 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'].must_equal "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'].must_equal Hash.new
-      h['additional_data'].size.must_equal 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'].must_be_close_to(40.0, 1.0)
+      _(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'].must_equal  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 ]
@@ -164,7 +164,7 @@ describe Hitimes::TimedValueMetric do
       it "has a value for #{f}" do
         3.times { |x| @tm.measure(x) { sleep 0.001 } }
         h = @tm.to_hash
-        h[f].wont_be_nil
+        _(h[f]).wont_be_nil
       end
     end
   end 

data/spec/value_metric_spec.rb

@@ -7,50 +7,50 @@ describe Hitimes::ValueMetric do
   end
 
   it 'has a name' do
-    @metric.name.must_equal "testing"
+    _(@metric.name).must_equal "testing"
   end
 
   it "has associated data from initialization" do
     m = Hitimes::ValueMetric.new( "more-data", 'foo' => 'bar', 'this' => 'that' )
-    m.additional_data['foo'].must_equal 'bar'
-    m.additional_data['this'].must_equal 'that'
+    _(m.additional_data['foo']).must_equal 'bar'
+    _(m.additional_data['this']).must_equal 'that'
     
     m = Hitimes::ValueMetric.new( "more-data", { 'foo' => 'bar', 'this' => 'that' } )
-    m.additional_data['foo'].must_equal 'bar'
-    m.additional_data['this'].must_equal 'that'
+    _(m.additional_data['foo']).must_equal 'bar'
+    _(m.additional_data['this']).must_equal 'that'
   end
 
   it "calculates the mean of the measurements" do
-    @metric.mean.must_equal 4.5
+    _(@metric.mean).must_equal 4.5
   end
 
   it "calculates the stddev of the measurements" do
-    @metric.stddev.must_be :>, 0.0
+    _(@metric.stddev).must_be :>, 0.0
   end
 
   it "returns 0.0 for stddev if there is no data" do
     m = Hitimes::ValueMetric.new('0-data')
-    m.stddev.must_equal 0.0
+    _(m.stddev).must_equal 0.0
   end
 
   it "keeps track of the sum of data" do
-    @metric.sum.must_equal 45.0
+    _(@metric.sum).must_equal 45.0
   end
 
   it "keeps track of the sum of squars of data" do
-    @metric.sumsq.must_equal 285.0
+    _(@metric.sumsq).must_equal 285.0
   end
 
   it "retuns 0.0 for mean if there is no data" do
-    Hitimes::ValueMetric.new('0-data').mean.must_equal 0.0
+    _(Hitimes::ValueMetric.new('0-data').mean).must_equal 0.0
   end
 
   it "keeps track of the min value" do
-    @metric.min.must_equal 0
+    _(@metric.min).must_equal 0
   end
 
   it "keeps track of the max value" do
-    @metric.max.must_equal 9
+    _(@metric.max).must_equal 9
   end
 
   it "keeps track of the first start time of all the measurements" do
@@ -58,11 +58,11 @@ describe Hitimes::ValueMetric do
     f1 = Time.now.gmtime.to_f * 1_000_000
     10.times{ |x| m.measure( x ); sleep 0.1 }
     f2 = Time.now.gmtime.to_f * 1_000_000
-    m.sampling_start_time.must_be :>=, f1
-    m.sampling_start_time.must_be :<, f2
+    _(m.sampling_start_time).must_be :>=, f1
+    _(m.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 - m.sampling_start_time).must_be :>, ( m.sampling_start_time - f1 )
+    _((f2 - m.sampling_start_time)).must_be :>, ( m.sampling_start_time - f1 )
   end
 
   it "keeps track of the last stop time of all the intervals" do
@@ -70,29 +70,29 @@ describe Hitimes::ValueMetric do
     f1 = Time.now.gmtime.to_f * 1_000_000
     10.times {|x| m.measure( x ); sleep 0.1  }
     f2 = Time.now.gmtime.to_f * 1_000_000
-    m.sampling_stop_time.must_be :>, f1
-    m.sampling_stop_time.must_be :<=, f2
+    _(m.sampling_stop_time).must_be :>, f1
+    _(m.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 - m.sampling_stop_time).must_be :<, ( m.sampling_stop_time - f1 )
+    _((f2 - m.sampling_stop_time)).must_be :<, ( m.sampling_stop_time - f1 )
   end
 
   describe "#to_hash" do
 
     it "has name value" do
       h = @metric.to_hash
-      h['name'].must_equal "testing"
+      _(h['name']).must_equal "testing"
     end
 
     it "has an empty has for additional_data" do
       h = @metric.to_hash
-      h['additional_data'].must_equal Hash.new
-      h['additional_data'].size.must_equal 0
+      _(h['additional_data']).must_equal Hash.new
+      _(h['additional_data'].size).must_equal 0
     end
 
     it "has the right sum" do
       h = @metric.to_hash
-      h['sum'].must_equal 45
+      _(h['sum']).must_equal 45
     end
 
     fields = ::Hitimes::Stats::STATS.dup + %w[ name additional_data sampling_start_time sampling_stop_time ]
@@ -100,7 +100,7 @@ describe Hitimes::ValueMetric do
     fields.each do |f|
       it "has a value for #{f}" do
         h = @metric.to_hash
-        h[f].wont_be_nil
+        _(h[f]).wont_be_nil
       end
     end
   end