[GR-18163] Adjust Coverage.start to accept arguments

PullRequest: truffleruby/3955

Author: andrykonchin

CHANGELOG.md

@@ -29,6 +29,7 @@ Compatibility:
 * Set `RbConfig::CONFIG['configure_args']` for openssl and libyaml (#3170, #3303, @eregon).
 * Support `Socket.sockaddr_in(port, Socket::INADDR_ANY)` (#3361, @mtortonesi).
 * Implement the `Data` class from Ruby 3.2 (#3039, @moste00, @eregon).
+* Make `Coverage.start` and `Coverage.result` accept parameters (#3149, @mtortonesi, @andrykonchin).
 
 Performance:
 

lib/truffle/coverage.rb

@@ -10,14 +10,61 @@
 # GNU Lesser General Public License version 2.1.
 
 module Coverage
+  def self.supported?(mode)
+    mode == :lines
+  end
+
+  def self.start(modes = Truffle::UNDEFINED)
+    if Truffle::Coverage.enabled?
+      raise 'coverage measurement is already setup'
+    end
+
+    if modes == :all || Primitive.undefined?(modes)
+      options = {}
+    else
+      options = Truffle::Type.rb_convert_type(modes, Hash, :to_hash)
+    end
 
-  def self.start
+    if options[:lines] && options[:oneshot_lines]
+      raise 'cannot enable lines and oneshot_lines simultaneously'
+    end
+
+    @default_mode = Primitive.undefined?(modes)
     Truffle::Coverage.enable
+
+    nil
   end
 
-  def self.result
+  def self.result(**options)
+    if options.empty?
+      stop = true
+      clear = true
+    else
+      stop = options[:stop]
+      clear = options[:clear]
+    end
+
+    if stop && !clear
+      warn 'stop implies clear', uplevel: 1
+    end
+
     result = peek_result
-    Truffle::Coverage.disable
+
+    # TODO: There should be a difference between :stop and :clear in a way they affect counters.
+    #       :stop means to remove all the counters at all, :clear - to set 0 values only.
+    #       Now we remove counters in both cases.
+    Truffle::Coverage.disable if stop || clear
+    Truffle::Coverage.enable if !stop && clear
+
+    # By default provides only lines coverage measurement.
+    # If some mode was specified explicitly then return counters per mode separately (e.g. for :lines, :branches, etc).
+    # Support only :lines for now.
+    if !@default_mode
+      result.transform_values! do |lines|
+        { lines: lines }
+      end
+    end
+
     result
   end
 

spec/ruby/library/coverage/result_spec.rb

@@ -8,10 +8,16 @@
     @eval_code_file = fixture __FILE__, 'eval_code.rb'
   end
 
+  before :each do
+    Coverage.running?.should == false
+  end
+
   after :each do
     $LOADED_FEATURES.delete(@class_file)
     $LOADED_FEATURES.delete(@config_file)
     $LOADED_FEATURES.delete(@eval_code_file)
+
+    Coverage.result if Coverage.running?
   end
 
   it 'gives the covered files as a hash with arrays of count or nil' do
@@ -26,6 +32,41 @@
     }
   end
 
+  ruby_version_is "3.2" do
+    it 'returns results for each mode separately when enabled :all modes' do
+      Coverage.start(:all)
+      require @class_file.chomp('.rb')
+      result = Coverage.result
+
+      result.should == {
+        @class_file => {
+          lines: [
+            nil, nil, 1, nil, nil, 1, nil, nil, 0, nil, nil, nil, nil, nil, nil, nil
+          ],
+          branches: {},
+          methods: {
+            [SomeClass, :some_method, 6, 2, 11, 5] => 0
+          }
+        }
+      }
+    end
+
+    it 'returns results for each mode separately when enabled any mode explicitly' do
+      Coverage.start(lines: true)
+      require @class_file.chomp('.rb')
+      result = Coverage.result
+
+      result.should == {
+        @class_file =>
+          {
+            lines: [
+              nil, nil, 1, nil, nil, 1, nil, nil, 0, nil, nil, nil, nil, nil, nil, nil
+            ]
+          }
+      }
+    end
+  end
+
   it 'no requires/loads should give empty hash' do
     Coverage.start
     result = Coverage.result
@@ -75,17 +116,6 @@
     end
   end
 
-  ruby_version_is '3.1' do
-    it 'second Coverage.start give exception' do
-      Coverage.start
-      -> {
-        require @config_file.chomp('.rb')
-      }.should raise_error(RuntimeError, 'coverage measurement is already setup')
-    ensure
-      Coverage.result
-    end
-  end
-
   it 'does not include the file starting coverage since it is not tracked' do
     require @config_file.chomp('.rb')
     Coverage.result.should_not include(@config_file)
@@ -98,18 +128,14 @@
       result = Coverage.result
 
       result.should == {
-          @eval_code_file => [
-              1, nil, 1, nil, 1, nil, nil, nil, nil, nil, 1
-          ]
+        @eval_code_file => [
+          1, nil, 1, nil, 1, nil, nil, nil, nil, nil, 1
+        ]
       }
     end
   end
 
   ruby_version_is '3.2' do
-    it 'indicates support for different features' do
-      Coverage.supported?(:lines).should == true
-    end
-
     it 'returns the correct results when eval coverage is enabled' do
       Coverage.supported?(:eval).should == true
 
@@ -118,24 +144,214 @@
       result = Coverage.result
 
       result.should == {
-          @eval_code_file => {
-              lines: [1, nil, 1, nil, 1, 1, nil, nil, nil, nil, 1]
-          }
+        @eval_code_file => {
+          lines: [1, nil, 1, nil, 1, 1, nil, nil, nil, nil, 1]
+        }
       }
     end
 
-    it 'returns the correct results when eval coverage is enabled' do
+    it 'returns the correct results when eval coverage is disabled' do
       Coverage.supported?(:eval).should == true
 
       Coverage.start(lines: true, eval: false)
       require @eval_code_file.chomp('.rb')
       result = Coverage.result
 
       result.should == {
-          @eval_code_file => {
-              lines: [1, nil, 1, nil, 1, nil, nil, nil, nil, nil, 1]
-          }
+        @eval_code_file => {
+          lines: [1, nil, 1, nil, 1, nil, nil, nil, nil, nil, 1]
+        }
       }
     end
   end
+
+  it "disables coverage measurement when stop option is not specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    Coverage.result
+    Coverage.running?.should == false
+  end
+
+  it "disables coverage measurement when stop: true option is specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    -> {
+      Coverage.result(stop: true)
+    }.should complain /warning: stop implies clear/
+
+    Coverage.running?.should == false
+  end
+
+  it "does not disable coverage measurement when stop: false option is specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    Coverage.result(stop: false)
+    Coverage.running?.should == true
+  end
+
+  it "does not disable coverage measurement when stop option is not specified but clear: true specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    Coverage.result(clear: true)
+    Coverage.running?.should == true
+  end
+
+  it "does not disable coverage measurement when stop option is not specified but clear: false specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    Coverage.result(clear: false)
+    Coverage.running?.should == true
+  end
+
+  it "disables coverage measurement when stop: true and clear: true specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    Coverage.result(stop: true, clear: true)
+    Coverage.running?.should == false
+  end
+
+  it "disables coverage measurement when stop: true and clear: false specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    -> {
+      Coverage.result(stop: true, clear: false)
+    }.should complain /warning: stop implies clear/
+
+    Coverage.running?.should == false
+  end
+
+  it "does not disable coverage measurement when stop: false and clear: true specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    Coverage.result(stop: false, clear: true)
+    Coverage.running?.should == true
+  end
+
+  it "does not disable coverage measurement when stop: false and clear: false specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    Coverage.result(stop: false, clear: false)
+    Coverage.running?.should == true
+  end
+
+  it "resets counters (remove them) when stop: true specified but clear option is not specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    -> {
+      Coverage.result(stop: true) # clears counters
+    }.should complain /warning: stop implies clear/
+
+    Coverage.start
+    Coverage.peek_result.should == {}
+  end
+
+  it "resets counters (remove them) when stop: true and clear: true specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    Coverage.result(stop: true, clear: true) # clears counters
+
+    Coverage.start
+    Coverage.peek_result.should == {}
+  end
+
+  it "resets counters (remove them) when stop: true and clear: false specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    -> {
+      Coverage.result(stop: true, clear: false) # clears counters
+    }.should complain /warning: stop implies clear/
+
+    Coverage.start
+    Coverage.peek_result.should == {}
+  end
+
+  it "resets counters (remove them) when both stop and clear options are not specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    Coverage.result # clears counters
+
+    Coverage.start
+    Coverage.peek_result.should == {}
+  end
+
+  it "clears counters (sets 0 values) when stop is not specified but clear: true specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    Coverage.result(clear: true) # clears counters
+
+    Coverage.peek_result.should == {
+      @class_file => [
+        nil, nil, 0, nil, nil, 0, nil, nil, 0, nil, nil, nil, nil, nil, nil, nil
+      ]
+    }
+  end
+
+  it "does not clear counters when stop is not specified but clear: false specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    result = Coverage.result(clear: false) # doesn't clear counters
+    result.should == {
+      @class_file => [
+        nil, nil, 1, nil, nil, 1, nil, nil, 0, nil, nil, nil, nil, nil, nil, nil
+      ]
+    }
+
+    Coverage.peek_result.should == result
+  end
+
+  it "does not clear counters when stop: false and clear is not specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    result = Coverage.result(stop: false) # doesn't clear counters
+    result.should == {
+      @class_file => [
+        nil, nil, 1, nil, nil, 1, nil, nil, 0, nil, nil, nil, nil, nil, nil, nil
+      ]
+    }
+
+    Coverage.peek_result.should == result
+  end
+
+  it "clears counters (sets 0 values) when stop: false and clear: true specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    Coverage.result(stop: false, clear: true) # clears counters
+
+    Coverage.peek_result.should == {
+      @class_file => [
+        nil, nil, 0, nil, nil, 0, nil, nil, 0, nil, nil, nil, nil, nil, nil, nil
+      ]
+    }
+  end
+
+  it "does not clear counters when stop: false and clear: false specified" do
+    Coverage.start
+    require @class_file.chomp('.rb')
+
+    result = Coverage.result(stop: false, clear: false) # doesn't clear counters
+    result.should == {
+      @class_file => [
+        nil, nil, 1, nil, nil, 1, nil, nil, 0, nil, nil, nil, nil, nil, nil, nil
+      ]
+    }
+
+    Coverage.peek_result.should == result
+  end
 end