xcknife 0.6.5 → 0.12.0

data/lib/xcknife.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'xcknife/events_analyzer'
 require 'xcknife/stream_parser'
 require 'xcknife/xctool_cmd_helper'
@@ -7,5 +9,5 @@ require 'xcknife/exceptions'
 require 'xcknife/xcscheme_analyzer'
 
 module XCKnife
-  VERSION = '0.6.5'
+  VERSION = '0.12.0'
 end

data/lib/xcknife/events_analyzer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'xcknife/json_stream_parser_helper'
 require 'set'
 
@@ -8,6 +10,7 @@ module XCKnife
 
     def self.for(events, relevant_partitions)
       return NullEventsAnalyzer.new if events.nil?
+
       new(events, relevant_partitions)
     end
 
@@ -17,19 +20,21 @@ module XCKnife
       @target_class_map = analyze_events(events)
     end
 
-    def has_test_target?(target)
-      target_class_map.has_key?(target)
+    def test_target?(target)
+      target_class_map.key?(target)
     end
 
-    def has_test_class?(target, clazz)
-      has_test_target?(target) and target_class_map[target].include?(clazz)
+    def test_class?(target, clazz)
+      test_target?(target) and target_class_map[target].include?(clazz)
     end
 
     private
+
     def analyze_events(events)
       ret = Hash.new { |h, key| h[key] = Set.new }
       each_test_event(events) do |target_name, result|
         next unless @relevant_partitions.include?(target_name)
+
         @total_tests += 1
         ret[target_name] << result.className
       end
@@ -40,11 +45,11 @@ module XCKnife
   # Null object for EventsAnalyzer
   # @ref https://en.wikipedia.org/wiki/Null_Object_pattern
   class NullEventsAnalyzer
-    def has_test_target?(target)
+    def test_target?(_target)
       true
     end
 
-    def has_test_class?(target, clazz)
+    def test_class?(_target, _clazz)
       true
     end
 

data/lib/xcknife/exceptions.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 module XCKnife
   # Base error class for xcknife
-  XCKnifeError = Class.new(StandardError)
+  XCKnifeError = Class.new(RuntimeError)
+
+  TestDumpError = Class.new(XCKnifeError)
 
   StreamParsingError = Class.new(XCKnifeError)
-end
+end

data/lib/xcknife/json_stream_parser_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module XCKnife
   module JsonStreamParserHelper
     extend self
@@ -6,18 +8,16 @@ module XCKnife
     def each_test_event(events, &block)
       current_target = nil
       events.each do |result|
-        current_target = result.targetName if result.event == "begin-ocunit"
-        if result.test and result.event == "end-test"
-          raise XCKnife::StreamParsingError, "No test target defined" if current_target.nil?
-          block.call(current_target, normalize_result(result))
-        end
+        current_target = result.targetName if result.event == 'begin-ocunit'
+        next unless result.test && (result.event == 'end-test')
+        raise XCKnife::StreamParsingError, 'No test target defined' if current_target.nil?
+
+        block.call(current_target, normalize_result(result))
       end
     end
 
     def normalize_result(result)
-      if result.totalDuration.is_a?(String)
-        result.totalDuration = result.totalDuration.to_f
-      end
+      result.totalDuration = result.totalDuration.to_f if result.totalDuration.is_a?(String)
       result
     end
   end

data/lib/xcknife/runner.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'optparse'
 
 module XCKnife
@@ -33,11 +35,11 @@ module XCKnife
     end
 
     private
+
     def gen_abbreviated_output(result)
       result.test_maps.map { |partition_set| only_arguments_for_a_partition_set(partition_set, output_type) }
     end
 
-
     def output_type
       @xcodebuild_output ? :xcodebuild : :xctool
     end
@@ -47,7 +49,7 @@ module XCKnife
         metadata: {
           worker_count: @worker_count,
           partition_set_count: result.test_maps.size,
-          total_time_in_ms: result.total_test_time,
+          total_time_in_ms: result.total_test_time
         }.merge(result.stats.to_h),
         partition_set_data: partition_sets_data(result)
       }
@@ -81,18 +83,15 @@ module XCKnife
     def write_output(data)
       json = JSON.pretty_generate(data)
       return puts json if @output_file_name.nil?
-      File.open(@output_file_name, "w") { |f| f.puts(json) }
+
+      File.open(@output_file_name, 'w') { |f| f.puts(json) }
       puts "Wrote file to: #{@output_file_name}"
     end
 
     def parse_arguments(args)
       positional_arguments = parse_options(args)
-      if positional_arguments.size < required_arguments.size
-        warn_and_exit("You must specify *all* required arguments: #{required_arguments.join(", ")}")
-      end
-      if @partitions.empty?
-        warn_and_exit("At least one target partition set must be provided with -p flag")
-      end
+      warn_and_exit("You must specify *all* required arguments: #{required_arguments.join(', ')}") if positional_arguments.size < required_arguments.size
+      warn_and_exit('At least one target partition set must be provided with -p flag') if @partitions.empty?
       worker_count, @historical_timings_file, @current_tests_file = positional_arguments
       @worker_count = Integer(worker_count)
     end
@@ -101,24 +100,24 @@ module XCKnife
       build_parser
       begin
         parser.parse(args)
-      rescue OptionParser::ParseError => error
-        warn_and_exit(error)
+      rescue OptionParser::ParseError => e
+        warn_and_exit(e)
       end
     end
 
     def build_parser
       @parser = OptionParser.new do |opts|
         opts.banner += " #{arguments_banner}"
-        opts.on("-p", "--partition TARGETS",
-          "Comma separated list of targets. Can be used multiple times.") do |v|
+        opts.on('-p', '--partition TARGETS',
+                'Comma separated list of targets. Can be used multiple times.') do |v|
           @partition_names << v
