fastlane 2.54.0.beta.20170822010003 → 2.54.0

data/snapshot/lib/assets/SnapshotHelperXcode8.swift

@@ -0,0 +1,173 @@
+//
+//  SnapshotHelperXcode8.swift
+//  Example
+//
+//  Created by Felix Krause on 10/8/15.
+//  Copyright © 2015 Felix Krause. All rights reserved.
+//
+
+// -----------------------------------------------------
+// IMPORTANT: When modifying this file, make sure to 
+//            increment the version number at the very
+//            bottom of the file to notify users about
+//            the new SnapshotHelperXcode8.swift
+// -----------------------------------------------------
+
+import Foundation
+import XCTest
+
+var deviceLanguage = ""
+var locale = ""
+
+@available(*, deprecated, message: "use setupSnapshot: instead")
+func setLanguage(_ app: XCUIApplication) {
+    setupSnapshot(app)
+}
+
+func setupSnapshot(_ app: XCUIApplication) {
+    Snapshot.setupSnapshot(app)
+}
+
+func snapshot(_ name: String, waitForLoadingIndicator: Bool = true) {
+    Snapshot.snapshot(name, waitForLoadingIndicator: waitForLoadingIndicator)
+}
+
+open class Snapshot: NSObject {
+
+    open class func setupSnapshot(_ app: XCUIApplication) {
+        setLanguage(app)
+        setLocale(app)
+        setLaunchArguments(app)
+    }
+
+    class func setLanguage(_ app: XCUIApplication) {
+        guard let prefix = pathPrefix() else {
+            return
+        }
+
+        let path = prefix.appendingPathComponent("language.txt")
+
+        do {
+            let trimCharacterSet = CharacterSet.whitespacesAndNewlines
+            deviceLanguage = try String(contentsOf: path, encoding: .utf8).trimmingCharacters(in: trimCharacterSet)
+            app.launchArguments += ["-AppleLanguages", "(\(deviceLanguage))"]
+        } catch {
+            print("Couldn't detect/set language...")
+        }
+    }
+
+    class func setLocale(_ app: XCUIApplication) {
+        guard let prefix = pathPrefix() else {
+            return
+        }
+
+        let path = prefix.appendingPathComponent("locale.txt")
+
+        do {
+            let trimCharacterSet = CharacterSet.whitespacesAndNewlines
+            locale = try String(contentsOf: path, encoding: .utf8).trimmingCharacters(in: trimCharacterSet)
+        } catch {
+            print("Couldn't detect/set locale...")
+        }
+        if locale.isEmpty {
+            locale = Locale(identifier: deviceLanguage).identifier
+        }
+        app.launchArguments += ["-AppleLocale", "\"\(locale)\""]
+    }
+
+    class func setLaunchArguments(_ app: XCUIApplication) {
+        guard let prefix = pathPrefix() else {
+            return
+        }
+
+        let path = prefix.appendingPathComponent("snapshot-launch_arguments.txt")
+        app.launchArguments += ["-FASTLANE_SNAPSHOT", "YES", "-ui_testing"]
+
+        do {
+            let launchArguments = try String(contentsOf: path, encoding: String.Encoding.utf8)
+            let regex = try NSRegularExpression(pattern: "(\\\".+?\\\"|\\S+)", options: [])
+            let matches = regex.matches(in: launchArguments, options: [], range: NSRange(location:0, length:launchArguments.characters.count))
+            let results = matches.map { result -> String in
+                (launchArguments as NSString).substring(with: result.range)
+            }
+            app.launchArguments += results
+        } catch {
+            print("Couldn't detect/set launch_arguments...")
+        }
+    }
+
+    open class func snapshot(_ name: String, waitForLoadingIndicator: Bool = true) {
+        if waitForLoadingIndicator {
+            waitForLoadingIndicatorToDisappear()
+        }
+
+        print("snapshot: \(name)") // more information about this, check out https://github.com/fastlane/fastlane/tree/master/snapshot#how-does-it-work
+
+        sleep(1) // Waiting for the animation to be finished (kind of)
+
+        #if os(tvOS)
+            XCUIApplication().childrenMatchingType(.Browser).count
+        #elseif os(OSX)
+            XCUIApplication().typeKey(XCUIKeyboardKeySecondaryFn, modifierFlags: [])
+        #else
+            XCUIDevice.shared().orientation = .unknown
+        #endif
+    }
+
+    class func waitForLoadingIndicatorToDisappear() {
+        #if os(tvOS)
+            return
+        #endif
+
+        let query = XCUIApplication().statusBars.children(matching: .other).element(boundBy: 1).children(matching: .other)
+
+        while (0..<query.count).map({ query.element(boundBy: $0) }).contains(where: { $0.isLoadingIndicator }) {
+            sleep(1)
+            print("Waiting for loading indicator to disappear...")
+        }
+    }
+
+    class func pathPrefix() -> URL? {
+        let homeDir: URL
+        // on OSX config is stored in /Users/<username>/Library
+        // and on iOS/tvOS/WatchOS it's in simulator's home dir
+        #if os(OSX)
+            guard let user = ProcessInfo().environment["USER"] else {
+                print("Couldn't find Snapshot configuration files - can't detect current user ")
+                return nil
+            }
+
+            guard let usersDir =  FileManager.default.urls(for: .userDirectory, in: .localDomainMask).first else {
+                print("Couldn't find Snapshot configuration files - can't detect `Users` dir")
+                return nil
+            }
+
+            homeDir = usersDir.appendingPathComponent(user)
+        #else
+            guard let simulatorHostHome = ProcessInfo().environment["SIMULATOR_HOST_HOME"] else {
+                print("Couldn't find simulator home location. Please, check SIMULATOR_HOST_HOME env variable.")
+                return nil
+            }
+            guard let homeDirUrl = URL(string: simulatorHostHome) else {
+                print("Can't prepare environment. Simulator home location is inaccessible. Does \(simulatorHostHome) exist?")
+                return nil
+            }
+            homeDir = URL(fileURLWithPath: homeDirUrl.path)
+        #endif
+        return homeDir.appendingPathComponent("Library/Caches/tools.fastlane")
+    }
+}
+
+extension XCUIElement {
+    var isLoadingIndicator: Bool {
+        let whiteListedLoaders = ["GeofenceLocationTrackingOn", "StandardLocationTrackingOn"]
+        if whiteListedLoaders.contains(self.identifier) {
+            return false
+        }
+        return self.frame.size == CGSize(width: 10, height: 20)
+    }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated configuration files
+// SnapshotHelperXcode8Version [1.4]

data/snapshot/lib/snapshot.rb

@@ -6,12 +6,16 @@ require 'snapshot/screenshot_rotate'
 require 'snapshot/dependency_checker'
 require 'snapshot/latest_os_version'
 require 'snapshot/test_command_generator'
+require 'snapshot/test_command_generator_xcode_8'
 require 'snapshot/error_handler'
 require 'snapshot/collector'
 require 'snapshot/options'
 require 'snapshot/update'
 require 'snapshot/fixes/simulator_zoom_fix'
 require 'snapshot/fixes/hardware_keyboard_fix'
+require 'snapshot/simulator_launchers/launcher_configuration'
+require 'snapshot/simulator_launchers/simulator_launcher'
+require 'snapshot/simulator_launchers/simulator_launcher_xcode_8'
 
 require 'fastlane_core'
 
@@ -46,6 +50,8 @@ module Snapshot
   UI = FastlaneCore::UI
   ROOT = Pathname.new(File.expand_path('../..', __FILE__))
   DESCRIPTION = "Automate taking localized screenshots of your iOS and tvOS apps on every device"
+  CACHE_DIR = File.join(Dir.home, "Library/Caches/tools.fastlane")
+  SCREENSHOTS_DIR = File.join(CACHE_DIR, 'screenshots')
 
   Snapshot::DependencyChecker.check_dependencies
 

data/snapshot/lib/snapshot/collector.rb

@@ -7,8 +7,18 @@ module Snapshot
       containing = File.join(TestCommandGenerator.derived_data_path, "Logs", "Test")
       attachments_path = File.join(containing, "Attachments")
 
-      to_store = attachments(containing)
-      matches = output.scan(/snapshot: (.*)/)
+      language_folder = File.join(Snapshot.config[:output_directory], dir_name)
+      FileUtils.mkdir_p(language_folder)
+
+      # Xcode 9 introduced a new API to take screenshots which allows us
+      # to avoid parsing the generated plist file to find the screenshots
+      # and instead, we can save them to a known location to use later on.
+      if Helper.xcode_at_least?(9)
+        return collect_screenshots_for_language_folder(language_folder)
+      else
+        to_store = attachments(containing)
+        matches = output.scan(/snapshot: (.*)/)
+      end
 
       if to_store.count == 0 && matches.count == 0
         return false
@@ -22,25 +32,41 @@ module Snapshot
         name = current[0]
         filename = to_store[index]
 
-        language_folder = File.join(Snapshot.config[:output_directory], dir_name)
-        FileUtils.mkdir_p(language_folder)
-
         device_name = device_type.delete(" ")
+
         components = [launch_arguments_index].delete_if { |a| a.to_s.length == 0 }
         screenshot_name = device_name + "-" + name + "-" + Digest::MD5.hexdigest(components.join("-")) + ".png"
         output_path = File.join(language_folder, screenshot_name)
+
         from_path = File.join(attachments_path, filename)
-        if FastlaneCore::Globals.verbose?
-          UI.success "Copying file '#{from_path}' to '#{output_path}'..."
-        else
-          UI.success "Copying '#{output_path}'..."
-        end
-        FileUtils.cp(from_path, output_path)
+
+        copy(from_path, output_path)
       end
+      return true
+    end
 
+    # Returns true if it succeeds
+    def self.collect_screenshots_for_language_folder(destination)
+      screenshots = Dir["#{SCREENSHOTS_DIR}/*.png"]
+      return false if screenshots.empty?
+      screenshots.each do |screenshot|
+        filename = File.basename(screenshot)
+        to_path = File.join(destination, filename)
+        copy(screenshot, to_path)
+      end
+      FileUtils.rm_rf(SCREENSHOTS_DIR)
       return true
     end
 
+    def self.copy(from_path, to_path)
+      if FastlaneCore::Globals.verbose?
+        UI.success "Copying file '#{from_path}' to '#{to_path}'..."
+      else
+        UI.success "Copying '#{to_path}'..."
+      end
+      FileUtils.cp(from_path, to_path)
+    end
+
     def self.attachments(containing)
       UI.message "Collecting screenshots..."
       plist_path = Dir[File.join(containing, "*.plist")].last # we clean the folder before each run

data/snapshot/lib/snapshot/detect_values.rb

@@ -41,6 +41,9 @@ module Snapshot
           # In Xcode 8, we only need iPad Pro 9.7 inch, not the iPad Air
           next if all_simulators.any? { |a| a.name.include?("9.7-inch") } && sim.name.include?("iPad Air")
 
+          # In Xcode 9, we only need one iPad Pro (12.9-inch)
+          next if sim.name.include?('iPad Pro (12.9-inch) (2nd generation)')
+
           # Filter iPhones
           # Full list: ["iPhone 4s", "iPhone 5", "iPhone 5s", "iPhone 6", "iPhone 6 Plus", "iPhone 6s", "iPhone 6s Plus"]
           next if sim.name.include?("5s") # same screen resolution as iPhone 5
@@ -52,7 +55,7 @@ module Snapshot
           config[:devices] << sim.name
         end
       elsif Snapshot.project.mac?
-        config[:devices] << "Mac"
+        config[:devices] = ["Mac"]
       end
     end
   end

data/snapshot/lib/snapshot/fixes/simulator_zoom_fix.rb

@@ -7,7 +7,7 @@ module Snapshot
 
     class SimulatorZoomFix
       def self.patch
-        UI.message "Patching '#{config_path}' to scale simulator to 100%"
+        UI.message "Patching all simulators '#{config_path}' to scale to 100%"
 
         FastlaneCore::DeviceManager.simulators.each do |simulator|
           simulator_name = simulator.name.tr("\s", "-")

data/snapshot/lib/snapshot/options.rb

@@ -181,6 +181,11 @@ module Snapshot
                                      env_name: "SNAPSHOT_NAMESPACE_LOG_FILES",
                                      description: "Separate the log files per device and per language",
                                      optional: true,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :concurrent_simulators,
+                                     env_name: "SNAPSHOT_EXECUTE_CONCURRENT_SIMULATORS",
+                                     description: "Take snapshots on multiple simulators concurrently. Note: This option is only applicable when running against Xcode 9",
+                                     default_value: true,
                                      is_string: false)
       ]
     end

