xcknife 0.6.3 → 0.11.0

data/TestDumper/build.sh

@@ -1,6 +1,7 @@
 #!/bin/bash
+rm -rf TestDumper.dylib testdumperbuild
 xcodebuild -project TestDumper.xcodeproj \
-    -configuration Release \
+    -configuration Debug \
     -derivedDataPath testdumperbuild \
     -scheme TestDumper \
-    -sdk iphonesimulator build
+    -sdk iphonesimulator build ONLY_ACTIVE_ARCH=NO

data/example/run_example.rb

@@ -26,6 +26,7 @@ def run(historical_file, current_file)
     partition_set.each do |partition|
       puts "target name for worker #{shard_number} = #{target_name}"
       puts "only is: #{xctool_only_arguments(partition).inspect}"
+      puts "skip-only is: #{xcodebuild_skip_arguments(partition, result.test_time_for_partitions).inspect}"
       shard_number += 1
     end
   end

data/lib/xcknife.rb

@@ -4,7 +4,8 @@ require 'xcknife/xctool_cmd_helper'
 require 'xcknife/runner'
 require 'xcknife/test_dumper'
 require 'xcknife/exceptions'
+require 'xcknife/xcscheme_analyzer'
 
 module XCKnife
-  VERSION = '0.6.3'
+  VERSION = '0.11.0'
 end

data/lib/xcknife/exceptions.rb

@@ -1,6 +1,8 @@
 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/stream_parser.rb

@@ -10,31 +10,40 @@ 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
+      attr_reader :stats, :test_maps, :test_times, :total_test_time, :test_time_imbalances, :test_time_for_partitions
       extend Forwardable
       delegate ResultStats.members => :@stats
 
-      def initialize(stats, partition_sets)
+      def initialize(stats, partition_sets, test_time_for_partitions)
         @stats = stats
         @partition_sets = partition_sets
         @test_maps = partition_sets_map(&:test_time_map)
         @test_times = partition_sets_map(&:total_time)
         @total_test_time = test_times.flatten.inject(:+)
         @test_time_imbalances = compute_test_time_imbalances
+        @test_time_for_partitions = test_time_for_partitions.inject(&:merge)
       end
 
       private
@@ -74,8 +83,8 @@ 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)
-      end)
+        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)
@@ -101,18 +110,21 @@ module XCKnife
 
       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
+      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
@@ -125,9 +137,9 @@ module XCKnife
       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)
+    # 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)
+    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) }
@@ -139,13 +151,36 @@ 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
+      list_of_test_target_classes_times = list_of_test_target_class_times.group_by do |test_target, class_name, duration_in_milliseconds|
+        if options.split_bundles_across_machines
+          [test_target, class_name]
+        else
+          test_target
+        end
+      end.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
 

data/lib/xcknife/test_dumper.rb

@@ -4,6 +4,10 @@ require 'fileutils'
 require 'tmpdir'
 require 'ostruct'
 require 'set'
+require 'logger'
+require 'shellwords'
+require 'open3'
+require 'xcknife/exceptions'
 
 module XCKnife
   class TestDumper
@@ -11,32 +15,125 @@ module XCKnife
       new(ARGV).run
     end
 
-    def initialize(args)
-      @derived_data_folder, @output_file, @device_id = args
+    attr_reader :logger
+
+    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 = []
+      parse_arguments(args)
       @device_id ||= "booted"
+      @logger = logger
+      @logger.level = @debug ? Logger::DEBUG : Logger::FATAL
+      @parser = nil
+      @simctl_timeout = 0
     end
 
     def run
-      if @derived_data_folder.nil? or @output_file.nil?
-        return puts "Usage: xcknife-test-dumper [derived_data_folder] [output_file] [<device_id>]"
-      end
-      helper = TestDumperHelper.new(@device_id)
+      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")
-      Dir.mktmpdir("xctestdumper_") do |outfolder|
-        helper.call(@derived_data_folder, outfolder).each do |test_specification|
-          concat_to_file(test_specification, output_fd)
+      if @temporary_output_folder.nil?
+        Dir.mktmpdir("xctestdumper_") do |outfolder|
+          list_tests(extra_environment_variables, helper, outfolder, output_fd)
+        end
+      else
+        unless File.directory?(@temporary_output_folder)
+          raise TestDumpError, "Error no such directory: #{@temporary_output_folder}"
+        end
+
+        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
+        list_tests(extra_environment_variables, helper, File.absolute_path(@temporary_output_folder), output_fd)
       end
       output_fd.close
       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)
+        raise ArgumentError, "Error: no such xcscheme file: #{@xcscheme_file}"
+      end
+      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
+      @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
+    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("-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
+      end
+    end
+
+    def required_arguments
+      %w[derived_data_folder output_file]
+    end
+
+    def optional_arguments
+      %w[device_id simctl_timeout]
+    end
+
+    def arguments_banner
+      optional_args = optional_arguments.map { |a| "[#{a}]" }
+      (required_arguments + optional_args).join(" ")
+    end
+
+    def warn_and_exit(msg)
+      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))
-        output_fd.write(line) unless should_test_event_be_ignored?(test_specification, event)
+        if should_test_event_be_ignored?(test_specification, event)
+          logger.info "Skipped test dumper line #{line}"
+        else
+          output_fd.write(line)
+        end
         output_fd.flush
       end
       output_fd.flush
@@ -52,48 +149,74 @@ module XCKnife
   class TestDumperHelper
     TestSpecification = Struct.new :json_stream_file, :skip_test_identifiers
 
