fastlane-plugin-test_center 3.7.0.parallelizing.alpha.4 → 3.7.0

data/lib/fastlane/plugin/test_center/helper/multi_scan_manager/runner.rb

@@ -1,356 +0,0 @@
-
-module TestCenter
-  module Helper
-    module MultiScanManager
-      require 'fastlane_core/ui/ui.rb'
-      require 'plist'
-      require 'json'
-      require 'shellwords'
-      require 'snapshot/reset_simulators'
-      require_relative './simulator_manager'
-
-      class Runner
-        Parallelization = TestCenter::Helper::MultiScanManager::Parallelization
-
-        attr_reader :retry_total_count
-
-        def initialize(multi_scan_options)
-          @output_directory = multi_scan_options[:output_directory] || 'test_results'
-          @try_count = multi_scan_options[:try_count]
-          @retry_total_count = 0
-          @testrun_completed_block = multi_scan_options[:testrun_completed_block]
-          @given_custom_report_file_name = multi_scan_options[:custom_report_file_name]
-          @given_output_types = multi_scan_options[:output_types]
-          @given_output_files = multi_scan_options[:output_files]
-          @invocation_based_tests = multi_scan_options[:invocation_based_tests]
-          @parallelize = multi_scan_options[:parallelize]
-          if  ENV['USE_REFACTORED_PARALLELIZED_MULTI_SCAN']
-            @test_collector = TestCenter::Helper::TestCollector.new(multi_scan_options)
-            @scan_options = multi_scan_options
-          else
-            @test_collector = TestCenter::Helper::TestCollector.new(multi_scan_options)
-            @scan_options = multi_scan_options.reject do |option, _|
-              %i[
-                output_directory
-                only_testing
-                skip_testing
-                clean
-                try_count
-                batch_count
-                custom_report_file_name
-                fail_build
-                testrun_completed_block
-                output_types
-                output_files
-                parallelize
-                quit_simulators
-                invocation_based_tests
-              ].include?(option)
-            end
-          end
-          @scan_options[:clean] = false
-          @scan_options[:disable_concurrent_testing] = true
-          @scan_options[:xctestrun] = @test_collector.xctestrun_path
-          @batch_count = @test_collector.test_batches.size
-          if @parallelize
-            @scan_options.delete(:derived_data_path)
-            @parallelizer = Parallelization.new(@batch_count, @output_directory, @testrun_completed_block)
-          end
-        end
-
-        def run
-          if @invocation_based_tests
-            run_invocation_based_tests
-          else
-            run_test_batches
-          end
-        end
-        
-        def run_invocation_based_tests
-          @scan_options[:only_testing] = @scan_options[:only_testing]&.map(&:strip_testcase)&.uniq
-          @scan_options[:skip_testing] = @scan_options[:skip_testing]&.map(&:strip_testcase)&.uniq
-          
-          RetryingScan.run(@scan_options)
-        end
-        
-        def run_test_batches
-          all_tests_passed = true
-          pool_options = @scan_options.reject { |key| %i[device devices].include?(key) }
-          pool = TestBatchWorkerPool.new(pool_options)
-          pool.setup_workers
-          
-          remaining_test_batches = @test_collector.test_batches.clone
-          remaining_test_batches.each_with_index do |test_batch, current_batch_index|
-            worker = pool.wait_for_worker  
-
-            testrun_passed = worker.run(
-              {
-                only_testing: test_batch.map(&:shellsafe_testidentifier),
-                output_directory: @output_directory,
-                try_count: @try_count,
-                batch: current_batch_index + 1
-              }
-            )
-            all_tests_passed = testrun_passed && all_tests_passed
-          end
-          pool.wait_for_all_workers
-          collate_batched_reports
-          all_tests_passed
-        end
-
-        def scan
-          return run if ENV['USE_REFACTORED_PARALLELIZED_MULTI_SCAN']
-
-          all_tests_passed = true
-          @testables_count = @test_collector.testables.size
-          FileUtils.rm_rf(Dir.glob("#{@output_directory}/**/*.{junit,html,xml,json}"))
-          all_tests_passed = each_batch do |test_batch, current_batch_index|
-            output_directory = testrun_output_directory(@output_directory, test_batch, current_batch_index)
-            reset_for_new_testable(output_directory)
-            FastlaneCore::UI.header("Starting test run on batch '#{current_batch_index}'")
-            @interstitial.batch = current_batch_index
-            @interstitial.output_directory = output_directory
-            @interstitial.before_all
-            testrun_passed = correcting_scan(
-              {
-                only_testing: test_batch.map(&:shellsafe_testidentifier),
-                output_directory: output_directory
-              },
-              current_batch_index,
-              @reportnamer
-            )
-            all_tests_passed = testrun_passed && all_tests_passed
-            TestCenter::Helper::MultiScanManager::ReportCollator.new(
-              source_reports_directory_glob: output_directory,
-              output_directory: output_directory,
-              reportnamer: @reportnamer,
-              scheme: @scan_options[:scheme],
-              result_bundle: @scan_options[:result_bundle]
-            ).collate
-            testrun_passed && all_tests_passed
-          end
-          all_tests_passed
-        end
-
-        def run_test_batch_through_retrying_scan(test_batch, current_batch_index)
-          FastlaneCore::UI.important("Investigate using rbspy for perf problems: https://github.com/rbspy/rbspy")
-          retrying_scan = TestCenter::Helper::MultiScanManager::RetryingScan.new(
-            @scan_options.merge(
-              only_testing: test_batch.map(&:shellsafe_testidentifier),
-              output_directory: @output_directory,
-              try_count: @try_count,
-              batch: current_batch_index + 1
-            ).reject { |key| %i[device devices].include?(key) }
-          )
-          retrying_scan.run
-        end
-  
-        def collate_batched_reports
-          return false unless @batch_count > 1
-
-          @test_collector.testables.each do |testable|
-            collate_batched_reports_for_testable(testable)
-          end
-          true
-        end
-
-        def collate_batched_reports_for_testable(testable)
-          absolute_output_directory = File.join(
-            File.absolute_path(@output_directory),
-            testable
-          )
-          source_reports_directory_glob = "#{absolute_output_directory}-batch-*"
-
-          TestCenter::Helper::MultiScanManager::ReportCollator.new(
-            source_reports_directory_glob: source_reports_directory_glob,
-            output_directory: absolute_output_directory,
-            reportnamer: @reportnamer = ReportNameHelper.new(
-              @given_output_types,
-              @given_output_files,
-              @given_custom_report_file_name
-            ),
-            scheme: @scan_options[:scheme],
-            result_bundle: @scan_options[:result_bundle]
-          ).collate
-          FileUtils.rm_rf(Dir.glob(source_reports_directory_glob))
-          true
-        end
-
-        def each_batch
-          tests_passed = true
-          if @parallelize
-            xctestrun_filename = File.basename(@test_collector.xctestrun_path)
-            xcproduct_dirpath = File.dirname(@test_collector.xctestrun_path)
-            tmp_xcproduct_dirpath = Dir.mktmpdir
-
-            FileUtils.copy_entry(xcproduct_dirpath, tmp_xcproduct_dirpath)
-
-            tmp_xctestrun_path = File.join(tmp_xcproduct_dirpath, xctestrun_filename)
-            app_infoplist = XCTestrunInfo.new(tmp_xctestrun_path)
-            @scan_options[:xctestrun] = tmp_xctestrun_path
-            batch_deploymentversions = @test_collector.test_batches.map do |test_batch|
-              testable = test_batch.first.split('/').first.gsub('\\', '')
-              # TODO: investigate the reason for this call that doesn't seem to do
-              # anything other than query for and then discard MinimumOSVersion
-              app_infoplist.app_plist_for_testable(testable)['MinimumOSVersion']
-            end
-            @parallelizer.setup_simulators(@scan_options[:devices] || Array(@scan_options[:device]), batch_deploymentversions)
-            @parallelizer.setup_pipes_for_fork
-            @test_collector.test_batches.each_with_index do |test_batch, current_batch_index|
-              fork do
-                @parallelizer.connect_subprocess_endpoint(current_batch_index)
-                begin
-                  @parallelizer.setup_scan_options_for_testrun(@scan_options, current_batch_index)
-                  # add output_directory to map of test-target: [ output_directories ]
-                  tests_passed = yield(test_batch, current_batch_index)
-                ensure
-                  @parallelizer.send_subprocess_result(current_batch_index, tests_passed)
-                end
-                # processes to disconnect from the Simulator subsystems
-                FastlaneCore::UI.message("batched scan #{current_batch_index} finishing")
-              end
-            end
-            # @parallelizer.wait_for_subprocesses
-            # tests_passed = @parallelizer.handle_subprocesses_results && tests_passed
-            @parallelizer.handle_subprocesses
-            @parallelizer.cleanup_simulators
-            @test_collector.testables.each do |testable|
-              # ReportCollator with a testable-batch glob pattern
-              source_reports_directory_glob = batched_testable_output_directory(@output_directory, '*', testable)
-              @reportnamer = ReportNameHelper.new(
-                @given_output_types,
-                @given_output_files,
-                @given_custom_report_file_name
-              )
-              TestCenter::Helper::MultiScanManager::ReportCollator.new(
-                source_reports_directory_glob: source_reports_directory_glob,
-                output_directory: @output_directory,
-                reportnamer: @reportnamer,
-                scheme: @scan_options[:scheme],
-                result_bundle: @scan_options[:result_bundle],
-                suffix: testable
-              ).collate
-              FileUtils.rm_rf(Dir.glob(source_reports_directory_glob))
-            end
-            # for each key in test-target : [ output_directories ], call
-            # collate_junit_reports for each key, the [ output_directories ] being
-            # used to find the report files.
-            # the resultant report file is to be placed in the originally requested
-            # output_directory, with the name changed to include a suffix matching
-            # the test target's name
-          else
-            @test_collector.test_batches.each_with_index do |test_batch, current_batch_index|
-              tests_passed = yield(test_batch, current_batch_index)
-            end
-          end
-          tests_passed
-        end
-
-        def batched_testable_output_directory(output_directory, batch_index, testable_name)
-          File.join(output_directory, "results-#{testable_name}-batch-#{batch_index}")
-        end
-
-        def testrun_output_directory(base_output_directory, test_batch, batch_index)
-          return base_output_directory if @batch_count == 1
-
-          testable_name = test_batch.first.split('/').first.gsub(/\\/, '')
-          batched_testable_output_directory(base_output_directory, batch_index, testable_name)
-        end
-
-        def reset_reportnamer
-          @reportnamer = ReportNameHelper.new(
-            @given_output_types,
-            @given_output_files,
-            @given_custom_report_file_name
-          )
-        end
-
-        def test_run_completed_callback
-          if @parallelize && @testrun_completed_block
-            Proc.new do |info|
-              puts "about to call @parallelizer.send_subprocess_tryinfo(#{info})"
-              @parallelizer.send_subprocess_tryinfo(info)
-            end
-          else
-            @testrun_completed_block
-          end
-        end
-
-        def reset_interstitial(output_directory)
-          @interstitial = TestCenter::Helper::MultiScanManager::Interstitial.new(
-            @scan_options.merge(
-              {
-                output_directory: output_directory,
-                reportnamer: @reportnamer,
-                testrun_completed_block: @testrun_completed_block,
-                parallelize: @parallelize
-              }
-            )
-          )
-        end
-
-        def reset_for_new_testable(output_directory)
-          reset_reportnamer
-          reset_interstitial(output_directory)
-        end
-
-        def correcting_scan(scan_run_options, batch, reportnamer)
-          scan_options = @scan_options.merge(scan_run_options)
-          try_count = 0
-          tests_passed = true
-          begin
-            try_count += 1
-            config = FastlaneCore::Configuration.create(
-              Fastlane::Actions::ScanAction.available_options,
-              scan_options.merge(reportnamer.scan_options)
-            )
-            Fastlane::Actions::ScanAction.run(config)
-            @interstitial.finish_try(try_count)
-            tests_passed = true
-          rescue FastlaneCore::Interface::FastlaneTestFailure => e
-            FastlaneCore::UI.verbose("Scan failed with #{e}")
-            if try_count < @try_count
-              @retry_total_count += 1
-              scan_options.delete(:code_coverage)
-              tests_to_retry = failed_tests(reportnamer, scan_options[:output_directory])
-
-              scan_options[:only_testing] = tests_to_retry.map(&:shellsafe_testidentifier)
-              FastlaneCore::UI.message('Re-running scan on only failed tests')
-              @interstitial.finish_try(try_count)
-              retry
-            end
-            tests_passed = false
-          end
-          tests_passed
-        end
-
-        def failed_tests(reportnamer, output_directory)
-          report_filepath = File.join(output_directory, reportnamer.junit_last_reportname)
-          config = FastlaneCore::Configuration.create(
-            Fastlane::Actions::TestsFromJunitAction.available_options,
-            {
-              junit: File.absolute_path(report_filepath)
-            }
-          )
-          Fastlane::Actions::TestsFromJunitAction.run(config)[:failed]
-        end
-      end
-    end
-  end
-end
-
-
-module FastlaneCore
-  class Shell < Interface
-    def format_string(datetime = Time.now, severity = "")
-      prefix = $batch_index.nil? ? '' : "#{$batch_index}: "
-      if FastlaneCore::Globals.verbose?
-        return "#{prefix}#{severity} [#{datetime.strftime('%Y-%m-%d %H:%M:%S.%2N')}]: "
-      elsif FastlaneCore::Env.truthy?("FASTLANE_HIDE_TIMESTAMP")
-        return prefix
-      else
-        return "#{prefix}[#{datetime.strftime('%H:%M:%S')}]: "
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/test_center/helper/multi_scan_manager/simulator_helper.rb

