fastlane-plugin-test_center 3.6.3.parallelizing.pre.alpha.pre.1 → 3.6.3

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

@@ -1,93 +0,0 @@
-module TestCenter
-  module Helper
-    module MultiScanManager
-      class RetryingScan
-        def initialize(options = {})
-          @options = options
-          @retrying_scan_helper = RetryingScanHelper.new(options)
-        end
-
-        def delete_xcresults
-          derived_data_path = File.expand_path(scan_config[:derived_data_path])
-          xcresults = Dir.glob("#{derived_data_path}/Logs/Test/*.xcresult")
-          FastlaneCore::UI.message("Deleting xcresults: #{xcresults}")
-          FileUtils.rm_rf(xcresults)
-        end
-
-        def scan_config
-          if Scan.config.nil?
-            Scan.config = FastlaneCore::Configuration.create(
-              Fastlane::Actions::ScanAction.available_options,
-              @options.select { |k,v| %i[project workspace scheme].include?(k) }
-            )
-          end
-          Scan.config
-        end
-
-        def update_scan_options
-          valid_scan_keys = Fastlane::Actions::ScanAction.available_options.map(&:key)
-          scan_options = @options.select { |k,v| valid_scan_keys.include?(k) }
-                                  .merge(@retrying_scan_helper.scan_options)
-
-          sc = scan_config
-          scan_options.each do |k,v|
-            sc.set(k,v) unless v.nil?
-          end
-        end
-
-        def run
-          update_scan_options
-          delete_xcresults
-
-          try_count = @options[:try_count] || 1
-          begin
-            @retrying_scan_helper.before_testrun
-
-            
-
-            # TODO: Investigate the following error:
-            """
-            2019-05-09 13:32:40.707 xcodebuild[78535:1944070] [MT] DVTAssertions: Warning in /Library/Caches/com.apple.xbs/Sources/IDEFrameworks_Fall2018/IDEFrameworks-14460.46/IDEFoundation/ProjectModel/ActionRecords/IDESchemeActionTestAttachment.m:186
-            Details:  Error writing attachment data to file /Users/lyndsey.ferguson/Library/Developer/Xcode/DerivedData/AtomicBoy-flqqvvvzbouqymbyffgdbtjoiufr/Logs/Test/Test-Transient Testing-2019.05.09_13-32-08--0400.xcresult/1_Test/Attachments/Screenshot_E0AE7940-E7F4-4CA8-BB2B-8822D730D10F.jpg: Error Domain=NSCocoaErrorDomain Code=4 \"The folder “Screenshot_E0AE7940-E7F4-4CA8-BB2B-8822D730D10F.jpg” doesn’t exist.\" UserInfo={NSFilePath=/Users/lyndsey.ferguson/Library/Developer/Xcode/DerivedData/AtomicBoy-flqqvvvzbouqymbyffgdbtjoiufr/Logs/Test/Test-Transient Testing-2019.05.09_13-32-08--0400.xcresult/1_Test/Attachments/Screenshot_E0AE7940-E7F4-4CA8-BB2B-8822D730D10F.jpg, NSUserStringVariant=Folder, NSUnderlyingError=0x7fa6ef34ef90 {Error Domain=NSPOSIXErrorDomain Code=2 \"No such file or directory\"}}
-            Object:   <IDESchemeActionTestAttachment: 0x7fa6ef22d270>
-            Method:   -_savePayload:
-            Thread:   <NSThread: 0x7fa6ea516110>{number = 1, name = main}
-            Please file a bug at https://bugreport.apple.com with this warning message and any useful information you can provide.
-
-            It may be due to:
-            2019-05-09 14:17:30.933 xcodebuild[86893:2045058]  IDETestOperationsObserverDebug: Failed to move logarchive from /Users/lyndsey.ferguson/Library/Developer/CoreSimulator/Devices/0D312041-2D60-4221-94CC-3B0040154D74/data/tmp/test-session-systemlogs-2019.05.09_14-17-04--0400.logarchive to diagnostics location /Users/lyndsey.ferguson/Library/Developer/Xcode/DerivedData/AtomicBoy-flqqvvvzbouqymbyffgdbtjoiufr/Logs/Test/Test-Transient Testing-2019.05.09_14-17-04--0400.xcresult/1_Test/Diagnostics/iPhone 5s_0D312041-2D60-4221-94CC-3B0040154D74/test-session-systemlogs-2019.05.09_14-17-04--0400.logarchive: Error Domain=NSCocoaErrorDomain Code=4 \"“test-session-systemlogs-2019.05.09_14-17-04--0400.logarchive” couldn’t be moved to “iPhone 5s_0D312041-2D60-4221-94CC-3B0040154D74” because either the former doesn’t exist, or the folder containing the latter doesn’t exist.\" UserInfo={NSSourceFilePathErrorKey=/Users/lyndsey.ferguson/Library/Developer/CoreSimulator/Devices/0D312041-2D60-4221-94CC-3B0040154D74/data/tmp/test-session-systemlogs-2019.05.09_14-17-04--0400.logarchive, NSUserStringVariant=(
-              Move
-              ), NSDestinationFilePath=/Users/lyndsey.ferguson/Library/Developer/Xcode/DerivedData/AtomicBoy-flqqvvvzbouqymbyffgdbtjoiufr/Logs/Test/Test-Transient Testing-2019.05.09_14-17-04--0400.xcresult/1_Test/Diagnostics/iPhone 5s_0D312041-2D60-4221-94CC-3B0040154D74/test-session-systemlogs-2019.05.09_14-17-04--0400.logarchive, NSFilePath=/Users/lyndsey.ferguson/Library/Developer/CoreSimulator/Devices/0D312041-2D60-4221-94CC-3B0040154D74/data/tmp/test-session-systemlogs-2019.05.09_14-17-04--0400.logarchive, NSUnderlyingError=0x7fdf96c6de90 {Error Domain=NSPOSIXErrorDomain Code=2 \"No such file or directory\"}}
-
-            """
-            update_scan_options
-            Scan::Runner.new.run
-            @retrying_scan_helper.after_testrun
-            true
-          rescue FastlaneCore::Interface::FastlaneTestFailure => e
-            @retrying_scan_helper.after_testrun(e)
-            retry if @retrying_scan_helper.testrun_count < try_count
-            false
-          rescue FastlaneCore::Interface::FastlaneBuildFailure => e
-            @retrying_scan_helper.after_testrun(e)
-            retry if @retrying_scan_helper.testrun_count < try_count
-            false
-          end
-        end
-      end
-    end
-  end
-end
-# Ug. How do I name this class?
-# I want a class that retries a scan
-# I want a class that controls or manages the class that retries the scan and the set up for that
-# etc.
-# So, the class or the realm could be:
-# MultiScanManager
-# MultiScanController
-# ScanManager
-# ScanMaster
-# MultiScanMaster
-# MasterScanManser
-# MasterMultiScan
-# I like MultiScanManager

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

