hitimes 1.1.1-java → 1.2.0-java

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 ]

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
@@ -19,97 +17,98 @@ describe Hitimes::TimedValueMetric 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
+    d.should be > 0
+    @tm.value_stats.count.should be == 1
+    @tm.timed_stats.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( 1 ).should > 0
-    @tm.stop( 1 ).should == false
+    @tm.stop( 1 ).should be > 0
+    @tm.stop( 1 ).should be == 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.should be == 0
+    @tm.timed_stats.count.should be == 0
     @tm.split( 1 )
-    @tm.value_stats.count.should == 1
-    @tm.timed_stats.count.should == 1
+    @tm.value_stats.count.should be == 1
+    @tm.timed_stats.count.should be == 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 ).should be == 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.should be_within(0.01).of(0.05)
+    @tm.value_stats.mean.should be == 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.should be_within(1.0).of(40.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.should be_within(0.001).of(0.05)
+    @tm.value_stats.stddev.should be == 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.should be == 0.0
+    @tm.value_stats.stddev.should be == 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.should be_within( 0.003 ).of(0.05)
+    @tm.value_stats.min.should be == 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.should be_within(0.003).of( 0.05 )
+    @tm.value_stats.max.should be == 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.should be_within(0.01).of(0.15)
+    @tm.value_stats.sum.should be == 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.should be_within(0.0005).of(0.0075)
+    @tm.value_stats.sumsq.should be == 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.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 )
   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.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 )
@@ -123,41 +122,41 @@ describe Hitimes::TimedValueMetric do
   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.should be_within(0.004).of(0.15)
+    t.timed_stats.count.should be == 3
+    t.value_stats.count.should be == 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.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-value-metric"
+      h['name'].should be == "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'].should be == Hash.new
+      h['additional_data'].size.should be == 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'].should be_within(1.0  ).of(40.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'].should be ==  10
     end
 
     fields = %w[ name additional_data sampling_start_time sampling_stop_time value_stats timed_stats rate unit_count ]

data/spec/value_metric_spec.rb

@@ -1,6 +1,4 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
-
-require 'hitimes/value_metric'
+require 'spec_helper'
 
 describe Hitimes::ValueMetric do
   before( :each ) do
@@ -9,21 +7,21 @@ describe Hitimes::ValueMetric 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::ValueMetric.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::ValueMetric.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 "calculates the mean of the measurements" do
-    @metric.mean.should == 4.5
+    @metric.mean.should be == 4.5
   end
 
   it "calculates the stddev of the measurements" do
@@ -32,27 +30,27 @@ describe Hitimes::ValueMetric do
 
   it "returns 0.0 for stddev if there is no data" do
     m = Hitimes::ValueMetric.new('0-data')
-    m.stddev.should == 0.0
+    m.stddev.should be == 0.0
   end
 
   it "keeps track of the sum of data" do
-    @metric.sum.should == 45.0
+    @metric.sum.should be == 45.0
   end
 
   it "keeps track of the sum of squars of data" do
-    @metric.sumsq.should == 285.0
+    @metric.sumsq.should be == 285.0
   end
 
   it "retuns 0.0 for mean if there is no data" do
-    Hitimes::ValueMetric.new('0-data').mean.should == 0.0
+    Hitimes::ValueMetric.new('0-data').mean.should be == 0.0
   end
 
   it "keeps track of the min value" do
-    @metric.min.should == 0
+    @metric.min.should be == 0
   end
 
   it "keeps track of the max value" do
-    @metric.max.should == 9
+    @metric.max.should be == 9
   end
 
   it "keeps track of the first start time of all the measurements" do
@@ -60,8 +58,8 @@ 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.should >= f1
-    m.sampling_start_time.should < f2
+    m.sampling_start_time.should be >= f1
+    m.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 - m.sampling_start_time).should > ( m.sampling_start_time - f1 )
@@ -72,8 +70,8 @@ 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.should > f1
-    m.sampling_stop_time.should <= f2
+    m.sampling_stop_time.should be > f1
+    m.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 - m.sampling_stop_time).should < ( m.sampling_stop_time - f1 )
@@ -83,18 +81,18 @@ describe Hitimes::ValueMetric do
 
     it "has name value" do
       h = @metric.to_hash
-      h['name'].should == "testing"
+      h['name'].should be == "testing"
     end
 
     it "has an empty has for additional_data" do
       h = @metric.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
       h = @metric.to_hash
-      h['sum'].should == 45
+      h['sum'].should be == 45
     end
 
     fields = ::Hitimes::Stats::STATS.dup + %w[ name additional_data sampling_start_time sampling_stop_time ]