b0VIM 8.2������~�bPU?��joshholtz�������������������������������Joshs-MacBook-Air.local�����������������~joshholtz/Developer/fastlane/fastlane/trainer/lib/trainer/test_parser.rb����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������utf-8 �3210����#"! U�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������tp�������������������������������� �������G�����������������������������������_����������������������������_���������������������J�������y���������������������a�����������������������������T�������!�������������������� �������u�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ad��� ��� ������������������������������q��p��a��N��6��5������������������y��A����� ��� ��� ��� ��p ��2 �����������������D����������`����� ��[ ��J �� ��� ��� ��R ��Q ��; �����������{��`��9���������������{��B����������o��A��������������F��7�������������W��G��9��-��,��������X��W��9�������������:�������������� number_of_skipped: � number_of_retries: tp.number_of_retries,� number_of_failures_excluding_retries: tp.number_of_failures_excluding_retries,� number_of_tests_excluding_retries: tp.number_of_tests_excluding_retries,� number_of_failures: tp.number_of_failures,� number_of_tests: tp.number_of_tests,� successful: tp.tests_successful?,� to_path: to_path,� return_hash[path] = {�� UI.success("Successfully generated '#{to_path}'") if should_write_file && !config[:silent]� File.write(to_path, tp.to_junit) if should_write_file� tp = Trainer::TestParser.new(path, config)�� end� end� end� to_path = path.gsub(".plist", extension)� else� to_path = path.gsub(".xcresult", extension)� if path.end_with?(".xcresult")� # Remove .xcresult or .plist extension� else� to_path = File.join(config[:output_directory], filename)� end� filename ||= File.basename(path).gsub(".plist", extension)� else� filename ||= File.basename(path).gsub(".xcresult", extension)� elsif path.end_with?(".xcresult")� filename = output_filename� if files.size == 1 && output_filename� # Use custom file name ONLY if one file otherwise issues� # Remove .xcresult or .plist extension� FileUtils.mkdir_p(config[:output_directory])� if config[:output_directory]� if should_write_file�� should_write_file = !extension.nil? || !output_filename.nil?�� output_filename = config[:output_filename]� extension = config[:extension]� files.each do |path|� return_hash = {}�� end� UI.user_error!("No test result files found in directory '#{containing_dir}', make sure the file name ends with 'TestSummaries.plist' or '.xcresult'")� if files.empty?�� files << containing_dir if File.extname(containing_dir) == ".xcresult"� files += Dir["#{containing_dir}/*.xcresult"]� files += Dir["#{containing_dir}/Test/*.xcresult"]� files += Dir["#{containing_dir}/**/Logs/Test/*.xcresult"]� # Xcode 11� files += Dir[containing_dir] if containing_dir.end_with?(".plist") # if it's the exact path to a plist file� files += Dir["#{containing_dir}/*.xcresult/TestSummaries.plist"]� files += Dir["#{containing_dir}/Test/*.xcresult/TestSummaries.plist"]� files += Dir["#{containing_dir}/**/Logs/Test/*.xcresult/TestSummaries.plist"]� # Xcode 10� files += Dir["#{containing_dir}/*TestSummaries.plist"]� files += Dir["#{containing_dir}/Test/*TestSummaries.plist"]� files = Dir["#{containing_dir}/**/Logs/Test/*TestSummaries.plist"]� # Xcode < 10� containing_dir = config[:path]�� end� title: "Summary for trainer #{Fastlane::VERSION}")� FastlaneCore::PrintTable.print_values(config: config,� unless config[:silent]� def self.auto_convert(config)� # defining if the tests were successful� # Returns a hash with th attr_accessor :number_of_skipped� attr_accessor :number_of_retries� attr_accessor :number_of_failures_excluding_retries� attr_accessor :number_of_tests_excluding_retries� attr_accessor :number_of_failures� attr_accessor :number_of_tests�� attr_accessor :raw_json�� attr_accessor :file_content�� attr_accessor :data� class TestParser�module Trainer��require_relative 'module'�require_relative 'xcresult'�require_relative 'junit_generator'��require 'fastlane_core/print_table'��require 'plist'�ad����������� ����������J������ ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������end� end� end� end� summary_row�� summary_row[:number_of_retries] = 0� summary_row[:number_of_failures_excluding_retries] = summary_row[:number_of_failures]� summary_row[:number_of_tests_excluding_retries] = summary_row[:number_of_tests]�ad��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� end� }� number_of_skipped: tp.number_of_skipped�ad�� ���������a�������������������e��J��%��$�����s��1��0��� ��_ �� ��������������j��+�� ��������N��D��C��� ��� ��? ��7 ��6 ��� ��� ��u ��* ��) ��������y��x��4��������������X���������������{��Q��P�������������������l��G��F�������������������|��{��J������������������c��,�����������������p��K��=��<���� ������������������������������ # Remove retry attempts from the count and test rows�� end� test_row�� tests_by_identifier[identifier] = info�� end� info[:success_count] = 1� else� info[:skip_count] += 1� test_row[:skipped] = true� elsif test.test_status == "Skipped"� info[:failure_count] += 1�� }]� failure_message: failure.failure_message� performance_failure: {},� message: "",� line_number: 0,� file_name: "",� test_row[:failures] = [{� if failure� failure = test.find_failure(failures)� # Set failure message if failure found�� info[:retry_count] = retry_count� end� retry_count += 1� else� retry_count = 0� if retry_count.nil?� retry_count = info[:retry_count]�� info[:success_count] ||= 0� info[:skip_count] ||= 0� info[:failure_count] ||= 0� info = tests_by_identifier[identifier] || {}�� }� guid: ""� # These don't map to anything but keeping empty strings�� test_group: test.parent.name,� status: test.test_status,� duration: test.duration,� name: test.name,� identifier: identifier,� test_row = {� identifier = "#{test.parent.name}.#{test.name}"� test_rows = all_tests.map do |test|�� tests_by_identifier = {}� # The identifier is duplicated until test succeeds or max count is reachd� # This is used when Xcode 13 (and up) retries tests� # Used by store number of passes and failures by identifier�� all_tests = testable_summary.all_tests.flatten� rows = testable_summaries.map do |testable_summary|� # Maps ActionTestableSummary to rows for junit generator�� testable_summaries = all_summaries.map(&:testable_summaries).flatten� all_summaries = summaries.map(&:summaries).flatten� # Gets flat list of all ActionTestableSummary� def summaries_to_data(summaries, failures, output_remove_retry_attempts: false)�� end� summaries_to_data(summaries, failures, output_remove_retry_attempts: output_remove_retry_attempts)� failures = actions_invocation_record.issues.test_failure_summaries || []� # Converts the ActionTestPlanRunSummaries to data for junit generator�� end� Trainer::XCResult::ActionTestPlanRunSummaries.new(json)� json = JSON.parse(raw)� raw = execute_cmd("xcrun xcresulttool get --format json --path #{path} --id #{id}")� summaries = ids.map do |id|� # containing specific information for each test summary,� # Maps ids into ActionTestPlanRunSummaries by executing xcresulttool to get JSON�� ids = test_refs.map(&:id)� end.compact� action.action_result.tests_ref� test_refs = actions_invocation_record.actions.map do |action|� actions_invocation_record = Trainer::XCResult::ActionsInvocationRecord.new(result_bundle_object)� # Parses JSON into ActionsInvocationRecord to find a list of all ids for ActionTestPlanRunSummaries�� result_bundle_object = JSON.parse(result_bundle_object_raw)� result_bundle_object_raw = execute_cmd("xcrun xcresulttool get --format json --path #{path}")� # Executes xcresulttool to get JSON format of the result bundle object�� path = Shellwords.escape(path)� require 'shellwords'� def parse_xcresult(path, output_remove_retry_attempts: false)�� end� return output� raise "Failed to execute - #{cmd}" unless $?.success?�ad��=���������T�������������������X��%��$�����������v��u��(����� ��� ��� �� ��~ ��k ��] ��Q ��P ��@ ��� ��������e��J��@��?�� ��������5��� ��� ��c ��� ��� ��� ��} ��s ��r ��[ ��S ��R �� �����������J�������v��#��������d��;����������u��D��6����������U���������� ��������������������g��������������������������������������������������������������������������� # Makes sure that plist support matches data output of xcresult�� summary_row[:number_of_failures] = summary_row[:tests].find_all { |a| (a[:failures] || []).count > 0 }.count� summary_row[:number_of_tests] = summary_row[:tests].count� }� end� current_row� end� end� }� failure_message: "#{current_failure['Message']} (#{current_failure['FileName']}:#{current_failure['LineNumber']})"� performance_failure: current_failure['PerformanceFailure'],� message: current_failure['Message'],� line_number: current_failure['LineNumber'],� file_name: current_failure['FileName'],� {� current_row[:failures] = current_test["FailureSummaries"].collect do |current_failure|� if current_test["FailureSummaries"]� }� duration: current_test["Duration"]� guid: current_test["TestSummaryGUID"],� status: current_test["TestStatus"],� object_class: current_test["TestObjectClass"],� name: test_name,� test_group: test_group,� identifier: current_test["TestIdentifier"],� current_row = {� test_group, test_name = test_group_and_name(testable_summary, current_test, xcpretty_naming)� tests: unfold_tests(testable_summary["Tests"]).collect do |current_test|� duration: testable_summary["Tests"].map { |current_test| current_test["Duration"] }.inject(:+),� test_name: testable_summary["TestName"],� target_name: testable_summary["TargetName"],� project_path: testable_summary["ProjectPath"],� summary_row = {� self.data = self.raw_json["TestableSummaries"].collect do |testable_summary|� def parse_content(xcpretty_naming)� # Convert the Hashes and Arrays in something more useful�� end� self.data = rows�� end� row�� row[:number_of_retries] = unique_tests.map { |a| a[:retry_count] }.inject(:+)� row[:number_of_failures_excluding_retries] = unique_tests.find_all { |a| (a[:success_count] + a[:skip_count]) == 0 }.count� row[:number_of_skipped] = unique_tests.map { |a| a[:skip_count] }.inject(:+)� row[:number_of_tests_excluding_retries] = unique_tests.count� unique_tests = tests_by_identifier.values || []� # Used for seeing if any tests continued to fail after all of the Xcode 13 (and up) retries have finished�� row[:number_of_failures] = row[:tests].find_all { |a| (a[:failures] || []).count > 0 }.count� row[:number_of_tests] = row[:tests].count�� }� tests: test_rows� duration: all_tests.map(&:duration).inject(:+),� test_name: testable_summary.name,� target_name: testable_summary.target_name,� project_path: testable_summary.project_relative_path,� row = {�� end� end� remove�� end� tests_by_identifier[identifier] = info� info[:retry_count] -= 1� info[:failure_count] -= 1� if remove� # Remove all failure and retry count if test did eventually pass�� end� remove = !(test_row[:failures] || []).empty?� if info[:retry_count] > 0� # Remove if this row is a retry and is a failure�� info = tests_by_identifier[identifier]� identifier = test_row[:identifier]�� remove = false� test_rows = test_rows.reject do |test_row|� if output_remove_retry_attempts�ad��������������������������������I��H�� ��������q��6��5��� ��� ��� ��� ��x ��w ��X ��6 �� �����������S�������H����� ��� ��� ��� ��� ��� ��� ��� ��/ �� ��� ��� ��� ��� ��� ��� ��i ��? �����������7�������������������U��'��������n��H�����������`��&��%����������������b��B��6��,�����������u��0����������{��8��������������������������������������������������� output = `#{cmd}`� def execute_cmd(cmd)�� end� return group, name� end� name = test["TestName"]� group = test["TestIdentifier"].split("/")[0..-2].join(".")� else� name = test["TestName"][0..-3]� group = testable_summary["TargetName"] + "." + test["TestIdentifier"].split("/")[0..-2].join(".")� if xcpretty_naming� def test_group_and_name(testable_summary, test, xcpretty_naming)� # Pass xcpretty_naming = true to get the test naming aligned with xcpretty� # Returns the test group and test name from the passed summary and test�� end� return tests� end� end� tests << current_hash� if current_hash["TestStatus"]� end� tests += unfold_tests(current_hash["Subtests"])� if current_hash["Subtests"]� data.each do |current_hash|� tests = []�� # "TestIdentifier"=>"Unit/testExample2()",� # "PerformanceFailure"=>false}],� # "Message"=>"XCTAssertTrue failed - ",� # "LineNumber"=>34,� # [{"FileName"=>"/Users/krausefx/Developer/themoji/Unit/Unit.swift",� # {"FailureSummaries"=>� # "TestSummaryGUID"=>"4A24BFED-03E6-4FBE-BC5E-2D80023C06B4"},� # "TestStatus"=>"Success",� # "TestObjectClass"=>"IDESchemeActionTestSummary",� # "TestName"=>"testExample()",� # "TestIdentifier"=>"Unit/testExample()",� # [{"Duration"=>0.4,� # [{"Subtests"=>� # [{"Subtests"=>� # => [{"Subtests"=>� # `data` looks like this� def unfold_tests(data)� # Converts the raw plist test structure into something that's easier to enumerate�� end� UI.user_error!("Format version '#{format_version}' is not supported, must be #{supported_versions.join(', ')}") unless supported_versions.include?(format_version)� supported_versions = ["1.1", "1.2"]� format_version = self.raw_json["FormatVersion"]� def ensure_file_valid!�� private�� end� self.data.collect { |a| a[:number_of_failures] }.all?(&:zero?)� def tests_successful?� # @return [Bool] were all tests successful? Is false if at least one test failed�� end� JunitGenerator.new(self.data).generate� def to_junit� # Returns the JUnit report as String�� end� end� self.number_of_retries += thing[:number_of_retries].to_i� self.number_of_failures_excluding_retries += thing[:number_of_failures_excluding_retries].to_i� self.number_of_tests_excluding_retries += thing[:number_of_tests_excluding_retries].to_i� self.number_of_failures += thing[:number_of_failures].to_i� self.number_of_tests += thing[:number_of_tests].to_i self.number_of_skipped = 0� self.number_of_retries = 0� self.number_of_failures_excluding_retries = 0� self.number_of_tests_excluding_retries = 0� self.number_of_failures = 0� self.number_of_tests = 0�� end� parse_content(config[:xcpretty_naming])� ensure_file_valid!�� return if self.raw_json["FormatVersion"].to_s.length.zero? # maybe that's a useless plist file�� self.raw_json = Plist.parse_xml(self.file_content)� self.file_content = File.read(path)� else� parse_xcresult(path, output_remove_retry_attempts: config[:output_remove_retry_attempts])� if File.directory?(path) && path.end_with?(".xcresult")�� UI.user_error!("File not found at path '#{path}'") unless File.exist?(path)� path = File.expand_path(path)� def initialize(path, config = {})�� end� return_hash�ad�����������J�������������`��������W����������� ��� ��� ��� ��� ��> ��$ ��������������������x��N�����������F��+����� ��� ��� ��� ��d ��6 ��� ��� ��} ��W �� ��������o��5��4��#�������������q��Q��E��;��(�� ����������?��&�����������G��'������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ output = `#{cmd}`� def execute_cmd(cmd)�� end� return group, name� end� name = test["TestName"]� group = test["TestIdentifier"].split("/")[0..-2].join(".")� else� name = test["TestName"][0..-3]� group = testable_summary["TargetName"] + "." + test["TestIdentifier"].split("/")[0..-2].join(".")� if xcpretty_naming� def test_group_and_name(testable_summary, test, xcpretty_naming)� # Pass xcpretty_naming = true to get the test naming aligned with xcpretty� # Returns the test group and test name from the passed summary and test�� end� return tests� end� end� tests << current_hash� if current_hash["TestStatus"]� end� tests += unfold_tests(current_hash["Subtests"])� if current_hash["Subtests"]� data.each do |current_hash|� tests = []�� # "TestIdentifier"=>"Unit/testExample2()",� # "PerformanceFailure"=>false}],� # "Message"=>"XCTAssertTrue failed - ",� # "LineNumber"=>34,� # [{"FileName"=>"/Users/krausefx/Developer/themoji/Unit/Unit.swift",� # {"FailureSummaries"=>� # "TestSummaryGUID"=>"4A24BFED-03E6-4FBE-BC5E-2D80023C06B4"},� # "TestStatus"=>"Success",� # "TestObjectClass"=>"IDESchemeActionTestSummary",� # "TestName"=>"testExample()",� # "TestIdentifier"=>"Unit/testExample()",� # [{"Duration"=>0.4,� # [{"Subtests"=>� # [{"Subtests"=>� # => [{"Subtests"=>� # `data` looks like this� def unfold_tests(data)� # Converts the raw plist test structure into something that's easier to enumerate�� end� UI.user_error!("Format version '#{format_version}' is not supported, must be #{supported_versions.join(', ')}") unless supported_versions.include?(format_version)� supported_versions = ["1.1", "1.2"]� format_version = self.raw_json["FormatVersion"]� def ensure_file_valid!�� private�� end� self.data.collect { |a| a[:number_of_failures] }.all?(&:zero?)� def tests_successful?� # @return [Bool] were all tests successful? Is false if at least one test failed�� end� JunitGenerator.new(self.data).generate� def to_junit� # Returns the JUnit report as String�� end� end� self.number_of_skipped += thing[:number_of_skipped].to_i� self.number_of_retries += thing[:number_of_retries].to_i� self.number_of_failures_excluding_retries += thing[:number_of_failures_excluding_retries].to_i� self.number_of_tests_excluding_retries += thing[:number_of_tests_excluding_retries].to_i� self.number_of_failures += thing[:number_of_failures].to_i� self.number_of_tests += thing[:number_of_tests].to_i� self.data.each do |thing|�ad��Z��������G����������������q��T����������������q��(��� ��� ��� ��D ��������?��.�����������6��5����� ��w ��v ��_ ��D �� ��� ��� ��� ��� ��� ��_ ��& ��������|��S��%����������o��*�������������r��;��+��������������<��;������������q���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� number_of_retries: tp.number_of_retries,� number_of_failures_excluding_retries: tp.number_of_failures_excluding_retries,� number_of_tests_excluding_retries: tp.number_of_tests_excluding_retries,� number_of_failures: tp.number_of_failures,� number_of_tests: tp.number_of_tests,� successful: tp.tests_successful?,� to_path: to_path,� return_hash[path] = {�� UI.success("Successfully generated '#{to_path}'") if should_write_file && !config[:silent]� File.write(to_path, tp.to_junit) if should_write_file� tp = Trainer::TestParser.new(path, config)�� end� end� end� to_path = path.gsub(".plist", extension)� else� to_path = path.gsub(".xcresult", extension)� if path.end_with?(".xcresult")� # Remove .xcresult or .plist extension� else� to_path = File.join(config[:output_directory], filename)� end� filename ||= File.basename(path).gsub(".plist", extension)� else� filename ||= File.basename(path).gsub(".xcresult", extension)� elsif path.end_with?(".xcresult")� filename = output_filename� if files.size == 1 && output_filename� # Use custom file name ONLY if one file otherwise issues� # Remove .xcresult or .plist extension� FileUtils.mkdir_p(config[:output_directory])� if config[:output_directory]� if should_write_file�� should_write_file = !extension.nil? || !output_filename.nil?�� output_filename = config[:output_filename]� extension = config[:extension]� files.each do |path|� return_hash = {}�� end� UI.user_error!("No test result files found in directory '#{containing_dir}', make sure the file name ends with 'TestSummaries.plist' or '.xcresult'")� if files.empty?�� files << containing_dir if File.extname(containing_dir) == ".xcresult"� files += Dir["#{containing_dir}/*.xcresult"]� files += Dir["#{containing_dir}/Test/*.xcresult"]� files += Dir["#{containing_dir}/**/Logs/Test/*.xcresult"]� # Xcode 11� files += Dir[containing_dir] if containing_dir.end_with?(".plist") # if it's the exact path to a plist file� files += Dir["#{containing_dir}/*.xcresult/TestSummaries.plist"]� files += Dir["#{containing_dir}/Test/*.xcresult/TestSummaries.plist"]� files += Dir["#{containing_dir}/**/Logs/Test/*.xcresult/TestSummaries.plist"]� # Xcode 10� files += Dir["#{containing_dir}/*TestSummaries.plist"]� files += Dir["#{containing_dir}/Test/*TestSummaries.plist"]� files = Dir["#{containing_dir}/**/Logs/Test/*TestSummaries.plist"]� # Xcode < 10� containing_dir = config[:path]�� end� title: "Summary for trainer #{Fastlane::VERSION}")� FastlaneCore::PrintTable.print_values(config: config,� unless config[:silent]� def self.auto_convert(config)� # defining if the tests were successful� # Returns a hash with the path being the key, and the value��