branchproof 0.6.0 → 0.8.0

data/lib/branchproof/evidence.rb

@@ -20,10 +20,16 @@ module Branchproof
       raise ArgumentError, "run_id is required" if run_id.nil? || run_id.to_s.empty?
 
       @inventory = inventory
+      @decisions_by_id = Array(fetch_value(@inventory, :decisions)).each_with_object({}) do |raw, index|
+        decision = symbolize(raw)
+        index[decision[:id].to_s] = decision
+      end
       @limits = normalize_limits(limits)
       @run_id = run_id.to_s
       @run_ids = [@run_id]
       @vectors = {}
+      @vector_counts_by_decision = Hash.new(0)
+      @owner_associations_count = 0
       @tests = {}
       @run_payloads = {}
       @abort_counts = Hash.new(0)
@@ -68,12 +74,13 @@ module Branchproof
       end
       decision_id = value[:decision_id].to_s
       vector_values = condition_values(decision_id, value[:observations])
-      if new_vector?(decision_id, vector_values,
-                     value[:outcome]) && vector_count(decision_id) >= @limits[:vectors_per_decision]
+      outcome = value[:outcome] ? true : false
+      vector_id = Branchproof::Records.id([decision_id, vector_values, outcome])
+      if new_vector?(vector_id) && vector_count(decision_id) >= @limits[:vectors_per_decision]
         @limited = true
         return status("limited", "vectors_per_decision reached")
       end
-      vector = vector_for(decision_id, vector_values, value[:outcome] ? true : false)
+      vector = vector_for(decision_id, vector_values, outcome, vector_id)
       new_owner = if value[:test_id]
                     !vector[:test_ids].include?(value[:test_id].to_s)
                   else
@@ -89,6 +96,7 @@ module Branchproof
       phase_map << value[:phase].to_s if phase_map && !phase_map.include?(value[:phase].to_s)
       vector[:unattributed_count] += 1 unless value[:test_id]
       vector[:count] += 1
+      @owner_associations_count += 1 if new_owner
       if value[:test_id] && @tests.key?(value[:test_id].to_s)
         test = @tests[value[:test_id].to_s]
         phase = value[:phase].to_s
@@ -194,25 +202,24 @@ module Branchproof
     def validate_execution(value)
       return "execution must be a hash" unless value.is_a?(Hash)
 
-      %i[run_id execution_id decision_id test_id phase owner observations outcome status].each do |key|
+      %i[run_id decision_id test_id phase observations outcome status].each do |key|
         return "missing #{key}" unless value.key?(key)
       end
       return "run mismatch" unless value[:run_id].to_s == @run_id
-      return "invalid owner" unless value[:owner].is_a?(Hash)
       return "invalid status" unless %w[completed aborted invalid].include?(value[:status].to_s)
       return "invalid phase" unless %w[setup body teardown suite unattributed].include?(value[:phase].to_s)
       return "invalid observations" unless value[:observations].is_a?(Array) && value[:observations].all? do |pair|
         pair.is_a?(Array) && pair.length == 2 && pair[0].is_a?(Integer) && [true, false].include?(pair[1])
       end
 
-      decision = decisions.find { |d| d[:id].to_s == value[:decision_id].to_s }
+      decision = @decisions_by_id[value[:decision_id].to_s]
       return "unknown decision" unless decision
 
-      conditions = Array(decision[:conditions])
-      return "condition count exceeds limit" if conditions.length > @limits[:conditions_per_decision]
+      dimensions = alternative_decision?(decision) ? Array(decision[:alternatives]) : Array(decision[:conditions])
+      return "condition count exceeds limit" if !alternative_decision?(decision) && dimensions.length > @limits[:conditions_per_decision]
       return "invalid condition index" unless value[:observations].map(&:first).uniq == value[:observations].map(&:first) && value[:observations].all? do |index, _|
