binpacker 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 991ac5d941b69573b4f6d03c211ff862465a91ee31ddd82f5ce8d8150a2d4f0d
-  data.tar.gz: 8ad2f245f73a46a4fdd64272049835c36d3b2dc4a0bb5df9cf67f851789ae59a
+  metadata.gz: ae35133b41b6a8423c8caa45b91a4153498099d2f04c790aeada3fb1e4e0d52a
+  data.tar.gz: 5e537cf525779a2783db551b1bf86f7525ce34558f16ce8c2eab253712454b8e
 SHA512:
-  metadata.gz: 4345168c76cd0e072ab8f0775df54fe705e13f873a1f7f8ce764b897f42f91f75c5b4b0dee07329b577200230a7707a90284e73b554a339798575e084ce93f15
-  data.tar.gz: 40408cf8b88b878033226df711fbf3e57c217293b85b6eb7f94f55289eb7740d02dcc66598c5f594a3cd21821b5186eb38942c7e03747838a6487ccc37e018d1
+  metadata.gz: ab3dd9a1c6993908e7e646c697d649745d029f15c6a77981ec8b2dd3735afebf92f6194a97e60e2923acc5500fa475e2f7118673cc6c18e2c49ba0a4aa7a7dc1
+  data.tar.gz: ad30734e5dbadb596dd753f90ff1163bbc0a12fa60f8d080baad357f9ed2be3ac8a9667d2ed8a52dab2ced6e3e76d2931a1368613976f0a4e2a5af3fd1c4a8da

data/exe/binpacker-worker

@@ -166,6 +166,16 @@ end.parse!
 
 wid = options[:id]
 exit_code = 0
+
+# Test code must never see the orchestrator's control pipe. A test
+# that reads stdin — an LSP server loop, anything calling gets —
+# would block forever on the pipe the orchestrator keeps open
+# between dynamic batches (or, worse, consume control messages).
+# Keep the pipe on a private handle and point process stdin, which
+# spawned test runners inherit, at /dev/null so readers see EOF.
+control = $stdin.dup
+$stdin.reopen(File::NULL)
+
 $stderr.puts "[worker-#{wid}] #{options[:runner]} worker started"
 
 loop do
@@ -174,7 +184,7 @@ loop do
 
   tests = []
   done_or_eof = false
-  $stdin.each_line do |line|
+  control.each_line do |line|
     data = JSON.parse(line.strip)
     if data["type"] == "done"
       done_or_eof = true
@@ -186,7 +196,7 @@ loop do
   end
 
   break if done_or_eof && tests.empty?
-  break if tests.empty? && ($stdin.eof? || $stdin.closed?)
+  break if tests.empty? && (control.eof? || control.closed?)
 
   files = tests.map { |t| t["file"] }.uniq
   $stderr.puts "[worker-#{wid}] batch: #{files.size} files, #{tests.size} entries"

data/lib/binpacker/cli.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "optparse"
+require 'optparse'
 
 module Binpacker
   class CLI
@@ -21,27 +21,32 @@ module Binpacker
       @skill_path = false
       @skill_describe = false
       @skill_name = nil
+      # A CI matrix sets env vars far more easily than it rewrites the command a Makefile target runs, so
+      # BINPACKER_SHARD is a first-class way in; an explicit --shard still wins over it.
+      @shard_spec = ENV.fetch('BINPACKER_SHARD', nil)
       parse!
     end
 
     def run
       case @command
-      when "calibrate"
+      when 'calibrate'
         cmd_calibrate
-      when "run"
+      when 'run'
         cmd_run
-      when "init"
+      when 'shards-check'
+        cmd_shards_check
+      when 'init'
         cmd_init
-      when "skill"
+      when 'skill'
         cmd_skill
-      when "describe"
+      when 'describe'
         cmd_describe
-      when "--version", "-v"
+      when '--version', '-v'
         puts "binpacker #{Binpacker::VERSION}"
-      when "--help", "-h", nil
+      when '--help', '-h', nil
         print_help
       else
-        $stderr.puts "unknown command: #{@command}"
+        warn "unknown command: #{@command}"
         print_help
         exit 1
       end
@@ -51,47 +56,51 @@ module Binpacker
 
     def parse!
       parser = OptionParser.new do |opts|
-        opts.banner = "Usage: binpacker <command> [options]"
+        opts.banner = 'Usage: binpacker <command> [options]'
 