data/snapshot/lib/snapshot/reports_generator.rb

@@ -15,7 +15,6 @@ module Snapshot
         Dir[File.join(language_folder, '*.png')].sort.each do |screenshot|
           available_devices.each do |key_name, output_name|
             next unless File.basename(screenshot).include?(key_name)
-
             # This screenshot is from this device
             @data[language] ||= {}
             @data[language][output_name] ||= []
@@ -38,9 +37,9 @@ module Snapshot
       system("open '#{export_path}'") unless Snapshot.config[:skip_open_summary]
     end
 
-    def available_devices
+    def xcode_8_and_below_device_name_mappings
       # The order IS important, since those names are used to check for include?
-      # and the iPhone 6 is inlucded in the iPhone 6 Plus
+      # and the iPhone 6 is included in the iPhone 6 Plus
       {
         'AppleTV1080p' => 'Apple TV',
         'iPhone7Plus' => "iPhone7Plus (5.5-Inch)",
@@ -63,5 +62,37 @@ module Snapshot
         'Mac' => "Mac"
       }
     end
+
+    def xcode_9_and_above_device_name_mappings
+      {
+        # snapshot in Xcode 9 saves screenshots with the SIMULATOR_DEVICE_NAME
+        # which includes spaces
+        'iPhone 7 Plus' => "iPhone 7 Plus (5.5-Inch)",
+        'iPhone 7' => "iPhone 7 (4.7-Inch)",
+        'iPhone 6s Plus' => "iPhone 6s Plus (5.5-Inch)",
+        'iPhone 6 Plus' => "iPhone 6 Plus (5.5-Inch)",
+        'iPhone 6s' => "iPhone 6s (4.7-Inch)",
+        'iPhone 6' => "iPhone 6 (4.7-Inch)",
+        'iPhone 5s' => "iPhone 5 (4-Inch)",
+        'iPhone SE' => "iPhone SE",
+        'iPad Air' => 'iPad Air',
+        'iPad Air 2' => 'iPad Air 2',
+        'iPad (5th generation)' => 'iPad (5th generation)',
+        'iPad Pro (9.7-inch)' => 'iPad Pro (9.7-inch)',
+        'iPad Pro (10.5-inch)' => 'iPad Pro (10.5-inch)',
+        'iPad Pro (12.9-inch) (2nd generation)' => 'iPad Pro (12.9-inch) (2nd generation)',
+        'iPad Pro (12.9-inch)' => 'iPad Pro (12.9-inch)',
+        'Apple TV 1080p' => 'Apple TV',
+        'Mac' => 'Mac'
+      }
+    end
+
+    def available_devices
+      if Helper.xcode_at_least?("9.0")
+        return xcode_9_and_above_device_name_mappings
+      else
+        return xcode_8_and_below_device_name_mappings
+      end
+    end
   end
 end