-          @partitions << v.split(",")
+          @partitions << v.split(',')
         end
-        opts.on("-o", "--output FILENAME", "Output file. Defaults to STDOUT") { |v| @output_file_name = v }
-        opts.on("-a", "--abbrev", "Results are abbreviated") { |v| @abbreviated_output = v }
-        opts.on("-x", "--xcodebuild-output", "Output is formatted for xcodebuild") { |v| @xcodebuild_output = v }
+        opts.on('-o', '--output FILENAME', 'Output file. Defaults to STDOUT') { |v| @output_file_name = v }
+        opts.on('-a', '--abbrev', 'Results are abbreviated') { |v| @abbreviated_output = v }
+        opts.on('-x', '--xcodebuild-output', 'Output is formatted for xcodebuild') { |v| @xcodebuild_output = v }
 
-        opts.on_tail("-h", "--help", "Show this message") do
+        opts.on_tail('-h', '--help', 'Show this message') do
           puts opts
           exit
         end
@@ -135,7 +134,7 @@ module XCKnife
 
     def arguments_banner
       optional_args = optional_arguments.map { |a| "[#{a}]" }
-      (required_arguments + optional_args).join(" ")
+      (required_arguments + optional_args).join(' ')
     end
 
     def warn_and_exit(msg)

data/lib/xcknife/stream_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'xcknife/json_stream_parser_helper'
 require 'json'
 require 'set'
@@ -10,21 +12,30 @@ module XCKnife
 
     attr_reader :number_of_shards, :test_partitions, :stats, :relevant_partitions
 
-    def initialize(number_of_shards, test_partitions)
+    def initialize(number_of_shards, test_partitions, options_for_metapartition: Array.new(test_partitions.size, {}), allow_fewer_shards: false)
       @number_of_shards = number_of_shards
       @test_partitions = test_partitions.map(&:to_set)
       @relevant_partitions = test_partitions.flatten.to_set
       @stats = ResultStats.new
-      ResultStats.members.each { |k| @stats[k] = 0}
+      @options_for_metapartition = options_for_metapartition.map { |o| Options::DEFAULT.merge(o) }
+      @allow_fewer_shards = allow_fewer_shards
+      ResultStats.members.each { |k| @stats[k] = 0 }
     end
 
-    PartitionWithMachines = Struct.new :test_time_map, :number_of_shards, :partition_time, :max_shard_count
+    PartitionWithMachines = Struct.new :test_time_map, :number_of_shards, :partition_time, :max_shard_count, :options
     MachineAssignment = Struct.new :test_time_map, :total_time
     ResultStats = Struct.new :historical_total_tests, :current_total_tests, :class_extrapolations, :target_extrapolations
+    Options = Struct.new :max_shard_count, :split_bundles_across_machines, :allow_fewer_shards do
+      def merge(hash)
+        self.class.new(*to_h.merge(hash).values_at(*members))
+      end
+    end
+    Options::DEFAULT = Options.new(nil, true, false).freeze
 
     class PartitionResult
       TimeImbalances = Struct.new :partition_set, :partitions
       attr_reader :stats, :test_maps, :test_times, :total_test_time, :test_time_imbalances, :test_time_for_partitions
+
       extend Forwardable
       delegate ResultStats.members => :@stats
 
@@ -39,10 +50,11 @@ module XCKnife
       end
 
       private
+
       # Yields the imbalances ratios of the partition sets, and the internal imbalance ratio of the respective partitions
       def compute_test_time_imbalances
         times = test_times
-        average_partition_size = times.map { |l| l.inject(:+).to_f / l.size}
+        average_partition_size = times.map { |l| l.inject(:+).to_f / l.size }
         ideal_partition_set_avg = average_partition_size.inject(:+) / @partition_sets.size
         partition_set_imbalance = average_partition_size.map { |avg| avg / ideal_partition_set_avg }
 
@@ -75,18 +87,20 @@ module XCKnife
 
     def compute_shards_for_partitions(test_time_for_partitions)
       PartitionResult.new(@stats, split_machines_proportionally(test_time_for_partitions).map do |partition|
-        compute_single_shards(partition.number_of_shards, partition.test_time_map)
+        compute_single_shards(partition.number_of_shards, partition.test_time_map, options: partition.options)
       end, test_time_for_partitions)
     end
 
     def test_time_for_partitions(historical_events, current_events = nil)
-      analyzer =  EventsAnalyzer.for(current_events, relevant_partitions)
+      analyzer = EventsAnalyzer.for(current_events, relevant_partitions)
       @stats[:current_total_tests] = analyzer.total_tests
       times_for_target_class = Hash.new { |h, current_target| h[current_target] = Hash.new(0) }
       each_test_event(historical_events) do |target_name, result|
         next unless relevant_partitions.include?(target_name)
+
         inc_stat :historical_total_tests
-        next unless analyzer.has_test_class?(target_name, result.className)
+        next unless analyzer.test_class?(target_name, result.className)
+
         times_for_target_class[target_name][result.className] += (result.totalDuration * 1000).ceil
       end
 
@@ -94,43 +108,47 @@ module XCKnife
       hash_partitions(times_for_target_class)
     end
 
+    # rubocop:disable Metrics/CyclomaticComplexity
     def split_machines_proportionally(partitions)
       total = 0
       partitions.each do |test_time_map|
-        each_duration(test_time_map) { |duration_in_milliseconds| total += duration_in_milliseconds}
+        each_duration(test_time_map) { |duration_in_milliseconds| total += duration_in_milliseconds }
       end
 
       used_shards = 0
       assignable_shards = number_of_shards - partitions.size