-        conditions.any? do |c|
-          c[:index].to_i == index
+        dimensions.any? do |dimension|
+          dimension[:index].to_i == index
         end
       end
       return "invalid trace" unless value[:status].to_s != "completed" || valid_trace?(decision, value[:observations],
@@ -222,7 +229,9 @@ module Branchproof
     end
 
     def valid_trace?(decision, observations, outcome)
-      tree = symbolize(decision[:tree])
+      return valid_alternative_trace?(decision, observations, outcome) if alternative_decision?(decision)
+
+      tree = decision[:tree]
       unless tree
         return observations.map(&:first) == observations.map(&:first).sort &&
                (outcome ? true : false) == evaluate_fallback(observations)
@@ -237,7 +246,6 @@ module Branchproof
     end
 
     def replay_tree(node, observations, cursor)
-      node = symbolize(node)
       type = node[:type].to_s
       if type == "atom"
         pair = observations[cursor]
@@ -245,6 +253,13 @@ module Branchproof
 
         return [pair[1], cursor + 1]
       end
+      if type == "not"
+        child = replay_tree(node.fetch(:child), observations, cursor)
+        return nil unless child
+
+        child_value, next_cursor = child
+        return [!child_value, next_cursor]
+      end
       left = replay_tree(node.fetch(:left), observations, cursor)
       return nil unless left
 
@@ -265,32 +280,48 @@ module Branchproof
     end
 
     def condition_values(decision_id, observations)
-      count = decision_conditions(decision_id).length
+      count = decision_dimension_count(decision_id)
       values = Array.new(count)
       observations.each { |index, value| values[index] = value }
       values
     end
 
-    def vector_for(decision_id, values, outcome)
-      id = Branchproof::Records.id([decision_id, values, outcome])
-      @vectors[id] ||= { id: id, decision_id: decision_id, values: values.dup, outcome: outcome,
-                         test_ids: [], phases_by_test: {}, unattributed_count: 0, count: 0 }
+    def vector_for(decision_id, values, outcome, id)
+      existing = @vectors[id]
+      return existing if existing
+
+      vector = { id: id, decision_id: decision_id, values: values.dup, outcome: outcome,
+                 test_ids: [], phases_by_test: {}, unattributed_count: 0, count: 0 }
+      @vectors[id] = vector
+      @vector_counts_by_decision[decision_id] += 1
+      vector
     end
 
     def merge_vector(raw)
       vector = symbolize(raw)
-      existing = @vectors[vector[:id].to_s]
+      id = vector[:id].to_s
+      existing = @vectors[id]
       if existing
-        existing[:test_ids] |= Array(vector[:test_ids]).map(&:to_s)
+        new_test_ids = Array(vector[:test_ids]).map(&:to_s) - existing[:test_ids]
+        existing[:test_ids] |= new_test_ids
         vector.fetch(:phases_by_test, {}).each do |test, phases|
           existing[:phases_by_test][test.to_s] = (existing[:phases_by_test][test.to_s] || []) | phases
         end
+        was_unattributed = existing[:unattributed_count].positive?
         existing[:count] += vector[:count].to_i
         existing[:unattributed_count] += vector[:unattributed_count].to_i
+        @owner_associations_count += new_test_ids.length
+        @owner_associations_count += 1 if !was_unattributed && existing[:unattributed_count].positive?
       else
-        @vectors[vector[:id].to_s] = { id: vector[:id].to_s, decision_id: vector[:decision_id].to_s,
-                                       values: Array(vector[:values]).dup, outcome: !!vector[:outcome], test_ids: Array(vector[:test_ids]).map(&:to_s),
-                                       phases_by_test: vector.fetch(:phases_by_test, {}).transform_keys(&:to_s), unattributed_count: vector[:unattributed_count].to_i, count: vector[:count].to_i }
+        decision_id = vector[:decision_id].to_s
+        test_ids = Array(vector[:test_ids]).map(&:to_s)
+        unattributed_count = vector[:unattributed_count].to_i
+        @vectors[id] = { id: id, decision_id: decision_id,
+                         values: Array(vector[:values]).dup, outcome: !!vector[:outcome], test_ids: test_ids,
+                         phases_by_test: vector.fetch(:phases_by_test, {}).transform_keys(&:to_s), unattributed_count: unattributed_count, count: vector[:count].to_i }
+        @vector_counts_by_decision[decision_id] += 1
+        @owner_associations_count += test_ids.length
+        @owner_associations_count += 1 if unattributed_count.positive?
       end
     end
 
@@ -305,10 +336,14 @@ module Branchproof
     end
 
     def condition_shapes
-      decisions.to_h do |decision|
-        [decision[:id].to_s, { conditions: Array(decision[:conditions]).map do |condition|
-          symbolize(condition)
-        end, tree: symbolize(decision[:tree]) }]
+      @decisions_by_id.transform_values do |decision|
+        shape = { conditions: Array(decision[:conditions]).map { |condition| symbolize(condition) },
+                  tree: symbolize(decision[:tree]) }
+        if alternative_decision?(decision)
+          shape[:kind] = decision[:kind].to_s
+          shape[:alternatives] = Array(decision[:alternatives]).map { |alternative| symbolize(alternative) }
+        end
+        shape
       end
     end
 
@@ -335,9 +370,11 @@ module Branchproof
         vector = symbolize(raw)
         return "invalid vector" unless vector[:id] && vector[:decision_id] && vector[:values].is_a?(Array)
 
-        decision = decisions.find { |item| item[:id].to_s == vector[:decision_id].to_s }
+        decision = @decisions_by_id[vector[:decision_id].to_s]
         return "unknown decision" unless decision
-        return "invalid vector shape" unless vector[:values].length == Array(decision[:conditions]).length &&
+
+        expected_values = decision_dimension_count(decision)
+        return "invalid vector shape" unless vector[:values].length == expected_values &&
                                              vector[:values].all? { |item| item.nil? || item == true || item == false }
 
         expected = Branchproof::Records.id([vector[:decision_id].to_s, vector[:values], vector[:outcome] ? true : false])
@@ -375,17 +412,42 @@ module Branchproof
       nil
     end
 
-    def decisions = Array(fetch_value(@inventory, :decisions)).map { symbolize(_1) }
-    def decision_conditions(id) = (decisions.find { |d| d[:id].to_s == id.to_s } || {}).fetch(:conditions, [])
-    def vector_count(id) = @vectors.values.count { |v| v[:decision_id] == id.to_s }
-    def new_vector?(id, values, outcome) = !@vectors.key?(Branchproof::Records.id([id, values, outcome]))
+    def alternative_decision?(decision)
+      kind = decision[:kind].to_s
+      !kind.empty? && kind != "boolean"
+    end
+
+    def decision_dimension_count(decision_or_id)
+      decision = decision_or_id.is_a?(Hash) ? decision_or_id : @decisions_by_id[decision_or_id.to_s]
+      return 0 unless decision
 
-    def owner_associations
-      @vectors.values.sum do |v|
-        v[:test_ids].length + (v[:unattributed_count].positive? ? 1 : 0)
+      alternative_decision?(decision) ? Array(decision[:alternatives]).length : Array(decision[:conditions]).length
+    end
+
+    def valid_alternative_trace?(decision, observations, outcome)
+      return false unless outcome == true
+
+      alternatives = Array(decision[:alternatives])
+      expected = alternatives.length
+      return false unless expected.positive?
+      if decision[:kind].to_s == "implicit"
+        return expected == 2 && observations.length == 2 &&
+               observations.map(&:first) == [0, 1] && observations.map(&:last).count(true) == 1
+      end
+
+      return false unless observations.length.between?(1, expected)
+
+      observations.each_with_index.all? do |(index, value), position|
+        index == position && value == (position == observations.length - 1)
       end
     end
 
+    def decision_conditions(id) = (@decisions_by_id[id.to_s] || {}).fetch(:conditions, [])
+    def vector_count(id) = @vector_counts_by_decision[id.to_s]
+    def new_vector?(id) = !@vectors.key?(id)
+
+    def owner_associations = @owner_associations_count
+
     def incoming_owner_associations(incoming)
       owners = @vectors.each_with_object({}) do |(_id, vector), result|
         vector[:test_ids].each { |test_id| result[[vector[:id], test_id]] = true }
@@ -455,7 +517,8 @@ module Branchproof
     def capture_state
       { vectors: deep_dup(@vectors), tests: deep_dup(@tests), run_ids: @run_ids.dup,
         run_payloads: @run_payloads.dup, diagnostics: deep_dup(@diagnostics),
-        abort_counts: @abort_counts.dup, limited: @limited, attribution_complete: @attribution_complete }
+        abort_counts: @abort_counts.dup, limited: @limited, attribution_complete: @attribution_complete,
+        vector_counts_by_decision: @vector_counts_by_decision.dup, owner_associations_count: @owner_associations_count }
     end
 
     def restore_state(state)
