parallel_calabash 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5e86fb602e2958bb44e857ec0cb81c1755904e1
-  data.tar.gz: 79a70e5354ac574d03691b929e8025d1c8e0106a
+  metadata.gz: 9d3c746855a83738b07bf9cf32ec7b325a4f395b
+  data.tar.gz: deb3562fc74e7b1e3d013eb98fa0b8148d93c15b
 SHA512:
-  metadata.gz: d26a69315b401ecc609ab9c8a3a934754276f1fb037b7d711da7ac5e165e7f809d533b71708879f6ae5b60de31c10973a37a000c0ced03ccc13d1ab82a1c65ea
-  data.tar.gz: 24bf3870f338d3a75664d33da1e607a5f08cc53642159956b54142a8ae335a48f8442b5c524fd27228617c49f6ba7e1562327647a4233745a9a8c440948ecd18
+  metadata.gz: ec49bae0ecd21aa231814738b08cb3429657169cedbb0671bcdb9c6d635dbe2f7cedb2f830651abaf1499c3c9a54e91bb83975a51c01d9a4f6b46f2932fa6992
+  data.tar.gz: e5fdee0cc4cfe40d18a82cc719c54ab58d021f371e24135604ad1de5b21dd9dac146f67555b0a1ef5f343acf6350e9e5e91d6d3e446036770e8aa1e281d025ac

data/README.md

@@ -5,9 +5,10 @@
 https://www.youtube.com/watch?v=sK3s0txeJvc
 
 
-Run calabash-android tests in parallel on multiple connected devices. This is inspired by parallel_tests  https://rubygems.org/gems/parallel_tests
+Run calabash-android or calabash-ios tests in parallel on multiple connected devices. This is inspired by parallel_tests  https://rubygems.org/gems/parallel_tests
 
-eg. bundle exec parallel_calabash -a my.apk -o'--format pretty' features/ --serialize-stdout
+eg. bundle exec parallel_calabash --apk my.apk -o'--format pretty' features/ --serialize-stdout
+eg. bundle exec parallel_calabash --app my.app -o'--format pretty' features/ --serialize-stdout
 
 ## Installation
 
@@ -25,13 +26,12 @@ Or install it yourself as:
 
     $ gem install parallel_calabash
 
-## Usage
+## Usage Android
 
 Usage: parallel_calabash [options]
 
 Example: parallel_calabash -a my.apk -o 'cucumber_opts_like_tags_profile_etc_here' features/
 
-
     -h, --help                       Show this message
     -v, --version                    Show version
     -a, --apk apk_path               apk file path
@@ -41,6 +41,84 @@ Example: parallel_calabash -a my.apk -o 'cucumber_opts_like_tags_profile_etc_her
     --group-by-scenarios             Distribute equally as per scenarios. This uses cucumber dry run
     --concurrent                     Run tests concurrently. Each test will run once on each device.
 