-      partition_with_machines_list = partitions.map do |test_time_map|
+      partition_with_machines_list = partitions.each_with_index.map do |test_time_map, metapartition|
+        options = @options_for_metapartition[metapartition]
         partition_time = 0
-        max_shard_count = test_time_map.values.map(&:size).inject(:+) || 1
-        each_duration(test_time_map) { |duration_in_milliseconds| partition_time += duration_in_milliseconds}
+        max_shard_count = test_time_map.each_value.map(&:size).reduce(&:+) || 1
+        max_shard_count = [max_shard_count, options.max_shard_count].min if options.max_shard_count
+        each_duration(test_time_map) { |duration_in_milliseconds| partition_time += duration_in_milliseconds }
         n = [1 + (assignable_shards * partition_time.to_f / total).floor, max_shard_count].min
         used_shards += n
-        PartitionWithMachines.new(test_time_map, n, partition_time, max_shard_count)
+        PartitionWithMachines.new(test_time_map, n, partition_time, max_shard_count, options)
       end
 
-      fifo_with_machines_who_can_use_more_shards = partition_with_machines_list.select { |x| x.number_of_shards < x.max_shard_count}.sort_by(&:partition_time)
-      while (number_of_shards - used_shards) > 0
+      fifo_with_machines_who_can_use_more_shards = partition_with_machines_list.select { |x| x.number_of_shards < x.max_shard_count }.sort_by(&:partition_time)
+      while number_of_shards > used_shards
         if fifo_with_machines_who_can_use_more_shards.empty?
+          break if @allow_fewer_shards
+
           raise XCKnife::XCKnifeError, "There are #{number_of_shards - used_shards} extra machines"
         end
         machine = fifo_with_machines_who_can_use_more_shards.pop
         machine.number_of_shards += 1
         used_shards += 1
-        if machine.number_of_shards < machine.max_shard_count
-          fifo_with_machines_who_can_use_more_shards.unshift(machine)
-        end
+        fifo_with_machines_who_can_use_more_shards.unshift(machine) if machine.number_of_shards < machine.max_shard_count
       end
       partition_with_machines_list
     end
 
     # Computes a 2-aproximation to the optimal partition_time, which is an instance of the Open shop scheduling problem (which is NP-hard)
     # see: https://en.wikipedia.org/wiki/Open-shop_scheduling
-    def compute_single_shards(number_of_shards, test_time_map)
-      raise XCKnife::XCKnifeError, "There are not enough workers provided" if number_of_shards <= 0
-      raise XCKnife::XCKnifeError, "Cannot shard an empty partition_time" if test_time_map.empty?
+    def compute_single_shards(number_of_shards, test_time_map, options: Options::DEFAULT)
+      raise XCKnife::XCKnifeError, 'There are not enough workers provided' if number_of_shards <= 0
+      raise XCKnife::XCKnifeError, 'Cannot shard an empty partition_time' if test_time_map.empty?
+
       assignements = Array.new(number_of_shards) { MachineAssignment.new(Hash.new { |k, v| k[v] = [] }, 0) }
 
       list_of_test_target_class_times = []
@@ -140,36 +158,61 @@ module XCKnife
         end
       end
 
-      list_of_test_target_class_times.sort_by! { |test_target, class_name, duration_in_milliseconds| -duration_in_milliseconds }
-      list_of_test_target_class_times.each do |test_target, class_name, duration_in_milliseconds|
+      # This might seem like an uncessary level of indirection, but it allows us to keep
+      # logic consistent regardless of the `split_bundles_across_machines` option
+      group = list_of_test_target_class_times.group_by do |test_target, class_name, _duration_in_milliseconds|
+        options.split_bundles_across_machines ? [test_target, class_name] : test_target
+      end
+
+      list_of_test_target_classes_times = group.map do |(test_target, _), classes|
+        [
+          test_target,
+          classes.map { |_test_target, class_name, _duration_in_milliseconds| class_name },
+          classes.reduce(0) { |total_duration, (_test_target, _class_name, duration_in_milliseconds)| total_duration + duration_in_milliseconds }
+        ]
+      end
+
+      list_of_test_target_classes_times.sort_by! { |_test_target, _class_names, duration_in_milliseconds| -duration_in_milliseconds }
+      list_of_test_target_classes_times.each do |test_target, class_names, duration_in_milliseconds|
         assignemnt = assignements.min_by(&:total_time)
-        assignemnt.test_time_map[test_target] << class_name
+        assignemnt.test_time_map[test_target].concat class_names
         assignemnt.total_time += duration_in_milliseconds
       end
-      raise XCKnife::XCKnifeError, "Too many shards" if assignements.any? { |a| a.test_time_map.empty? }
+
+      if (empty_test_map_assignments = assignements.select { |a| a.test_time_map.empty? }) && !empty_test_map_assignments.empty? && !options.allow_fewer_shards
+        test_grouping = options.split_bundles_across_machines ? 'classes' : 'targets'
+        raise XCKnife::XCKnifeError, "Too many shards -- #{empty_test_map_assignments.size} of #{number_of_shards} assignments are empty," \
+                                     " because there are not enough test #{test_grouping} for that many shards."
+      end
+      assignements.reject! { |a| a.test_time_map.empty? }
+
       assignements
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
 
     def parse_json_stream_file(filename)
       return nil if filename.nil?
-      return [] unless File.exists?(filename)
+      return [] unless File.exist?(filename)
+
       lines = IO.readlines(filename)
-      lines.lazy.map { |line| OpenStruct.new(JSON.load(line)) }
+      lines.lazy.map { |line| OpenStruct.new(JSON.parse(line)) }
     end
 
     private
