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��