@@ -465,6 +528,8 @@ module Branchproof
       @run_payloads = state[:run_payloads]
       @diagnostics = state[:diagnostics]
       @abort_counts = state[:abort_counts]
+      @vector_counts_by_decision = state[:vector_counts_by_decision]
+      @owner_associations_count = state[:owner_associations_count]
       @limited = state[:limited]
       @attribution_complete = state[:attribution_complete]
     end

data/lib/branchproof/flow_instrumentation.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+# Keep each bounded source rewrite together so its evaluation order can be audited.
+# rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+
+module Branchproof
+  # Source-location edits around Ruby's native matching and assignment operations.
+  module FlowInstrumentation
+    private
+
+    def render_flow(bytes, decision, nested, encloses)
+      metadata = decision.fetch(:instrumentation)
+      case metadata.fetch(:type)
+      when "safe_navigation"
+        receiver = metadata.fetch(:receiver)
+        replacements = [flow_replacement(bytes, receiver, nested, encloses) do |expression|
+          "#{self.class::RUNTIME}.flow_receiver(#{decision[:id].inspect}, (#{expression}))"
+        end]
+        flow_fragments(bytes, decision, nested, replacements, encloses)
+      when "assignment"
+        rhs = metadata.fetch(:rhs)
+        replacements = [flow_replacement(bytes, rhs, nested, encloses) do |expression|
+          "(begin; #{self.class::RUNTIME}.flow_path(#{decision[:id].inspect}, 1); (#{expression}); end)"
+        end]
+        expression = flow_fragments(bytes, decision, nested, replacements, encloses)
+        flow_frame(decision[:id], expression, default_path: 0)
+      when "case"
+        render_case_flow(bytes, decision, nested, metadata, encloses)
+      when "case_match"
+        render_pattern_flow(bytes, decision, nested, metadata, encloses)
+      else
+        raise ArgumentError, "unknown instrumentation type: #{metadata[:type]}"
+      end
+    end
+
+    def render_case_flow(bytes, decision, nested, metadata, encloses)
+      identifier = decision[:id].inspect
+      runtime = self.class::RUNTIME
+      replacements = metadata.fetch(:candidates).map do |candidate|
+        flow_replacement(bytes, candidate, nested, encloses) do |expression|
+          "(begin; #{runtime}.flow_candidate(#{identifier}, #{candidate[:index]}); (#{expression}); end)"
+        end
+      end
+      metadata.fetch(:branches).each do |branch|
+        suffix = branch[:empty] ? "nil; " : ""
+        replacements << { start: branch[:insert_at], length: 0,
+                          text: "; #{runtime}.flow_selected(#{identifier}); #{suffix}" }
+      end
+      if metadata[:else]
+        alternative = metadata[:else]
+        replacements << { start: alternative[:insert_at], length: 0,
+                          text: "; #{runtime}.flow_select(#{identifier}, #{alternative[:index]}); " }
+      else
+        index = decision.fetch(:alternatives).length - 1
+        replacements << { start: metadata.fetch(:end_start), length: 0,
+                          text: "else; #{runtime}.flow_select(#{identifier}, #{index}); nil; " }
+      end
+      flow_frame(decision[:id], flow_fragments(bytes, decision, nested, replacements, encloses))
+    end
+
+    def render_pattern_flow(bytes, decision, nested, metadata, encloses)
+      identifier = decision[:id].inspect
+      runtime = self.class::RUNTIME
+      replacements = metadata.fetch(:branches).map do |branch|
+        suffix = branch[:empty] ? "nil; " : ""
+        { start: branch[:insert_at], length: 0,
+          text: "; #{runtime}.flow_select(#{identifier}, #{branch[:index]}); #{suffix}" }
+      end
+      if metadata[:else]
+        alternative = metadata[:else]
+        replacements << { start: alternative[:insert_at], length: 0,
+                          text: "; #{runtime}.flow_select(#{identifier}, #{alternative[:index]}); " }
+      end
+      flow_frame(decision[:id], flow_fragments(bytes, decision, nested, replacements, encloses))
+    end
+
+    def flow_replacement(bytes, location, nested, encloses)
+      start = location.fetch(:byte_start)
+      length = location.fetch(:byte_length)
+      { start: start, length: length, text: yield(render_children(bytes, start, length, nested, encloses)) }
+    end
+
+    def flow_fragments(bytes, decision, nested, replacements, encloses)
+      cursor = decision.fetch(:byte_start)
+      finish = cursor + decision.fetch(:byte_length)
+      chunks = []
+      replacements.sort_by { |edit| [edit[:start], edit[:length]] }.each do |edit|
+        raise ArgumentError, "overlapping flow edits" if edit[:start] < cursor
+
+        chunks << render_children(bytes, cursor, edit[:start] - cursor, nested, encloses)
+        chunks << edit[:text]
+        cursor = edit[:start] + edit[:length]
+      end
+      chunks << render_children(bytes, cursor, finish - cursor, nested, encloses)
+      chunks.join
+    end
+
+    def flow_frame(decision_id, expression, default_path: nil)
+      runtime = self.class::RUNTIME
+      "(begin; #{runtime}.enter(#{decision_id.inspect}); begin; " \
+        "#{runtime}.flow_finish(#{decision_id.inspect}, (#{expression}), #{default_path.inspect}); ensure; " \
+        "#{runtime}.leave(#{decision_id.inspect}); end; end)"
+    end
+  end
+end
+
+# rubocop:enable Metrics/AbcSize, Metrics/MethodLength

