fast_cov 0.1.6 → 0.2.0

data/ext/fast_cov/fast_cov.c

@@ -1,7 +1,6 @@
 #include <ruby.h>
 #include <ruby/version.h>
 #include <ruby/debug.h>
-#include <ruby/st.h>
 
 #include <stdbool.h>
 
@@ -12,28 +11,11 @@
 // Tracks which source files are executed during a test run by hooking into
 // Ruby VM events. Designed for test impact analysis.
 
-#define MAX_CONST_RESOLUTION_ROUNDS 10
-
 // threads: true = multi-threaded (global hook), false = single-threaded (per-thread hook)
 
-// Constant resolution via Ruby helper (FastCov::ConstantExtractor)
-static VALUE cConstantExtractor;
-static ID id_extract;
-static ID id_keys;
-
-// Cache infrastructure
-VALUE fast_cov_cache_hash; // process-level cache (non-static for access from utils)
-static ID id_clear;
-static ID id_merge_bang;
-
 // Forward declarations
 static VALUE fast_cov_stop(VALUE self);
-
-static int mark_key_for_gc_i(st_data_t key, st_data_t _value,
-                              st_data_t _data) {
-  rb_gc_mark((VALUE)key);
-  return ST_CONTINUE;
-}
+static VALUE fast_cov_yield_block(VALUE _arg);
 
 // ---- Data structure -----------------------------------------------------
 
@@ -43,18 +25,15 @@ struct fast_cov_data {
   char *root;
   long root_len;
 
-  char *ignored_path;
-  long ignored_path_len;
+  char **ignored_paths;
+  long *ignored_path_lens;
+  long ignored_paths_count;
 
   uintptr_t last_filename_ptr;
 
   bool threads;
-  bool constant_references;
-  bool allocations;
+  bool started;
   VALUE th_covered;
-
-  VALUE object_allocation_tracepoint;
-  st_table *klasses_table;
 };
 
 // ---- GC callbacks -------------------------------------------------------
@@ -67,18 +46,19 @@ static void fast_cov_mark(void *ptr) {
   struct fast_cov_data *data = ptr;
   rb_gc_mark(data->impacted_files);
   rb_gc_mark(data->th_covered);
-  rb_gc_mark(data->object_allocation_tracepoint);
-
-  if (data->klasses_table != NULL) {
-    st_foreach(data->klasses_table, mark_key_for_gc_i, 0);
-  }
 }
 
 static void fast_cov_free(void *ptr) {
   struct fast_cov_data *data = ptr;
+  long i;
   if (data->root) xfree(data->root);
-  if (data->ignored_path) xfree(data->ignored_path);
-  if (data->klasses_table) st_free_table(data->klasses_table);
+  if (data->ignored_paths) {
+    for (i = 0; i < data->ignored_paths_count; i++) {
+      xfree(data->ignored_paths[i]);
+    }
+    xfree(data->ignored_paths);
+  }
+  if (data->ignored_path_lens) xfree(data->ignored_path_lens);
   xfree(data);
 }
 
@@ -101,19 +81,16 @@ static VALUE fast_cov_allocate(VALUE klass) {
   // Qfalse, not Qnil — and marking Qfalse can confuse Ruby 3.4's GC.
   data->impacted_files = Qnil;
   data->th_covered = Qnil;
-  data->object_allocation_tracepoint = Qnil;
-  data->klasses_table = NULL;
 
   data->impacted_files = rb_hash_new();
   data->root = NULL;
   data->root_len = 0;
-  data->ignored_path = NULL;
-  data->ignored_path_len = 0;
+  data->ignored_paths = NULL;
+  data->ignored_path_lens = NULL;
+  data->ignored_paths_count = 0;
   data->last_filename_ptr = 0;
   data->threads = true;
-  data->constant_references = true;
-  data->allocations = true;
-  data->klasses_table = st_init_numtable();
+  data->started = false;
 
   return obj;
 }
