summaryrefslogtreecommitdiff
path: root/ext/coverage
diff options
context:
space:
mode:
Diffstat (limited to 'ext/coverage')
-rw-r--r--ext/coverage/coverage.c304
-rw-r--r--ext/coverage/depend44
-rw-r--r--ext/coverage/extconf.rb5
3 files changed, 353 insertions, 0 deletions
diff --git a/ext/coverage/coverage.c b/ext/coverage/coverage.c
new file mode 100644
index 0000000000..f46955aae2
--- /dev/null
+++ b/ext/coverage/coverage.c
@@ -0,0 +1,304 @@
+/************************************************
+
+ coverage.c -
+
+ $Author: $
+
+ Copyright (c) 2008 Yusuke Endoh
+
+************************************************/
+
+#include "ruby.h"
+#include "vm_core.h"
+#include "gc.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 (mode == 0) {
+ rb_raise(rb_eRuntimeError, "no measuring target is specified");
+ }
+ }
+
+ if (mode & COVERAGE_TARGET_METHODS) {
+ me2counter = rb_hash_new_compare_by_id();
+ }
+ 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;
+}
+
+static VALUE
+branch_coverage(VALUE branches)
+{
+ VALUE ret = rb_hash_new();
+ VALUE structure = rb_ary_dup(RARRAY_AREF(branches, 0));
+ VALUE counters = rb_ary_dup(RARRAY_AREF(branches, 1));
+ int i, j;
+ long id = 0;
+
+ for (i = 0; i < RARRAY_LEN(structure); i++) {
+ VALUE branches = RARRAY_AREF(structure, i);
+ VALUE base_type = RARRAY_AREF(branches, 0);
+ VALUE base_first_lineno = RARRAY_AREF(branches, 1);
+ VALUE base_first_column = RARRAY_AREF(branches, 2);
+ VALUE base_last_lineno = RARRAY_AREF(branches, 3);
+ VALUE base_last_column = RARRAY_AREF(branches, 4);
+ VALUE children = rb_hash_new();
+ rb_hash_aset(ret, rb_ary_new_from_args(6, base_type, LONG2FIX(id++), base_first_lineno, base_first_column, base_last_lineno, base_last_column), children);
+ for (j = 5; j < RARRAY_LEN(branches); j += 6) {
+ VALUE target_label = RARRAY_AREF(branches, j);
+ VALUE target_first_lineno = RARRAY_AREF(branches, j + 1);
+ VALUE target_first_column = RARRAY_AREF(branches, j + 2);
+ VALUE target_last_lineno = RARRAY_AREF(branches, j + 3);
+ VALUE target_last_column = RARRAY_AREF(branches, j + 4);
+ int idx = FIX2INT(RARRAY_AREF(branches, j + 5));
+ rb_hash_aset(children, rb_ary_new_from_args(6, target_label, LONG2FIX(id++), target_first_lineno, target_first_column, target_last_lineno, target_last_column), RARRAY_AREF(counters, idx));
+ }
+ }
+
+ return ret;
+}
+
+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) {
+ 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);
+ }
+ }
+ }
+ 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);
+ lines = rb_ary_dup(lines);
+ rb_ary_freeze(lines);
+ rb_hash_aset(h, ID2SYM(rb_intern("lines")), 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.
+ *
+ * {
+ * "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");
+ }
+ st_foreach(RHASH_TBL(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;
+}
+
+/*
+ * call-seq:
+ * Coverage.result => hash
+ *
+ * Returns a hash that contains filename as key and coverage array as value
+ * and disables coverage measurement.
+ */
+static VALUE
+rb_coverage_result(VALUE klass)
+{
+ VALUE ncoverages = rb_coverage_peek_result(klass);
+ 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+).
+ *
+ * = Example
+ *
+ * [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]}
+ */
+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, 0);
+ 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);
+}
diff --git a/ext/coverage/depend b/ext/coverage/depend
new file mode 100644
index 0000000000..b6871fc9cb
--- /dev/null
+++ b/ext/coverage/depend
@@ -0,0 +1,44 @@
+$(OBJS): $(HDRS) $(ruby_headers) \
+ $(top_srcdir)/vm_core.h \
+ $(top_srcdir)/node.h \
+ $(top_srcdir)/vm_debug.h \
+ $(top_srcdir)/vm_opts.h \
+ {$(VPATH)}id.h \
+ $(top_srcdir)/method.h \
+ $(top_srcdir)/ruby_atomic.h \
+ $(top_srcdir)/thread_pthread.h \
+ $(top_srcdir)/internal.h \
+ $(top_srcdir)/include/ruby/thread_native.h
+
+# AUTOGENERATED DEPENDENCIES START
+coverage.o: $(RUBY_EXTCONF_H)
+coverage.o: $(arch_hdrdir)/ruby/config.h
+coverage.o: $(hdrdir)/ruby/backward.h
+coverage.o: $(hdrdir)/ruby/defines.h
+coverage.o: $(hdrdir)/ruby/encoding.h
+coverage.o: $(hdrdir)/ruby/intern.h
+coverage.o: $(hdrdir)/ruby/io.h
+coverage.o: $(hdrdir)/ruby/missing.h
+coverage.o: $(hdrdir)/ruby/onigmo.h
+coverage.o: $(hdrdir)/ruby/oniguruma.h
+coverage.o: $(hdrdir)/ruby/ruby.h
+coverage.o: $(hdrdir)/ruby/st.h
+coverage.o: $(hdrdir)/ruby/subst.h
+coverage.o: $(hdrdir)/ruby/thread_native.h
+coverage.o: $(top_srcdir)/ccan/check_type/check_type.h
+coverage.o: $(top_srcdir)/ccan/container_of/container_of.h
+coverage.o: $(top_srcdir)/ccan/list/list.h
+coverage.o: $(top_srcdir)/ccan/str/str.h
+coverage.o: $(top_srcdir)/include/ruby.h
+coverage.o: $(top_srcdir)/internal.h
+coverage.o: $(top_srcdir)/method.h
+coverage.o: $(top_srcdir)/node.h
+coverage.o: $(top_srcdir)/ruby_assert.h
+coverage.o: $(top_srcdir)/ruby_atomic.h
+coverage.o: $(top_srcdir)/thread_pthread.h
+coverage.o: $(top_srcdir)/vm_core.h
+coverage.o: $(top_srcdir)/vm_debug.h
+coverage.o: $(top_srcdir)/vm_opts.h
+coverage.o: coverage.c
+coverage.o: {$(VPATH)}id.h
+# AUTOGENERATED DEPENDENCIES END
diff --git a/ext/coverage/extconf.rb b/ext/coverage/extconf.rb
new file mode 100644
index 0000000000..3a6f530a92
--- /dev/null
+++ b/ext/coverage/extconf.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: false
+require 'mkmf'
+$VPATH << '$(topdir)' << '$(top_srcdir)'
+$INCFLAGS << " -I$(topdir) -I$(top_srcdir)"
+create_makefile('coverage')
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-06 06:17:15 +0000