data/lib/branchproof/focused_report.rb

@@ -6,16 +6,23 @@ require "pathname"
 module Branchproof
   # Terminal renderings grouped around conditions or tests.
   class FocusedReport
-    def initialize(document:, view:, level:, missing_only: false)
+    DECISION_TABLE_LABELS = { "true" => "T", "false" => "F", "dont_care" => "-" }.freeze
+
+    def initialize(document:, view:, level:, missing_only: false, coordinator: nil)
       @document = document || {}
       @view = view.to_sym
-      raise ArgumentError, "view must be :conditions or :tests" unless %i[conditions tests].include?(@view)
+      unless (Report::VIEWS - [:decisions]).include?(@view)
+        raise ArgumentError, "view must be :conditions, :tests, or :decision_tables"
+      end
 
       @level = level.to_i
       @missing_only = missing_only ? true : false
       @index = CoverageIndex.new(document: @document)
       @tests = @index.tests.to_h { |test| [test[:id].to_s, test] }
-      @coordinator = Report.from_document(document: @document, level: @level)
+      @test_name_counts = @index.tests.each_with_object(Hash.new(0)) do |test, counts|
+        counts[[test[:name], test[:relative_path], test[:line]]] += 1
+      end
+      @coordinator = coordinator || Report.from_document(document: @document, level: @level)
     end
 
     def render