@@ -122,8 +99,9 @@ static VALUE fast_cov_allocate(VALUE klass) {
 
 static bool record_impacted_file(struct fast_cov_data *data, VALUE filename) {
   if (!fast_cov_is_path_included(RSTRING_PTR(filename), data->root,
-                                 data->root_len, data->ignored_path,
-                                 data->ignored_path_len)) {
+                                 data->root_len, data->ignored_paths,
+                                 data->ignored_path_lens,
+                                 data->ignored_paths_count)) {
     return false;
   }
 
@@ -131,6 +109,8 @@ static bool record_impacted_file(struct fast_cov_data *data, VALUE filename) {
   return true;
 }
 
+static VALUE fast_cov_yield_block(VALUE _arg) { return rb_yield(Qnil); }
+
 // ---- Line event callback ------------------------------------------------
 
 static void on_line_event(rb_event_flag_t event, VALUE self_data, VALUE self,
@@ -160,156 +140,6 @@ static void on_line_event(rb_event_flag_t event, VALUE self_data, VALUE self,
   record_impacted_file(data, filename);
 }
 
-// ---- Allocation tracing helpers -----------------------------------------
-
-static bool record_impacted_klass(struct fast_cov_data *data, VALUE klass) {
-  VALUE klass_name = fast_cov_rescue_nil(rb_class_name, klass);
-  if (klass_name == Qnil) {
-    return false;
-  }
-
-  VALUE filename = fast_cov_resolve_const_to_file(klass_name);
-  if (filename == Qnil) {
-    return false;
-  }
-
-  return record_impacted_file(data, filename);
-}
-
-static int each_instantiated_klass(st_data_t key, st_data_t _value,
-                                   st_data_t cb_data) {
-  VALUE klass = (VALUE)key;
-  struct fast_cov_data *data = (struct fast_cov_data *)cb_data;
-
-  VALUE ancestors = fast_cov_rescue_nil(rb_mod_ancestors, klass);
-  if (ancestors == Qnil || !RB_TYPE_P(ancestors, T_ARRAY)) {
-    return ST_CONTINUE;
-  }
-
-  long len = RARRAY_LEN(ancestors);
-  for (long i = 0; i < len; i++) {
-    VALUE mod = rb_ary_entry(ancestors, i);
-    if (mod == Qnil) {
-      continue;
-    }
-    record_impacted_klass(data, mod);
-  }
-
-  return ST_CONTINUE;
-}
-
-// ---- Newobj event callback ----------------------------------------------
-
-static void on_newobj_event(VALUE tracepoint_data, void *raw_data) {
-  rb_trace_arg_t *tracearg = rb_tracearg_from_tracepoint(tracepoint_data);
-  VALUE new_object = rb_tracearg_object(tracearg);
-
-  enum ruby_value_type type = rb_type(new_object);
-  if (type != RUBY_T_OBJECT && type != RUBY_T_STRUCT) {
-    return;
-  }
-
-  VALUE klass = rb_class_of(new_object);
-#if RUBY_API_VERSION_MAJOR < 4
-  // Ruby 3.x: rb_class_of can return 0 during NEWOBJ for some allocations
-  if (klass == Qnil || klass == 0) {
-#else
-  if (klass == Qnil) {
-#endif
-    return;
-  }
-  if (rb_mod_name(klass) == Qnil) {
-    return;
-  }
-
-  struct fast_cov_data *data = (struct fast_cov_data *)raw_data;
-  st_insert(data->klasses_table, (st_data_t)klass, 1);
-}
-
-// ---- Constant reference resolution (cached) -----------------------------
-
-// Parse file with Prism and extract constant names.
-static VALUE extract_const_names_body(VALUE filename) {
-  return rb_funcall(cConstantExtractor, id_extract, 1, filename);
-}
-
-// Returns an array of constant name strings for a file, using the cache.
-// Cache is keyed by filename only - once parsed, results are cached for
-// the lifetime of the process. No digest/mtime validation needed since
-// files don't change during a test suite run.
-static VALUE get_const_refs_for_file(VALUE filename) {
-  VALUE const_refs_hash =
-      rb_hash_lookup(fast_cov_cache_hash, ID2SYM(rb_intern("const_refs")));
-
-  // Cache hit: return cached refs
-  VALUE cached = rb_hash_lookup(const_refs_hash, filename);
-  if (cached != Qnil) {
-    return cached;
-  }
-
-  // Cache miss: parse with Prism and extract constant names
-  int exception_state;
-  VALUE const_names =
-      rb_protect(extract_const_names_body, filename, &exception_state);
-  if (exception_state != 0) {
-    rb_set_errinfo(Qnil);
-    return Qnil;
-  }
-
-  // Store in cache (filename -> refs)
-  rb_hash_aset(const_refs_hash, filename, const_names);
-
-  return const_names;
-}
-
-static void resolve_constant_references(struct fast_cov_data *data) {
-  VALUE seen_consts = rb_hash_new();
-  VALUE processed_files = rb_hash_new();
-
-  for (int round = 0; round < MAX_CONST_RESOLUTION_ROUNDS; round++) {
-    VALUE keys = rb_funcall(data->impacted_files, id_keys, 0);
-    long num_keys = RARRAY_LEN(keys);
-    int found_new_file = 0;
-
-    for (long i = 0; i < num_keys; i++) {
-      VALUE filename = rb_ary_entry(keys, i);
-
-      if (rb_hash_lookup(processed_files, filename) != Qnil) {
-        continue;
-      }
-      rb_hash_aset(processed_files, filename, Qtrue);
-
-      VALUE const_names = get_const_refs_for_file(filename);
-      if (NIL_P(const_names) || !RB_TYPE_P(const_names, T_ARRAY)) {
-        continue;
-      }
-
-      long num_refs = RARRAY_LEN(const_names);
-      for (long j = 0; j < num_refs; j++) {
-        VALUE const_name = rb_ary_entry(const_names, j);
-
-        if (rb_hash_lookup(seen_consts, const_name) != Qnil) {
-          continue;
-        }
-        rb_hash_aset(seen_consts, const_name, Qtrue);
-
-        VALUE resolved_file = fast_cov_resolve_const_to_file(const_name);
-        if (NIL_P(resolved_file)) {
-          continue;
-        }
-
-        if (record_impacted_file(data, resolved_file)) {
-          found_new_file = 1;
-        }
-      }
-    }
-
-    if (!found_new_file) {
-      break;
-    }
-  }
-}
-
 // ---- Utils module methods (FastCov::Utils) ------------------------------
 
 // Utils.path_within?(path, directory) -> true/false
@@ -384,28 +214,6 @@ static VALUE utils_relativize_paths(VALUE self, VALUE set, VALUE root) {
   return set;
 }
 
-// ---- Cache module methods (FastCov::Cache) ------------------------------
-
-static VALUE cache_get_data(VALUE self) { return fast_cov_cache_hash; }
-
-static VALUE cache_set_data(VALUE self, VALUE new_cache) {
-  if (!RB_TYPE_P(new_cache, T_HASH)) {
-    rb_raise(rb_eTypeError, "cache data must be a Hash");
-  }
-  rb_funcall(fast_cov_cache_hash, id_clear, 0);
-  rb_funcall(fast_cov_cache_hash, id_merge_bang, 1, new_cache);
-  return fast_cov_cache_hash;
-}
-
-static VALUE cache_clear(VALUE self) {
-  rb_funcall(fast_cov_cache_hash, id_clear, 0);
-  rb_hash_aset(fast_cov_cache_hash, ID2SYM(rb_intern("const_refs")),
-               rb_hash_new());
-  rb_hash_aset(fast_cov_cache_hash, ID2SYM(rb_intern("const_locations")),
-               rb_hash_new());
-  return Qnil;
-}
-
 // ---- Ruby instance methods ----------------------------------------------
 
 static VALUE fast_cov_initialize(int argc, VALUE *argv, VALUE self) {
@@ -418,44 +226,63 @@ static VALUE fast_cov_initialize(int argc, VALUE *argv, VALUE self) {
   if (!RTEST(rb_root)) {
     rb_root = rb_funcall(rb_cDir, rb_intern("pwd"), 0);
   }
+  Check_Type(rb_root, T_STRING);
 
-  // ignored_path: optional, nil if not provided
-  VALUE rb_ignored_path =
-      rb_hash_lookup(opt, ID2SYM(rb_intern("ignored_path")));
+  // ignored_paths: optional array, [] if not provided
+  VALUE rb_ignored_paths =
+      rb_hash_lookup(opt, ID2SYM(rb_intern("ignored_paths")));
+  if (!NIL_P(rb_ignored_paths)) {
+    Check_Type(rb_ignored_paths, T_ARRAY);
+  }
 
   // threads: true (multi) or false (single), defaults to true
   VALUE rb_threads = rb_hash_lookup(opt, ID2SYM(rb_intern("threads")));
   bool threads = (rb_threads != Qfalse);
 
-  // constant_references: defaults to true
-  VALUE rb_const_refs =
-      rb_hash_lookup(opt, ID2SYM(rb_intern("constant_references")));
-  bool constant_references = (rb_const_refs != Qfalse);
-
-  // allocations: defaults to true
-  VALUE rb_allocations =
-      rb_hash_lookup(opt, ID2SYM(rb_intern("allocations")));
-  bool allocations = (rb_allocations != Qfalse);
-
   struct fast_cov_data *data;
   TypedData_Get_Struct(self, struct fast_cov_data, &fast_cov_data_type, data);
 
+  char *root = fast_cov_ruby_strndup(RSTRING_PTR(rb_root), RSTRING_LEN(rb_root));
+
   data->threads = threads;
-  data->constant_references = constant_references;
-  data->allocations = allocations;
+  if (data->root) xfree(data->root);
+  data->root = root;
   data->root_len = RSTRING_LEN(rb_root);
-  data->root =
-      fast_cov_ruby_strndup(RSTRING_PTR(rb_root), data->root_len);
 
-  if (RTEST(rb_ignored_path)) {
-    data->ignored_path_len = RSTRING_LEN(rb_ignored_path);
-    data->ignored_path = fast_cov_ruby_strndup(RSTRING_PTR(rb_ignored_path),
-                                               data->ignored_path_len);
+  if (data->ignored_paths) {
+    long i;
+    for (i = 0; i < data->ignored_paths_count; i++) {
+      xfree(data->ignored_paths[i]);
+    }
+    xfree(data->ignored_paths);
+    data->ignored_paths = NULL;
+  }
+  if (data->ignored_path_lens) {
+    xfree(data->ignored_path_lens);
+    data->ignored_path_lens = NULL;
   }
+  data->ignored_paths_count = 0;
+
+  if (!NIL_P(rb_ignored_paths) && RARRAY_LEN(rb_ignored_paths) > 0) {
+    long i;
+    long ignored_paths_count = RARRAY_LEN(rb_ignored_paths);
 
-  if (allocations) {
-    data->object_allocation_tracepoint = rb_tracepoint_new(
-        Qnil, RUBY_INTERNAL_EVENT_NEWOBJ, on_newobj_event, (void *)data);
+    for (i = 0; i < ignored_paths_count; i++) {
+      Check_Type(rb_ary_entry(rb_ignored_paths, i), T_STRING);
+    }
+
+    data->ignored_paths_count = ignored_paths_count;
+    data->ignored_paths = xcalloc(data->ignored_paths_count, sizeof(char *));
+    data->ignored_path_lens = xcalloc(data->ignored_paths_count, sizeof(long));
+
+    for (i = 0; i < data->ignored_paths_count; i++) {
+      VALUE rb_ignored_path = rb_ary_entry(rb_ignored_paths, i);
+
+      data->ignored_path_lens[i] = RSTRING_LEN(rb_ignored_path);
+      data->ignored_paths[i] =
+          fast_cov_ruby_strndup(RSTRING_PTR(rb_ignored_path),
+                                data->ignored_path_lens[i]);
+    }
   }
 
   return Qnil;
@@ -469,6 +296,13 @@ static VALUE fast_cov_start(VALUE self) {
     rb_raise(rb_eRuntimeError, "root is required");
   }
 
+  if (data->started) {
+    if (rb_block_given_p()) {
+      rb_raise(rb_eRuntimeError, "Coverage is already started");
+    }
+    return self;
+  }
+
   if (!data->threads) {
     VALUE thval = rb_thread_current();
     rb_thread_add_event_hook(thval, on_line_event, RUBY_EVENT_LINE, self);
@@ -476,15 +310,17 @@ static VALUE fast_cov_start(VALUE self) {
   } else {
     rb_add_event_hook(on_line_event, RUBY_EVENT_LINE, self);
   }
-
-  if (data->object_allocation_tracepoint != Qnil) {
-    rb_tracepoint_enable(data->object_allocation_tracepoint);
-  }
+  data->started = true;
 
   // Block form: start { ... } runs the block then returns stop result
   if (rb_block_given_p()) {
-    rb_yield(Qnil);
-    return fast_cov_stop(self);
+    int exception_state = 0;
+    rb_protect(fast_cov_yield_block, Qnil, &exception_state);
+    VALUE result = fast_cov_stop(self);
+    if (exception_state != 0) {
+      rb_jump_tag(exception_state);
+    }
+    return result;
   }
 
   return self;
@@ -494,6 +330,10 @@ static VALUE fast_cov_stop(VALUE self) {
   struct fast_cov_data *data;
   TypedData_Get_Struct(self, struct fast_cov_data, &fast_cov_data_type, data);
 
+  if (!data->started) {
+    return rb_hash_new();
+  }
+
   if (!data->threads) {
     VALUE thval = rb_thread_current();
     if (thval != data->th_covered) {
@@ -505,23 +345,11 @@ static VALUE fast_cov_stop(VALUE self) {
     rb_remove_event_hook(on_line_event);
   }
 
-  if (data->object_allocation_tracepoint != Qnil) {
-    rb_tracepoint_disable(data->object_allocation_tracepoint);
-  }
-
-  if (data->allocations) {
-    st_foreach(data->klasses_table, each_instantiated_klass, (st_data_t)data);
-    st_clear(data->klasses_table);
-  }
-
-  if (data->constant_references) {
-    resolve_constant_references(data);
-  }
-
   VALUE res = data->impacted_files;
 
   data->impacted_files = rb_hash_new();
   data->last_filename_ptr = 0;
+  data->started = false;
 
   return res;
 }
@@ -529,28 +357,8 @@ static VALUE fast_cov_stop(VALUE self) {
 // ---- Init ---------------------------------------------------------------
 
 void Init_fast_cov(void) {
-  id_extract = rb_intern("extract");
-  id_keys = rb_intern("keys");
-  id_clear = rb_intern("clear");
-  id_merge_bang = rb_intern("merge!");
-
-  rb_require("fast_cov/constant_extractor");
-
-  // Initialize process-level cache
-  fast_cov_cache_hash = rb_hash_new();
-  rb_gc_register_address(&fast_cov_cache_hash);
-  rb_hash_aset(fast_cov_cache_hash, ID2SYM(rb_intern("const_refs")),
-               rb_hash_new());
-  rb_hash_aset(fast_cov_cache_hash, ID2SYM(rb_intern("const_locations")),
-               rb_hash_new());
-
   VALUE mFastCov = rb_define_module("FastCov");
 
-  // FastCov::ConstantExtractor must be loaded before the C extension
-  cConstantExtractor =
-      rb_const_get(mFastCov, rb_intern("ConstantExtractor"));
-  rb_gc_register_address(&cConstantExtractor);
-
   VALUE cCoverage = rb_define_class_under(mFastCov, "Coverage", rb_cObject);
 
   rb_define_alloc_func(cCoverage, fast_cov_allocate);
@@ -558,12 +366,6 @@ void Init_fast_cov(void) {
   rb_define_method(cCoverage, "start", fast_cov_start, 0);
   rb_define_method(cCoverage, "stop", fast_cov_stop, 0);
 
-  // FastCov::Cache module (C-defined methods)
-  VALUE mCache = rb_define_module_under(mFastCov, "Cache");
-  rb_define_module_function(mCache, "data", cache_get_data, 0);
-  rb_define_module_function(mCache, "data=", cache_set_data, 1);
-  rb_define_module_function(mCache, "clear", cache_clear, 0);
-
   // FastCov::Utils module (C-defined methods)
   VALUE mUtils = rb_define_module_under(mFastCov, "Utils");
   rb_define_module_function(mUtils, "path_within?", utils_path_within, 2);

data/ext/fast_cov/fast_cov.h

@@ -4,29 +4,18 @@
 #include <ruby.h>
 #include <stdbool.h>
 
-/* ---- Cache -------------------------------------------------------------- */
-
-extern VALUE fast_cov_cache_hash;
-
 /* ---- Path filtering ----------------------------------------------------- */
 
 bool fast_cov_is_within_root(const char *path, long path_len,
                              const char *root, long root_len);
 
 bool fast_cov_is_path_included(const char *path, const char *root_path,
-                               long root_path_len, const char *ignored_path,
-                               long ignored_path_len);
+                               long root_path_len, char **ignored_paths,
+                               long *ignored_path_lens,
+                               long ignored_paths_count);
 
 /* ---- Utility functions -------------------------------------------------- */
 
 char *fast_cov_ruby_strndup(const char *str, size_t size);
 
-VALUE fast_cov_rescue_nil(VALUE (*fn)(VALUE), VALUE arg);
-
-VALUE fast_cov_get_const_source_location(VALUE const_name_str);
-
-VALUE fast_cov_safely_get_const_source_location(VALUE const_name_str);
-
-VALUE fast_cov_resolve_const_to_file(VALUE const_name_str);
-
 #endif /* FAST_COV_H */

data/ext/fast_cov/fast_cov_utils.c

@@ -34,17 +34,23 @@ bool fast_cov_is_within_root(const char *path, long path_len,
 }
 
 bool fast_cov_is_path_included(const char *path, const char *root_path,
-                               long root_path_len, const char *ignored_path,
-                               long ignored_path_len) {
+                               long root_path_len, char **ignored_paths,
+                               long *ignored_path_lens,
+                               long ignored_paths_count) {
   long path_len = (long)strlen(path);
+  long i;
 
   if (!fast_cov_is_within_root(path, path_len, root_path, root_path_len)) {
     return false;
   }
-  if (ignored_path_len > 0 &&
-      fast_cov_is_within_root(path, path_len, ignored_path, ignored_path_len)) {
-    return false;
+
+  for (i = 0; i < ignored_paths_count; i++) {
+    if (fast_cov_is_within_root(path, path_len, ignored_paths[i],
+                                ignored_path_lens[i])) {
+      return false;
+    }
   }
+
   return true;
 }
 
@@ -54,51 +60,3 @@ char *fast_cov_ruby_strndup(const char *str, size_t size) {
   dup[size] = '\0';
   return dup;
 }
-
-VALUE fast_cov_rescue_nil(VALUE (*fn)(VALUE), VALUE arg) {
-  int exception_state;
-  VALUE result = rb_protect(fn, arg, &exception_state);
-  if (exception_state != 0) {
-    rb_set_errinfo(Qnil);
-    return Qnil;
-  }
-  return result;
-}
-
-VALUE fast_cov_get_const_source_location(VALUE const_name_str) {
-  return rb_funcall(rb_cObject, rb_intern("const_source_location"), 1,
-                    const_name_str);
-}
-
-VALUE fast_cov_safely_get_const_source_location(VALUE const_name_str) {
-  return fast_cov_rescue_nil(fast_cov_get_const_source_location,
-                             const_name_str);
-}
-
-VALUE fast_cov_resolve_const_to_file(VALUE const_name_str) {
-  // Check cache first
-  VALUE const_locations_hash =
-      rb_hash_lookup(fast_cov_cache_hash, ID2SYM(rb_intern("const_locations")));
-  VALUE cached = rb_hash_lookup(const_locations_hash, const_name_str);
-  if (cached != Qnil) {
-    return cached;
-  }
-
-  // Cache miss - resolve via Object.const_source_location
-  VALUE source_location =
-      fast_cov_safely_get_const_source_location(const_name_str);
-  if (NIL_P(source_location) || !RB_TYPE_P(source_location, T_ARRAY) ||
-      RARRAY_LEN(source_location) == 0) {
-    return Qnil;
-  }
-
-  VALUE filename = RARRAY_AREF(source_location, 0);
-  if (NIL_P(filename) || !RB_TYPE_P(filename, T_STRING)) {
-    return Qnil;
-  }
-
-  // Cache the result
-  rb_hash_aset(const_locations_hash, const_name_str, filename);
-
-  return filename;
-}

data/lib/fast_cov/benchmark/scenarios.rb

@@ -5,7 +5,6 @@ module FastCov
     module Scenarios
       def self.register(runner, fixtures_dir:)
         root_calculator = File.join(fixtures_dir, "calculator")
-        root_app = File.join(fixtures_dir, "app")
         root_all = fixtures_dir
         ignored_path = File.join(fixtures_dir, "vendor")
 
@@ -42,44 +41,13 @@ module FastCov
         end
 
         runner.scenario("Line coverage (with ignored_path)") do
-          cov = FastCov::Coverage.new(root: root_all, ignored_path: ignored_path)
+          cov = FastCov::Coverage.new(root: root_all, ignored_paths: [ignored_path])
           cov.start
           calculator.add(1, 2)
           calculator.subtract(3, 1)
           cov.stop
         end
 
-        runner.scenario("Allocation tracing") do
-          cov = FastCov::Coverage.new(root: root_app, allocations: true)
-          cov.start
-          MyModel.new
-          User.new("test", "test@test.com")
-          DynamicModel.new
-          cov.stop
-        end
-
-        runner.scenario("Constant resolution (cold cache)") do
-          FastCov::Cache.clear
-          cov = FastCov::Coverage.new(root: root_calculator)
-          cov.start
-          ConstantReader.new.operations
-          calculator.add(1, 2)
-          cov.stop
-        end
-
-        runner.scenario("Constant resolution (warm cache)") do
-          warm = FastCov::Coverage.new(root: root_calculator)
-          warm.start
-          ConstantReader.new.operations
-          warm.stop
-
-          cov = FastCov::Coverage.new(root: root_calculator)
-          cov.start
-          ConstantReader.new.operations
-          calculator.add(1, 2)
-          cov.stop
-        end
-
         runner.scenario("Rapid start/stop (100x)") do
           cov = FastCov::Coverage.new(root: root_calculator)
           100.times do