+
     def inc_stat(name)
       @stats[name] += 1
     end
 
-    def each_duration(test_time_map, &block)
-      test_time_map.each do |test_target, class_times|
-        class_times.each do |class_name, duration_in_milliseconds|
+    def each_duration(test_time_map)
+      test_time_map.each do |_test_target, class_times|
+        class_times.each do |_class_name, duration_in_milliseconds|
           yield(duration_in_milliseconds)
         end
       end
     end
 
+    # rubocop:disable Metrics/CyclomaticComplexity
     def extrapolate_times_for_current_events(analyzer, times_for_target_class)
       median_map = {}
       times_for_target_class.each do |test_target, class_times|
@@ -179,9 +222,9 @@ module XCKnife
       all_times_for_all_classes = times_for_target_class.values.flat_map(&:values)
       median_of_targets = median(all_times_for_all_classes)
       analyzer.target_class_map.each do |test_target, class_set|
-        if times_for_target_class.has_key?(test_target)
+        if times_for_target_class.key?(test_target)
           class_set.each do |clazz|
-            unless times_for_target_class[test_target].has_key?(clazz)
+            unless times_for_target_class[test_target].key?(clazz)
               inc_stat :class_extrapolations
               times_for_target_class[test_target][clazz] = median_map[test_target]
             end
@@ -199,6 +242,7 @@ module XCKnife
     DEFAULT_EXTRAPOLATED_DURATION = 1000
     def extrapolated_duration(median_of_targets, class_set)
       return DEFAULT_EXTRAPOLATED_DURATION if median_of_targets.nil?
+
       median_of_targets / class_set.size
     end
 
@@ -214,10 +258,9 @@ module XCKnife
         end
       end
       ret.each_with_index do |partition, index|
-        if partition.empty?
-          raise XCKnife::XCKnifeError, "The following partition has no tests: #{test_partitions[index].to_a.inspect}"
-        end
+        raise XCKnife::XCKnifeError, "The following partition has no tests: #{test_partitions[index].to_a.inspect}" if partition.empty?
       end
     end
   end
+  # rubocop:enable Metrics/CyclomaticComplexity
 end

data/lib/xcknife/test_dumper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'pp'
 require 'fileutils'
@@ -5,6 +7,10 @@ require 'tmpdir'
 require 'ostruct'
 require 'set'
 require 'logger'
+require 'shellwords'
+require 'open3'
+require 'xcknife/exceptions'
+require 'etc'
 
 module XCKnife
   class TestDumper
@@ -14,85 +20,82 @@ module XCKnife
 
     attr_reader :logger
 
-    def initialize(args)
+    def initialize(args, logger: Logger.new($stdout, progname: 'xcknife test dumper'))
       @debug = false
       @max_retry_count = 150
       @temporary_output_folder = nil
       @xcscheme_file = nil
       @parser = build_parser
+      @naive_dump_bundle_names = []
+      @skip_dump_bundle_names = []
+      @simctl_timeout = 0
       parse_arguments(args)
-      @device_id ||= "booted"
-      @logger = Logger.new($stdout)
+      @device_id ||= 'booted'
+      @logger = logger
       @logger.level = @debug ? Logger::DEBUG : Logger::FATAL
       @parser = nil
     end
 
     def run
-      helper = TestDumperHelper.new(@device_id, @max_retry_count, @debug, @logger)
+      helper = TestDumperHelper.new(@device_id, @max_retry_count, @debug, @logger, @dylib_logfile_path,
+                                    naive_dump_bundle_names: @naive_dump_bundle_names, skip_dump_bundle_names: @skip_dump_bundle_names, simctl_timeout: @simctl_timeout)
       extra_environment_variables = parse_scheme_file
       logger.info { "Environment variables from xcscheme: #{extra_environment_variables.pretty_inspect}" }
-      output_fd = File.open(@output_file, "w")
+      output_fd = File.open(@output_file, 'w')
       if @temporary_output_folder.nil?
-        Dir.mktmpdir("xctestdumper_") do |outfolder|
+        Dir.mktmpdir('xctestdumper_') do |outfolder|
           list_tests(extra_environment_variables, helper, outfolder, output_fd)
         end
       else
-        unless File.directory?(@temporary_output_folder)
-          puts "Error no such directory: #{@temporary_output_folder}"
-          exit 1
-        end
+        raise TestDumpError, "Error no such directory: #{@temporary_output_folder}" unless File.directory?(@temporary_output_folder)
 
-        if Dir.entries(@temporary_output_folder).any? { |f| File.file?(File.join(@temporary_output_folder,f)) }
-          puts "Warning: #{@temporary_output_folder} is not empty! Files can be overwritten."
-        end
+        puts "Warning: #{@temporary_output_folder} is not empty! Files can be overwritten." if Dir.entries(@temporary_output_folder).any? { |f| File.file?(File.join(@temporary_output_folder, f)) }
         list_tests(extra_environment_variables, helper, File.absolute_path(@temporary_output_folder), output_fd)
       end
       output_fd.close
-      puts "Done listing test methods"
+      puts 'Done listing test methods'
     end
 
     private
+
     def list_tests(extra_environment_variables, helper, outfolder, output_fd)
       helper.call(@derived_data_folder, outfolder, extra_environment_variables).each do |test_specification|
         concat_to_file(test_specification, output_fd)
       end
     end
 
-
     def parse_scheme_file
       return {} unless @xcscheme_file