@@ -1,236 +0,0 @@
-module TestCenter
-  module Helper
-    module MultiScanManager
-      require_relative 'device_manager'
-
-      class RetryingScanHelper
-
-        attr_reader :testrun_count
-
-        def initialize(options)
-          raise ArgumentError, 'Do not use the :device or :devices option. Instead use the :destination option.' if (options.key?(:device) or options.key?(:devices))
-
-          @options = options
-          @testrun_count = 0
-          @xcpretty_json_file_output = ENV['XCPRETTY_JSON_FILE_OUTPUT']
-
-          @reportnamer = ReportNameHelper.new(
-            options[:output_types],
-            options[:output_files],
-            options[:custom_report_file_name]
-          )
-        end
-        
-        def before_testrun
-          remove_preexisting_test_result_bundles
-          set_json_env
-          print_starting_scan_message
-        end
-
-        def print_starting_scan_message
-          scan_message = "Starting scan ##{@testrun_count + 1} with #{@options.fetch(:only_testing, []).size} tests"
-          scan_message << " for batch ##{@options[:batch]}" unless @options[:batch].nil?
-          FastlaneCore::UI.message("#{scan_message}.")
-        end
-
-        def set_json_env
-          return unless @reportnamer.includes_json?
-
-          ENV['XCPRETTY_JSON_FILE_OUTPUT'] = File.join(
-            @options[:output_directory],
-            @reportnamer.json_last_reportname
-          )
-        end
-
-        def reset_json_env
-          return unless @reportnamer.includes_json?
-
-          ENV['XCPRETTY_JSON_FILE_OUTPUT'] = @xcpretty_json_file_output
-        end
-
-        def remove_preexisting_test_result_bundles
-          return unless @options[:result_bundle]
-
-          absolute_output_directory = File.absolute_path(@options[:output_directory])
-          glob_pattern = "#{absolute_output_directory}/*.test_result"
-          preexisting_test_result_bundles = Dir.glob(glob_pattern)
-          FileUtils.rm_rf(preexisting_test_result_bundles)
-        end
-
-        def scan_options
-          valid_scan_keys = Fastlane::Actions::ScanAction.available_options.map(&:key)
-          @options.select { |k,v| valid_scan_keys.include?(k) }
-                  .merge(@reportnamer.scan_options)
-        end
-
-        # after_testrun methods
-
-        def after_testrun(exception = nil)
-          @testrun_count = @testrun_count + 1
-          if exception.kind_of?(FastlaneCore::Interface::FastlaneTestFailure)
-            handle_test_failure
-          elsif exception.kind_of?(FastlaneCore::Interface::FastlaneBuildFailure)
-            handle_build_failure(exception)
-          else
-            handle_success
-          end
-        end
-
-        def handle_success
-          send_callback_testrun_info
-          move_test_result_bundle_for_next_run
-          reset_json_env
-          collate_reports
-        end
-        
-        def collate_reports
-          absolute_output_directory = File.absolute_path(@options[:output_directory])
-
-          TestCenter::Helper::MultiScanManager::ReportCollator.new(
-            source_reports_directory_glob: absolute_output_directory,
-            output_directory: absolute_output_directory,
-            reportnamer: @reportnamer,
-            scheme: @options[:scheme],
-            result_bundle: @options[:result_bundle]
-          ).collate
-        end
-
-        def handle_test_failure
-          send_callback_testrun_info
-          reset_simulators
-          move_test_result_bundle_for_next_run
-          update_scan_options
-          @reportnamer.increment
-        end
-
-        def send_callback_testrun_info(additional_info = {})
-          return unless @options[:testrun_completed_block]
-
-          report_filepath = nil
-          junit_results = {}
-          unless additional_info.key?(:test_operation_failure)
-            report_filepath = File.absolute_path(File.join(@options[:output_directory], @reportnamer.junit_last_reportname))
-  
-            config = FastlaneCore::Configuration.create(
-              Fastlane::Actions::TestsFromJunitAction.available_options,
-              {
-                junit: File.absolute_path(report_filepath)
-              }
-            )
-            junit_results = Fastlane::Actions::TestsFromJunitAction.run(config)
-          end
-
-          info = {
-            failed: junit_results[:failed],
-            passing: junit_results[:passing],
-            batch: 1,
-            try_count: @testrun_count,
-            report_filepath: report_filepath
-          }.merge(additional_info)
-
-          if @reportnamer.includes_html?
-            html_report_filepath = File.join(@options[:output_directory], @reportnamer.html_last_reportname)
-            info[:html_report_filepath] = html_report_filepath
-          end
-          if @reportnamer.includes_json?
-            json_report_filepath = File.join(@options[:output_directory], @reportnamer.json_last_reportname)
-            info[:json_report_filepath] = json_report_filepath
-          end
-          if @options[:result_bundle]
-            test_result_suffix = '.test_result'
-            test_result_suffix.prepend("-#{@reportnamer.report_count}") unless @reportnamer.report_count.zero?
-            test_result_bundlepath = File.join(@options[:output_directory], @options[:scheme]) + test_result_suffix
-            info[:test_result_bundlepath] = test_result_bundlepath
-          end
-          @options[:testrun_completed_block].call(info)
-        end
-
-        def update_scan_options
-          update_only_testing
-          turn_off_code_coverage
-        end
-
-        def turn_off_code_coverage
-          # Turn off code coverage as code coverage reports are not merged and
-          # the first, more valuable, report will be overwritten
-          @options.delete(:code_coverage)
-        end
-
-        def update_only_testing
-          report_filepath = File.join(@options[:output_directory], @reportnamer.junit_last_reportname)
-          config = FastlaneCore::Configuration.create(
-            Fastlane::Actions::TestsFromJunitAction.available_options,
-            {
-              junit: File.absolute_path(report_filepath)
-            }
-          )
-          @options[:only_testing] = Fastlane::Actions::TestsFromJunitAction.run(config)[:failed]
-        end
-        
-        def reset_simulators
-          return unless @options[:reset_simulators]
-
-          @options[:simulators].each(&:reset)
-        end
-
-        def handle_build_failure(exception)
-          test_operation_failure = ''
-
-          test_session_last_messages = last_lines_of_test_session_log
-          test_operation_failure_match = /Test operation failure: (?<test_operation_failure>.*)$/ =~ test_session_last_messages
-          if test_operation_failure_match.nil?
-            test_operation_failure = 'Unknown test operation failure'
-          end
-          
-          case test_operation_failure
-          when /Test runner exited before starting test execution/
-            FastlaneCore::UI.error(test_operation_failure)
-          when /Lost connection to testmanagerd/
-            FastlaneCore::UI.error(test_operation_failure)
-            FastlaneCore::UI.important("com.apple.CoreSimulator.CoreSimulatorService may have become corrupt, consider quitting it")
-            if @options[:quit_core_simulator_service]
-              Fastlane::Actions::RestartCoreSimulatorServiceAction.run
-            end
-          else
-            FastlaneCore::UI.error(test_operation_failure)
-            send_callback_testrun_info(test_operation_failure: test_operation_failure)
-            raise exception
-          end
-          if @options[:reset_simulators]
-            @options[:simulators].each do |simulator|
-              simulator.reset
-            end
-          end
-          send_callback_testrun_info(test_operation_failure: test_operation_failure)
-        end
-
-        def last_lines_of_test_session_log
-          derived_data_path = File.expand_path(@options[:derived_data_path])
-          test_session_logs = Dir.glob("#{derived_data_path}/Logs/Test/*.xcresult/*_Test/Diagnostics/**/Session-*.log")
-          test_session_logs.sort! { |logfile1, logfile2| File.mtime(logfile1) <=> File.mtime(logfile2) }
-          test_session = File.open(test_session_logs.last)
-          backwards_seek_offset = -1 * [1000, test_session.stat.size].min
-          test_session.seek(backwards_seek_offset, IO::SEEK_END)
-          test_session_last_messages = test_session.read
-        end
-
-        def move_test_result_bundle_for_next_run
-          return unless @options[:result_bundle]
-
-          absolute_output_directory = File.absolute_path(@options[:output_directory])
-          glob_pattern = "#{absolute_output_directory}/*.test_result"
-          preexisting_test_result_bundles = Dir.glob(glob_pattern)
-          unnumbered_test_result_bundles = preexisting_test_result_bundles.reject do |test_result|
-            test_result =~ /.*-\d+\.test_result/
-          end
-          src_test_bundle = unnumbered_test_result_bundles.first
-          dst_test_bundle_parent_dir = File.dirname(src_test_bundle)
-          dst_test_bundle_basename = File.basename(src_test_bundle, '.test_result')
-          dst_test_bundle = "#{dst_test_bundle_parent_dir}/#{dst_test_bundle_basename}-#{@testrun_count}.test_result"
-          FileUtils.mkdir_p(dst_test_bundle)
-          FileUtils.mv(src_test_bundle, dst_test_bundle)
-        end
-      end
-    end
-  end
-end

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

