xcknife 0.6.6 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7503a50d7e372941c78a9274cafb77a1df3da572
-  data.tar.gz: 4b033eb3921f6e77174754e8b144feabd39d8d19
+SHA256:
+  metadata.gz: aca898703e491f17c9923c8c7e28496e0cbac2e2ad1f9b82ae1a632142bacad9
+  data.tar.gz: ea35d7ce95bd76c7d5011683047245a457668acf2b49c070808e99eb06be6da3
 SHA512:
-  metadata.gz: 8beab2cbde2dd91002831cc729912a95e95e2ff8fe85187ae94842d2038c7673972d32d1ecda6ff00737886a5db450c19caf29b2b2c1064954c7f954821a6b22
-  data.tar.gz: 1354e663134f746808560e11af61406986759fe3f30b4341bb054cd07ce92ae207413865cee6d86995a4fef8d562f4f27bf9d638f5a4947ec30b4c6c386f7ecb
+  metadata.gz: 548661d771e7e367e9fd4cee9687761ecd8b1a504702816e096efd1a0b41c60454deda107f56e73096bd851b20d054931ef3b8605c90c87948d4af59aecad157
+  data.tar.gz: 052d69c88e71f0ad388c676ee3f6f374c814b1acec74c090f27acb54541db02f189d3e18bf8e578947b5fa227931bbcfd9aa16ac087e0aee78652c9032c5441a

data/.gitignore

@@ -2,9 +2,10 @@
 pkg
 .idea/
 *.gem
-Gemfile.lock
 xcuserdata/
 testdumperbuild
 contents.xcworkspacedata
 TestDumper/TestDumper.dylib
 *.tmp
+.bin/
+.bundle/

data/.hubkins

@@ -0,0 +1,5 @@
+[build "PR"]
+template = iOS-Builder-Multi-Xcode-PR-Template
+build_script = ./sqiosbuild/sqiosbuild.sh specs
+trigger_build = true
+pull_request = true

data/.ruby-version

@@ -1 +1 @@
-2.2.3
+2.3.1

data/.sqiosbuild.json

@@ -0,0 +1,6 @@
+{
+  "specs": {
+    "post_build": ["bundle", "exec", "rake", "build_test_dumper", "spec"],
+    "xcode_version": "9.4.0"
+  }
+}

data/Gemfile

@@ -1,8 +1,11 @@
-source 'https://rubygems.org'
+source 'https://gems.vip.global.square'
+source 'https://gems.vip.global.square/private'
 
 group :development, :test do
   gem 'rake', '~> 11.1.1'
   gem 'rspec', '~> 3.4.0'
 end
 
+gem 'sq-gem_tasks', '~> 1.0'
+
 gemspec

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    xcknife (0.10.0)
+
+GEM
+  remote: https://gems.vip.global.square/
+  remote: https://gems.vip.global.square/private/
+  specs:
+    diff-lcs (1.3)
+    rake (11.1.2)
+    rangeclient (0.0.17)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    sq-gem_tasks (1.7.1)
+      bundler (~> 1.6)
+      rangeclient (>= 0.0.12)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.12)
+  rake (~> 11.1.1)
+  rspec (~> 3.4.0)
+  sq-gem_tasks (~> 1.0)
+  xcknife!
+
+BUNDLED WITH
+   1.17.3

data/OWNERS.yml

@@ -0,0 +1,2 @@
+---
+cc: [mdx-ios]

data/Rakefile

@@ -1,5 +1,5 @@
 require 'rspec/core/rake_task'
-require "bundler/gem_tasks"
+require 'sq/gem_tasks'
 require 'fileutils'
 
 RSpec::Core::RakeTask.new(:spec)
@@ -19,4 +19,5 @@ end
 desc "Release wih test_dumper"
 task :gem_release => [:build_test_dumper, :build] do
   system 'gem push pkg/xcknife-*.gem'
-end
+end
+

data/TestDumper/TestDumper/Initialize.m

@@ -71,6 +71,38 @@
 
 #include <dlfcn.h>
 
