mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
0026f644d7
This commits adds in documentation to illustrate the different modes you can start coverage with. Examples are provided to show how to start each of these modes, along with an explanation of the mode and a description of the output.
488 lines
14 KiB
C
488 lines
14 KiB
C
/************************************************
|
|
|
|
coverage.c -
|
|
|
|
$Author: $
|
|
|
|
Copyright (c) 2008 Yusuke Endoh
|
|
|
|
************************************************/
|
|
|
|
#include "gc.h"
|
|
#include "internal/hash.h"
|
|
#include "internal/thread.h"
|
|
#include "internal/sanitizers.h"
|
|
#include "ruby.h"
|
|
#include "vm_core.h"
|
|
|
|
static int current_mode;
|
|
static VALUE me2counter = Qnil;
|
|
|
|
/*
|
|
* call-seq:
|
|
* Coverage.start => nil
|
|
*
|
|
* Enables coverage measurement.
|
|
*/
|
|
static VALUE
|
|
rb_coverage_start(int argc, VALUE *argv, VALUE klass)
|
|
{
|
|
VALUE coverages, opt;
|
|
int mode;
|
|
|
|
rb_scan_args(argc, argv, "01", &opt);
|
|
|
|
if (argc == 0) {
|
|
mode = 0; /* compatible mode */
|
|
}
|
|
else if (opt == ID2SYM(rb_intern("all"))) {
|
|
mode = COVERAGE_TARGET_LINES | COVERAGE_TARGET_BRANCHES | COVERAGE_TARGET_METHODS;
|
|
}
|
|
else {
|
|
mode = 0;
|
|
opt = rb_convert_type(opt, T_HASH, "Hash", "to_hash");
|
|
|
|
if (RTEST(rb_hash_lookup(opt, ID2SYM(rb_intern("lines")))))
|
|
mode |= COVERAGE_TARGET_LINES;
|
|
if (RTEST(rb_hash_lookup(opt, ID2SYM(rb_intern("branches")))))
|
|
mode |= COVERAGE_TARGET_BRANCHES;
|
|
if (RTEST(rb_hash_lookup(opt, ID2SYM(rb_intern("methods")))))
|
|
mode |= COVERAGE_TARGET_METHODS;
|
|
if (RTEST(rb_hash_lookup(opt, ID2SYM(rb_intern("oneshot_lines"))))) {
|
|
if (mode & COVERAGE_TARGET_LINES)
|
|
rb_raise(rb_eRuntimeError, "cannot enable lines and oneshot_lines simultaneously");
|
|
mode |= COVERAGE_TARGET_LINES;
|
|
mode |= COVERAGE_TARGET_ONESHOT_LINES;
|
|
}
|
|
}
|
|
|
|
if (mode & COVERAGE_TARGET_METHODS) {
|
|
me2counter = rb_ident_hash_new();
|
|
}
|
|
else {
|
|
me2counter = Qnil;
|
|
}
|
|
|
|
coverages = rb_get_coverages();
|
|
if (!RTEST(coverages)) {
|
|
coverages = rb_hash_new();
|
|
rb_obj_hide(coverages);
|
|
current_mode = mode;
|
|
if (mode == 0) mode = COVERAGE_TARGET_LINES;
|
|
rb_set_coverages(coverages, mode, me2counter);
|
|
}
|
|
else if (current_mode != mode) {
|
|
rb_raise(rb_eRuntimeError, "cannot change the measuring target during coverage measurement");
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
struct branch_coverage_result_builder
|
|
{
|
|
int id;
|
|
VALUE result;
|
|
VALUE children;
|
|
VALUE counters;
|
|
};
|
|
|
|
static int
|
|
branch_coverage_ii(VALUE _key, VALUE branch, VALUE v)
|
|
{
|
|
struct branch_coverage_result_builder *b = (struct branch_coverage_result_builder *) v;
|
|
|
|
VALUE target_label = RARRAY_AREF(branch, 0);
|
|
VALUE target_first_lineno = RARRAY_AREF(branch, 1);
|
|
VALUE target_first_column = RARRAY_AREF(branch, 2);
|
|
VALUE target_last_lineno = RARRAY_AREF(branch, 3);
|
|
VALUE target_last_column = RARRAY_AREF(branch, 4);
|
|
long counter_idx = FIX2LONG(RARRAY_AREF(branch, 5));
|
|
rb_hash_aset(b->children, rb_ary_new_from_args(6, target_label, LONG2FIX(b->id++), target_first_lineno, target_first_column, target_last_lineno, target_last_column), RARRAY_AREF(b->counters, counter_idx));
|
|
|
|
return ST_CONTINUE;
|
|
}
|
|
|
|
static int
|
|
branch_coverage_i(VALUE _key, VALUE branch_base, VALUE v)
|
|
{
|
|
struct branch_coverage_result_builder *b = (struct branch_coverage_result_builder *) v;
|
|
|
|
VALUE base_type = RARRAY_AREF(branch_base, 0);
|
|
VALUE base_first_lineno = RARRAY_AREF(branch_base, 1);
|
|
VALUE base_first_column = RARRAY_AREF(branch_base, 2);
|
|
VALUE base_last_lineno = RARRAY_AREF(branch_base, 3);
|
|
VALUE base_last_column = RARRAY_AREF(branch_base, 4);
|
|
VALUE branches = RARRAY_AREF(branch_base, 5);
|
|
VALUE children = rb_hash_new();
|
|
rb_hash_aset(b->result, rb_ary_new_from_args(6, base_type, LONG2FIX(b->id++), base_first_lineno, base_first_column, base_last_lineno, base_last_column), children);
|
|
b->children = children;
|
|
rb_hash_foreach(branches, branch_coverage_ii, v);
|
|
|
|
return ST_CONTINUE;
|
|
}
|
|
|
|
static VALUE
|
|
branch_coverage(VALUE branches)
|
|
{
|
|
VALUE structure = RARRAY_AREF(branches, 0);
|
|
|
|
struct branch_coverage_result_builder b;
|
|
b.id = 0;
|
|
b.result = rb_hash_new();
|
|
b.counters = RARRAY_AREF(branches, 1);
|
|
|
|
rb_hash_foreach(structure, branch_coverage_i, (VALUE)&b);
|
|
|
|
return b.result;
|
|
}
|
|
|
|
static int
|
|
method_coverage_i(void *vstart, void *vend, size_t stride, void *data)
|
|
{
|
|
/*
|
|
* ObjectSpace.each_object(Module){|mod|
|
|
* mod.instance_methods.each{|mid|
|
|
* m = mod.instance_method(mid)
|
|
* if loc = m.source_location
|
|
* p [m.name, loc, $g_method_cov_counts[m]]
|
|
* end
|
|
* }
|
|
* }
|
|
*/
|
|
VALUE ncoverages = *(VALUE*)data, v;
|
|
|
|
for (v = (VALUE)vstart; v != (VALUE)vend; v += stride) {
|
|
void *poisoned = asan_poisoned_object_p(v);
|
|
asan_unpoison_object(v, false);
|
|
|
|
if (RB_TYPE_P(v, T_IMEMO) && imemo_type(v) == imemo_ment) {
|
|
const rb_method_entry_t *me = (rb_method_entry_t *) v;
|
|
VALUE path, first_lineno, first_column, last_lineno, last_column;
|
|
VALUE data[5], ncoverage, methods;
|
|
VALUE methods_id = ID2SYM(rb_intern("methods"));
|
|
VALUE klass;
|
|
const rb_method_entry_t *me2 = rb_resolve_me_location(me, data);
|
|
if (me != me2) continue;
|
|
klass = me->owner;
|
|
if (RB_TYPE_P(klass, T_ICLASS)) {
|
|
rb_bug("T_ICLASS");
|
|
}
|
|
path = data[0];
|
|
first_lineno = data[1];
|
|
first_column = data[2];
|
|
last_lineno = data[3];
|
|
last_column = data[4];
|
|
if (FIX2LONG(first_lineno) <= 0) continue;
|
|
ncoverage = rb_hash_aref(ncoverages, path);
|
|
if (NIL_P(ncoverage)) continue;
|
|
methods = rb_hash_aref(ncoverage, methods_id);
|
|
|
|
{
|
|
VALUE method_id = ID2SYM(me->def->original_id);
|
|
VALUE rcount = rb_hash_aref(me2counter, (VALUE) me);
|
|
VALUE key = rb_ary_new_from_args(6, klass, method_id, first_lineno, first_column, last_lineno, last_column);
|
|
VALUE rcount2 = rb_hash_aref(methods, key);
|
|
|
|
if (NIL_P(rcount)) rcount = LONG2FIX(0);
|
|
if (NIL_P(rcount2)) rcount2 = LONG2FIX(0);
|
|
if (!POSFIXABLE(FIX2LONG(rcount) + FIX2LONG(rcount2))) {
|
|
rcount = LONG2FIX(FIXNUM_MAX);
|
|
}
|
|
else {
|
|
rcount = LONG2FIX(FIX2LONG(rcount) + FIX2LONG(rcount2));
|
|
}
|
|
rb_hash_aset(methods, key, rcount);
|
|
}
|
|
}
|
|
|
|
if (poisoned) {
|
|
asan_poison_object(v);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
coverage_peek_result_i(st_data_t key, st_data_t val, st_data_t h)
|
|
{
|
|
VALUE path = (VALUE)key;
|
|
VALUE coverage = (VALUE)val;
|
|
VALUE coverages = (VALUE)h;
|
|
if (current_mode == 0) {
|
|
/* compatible mode */
|
|
VALUE lines = rb_ary_dup(RARRAY_AREF(coverage, COVERAGE_INDEX_LINES));
|
|
rb_ary_freeze(lines);
|
|
coverage = lines;
|
|
}
|
|
else {
|
|
VALUE h = rb_hash_new();
|
|
|
|
if (current_mode & COVERAGE_TARGET_LINES) {
|
|
VALUE lines = RARRAY_AREF(coverage, COVERAGE_INDEX_LINES);
|
|
const char *kw = (current_mode & COVERAGE_TARGET_ONESHOT_LINES) ? "oneshot_lines" : "lines";
|
|
lines = rb_ary_dup(lines);
|
|
rb_ary_freeze(lines);
|
|
rb_hash_aset(h, ID2SYM(rb_intern(kw)), lines);
|
|
}
|
|
|
|
if (current_mode & COVERAGE_TARGET_BRANCHES) {
|
|
VALUE branches = RARRAY_AREF(coverage, COVERAGE_INDEX_BRANCHES);
|
|
rb_hash_aset(h, ID2SYM(rb_intern("branches")), branch_coverage(branches));
|
|
}
|
|
|
|
if (current_mode & COVERAGE_TARGET_METHODS) {
|
|
rb_hash_aset(h, ID2SYM(rb_intern("methods")), rb_hash_new());
|
|
}
|
|
|
|
coverage = h;
|
|
}
|
|
|
|
rb_hash_aset(coverages, path, coverage);
|
|
return ST_CONTINUE;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* Coverage.peek_result => hash
|
|
*
|
|
* Returns a hash that contains filename as key and coverage array as value.
|
|
* This is the same as `Coverage.result(stop: false, clear: false)`.
|
|
*
|
|
* {
|
|
* "file.rb" => [1, 2, nil],
|
|
* ...
|
|
* }
|
|
*/
|
|
static VALUE
|
|
rb_coverage_peek_result(VALUE klass)
|
|
{
|
|
VALUE coverages = rb_get_coverages();
|
|
VALUE ncoverages = rb_hash_new();
|
|
if (!RTEST(coverages)) {
|
|
rb_raise(rb_eRuntimeError, "coverage measurement is not enabled");
|
|
}
|
|
OBJ_WB_UNPROTECT(coverages);
|
|
st_foreach(RHASH_TBL_RAW(coverages), coverage_peek_result_i, ncoverages);
|
|
|
|
if (current_mode & COVERAGE_TARGET_METHODS) {
|
|
rb_objspace_each_objects(method_coverage_i, &ncoverages);
|
|
}
|
|
|
|
rb_hash_freeze(ncoverages);
|
|
return ncoverages;
|
|
}
|
|
|
|
|
|
static int
|
|
clear_me2counter_i(VALUE key, VALUE value, VALUE unused)
|
|
{
|
|
rb_hash_aset(me2counter, key, INT2FIX(0));
|
|
return ST_CONTINUE;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* Coverage.result(stop: true, clear: true) => hash
|
|
*
|
|
* Returns a hash that contains filename as key and coverage array as value.
|
|
* If +clear+ is true, it clears the counters to zero.
|
|
* If +stop+ is true, it disables coverage measurement.
|
|
*/
|
|
static VALUE
|
|
rb_coverage_result(int argc, VALUE *argv, VALUE klass)
|
|
{
|
|
VALUE ncoverages;
|
|
VALUE opt;
|
|
int stop = 1, clear = 1;
|
|
|
|
rb_scan_args(argc, argv, "01", &opt);
|
|
|
|
if (argc == 1) {
|
|
opt = rb_convert_type(opt, T_HASH, "Hash", "to_hash");
|
|
stop = RTEST(rb_hash_lookup(opt, ID2SYM(rb_intern("stop"))));
|
|
clear = RTEST(rb_hash_lookup(opt, ID2SYM(rb_intern("clear"))));
|
|
}
|
|
|
|
ncoverages = rb_coverage_peek_result(klass);
|
|
if (stop && !clear) {
|
|
rb_warn("stop implies clear");
|
|
clear = 1;
|
|
}
|
|
if (clear) {
|
|
rb_clear_coverages();
|
|
if (!NIL_P(me2counter)) rb_hash_foreach(me2counter, clear_me2counter_i, Qnil);
|
|
}
|
|
if (stop) {
|
|
rb_reset_coverages();
|
|
me2counter = Qnil;
|
|
}
|
|
return ncoverages;
|
|
}
|
|
|
|
|
|
/*
|
|
* call-seq:
|
|
* Coverage.running? => bool
|
|
*
|
|
* Returns true if coverage stats are currently being collected (after
|
|
* Coverage.start call, but before Coverage.result call)
|
|
*/
|
|
static VALUE
|
|
rb_coverage_running(VALUE klass)
|
|
{
|
|
VALUE coverages = rb_get_coverages();
|
|
return RTEST(coverages) ? Qtrue : Qfalse;
|
|
}
|
|
|
|
/* Coverage provides coverage measurement feature for Ruby.
|
|
* This feature is experimental, so these APIs may be changed in future.
|
|
*
|
|
* = Usage
|
|
*
|
|
* 1. require "coverage"
|
|
* 2. do Coverage.start
|
|
* 3. require or load Ruby source file
|
|
* 4. Coverage.result will return a hash that contains filename as key and
|
|
* coverage array as value. A coverage array gives, for each line, the
|
|
* number of line execution by the interpreter. A +nil+ value means
|
|
* coverage is disabled for this line (lines like +else+ and +end+).
|
|
*
|
|
* = Examples
|
|
*
|
|
* [foo.rb]
|
|
* s = 0
|
|
* 10.times do |x|
|
|
* s += x
|
|
* end
|
|
*
|
|
* if s == 45
|
|
* p :ok
|
|
* else
|
|
* p :ng
|
|
* end
|
|
* [EOF]
|
|
*
|
|
* require "coverage"
|
|
* Coverage.start
|
|
* require "foo.rb"
|
|
* p Coverage.result #=> {"foo.rb"=>[1, 1, 10, nil, nil, 1, 1, nil, 0, nil]}
|
|
*
|
|
* == Lines Coverage
|
|
*
|
|
* If a coverage mode is not explicitly specified when starting coverage, lines
|
|
* coverage is what will run. It reports the number of line executions for each
|
|
* line.
|
|
*
|
|
* require "coverage"
|
|
* Coverage.start(lines: true)
|
|
* require "foo.rb"
|
|
* p Coverage.result #=> {"foo.rb"=>{:lines=>[1, 1, 10, nil, nil, 1, 1, nil, 0, nil]}}
|
|
*
|
|
* The value of the lines coverage result is an array containing how many times
|
|
* each line was executed. Order in this array is important. For example, the
|
|
* first item in this array, at index 0, reports how many times line 1 of this
|
|
* file was executed while coverage was run (which, in this example, is one
|
|
* time).
|
|
*
|
|
* A +nil+ value means coverage is disabled for this line (lines like +else+
|
|
* and +end+).
|
|
*
|
|
* == Oneshot Lines Coverage
|
|
*
|
|
* Oneshot lines coverage tracks and reports on the executed lines while
|
|
* coverage is running. It will not report how many times a line was executed,
|
|
* only that it was executed.
|
|
*
|
|
* require "coverage"
|
|
* Coverage.start(oneshot_lines: true)
|
|
* require "foo.rb"
|
|
* p Coverage.result #=> {"foo.rb"=>{:oneshot_lines=>[1, 2, 3, 6, 7]}}
|
|
*
|
|
* The value of the oneshot lines coverage result is an array containing the
|
|
* line numbers that were executed.
|
|
*
|
|
* == Branches Coverage
|
|
*
|
|
* Branches coverage reports how many times each branch within each conditional
|
|
* was executed.
|
|
*
|
|
* require "coverage"
|
|
* Coverage.start(branches: true)
|
|
* require "foo.rb"
|
|
* p Coverage.result #=> {"foo.rb"=>{:branches=>{[:if, 0, 6, 0, 10, 3]=>{[:then, 1, 7, 2, 7, 7]=>1, [:else, 2, 9, 2, 9, 7]=>0}}}}
|
|
*
|
|
* Each entry within the branches hash is a conditional, the value of which is
|
|
* another hash where each entry is a branch in that conditional. The values
|
|
* are the number of times the method was executed, and the keys are identifying
|
|
* information about the branch.
|
|
*
|
|
* The information that makes up each key identifying branches or conditionals
|
|
* is the following, from left to right:
|
|
*
|
|
* 1. A label for the type of branch or conditional.
|
|
* 2. A unique identifier.
|
|
* 3. The starting line number it appears on in the file.
|
|
* 4. The starting column number it appears on in the file.
|
|
* 5. The ending line number it appears on in the file.
|
|
* 6. The ending column number it appears on in the file.
|
|
*
|
|
* == Methods Coverage
|
|
*
|
|
* Methods coverage reports how many times each method was executed.
|
|
*
|
|
* [foo_method.rb]
|
|
* class Greeter
|
|
* def greet
|
|
* "welcome!"
|
|
* end
|
|
* end
|
|
*
|
|
* def hello
|
|
* "Hi"
|
|
* end
|
|
*
|
|
* hello()
|
|
* Greeter.new.greet()
|
|
* [EOF]
|
|
*
|
|
* require "coverage"
|
|
* Coverage.start(methods: true)
|
|
* require "foo_method.rb"
|
|
* p Coverage.result #=> {"foo_method.rb"=>{:methods=>{[Object, :hello, 7, 0, 9, 3]=>1, [Greeter, :greet, 2, 2, 4, 5]=>1}}}
|
|
*
|
|
* Each entry within the methods hash represents a method. The values in this
|
|
* hash are the number of times the method was executed, and the keys are
|
|
* identifying information about the method.
|
|
*
|
|
* The information that makes up each key identifying a method is the following,
|
|
* from left to right:
|
|
*
|
|
* 1. The class.
|
|
* 2. The method name.
|
|
* 3. The starting line number the method appears on in the file.
|
|
* 4. The starting column number the method appears on in the file.
|
|
* 5. The ending line number the method appears on in the file.
|
|
* 6. The ending column number the method appears on in the file.
|
|
*
|
|
* == All Coverage Modes
|
|
*
|
|
* You can also run all modes of coverage simultaneously with this shortcut.
|
|
* Note that running all coverage modes does not run both lines and oneshot
|
|
* lines. Those modes cannot be run simultaneously. Lines coverage is run in
|
|
* this case, because you can still use it to determine whether or not a line
|
|
* was executed.
|
|
*
|
|
* require "coverage"
|
|
* Coverage.start(:all)
|
|
* require "foo.rb"
|
|
* p Coverage.result #=> {"foo.rb"=>{:lines=>[1, 1, 10, nil, nil, 1, 1, nil, 0, nil], :branches=>{[:if, 0, 6, 0, 10, 3]=>{[:then, 1, 7, 2, 7, 7]=>1, [:else, 2, 9, 2, 9, 7]=>0}}, :methods=>{}}}
|
|
*/
|
|
void
|
|
Init_coverage(void)
|
|
{
|
|
VALUE rb_mCoverage = rb_define_module("Coverage");
|
|
rb_define_module_function(rb_mCoverage, "start", rb_coverage_start, -1);
|
|
rb_define_module_function(rb_mCoverage, "result", rb_coverage_result, -1);
|
|
rb_define_module_function(rb_mCoverage, "peek_result", rb_coverage_peek_result, 0);
|
|
rb_define_module_function(rb_mCoverage, "running?", rb_coverage_running, 0);
|
|
rb_global_variable(&me2counter);
|
|
}
|