-    def initialize(device_id)
+    attr_reader :logger
+
+    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
 
-    def call(derived_data_folder, list_folder)
-      @testroot = "#{derived_data_folder}/Build/Products/"
-      xctestrun_file = Dir["#{@testroot}/*.xctestrun"].first
+    def call(derived_data_folder, list_folder, extra_environment_variables = {})
+      @testroot = File.join(derived_data_folder, 'Build', 'Products')
+      xctestrun_file = Dir[File.join(@testroot, '*.xctestrun')].first
       if xctestrun_file.nil?
-        puts "No xctestrun on #{@testroot}"
-        exit 1
+        raise ArgumentError, "No xctestrun on #{@testroot}"
       end
       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)
-        wait_test_dumper_completion(test_specification.json_stream_file)
+      list_tests(JSON.load(xctestrun_as_json), list_folder, extra_environment_variables)
+    end
+
+    private
+
+    attr_reader :testroot
+
+    def list_tests(xctestrun, list_folder, extra_environment_variables)
+      xctestrun.reject! { |test_bundle_name, _| test_bundle_name == '__xctestrun_metadata__' }
+      xctestrun.map do |test_bundle_name, test_bundle|
+        if @skip_dump_bundle_names.include?(test_bundle_name)
+          logger.info { "Skipping dumping tests in `#{test_bundle_name}` -- writing out fake event"}
+          test_specification = list_single_test(list_folder, test_bundle, test_bundle_name)
+        elsif @naive_dump_bundle_names.include?(test_bundle_name)
+          test_specification = list_tests_with_nm(list_folder, test_bundle, test_bundle_name)
+        else
+          test_specification = list_tests_with_simctl(list_folder, test_bundle, test_bundle_name, extra_environment_variables)
+          wait_test_dumper_completion(test_specification.json_stream_file)
+        end
+
         test_specification
       end
     end
 
-    private
-    def list_tests_wiht_simctl(list_folder, test_bundle, test_bundle_name)
+    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 = "#{list_folder}/#{test_bundle_name}"
+      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'))
       unless File.exist?(test_dumper_path)
-        warn "Could not find TestDumpber.dylib on #{test_dumper_path}"
-        exit 1
+        raise TestDumpError, "Could not find TestDumper.dylib on #{test_dumper_path}"
       end
 
       is_logic_test = test_bundle["TestHostBundleIdentifier"].nil?
       env = simctl_child_attrs(
-        "XCTEST_TYPE" => is_logic_test ? "LOGICTEST" : "APPTEST",
+        "XCTEST_TYPE" => xctest_type(test_bundle),
         "XCTEST_TARGET" => test_bundle_name,
         "TestDumperOutputPath" => outpath,
         "IDE_INJECTION_PATH" => testing_env_variables["DYLD_INSERT_LIBRARIES"],
@@ -110,7 +233,10 @@ module XCKnife
         "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.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
@@ -121,6 +247,46 @@ module XCKnife
       return TestSpecification.new outpath, discover_tests_to_skip(test_bundle)
     end
 
+    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"] || []
@@ -131,10 +297,31 @@ module XCKnife
       @simctl_path
     end
 
+    def wrapped_simctl(args)
+      args = [*gtimeout, simctl] + args
+      args
+    end
+
+    def gtimeout
+      return [] unless @simctl_timeout > 0
+
+      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}"]
+    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)
+        gsub("__TESTROOT__", testroot)
     end
 
     def inject_vars(env, test_host)
@@ -150,47 +337,96 @@ 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) or 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
+
+      if retries_count > max_retry_count
+        raise TestDumpError, "Installing #{test_host_path} failed"
       end
+
     end
 
     def wait_test_dumper_completion(file)
       retries_count = 0
       until has_test_dumper_terminated?(file)  do
         retries_count += 1
-        assert_has_not_timed_out(retries_count, file)
+        if retries_count == @max_retry_count
+          raise TestDumpError, "Timeout error on: #{file}"
+        end
         sleep 0.1
       end
     end
 
-    def assert_has_not_timed_out(retries_count, file)
-      if retries_count == 100
-        puts "Timeout error on: #{file}"
-        exit 1
-      end
-    end
-
     def has_test_dumper_terminated?(file)
       return false unless File.exists?(file)
       last_line = `tail -n 1 "#{file}"`
-      return /Completed Test Dumper/.match(last_line)
+      return 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}'"
+      unless 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
     end
 
     def run_logic_test(env, test_host, test_bundle_path)
-      call_simctl env, "spawn #{@device_id} '#{test_host}' -XCTest All '#{test_bundle_path}' 2> /dev/null"
+      opts = @debug ? {} : { err: "/dev/null" }
+      unless call_simctl(["spawn", @device_id, test_host, '-XCTest', 'All', dylib_logfile_path, test_bundle_path], env: env, **opts)
+        raise TestDumpError, "Spawning #{test_bundle_path} in #{test_host} failed"
+      end
     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}"
-      unless system(env, cmd)
-        puts "Simctl errored with the following env:\n #{env.pretty_print_inspect}"
+      logger.info { "Environment variables:\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)
+      Open3.pipeline_r([@nm_path, File.join(test_bundle_path, File.basename(test_bundle_path, '.xctest'))], [@swift_path, 'demangle']) do |o, _ts|
+        yield(o)
+      end
+    end
+
+    def method_from_nm_line(line)
+      return unless line.strip =~ %r{^
+        [\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: $1 || $3, method: $2 || $4 }
+    end
   end
 end