data/snapshot/lib/snapshot/runner.rb

@@ -1,14 +1,10 @@
 require 'shellwords'
 require 'plist'
+require 'os'
+require 'thread'
 
 module Snapshot
   class Runner
-    # The number of times we failed on launching the simulator... sigh
-    attr_accessor :number_of_retries_due_to_failing_simulator
-
-    # All the errors we experience while running snapshot
-    attr_accessor :collected_errors
-
     def work
       if File.exist?("./fastlane/snapshot.js") or File.exist?("./snapshot.js")
         UI.error "Found old snapshot configuration file 'snapshot.js'"
@@ -32,85 +28,30 @@ module Snapshot
 
       UI.success "Building and running project - this might take some time..."
 
-      self.number_of_retries_due_to_failing_simulator = 0
-      self.collected_errors = []
-      results = {} # collect all the results for a nice table
-      launch_arguments_set = config_launch_arguments
-      Snapshot.config[:devices].each_with_index do |device, device_index|
-        launch_arguments_set.each do |launch_arguments|
-          Snapshot.config[:languages].each_with_index do |language, language_index|
-            locale = nil
-            if language.kind_of?(Array)
-              locale = language[1]
-              language = language[0]
-            end
-            results[device] ||= {}
-
-            current_run = device_index * Snapshot.config[:languages].count + language_index + 1
-            number_of_runs = Snapshot.config[:languages].count * Snapshot.config[:devices].count
-            UI.message("snapshot run #{current_run} of #{number_of_runs}")
+      launcher_config = SimulatorLauncherConfiguration.new(snapshot_config: Snapshot.config)
 