-        opts.on("--profile PROFILE", "Profile name from binpacker.yml") do |v|
+        opts.on('--profile PROFILE', 'Profile name from binpacker.yml') do |v|
           @profile = v
         end
 
-        opts.on("--version", "Show version") do
-          @command ||= "--version"
+        opts.on('--version', 'Show version') do
+          @command ||= '--version'
         end
 
-        opts.on("--help", "Show help") do
-          @command ||= "--help"
+        opts.on('--help', 'Show help') do
+          @command ||= '--help'
         end
 
-        opts.on("--quiet", "Suppress worker output") do
+        opts.on('--quiet', 'Suppress worker output') do
           @quiet = true
         end
 
-        opts.on("--incremental", "Calibrate only tests without timing data") do
+        opts.on('--incremental', 'Calibrate only tests without timing data') do
           @incremental = true
         end
 
-        opts.on("--report PATH", "(run) Write a JSON run report to PATH") do |v|
+        opts.on('--report PATH', '(run) Write a JSON run report to PATH') do |v|
           @report_path = v
         end
 
-        opts.on("--list", "(skill) List bundled skills") do
+        opts.on('--shard K/N', '(run) Run only shard K of N (1-based)') do |v|
+          @shard_spec = v
+        end
+
+        opts.on('--list', '(skill) List bundled skills') do
           @skill_list = true
         end
 
-        opts.on("--path", "(skill) Print the SKILL.md path for <name>") do
+        opts.on('--path', '(skill) Print the SKILL.md path for <name>') do
           @skill_path = true
         end
 
-        opts.on("--describe", "(skill) Report project state and next skill") do
+        opts.on('--describe', '(skill) Report project state and next skill') do
           @skill_describe = true
         end
       end
 
       # Extract passthrough arguments after "--"
-      if (split_idx = @args.index("--"))
+      if (split_idx = @args.index('--'))
         @passthrough = @args[(split_idx + 1)..] || []
         @args = @args[0...split_idx]
       end
@@ -100,11 +109,14 @@ module Binpacker
       # A positional command wins; otherwise keep any command an option set
       # (e.g. --version), so `binpacker --version` isn't clobbered to nil.
       @command = remaining.shift || @command
-      @skill_name = remaining.shift
+      @skill_name = remaining.first
+      # `shards-check` takes a list of run-report paths, so the positionals stay available in full rather
+      # than being consumed into the single-name slot `skill` uses.
+      @shard_reports = remaining
     end
 
     def cmd_init
-      config_path = Pathname.pwd.join("binpacker.yml")
+      config_path = Pathname.pwd.join('binpacker.yml')
       if config_path.exist?
         puts "binpacker.yml already exists at #{config_path}"
         exit 1
@@ -112,11 +124,11 @@ module Binpacker
 
       framework = detect_framework
       unless ProjectState::SUPPORTED_FRAMEWORKS.include?(framework)
-        $stderr.puts "Detected #{framework} — binpacker supports rspec and minitest only."
-        $stderr.puts "No binpacker.yml was created."
+        warn "Detected #{framework} — binpacker supports rspec and minitest only."
+        warn 'No binpacker.yml was created.'
         exit 1
       end
-      pattern = framework == "minitest" ? "test/**/*_test.rb" : "spec/**/*_spec.rb"
+      pattern = framework == 'minitest' ? 'test/**/*_test.rb' : 'spec/**/*_spec.rb'
       runner = framework
 
       yaml = <<~YAML
@@ -137,15 +149,15 @@ module Binpacker
       config_path.write(yaml)
       puts "Created #{config_path}"
       puts "Detected test framework: #{framework}"
-      puts ""
-      puts "Next steps:"
-      puts "  1. binpacker calibrate   (seed timing data)"
-      puts "  2. binpacker run          (run in parallel)"
+      puts ''
+      puts 'Next steps:'
+      puts '  1. binpacker calibrate   (seed timing data)'
+      puts '  2. binpacker run          (run in parallel)'
     end
 
     def cmd_calibrate
       config = Config.new(profile: @profile)
-      discovery_klass = config.test_runner == "rspec" ? RSpecDiscovery : MinitestDiscovery
+      discovery_klass = config.test_runner == 'rspec' ? RSpecDiscovery : MinitestDiscovery
       tests = discovery_klass.new(config).enumerate
 
       cal = Calibration.new(config)
@@ -175,7 +187,7 @@ module Binpacker
         if path
           puts path
         else