@@ -23,7 +30,11 @@ module Branchproof
       completeness = fetch(@document, :completeness) || {}
       evidence = fetch(@document, :observations) || {}
       lines = ["Branchproof focused view: #{@view}", "Tests: #{fetch(baseline, :status) || "INCOMPLETE"}",
-               "Values: T=true, F=false, -=short-circuited"]
+               (if @index.alternatives.empty?
+                  "Values: T=true, F=false, -=short-circuited"
+                else
+                  "Values: Boolean T=true/F=false; flow T=selected, F=not-selected, -=skipped"
+                end)]
       if completeness.values.include?(false) || fetch(baseline, :status).to_s != "PASSED"
         lines << "Warning: failed or incomplete run; observations and proof evidence may be unavailable."
       end
@@ -35,9 +46,19 @@ module Branchproof
       lines << "Empty groups mean no recorded completed observation."
       lines << ""
       lines.concat(@coordinator.coverage_ladder_lines)
-      @view == :conditions ? render_conditions(lines) : render_tests(lines)
-      render_unowned(lines)
-      render_unsupported(lines)
+      case @view
+      when :conditions
+        render_conditions(lines)
+        render_alternatives(lines)
+      when :decision_tables
+        render_decision_tables(lines)
+      else
+        render_tests(lines)
+      end
+      unless @view == :decision_tables
+        render_unowned(lines)
+        render_unsupported(lines)
+      end
       Array(fetch(@document, :diagnostics)).each do |diagnostic|
         lines << "Diagnostic: #{@coordinator.diagnostic_message(diagnostic)}"
       end
