rcov 0.8.1.2.0 → 0.9.3

data/lib/rcov/version.rb

@@ -1,13 +1,10 @@
 # rcov Copyright (c) 2004-2006 Mauricio Fernandez <mfp@acm.org>
 #
-# See LEGAL and LICENSE for licensing information.
+# See LICENSE for licensing information.
 
 module Rcov
-
-VERSION = "0.8.1.2"
-RELEASE_DATE = "2007-11-22"
-RCOVRT_ABI = [2,0,0]
-UPSTREAM_URL = "http://eigenclass.org/hiki/rcov"
-
+  VERSION = "0.9.3"
+  RELEASE_DATE = "2009-09-25"
+  RCOVRT_ABI = [2,0,0]
+  UPSTREAM_URL = "http://github.com/relevance/rcov"
 end
-# vi: set sw=2:

data/setup.rb

@@ -1255,7 +1255,7 @@ class Installer
   alias setup_dir_lib noop
 
   def setup_dir_ext(rel)
-    make if extdir?(curr_srcdir())
+    make if extdir?(curr_srcdir()) and File.exist?("#{curr_srcdir()}/Makefile")
   end
 
   alias setup_dir_data noop
@@ -1288,7 +1288,10 @@ class Installer
     if /\Aruby/ =~ File.basename(old.cmd)
       Shebang.new(config('rubypath'), old.args)
     elsif File.basename(old.cmd) == 'env' and old.args.first == 'ruby'
-      Shebang.new(config('rubypath'), old.args[1..-1])
+      puts "Skipping shebang rename"
+      # We don't want this to happen anymore, it doesn't make sense
+      # Shebang.new(config('rubypath'), old.args[1..-1])
+      old
     else
       return old unless config('shebang') == 'all'
       Shebang.new(config('rubypath'))

data/test/{test_CallSiteAnalyzer.rb → call_site_analyzer_test.rb}

@@ -1,11 +1,8 @@
+require File.dirname(__FILE__) + '/test_helper'
 
+class TestCallSiteAnalyzer < Test::Unit::TestCase
 
-require 'test/unit'
-require 'rcov'
-
-class Test_CallSiteAnalyzer < Test::Unit::TestCase
-
-  sample_file = File.join(File.dirname(__FILE__), "sample_03.rb")
+  sample_file = File.join(File.dirname(__FILE__), "assets/sample_03.rb")
   load sample_file
 
   def setup
@@ -14,40 +11,54 @@ class Test_CallSiteAnalyzer < Test::Unit::TestCase
   end
 
   def verify_callsites_equal(expected, actual)
-    callsites = expected.inject({}) do |s,(backtrace, count)| 
+    callsites = expected.inject({}) do |s,(backtrace, count)|
       unless $".any?{|x| %r{\brcovrt\b} =~ x}
         backtrace = backtrace.map{|_, mid, file, line| [nil, mid, file, line] }
       end
+      backtrace[0][2] = File.expand_path(backtrace[0][2])
       s[Rcov::CallSiteAnalyzer::CallSite.new(backtrace)] = count
       s
     end
-    assert_equal(callsites, actual)
+    
+    act_callsites = actual.inject({}) do |s, (key, value)|
+      #wow thats obtuse.  In a callsite we have an array of arrays.  We have to deep copy them because
+      # if we muck with the actual backtrace it messes things up for accumulation type tests.
+      # we have to muck with backtrace so that we can normalize file names (it's an issue between MRI and JRuby)
+      backtrace = key.backtrace.inject([]) {|y, val| y << val.inject([]) {|z, v2| z<< v2}}
+      backtrace[0][2] = File.expand_path(key.backtrace[0][2])
+      s[Rcov::CallSiteAnalyzer::CallSite.new(backtrace)] = value
+      s
+    end
+    assert_equal(callsites.to_s, act_callsites.to_s)
   end
 
   def verify_defsite_equal(expected, actual)