+// Logging
+FILE *logFile;
+
+void initializeLogFile(char *logFilePath)
+{
+    logFile = fopen(logFilePath, "w");
+}
+
+void logDebug(NSString *msg)
+{
+    assert(logFile);
+    fprintf(logFile, "%s", msg.UTF8String);
+    fprintf(logFile, "\n");
+    
+    NSLog(@"%@", msg);
+}
+
+void logInit()
+{
+    logDebug(@"Starting TestDumper...");
+    logDebug(@"Environment Variables:");
+    logDebug(NSProcessInfo.processInfo.environment.description);
+    logDebug(@"Command Line Arguments:");
+    logDebug(NSProcessInfo.processInfo.arguments.description);
+    
+    logDebug(@"--------------------------------");
+}
+
+void logEnd()
+{
+    logDebug(@"EndingTestDumper...");
+}
 
 // Used for a structured log, just like Xctool's.
 // Example: https://github.com/square/xcknife/blob/master/example/xcknife-exemplar.json-stream
@@ -119,10 +151,15 @@ void enumerateTests();
 const int TEST_TARGET_LEVEL = 0;
 const int TEST_CLASS_LEVEL = 1;
 const int TEST_METHOD_LEVEL = 2;
+FILE *noteFile;
 
 __attribute__((constructor))
 void initialize() {
     NSLog(@"Starting TestDumper");
+    char *logFilePath = [[[NSProcessInfo processInfo] arguments][3] UTF8String];
+    initializeLogFile(logFilePath);
+    logInit();
+    NSString *testBundlePath = [[NSProcessInfo processInfo] arguments][4];
     NSString *testDumperOutputPath = NSProcessInfo.processInfo.environment[@"TestDumperOutputPath"];
     NSFileManager *fileManager = [NSFileManager defaultManager];
 
@@ -134,38 +171,41 @@ void initialize() {
 
     if ([testType isEqualToString: @"APPTEST"]) {
         [[NSNotificationCenter defaultCenter] addObserverForName:UIApplicationDidFinishLaunchingNotification object:nil queue:nil usingBlock:^(NSNotification * _Nonnull note) {
-            enumerateTests();
+            enumerateTests(testBundlePath);
         }];
     } else {
-        enumerateTests();
+        enumerateTests(testBundlePath);
     }
 }
 
-
-void enumerateTests() {
-    XCTestConfiguration *config = [[XCTestConfiguration alloc] init];
+void enumerateTests(NSString *testBundlePath) {
+    logDebug(@"Listing all test bundles");
+    for (NSBundle *bundle in NSBundle.allBundles) {
+        NSString *string = [@"Found a test bundle named: " stringByAppendingString:bundle.bundlePath];
+        logDebug(string);
+    }
+    logDebug(@"Finished listing all test bundles");
+    
+    NSBundle* testBundleObj = [NSBundle bundleWithPath:testBundlePath];
+    [testBundleObj load];
+    logDebug(@"test bundle loaded");
+    
+    logDebug(@"Listing all test bundles");
+    for (NSBundle *bundle in NSBundle.allBundles) {
+        NSString *string = [@"Found a test bundle named: " stringByAppendingString:bundle.bundlePath];
+        logDebug(string);
+    }
+    logDebug(@"Finished listing all test bundles");
+    
     NSString *testType = [NSString stringWithUTF8String: getenv("XCTEST_TYPE")];
-    NSString *testTarget = [NSString stringWithUTF8String: getenv("XCTEST_TARGET")];
-
+    NSString *testTarget = [[[testBundlePath componentsSeparatedByString:@"/"] lastObject] componentsSeparatedByString:@"."][0];
+    
+    logDebug(@"The test target is:");
+    logDebug(testTarget);
     if ([testType isEqualToString: @"APPTEST"]) {
-        config.testBundleURL = [NSURL fileURLWithPath:NSProcessInfo.processInfo.environment[@"XCInjectBundle"]];
-        config.targetApplicationPath = NSProcessInfo.processInfo.environment[@"XCInjectBundleInto"];
-
-        NSString *configPath = [NSTemporaryDirectory() stringByAppendingPathComponent:[NSString stringWithFormat:@"%ul.xctestconfiguration", arc4random()]];
-
-        NSLog(@"Writing config to %@", configPath);
-
-        NSData *data = [NSKeyedArchiver archivedDataWithRootObject:config];
-
-        [data writeToFile:configPath atomically:true];
-
-        setenv("XCTestConfigurationFilePath", configPath.UTF8String, YES);
-
-        dlopen(getenv("IDE_INJECTION_PATH"), RTLD_GLOBAL);
+        logDebug(@"IS APPTEST");
     }
-    NSString *testBundle = [[[NSProcessInfo processInfo] arguments] lastObject];
-    [[NSBundle bundleWithPath:testBundle] load];
-
+    
     FILE *outFile;
     NSString *testDumperOutputPath = NSProcessInfo.processInfo.environment[@"TestDumperOutputPath"];
 
@@ -177,14 +217,17 @@ void enumerateTests() {
 
     NSLog(@"Opened %@ with fd %p", testDumperOutputPath, outFile);
     if (outFile == NULL) {
+        logDebug(@"File already exists. Stopping");
         NSLog(@"File already exists %@. Stopping", testDumperOutputPath);
         exit(0);
     }
-
+    
     PrintDumpStart(outFile, testType);
-    [[XCTestSuite defaultTestSuite] printTestsWithLevel:0 withTarget: testTarget withParent: nil outputFile:outFile];
+    XCTestSuite* testSuite = [XCTestSuite defaultTestSuite];
+    [testSuite printTestsWithLevel:0 withTarget: testTarget withParent: nil outputFile:outFile];
     PrintDumpEnd(outFile, testType);
     fclose(outFile);
+    logEnd();
     exit(0);
 }
 

data/lib/xcknife.rb

@@ -7,5 +7,5 @@ require 'xcknife/exceptions'
 require 'xcknife/xcscheme_analyzer'
 
 module XCKnife
-  VERSION = '0.6.6'
+  VERSION = '0.10.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,17 +10,25 @@ 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
@@ -75,7 +83,7 @@ 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
 
@@ -102,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
@@ -128,7 +139,7 @@ module XCKnife
 
     # 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) }
@@ -140,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

@@ -5,6 +5,9 @@ require 'tmpdir'
 require 'ostruct'
 require 'set'
 require 'logger'
+require 'shellwords'
+require 'open3'
+require 'xcknife/exceptions'
 
 module XCKnife
   class TestDumper
@@ -14,21 +17,24 @@ 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 = []
       parse_arguments(args)
       @device_id ||= "booted"
-      @logger = Logger.new($stdout)
+      @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)
       extra_environment_variables = parse_scheme_file
       logger.info { "Environment variables from xcscheme: #{extra_environment_variables.pretty_inspect}" }
       output_fd = File.open(@output_file, "w")
@@ -38,8 +44,7 @@ module XCKnife
         end
       else
         unless File.directory?(@temporary_output_folder)
-          puts "Error no such directory: #{@temporary_output_folder}"
-          exit 1
+          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)) }
@@ -62,8 +67,7 @@ module XCKnife
     def parse_scheme_file
       return {} unless @xcscheme_file
       unless File.exists?(@xcscheme_file)