-          $stderr.puts "unknown skill: #{@skill_name}"
+          warn "unknown skill: #{@skill_name}"
           exit 1
         end
       elsif @skill_name && !@skill_list
@@ -187,12 +199,12 @@ module Binpacker
 
     def cmd_describe
       state = ProjectState.new
-      puts "binpacker project state:"
+      puts 'binpacker project state:'
       puts "  config (binpacker.yml): #{state.config_present? ? 'present' : 'missing'}"
       puts "  timing data:            #{state.timing_present? ? 'present' : 'missing'}"
       puts "  test framework:         #{state.framework || 'not detected'}"
       puts "  CI wired for binpacker: #{state.ci_wired? ? 'yes' : 'no'}"
-      puts ""
+      puts ''
 
       unless state.supported_framework?
         puts "binpacker supports rspec and minitest; #{state.framework} is not supported yet."
@@ -208,45 +220,52 @@ module Binpacker
     def list_skills
       skills = Skills.list
       if skills.empty?
-        puts "No bundled skills found."
+        puts 'No bundled skills found.'
         return
       end
-      puts "Bundled skills:"
+      puts 'Bundled skills:'
       skills.each { |s| puts "  #{s[:name]}" }
-      puts ""
+      puts ''
       puts "Print a skill's instructions with `binpacker skill <name>`."
     end
 
     def print_skill(name)
       unless Skills.exist?(name)
-        $stderr.puts "unknown skill: #{name}"
-        $stderr.puts "Run `binpacker skill` to list bundled skills."
+        warn "unknown skill: #{name}"
+        warn 'Run `binpacker skill` to list bundled skills.'
         exit 1
       end
 
       puts "# Skill: #{name}"
       puts "# Source: #{Skills.path(name)}"
-      puts ""
+      puts ''
       puts Skills.body(name)
     end
 
     def cmd_run
       config = Config.new(profile: @profile)
       report_path = @report_path || config.report_file
+      shard = Shard.parse(@shard_spec)
       orchestrator = Orchestrator.new(
-        config, passthrough: @passthrough, quiet: @quiet, report_path: report_path
+        config, passthrough: @passthrough, quiet: @quiet, report_path: report_path, shard: shard
       )
 
-      puts "binpacker starting (#{config.worker_count} workers, profile: #{config.profile})"
+      start_line = "binpacker starting (#{config.worker_count} workers, profile: #{config.profile}"
+      start_line += ", shard: #{shard}" if shard
+      puts "#{start_line})"
       result = orchestrator.run
       puts "Run report written to #{report_path}" if report_path
       unit = test_unit_label(config)
+      # Named in the summary because a sharded run's totals are its slice's, not the suite's — a reader
+      # comparing "10203 examples" with "3401 examples" needs to see which of the two this was.
+      scope = shard ? " (shard #{shard})" : ''
 
       if result[:passed]
-        puts "All #{result[:total]} #{pluralize(result[:total], unit)} passed across #{config.worker_count} workers."
+        puts "All #{result[:total]} #{pluralize(result[:total], unit)} passed across " \
+             "#{config.worker_count} workers#{scope}."
         exit 0
       elsif result[:empty_filter]
-        puts "No tests matched the Minitest filter."
+        puts 'No tests matched the Minitest filter.'
         exit 1
       else
         failed = result[:total] - result[:passed_count]
@@ -255,8 +274,23 @@ module Binpacker
       end
     end
 
+    # Run after a sharded matrix, over every shard's `--report`. A shard cannot tell "not mine" from "does
+    # not exist", so this is the only place a partition that dropped tests can be caught.
+    def cmd_shards_check
+      result = ShardCheck.call(@shard_reports)
+
+      if result.ok?
+        puts result.summary
+        exit 0
+      end
+
+      warn result.summary
+      result.problems.each { |problem| warn "  #{problem}" }
+      exit 1
+    end
+
     def test_unit_label(config)
-      config.test_runner == "rspec" ? "example" : "test"
+      config.test_runner == 'rspec' ? 'example' : 'test'
     end
 
     def pluralize(count, word)
@@ -269,6 +303,7 @@ module Binpacker
 
         Commands:
           run          Execute tests across worker processes
+          shards-check Verify a sharded matrix's run reports cover the whole suite
           calibrate    Run tests serially to generate timing data
           init         Create binpacker.yml with auto-detected settings
           describe     Report project state and recommend the next skill