+## Usage iOS
+
+Example: parallel_calabash -app my.app --ios_config ~/.parallel_calabash.iphoneos -o '-cucumber -opts' -r '-cucumber -reports>' features/
+
+    -h, --help                       Show this message
+    -v, --version                    Show version
+        --app app_path               app file path
+        --device_target target       ios target if no .parallel-calabash config
+        --device_endpoint endpoint   ios endpoint if no .parallel-calabash config
+        --simulator type             for simctl create, e.g. 'com.apple.CoreSimulator.SimDeviceType.iPhone-6 com.apple.CoreSimulator.SimRuntime.iOS-8-4'
+        --ios_config file            for ios, configuration for devices and users
+    -d, --distribution-tag tag       divide features into groups as per occurrence of given tag
+    -f, --filter filter              Filter devices to run tests against keys or values in config. Multiple filters seperated by ','
+        --skip_ios_ping_check        Skip the connectivity test for iOS devices
+    -o, --cucumber_opts '[OPTIONS]'  execute with those cucumber options
+    -r '[REPORTS]',                  generate these cucumber reports (not during filtering)
+        --cucumber_reports
+        --serialize-stdout           Serialize stdout output, nothing will be written until everything is done
+        --concurrent                 Run tests concurrently. Each test will run once on each device
+        --group-by-scenarios         Distribute equally as per scenarios. This uses cucumber dry run
+
+### iOS set-up
+
+* iOS testing is only supported on MacOS hosts.
+* Create as many (Administrator-privileged!) test accounts as you have devices or want simulators (Settings > Users & Groups)
+* As the main user, the one that runs parallel_calabash, create ~/.parallel_calabash.iphonesimulator and/or ~/.parallel_calabash.iphoneos
+
+As follows:
+
+    {
+      USERS: [ 'tester1', 'tester2', 'tester3' ],
+      INIT: '[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"',
+      # You only need to specify the port if the default clashes for you. Simulators start sequentially from this.
+      # CALABASH_SERVER_PORT: 3800,
+      # You only need to give the test users' password if you want to run autostart_test_users
+      # PASSWORD: 'testuserspassword',
+      # You only need to set this if you want to run autostart_test_users and the default 6900 clashes with something.
+      # VNC_FORWARD: 6900,
+      # Omit 'DEVICES' entirely if you're only testing on simulators.
+      DEVICES: [
+        {
+          NAME: 'ios-iphone5c-tinkywinkie (8.4.1)',
+          DEVICE_TARGET: '23984729837401987239874987239',
+          DEVICE_ENDPOINT: 'http://192.168.126.206:37265'
+        },
+        {
+          NAME: 'ios-iphone6plus-lala (8.4)',
+          DEVICE_TARGET: 'c987234987983458729375923485792345',
+          DEVICE_ENDPOINT: 'http://192.168.126.205:37265',
+        },
+        {
+          NAME: 'ios-iphone6plus-dipsy (8.4.1)',
+          DEVICE_TARGET: '98723498792873459872398475982347589',
+          DEVICE_ENDPOINT: 'http://192.168.126.207:37265',
+        }
+      ]
+    }
+
+* As the main account, run ssh-keygen
+* As each test account:
+1. Use Screen Sharing to log in to the user's desktop (particularly if you're using simulators) to let the computer set it up.
+2. Settings > Sharing > Remote Login > Allow access for main account (if not already permitted by Remote Management)
+3. Copy ~main_account/.ssh/id_rsa.pub into each test account's ~tester1/.ssh/authorized_keys
+4. Any other set-up, e.g. ln -s /Users/main_account/.rvm ~/.rvm
+
+* If you don't want to test on simulators, your set-up stops here.
+* If you want to test on simulators too...
+* ... for each test user, Settings > Sharing > Screen sharing > Allow access (if not already permitted by Remote Management)
+* ... (we were suprised that a mac mini can cheerfully run upwards of 7 simulators without much struggle)
+* ... and as your primary user:
+1. Run: sudo defaults write com.apple.ScreenSharing skipLocalAddressCheck -boolean YES
+2. Run: ln -s ~/.parallel_config.iphonesimulator ~/.parallel_config.autostart  (or whatever your simulators' config is called).
+3. Add a PASSWORD: 'whatever', in your config - same password for all test users.
+4. Copy misc/autostart_test_users.app from the Git repository into the system /Applications/ directory
+5. Run /Applications/autostart_test_users, skip the countdown, and see it complain about accessibility; close the connection request dialog
+6. In Settings > Privacy & Security > Privacy > Accessibility, allow it - close Settings
+7. Re-run it, skip the countdown, and it should open a screen sharing session for each test user.
+8. Add it into Settings > User & Groups > Login Items, set BOOT_DELAY if you need to tune the post-login startup time.
 
 ## FILTERING
 Filters are partial matches on the device id, or model name.
@@ -53,7 +131,7 @@ emulator-5554          device product:sdk_phone_x86_64 model:Android_SDK_built_f
 To run against just the emulator: -f emulator
 To run against a device id list: -f 4100142545f271b5,4366432135f271c6
 
-## REPROTING
+## REPORTING
 
 use ENV['TEST_PROCESS_NUMBER'] environment variable in your ruby scripts to find out the process number. you can use this for reporting purpose OR process specific action.
 

data/bin/parallel_calabash

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 $LOAD_PATH << File.expand_path("../../lib", __FILE__)
-require "parallel_calabash"
+require 'parallel_calabash'
 require 'parallel_calabash/version'
 require 'optparse'
 
@@ -9,7 +9,7 @@ def parse_arguments(arguments)
   options = {}
   opt_parser = OptionParser.new do |opts|
     opts.banner = "Usage: parallel_calabash [options]\n" \
-                "Example: parallel_calabash -a my.apk -o '<cucumber opts>' features/"
+                "Example: parallel_calabash -a my.apk -o '<cucumber opts>' -r '<cucumber_reports>' features/"
 
     opts.on("-h", "--help", "Show this message") do
       puts opts
@@ -25,18 +25,46 @@ def parse_arguments(arguments)
       options[:apk_path] = apk_path
     end
 
-      opts.on("-d", "--distribution-tag tag", "divide features into groups as per occurrence of given tag") do |distribution_tag|
+    opts.on('--app app_path', 'app file path') do |app_path|
+      options[:app_path] = app_path
+    end
+
+    opts.on('--device_target target', 'ios target if no .parallel-calabash config') do |device_target|
+      options[:device_target] = device_target
+    end
+
+    opts.on('--device_endpoint endpoint', 'ios endpoint if no .parallel-calabash config') do |device_endpoint|
+      options[:device_endpoint] = device_endpoint
+    end
+
+    opts.on('--simulator type', "for simctl create, e.g. 'com.apple.CoreSimulator.SimDeviceType.iPhone-6 com.apple.CoreSimulator.SimRuntime.iOS-8-4'") do |simulator|
+      options[:simulator] = simulator
+    end
+
+    opts.on('--ios_config file', 'for ios, configuration for devices and users') do |ios_config|
+      options[:ios_config] = ios_config
+    end
+
+    opts.on("-d", "--distribution-tag tag", "divide features into groups as per occurrence of given tag") do |distribution_tag|
       options[:distribution_tag] = distribution_tag
     end
 
     opts.on("-f", "--filter filter", "Filter devices to run tests against using partial device id or model name matching. Multiple filters seperated by ','") do |filter_opts|
-      options[:filter] = filter_opts.split(",")
+      options[:filter] = filter_opts.split(',').grep(/./)
+    end
+
+    opts.on('--skip_ios_ping_check', 'Skip the connectivity test for iOS devices') do
+      options[:skip_ios_ping_check] = true
     end
 
     opts.on("-o", "--cucumber_opts '[OPTIONS]'", "execute with those cucumber options") do |cucumber_opts|
       options[:cucumber_options] = cucumber_opts
     end
 
+    opts.on("-r", "--cucumber_reports '[REPORTS]'", "generate these cucumber reports (not during filtering)") do |cucumber_reports|
+      options[:cucumber_reports] = cucumber_reports
+    end
+
     opts.on("--serialize-stdout", "Serialize stdout output, nothing will be written until everything is done") do |mute_output|
       options[:mute_output] = mute_output
     end
@@ -53,14 +81,16 @@ def parse_arguments(arguments)
 
   opt_parser.parse!(arguments)
   options[:feature_folder] = arguments
+  fail '-a apk and -p app are mutually exclusive' if options.has_key?(:apk_path) && options.has_key?(:app_path)
+  fail '-a apk or -p app is required' unless options.has_key?(:apk_path) || options.has_key?(:app_path)
   options
-rescue OptionParser::InvalidOption
-  puts "Invalid arguments "
-  puts opt_parser.help
+rescue OptionParser::InvalidOption => e
+  puts "Invalid arguments #{e}"
+  fail opt_parser.help
 end
 
 options = parse_arguments(ARGV)
 
-ParallelCalabash.run_tests_in_parallel options
+ParallelCalabash::ParallelCalabashApp.new(options).run_tests_in_parallel
 
 

data/lib/parallel_calabash.rb

@@ -8,33 +8,62 @@ require 'parallel_calabash/result_formatter'
 require 'rbconfig'
 
 module ParallelCalabash
-
   WINDOWS = (RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/)
-  class << self
 
-    def number_of_processes_to_start options
-      number_of_processes = AdbHelper.number_of_connected_devices(options[:filter])
+  class ParallelCalabashApp
+
+    def initialize(options)
+      @options = options
+      @helper = if options.has_key?(:apk_path)
+                  ParallelCalabash::AdbHelper.new(options[:filter])
+                else
+                  ParallelCalabash::IosHelper.new(
+                      options[:filter],
+                      {
+                          DEVICE_TARGET: options[:device_target],
+                          DEVICE_ENDPOINT: options[:device_endpoint],
+                      },
+                      options[:ios_config]
+                  )
+                end
+      @runner = if options.has_key?(:apk_path)
+                  ParallelCalabash::AndroidRunner.new(@helper, options[:mute_output])
+                else
+                  ParallelCalabash::IosRunner.new(@helper, options[:mute_output], options[:skip_ios_ping_check])
+                end
+    end
+
+
+    def number_of_processes_to_start
+      number_of_processes = @helper.number_of_connected_devices
       raise "\n**** NO DEVICE FOUND ****\n" if number_of_processes==0
-      puts "*******************************"
-      puts " #{number_of_processes} DEVICES FOUND"
-      puts "*******************************"
+      puts '*******************************'
+      puts " #{number_of_processes} DEVICES FOUND:"
+      puts @helper.connected_devices_with_model_info
+      puts '*******************************'
       number_of_processes
     end
 
-    def run_tests_in_parallel(options)
-      number_of_processes = number_of_processes_to_start(options)
-
+    def run_tests_in_parallel
+      @runner.prepare_for_parallel_execution
+      number_of_processes = number_of_processes_to_start
       test_results = nil
       report_time_taken do
-        groups = FeatureGrouper.feature_groups(options, number_of_processes)
+        groups = FeatureGrouper.feature_groups(@options, number_of_processes)
         threads = groups.size
-
-        test_results = Parallel.map_with_index(groups, :in_threads => threads) do |group, index|
-          Runner.run_tests(group, index, options)
+        puts "Running with #{threads} threads: #{groups}"
+        complete = []
+        test_results = Parallel.map_with_index(
+            groups,
+            :in_threads => threads,
+            :finish => lambda { |_, i, _|  complete.push(i); print complete, "\n" }) do |group, index|
+          @runner.run_tests(group, index, @options)
         end
+        puts 'All threads complete'
         ResultFormatter.report_results(test_results)
       end
-
+      @runner.prepare_for_parallel_execution
+      puts 'Parallel run complete'
       Kernel.exit(1) if any_test_failed?(test_results)
     end
 
@@ -49,6 +78,5 @@ module ParallelCalabash
       mm, ss = time_in_sec.divmod(60)
       puts "\nTook #{mm} Minutes, #{ss.round(2)} Seconds"
     end
-
   end
 end

data/lib/parallel_calabash/adb_helper.rb

@@ -1,43 +1,123 @@
+require 'fileutils'
+
 module ParallelCalabash
-  module AdbHelper
-    class << self
+  module DevicesHelper
+    def device_for_process process_num
+      connected_devices_with_model_info[process_num]
+    end
 
-      def device_for_process process_num, filter=[]
-        connected_devices_with_model_info(filter)[process_num]
-      end
+    def number_of_connected_devices
+      connected_devices_with_model_info.size
+    end
+  end
 
-      def number_of_connected_devices filter=[]
-        connected_devices_with_model_info(filter).size
-      end
+  class AdbHelper
+    include ParallelCalabash::DevicesHelper
+
+    def initialize(filter = [])
+      @filter = filter
+    end
 
-      def connected_devices_with_model_info filter
-        begin
-          list =
+    def connected_devices_with_model_info
+      begin
+        list =
             `adb devices -l`.split("\n").collect do |line|
               device = device_id_and_model(line)
-              filter_device(device, filter)
+              filter_device(device)
             end
-          list.compact
-        rescue
-          []
-        end
+        list.compact
+      rescue
+        []
       end
+    end
 
-      def device_id_and_model line
-        if line.match(/device(?!s)/)
-          [line.split(" ").first,line.scan(/model:(.*) device/).flatten.first]
-        end
+    def device_id_and_model line
+      if line.match(/device(?!s)/)
+        [line.split(" ").first, line.scan(/model:(.*) device/).flatten.first]
+      end
+    end
+
+    def filter_device device
+      if @filter && !@filter.empty? && device
+        device unless @filter.collect { |f| device[0].match(f) || device[1].match(f) }.compact.empty?
+      else
+        device
       end
+    end
+  end
+
+  class IosHelper
+    include ParallelCalabash::DevicesHelper
 
-      def filter_device device, filter
-        if filter && !filter.empty? && device
-          device unless filter.collect{|f| device[0].match(f) || device[1].match(f) }.compact.empty?
+    def initialize(filter = nil, default_simulator = nil, config_file = nil, instruments = nil)
+      @filter = filter || []
+      @default_simulator = default_simulator || {}
+      config_file = config_file || "#{ENV['HOME']}/.parallel_calabash"
+      if config_file.is_a? Hash
+          @config = config_file
         else
-          device
+          @config = File.exist?(config_file) ? eval(File.read(config_file)) : {}
+      end
+      @instruments = instruments || %x(instruments -s devices ; echo) # Bizarre workaround for xcode 7
+    end
+
+    def xcode7?
+      !@instruments.match(' Simulator\)')
+    end
+
+    def connected_devices_with_model_info
+      return @devices if @devices
+      if @config[:DEVICES]
+        configs = apply_filter(compute_devices)
+        fail '** No devices (or users) unfiltered!' if configs.empty?
+      else
+        configs = apply_filter(compute_simulators)
+        configs = configs.empty? ? [@default_simulator] : configs
+      end
+      @devices = configs
+    end
+
+    def compute_simulators
+      port = (@config[:CALABASH_SERVER_PORT] || 28000).to_i
+      users = @config[:USERS] || []
+      init = @config[:INIT] || ''
+      users.map.with_index do |u, i|
+        {USER: u, CALABASH_SERVER_PORT: port + i, INIT: init}
+      end
+    end
+
+    def compute_devices
+      users = @config[:USERS] || []
+      init = @config[:INIT] || ''
+      devices = remove_unconnected_devices(@config[:DEVICES])
+      fail 'Devices configured, but no devices attached!' if devices.empty?
+      configs = devices.map.with_index do |d, i|
+        if users[i]
+          d[:USER] = users[i]
+          d[:INIT] = init
+          d
+        else
+          print "** No user for device #{d}"
+          nil
         end
       end
+      configs.compact
+    end
 
+    def apply_filter(configs)
+      return configs if @filter.empty?
+      filter_join = @filter.join('|')
+      configs.select do |c|
+        [c.keys, c.values].flatten.find { |k| k.to_s.match(filter_join) }
+      end
     end
 
+    def remove_unconnected_devices(configs)
+      udids = @instruments.each_line.map { |n| n.match(/\[(.*)\]/) && $1 }.flatten.compact
+      configs.find_all do |c|
+        var = c[:DEVICE_TARGET]
+        !udids.grep(var).empty?
+      end
+    end
   end
 end

data/lib/parallel_calabash/feature_grouper.rb

@@ -11,6 +11,22 @@ module ParallelCalabash
         feature_groups_by_feature_files(options[:feature_folder], group_size)
       end
 
+      def feature_groups_by_scenarios(features_scenarios,group_size)
+        puts "Scenarios: #{features_scenarios.size}"
+        min_number_scenarios_per_group = features_scenarios.size/group_size
+        remaining_number_of_scenarios = features_scenarios.size % group_size
+        groups = Array.new(group_size) { [] }
+        groups.each do |group|
+          min_number_scenarios_per_group.times { group << features_scenarios.delete_at(0) }
+        end
+        unless remaining_number_of_scenarios==0
+          groups[0..(remaining_number_of_scenarios-1)].each do |group|
+            group << features_scenarios.delete_at(0)
+          end
+        end
+        groups.reject(&:empty?)
+      end
+
       def concurrent_feature_groups(feature_folder, number_of_groups)
         groups = []
         (0...number_of_groups).each{ groups << feature_files_in_folder(feature_folder) }
@@ -42,15 +58,20 @@ module ParallelCalabash
         generate_dry_run_report options
         raise "Can not create dry run for scenario distribution" unless File.exists?("parallel_calabash_dry_run.json")
         distribution_data = JSON.parse(File.read("parallel_calabash_dry_run.json"))
+        # puts "SCENARIO GROUPS #{distribution_data}"
         all_runnable_scenarios = distribution_data.map do |feature|
           unless feature["elements"].nil?
             feature["elements"].map do |scenario|
               if scenario["keyword"] == 'Scenario'
                 "#{feature["uri"]}:#{scenario["line"]}"
               elsif scenario['keyword'] == 'Scenario Outline'
-                scenario["examples"].map { |example|
-                  "#{feature["uri"]}:#{example["line"]}"
-                }
+                if scenario["examples"]
+                  scenario["examples"].map { |example|
+                    "#{feature["uri"]}:#{example["line"]}"
+                  }
+                else
+                  "#{feature["uri"]}:#{scenario["line"]}" # Cope with --expand
+                end
               end
             end
           end
@@ -59,7 +80,7 @@ module ParallelCalabash
       end
 
       def generate_dry_run_report options
-        `cucumber #{options[:cucumber_options]}  -f usage --dry-run -f json --out parallel_calabash_dry_run.json #{options[:feature_folder].join(' ')}`
+        %x( cucumber #{options[:cucumber_options]} --dry-run -f json --out parallel_calabash_dry_run.json #{options[:feature_folder].join(' ')} )
       end
 
       def feature_files_in_folder(feature_dir)

data/lib/parallel_calabash/result_formatter.rb

@@ -5,7 +5,7 @@ module ParallelCalabash
 
       def report_results(test_results)
         results = find_results(test_results.map { |result| result[:stdout] }.join(''))
-        puts ""
+        puts ''
         puts summarize_results(results)
       end
 

data/lib/parallel_calabash/runner.rb

@@ -1,52 +1,224 @@
+require 'fileutils'
+require 'find'
+
 module ParallelCalabash
-  class Runner
-    class << self
-      def base_command
-        'calabash-android run'
+  module Runner
+    def execute_command_for_process(process_number, cmd)
+      output = open("|#{cmd}", 'r') { |output| show_output(output, process_number) }
+      exitstatus = $?.exitstatus
+
+      if @silence
+        $stdout.print output
+        $stdout.flush
+      end
+      puts "\n****** PROCESS #{process_number} COMPLETED ******\n\n"
+      {:stdout => output, :exit_status => exitstatus}
+    end
+
+    def show_output(output, process_number)
+      result = ''
+      loop do
+        begin
+          unless @silence
+            read = output.readline()
+            $stdout.print "#{process_number}> #{read}"
+            $stdout.flush
+          else
+            read = output.readpartial(1000000) # read whatever chunk we can get
+          end
+          result << read
+        end
+      end rescue EOFError
+      result
+    end
+  end
+
+  class AndroidRunner
+    include Runner
+
+    def initialize(device_helper, silence)
+      @device_helper = device_helper
+      @silence = silence
+    end
+
+    def prepare_for_parallel_execution
+      # Android is fairly sane....
+    end
+
+    def base_command
+      'calabash-android run'
+    end
+
+    def run_tests(test_files, process_number, options)
+      cmd = command_for_test(
+          process_number, base_command, options[:apk_path],
+          "#{options[:cucumber_options]} #{options[:cucumber_reports]}", test_files)
+      $stdout.print "#{process_number}>> Command: #{cmd}\n"
+      $stdout.flush
+      execute_command_for_process(process_number, cmd)
+    end
+
+    def command_for_test(process_number, base_command, apk_path, cucumber_options, test_files)
+      cmd = [base_command, apk_path, cucumber_options, *test_files].compact*' '
+      device_id, device_info = @device_helper.device_for_process process_number
+      env = {
+          AUTOTEST: '1',
+          ADB_DEVICE_ARG: device_id,
+          DEVICE_INFO: device_info,
+          TEST_PROCESS_NUMBER: (process_number+1).to_s,
+          SCREENSHOT_PATH: device_id.to_s + '_'
+      }
+      separator = (WINDOWS ? ' & ' : ';')
+      exports = env.map { |k, v| WINDOWS ? "(SET \"#{k}=#{v}\")" : "#{k}=#{v};export #{k}" }.join(separator)
+      exports + separator + cmd
+    end
+  end
+
+  class IosRunner
+    include Runner
+
+    def initialize(device_helper, silence, skip_ios_ping_check)
+      @device_helper = device_helper
+      @silence = silence
+      @skip_ios_ping_check = skip_ios_ping_check
+    end
+
+    def base_command
+      'bundle exec cucumber'
+    end
+
+    def run_tests(test_files, process_number, options)
+      test = command_for_test(
+          process_number, test_files,
+          options[:app_path], "#{options[:cucumber_options]} #{options[:cucumber_reports]}",
+          options[:simulator] || '0-0')
+      $stdout.print "#{process_number}>> Command: #{test}\n"
+      $stdout.flush
+
+      o = execute_command_for_process(process_number, test)
+      device = @device_helper.device_for_process process_number
+      log = "/tmp/PCal-#{device[:USER]}.process_number"
+      puts "Writing log #{log}"
+      open(log, 'w') { |file| file.print o[:stdout] }
+      o
+    end
+
+    def command_for_test(process_number, test_files, app_path, cucumber_options, simulator)
+      device = @device_helper.device_for_process process_number
+      separator = (WINDOWS ? ' & ' : ';')
+      remote = device[:USER] ? "ssh #{device[:USER]}@localhost" : 'bash -c'
+
+      if device[:CALABASH_SERVER_PORT]
+        user_app = copy_app_set_port(app_path, device)
+      else
+        user_app = app_path
       end
 
-      def run_tests(test_files, process_number, options)
-        cmd = [base_command, options[:apk_path], options[:cucumber_options], *test_files].compact*' '
-        execute_command_for_process(process_number, cmd, options[:mute_output], options[:filter])
+      device_name = device[:DEVICE_NAME] || "PCal-#{device[:USER]}"
+      device_simulator = device[:SIMULATOR] || simulator
+
+      # Device target changed in XCode 7, losing ' Simulator' for some reason.
+      maybe_simulator = @device_helper.xcode7? ? '' : ' Simulator'
+      device_target = device[:DEVICE_TARGET] || "#{device_name} (#{version(device_simulator)}#{maybe_simulator})"
+      device_info = device[:DEVICE_TARGET] || (device[:USER] ? create_simulator(device_name, remote, simulator) : '')
+      device_endpoint = device[:DEVICE_ENDPOINT] || "http://localhost:#{device[:CALABASH_SERVER_PORT]}"
+      $stdout.print "#{process_number}>> Device: #{device_info} = #{device_name} = #{device_target}\n"
+      $stdout.flush
+
+      unless @skip_ios_ping_check
+        hostname = device_endpoint.match("http://(.*):").captures.first
+        pingable = system "ping -c 1 -o #{hostname}"
+        fail "Cannot ping device_endpoint host: #{hostname}" unless pingable
+      end
+
+      cmd = [base_command, "APP_BUNDLE_PATH=#{user_app}", cucumber_options, *test_files].compact*' '
+
+      env = {
+          AUTOTEST: '1',
+          DEVICE_ENDPOINT: device_endpoint,
+          DEVICE_TARGET: device_target,
+          DEVICE_INFO: device_info,
+          TEST_USER: device[:USER] || %x( whoami ).strip,
+          # 'DEBUG_UNIX_CALLS' => '1',
+          TEST_PROCESS_NUMBER: (process_number+1).to_s,
+          SCREENSHOT_PATH: "PCal_#{process_number+1}_"
+      }
+      env['BUNDLE_ID'] = ENV['BUNDLE_ID'] if ENV['BUNDLE_ID']
+      exports = env.map { |k, v| WINDOWS ? "(SET \"#{k}=#{v}\")" : "#{k}='#{v}';export #{k}" }.join(separator)
+
+      cmd = [ exports,  "#{device[:INIT] || ' : '}", "cd #{File.absolute_path('.')}", "umask 002", cmd].join(separator)
+
+      if device[:USER]
+        "#{remote} bash -lc \"#{cmd}\" 2>&1"
+      else
+        "bash -c \"#{cmd}\" 2>&1"
       end
+    end
+
+    # def udid(name)
+    #   name = name.gsub(/(\W)/, '\\\\\\1')
+    #   line = %x( instruments -s devices ).split("\n").grep(/#{name}/)
+    #   fail "Found #{line.size} matches for #{name}, expected 1" unless line.size == 1
+    #   line.first.match(/\[(\S+)\]/).captures.first.to_s
+    # end
 
-      def execute_command_for_process(process_number, cmd, silence, filter)
-        command_for_current_process = command_for_process(process_number, cmd, filter)
-        output = open("|#{command_for_current_process}", "r") { |output| show_output(output, silence) }
-        exitstatus = $?.exitstatus
+    def version(simulator)
+      simulator.match('\d+-\d+$').to_s.gsub('-', '.')
+    end
 
-        if silence
-          $stdout.print output
-          $stdout.flush
+    def prepare_for_parallel_execution
+      # copy-chown all the files, and set everything group-writable.
+      Find.find('.') do |path|
+        if File.file?(path) && !File.stat(path).owned?
+          temp = "#{path}......"
+          FileUtils.copy(path, temp)
+          FileUtils.move(temp, path)
+          puts "Chowned/copied.... #{path}"
         end
-        puts "\n****** PROCESS #{process_number} COMPLETED ******\n\n"
-        {:stdout => output, :exit_status => exitstatus}
       end
+      FileUtils.chmod_R('g+w', 'build/reports')
+      FileUtils.chmod('g+w', Dir['*'])
+      FileUtils.chmod('g+w', '.')
+    end
+
+    def create_simulator(device_name, ssh, simulator)
+      stop_and_remove(device_name, ssh)
+      puts "Double check..."
+      stop_and_remove(device_name, ssh)
+      puts "OK if none"
+
+      device_info = %x( #{ssh} "xcrun simctl create #{device_name} #{simulator}" ).strip
+      fail "Failed to create #{device_name} for #{ssh}" unless device_info
+      device_info
+    end
 
-      def command_for_process(process_number, cmd, filter)
-        env = {}
-        device_id, device_info = ParallelCalabash::AdbHelper.device_for_process process_number, filter
-        env = env.merge({'AUTOTEST' => '1', 'ADB_DEVICE_ARG' => device_id, 'DEVICE_INFO' => device_info, "TEST_PROCESS_NUMBER" => (process_number+1).to_s})
-        separator = (WINDOWS ? ' & ' : ';')
-        exports = env.map { |k, v| WINDOWS ? "(SET \"#{k}=#{v}\")" : "#{k}=#{v};export #{k}" }.join(separator)
-        exports + separator + cmd
+    def stop_and_remove(device_name, ssh)
+      devices = %x( #{ssh} "xcrun simctl list devices" | grep #{device_name} )
+      puts "Devices: #{devices}"
+      devices.each_line do |device|
+        _name, id, state = device.match(/^\s*([^(]*?)\s*\((\S+)\)\s+\((\S+)\)/).captures
+        puts 'Shutdown: ' + %x( #{ssh} "xcrun simctl shutdown #{id}" ) if state =~ /booted/
+        puts 'Delete: ' + %x( #{ssh} "xcrun simctl delete #{id}" )
       end
+    end
 
-      def show_output(output, silence)
-        result = ""
-        loop do
-          begin
-            read = output.readpartial(1000000) # read whatever chunk we can get
-            result << read
-            unless silence
-              $stdout.print read
-              $stdout.flush
-            end
-          end
-        end rescue EOFError
-        result
+    def copy_app_set_port(app_path, device)
+      user_path = File.dirname(app_path) + '/' + device[:USER]
+      FileUtils.rmtree(user_path)
+      FileUtils.mkdir_p(user_path)
+      user_app = user_path + '/' + File.basename(app_path)
+      FileUtils.copy_entry(app_path, user_app)
+
+      # Set plist.
+
+      system("/usr/libexec/PlistBuddy -c 'Delete CalabashServerPort integer #{device[:CALABASH_SERVER_PORT]}' #{user_app}/Info.plist")
+      unless system("/usr/libexec/PlistBuddy -c 'Add CalabashServerPort integer #{device[:CALABASH_SERVER_PORT]}' #{user_app}/Info.plist")
+        raise "Unable to set CalabashServerPort in #{user_app}/Info.plist"
       end
 
+      puts "User app: #{user_app}"
+
+      user_app
     end
   end
-end
+end

data/lib/parallel_calabash/version.rb

@@ -1,3 +1,3 @@
 module ParallelCalabash
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/misc/autostart_test_users.app/Contents/Info.plist

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleAllowMixedLocalizations</key>
+	<true/>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>applet</string>
+	<key>CFBundleIconFile</key>
+	<string>applet</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.apple.ScriptEditor.id.autostart-test-users</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>autostart_test_users</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>aplt</string>
+	<key>LSMinimumSystemVersionByArchitecture</key>
+	<dict>
+		<key>x86_64</key>
+		<string>10.6</string>
+	</dict>
+	<key>LSRequiresCarbon</key>
+	<true/>
+	<key>WindowState</key>
+	<dict>
+		<key>bundleDividerCollapsed</key>
+		<true/>
+		<key>bundlePositionOfDivider</key>
+		<real>0.0</real>
+		<key>dividerCollapsed</key>
+		<false/>
+		<key>eventLogLevel</key>
+		<integer>-1</integer>
+		<key>name</key>
+		<string>ScriptWindowState</string>
+		<key>positionOfDivider</key>
+		<real>662</real>
+		<key>savedFrame</key>
+		<string>191 73 1004 804 0 0 1440 877 </string>
+		<key>selectedTab</key>
+		<string>log</string>
+	</dict>
+</dict>
+</plist>

data/misc/autostart_test_users.app/Contents/PkgInfo

@@ -0,0 +1 @@
+APPLaplt

data/misc/autostart_test_users.app/Contents/Resources/description.rtfd/TXT.rtf

@@ -0,0 +1,4 @@
+{\rtf1\ansi\ansicpg1252\cocoartf1347\cocoasubrtf570
+{\fonttbl}
+{\colortbl;\red255\green255\blue255;}
+}

data/misc/example_ios_config

@@ -0,0 +1,24 @@
+{
+  USERS: [ 'tester1', 'tester2', 'tester3' ],
+  INIT: '[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"',
+  # You only need to specify the port if the default clashes for you. Simulators start sequentially from this.
+  # CALABASH_SERVER_PORT: 3800,
+  # Omit 'DEVICES' entirely if you're only testing on simulators.
+  DEVICES: [
+    {
+      NAME: 'ios-iphone5c-tinkywinkie (8.4.1)',
+      DEVICE_TARGET: '23984729837401987239874987239',
+      DEVICE_ENDPOINT: 'http://192.168.126.206:37265'
+    },
+    {
+      NAME: 'ios-iphone6plus-lala (8.4)',
+      DEVICE_TARGET: 'c987234987983458729375923485792345',
+      DEVICE_ENDPOINT: 'http://192.168.126.205:37265',
+    },
+    {
+      NAME: 'ios-iphone6plus-dipsy (8.4.1)',
+      DEVICE_TARGET: '98723498792873459872398475982347589',
+      DEVICE_ENDPOINT: 'http://192.168.126.207:37265',
+    }
+  ]
+}

data/misc/sim_control.rb

@@ -0,0 +1,70 @@
+require 'run_loop/sim_control'
+
+# This patch is needed to work around 'simctl erase' not working on a booted device:
+#  Because of RunLoop's assumptions and Mac inadequacies relating to multiple
+#  users, this 'shutdown' helped our 'Before scenario' hooks.
+#
+# You'll want to copy this to your Cucumber project. Probably.
+#
+# Copyright whoever owns RunLoop, except for the hashed block which is presumably Badoo's but
+# we'll let you have it because we're nice.
+
+puts "Monkeypatch: #{__FILE__}"
+RunLoop::SimControl.class_eval do
+  # @!visibility private
+  # Uses the `simctl erase` command to reset a simulator content and settings.
+  # If no `sim_udid` is nil, _all_ simulators are reset.
+  #
+  # # @note This is an Xcode 6 only method. It will raise an error if called on
+  #  Xcode < 6.
+  #
+  # @note This method will quit the simulator.
+  #
+  # @param [String] sim_udid The udid of the simulator that will be reset.
+  #   If sim_udid is nil, _all_ simulators will be reset.
+  # @raise [RuntimeError] If called on Xcode < 6.
+  # @raise [RuntimeError] If `sim_udid` is not a valid simulator udid.  Valid
+  #  simulator udids are determined by calling `simctl list`.
+  def simctl_reset(sim_udid = nil)
+    unless xcode_version_gte_6?
+      fail 'this method is only available on Xcode >= 6'
+    end
+
+    quit_sim
+
+    sim_details = sim_details(:udid)
+    simctl_erase = lambda { |udid|
+      # ################################################
+      puts '** MONKEYPATCH Speculative shutdown - may fail harmlessly'
+      shutdown_output = %x( xcrun simctl shutdown #{udid} )
+      puts "** MONKEYPATCH Injected simctl_shutdown: #{shutdown_output} [#{__FILE__}]"
+      # ################################################
+      args = "simctl erase #{udid}".split(' ')
+      Open3.popen3('xcrun', *args) do |_, stdout, stderr, wait_thr|
+        out = stdout.read.strip
+        err = stderr.read.strip
+        if ENV['DEBUG_UNIX_CALLS'] == '1'
+          cmd = "xcrun simctl erase #{udid}"
+          puts __FILE__ + " sim_erase cmd #{cmd}"
+          puts "#{cmd} => stdout: '#{out}' | stderr: '#{err}'"
+        end
+        wait_thr.value.success?
+      end
+    }
+
+    # Call erase on all simulators
+    if sim_udid.nil?
+      res = []
+      sim_details.each_key do |key|
+        res << simctl_erase.call(key)
+      end
+      res.all?
+    else
+      if sim_details[sim_udid]
+        simctl_erase.call(sim_udid)
+      else
+        fail "Could not find simulator with udid '#{sim_udid}'"
+      end
+    end
+  end
+end

data/spec/lib/parallel_calabash/adb_helper_spec.rb

@@ -1,53 +1,132 @@
 require 'spec_helper'
-
+require 'minitest/mock'
 require 'parallel_calabash/adb_helper'
 describe ParallelCalabash::AdbHelper do
 
   describe :device_id_and_model do
     it 'should not match any devices in list of devices attached line' do
-      expect(ParallelCalabash::AdbHelper.device_id_and_model("List of devices attached")).to eq nil
+      expect(ParallelCalabash::AdbHelper.new([]).device_id_and_model("List of devices attached")).to eq nil
     end
 
     it 'should match devices if there is a space after the word device' do
-      expect(ParallelCalabash::AdbHelper.device_id_and_model("emulator-5554  device ")).to eq \
+      expect(ParallelCalabash::AdbHelper.new([]).device_id_and_model("emulator-5554  device ")).to eq \
          ["emulator-5554", nil]
     end
 
     it 'should match devices if there is not a space after the word device' do
-      expect(ParallelCalabash::AdbHelper.device_id_and_model("emulator-5554  device")).to eq \
+      expect(ParallelCalabash::AdbHelper.new([]).device_id_and_model("emulator-5554  device")).to eq \
          ["emulator-5554", nil]
     end
 
     it 'should not match a device if it is an empty line' do
-      expect(ParallelCalabash::AdbHelper.device_id_and_model("")).to eq nil
+      expect(ParallelCalabash::AdbHelper.new([]).device_id_and_model("")).to eq nil
     end
 
     it 'should match physical devices' do
       output = "192.168.56.101:5555 device product:vbox86p model:device1 device:vbox86p"
-      expect(ParallelCalabash::AdbHelper.device_id_and_model(output)).to eq ["192.168.56.101:5555", "device1"]
+      expect(ParallelCalabash::AdbHelper.new([]).device_id_and_model(output)).to eq ["192.168.56.101:5555", "device1"]
     end
   end
 
   describe :filter_device do
     it 'should return devices if no filter is specified' do
       device = ["192.168.56.101:5555", "device1"]
-      expect(ParallelCalabash::AdbHelper.filter_device(device, [])).to eq device
+      expect(ParallelCalabash::AdbHelper.new([]).filter_device(device)).to eq device
     end
 
     it 'should match devices that match the filter' do
       device = ["192.168.56.101:5555", "device1"]
-      expect(ParallelCalabash::AdbHelper.filter_device(device, ["device1"])).to eq device
+      expect(ParallelCalabash::AdbHelper.new(["device1"]).filter_device(device)).to eq device
     end
 
     it 'should not return devices that do not match the filter' do
       device = ["192.168.56.101:5555", "device1"]
-      expect(ParallelCalabash::AdbHelper.filter_device(device, ["notmatching"])).to eq nil
+      expect(ParallelCalabash::AdbHelper.new(["notmatching"]).filter_device(device)).to eq nil
     end
 
     it 'can also match on ip address' do
       device = ["192.168.56.101:5555", "device1"]
-      expect(ParallelCalabash::AdbHelper.filter_device(device, ["192.168.56.101"])).to eq device
+      expect(ParallelCalabash::AdbHelper.new(["192.168.56.101"]).filter_device(device)).to eq device
     end
   end
 
 end
+
+describe ParallelCalabash::IosHelper do
+  describe :test_apply_filter do
+    it 'Does nothing with no filters' do
+      expect(ParallelCalabash::IosHelper.new([], nil, {}, '')
+                 .apply_filter([{any: 'thing'}, {what: 'soever'}]))
+          .to eq [{any: 'thing'}, {what: 'soever'}]
+    end
+
+    it 'Excludes anything not mentioned' do
+      expect(ParallelCalabash::IosHelper.new(['yes'], nil, {}, '')
+                 .apply_filter([{any: 'thing'}, {what: 'soever'}]))
+          .to eq []
+    end
+
+    it 'Excludes only things not mentioned' do
+      expect(ParallelCalabash::IosHelper.new(['aa', 'bb'], nil, {}, '')
+                 .apply_filter([{eaa: 'thing', ecc: 'thing'}, {what: 'aa', so: 'ebb'}, {ever: 'thing'}]))
+          .to eq [{eaa: 'thing', ecc: 'thing'}, {what: 'aa', so: 'ebb'}]
+    end
+  end
+
+  describe :test_remove_unconnected_devices do
+    it 'Removes unconnected devices' do
+      expect(ParallelCalabash::IosHelper.new(nil, nil, {},
+                                             "name [udid1]\nname2 [udid2]\nname3 [udid-unknown]")
+                 .remove_unconnected_devices([{DEVICE_TARGET: 'udid1'},
+                                              {DEVICE_TARGET: 'udid2'},
+                                              {DEVICE_TARGET: 'udid-unplugged'}]))
+          .to eq [{DEVICE_TARGET: "udid1"}, {DEVICE_TARGET: "udid2"}]
+    end
+  end
+
+  describe :test_compute_simulators do
+    it 'allocates ports to users' do
+      expect(ParallelCalabash::IosHelper.new([], {}, {USERS:['a', 'b'], INIT:'foo'}, '')
+                 .compute_simulators)
+          .to eq [{USER:'a', INIT:'foo', CALABASH_SERVER_PORT: 28000},
+                  {USER:'b', INIT:'foo', CALABASH_SERVER_PORT: 28001}]
+    end
+
+    it 'allocates other ports to users' do
+      expect(ParallelCalabash::IosHelper.new([], {}, {USERS:['a', 'b'], INIT:'foo', CALABASH_SERVER_PORT:100}, '')
+                 .compute_simulators)
+          .to eq [{USER:'a', INIT:'foo', CALABASH_SERVER_PORT: 100},
+                  {USER:'b', INIT:'foo', CALABASH_SERVER_PORT: 101}]
+    end
+  end
+
+  describe :test_compute_devices do
+    it 'returns nothing with no users' do
+      expect(ParallelCalabash::IosHelper.new([], {}, {DEVICES: [{DEVICE_TARGET: 'udid'}]}, 'name [udid]')
+                 .compute_devices)
+          .to eq []
+    end
+
+    it 'fails with no devices' do
+      expect { ParallelCalabash::IosHelper.new([], {}, {DEVICES: [{DEVICE_TARGET: 'udid'}],
+                                                        USERS: ['a']}, 'name [udon\'t]')
+                   .compute_devices }
+          .to raise_error(RuntimeError)
+    end
+
+    it 'allocates users to devices' do
+      expect(ParallelCalabash::IosHelper.new([], {}, {DEVICES: [{DEVICE_TARGET: 'udid'}],
+                                                      USERS: ['a', 'b']}, 'name [udid]')
+                 .compute_devices)
+          .to eq [{DEVICE_TARGET: "udid", USER: "a", INIT: ""}]
+    end
+
+    it 'allocates users init to devices' do
+      expect(ParallelCalabash::IosHelper.new([], {}, {DEVICES: [{DEVICE_TARGET: 'udid'}],
+                                                      USERS: ['a', 'b'],
+                                                      INIT: 'start'}, 'name [udid]')
+                 .compute_devices)
+          .to eq [{DEVICE_TARGET: "udid", USER: "a", INIT: "start"}]
+    end
+  end
+end

data/spec/lib/parallel_calabash/runner_spec.rb

@@ -1,25 +1,30 @@
 require 'spec_helper'
+require 'minitest/mock'
 require 'parallel_calabash'
 
 describe ParallelCalabash::Runner do
   describe :command_for_process do
     it 'should return command with env variables' do
-      ParallelCalabash::AdbHelper.should_receive(:device_for_process).with(0,nil).and_return(["4d00fa3cb814c03f", "GT_N7100"])
-      expect(ParallelCalabash::Runner.command_for_process(0, 'base_command', nil)).to eq \
-      "AUTOTEST=1;export AUTOTEST;ADB_DEVICE_ARG=4d00fa3cb814c03f;export ADB_DEVICE_ARG;DEVICE_INFO=GT_N7100;export DEVICE_INFO;TEST_PROCESS_NUMBER=1;export TEST_PROCESS_NUMBER;base_command"
+      adb_helper = MiniTest::Mock.new
+      adb_helper.expect(:device_for_process, ["4d00fa3cb814c03f", "GT_N7100"], [0])
+      expect(ParallelCalabash::AndroidRunner.new(adb_helper, true)
+                 .command_for_test(0, 'base_command', 'some.apk', '-some -options', %w(file1 file2)))
+          .to eq 'AUTOTEST=1;export AUTOTEST;ADB_DEVICE_ARG=4d00fa3cb814c03f;export ADB_DEVICE_ARG;'\
+                 'DEVICE_INFO=GT_N7100;export DEVICE_INFO;TEST_PROCESS_NUMBER=1;export TEST_PROCESS_NUMBER;'\
+                 'SCREENSHOT_PATH=4d00fa3cb814c03f_;export SCREENSHOT_PATH;'\
+                 'base_command some.apk -some -options file1 file2'
     end
   end
 
-
   describe :execute_command_for_process do
+    adb_helper = MiniTest::Mock.new
+    runner = ParallelCalabash::AndroidRunner.new(nil, true)
     it 'should execute the command with correct env variables set and return exit status 0 when command gets executed successfully' do
-      ParallelCalabash::AdbHelper.should_receive(:device_for_process).with(3,nil).and_return("DEVICE3")
-      expect(ParallelCalabash::Runner.execute_command_for_process(3,'echo $ADB_DEVICE_ARG;echo $TEST_PROCESS_NUMBER',true,nil)).to eq ({:stdout=>"DEVICE3\n4\n", :exit_status=>0})
+      expect(runner.execute_command_for_process(3, 'ADB_DEVICE_ARG=DEVICE3; export ADB_DEVICE_ARG; TEST_PROCESS_NUMBER=4; export TEST_PROCESS_NUMBER; echo $ADB_DEVICE_ARG;echo $TEST_PROCESS_NUMBER')).to eq ({:stdout=>"DEVICE3\n4\n", :exit_status=>0})
     end
 
     it 'should return exit status of 1' do
-      expect(ParallelCalabash::Runner.execute_command_for_process(3,"ruby -e 'exit(1)'",true,nil)).to eq ({:stdout=>"", :exit_status=>1})
+      expect(runner.execute_command_for_process(3,"ruby -e 'exit(1)'")).to eq ({:stdout=>'', :exit_status=>1})
     end
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_calabash
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Rajdeep
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-24 00:00:00.000000000 Z
+date: 2015-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -74,6 +74,15 @@ files:
 - lib/parallel_calabash/result_formatter.rb
 - lib/parallel_calabash/runner.rb
 - lib/parallel_calabash/version.rb
+- misc/autostart_test_users.app/Contents/Info.plist
+- misc/autostart_test_users.app/Contents/MacOS/applet
+- misc/autostart_test_users.app/Contents/PkgInfo
+- misc/autostart_test_users.app/Contents/Resources/Scripts/main.scpt
+- misc/autostart_test_users.app/Contents/Resources/applet.icns
+- misc/autostart_test_users.app/Contents/Resources/applet.rsrc
+- misc/autostart_test_users.app/Contents/Resources/description.rtfd/TXT.rtf
+- misc/example_ios_config
+- misc/sim_control.rb
 - parallel_calabash.gemspec
 - sample_output_with_4_processes.txt
 - spec/lib/parallel_calabash/adb_helper_spec.rb