-        puts "Error: no such xcscheme file: #{@xcscheme_file}"
-        exit 1
+        raise ArgumentError, "Error: no such xcscheme file: #{@xcscheme_file}"
       end
       XCKnife::XcschemeAnalyzer.extract_environment_variables(IO.read(@xcscheme_file))
     end
@@ -91,6 +95,9 @@ module XCKnife
         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("-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
@@ -113,8 +120,7 @@ module XCKnife
     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)
@@ -143,51 +149,71 @@ module XCKnife
 
     attr_reader :logger
 
-    def initialize(device_id, max_retry_count, debug, logger)
+    def initialize(device_id, max_retry_count, debug, logger, dylib_logfile_path,
+                   naive_dump_bundle_names: [], skip_dump_bundle_names: [])
       @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
       @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, extra_environment_variables = {})
-      @testroot = "#{derived_data_folder}/Build/Products/"
-      xctestrun_file = Dir["#{@testroot}/*.xctestrun"].first
+      @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, extra_environment_variables)
-        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, extra_environment_variables)
+    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"],
@@ -206,7 +232,7 @@ module XCKnife
       )
       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)
@@ -218,6 +244,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"] || []
@@ -231,7 +297,7 @@ module XCKnife
     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)
@@ -247,9 +313,19 @@ 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)
@@ -257,8 +333,7 @@ module XCKnife
       until has_test_dumper_terminated?(file)  do
         retries_count += 1
         if retries_count == @max_retry_count