-    assert_equal(Rcov::CallSiteAnalyzer::DefSite.new(*expected), actual)
+    defsite = Rcov::CallSiteAnalyzer::DefSite.new(*expected)
+    defsite.file = File.expand_path defsite.file
+    actual.file = File.expand_path actual.file
+    assert_equal(defsite.to_s, actual.to_s)
   end
 
   def test_callsite_compute_raw_difference
-    src = [ 
+    src = [
             { ["Foo", "foo"] => {"bar" => 1},
-              ["Foo", "bar"] => {"baz" => 10} }, 
-            { ["Foo", "foo"] => ["foo.rb", 10] } 
+              ["Foo", "bar"] => {"baz" => 10} },
+            { ["Foo", "foo"] => ["foo.rb", 10] }
           ]
-    dst = [ 
+    dst = [
             { ["Foo", "foo"] => {"bar" => 1, "fubar" => 10},
               ["Foo", "baz"] => {"baz" => 10} },
             { ["Foo", "foo"] => ["fooredef.rb", 10],
               ["Foo", "baz"] => ["foo.rb", 20]}
           ]
-    expected = [ 
+    expected = [
                  { ["Foo", "foo"] => {"fubar" => 10},
                    ["Foo", "baz"] => {"baz"   => 10} },
                  { ["Foo", "foo"] => ["fooredef.rb", 10],
-                   ["Foo", "baz"] => ["foo.rb", 20] } 
+                   ["Foo", "baz"] => ["foo.rb", 20] }
     ]
-               
-    assert_equal(expected, 
+
+    assert_equal(expected,
                  @a.instance_eval{ compute_raw_data_difference(src, dst) } )
   end
 
@@ -62,55 +73,40 @@ class Test_CallSiteAnalyzer < Test::Unit::TestCase
 
   def test_basic_defsite_recording
     @a.run_hooked{ @o.f1 }
-    verify_defsite_equal(["./test/sample_03.rb", 3], 
-                 @a.defsite("Rcov::Test::Temporary::Sample03", "f1"))
-    verify_defsite_equal(["./test/sample_03.rb", 7], 
-                 @a.defsite("Rcov::Test::Temporary::Sample03", "f2"))
-    verify_defsite_equal(["./test/sample_03.rb", 7], 
-                 @a.defsite("Rcov::Test::Temporary::Sample03#f2"))
+    verify_defsite_equal(["./test/assets/sample_03.rb", 3], @a.defsite("Rcov::Test::Temporary::Sample03", "f1"))
+    verify_defsite_equal(["./test/assets/sample_03.rb", 7], @a.defsite("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_defsite_equal(["./test/assets/sample_03.rb", 7], @a.defsite("Rcov::Test::Temporary::Sample03#f2"))
   end
 
   def test_basic_callsite_recording
     @a.run_hooked{ @o.f1 }
     assert(@a.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
     assert_equal(%w[f1 f2], @a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/sample_03.rb", 4]] => 10}, 
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/sample_03.rb", 4]] => 10}, 
-                 @a.callsites("Rcov::Test::Temporary::Sample03#f2"))
-    #verify_callsites_equal({["./test/sample_03.rb:4:in `f1'"] => 10}, 
-    #             @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
-    #verify_callsites_equal({["./test/sample_03.rb:4:in `f1'"] => 10}, 
-    #             @a.callsites("Rcov::Test::Temporary::Sample03#f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03#f2"))
   end
 
   def test_basic_callsite_recording_API
     @a.run_hooked{ @o.f1 }
     assert(@a.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
     assert_equal(%w[f1 f2], @a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, 
-                              "./test/sample_03.rb", 4]] => 10}, 
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/sample_03.rb", 4]] => 10}, 
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
     callsites = @a.callsites("Rcov::Test::Temporary::Sample03", "f2")
     callsite = callsites.keys[0]
-    assert_equal("./test/sample_03.rb", callsite.file)
+    #expand path is used here to compensate for differences between JRuby and MRI
+    assert_equal(File.expand_path("./test/assets/sample_03.rb"), File.expand_path(callsite.file))
     assert_equal(4, callsite.line)
     assert_equal(:f1, callsite.calling_method)
   end
-  
-  
+
+
   def test_basic_callsite_recording_with_singleton_classes
     @a.run_hooked{ @o.class.g1 }
     assert(@a.analyzed_classes.include?("#<Class:Rcov::Test::Temporary::Sample03>"))
     assert_equal(%w[g1 g2], @a.analyzed_methods("#<Class:Rcov::Test::Temporary::Sample03>"))
-    verify_callsites_equal({[[class << Rcov::Test::Temporary::Sample03; self end, 
-                             :g1, "./test/sample_03.rb", 15]] => 10}, 
-                 @a.callsites("Rcov::Test::Temporary::Sample03.g2"))
-    verify_callsites_equal({[[class << Rcov::Test::Temporary::Sample03; self end,
-                              :g1, "./test/sample_03.rb", 15]] => 10}, 
-                 @a.callsites("#<Class:Rcov::Test::Temporary::Sample03>","g2"))
+    verify_callsites_equal({[[class << Rcov::Test::Temporary::Sample03; self end, :g1, "./test/assets/sample_03.rb", 15]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03.g2"))
+    verify_callsites_equal({[[class << Rcov::Test::Temporary::Sample03; self end, :g1, "./test/assets/sample_03.rb", 15]] => 10}, @a.callsites("#<Class:Rcov::Test::Temporary::Sample03>","g2"))
   end
 
 
@@ -118,24 +114,17 @@ class Test_CallSiteAnalyzer < Test::Unit::TestCase
     @a.run_hooked{ @o.f1 }
     assert(@a.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
     assert_equal(%w[f1 f2], @a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                              "./test/sample_03.rb", 4]] => 10}, 
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
 
     @a.run_hooked{ @o.f1 }
     assert(@a.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
     assert_equal(%w[f1 f2], @a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                              "./test/sample_03.rb", 4]] => 20}, 
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
-    
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 20}, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+
     @a.run_hooked{ @o.f3 }
     assert_equal(%w[f1 f2 f3], @a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, 
-                              "./test/sample_03.rb", 4]] => 120,
-                  [[Rcov::Test::Temporary::Sample03, :f3, 
-                    "./test/sample_03.rb", 11]]=>100 },
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 120, 
+                            [[Rcov::Test::Temporary::Sample03, :f3, "./test/assets/sample_03.rb", 11]] => 100 }, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
   end
 
   def test_reset
@@ -146,50 +135,37 @@ class Test_CallSiteAnalyzer < Test::Unit::TestCase
     end
     assert(@a.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
     assert_equal(%w[f1 f2], @a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, 
-                              "./test/sample_03.rb", 4]] => 10}, 
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
-
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
   end
 
   def test_nested_callsite_recording
     a = Rcov::CallSiteAnalyzer.new
     b = Rcov::CallSiteAnalyzer.new
