ultra-pro-pkg 0.0.1

data/simplecov-1.0.0/lib/simplecov.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+#
+# Code coverage for ruby. Please check out README for a full introduction.
+#
+module SimpleCov
+  # Raised when a user's configuration is internally inconsistent — e.g.
+  # every coverage criterion has been disabled.
+  class ConfigurationError < StandardError; end
+
+  class << self
+    CRITERION_TO_RUBY_COVERAGE = {
+      branch: :branches,
+      line: :lines,
+      method: :methods,
+      oneshot_line: :oneshot_lines
+    }.freeze
+
+    attr_accessor :pid
+    # When this process started tracking coverage. Captured by SimpleCov.start
+    # so JSONFormatter can detect when an existing coverage.json was written
+    # by a sibling process running concurrently.
+    attr_accessor :process_start_time
+
+    # A monotonically increasing serial the parent assigns to each forked
+    # subprocess (see SimpleCov::ProcessForkHook). The default `at_fork`
+    # builds the worker's command_name from this rather than the OS pid:
+    # the serial sequence is the same from one run to the next, so a re-run
+    # overwrites the previous run's resultset entries instead of writing
+    # uniquely-named ones that pile up until merge_timeout. See issue #1171.
+    def subprocess_serial
+      @subprocess_serial ||= 0
+    end
+
+    # @api private — bump the serial in the parent before a fork so the
+    # child inherits its own ordinal via copy-on-write.
+    def next_subprocess_serial!
+      @subprocess_serial = subprocess_serial + 1
+    end
+
+    # @api private — true in a process that was forked while coverage was
+    # running (set by SimpleCov::ProcessForkHook in the child). Such a child
+    # stores its own slice but must not act as the final-result process: the
+    # process that forked it merges every slice and produces the report. Only
+    # consulted when no parallel-test adapter is active, since adapters answer
+    # `first_worker?` themselves. See issue #1171.
+    def forked_subprocess?
+      !!(defined?(@forked_subprocess) && @forked_subprocess)
+    end
+
+    # @api private — marked in the child immediately after a fork.
+    def mark_forked_subprocess!
+      @forked_subprocess = true
+    end
+    # Should we take care of at_exit behavior or something else? Used by the
+    # minitest plugin. See lib/minitest/simplecov_plugin.rb.
+    attr_accessor :external_at_exit
+
+    # `:oneshot_line` data is folded into the `:line` bucket of
+    # `coverage_statistics` by `ResultAdapter`, so use `:line` to look
+    # up stats for either criterion.
+    def coverage_statistics_key(criterion)
+      criterion == :oneshot_line ? :line : criterion
+    end
+
+    # Coerce to a proper boolean so rspec-mocks 4's predicate matcher
+    # (`expect(...).not_to be_external_at_exit`) accepts the result.
+    def external_at_exit?
+      !!@external_at_exit
+    end
+
+    #
+    # Sets up SimpleCov to run against your project. See README for
+    # the full DSL, or:
+    #
+    #     SimpleCov.start
+    #     SimpleCov.start 'rails'                # using a profile
+    #     SimpleCov.start { add_filter 'test' }  # with a config block
+    #
+    def start(profile = nil, &)
+      warn_about_start_in_dot_simplecov if @autoloading_dot_simplecov
+
+      initial_setup(profile, &)
+      start_tracking
+      install_at_exit_hook
+    end
+
+    # @api private
+    #
+    # Mark the duration of a `.simplecov` auto-load so any `SimpleCov.start`
+    # call inside the file can warn about the impending migration to a
+    # config-only file. Tracking still begins for backward compatibility;
+    # the warning is the cue to move `SimpleCov.start` into a test helper.
+    # See #581.
+    def with_dot_simplecov_autoload
+      previous = @autoloading_dot_simplecov
+      @autoloading_dot_simplecov = true
+      yield
+    ensure
+      @autoloading_dot_simplecov = previous
+    end
+
+    def warn_about_start_in_dot_simplecov
+      return if @dot_simplecov_start_warned
+
+      @dot_simplecov_start_warned = true
+      warn "[DEPRECATION] Calling `SimpleCov.start` from `.simplecov` is deprecated and will " \
+           "be removed in a future release. `.simplecov` should contain configuration only; " \
+           "move the `SimpleCov.start` call into your `spec_helper.rb` / `test_helper.rb`. " \
+           "Coverage tracking still begins for backward compatibility, but a future release " \
+           "will require the explicit `SimpleCov.start` from a test helper. " \
+           "See https://github.com/simplecov-ruby/simplecov/issues/581."
+    end
+
+    #
+    # Install the at_exit hook that formats results and runs exit-code
+    # checks. `SimpleCov.start` calls this automatically. Idempotent —
+    # safe to call multiple times. Callers that drive the formatting
+    # pipeline themselves (e.g., dogfood test setups) can skip it by
+    # using `start_tracking` directly instead of `start`.
+    #
+    def install_at_exit_hook
+      return if @at_exit_hook_installed
+
+      @at_exit_hook_installed = true
+      defer_to_minitest_after_run if minitest_autorun_pending?
+      Kernel.at_exit do
+        next if SimpleCov.external_at_exit?
+
+        SimpleCov.at_exit_behavior
+      end
+    end
+
+    #
+    # Begin coverage tracking without applying configuration. Pairs with
+    # `SimpleCov.configure { ... }` for callers that want to separate
+    # the two — for example a dogfood test that has already started
+    # `Coverage` itself before requiring simplecov, but still wants the
+    # process_start_time / pid / fork-hook bookkeeping.
+    #
+    def start_tracking
+      require "coverage"
+      warn_if_jruby_full_trace_disabled
+      validate_coverage_criteria!
+      # simplecov:disable — fork-hook is enabled via SimpleCov.enable_for_subprocesses, off by default
+      require_relative "simplecov/process" if SimpleCov.enabled_for_subprocesses? &&
+                                              ::Process.respond_to?(:_fork)
+      # simplecov:enable
+
+      # Trigger adapter selection now so the (possibly lazy) parallel_tests
+      # gem load happens at start_tracking time rather than mid-suite.
+      # `current` is memoized; subsequent calls are cheap.
+      SimpleCov::ParallelAdapters.current
+
+      @result = nil
+      self.pid = Process.pid
+      self.process_start_time = Time.now
+
+      start_coverage_measurement
+    end
+
+  private
+
+    #
+    # Trigger Coverage.start with the configured criteria. Every supported
+    # runtime (CRuby >= 3.2, JRuby >= 10, TruffleRuby >= 22) accepts the
+    # criteria-hash form, so no compatibility fallback is needed.
+    #
+    def start_coverage_measurement
+      start_arguments = coverage_criteria.to_h do |criterion|
+        [CRITERION_TO_RUBY_COVERAGE.fetch(criterion), true]
+      end
+
+      start_arguments[:eval] = true if coverage_for_eval_enabled?
+
+      Coverage.start(start_arguments) unless Coverage.running?
+    end
+
+    # `Rake::TestTask` runs `ruby -e 'require "minitest/autorun"; ...'`,
+    # which means Minitest's at_exit registers before SimpleCov's. Since
+    # at_exit fires LIFO, SimpleCov's hook would otherwise run *before*
+    # Minitest gets a chance to invoke the tests — and format an empty
+    # resultset. When we can see that Minitest is loaded and its autorun
+    # is armed, route the report through `Minitest.after_run` instead,
+    # which fires after the suite completes. See issues #1099 and #1112.
+    def minitest_autorun_pending?
+      return false unless defined?(Minitest) && Minitest.respond_to?(:after_run)
+      return false unless Minitest.class_variable_defined?(:@@installed_at_exit)
+
+      Minitest.class_variable_get(:@@installed_at_exit)
+    end
+
+    def defer_to_minitest_after_run
+      self.external_at_exit = true
+      Minitest.after_run { SimpleCov.at_exit_behavior }
+    end
+
+    # JRuby coverage data is unreliable unless full-trace mode is enabled.
+    # @see https://github.com/jruby/jruby/issues/1196
+    # @see https://github.com/simplecov-ruby/simplecov/issues/420
+    # @see https://github.com/simplecov-ruby/simplecov/issues/86
+    def warn_if_jruby_full_trace_disabled
+      return unless defined?(JRUBY_VERSION) && defined?(JRuby) # simplecov:disable — JRuby-only branch
+
+      # simplecov:disable — JRuby-only branches; unreachable from CRuby
+      return if org.jruby.RubyInstanceConfig.FULL_TRACE_ENABLED
+
+      warn 'Coverage may be inaccurate; set the "--debug" command line option, ' \
+           'or do JRUBY_OPTS="--debug" ' \
+           'or set the "debug.fullTrace=true" option in your .jrubyrc'
+      # simplecov:enable
+    end
+  end
+end
+
+# requires are down here for a load order reason I'm not sure what it is about
+require "forwardable"
+require_relative "simplecov/color"
+require_relative "simplecov/deprecation"
+require_relative "simplecov/configuration"
+SimpleCov.extend SimpleCov::Configuration
+require_relative "simplecov/coverage_statistics"
+require_relative "simplecov/coverage_violations"
+require_relative "simplecov/exit_codes"
+require_relative "simplecov/profiles"
+require_relative "simplecov/source_file/line"
+require_relative "simplecov/source_file/branch"
+require_relative "simplecov/source_file/method"
+require_relative "simplecov/source_file"
+require_relative "simplecov/file_list"
+require_relative "simplecov/result"
+require_relative "simplecov/filter"
+require_relative "simplecov/formatter"
+require_relative "simplecov/last_run"
+require_relative "simplecov/lines_classifier"
+require_relative "simplecov/result_merger"
+require_relative "simplecov/parallel_adapters"
+require_relative "simplecov/command_guesser"
+require_relative "simplecov/version"
+require_relative "simplecov/result_adapter"
+require_relative "simplecov/combine"
+require_relative "simplecov/combine/branches_combiner"
+require_relative "simplecov/combine/methods_combiner"
+require_relative "simplecov/combine/files_combiner"
+require_relative "simplecov/combine/lines_combiner"
+require_relative "simplecov/combine/results_combiner"
+require_relative "simplecov/useless_results_remover"
+require_relative "simplecov/simulate_coverage"
+require_relative "simplecov/result_processing"
+require_relative "simplecov/exit_handling"
+require_relative "simplecov/parallel_coordination"
+
+# Load default config
+# simplecov:disable — env-var only set by aruba feature tests
+require_relative "simplecov/defaults" unless ENV["SIMPLECOV_NO_DEFAULTS"]