-          puts "Timeout error on: #{file}"
-          exit 1
+          raise TestDumpError, "Timeout error on: #{file}"
         end
         sleep 0.1
       end
@@ -267,29 +342,71 @@ module XCKnife
     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}'#{redirect_output}"
-    end
-
-    def redirect_output
-      return '' if @debug
-      ' 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 = [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
+      if @dylib_logfile_path then
+        @dylib_logfile_path
+      else
+        '/tmp/xcknife_testdumper_dylib.log'
+      end
+    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

data/lib/xcknife/xctool_cmd_helper.rb

@@ -25,12 +25,24 @@ module XCKnife
     end
 
     # only-testing is available since Xcode 8
-    def xcodebuild_only_arguments(single_partition)
-      single_partition.flat_map do |test_target, classes|
+    def xcodebuild_only_arguments(single_partition, meta_partition = nil)
+      only_targets = if meta_partition
+        single_partition.keys.to_set & meta_partition.flat_map(&:keys).group_by(&:to_s).select{|_,v| v.size == 1 }.map(&:first).to_set
+      else
+        Set.new
+      end
+
+      only_target_arguments = only_targets.sort.map { |test_target| "-only-testing:#{test_target}" }
+
+      only_class_arguments = single_partition.flat_map do |test_target, classes|
+        next [] if only_targets.include?(test_target)
+
         classes.sort.map do |clazz|
           "-only-testing:#{test_target}/#{clazz}"
         end
-      end
+      end.sort
+
+      only_target_arguments + only_class_arguments
     end
 
     # skip-testing is available since Xcode 8
@@ -50,4 +62,4 @@ module XCKnife
       partition_set.map { |partition| xctool_only_arguments(partition) }
     end
   end
-end
+end

data/xcknife.gemspec

@@ -17,9 +17,6 @@ Gem::Specification.new do |s|
     Works by leveraging xctool's json-streams timing and test data.
   DESCRIPTION
 
-  # Only allow gem to be pushed to https://rubygems.org
-  s.metadata["allowed_push_host"] = 'https://rubygems.org'
-
   s.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR).reject { |f| f =~ /^spec/} + ["TestDumper/TestDumper.dylib"]
   s.bindir        = 'bin'
   s.executables      = ['xcknife', 'xcknife-min', 'xcknife-test-dumper']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xcknife
 version: !ruby/object:Gem::Version
-  version: 0.6.6
+  version: 0.10.0
 platform: ruby
 authors:
 - Daniel Ribeiro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-06 00:00:00.000000000 Z
+date: 2019-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,13 +38,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- ".gitmodules"
+- ".hubkins"
 - ".rspec"
 - ".ruby-version"
+- ".sqiosbuild.json"
 - ".travis.yml"
 - CONTRIBUTING.md
 - Gemfile
+- Gemfile.lock
 - LICENSE
+- OWNERS.yml
 - README.md
 - Rakefile
 - TestDumper/README.md
@@ -75,8 +78,7 @@ files:
 homepage: https://github.com/square/xcknife
 licenses:
 - Apache-2.0
-metadata:
-  allowed_push_host: https://rubygems.org
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -93,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.7.4
 signing_key: 
 specification_version: 4
 summary: Simple tool for optimizing XCTest runs across machines

data/.gitmodules

@@ -1,3 +0,0 @@
-[submodule "spec/xcknife-exemplar"]
-	path = spec/xcknife-exemplar
-	url = https://github.com/danielribeiro/xcknife-exemplar.git