-    a.run_hooked do 
+    a.run_hooked do
       b.run_hooked { @o.f1 }
       assert(b.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
       assert_equal(%w[f1 f2], b.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-      verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                                "./test/sample_03.rb", 4]] => 10}, 
-                   b.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+      verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, b.callsites("Rcov::Test::Temporary::Sample03", "f2"))
 
       @o.f1
       assert_equal(%w[f1 f2], b.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-      verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                                "./test/sample_03.rb", 4]] => 10}, 
-                   b.callsites("Rcov::Test::Temporary::Sample03", "f2"))
-      
+      verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, b.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+
       assert(a.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
       assert_equal(%w[f1 f2], a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-      verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                                "./test/sample_03.rb", 4]] => 20}, 
-                   a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+      verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 20}, a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
     end
+    
     b.run_hooked{ @o.f3 }
     assert_equal(%w[f1 f2 f3], b.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, 
-                              "./test/sample_03.rb", 4]] => 110,
-                  [[Rcov::Test::Temporary::Sample03, :f3,
-                    "./test/sample_03.rb", 11]]=>100 },
-                 b.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 110,
+                            [[Rcov::Test::Temporary::Sample03, :f3, "./test/assets/sample_03.rb", 11]]=>100 }, b.callsites("Rcov::Test::Temporary::Sample03", "f2"))
   end
 
   def test_expand_name
     assert_equal(["Foo", "foo"], @a.instance_eval{ expand_name("Foo#foo") })
     assert_equal(["Foo", "foo"], @a.instance_eval{ expand_name("Foo", "foo") })