-            results[device][language] = run_for_device_and_language(language, locale, device, launch_arguments)
-
-            copy_simulator_logs(device, language, locale, launch_arguments)
-          end
-        end
+      if Helper.xcode_at_least?(9)
+        launcher = SimulatorLauncher.new(launcher_configuration: launcher_config)
+        results = launcher.take_screenshots_simultaneously
+      else
+        launcher = SimulatorLauncherXcode8.new(launcher_configuration: launcher_config)
+        results = launcher.take_screenshots_one_simulator_at_a_time
       end
 
       print_results(results)
 
-      UI.test_failure!(self.collected_errors.join('; ')) if self.collected_errors.count > 0
+      UI.test_failure!(launcher.collected_errors.uniq.join('; ')) if launcher.collected_errors.count > 0
 
       # Generate HTML report
       ReportsGenerator.new.generate
 
       # Clear the Derived Data
       unless Snapshot.config[:derived_data_path]
-        FileUtils.rm_rf(TestCommandGenerator.derived_data_path)
+        # this should actually be launcher.derived_data_path
+        FileUtils.rm_rf(TestCommandGeneratorBase.derived_data_path)
       end
     end
 
-    # This is its own method so that it can re-try if the tests fail randomly
-    # @return true/false depending on if the tests succeeded
-    def run_for_device_and_language(language, locale, device, launch_arguments, retries = 0)
-      return launch(language, locale, device, launch_arguments)
-    rescue => ex
-      UI.error ex.to_s # show the reason for failure to the user, but still maybe retry
-
-      if retries < Snapshot.config[:number_of_retries]
-        UI.important "Tests failed, re-trying #{retries + 1} out of #{Snapshot.config[:number_of_retries] + 1} times"
-        run_for_device_and_language(language, locale, device, launch_arguments, retries + 1)
-      else
-        UI.error "Backtrace:\n\t#{ex.backtrace.join("\n\t")}" if FastlaneCore::Globals.verbose?
-        self.collected_errors << ex
-        raise ex if Snapshot.config[:stop_after_first_error]
-        return false # for the results
-      end
-    end
-
-    def config_launch_arguments
-      launch_arguments = Array(Snapshot.config[:launch_arguments])
-      # if more than 1 set of arguments, use a tuple with an index
-      if launch_arguments.count == 1
-        [launch_arguments]
-      else
-        launch_arguments.map.with_index { |e, i| [i, e] }
-      end
-    end
-
-    def copy_simulator_logs(device_name, language, locale, launch_arguments)
-      return unless Snapshot.config[:output_simulator_logs]
-
-      detected_language = locale || language
-      language_folder = File.join(Snapshot.config[:output_directory], detected_language)
-      device = TestCommandGenerator.find_device(device_name)
-      components = [launch_arguments].delete_if { |a| a.to_s.length == 0 }
-
-      UI.header("Collecting system logs #{device_name} - #{language}")
-      log_identity = Digest::MD5.hexdigest(components.join("-"))
-      FastlaneCore::Simulator.copy_logs(device, log_identity, language_folder)
-    end
-
     def print_results(results)
       return if results.count == 0
 