-      unless File.exists?(@xcscheme_file)
-        puts "Error: no such xcscheme file: #{@xcscheme_file}"
-        exit 1
-      end
+      raise ArgumentError, "Error: no such xcscheme file: #{@xcscheme_file}" unless File.exist?(@xcscheme_file)
+
       XCKnife::XcschemeAnalyzer.extract_environment_variables(IO.read(@xcscheme_file))
     end
 
     def parse_arguments(args)
       positional_arguments = parse_options(args)
-      if positional_arguments.size < required_arguments.size
-        warn_and_exit("You must specify *all* required arguments: #{required_arguments.join(", ")}")
-      end
+      warn_and_exit("You must specify *all* required arguments: #{required_arguments.join(', ')}") if positional_arguments.size < required_arguments.size
       @derived_data_folder, @output_file, @device_id = positional_arguments
     end
 
     def parse_options(args)
-      begin
-        return @parser.parse(args)
-      rescue OptionParser::ParseError => error
-        warn_and_exit(error)
-      end
+      @parser.parse(args)
+    rescue OptionParser::ParseError => e
+      warn_and_exit(e)
     end
 
     def build_parser
       OptionParser.new do |opts|
         opts.banner += " #{arguments_banner}"
-        opts.on("-d", "--debug", "Debug mode enabled") { |v| @debug = v }
-        opts.on("-r", "--retry-count COUNT", "Max retry count for simulator output", Integer) { |v| @max_retry_count = v }
-        opts.on("-t", "--temporary-output OUTPUT_FOLDER", "Sets temporary Output folder") { |v| @temporary_output_folder = v }
-        opts.on("-s", "--scheme XCSCHEME_FILE", "Reads environments variables from the xcscheme file") { |v| @xcscheme_file = v }
-
-        opts.on_tail("-h", "--help", "Show this message") do
+        opts.on('-d', '--debug', 'Debug mode enabled') { |v| @debug = v }
+        opts.on('-r', '--retry-count COUNT', 'Max retry count for simulator output', Integer) { |v| @max_retry_count = v }
+        opts.on('-x', '--simctl-timeout SECONDS', 'Max allowed time in seconds for simctl commands', Integer) { |v| @simctl_timeout = v }
+        opts.on('-t', '--temporary-output OUTPUT_FOLDER', 'Sets temporary Output folder') { |v| @temporary_output_folder = v }
+        opts.on('-s', '--scheme XCSCHEME_FILE', 'Reads environments variables from the xcscheme file') { |v| @xcscheme_file = v }
+        opts.on('-l', '--dylib_logfile DYLIB_LOG_FILE', 'Path for dylib log file') { |v| @dylib_logfile_path = v }
+        opts.on('--naive-dump TEST_BUNDLE_NAMES', 'List of test bundles to dump using static analysis', Array) { |v| @naive_dump_bundle_names = v }
+        opts.on('--skip-dump TEST_BUNDLE_NAMES', 'List of test bundles to skip dumping', Array) { |v| @skip_dump_bundle_names = v }
+
+        opts.on_tail('-h', '--help', 'Show this message') do
           puts opts
           exit
         end
@@ -104,23 +107,22 @@ module XCKnife
     end
 
     def optional_arguments
-      %w[device_id]
+      %w[device_id simctl_timeout]
     end
 
     def arguments_banner
       optional_args = optional_arguments.map { |a| "[#{a}]" }
-      (required_arguments + optional_args).join(" ")
+      (required_arguments + optional_args).join(' ')
     end
 
     def warn_and_exit(msg)
-      warn "#{msg.to_s.capitalize} \n\n#{@parser}"
-      exit 1
+      raise TestDumpError, "#{msg.to_s.capitalize} \n\n#{@parser}"
     end
 
     def concat_to_file(test_specification, output_fd)
       file = test_specification.json_stream_file
       IO.readlines(file).each do |line|
-        event = OpenStruct.new(JSON.load(line))
+        event = OpenStruct.new(JSON.parse(line))
         if should_test_event_be_ignored?(test_specification, event)
           logger.info "Skipped test dumper line #{line}"
         else
@@ -133,8 +135,9 @@ module XCKnife
 
     # Current limitation: this only supports class level skipping
     def should_test_event_be_ignored?(test_specification, event)
-      return false unless event["test"] == "1"
-      test_specification.skip_test_identifiers.include?(event["className"])
+      return false unless event['test'] == '1'
+
+      test_specification.skip_test_identifiers.include?(event['className'])
     end
   end
 
@@ -143,84 +146,190 @@ module XCKnife
 
     attr_reader :logger
 
-    def initialize(device_id, max_retry_count, debug, logger)
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(device_id, max_retry_count, debug, logger, dylib_logfile_path,
+                   naive_dump_bundle_names: [], skip_dump_bundle_names: [], simctl_timeout: 0)
       @xcode_path = `xcode-select -p`.strip
       @simctl_path = `xcrun -f simctl`.strip
-      @platforms_path = "#{@xcode_path}/Platforms/"
-      @platform_path = "#{@platforms_path}/iPhoneSimulator.platform"
-      @sdk_path = "#{@platform_path}/Developer/SDKs/iPhoneSimulator.sdk"
+      @nm_path = `xcrun -f nm`.strip
+      @swift_path = `xcrun -f swift`.strip
+      @platforms_path = File.join(@xcode_path, 'Platforms')
+      @platform_path = File.join(@platforms_path, 'iPhoneSimulator.platform')
+      @sdk_path = File.join(@platform_path, 'Developer/SDKs/iPhoneSimulator.sdk')
       @testroot = nil
       @device_id = device_id
       @max_retry_count = max_retry_count
+      @simctl_timeout = simctl_timeout
       @logger = logger
       @debug = debug
+      @dylib_logfile_path = dylib_logfile_path if dylib_logfile_path
+      @naive_dump_bundle_names = naive_dump_bundle_names
+      @skip_dump_bundle_names = skip_dump_bundle_names
     end