@@ -53,6 +74,8 @@ module Branchproof
         lines << "Condition: #{row[:expression]}"
         lines << "Location: #{location(row[:relative_path], row[:line], unavailable: "condition line unavailable")}"
         lines << "Decision: #{row[:decision_expression]} (condition #{row[:index]})"
+        lines << "Kind: #{row[:kind]}"
+        lines << "Context: #{row[:context]}" unless row[:context].to_s.empty?
         status = if @level == 1 && !coverage_available?
                    "NOT CALCULATED"
                  else
@@ -106,16 +129,110 @@ module Branchproof
       end
     end
 
+    # One block per Boolean decision that carries a decision table. With
+    # --missing-only only uncovered, non-impossible rules remain: a rule proven
+    # impossible is not a missing obligation.
+    def render_decision_tables(lines)
+      rows = @index.decision_tables
+      rendered = 0
+      impossible = 0
+      rows.each do |row|
+        impossible += row[:impossible_rules].to_i
+        rules = @missing_only ? row[:rules].select { |rule| rule[:coverage].to_s == "missing" } : row[:rules]
+        next if @missing_only && rules.empty? && row[:status].to_s == "calculated"
+
+        rendered += 1
+        lines << "Decision: #{row[:decision_expression]}"
+        lines << "Location: #{location(row[:relative_path], row[:line], unavailable: "decision line unavailable")}"
+        lines << "Context: #{row[:context]}" unless row[:context].to_s.empty?
+        if row[:status].to_s != "calculated"
+          lines << "Decision Table: NOT CALCULATED"
+          lines << "Reason: #{row[:reason]}"
+          lines << ""
+          next
+        end
+        lines << "Decision Table: #{row[:covered_rules]}/#{row[:required_rules]} rules covered" \
+                 "#{" (#{row[:percentage]}%)" unless row[:percentage].nil?}"
+        lines << "Reachability: not analyzed" unless row[:reachability_analyzed]
+        rules.each { |rule| render_decision_table_rule(lines, row, rule) }
+        lines << ""
+      end
+      lines << "No missing decision-table rules" if @missing_only && rendered.zero?
+      return unless impossible.positive?
+
+      lines << "#{impossible} statically impossible rule#{"s" unless impossible == 1} excluded"
+    end
+
+    def render_decision_table_rule(lines, row, rule)
+      signature = rule[:conditions].map { |item| DECISION_TABLE_LABELS.fetch(item.to_s, item.to_s) }.join
+      status = rule[:coverage].to_s.upcase
+      lines << "  #{rule[:label]} #{signature} => #{rule[:outcome] ? "T" : "F"}  #{status}"
+      row[:conditions].each_with_index do |expression, index|
+        requirement = @coordinator.decision_table_requirement(rule[:conditions][index])
+        next if requirement.nil?
+
+        lines << "    #{expression} = #{requirement}"
+      end
+      lines << "    #{@coordinator.decision_table_expected_heading(row)} #{rule[:outcome] ? "true" : "false"}"
+      if rule[:coverage].to_s == "covered"
+        owners = Array(rule[:tests]).map { |id| test_label(id) }
+        owners << "unattributed" if rule[:unattributed_count].to_i.positive?
+        lines << "    Tests: #{owners.empty? ? "none recorded" : owners.uniq.join(", ")}"
+      else
+        lines << "    Tests: NOT COVERED"
+      end
+      lines << "    Reachability: #{@coordinator.decision_table_reachability(rule)}"
+      return if rule[:reachability_reason].to_s.empty?
+
+      lines << "    Reason: #{Constraints.message(rule[:reachability_reason])}"
+    end
+
+    def render_alternatives(lines)
+      rows = @index.alternatives
+      rows = rows.select { |row| row[:missing] || row[:status].to_s != "covered" } if @missing_only && @level > 1
+      rows.each do |row|
+        lines << "Alternative #{row[:index]}: #{row[:expression]}"
+        lines << "Location: #{location(row[:relative_path], row[:line],
+                                       unavailable: "alternative location unavailable")}"
+        lines << "Decision: #{row[:decision_expression]} (alternative #{row[:index]})"
+        lines << "Kind: #{row[:kind]}"
+        lines << "Context: #{row[:context]}" unless row[:context].to_s.empty?
+        lines << "Selection: #{row[:status] || "NOT_CALCULATED"}"
+        lines << "MC/DC: N/A (not applicable)"
+        render_alternative_group(lines, "Selected by", row[:selected])
+        render_alternative_group(lines, "Not selected by", row[:not_selected])
+        render_alternative_group(lines, "Skipped in", row[:skipped])
+        if row[:missing]
+          lines << "  Missing alternative: #{row[:expression]}"
+          lines << "  Need selection of: #{row[:expression]}"
+        end
+        lines << ""
+      end
+      lines << "No missing alternatives" if @missing_only && rows.empty?
+    end
+
+    def render_alternative_group(lines, heading, evidence)
+      evidence ||= {}
+      ids = Array(evidence[:test_ids]).map { |id| test_label(id) }
+      ids << "unattributed" if evidence[:unattributed_count].to_i.positive?
+      lines << "  #{heading}: #{ids.empty? ? "none recorded" : ids.uniq.join(", ")}"
+    end
+
     def render_tests(lines)
       rows = @index.tests
       missing_ids = @index.conditions.reject { |row| row[:status].to_s.upcase == "PROVEN" }.map { |row| row[:id] }