@@ -133,145 +74,6 @@ module Snapshot
       puts ""
     end
 
-    # Returns true if it succeeded
-    def launch(language, locale, device_type, launch_arguments)
-      screenshots_path = TestCommandGenerator.derived_data_path
-      FileUtils.rm_rf(File.join(screenshots_path, "Logs"))
-      FileUtils.rm_rf(screenshots_path) if Snapshot.config[:clean]
-      FileUtils.mkdir_p(screenshots_path)
-
-      prefix = File.join(Dir.home, "Library/Caches/tools.fastlane")
-      FileUtils.mkdir_p(prefix)
-      File.write(File.join(prefix, "language.txt"), language)
-      File.write(File.join(prefix, "locale.txt"), locale || "")
-      File.write(File.join(prefix, "snapshot-launch_arguments.txt"), launch_arguments.last)
-
-      unless device_type == "Mac"
-        # Kill and shutdown all currently running simulators so that the following settings
-        # changes will be picked up when they are started again.
-        Snapshot.kill_simulator # because of https://github.com/fastlane/snapshot/issues/337
-        `xcrun simctl shutdown booted &> /dev/null`
-
-        Fixes::SimulatorZoomFix.patch
-        Fixes::HardwareKeyboardFix.patch
-
-        if Snapshot.config[:erase_simulator] || Snapshot.config[:localize_simulator]
-          erase_simulator(device_type)
-          if Snapshot.config[:localize_simulator]
-            localize_simulator(device_type, language, locale)
-          end
-        elsif Snapshot.config[:reinstall_app]
-          # no need to reinstall if device has been erased
-          uninstall_app(device_type)
-        end
-      end
-
-      add_media(device_type, :photo, Snapshot.config[:add_photos]) if Snapshot.config[:add_photos]
-      add_media(device_type, :video, Snapshot.config[:add_videos]) if Snapshot.config[:add_videos]
-
-      open_simulator_for_device(device_type)
-
-      command = TestCommandGenerator.generate(device_type: device_type, language: language, locale: locale)
-
-      if locale
-        UI.header("#{device_type} - #{language} (#{locale})")
-      else
-        UI.header("#{device_type} - #{language}")
-      end
-
-      prefix_hash = [
-        {
-          prefix: "Running Tests: ",
-          block: proc do |value|
-            value.include?("Touching")
-          end
-        }
-      ]
-
-      FastlaneCore::CommandExecutor.execute(command: command,
-                                          print_all: true,
-                                      print_command: true,
-                                             prefix: prefix_hash,
-                                            loading: "Loading...",
-                                              error: proc do |output, return_code|
-                                                ErrorHandler.handle_test_error(output, return_code)
-
-                                                # no exception raised... that means we need to retry
-                                                UI.error "Caught error... #{return_code}"
-
-                                                self.number_of_retries_due_to_failing_simulator += 1
-                                                if self.number_of_retries_due_to_failing_simulator < 20
-                                                  launch(language, locale, device_type, launch_arguments)
-                                                else
-                                                  # It's important to raise an error, as we don't want to collect the screenshots
-                                                  UI.crash!("Too many errors... no more retries...")
-                                                end
-                                              end)
-
-      raw_output = File.read(TestCommandGenerator.xcodebuild_log_path(device_type: device_type, language: language, locale: locale))
-
-      dir_name = locale || language
-
-      return Collector.fetch_screenshots(raw_output, dir_name, device_type, launch_arguments.first)
-    end
-
-    def open_simulator_for_device(device_name)
-      return unless FastlaneCore::Env.truthy?('FASTLANE_EXPLICIT_OPEN_SIMULATOR')
-
-      device = TestCommandGenerator.find_device(device_name)
-      FastlaneCore::Simulator.launch(device) if device
-    end
-
-    def uninstall_app(device_type)
-      UI.verbose "Uninstalling app '#{Snapshot.config[:app_identifier]}' from #{device_type}..."
-      Snapshot.config[:app_identifier] ||= UI.input("App Identifier: ")
-      device_udid = TestCommandGenerator.device_udid(device_type)
-
-      UI.message "Launch Simulator #{device_type}"
-      Helper.backticks("xcrun instruments -w #{device_udid} &> /dev/null")
-
-      UI.message "Uninstall application #{Snapshot.config[:app_identifier]}"
-      Helper.backticks("xcrun simctl uninstall #{device_udid} #{Snapshot.config[:app_identifier]} &> /dev/null")
-    end
-
-    def erase_simulator(device_type)
-      UI.verbose("Erasing #{device_type}...")
-      device_udid = TestCommandGenerator.device_udid(device_type)
-
-      UI.important("Erasing #{device_type}...")
-
-      `xcrun simctl erase #{device_udid} &> /dev/null`
-    end
-
-    def localize_simulator(device_type, language, locale)
-      device_udid = TestCommandGenerator.device_udid(device_type)
-      if device_udid
-        locale ||= language.sub("-", "_")
-        plist = {
-          AppleLocale: locale,
-          AppleLanguages: [language]
-        }
-        UI.message "Localizing #{device_type} (AppleLocale=#{locale} AppleLanguages=[#{language}])"
-        plist_path = "#{ENV['HOME']}/Library/Developer/CoreSimulator/Devices/#{device_udid}/data/Library/Preferences/.GlobalPreferences.plist"
-        File.write(plist_path, Plist::Emit.dump(plist))
-      end
-    end
-
-    def add_media(device_type, media_type, paths)
-      media_type = media_type.to_s
-
-      UI.verbose "Adding #{media_type}s to #{device_type}..."
-      device_udid = TestCommandGenerator.device_udid(device_type)
-
-      UI.message "Launch Simulator #{device_type}"
-      Helper.backticks("xcrun instruments -w #{device_udid} &> /dev/null")
-
-      paths.each do |path|
-        UI.message "Adding '#{path}'"
-        Helper.backticks("xcrun simctl add#{media_type} #{device_udid} #{path.shellescape} &> /dev/null")
-      end
-    end
-
     def clear_previous_screenshots
       UI.important "Clearing previously generated screenshots"
       path = File.join(Snapshot.config[:output_directory], "*", "*.png")