+    # rubocop:enable Metrics/ParameterLists
 
     def call(derived_data_folder, list_folder, extra_environment_variables = {})
-      @testroot = "#{derived_data_folder}/Build/Products/"
-      xctestrun_file = Dir["#{@testroot}/*.xctestrun"].first
-      if xctestrun_file.nil?
-        puts "No xctestrun on #{@testroot}"
-        exit 1
-      end
+      @testroot = File.join(derived_data_folder, 'Build', 'Products')
+      xctestrun_file = Dir[File.join(@testroot, '*.xctestrun')].first
+      raise ArgumentError, "No xctestrun on #{@testroot}" if xctestrun_file.nil?
+
       xctestrun_as_json = `plutil -convert json -o - "#{xctestrun_file}"`
       FileUtils.mkdir_p(list_folder)
-      JSON.load(xctestrun_as_json).map do |test_bundle_name, test_bundle|
-        test_specification = list_tests_wiht_simctl(list_folder, test_bundle, test_bundle_name, extra_environment_variables)
-        wait_test_dumper_completion(test_specification.json_stream_file)
-        test_specification
-      end
+      list_tests(JSON.parse(xctestrun_as_json), list_folder, extra_environment_variables)
     end
 
     private
-    def list_tests_wiht_simctl(list_folder, test_bundle, test_bundle_name, extra_environment_variables)
-      env_variables = test_bundle["EnvironmentVariables"]
-      testing_env_variables = test_bundle["TestingEnvironmentVariables"]
-      outpath = "#{list_folder}/#{test_bundle_name}"
-      test_host = replace_vars(test_bundle["TestHostPath"])
-      test_bundle_path = replace_vars(test_bundle["TestBundlePath"], test_host)
-      test_dumper_path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'TestDumper', 'TestDumper.dylib'))
-      unless File.exist?(test_dumper_path)
-        warn "Could not find TestDumpber.dylib on #{test_dumper_path}"
-        exit 1
+
+    attr_reader :testroot
+
+    def test_groups(xctestrun)
+      xctestrun.group_by do |test_bundle_name, _test_bundle|
+        if @skip_dump_bundle_names.include?(test_bundle_name)
+          'single'
+        elsif @naive_dump_bundle_names.include?(test_bundle_name)
+          'nm'
+        else
+          'simctl'
+        end
       end
+    end
+
+    # This executes naive test dumping in parallel by queueing up items onto a work queue to process
+    # with 1 new thread per processor. Results are placed onto a threadsafe spec queue to avoid writing
+    # to an object between threads, then popped off re-inserting them to our list of test results.
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def list_tests(xctestrun, list_folder, extra_environment_variables)
+      xctestrun.reject! { |test_bundle_name, _| test_bundle_name == '__xctestrun_metadata__' }
+
+      test_runs_by_method = test_groups(xctestrun)
+      spec_queue = Queue.new
+      nm_bundle_queue = Queue.new
+      results = []
+      single_tests = test_runs_by_method['single'] || []
+      nm_tests = test_runs_by_method['nm'] || []
+      simctl_tests = test_runs_by_method['simctl'] || []
+
+      single_tests.each do |test_bundle_name, test_bundle|
+        logger.info { "Skipping dumping tests in `#{test_bundle_name}` -- writing out fake event" }
+        spec_queue << list_single_test(list_folder, test_bundle, test_bundle_name)
+      end
+
+      simctl_tests.each do |test_bundle_name, test_bundle|
+        test_spec = list_tests_with_simctl(list_folder, test_bundle, test_bundle_name, extra_environment_variables)
+        wait_test_dumper_completion(test_spec.json_stream_file)
+
+        spec_queue << test_spec
+      end
+
+      nm_tests.each { |item| nm_bundle_queue << item }
+
+      [Etc.nprocessors, nm_bundle_queue.size].min.times.map do
+        nm_bundle_queue << :stop
+
+        Thread.new do
+          Thread.current.abort_on_exception = true
+
+          until (item = nm_bundle_queue.pop) == :stop
+            test_bundle_name, test_bundle = item
+            spec_queue << list_tests_with_nm(list_folder, test_bundle, test_bundle_name)
+          end
+        end
+      end.each(&:join)
+
+      results << spec_queue.pop until spec_queue.empty?
+
+      results
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    def list_tests_with_simctl(list_folder, test_bundle, test_bundle_name, extra_environment_variables)
+      env_variables = test_bundle['EnvironmentVariables']
+      testing_env_variables = test_bundle['TestingEnvironmentVariables']
+      outpath = File.join(list_folder, test_bundle_name)
+      test_host = replace_vars(test_bundle['TestHostPath'])
+      test_bundle_path = replace_vars(test_bundle['TestBundlePath'], test_host)
+      test_dumper_path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'TestDumper', 'TestDumper.dylib'))
+      raise TestDumpError, "Could not find TestDumper.dylib on #{test_dumper_path}" unless File.exist?(test_dumper_path)
 