-    assert_equal(["#<Class:Foo>", "foo"], 
-                 @a.instance_eval{ expand_name("Foo.foo") })
-    assert_equal(["#<Class:Foo>", "foo"], 
-                 @a.instance_eval{ expand_name("#<Class:Foo>", "foo") })
+    assert_equal(["#<Class:Foo>", "foo"], @a.instance_eval{ expand_name("Foo.foo") })
+    assert_equal(["#<Class:Foo>", "foo"], @a.instance_eval{ expand_name("#<Class:Foo>", "foo") })
   end
 end

data/test/{test_CodeCoverageAnalyzer.rb → code_coverage_analyzer_test.rb}

@@ -1,9 +1,7 @@
+require File.dirname(__FILE__) + '/test_helper'
 
-require 'test/unit'
-require 'rcov'
-
-class Test_CodeCoverageAnalyzer < Test::Unit::TestCase
-    LINES = <<-EOF.to_a
+class TestCodeCoverageAnalyzer < Test::Unit::TestCase
+  LINES = <<-EOF.split "\n"
 puts 1
 if foo
   bar
@@ -26,7 +24,7 @@ EOF
   def test_refine_coverage_info
     analyzer = Rcov::CodeCoverageAnalyzer.new
     cover = [1, 1, nil, nil, 0, 5, 5, 5, 0]
-    line_info, marked_info, 
+    line_info, marked_info,
       count_info = analyzer.instance_eval{ refine_coverage_info(LINES, cover) }
     assert_equal(LINES, line_info)
     assert_equal([true] * 2 + [false] * 3 + [true] * 3 + [false], marked_info)
@@ -39,17 +37,19 @@ EOF
   end
 
   def test_raw_coverage_info
-    sample_file = File.join(File.dirname(__FILE__), "sample_01.rb")
+    sample_file = File.join(File.dirname(__FILE__), "assets/sample_01.rb")
     lines = File.readlines(sample_file)
     analyzer = Rcov::CodeCoverageAnalyzer.new
     analyzer.run_hooked{ load sample_file }
-    
+
     assert_equal(lines, SCRIPT_LINES__[sample_file][0, lines.size])
     assert(analyzer.analyzed_files.include?(sample_file))
     line_info, cov_info, count_info = analyzer.data(sample_file)
     assert_equal(lines, line_info)
     assert_equal([true, true, false, false, true, false, true], cov_info)
-    assert_equal([1, 2, 0, 0, 1, 0, 11], count_info)
+    assert_equal([1, 2, 0, 0, 1, 0, 11], count_info) unless RUBY_PLATFORM =~ /java/
+    # JRUBY reports an if x==blah as hitting this type of line once, JRUBY also optimizes this stuff so you'd have to run with --debug to get "extra" information.  MRI hits it twice.
+    assert_equal([1, 3, 0, 0, 1, 0, 33], count_info) if RUBY_PLATFORM =~ /java/
     analyzer.reset
     assert_equal(nil, analyzer.data(sample_file))
     assert_equal([], analyzer.analyzed_files)
@@ -60,10 +60,10 @@ EOF
     lines = ["puts a", "foo", "bar"] * 3
     coverage = [true] * 3 + [false] * 6
     counts = [1] * 3 + [0] * 6
-    nlines, ncoverage, ncounts = analyzer.instance_eval do 
+    nlines, ncoverage, ncounts = analyzer.instance_eval do
       script_lines_workaround(lines, coverage, counts)
     end
-   
+
     assert_equal(["puts a", "foo", "bar"], nlines)
     assert_equal([true, true, true], ncoverage)
     assert_equal([1, 1, 1], ncounts)
