katsuya-rcov 0.9.7.1

data/test/assets/sample_01.rb

@@ -0,0 +1,7 @@
+a = 1
+if a == 2
+  b = 1
+else
+  b = 2
+end
+10.times{ b += 1 }

data/test/assets/sample_02.rb

@@ -0,0 +1,5 @@
+module Rcov; module Test; module Temporary; module Sample02
+  def self.foo(a,b)
+    a + b
+  end
+end end end end

data/test/assets/sample_03.rb

@@ -0,0 +1,20 @@
+
+module Rcov; module Test; module Temporary; class Sample03
+  def f1                # MUST NOT CHANGE the position or the tests will break
+    10.times { f2 }
+  end
+
+  def f2; 1 end
+
+  def f3
+    10.times{ f1 }
+    100.times{ f2 }
+  end                   
+  
+  def self.g1
+    10.times{ g2 }
+  end
+
+  def self.g2; 1 end
+  # safe from here ...
+end end end end

data/test/assets/sample_04.rb

@@ -0,0 +1,10 @@
+$: << File.dirname(__FILE__)
+require 'sample_03'
+
+klass = Rcov::Test::Temporary::Sample03
+obj = klass.new
+obj.f1
+obj.f2
+obj.f3
+#klass.g1 uncovered
+klass.g2

data/test/assets/sample_05-new.rb

@@ -0,0 +1,17 @@
+def d(x)
+  4*x
+end
+
+def a
+  b 10
+end
+
+def b(x)
+  x*10
+end
+
+def c(x)
+  3*x
+end
+
+a()

data/test/assets/sample_05-old.rb

@@ -0,0 +1,13 @@
+def a
+  b 10
+end
+
+def b(x)
+  x*10
+end
+
+def c(x)
+  3*x
+end
+
+a()

data/test/assets/sample_05.rb

@@ -0,0 +1,17 @@
+def d(x)
+  4*x
+end
+
+def a
+  b 10
+end
+
+def b(x)
+  x*10
+end
+
+def c(x)
+  3*x
+end
+
+a()

data/test/assets/sample_06.rb

@@ -0,0 +1,8 @@
+x = 2
+if x.nil?
+ x = 4
+elsif x == 2
+ x = x*x
+else
+  x = x+4
+end

data/test/call_site_analyzer_test.rb

@@ -0,0 +1,171 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TestCallSiteAnalyzer < Test::Unit::TestCase
+
+  sample_file = File.join(File.dirname(__FILE__), "assets/sample_03.rb")
+  load sample_file
+
+  def setup
+    @a = Rcov::CallSiteAnalyzer.new
+    @o = Rcov::Test::Temporary::Sample03.new
+  end
+
+  def verify_callsites_equal(expected, actual)
+    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
+    
+    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)
+    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 = [
+            { ["Foo", "foo"] => {"bar" => 1},
+              ["Foo", "bar"] => {"baz" => 10} },
+            { ["Foo", "foo"] => ["foo.rb", 10] }
+          ]
+    dst = [
+            { ["Foo", "foo"] => {"bar" => 1, "fubar" => 10},
+              ["Foo", "baz"] => {"baz" => 10} },
+            { ["Foo", "foo"] => ["fooredef.rb", 10],
+              ["Foo", "baz"] => ["foo.rb", 20]}
+          ]
+    expected = [
+                 { ["Foo", "foo"] => {"fubar" => 10},
+                   ["Foo", "baz"] => {"baz"   => 10} },
+                 { ["Foo", "foo"] => ["fooredef.rb", 10],
+                   ["Foo", "baz"] => ["foo.rb", 20] }
+    ]
+
+    assert_equal(expected,
+                 @a.instance_eval{ compute_raw_data_difference(src, dst) } )
+  end
+
+  def test_return_values_when_no_match
+    @a.run_hooked{ @o.f1 }
+    assert_equal(nil, @a.defsite("Foobar#bogus"))
+    assert_equal(nil, @a.defsite("Foobar", "bogus"))
+    assert_equal(nil, @a.callsites("Foobar", "bogus"))
+    assert_equal(nil, @a.callsites("Foobar.bogus"))
+    assert_equal(nil, @a.callsites("<Class:Foobar>", "bogus"))
+  end
+
+  def test_basic_defsite_recording
+    @a.run_hooked{ @o.f1 }
+    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/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/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]
+    #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/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
+
+
+  def test_differential_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/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/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/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
+    @a.run_hooked do
+      10.times{ @o.f1 }
+      @a.reset
+      @o.f1
+    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/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
+      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/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/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/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/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") })
+  end
+end