@@ -278,6 +313,7 @@ module Binpacker
           --profile NAME   Select profile from binpacker.yml
           --incremental    (calibrate) Measure only tests without timing data
           --report PATH    (run) Write a JSON run report to PATH
+          --shard K/N      (run) Run only shard K of N (1-based; env: BINPACKER_SHARD)
           --list           (skill) List bundled skills
           --path           (skill) Print the SKILL.md path for <name>
           --describe       (skill) Report project state and next skill
@@ -287,6 +323,8 @@ module Binpacker
           binpacker init
           binpacker run --profile ci
           binpacker run -- --tag ~slow
+          binpacker run --shard 2/3 --report shard-2.json
+          binpacker shards-check shard-*.json
           binpacker calibrate --incremental
           binpacker describe
           binpacker skill binpacker-setup
@@ -294,7 +332,7 @@ module Binpacker
     end
 
     def detect_framework
-      ProjectState.new.framework || "rspec"
+      ProjectState.new.framework || 'rspec'
     end
   end
 end

data/lib/binpacker/orchestrator.rb

@@ -2,22 +2,49 @@
 
 module Binpacker
   class Orchestrator
-    BATCH_SIZE = 10
-
-    def initialize(config, passthrough: [], quiet: false, report_path: nil)
+    # Dynamic batches halve the queue's remaining predicted weight,
+    # floored at a per-run minimum: early batches are large to amortize
+    # the per-batch test-runner boot (each batch is a fresh rspec
+    # process), tail batches stay small so workers finish together.
+    #
+    # The floor comes in two regimes (computed by #min_batch_weight in
+    # #run and threaded into #drain_batch):
+    #   - Calibrated: weights are measured seconds, so the floor is a
+    #     fixed MIN_BATCH_WEIGHT (~30s), an order of magnitude above the
+    #     ~3s runner boot — boot overhead stays in the noise.
+    #   - Cold start: weights are filesize KB, not seconds, so a fixed
+    #     30 is meaningless. We instead derive a floor that targets
+    #     ~COLD_START_BATCHES_PER_WORKER batches per worker (below).
+    MIN_BATCH_WEIGHT = 30.0
+
+    # On a pure cold start predicted weights are filesize KB, not
+    # seconds, so the 30s MIN_BATCH_WEIGHT floor has no meaning. Instead
+    # we size the floor so the total predicted weight divides into about
+    # this many batches per worker — matching the ~5 runner boots per
+    # worker that gave the best makespan in the PR #12 simulation.
+    COLD_START_BATCHES_PER_WORKER = 5
+
+    def initialize(config, passthrough: [], quiet: false, report_path: nil, shard: nil)
       @config = config
       @passthrough = passthrough
       @quiet = quiet
       @report_path = report_path
+      @shard = shard
     end
 
     def run
       tests = discover
       timing = Timing.new(@config.timing_file)
+      # Weights are computed over the WHOLE suite before slicing, so every shard cuts against the same
+      # numbers and the partition they agree on covers every test exactly once.
       timings = timing.load_with_fallback(tests)
       @timings = timings
 