data/simplecov-1.0.0/lib/simplecov_json_formatter.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Backward-compatibility shim: simplecov_json_formatter is now part of simplecov.
+require_relative "simplecov/formatter/json_formatter"

data/simplecov-1.0.0/schemas/coverage-v1.0.schema.json

@@ -0,0 +1,306 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/simplecov-ruby/simplecov/main/schemas/coverage-v1.0.schema.json",
+  "title": "SimpleCov coverage.json",
+  "description": "Schema for the coverage.json file emitted by SimpleCov's JSONFormatter. Versioned independently of the gem. Non-breaking additions bump the minor segment of schema_version, breaking changes bump the major segment. The versioned file at schemas/coverage-vX.Y.schema.json is the canonical artifact for that version, schemas/coverage.schema.json is a convenience alias for the latest.",
+  "type": "object",
+  "required": ["$schema", "meta", "total", "coverage", "groups", "errors"],
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "format": "uri",
+      "description": "URL of the JSON Schema this document conforms to. Pinned to the versioned canonical URL so documents stay validatable against the exact contract they were emitted under, even after the schema evolves."
+    },
+    "meta": {
+      "type": "object",
+      "required": [
+        "schema_version",
+        "simplecov_version",
+        "command_name",
+        "project_name",
+        "timestamp",
+        "root",
+        "commit",
+        "primary_coverage",
+        "line_coverage",
+        "branch_coverage",
+        "method_coverage"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "schema_version": {
+          "type": "string",
+          "const": "1.0",
+          "description": "Schema major.minor. Additive changes bump minor; breaking changes bump major. Update this `const` whenever the schema version is bumped so documents claiming a different version don't quietly validate against this contract."
+        },
+        "simplecov_version": {
+          "type": "string",
+          "description": "The version of the SimpleCov gem that produced this file."
+        },
+        "command_name": {"type": "string"},
+        "project_name": {"type": "string"},
+        "timestamp": {
+          "type": "string",
+          "format": "date-time",
+          "description": "ISO 8601 timestamp with millisecond precision."
+        },
+        "root": {
+          "type": "string",
+          "description": "Absolute path to SimpleCov.root at the time of write."
+        },
+        "commit": {
+          "type": ["string", "null"],
+          "description": "Full git commit SHA of `root`'s HEAD when the report was generated, or null when the project isn't a git checkout (or git isn't available). Lets tools recover the exact source a report reflects, which matters most when `source_in_json` is false and the per-file `source` arrays are omitted."
+        },
+        "primary_coverage": {
+          "type": "string",
+          "enum": ["line", "branch", "method"],
+          "description": "The coverage criterion `SimpleCov.primary_coverage` names as primary. The HTML report sorts file lists by this criterion's coverage by default."
+        },
+        "line_coverage": {"type": "boolean"},
+        "branch_coverage": {"type": "boolean"},
+        "method_coverage": {"type": "boolean"}
+      }
+    },
+    "total": {"$ref": "#/definitions/totals"},
+    "coverage": {
+      "type": "object",
+      "description": "Map of project-relative file paths to per-file coverage data.",
+      "additionalProperties": {"$ref": "#/definitions/source_file"}
+    },
+    "groups": {
+      "type": "object",
+      "description": "Map of group names to per-group totals plus the list of files in the group.",
+      "additionalProperties": {"$ref": "#/definitions/group"}
+    },
+    "errors": {
+      "type": "object",
+      "description": "Threshold violations from minimum_coverage, minimum_coverage_by_file, minimum_coverage_by_group, maximum_coverage, and maximum_coverage_drop. Empty object when no thresholds were violated.",
+      "additionalProperties": false,
+      "properties": {
+        "minimum_coverage": {
+          "type": "object",
+          "description": "Keyed by criterion: lines, branches, methods.",
+          "additionalProperties": {"$ref": "#/definitions/expected_actual"}
+        },
+        "minimum_coverage_by_file": {
+          "type": "object",
+          "description": "Keyed by project-relative filename, then by criterion (lines, branches, methods).",
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": {"$ref": "#/definitions/expected_actual"}
+          }
+        },
+        "minimum_coverage_by_group": {
+          "type": "object",
+          "description": "Keyed by group name, then by criterion (lines, branches, methods).",
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": {"$ref": "#/definitions/expected_actual"}
+          }
+        },
+        "maximum_coverage": {
+          "type": "object",
+          "description": "Keyed by criterion: lines, branches, methods. `expected` is the configured maximum, `actual` is the measured value that exceeded it.",
+          "additionalProperties": {"$ref": "#/definitions/expected_actual"}
+        },
+        "maximum_coverage_drop": {
+          "type": "object",
+          "description": "Keyed by criterion: lines, branches, methods.",
+          "additionalProperties": {"$ref": "#/definitions/maximum_actual"}
+        }
+      }
+    }
+  },
+  "definitions": {
+    "totals": {
+      "type": "object",
+      "additionalProperties": false,
+      "anyOf": [
+        {"required": ["lines"]},
+        {"required": ["branches"]},
+        {"required": ["methods"]}
+      ],
+      "properties": {
+        "lines": {"$ref": "#/definitions/line_statistic"},
+        "branches": {"$ref": "#/definitions/coverage_statistic"},
+        "methods": {"$ref": "#/definitions/coverage_statistic"}
+      }
+    },
+    "source_file": {
+      "type": "object",
+      "additionalProperties": false,
+      "anyOf": [
+        {"required": ["lines"]},
+        {"required": ["branches"]},
+        {"required": ["methods"]}
+      ],
+      "dependentRequired": {
+        "lines":                    ["lines_covered_percent", "covered_lines", "missed_lines", "omitted_lines", "total_lines"],
+        "lines_covered_percent":    ["lines", "covered_lines", "missed_lines", "omitted_lines", "total_lines"],
+        "covered_lines":            ["lines", "lines_covered_percent", "missed_lines", "omitted_lines", "total_lines"],
+        "missed_lines":             ["lines", "lines_covered_percent", "covered_lines", "omitted_lines", "total_lines"],
+        "omitted_lines":            ["lines", "lines_covered_percent", "covered_lines", "missed_lines", "total_lines"],
+        "total_lines":              ["lines", "lines_covered_percent", "covered_lines", "missed_lines", "omitted_lines"],
+        "branches":                 ["branches_covered_percent", "covered_branches", "missed_branches", "total_branches"],
+        "branches_covered_percent": ["branches", "covered_branches", "missed_branches", "total_branches"],
+        "covered_branches":         ["branches", "branches_covered_percent", "missed_branches", "total_branches"],
+        "missed_branches":          ["branches", "branches_covered_percent", "covered_branches", "total_branches"],
+        "total_branches":           ["branches", "branches_covered_percent", "covered_branches", "missed_branches"],
+        "methods":                  ["methods_covered_percent", "covered_methods", "missed_methods", "total_methods"],
+        "methods_covered_percent":  ["methods", "covered_methods", "missed_methods", "total_methods"],
+        "covered_methods":          ["methods", "methods_covered_percent", "missed_methods", "total_methods"],
+        "missed_methods":           ["methods", "methods_covered_percent", "covered_methods", "total_methods"],
+        "total_methods":            ["methods", "methods_covered_percent", "covered_methods", "missed_methods"]
+      },
+      "properties": {
+        "lines": {
+          "type": "array",
+          "description": "Per-source-line coverage. Element index N corresponds to source line N+1. Integer hit-count, null for non-relevant (blank/comment) lines, or the string \"ignored\" for lines inside a simplecov:disable / :nocov: region. Present if and only if `meta.line_coverage` is true. When present, the five line stat fields (`lines_covered_percent`, `covered_lines`, `missed_lines`, `omitted_lines`, `total_lines`) are guaranteed to be present too.",
+          "items": {"$ref": "#/definitions/line_coverage"}
+        },
+        "source": {
+          "type": "array",
+          "description": "Source lines of the file, in order (one entry per physical line). When the per-file `lines` array is present it has the same length, but `source` is emitted independently of line coverage. Present only when SimpleCov.source_in_json is true (the default); omitted when downstream tools opt out via `source_in_json false` to keep coverage.json smaller.",
+          "items": {"type": "string"}
+        },
+        "lines_covered_percent": {"type": "number"},
+        "covered_lines": {"type": "integer", "minimum": 0, "description": "Count of executable lines that were hit at least once."},
+        "missed_lines": {"type": "integer", "minimum": 0, "description": "Count of executable lines that were never hit."},
+        "omitted_lines": {"type": "integer", "minimum": 0, "description": "Count of non-executable lines (blank lines, comments). Mirrors `total.lines.omitted` at the per-file level. Excludes lines inside simplecov:disable / :nocov: regions, which surface as `\"ignored\"` in the `lines` array."},
+        "total_lines": {"type": "integer", "minimum": 0, "description": "Count of executable lines: `covered_lines + missed_lines`. Does not include non-executable (omitted) lines or lines inside simplecov:disable / :nocov: regions, so this can be smaller than `lines.length`."},
+        "branches": {
+          "type": "array",
+          "description": "Per-branch coverage. Present if and only if `meta.branch_coverage` is true. When present, the four branch stat fields (`branches_covered_percent`, `covered_branches`, `missed_branches`, `total_branches`) are guaranteed to be present too.",
+          "items": {"$ref": "#/definitions/branch"}
+        },
+        "branches_covered_percent": {"type": "number"},
+        "covered_branches": {"type": "integer", "minimum": 0},
+        "missed_branches": {"type": "integer", "minimum": 0},
+        "total_branches": {"type": "integer", "minimum": 0, "description": "Count of branches: `covered_branches + missed_branches`."},
+        "methods": {
+          "type": "array",
+          "description": "Per-method coverage. Present if and only if `meta.method_coverage` is true. When present, the four method stat fields (`methods_covered_percent`, `covered_methods`, `missed_methods`, `total_methods`) are guaranteed to be present too.",
+          "items": {"$ref": "#/definitions/method"}
+        },
+        "methods_covered_percent": {"type": "number"},
+        "covered_methods": {"type": "integer", "minimum": 0},
+        "missed_methods": {"type": "integer", "minimum": 0},
+        "total_methods": {"type": "integer", "minimum": 0, "description": "Count of methods: `covered_methods + missed_methods`."}
+      }
+    },
+    "branch": {
+      "type": "object",
+      "required": ["type", "start_line", "end_line", "coverage", "inline", "report_line"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "type": "string",
+          "description": "Branch kind from Ruby's Coverage library (e.g. \"then\", \"else\", \"when\")."
+        },
+        "start_line": {"type": "integer", "minimum": 1},
+        "end_line": {"type": "integer", "minimum": 1},
+        "coverage": {"$ref": "#/definitions/branch_method_coverage"},
+        "inline": {"type": "boolean"},
+        "report_line": {"type": "integer", "minimum": 1, "description": "Line of the conditional that owns this branch (the `if`, `case`, or `&&` line), not the start of the branch body. Useful for rendering annotations at the decision point."}
+      }
+    },
+    "method": {
+      "type": "object",
+      "required": ["name", "start_line", "end_line", "coverage"],
+      "additionalProperties": false,
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "Qualified method name, e.g. \"Foo#bar\", \"Foo.bar\", or \"Foo::Bar#baz\"."
+        },
+        "start_line": {"type": "integer", "minimum": 1},
+        "end_line": {"type": "integer", "minimum": 1},
+        "coverage": {"$ref": "#/definitions/branch_method_coverage"}
+      }
+    },
+    "group": {
+      "type": "object",
+      "required": ["files"],
+      "additionalProperties": false,
+      "anyOf": [
+        {"required": ["lines"]},
+        {"required": ["branches"]},
+        {"required": ["methods"]}
+      ],
+      "properties": {
+        "lines": {"$ref": "#/definitions/line_statistic"},
+        "branches": {"$ref": "#/definitions/coverage_statistic"},
+        "methods": {"$ref": "#/definitions/coverage_statistic"},
+        "files": {
+          "type": "array",
+          "description": "Project-relative paths of the files that fell into this group.",
+          "items": {"type": "string"}
+        }
+      }
+    },
+    "line_statistic": {
+      "type": "object",
+      "required": ["covered", "missed", "omitted", "total", "percent", "strength"],
+      "additionalProperties": false,
+      "properties": {
+        "covered": {"type": "integer", "minimum": 0},
+        "missed": {"type": "integer", "minimum": 0},
+        "omitted": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Lines that cannot be covered (blank, comment, etc.). Only present on line stats."
+        },
+        "total": {"type": "integer", "minimum": 0, "description": "Executable lines: `covered + missed`. Does not include `omitted`."},
+        "percent": {"type": "number"},
+        "strength": {"type": "number", "description": "Average number of executions across covered lines (hits per covered line)."}
+      }
+    },
+    "coverage_statistic": {
+      "type": "object",
+      "required": ["covered", "missed", "total", "percent", "strength"],
+      "additionalProperties": false,
+      "properties": {
+        "covered": {"type": "integer", "minimum": 0},
+        "missed": {"type": "integer", "minimum": 0},
+        "total": {"type": "integer", "minimum": 0, "description": "Total branches or methods: `covered + missed`."},
+        "percent": {"type": "number"},
+        "strength": {"type": "number", "description": "Average number of executions across covered branches or methods (hits per covered item)."}
+      }
+    },
+    "line_coverage": {
+      "description": "Coverage value for a source line in the per-file `lines` array. Integer hit count, `null` for a non-executable line (blank or comment), or the literal string `\"ignored\"` for a line inside a simplecov:disable / :nocov: region.",
+      "oneOf": [
+        {"type": "integer", "minimum": 0},
+        {"type": "null"},
+        {"type": "string", "const": "ignored"}
+      ]
+    },
+    "branch_method_coverage": {
+      "description": "Coverage value for a branch or method `coverage` field. Integer hit count, or the literal string `\"ignored\"` for code inside a simplecov:disable / :nocov: region. Unlike line coverage, `null` never occurs: every branch and method maps to an executable construct.",
+      "oneOf": [
+        {"type": "integer", "minimum": 0},
+        {"type": "string", "const": "ignored"}
+      ]
+    },
+    "expected_actual": {
+      "type": "object",
+      "required": ["expected", "actual"],
+      "additionalProperties": false,
+      "properties": {
+        "expected": {"type": "number"},
+        "actual": {"type": "number"}
+      }
+    },
+    "maximum_actual": {
+      "type": "object",
+      "required": ["maximum", "actual"],
+      "additionalProperties": false,
+      "properties": {
+        "maximum": {"type": "number"},
+        "actual": {"type": "number"}
+      }
+    }
+  }
+}