-      rows.each { |row| render_test_row(lines, row, missing_ids) }
+      missing_alternative_ids = @index.alternatives.select { |row| row[:missing] || row[:status].to_s != "covered" }
+                                      .map { |row| row[:alternative_id] }
+      rows.each { |row| render_test_row(lines, row, missing_ids, missing_alternative_ids) }
     end
 
-    def render_test_row(lines, row, missing_ids)
+    def render_test_row(lines, row, missing_ids, missing_alternative_ids = [])
       observations = row[:observations]
       if @missing_only
-        observations = observations.select { |observation| missing_ids.include?(observation[:condition_id]) }
+        observations = observations.select do |observation|
+          missing_ids.include?(observation[:condition_id]) ||
+            missing_alternative_ids.include?(observation[:alternative_id])
+        end
         return if observations.empty?
       end
       lines << "Test: #{row[:name]}"
@@ -131,31 +248,51 @@ module Branchproof
         lines << "  No recorded completed condition observations"
         return
       end
-      observations.group_by { |observation| observation[:condition_id] }.each_value do |items|
+      grouped = observations.group_by { |observation| observation[:alternative_id] || observation[:condition_id] }
+      grouped.each_value do |items|
         observation = items.first
-        observed_values = items.map { |item| item[:value] }.uniq
-        label = observed_values.all?(&:nil?) ? "short-circuited-only" : "evaluated"
-        label += "; owns canonical witness evidence" if @level > 1 && items.any? { |item| item[:owns_witness] }
         phases = items.flat_map { |item| item[:phases] }.uniq.sort.join(", ")