-      is_logic_test = test_bundle["TestHostBundleIdentifier"].nil?
+      is_logic_test = test_bundle['TestHostBundleIdentifier'].nil?
       env = simctl_child_attrs(
-        "XCTEST_TYPE" => is_logic_test ? "LOGICTEST" : "APPTEST",
-        "XCTEST_TARGET" => test_bundle_name,
-        "TestDumperOutputPath" => outpath,
-        "IDE_INJECTION_PATH" => testing_env_variables["DYLD_INSERT_LIBRARIES"],
-        "XCInjectBundleInto" => testing_env_variables["XCInjectBundleInto"],
-        "XCInjectBundle" => test_bundle_path,
-        "TestBundleLocation" => test_bundle_path,
-        "OS_ACTIVITY_MODE" => "disable",
-        "DYLD_PRINT_LIBRARIES" => "YES",
-        "DYLD_PRINT_ENV" => "YES",
-        "DYLD_ROOT_PATH" => @sdk_path,
-        "DYLD_LIBRARY_PATH" => env_variables["DYLD_LIBRARY_PATH"],
-        "DYLD_FRAMEWORK_PATH" => env_variables["DYLD_FRAMEWORK_PATH"],
-        "DYLD_FALLBACK_LIBRARY_PATH" => "#{@sdk_path}/usr/lib",
-        "DYLD_FALLBACK_FRAMEWORK_PATH" => "#{@platform_path}/Developer/Library/Frameworks",
-        "DYLD_INSERT_LIBRARIES" => test_dumper_path,
+        'XCTEST_TYPE' => xctest_type(test_bundle),
+        'XCTEST_TARGET' => test_bundle_name,
+        'TestDumperOutputPath' => outpath,
+        'IDE_INJECTION_PATH' => testing_env_variables['DYLD_INSERT_LIBRARIES'],
+        'XCInjectBundleInto' => testing_env_variables['XCInjectBundleInto'],
+        'XCInjectBundle' => test_bundle_path,
+        'TestBundleLocation' => test_bundle_path,
+        'OS_ACTIVITY_MODE' => 'disable',
+        'DYLD_PRINT_LIBRARIES' => 'YES',
+        'DYLD_PRINT_ENV' => 'YES',
+        'DYLD_ROOT_PATH' => @sdk_path,
+        'DYLD_LIBRARY_PATH' => env_variables['DYLD_LIBRARY_PATH'],
+        'DYLD_FRAMEWORK_PATH' => env_variables['DYLD_FRAMEWORK_PATH'],
+        'DYLD_FALLBACK_LIBRARY_PATH' => "#{@sdk_path}/usr/lib",
+        'DYLD_FALLBACK_FRAMEWORK_PATH' => "#{@platform_path}/Developer/Library/Frameworks",
+        'DYLD_INSERT_LIBRARIES' => test_dumper_path
       )
       env.merge!(simctl_child_attrs(extra_environment_variables))
       inject_vars(env, test_host)
-      FileUtils.remove(outpath) if File.exists?(outpath)
+      FileUtils.rm_f(outpath)
       logger.info { "Temporary TestDumper file for #{test_bundle_name} is #{outpath}" }
       if is_logic_test
         run_logic_test(env, test_host, test_bundle_path)
       else
         install_app(test_host)
-        test_host_bundle_identifier = replace_vars(test_bundle["TestHostBundleIdentifier"], test_host)
+        test_host_bundle_identifier = replace_vars(test_bundle['TestHostBundleIdentifier'], test_host)
         run_apptest(env, test_host_bundle_identifier, test_bundle_path)
       end
-      return TestSpecification.new outpath, discover_tests_to_skip(test_bundle)
+      TestSpecification.new outpath, discover_tests_to_skip(test_bundle)
+    end
+
+    # Improvement?: assume that everything in the historical info is correct, so dont simctl or nm, and just spit out exactly what it said the classes were
+
+    def list_tests_with_nm(list_folder, test_bundle, test_bundle_name)
+      output_methods(list_folder, test_bundle, test_bundle_name) do |test_bundle_path|
+        methods = []
+        swift_demangled_nm(test_bundle_path) do |output|
+          output.each_line do |line|
+            next unless (method = method_from_nm_line(line))
+
+            methods << method
+          end
+        end
+        methods
+      end
+    end
+
+    def list_single_test(list_folder, test_bundle, test_bundle_name)
+      output_methods(list_folder, test_bundle, test_bundle_name) do
+        [{ class: test_bundle_name, method: 'test' }]
+      end
+    end
+
+    def output_methods(list_folder, test_bundle, test_bundle_name)
+      outpath = File.join(list_folder, test_bundle_name)
+      logger.info { "Writing out TestDumper file for #{test_bundle_name} to #{outpath}" }
+      test_specification = TestSpecification.new outpath, discover_tests_to_skip(test_bundle)
+
+      test_bundle_path = replace_vars(test_bundle['TestBundlePath'], replace_vars(test_bundle['TestHostPath']))
+      methods = yield(test_bundle_path)
+
+      test_type = xctest_type(test_bundle)
+      File.open test_specification.json_stream_file, 'a' do |f|
+        f << JSON.dump(message: 'Starting Test Dumper', event: 'begin-test-suite', testType: test_type) << "\n"
+        f << JSON.dump(event: 'begin-ocunit', bundleName: File.basename(test_bundle_path), targetName: test_bundle_name) << "\n"
+        methods.map { |method| method[:class] }.uniq.each do |class_name|
+          f << JSON.dump(test: '1', className: class_name, event: 'end-test', totalDuration: '0') << "\n"
+        end
+        f << JSON.dump(message: 'Completed Test Dumper', event: 'end-action', testType: test_type) << "\n"
+      end
+
+      test_specification
     end
 
     def discover_tests_to_skip(test_bundle)
-      identifier_for_test_method = "/"
-      skip_test_identifiers = test_bundle["SkipTestIdentifiers"] || []
+      identifier_for_test_method = '/'
+      skip_test_identifiers = test_bundle['SkipTestIdentifiers'] || []
       skip_test_identifiers.reject { |i| i.include?(identifier_for_test_method) }.to_set
     end
 
@@ -228,15 +337,35 @@ module XCKnife
       @simctl_path
     end
 