@@ -74,7 +74,7 @@ EOF
     lines = ["puts a", "foo", "bar"] * 2 + ["puts a", "foo", "baz"]
     coverage = [true] * 9
     counts = [1] * 9
-    nlines, ncoverage, ncounts = analyzer.instance_eval do 
+    nlines, ncoverage, ncounts = analyzer.instance_eval do
       script_lines_workaround(lines, coverage, counts)
     end
     assert_equal(lines, nlines)
@@ -82,55 +82,85 @@ EOF
     assert_equal(counts, ncounts)
   end
 
+  def test_if_elsif_reports_correctly
+    sample_file = File.join(File.dirname(__FILE__), "assets/sample_06.rb")
+    lines = File.readlines(sample_file)
+    analyzer = Rcov::CodeCoverageAnalyzer.new
+    analyzer.run_hooked{ load sample_file }
+    assert_equal(lines, SCRIPT_LINES__[sample_file][0, lines.size])
+    assert(analyzer.analyzed_files.include?(sample_file))
+    line_info, cov_info, count_info = analyzer.data(sample_file)
+    assert_equal(lines, line_info)
+    assert_equal([true, true, false, true, true, false, false, false], cov_info) unless RUBY_PLATFORM == "java"
+  end
+
   def test_differential_coverage_data
-    sample_file = File.join(File.dirname(__FILE__), "sample_01.rb")
+    sample_file = File.join(File.dirname(__FILE__), "assets/sample_01.rb")
     lines = File.readlines(sample_file)
     analyzer = Rcov::CodeCoverageAnalyzer.new
     analyzer.run_hooked{ load sample_file }
     line_info, cov_info, count_info = analyzer.data(sample_file)
-    assert_equal([1, 2, 0, 0, 1, 0, 11], count_info)
-    
+    assert_equal([1, 2, 0, 0, 1, 0, 11], count_info) if RUBY_VERSION =~ /1.9/
+
     analyzer.reset
-    
-    sample_file = File.join(File.dirname(__FILE__), "sample_02.rb")
+    #set_trace_func proc { |event, file, line, id, binding, classname| printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname if (file =~ /sample_02.rb/) }     
+
+    sample_file = File.join(File.dirname(__FILE__), "assets/sample_02.rb")
     analyzer.run_hooked{ load sample_file }
     line_info, cov_info, count_info = analyzer.data(sample_file)
-    assert_equal([8, 1, 0, 0, 0], count_info)
-    
+    if RUBY_PLATFORM == "java"
+      assert_equal([8, 3, 0, 0, 0], count_info) 
+    else
+      assert_equal([8, 1, 0, 0, 0], count_info) unless  RUBY_VERSION =~ /1.9/
+      assert_equal([4, 1, 0, 0, 4], count_info) if RUBY_VERSION =~ /1.9/
+    end
+
     analyzer.reset
     assert_equal([], analyzer.analyzed_files)
     analyzer.run_hooked{ Rcov::Test::Temporary::Sample02.foo(1, 1) }
     line_info, cov_info, count_info = analyzer.data(sample_file)
-    assert_equal([0, 1, 1, 1, 0], count_info)
-    analyzer.run_hooked do 
+    if RUBY_PLATFORM == "java"
+      assert_equal([0, 1, 3, 1, 0], count_info) unless RUBY_VERSION =~ /1.9/
+    else
+      assert_equal([0, 1, 1, 1, 0], count_info) unless RUBY_VERSION =~ /1.9/
+      assert_equal([0, 2, 1, 0, 0], count_info) if RUBY_VERSION =~ /1.9/
+    end
+    analyzer.run_hooked do
       10.times{ Rcov::Test::Temporary::Sample02.foo(1, 1) }
     end
     line_info, cov_info, count_info = analyzer.data(sample_file)
-    assert_equal([0, 11, 11, 11, 0], count_info)
+    assert_equal([0, 11, 33, 11, 0], count_info) if RUBY_PLATFORM == "java"
+    assert_equal([0, 11, 11, 11, 0], count_info) unless RUBY_PLATFORM == "java"
     10.times{ analyzer.run_hooked{ Rcov::Test::Temporary::Sample02.foo(1, 1) } }
     line_info, cov_info, count_info = analyzer.data(sample_file)