-        signs = values(values: observed_values)
-        condition_location = location(observation[:relative_path], observation[:line],
-                                      unavailable: "condition line unavailable")
-        lines << "  #{observation[:expression]} (#{condition_location}): #{signs}; #{label}; " \
-                 "phases: #{phases}"
+        if observation[:alternative_id]
+          states = items.map { |item| item[:alternative_state] }.uniq.join(", ")
+          alternative_location = location(observation[:relative_path], observation[:line],
+                                          unavailable: "alternative location unavailable")
+          lines << "  Alternative #{observation[:alternative_id]}: #{observation[:expression]} " \
+                   "(#{alternative_location}): #{states}; phases: #{phases}"
+        else
+          observed_values = items.map { |item| item[:value] }.uniq
+          label = observed_values.all?(&:nil?) ? "short-circuited-only" : "evaluated"
+          label += "; owns canonical witness evidence" if @level > 1 && items.any? { |item| item[:owns_witness] }
+          signs = values(values: observed_values)
+          condition_location = location(observation[:relative_path], observation[:line],
+                                        unavailable: "condition line unavailable")
+          lines << "  #{observation[:expression]} (#{condition_location}): #{signs}; #{label}; " \
+                   "phases: #{phases}"
+        end
       end
     end
 
     def render_unowned(lines)
       rows = @index.conditions
       rows = rows.reject { |row| row[:status] == "PROVEN" } if @missing_only
-      { "Unexecuted conditions" => rows.select { |row| row[:unexecuted] },
-        "Unattributed evidence" => rows.select { |row| row[:unattributed].positive? } }.each do |heading, conditions|
+      groups = { "Unexecuted conditions" => rows.select { |row| row[:unexecuted] },
+                 "Unattributed evidence" => rows.select { |row| row[:unattributed].positive? } }
+      alternative_rows = @index.alternatives
+      alternative_rows = alternative_rows.reject { |row| row[:status].to_s == "covered" } if @missing_only
+      unless alternative_rows.empty?
+        groups["Unexecuted alternatives"] = alternative_rows.select do |row|
+          row[:selected][:observed] == false && row[:not_selected][:observed] == false
+        end
+        groups["Unattributed alternative evidence"] = alternative_rows.select do |row|
+          %i[selected not_selected skipped].any? { |state| row[state][:unattributed_count].to_i.positive? }
+        end
+      end
+      groups.each do |heading, conditions|
         next if conditions.empty?
 
         lines << "#{heading}:"
         conditions.each do |row|
-          lines << "  #{row[:expression]} (#{location(row[:relative_path], row[:line],
-                                                      unavailable: "condition line unavailable")})"
+          unavailable = row[:alternative_id] ? "alternative location unavailable" : "condition line unavailable"
+          lines << "  #{row[:expression]} (#{location(row[:relative_path], row[:line], unavailable: unavailable)})"
         end
       end
     end
@@ -204,9 +341,7 @@ module Branchproof
       return id.to_s unless test
 
       label = "#{test[:name]} (#{location(test[:relative_path], test[:line])})"
-      duplicates = @index.tests.count do |row|
-        [row[:name], row[:relative_path], row[:line]] == [test[:name], test[:relative_path], test[:line]]
-      end
+      duplicates = @test_name_counts[[test[:name], test[:relative_path], test[:line]]]
       duplicates > 1 ? "#{label} [#{id}]" : label
     end