data/test/code_coverage_analyzer_test.rb

@@ -0,0 +1,219 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TestCodeCoverageAnalyzer < Test::Unit::TestCase
+  LINES = <<-EOF.split "\n"
+puts 1
+if foo
+  bar
+  baz
+end
+5.times do
+  foo
+  bar if baz
+end
+EOF
+
+  def setup
+    if defined? Rcov::Test::Temporary
+      Rcov::Test::Temporary.constants.each do |name|
+        Rcov::Test::Temporary.module_eval{ remove_const(name) }
+      end
+    end
+  end
+
+  def test_refine_coverage_info
+    analyzer = Rcov::CodeCoverageAnalyzer.new
+    cover = [1, 1, nil, nil, 0, 5, 5, 5, 0]
+    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)
+    assert_equal([1, 1, 0, 0, 0, 5, 5, 5, 0], count_info)
+  end
+
+  def test_analyzed_files_no_analysis
+    analyzer = Rcov::CodeCoverageAnalyzer.new
+    assert_equal([], analyzer.analyzed_files)
+  end
+
+  def test_raw_coverage_info
+    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) 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)
+  end
+
+  def test_script_lines_workaround_detects_correctly
+    analyzer = Rcov::CodeCoverageAnalyzer.new
+    lines = ["puts a", "foo", "bar"] * 3
+    coverage = [true] * 3 + [false] * 6
+    counts = [1] * 3 + [0] * 6
+    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)
+  end
+
+  def test_script_lines_workaround_no_false_positives
+    analyzer = Rcov::CodeCoverageAnalyzer.new
+    lines = ["puts a", "foo", "bar"] * 2 + ["puts a", "foo", "baz"]
+    coverage = [true] * 9
+    counts = [1] * 9
+    nlines, ncoverage, ncounts = analyzer.instance_eval do
+      script_lines_workaround(lines, coverage, counts)
+    end
+    assert_equal(lines, nlines)
+    assert_equal(coverage, ncoverage)
+    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__), "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) if RUBY_VERSION =~ /1.9/
+
+    analyzer.reset
+    #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)
+    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)
+    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, 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, 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
+        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
+    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__), "assets/sample_02.rb")
+    load sample_file
+
+    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) }
+      end
+      100.times{ Rcov::Test::Temporary::Sample02.foo(1, 1) }
+    end
+
+    a2.run_hooked do
+      100.times{ Rcov::Test::Temporary::Sample02.foo(1, 1) }
+      10.times{ a1.run_hooked { Rcov::Test::Temporary::Sample02.foo(1, 1) } }
+    end
+
+    a1.install_hook
+    Rcov::Test::Temporary::Sample02.foo(1, 1)
+    a1.remove_hook
+
+    a2.install_hook
+    Rcov::Test::Temporary::Sample02.foo(1, 1)
+    a2.remove_hook
+
+    _, _, counts1 = a1.data(sample_file)
+    _, _, counts2 = a2.data(sample_file)
+    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__), "assets/sample_02.rb")
+    load sample_file
+    
+    a1.run_hooked do
+      100.times do |i|
+        Rcov::Test::Temporary::Sample02.foo(1, 1)
+        a1.reset if i == 49
+      end
+    end
+
+    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]},
+                 a.instance_eval{ compute_raw_data_difference(first, last)} )
+  end
+end