-    assert_equal([0, 21, 21, 21, 0], count_info)
+    assert_equal([0, 21, 63, 21, 0], count_info) if RUBY_PLATFORM == "java"
+    assert_equal([0, 21, 21, 21, 0], count_info) unless RUBY_PLATFORM == "java"
 
     count_info2 = nil
     10.times do |i|
-      analyzer.run_hooked do 
+      analyzer.run_hooked do
         Rcov::Test::Temporary::Sample02.foo(1, 1)
         line_info, cov_info, count_info = analyzer.data(sample_file) if i == 3
         line_info2, cov_info2, count_info2 = analyzer.data(sample_file)
       end
     end
-    assert_equal([0, 25, 25, 25, 0], count_info)
-    assert_equal([0, 31, 31, 31, 0], count_info2)
+    if RUBY_PLATFORM == "java"
+      assert_equal([0, 25, 75, 25, 0], count_info)
+      assert_equal([0, 31, 93, 31, 0], count_info2)
+    else
+      assert_equal([0, 25, 25, 25, 0], count_info)
+      assert_equal([0, 31, 31, 31, 0], count_info2)
+    end
   end
 
   def test_nested_analyzer_blocks
     a1 = Rcov::CodeCoverageAnalyzer.new
     a2 = Rcov::CodeCoverageAnalyzer.new
 
-    sample_file = File.join(File.dirname(__FILE__), "sample_02.rb")
+    sample_file = File.join(File.dirname(__FILE__), "assets/sample_02.rb")
     load sample_file
-    
-    a1.run_hooked do 
+
+    a1.run_hooked do
       100.times{ Rcov::Test::Temporary::Sample02.foo(1, 1) }
       a2.run_hooked do
         10.times{ Rcov::Test::Temporary::Sample02.foo(1, 1) }
@@ -153,16 +183,21 @@ EOF
 
     _, _, counts1 = a1.data(sample_file)
     _, _, counts2 = a2.data(sample_file)
-    assert_equal([0, 221, 221, 221, 0], counts1)
-    assert_equal([0, 121, 121, 121, 0], counts2)
+    if RUBY_PLATFORM == "java"
+      assert_equal([0, 221, 663, 221, 0], counts1)    
+      assert_equal([0, 121, 363, 121, 0], counts2)
+    else
+      assert_equal([0, 221, 221, 221, 0], counts1)
+      assert_equal([0, 121, 121, 121, 0], counts2)
+    end
   end
 
   def test_reset
     a1 = Rcov::CodeCoverageAnalyzer.new
 
-    sample_file = File.join(File.dirname(__FILE__), "sample_02.rb")
+    sample_file = File.join(File.dirname(__FILE__), "assets/sample_02.rb")
     load sample_file
-
+    
     a1.run_hooked do
       100.times do |i|
         Rcov::Test::Temporary::Sample02.foo(1, 1)
@@ -170,14 +205,15 @@ EOF
       end
     end
 
-    assert_equal([0, 50, 50, 50, 0], a1.data(sample_file)[2])
+    assert_equal([0, 50, 50, 50, 0], a1.data(sample_file)[2]) unless RUBY_PLATFORM == "java"
+    assert_equal([0, 50, 150, 50, 0], a1.data(sample_file)[2]) if RUBY_PLATFORM == "java"
   end
 
   def test_compute_raw_difference
     first = {"a" => [1,1,1,1,1]}
     last =  {"a" => [2,1,5,2,1], "b" => [1,2,3,4,5]}
     a = Rcov::CodeCoverageAnalyzer.new
-    assert_equal({"a" => [1,0,4,1,0], "b" => [1,2,3,4,5]}, 
+    assert_equal({"a" => [1,0,4,1,0], "b" => [1,2,3,4,5]},
                  a.instance_eval{ compute_raw_data_difference(first, last)} )
   end
 end