-      scheduler = Scheduler.for(@config.scheduler["algorithm"])
+      scheduler = Scheduler.for(@config.scheduler['algorithm'])
+      @discovered_count = tests.size
+      tests = @shard.select(tests: tests, timings: timings, scheduler: scheduler) if @shard
+      @selected_count = tests.size
+
       queues = scheduler.partition(
         tests: tests,
         worker_count: @config.worker_count,
@@ -28,12 +55,12 @@ module Binpacker
       @predicted_loads = queues.map { |q| q.total_weight(timings) }
 
       runner_class = TestRunner.for(@config.test_runner)
-      workers = queues.map.with_index do |queue, idx|
+      workers = queues.map.with_index do |_queue, idx|
         Worker.new(idx, runner_class, passthrough: @passthrough, quiet: @quiet).tap(&:start)
       end
 
-      if @config.scheduler["steal_enabled"]
-        run_dynamic(workers, queues, timing, tests)
+      if @config.scheduler['steal_enabled']
+        run_dynamic(workers, queues, timing, tests, min_batch_weight(timing, timings))
       else
         run_static(workers, queues, timing, tests)
       end
@@ -43,9 +70,9 @@ module Binpacker
 
     def discover
       case @config.test_runner
-      when "rspec"
+      when 'rspec'
         RSpecDiscovery.new(@config).enumerate
-      when "minitest"
+      when 'minitest'
         MinitestDiscovery.new(@config).enumerate
       else
         raise ConfigError, "unsupported runner: #{@config.test_runner}"
@@ -58,7 +85,7 @@ module Binpacker
 
       workers.zip(queues).each do |worker, queue|
         worker.send_tests(queue.remaining)
-        progress.update(worker.id, done: 0, total: queue_totals[worker.id], file: queue.remaining.first&.file || "")
+        progress.update(worker.id, done: 0, total: queue_totals[worker.id], file: queue.remaining.first&.file || '')
       end
       progress.refresh
 
@@ -81,10 +108,10 @@ module Binpacker
         worker_examples[worker.id] = worker.example_count
         worker_passed[worker.id] = worker.passed_count
         worker_time[worker.id] = worker.timings.sum { |t| t[:time] }
-        progress.update(worker.id, done: queue_totals[worker.id], total: queue_totals[worker.id], file: "done")
+        progress.update(worker.id, done: queue_totals[worker.id], total: queue_totals[worker.id], file: 'done')
         progress.refresh
       rescue WorkerError => e
-        $stderr.puts "worker #{worker.id} error: #{e.message}"
+        warn "worker #{worker.id} error: #{e.message}"
         all_passed = false
       ensure
         worker.cleanup
@@ -92,7 +119,7 @@ module Binpacker
 
       progress.finish
 
-      worker_stats = workers.map.with_index do |w, i|
+      worker_stats = workers.map.with_index do |_w, i|
         {
           files: queue_totals[i],
           total_time: worker_time[i],
@@ -106,11 +133,9 @@ module Binpacker
       finalize(timing, all_timings, all_passed, total_examples, passed_examples, tests)
     end
 
-    def run_dynamic(workers, queues, timing, tests)
+    def run_dynamic(workers, queues, timing, tests, floor)
       all_timings = []
       all_passed = true
-      total_examples = 0
-      passed_examples = 0
       active = []
 
       queue_totals = queues.map(&:size)
@@ -123,25 +148,23 @@ module Binpacker
       progress = ProgressDisplay.new(workers.size)
 
       workers.zip(queues).each do |worker, queue|
-        batch = drain_batch(queue)
+        batch = drain_batch(queue, floor)
         if batch.empty?
           worker.signal_done
           worker.collect_results
           all_timings.concat(worker.timings)
           all_passed &&= worker.success?
-          total_examples += worker.example_count
-          passed_examples += worker.passed_count
           worker_examples[worker.id] = worker.example_count
           worker_passed[worker.id] = worker.passed_count
           worker.cleanup
           worker_done[worker.id] = queue_totals[worker.id]
-          progress.update(worker.id, done: worker_done[worker.id], total: queue_totals[worker.id], file: "done")
+          progress.update(worker.id, done: worker_done[worker.id], total: queue_totals[worker.id], file: 'done')
         else
           worker.send_tests(batch)
           worker.batch_done
           active << worker
           batch_sizes[worker.id] = batch.size
-          current_file = batch.first&.file || ""
+          current_file = batch.first&.file || ''
           progress.update(worker.id, done: 0, total: queue_totals[worker.id], file: current_file)
         end
       end
@@ -149,33 +172,38 @@ module Binpacker
       until active.empty?
         ready = active.find { |w| w.wait_for_batch }
         unless ready
-          active.reject! { |w| w.status == :crashed || w.status == :error }
+          active.reject! { |w| %i[crashed error].include?(w.status) }
           sleep 0.1
           next
         end
 
         begin
           all_passed &&= ready.success?
-          total_examples += ready.example_count
-          passed_examples += ready.passed_count
 
           worker_done[ready.id] += batch_sizes[ready.id]
+          # Worker#example_count accumulates across batches, so these
+          # are running totals per worker; the grand totals are summed
+          # once after the loop, never added per batch.
           worker_examples[ready.id] = ready.example_count
           worker_passed[ready.id] = ready.passed_count
 
           own_queue = queues[ready.id]
-          next_batch = drain_batch(own_queue)
+          next_batch = drain_batch(own_queue, floor)
 
           if next_batch.empty?
-            donor = queues.reject(&:empty?).max_by(&:size)
-            next_batch = drain_batch(donor) if donor
+            donor = queues.reject(&:empty?).max_by { |q| q.total_weight(@timings) }
+            if donor
+              next_batch = drain_batch(donor, floor)
+              queue_totals[ready.id] += next_batch.size
+              queue_totals[donor.worker_id] -= next_batch.size
+            end
           end
 
           if next_batch.any?
             ready.send_tests(next_batch)
             ready.batch_done
             batch_sizes[ready.id] = next_batch.size
-            current_file = next_batch.first&.file || ""
+            current_file = next_batch.first&.file || ''
             progress.update(ready.id, done: worker_done[ready.id], total: queue_totals[ready.id], file: current_file)
             progress.refresh
           else
@@ -183,11 +211,11 @@ module Binpacker
             all_timings.concat(ready.timings)
             active.delete(ready)
             worker_done[ready.id] = queue_totals[ready.id]
-            progress.update(ready.id, done: queue_totals[ready.id], total: queue_totals[ready.id], file: "done")
+            progress.update(ready.id, done: queue_totals[ready.id], total: queue_totals[ready.id], file: 'done')
             progress.refresh
           end
         rescue WorkerError => e
-          $stderr.puts "worker #{ready.id} error: #{e.message}"
+          warn "worker #{ready.id} error: #{e.message}"
           all_passed = false
           active.delete(ready)
         end
@@ -195,6 +223,9 @@ module Binpacker
 
       progress.finish
 
+      total_examples = worker_examples.sum
+      passed_examples = worker_passed.sum
+
       worker_stats = workers.map.with_index do |w, i|
         tw = w.timings.sum { |t| t[:time] }
         {
@@ -216,27 +247,54 @@ module Binpacker
 
       Report.new(
         profile: @config.profile,
-        algorithm: @config.scheduler["algorithm"],
+        algorithm: @config.scheduler['algorithm'],
         predicted_loads: @predicted_loads,
         worker_stats: worker_stats,
         all_timings: all_timings,
-        timings: @timings
+        timings: @timings,
+        shard: @shard,
+        discovered: @discovered_count,
+        selected: @selected_count
       ).write(@report_path)
     end
 
-    def drain_batch(queue)
+    # Per-run batch-weight floor. Calibrated runs use the fixed
+    # seconds-scale MIN_BATCH_WEIGHT. On a cold start weights are KB, so
+    # that floor is meaningless; derive one that splits the total
+    # predicted weight into ~COLD_START_BATCHES_PER_WORKER batches per
+    # worker, falling back to MIN_BATCH_WEIGHT when there is nothing to
+    # divide (zero total weight or zero workers).
+    def min_batch_weight(timing, timings)
+      return MIN_BATCH_WEIGHT if timing.calibrated?
+
+      total = timings.values.sum(0.0)
+      workers = @config.worker_count
+      return MIN_BATCH_WEIGHT if total.zero? || workers.zero?
+
+      total / (workers * COLD_START_BATCHES_PER_WORKER)
+    end
+
+    # Drains the next batch off +queue+: enough tests to halve its
+    # remaining predicted weight, but never less than +floor+ (see
+    # #min_batch_weight) and never fewer than one test.
+    def drain_batch(queue, floor)
       return [] if queue.nil? || queue.empty?
+
+      target = [queue.total_weight(@timings) / 2.0, floor].max
       batch = []
-      BATCH_SIZE.times do
-        test = queue.pop
-        break unless test
+      weight = 0.0
+      while (batch.empty? || weight < target) && (test = queue.pop)
         batch << test
+        weight += @timings.fetch(test.key, Timing::DEFAULT_WEIGHT)
       end
       batch
     end
 
     def finalize(timing, all_timings, all_passed, total_examples, passed_examples, tests)
-      timing.append_all(all_timings) unless all_timings.empty?
+      unless all_timings.empty?
+        timing.append_all(all_timings)
+        timing.compact!
+      end
       empty_filter = minitest_empty_filter?(tests, total_examples)
       all_passed = false if empty_filter
 
@@ -250,7 +308,7 @@ module Binpacker
     end
 
     def minitest_empty_filter?(tests, total_examples)
-      return false unless @config.test_runner == "minitest"
+      return false unless @config.test_runner == 'minitest'
       return false unless tests.any?
       return false unless total_examples.zero?
 
@@ -260,8 +318,8 @@ module Binpacker
     def minitest_include_filter?
       @passthrough.any? do |arg|
         %w[--name --include -n -i].include?(arg) ||
-          arg.start_with?("--name=", "--include=") ||
-          (arg.start_with?("-n", "-i") && arg.length > 2)
+          arg.start_with?('--name=', '--include=') ||
+          (arg.start_with?('-n', '-i') && arg.length > 2)
       end
     end
   end