@@ -1,49 +0,0 @@
-module TestCenter
-  module Helper
-    module MultiScanManager
-      class SimulatorHelper
-        def initialize(options)
-          @options = options
-        end
-
-        def setup
-          if (@options[:batch_count] || @options[:parallel_simulator_fork_count] || 1) > 1
-            delete_multi_scan_cloned_simulators
-          end
-        end
-
-        def clone_destination_simulators
-          cloned_simulators = []
-
-          batch_count = @options[:batch_count] || @options[:parallel_simulator_fork_count] || 0
-          destination_simulator_ids = Scan.config[:destination].map do |destination|
-            destination.split(',id=').last
-          end
-          original_simulators = FastlaneCore::DeviceManager.simulators('iOS').find_all do |simulator|
-            destination_simulator_ids.include?(simulator.udid)
-          end
-          original_simulators.each(&:shutdown)
-          (0...batch_count).each do |batch_index|
-            cloned_simulators << []
-            original_simulators.each do |simulator|
-              FastlaneCore::UI.verbose("Cloning simulator")
-              cloned_simulator = simulator.clone
-              new_first_name = simulator.name.sub(/( ?\(.*| ?$)/, " Clone #{batch_index}")
-              new_last_name = "#{self.class.name}<#{self.object_id}>"
-              cloned_simulator.rename("#{new_first_name} #{new_last_name}")
-
-              cloned_simulators.last << cloned_simulator
-            end
-          end
-          cloned_simulators
-        end
-
-        def delete_multi_scan_cloned_simulators
-          FastlaneCore::DeviceManager.simulators('iOS').each do |simulator|
-            simulator.delete if /#{self.class.name}<\d+>/ =~ simulator.name
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/test_center/helper/multi_scan_manager/simulator_manager.rb

@@ -1,317 +0,0 @@
-module TestCenter
-  module Helper
-    module MultiScanManager
-      require 'scan'
-      require 'colorize'
-      require_relative './device_manager'
-
-      class Parallelization
-        def initialize(batch_count, output_directory, testrun_completed_block)
-          @batch_count = batch_count
-          @output_directory = output_directory
-          @testrun_completed_block = testrun_completed_block
-          
-          @simulators ||= []
-
-          if ENV['USE_REFACTORED_PARALLELIZED_MULTI_SCAN']
-            @simhelper = SimulatorHelper.new(
-              parallelize: true,
-              batch_count: batch_count
-            )
-            @simhelper.setup
-          end
-          if @batch_count < 1
-            raise FastlaneCore::FastlaneCrash.new({}), "batch_count (#{@batch_count}) < 1, this should never happen"
-          end
-          ObjectSpace.define_finalizer(self, self.class.finalize)
-        end
-
-        def self.finalize
-          proc { cleanup_simulators }
-        end
-
-        def setup_simulators(devices, batch_deploymentversions)
-          if ENV['USE_REFACTORED_PARALLELIZED_MULTI_SCAN']
-            @simulators = @simhelper.clone_destination_simulators
-          else
-            FastlaneCore::DeviceManager.simulators('iOS').each do |simulator|
-              simulator.delete if /-batchclone-/ =~ simulator.name
-            end
-
-            (0...@batch_count).each do |batch_index|
-              found_simulator_devices = []
-              if devices.count > 0
-                found_simulator_devices = detect_simulator(devices, batch_deploymentversions[batch_index])
-              else
-                found_simulator_devices = Scan::DetectValues.detect_simulator(devices, 'iOS', 'IPHONEOS_DEPLOYMENT_TARGET', 'iPhone 5s', nil)
-              end
-              @simulators[batch_index] ||= []
-              found_simulator_devices.each do |found_simulator_device|
-                device_for_batch = found_simulator_device.clone
-                new_name = "#{found_simulator_device.name.gsub(/[^a-zA-Z\d]/,'')}-batchclone-#{batch_index + 1}"
-                device_for_batch.rename(new_name)
-                device_for_batch.boot
-                @simulators[batch_index] << device_for_batch
-              end
-            end
-          end
-        end
-
-        def detect_simulator(devices, deployment_target_version)
-          require 'set'
-
-          simulators = Scan::DetectValues.filter_simulators(
-            FastlaneCore::DeviceManager.simulators('iOS').tap do |array|
-              if array.empty?
-                FastlaneCore::UI.user_error!(['No', simulator_type_descriptor, 'simulators found on local machine'].reject(&:nil?).join(' '))
-              end
-            end,
-            :greater_than_or_equal,
-            deployment_target_version
-          ).tap do |sims|
-            if sims.empty?
-              FastlaneCore::UI.error("No simulators found that are greater than or equal to the version of deployment target (#{deployment_target_version})")
-            end
-          end
-
-          # At this point we have all simulators for the given deployment target (or higher)
-
-          # We create 2 lambdas, which we iterate over later on
-          # If the first lambda `matches` found a simulator to use
-          # we'll never call the second one
-
-          matches = lambda do
-            set_of_simulators = devices.inject(
-              Set.new # of simulators
-            ) do |set, device_string|
-              pieces = device_string.split(/\s(?=\([\d\.]+\)$)/)
-
-              selector = ->(sim) { pieces.count > 0 && sim.name == pieces.first }
-
-              set + (
-                if pieces.count == 0
-                  [] # empty array
-                elsif pieces.count == 1
-                  simulators
-                    .select(&selector)
-                    .reverse # more efficient, because `simctl` prints higher versions first
-                    .sort_by! { |sim| Gem::Version.new(sim.os_version) }
-                    .pop(1)
-                else # pieces.count == 2 -- mathematically, because of the 'end of line' part of our regular expression
-                  version = pieces[1].tr('()', '')
-                  potential_emptiness_error = lambda do |sims|
-                    if sims.empty?
-                      FastlaneCore::UI.error("No simulators found that are equal to the version " \
-                      "of specifier (#{version}) and greater than or equal to the version " \
-                      "of deployment target (#{deployment_target_version})")
-                    end
-                  end
-                  Scan::DetectValues.filter_simulators(simulators, :equal, version).tap(&potential_emptiness_error).select(&selector)
-                end
-              ).tap do |array|
-                FastlaneCore::UI.error("Ignoring '#{device_string}', couldn't find matching simulator") if array.empty?
-              end
-            end
-
-            set_of_simulators.to_a
-          end
-
-          default = lambda do
-            FastlaneCore::UI.error("Couldn't find any matching simulators for '#{devices}' - falling back to default simulator") if (devices || []).count > 0
-
-            result = Array(
-              simulators
-                .select { |sim| sim.name == default_device_name }
-                .reverse # more efficient, because `simctl` prints higher versions first
-                .sort_by! { |sim| Gem::Version.new(sim.os_version) }
-                .last || simulators.first
-            )
-
-            FastlaneCore::UI.message("Found simulator \"#{result.first.name} (#{result.first.os_version})\"") if result.first
-
-            result
-          end
-
-          [matches, default].lazy.map { |x|
-            arr = x.call
-            arr unless arr.empty?
-          }.reject(&:nil?).first
-        end
-
-        def cleanup_simulators
-          @simulators.flatten.each(&:delete)
-          @simulators = []
-        end
-
-        def destination_for_batch(batch_index)
-          @simulators[batch_index]
-        end
-
-        def devices(batch_index)
-          if batch_index > @batch_count
-            simulator_count = [@batch_count, @simulators.count].max
-            raise "Error: impossible to request devices for batch #{batch_index}, there are only #{simulator_count} set(s) of simulators"
-          end
-
-          if @simulators.count > 0
-            @simulators[batch_index - 1].map do |simulator|
-              "#{simulator.name} (#{simulator.os_version})"
-            end
-          else
-            @scan_options[:devices] || Array(@scan_options[:device])
-          end
-        end
-
-        def ensure_conflict_free_scanlogging(scan_options, batch_index)
-          scan_options[:buildlog_path] = scan_options[:buildlog_path] + "-#{batch_index}"
-        end
-
-        def ensure_devices_cloned_for_testrun_are_used(scan_options, batch_index)
-          scan_options.delete(:device)
-          scan_options[:devices] = devices(batch_index)
-        end
-
-        def setup_scan_options_for_testrun(scan_options, batch_index)
-          ensure_conflict_free_scanlogging(scan_options, batch_index)
-          ensure_devices_cloned_for_testrun_are_used(scan_options, batch_index)
-        end
-
-        def setup_pipes_for_fork
-          @pipe_endpoints = []
-          (0...@batch_count).each do
-            @pipe_endpoints << IO.pipe
-          end
-        end
-
-        def connect_subprocess_endpoint(batch_index)
-          mainprocess_reader, = @pipe_endpoints[batch_index]
-          mainprocess_reader.close # we are now in the subprocess
-          FileUtils.mkdir_p(@output_directory)
-          subprocess_output_dir = Dir.mktmpdir
-          subprocess_logfilepath = File.join(subprocess_output_dir, "batchscan_#{batch_index}.log")
-          $subprocess_logfile = File.open(subprocess_logfilepath, 'w')
-          $subprocess_logfile.sync = true
-          $old_stdout = $stdout.dup
-          $old_stderr = $stderr.dup
-          $stdout.reopen($subprocess_logfile)
-          $stderr.reopen($subprocess_logfile)
-        end
-
-        def disconnect_subprocess_endpoints
-          # This is done from the parent process to close the pipe from its end so
-          # that its reading of the pipe doesn't block waiting for more IO on the
-          # writer.
-          # This has to be done after the fork, because we don't want the subprocess
-          # to receive its endpoint already closed.
-          @pipe_endpoints.each { |_, subprocess_writer| subprocess_writer.close }
-        end
-
-        def send_subprocess_tryinfo(info)
-          puts "in send_subprocess_tryinfo"
-          _, subprocess_writer = @pipe_endpoints[batch_index]
-          subprocess_output = {
-            'message_type' => 'tryinfo',
-            'batch_index' => batch_index,
-            'tryinfo' => info
-          }
-          subprocess_writer.puts subprocess_output.to_json
-        end
-
-        def send_subprocess_result(batch_index, result)
-          $stdout = $old_stdout.dup
-          $stderr = $old_stderr.dup
-          _, subprocess_writer = @pipe_endpoints[batch_index]
-
-          subprocess_output = {
-            'message_type' => 'completed',
-            'batch_index' => batch_index,
-            'subprocess_logfilepath' => $subprocess_logfile.path,
-            'tests_passed' => result
-          }
-          subprocess_writer.puts subprocess_output.to_json
-          subprocess_writer.close
-          $subprocess_logfile.close
-        end
-
-        def parse_subprocess_results(subprocess_index, subprocess_output)
-          subprocess_result = {
-            'tests_passed' => false
-          }
-          if subprocess_output.empty?
-            FastlaneCore::UI.error("Something went terribly wrong: no output from parallelized batch #{subprocess_index}!")
-          else
-            subprocess_result = JSON.parse(subprocess_output)
-          end
-          subprocess_result
-        end
-
-        def stream_subprocess_result_to_console(index, subprocess_logfilepath)
-          puts '-' * 80
-          if File.exist?(subprocess_logfilepath)
-            simulator_prefix = "[Sim-#{index}]"
-            unless ENV['FASTLANE_DISABLE_COLORS']
-            colors = String.colors - [:default, :black, :white]
-            color = colors.sample
-              simulator_prefix = simulator_prefix.colorize(color)
-            end
-            File.foreach(subprocess_logfilepath) do |line|
-              print simulator_prefix, line
-            end
-          end
-        end
-
-        def handle_subprocesses
-          # disconnect_subprocess_endpoints # to ensure no blocking on pipe
-          FastlaneCore::Helper.show_loading_indicator("Scanning in #{@batch_count} batches")
-          loop do
-            break if @pipe_endpoints.size.zero?
-
-            remaining_pipe_endpoints = @pipe_endpoints.map(&:first).reject { |pe| pe.closed? }
-            puts "there are #{remaining_pipe_endpoints.size} endpoints remaining".yellow
-            read_array, _, error_array = IO.select(remaining_pipe_endpoints)
-            read_array.each do |pipe_reader|
-              endpoint_index = @pipe_endpoints.find_index { |pe| pe.first == pipe_reader }
-              child_message_size = pipe_reader.stat.size
-              child_message = pipe_reader.read_nonblock(child_message_size)
-              subprocess_result = parse_subprocess_results(0, child_message)
-              if subprocess_result['message_type'] == 'completed'
-                stream_subprocess_result_to_console(subprocess_result['batch_index'], subprocess_result['subprocess_logfilepath'])
-                pipe_reader.close
-                @pipe_endpoints.delete_at(endpoint_index)
-              elsif subprocess_result['message_type'] == 'tryinfo'
-                puts "in simulator_manager, about to call @testrun_completed_block witth #{subprocess_result['tryinfo']}"
-                @testrun_completed_block && @testrun_completed_block.call(subprocess_result['tryinfo'])
-              end
-            end
-            error_array.each { |e| puts e }
-            break if error_array.size > 0
-            break if read_array.size.zero?
-          end
-          FastlaneCore::Helper.hide_loading_indicator
-        end
-
-        def wait_for_subprocesses
-          disconnect_subprocess_endpoints # to ensure no blocking on the pipe
-          FastlaneCore::Helper.show_loading_indicator("Scanning in #{@batch_count} batches")
-          Process.waitall
-          FastlaneCore::Helper.hide_loading_indicator
-        end
-
-        def handle_subprocesses_results
-          tests_passed = false
-          FastlaneCore::UI.header("Output from parallelized batch run")
-          @pipe_endpoints.each_with_index do |endpoints, index|
-            mainprocess_reader, = endpoints
-            subprocess_result = parse_subprocess_results(index, mainprocess_reader.read)
-            mainprocess_reader.close
-            stream_subprocess_result_to_console(index, subprocess_result['subprocess_logfilepath'])
-            tests_passed = subprocess_result['tests_passed']
-          end
-          puts '=' * 80
-          tests_passed
-          true
-        end
-      end
-    end
-  end
-end