@@ -1,313 +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]
-          @parallelize = multi_scan_options[:parallelize]
-          @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
-            ].include?(option)
-          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 scan
-          all_tests_passed = true
-          @testables_count = @test_collector.testables.size
-          all_tests_passed = each_batch do |test_batch, current_batch_index|
-            if ENV['USE_REFACTORED_PARALLELIZED_MULTI_SCAN']
-              # destination = @parallelizer&.destination_for_batch(current_batch_index) || Scan&.config&.fetch(:destination)
-              # if destination.nil?
-              #   app_infoplist ||= XCTestrunInfo.new(@scan_options[:xctestrun])
-                
-              #   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
-
-              #   device_description = @scan_options[:device]
-              #   device_name = 'iPhone 5s'
-              #   device_version = batch_deploymentversions[current_batch_index]
-              #   unless device_description.nil?
-              #     /(?<device_name>.*)\s+\((?<device_version>.*)\)/ =~ device_description
-              #   end
-              #   # TODO: check for an existing simulator that can serve
-              #   all_runtimes = ::Snapshot::ResetSimulators.runtimes
-
-              #   all_ios_runtimes = all_runtimes.select { |v, id| v[/^iOS/] }
-              #   ios_runtimes_greater_than_equal = all_ios_runtimes.select do |versionstr, _|
-              #     _, version = versionstr.split(' ')
-              #     Gem::Version.new(device_version) <= Gem::Version.new(version)
-              #   end
-              #   ios_runtimes_greater_than_equal.sort! do |a, b|
-              #     version_a = a.first.split(' ').last
-              #     version_b = b.first.split(' ').last
-              #     Gem::Version.new(version_a) <=> Gem::Version.new(version_b)
-              #   end
-                
-              #   runtime = ios_runtimes_greater_than_equal.first.last
-              #   device_type = `xcrun simctl list devicetypes`.scan(/(.*)\s\((.*)\)/)
-              #     .find { |name, device_id| name == device_name }
-
-              #   command = "xcrun simctl create '#{device_name}' #{device_type.last} #{runtime}"
-              #   UI.command(command) if ::FastlaneCore::Globals.verbose?
-              #   udid = `#{command}`.chomp
-              #   destination = "platform=iOS Simulator,id=#{udid}"
-              # end
-              retrying_scan = TestCenter::Helper::MultiScanManager::RetryingScan.new(
-                @scan_options.merge(
-                  # destination: destination,
-                  only_testing: test_batch.map(&:shellsafe_testidentifier),
-                  output_directory: @output_directory
-                ).reject { |key| %i[device devices].include?(key) }
-              )
-              retrying_scan.run
-            else
-              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
-            end
-            testrun_passed && all_tests_passed
-          end
-          all_tests_passed
-        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