@@ -281,13 +83,26 @@ module Snapshot
       end
     end
 
-    def version_of_bundled_helper
+    # Depending on the Xcode version, the return value is different
+    def self.path_to_helper_file_from_gem
       runner_dir = File.dirname(__FILE__)
-      bundled_helper = File.read File.expand_path('../assets/SnapshotHelper.swift', runner_dir)
-      current_version = bundled_helper.match(/\n.*SnapshotHelperVersion \[.+\]/)[0]
 
-      ## Something like "// SnapshotHelperVersion [1.2]", but be relaxed about whitespace
-      current_version.gsub(%r{^//\w*}, '').strip
+      if Helper.xcode_at_least?("9.0")
+        return File.expand_path('../assets/SnapshotHelper.swift', runner_dir)
+      else
+        return File.expand_path('../assets/SnapshotHelperXcode8.swift', runner_dir)
+      end
+    end
+
+    def version_of_bundled_helper
+      asset_path = self.class.path_to_helper_file_from_gem
+      regex_to_use = Helper.xcode_at_least?("9.0") ? /\n.*SnapshotHelperVersion \[.+\]/ : /\n.*SnapshotHelperXcode8Version \[.+\]/
+
+      bundled_helper = File.read(asset_path)
+      current_version = bundled_helper.match(regex_to_use)[0]
+
+      # Something like "// SnapshotHelperVersion [1.2]", but be relaxed about whitespace
+      return current_version.gsub(%r{^//\w*}, '').strip
     end
 
     # rubocop:disable Style/Next