rcov 0.9.11 → 1.0.0

data/test/assets/sample_01.rb

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

data/test/assets/sample_02.rb

@@ -1,5 +0,0 @@
-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

@@ -1,20 +0,0 @@
-
-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

@@ -1,10 +0,0 @@
-$: << 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

@@ -1,17 +0,0 @@
-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

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

data/test/assets/sample_05.rb

@@ -1,17 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,171 +0,0 @@
-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

@@ -1,220 +0,0 @@
-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, 13], 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