-    def replace_vars(str, testhost = "<UNKNOWN>")
-      str.gsub("__PLATFORMS__", @platforms_path).
-        gsub("__TESTHOST__", testhost).
-        gsub("__TESTROOT__", @testroot)
+    def wrapped_simctl(args)
+      [*gtimeout, simctl] + args
+    end
+
+    def gtimeout
+      return [] unless @simctl_timeout.positive?
+
+      path = gtimeout_path
+      if path.empty?
+        puts "warning: simctl_timeout specified but 'gtimeout' is not installed. The specified timeout will be ignored."
+        return []
+      end
+
+      [path, '-k', '5', @simctl_timeout.to_s]
+    end
+
+    def gtimeout_path
+      `which gtimeout`.strip
+    end
+
+    def replace_vars(str, testhost = '<UNKNOWN>')
+      str.gsub('__PLATFORMS__', @platforms_path)
+         .gsub('__TESTHOST__', testhost)
+         .gsub('__TESTROOT__', testroot)
     end
 
     def inject_vars(env, test_host)
       env.each do |k, v|
-        env[k] = replace_vars(v || "", test_host)
+        env[k] = replace_vars(v || '', test_host)
       end
     end
 
@@ -247,49 +376,91 @@ module XCKnife
     end
 
     def install_app(test_host_path)
-      until system("#{simctl} install #{@device_id} '#{test_host_path}'")
-        sleep 0.1
+      retries_count = 0
+      max_retry_count = 3
+      until (retries_count > max_retry_count) || call_simctl(['install', @device_id, test_host_path])
+        retries_count += 1
+        call_simctl ['shutdown', @device_id]
+        call_simctl ['boot', @device_id]
+        sleep 1.0
       end
+
+      raise TestDumpError, "Installing #{test_host_path} failed" if retries_count > max_retry_count
     end
 
     def wait_test_dumper_completion(file)
       retries_count = 0
-      until has_test_dumper_terminated?(file)  do
+      until test_dumper_terminated?(file)
         retries_count += 1
-        if retries_count == @max_retry_count
-          puts "Timeout error on: #{file}"
-          exit 1
-        end
+        raise TestDumpError, "Timeout error on: #{file}" if retries_count == @max_retry_count
+
         sleep 0.1
       end
     end
 
-    def has_test_dumper_terminated?(file)
-      return false unless File.exists?(file)
+    def test_dumper_terminated?(file)
+      return false unless File.exist?(file)
+
       last_line = `tail -n 1 "#{file}"`
-      return /Completed Test Dumper/.match(last_line)
+      last_line.include?('Completed Test Dumper')
     end
 
     def run_apptest(env, test_host_bundle_identifier, test_bundle_path)
-      call_simctl env, "launch #{@device_id} '#{test_host_bundle_identifier}' -XCTest All '#{test_bundle_path}'"
+      return if call_simctl(['launch', @device_id, test_host_bundle_identifier, '-XCTest', 'All', dylib_logfile_path, test_bundle_path], env: env)
+
+      raise TestDumpError, "Launching #{test_bundle_path} in #{test_host_bundle_identifier} failed"
     end
 
     def run_logic_test(env, test_host, test_bundle_path)
-      call_simctl env, "spawn #{@device_id} '#{test_host}' -XCTest All '#{test_bundle_path}'#{redirect_output}"
-    end
+      opts = @debug ? {} : { err: '/dev/null' }
+      return if call_simctl(['spawn', @device_id, test_host, '-XCTest', 'All', dylib_logfile_path, test_bundle_path], env: env, **opts)
 
-    def redirect_output
-      return '' unless @debug
-      ' 2> /dev/null'
+      raise TestDumpError, "Spawning #{test_bundle_path} in #{test_host} failed"
     end
 
-    def call_simctl(env, string_args)
-      cmd = "#{simctl} #{string_args}"
+    def call_simctl(args, env: {}, **spawn_opts)
+      args = wrapped_simctl(args)
+      cmd = Shellwords.shelljoin(args)
       puts "Running:\n$ #{cmd}"
       logger.info { "Environment variables:\n #{env.pretty_print_inspect}" }
-      unless system(env, cmd)
-        puts "Simctl errored with the following env:\n #{env.pretty_print_inspect}"
+
+      ret = system(env, *args, **spawn_opts)
+      puts "Simctl errored with the following env:\n #{env.pretty_print_inspect}" unless ret
+      ret
+    end
+
+    def dylib_logfile_path
+      @dylib_logfile_path ||= '/tmp/xcknife_testdumper_dylib.log'
+    end
+
+    def xctest_type(test_bundle)
+      if test_bundle['TestHostBundleIdentifier'].nil?
+        'LOGICTEST'
+      else
+        'APPTEST'
       end
     end
+
+    def swift_demangled_nm(test_bundle_path, &block)
+      Open3.pipeline_r([@nm_path, File.join(test_bundle_path, File.basename(test_bundle_path, '.xctest'))], [@swift_path, 'demangle'], &block)
+    end
+
+    def method_from_nm_line(line)
+      return unless line.strip =~ /^
+        [\da-f]+\s # address
+        [tT]\s # symbol type
+        (?: # method
+          -\[(.+)\s(test.+)\] # objc instance method
+          | # or swift instance method
+            _? # only present on Xcode 10.0 and below
+            (?:@objc\s)? # optional objc annotation
+            (?:[^.]+\.)? # module name
+            (.+) # class name
+            \.(test.+)\s->\s\(\) # method signature
+        )
+      $/ox
+
+      { class: Regexp.last_match(1) || Regexp.last_match(3), method: Regexp.last_match(2) || Regexp.last_match(4) }
+    end
   end
 end