testa_appium_driver 0.1.0

data/lib/testa_appium_driver/common/constants.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+#noinspection ALL
+module TestaAppiumDriver
+  FIND_STRATEGY_UIAUTOMATOR = :uiautomator
+  FIND_STRATEGY_XPATH = :xpath
+
+  SCROLL_STRATEGY_UIAUTOMATOR = :uiautomator
+  SCROLL_STRATEGY_W3C = :w3c
+
+
+  SCROLL_CORRECTION_W3C = 30
+  SCROLL_ALIGNMENT_THRESHOLD = 25
+
+  SCROLL_ACTION_TYPE_SCROLL = :scroll
+  SCROLL_ACTION_TYPE_FLING = :fling
+  SCROLL_ACTION_TYPE_DRAG = :drag
+
+
+  DEFAULT_UIAUTOMATOR_MAX_SWIPES = 20
+
+  DEFAULT_ANDROID_FIND_STRATEGY = FIND_STRATEGY_UIAUTOMATOR
+  DEFAULT_ANDROID_SCROLL_STRATEGY = SCROLL_STRATEGY_UIAUTOMATOR
+
+
+  DEFAULT_IOS_FIND_STRATEGY = FIND_STRATEGY_XPATH
+  DEFAULT_IOS_SCROLL_STRATEGY = SCROLL_STRATEGY_W3C
+
+  DEFAULT_W3C_MAX_SCROLLS = 7
+
+  EXISTS_WAIT = 0.5
+  LONG_TAP_DURATION = 1.5
+end

data/lib/testa_appium_driver/common/exceptions/strategy_mix_exception.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module TestaAppiumDriver
+  class StrategyMixException < Exception
+    def initialize(strategy, strategy_reason, mixed_strategy, mixed_reason)
+
+      # example: parent is only available in xpath strategy and cannot be used with from_element which is only available in uiautomator strategy
+      msg = "strategy mix exception: '#{strategy_reason}' is only available in #{strategy} strategy and cannot be used with '#{mixed_reason}' which is only available in #{mixed_strategy} strategy"
+      super(msg)
+    end
+  end
+end

data/lib/testa_appium_driver/common/helpers.rb

@@ -0,0 +1,242 @@
+module TestaAppiumDriver
+  module Helpers
+
+    # supported selectors
+    # id: "com.my.package:id/myId"
+    # id: "myId" => will be converted to "com.my.package:id/myId"
+    # id: /my/ will find all elements with ids that contain my
+    # desc: "element description"
+    # desc: /ription/ will find all elements that contains ription
+    # class: "android.widget.Button"
+    # class: /Button/ will find all elements with classes that contain Button
+    # text: "Hello world"
+    # text: /ello/ will find all elements with text that contain ello
+    # package: "com.my.package"
+    # package: /my/ will find all elements with package that contains my
+    # long_clickable: true or false
+    # checkable: true or false
+    # checked: true or false
+    # clickable: true or false
+    # enabled: true or false
+    # focusable: true or false
+    # focused: true or false
+    # index: child index inside of a parent element, index starts from 0
+    # selected: true or false
+    # scrollable: true or false
+    # @param [Hash] hash selectors for finding elements
+    # @param [Boolean] single should the command return first instance or all of matched elements
+    # @return [String] hash selectors converted to uiautomator command
+    def hash_to_uiautomator(hash, single = true)
+      command = "new UiSelector()"
+
+      if hash[:id] && hash[:id].kind_of?(String) && !hash[:id].match?(/.*:id\//)
+        # shorthand ids like myId make full ids => my.app.package:id/myId
+
+        if hash[:id][0] == "="
+          id = hash[:id][1..-1]
+        else
+          id = "#{@driver.current_package}:id/#{hash[:id]}"
+        end
+      else
+        id = hash[:id]
+      end
+      command = "#{ command }.resourceId(\"#{ %(#{ id }) }\")" if id && id.kind_of?(String)
+      command = "#{ command }.resourceIdMatches(\"#{ %(#{ id.source }) }\")" if id && id.kind_of?(Regexp)
+      command = "#{ command }.description(\"#{ %(#{ hash[:desc] }) }\")" if hash[:desc] && hash[:desc].kind_of?(String)
+      command = "#{ command }.descriptionMatches(\"#{ %(#{ hash[:desc].source }) }\")" if hash[:desc] && hash[:desc].kind_of?(Regexp)
+      command = "#{ command }.className(\"#{ %(#{ hash[:class] }) }\")" if hash[:class] && hash[:class].kind_of?(String)
+      command = "#{ command }.classNameMatches(\"#{ %(#{ hash[:class].source }) }\")" if hash[:class] && hash[:class].kind_of?(Regexp)
+      command = "#{ command }.text(\"#{ %(#{ hash[:text] }) }\")" if hash[:text] && hash[:text].kind_of?(String)
+      command = "#{ command }.textMatches(\"#{ %(#{ hash[:text].source }) }\")" if hash[:text] && hash[:text].kind_of?(Regexp)
+      command = "#{ command }.packageName(\"#{ %(#{ hash[:package] }) }\")" if hash[:package] && hash[:package].kind_of?(String)
+      command = "#{ command }.packageNameMatches(\"#{ %(#{ hash[:package].source }) }\")" if hash[:package] && hash[:package].kind_of?(Regexp)
+
+      command = "#{ command }.longClickable(#{ hash[:long_clickable] })" if hash[:long_clickable]
+      command = "#{ command }.checkable(#{ hash[:checkable] })" unless hash[:checkable].nil?
+      command = "#{ command }.checked(#{ hash[:checked] })" unless hash[:checked].nil?
+      command = "#{ command }.clickable(#{ hash[:clickable] })" unless hash[:clickable].nil?
+      command = "#{ command }.enabled(#{ hash[:enabled] })" unless hash[:enabled].nil?
+      command = "#{ command }.focusable(#{ hash[:focusable] })" unless hash[:focusable].nil?
+      command = "#{ command }.focused(#{ hash[:focused] })" unless hash[:focused].nil?
+      command = "#{ command }.index(#{ hash[:index].to_s })" unless hash[:index].nil?
+      command = "#{ command }.selected(#{ hash[:selected] })" unless hash[:selected].nil?
+      command = "#{ command }.scrollable(#{ hash[:scrollable] })" unless hash[:scrollable].nil?
+
+      command += ".instance(0)" if single
+
+      command
+    end
+
+
+    # supported selectors
+    # id: "com.my.package:id/myId"
+    # id: "myId" => will be converted to "com.my.package:id/myId"
+    # id: /my/ will find all elements with ids that contain my
+    # desc: "element description"
+    # desc: /ription/ will find all elements that contains ription
+    # class: "android.widget.Button"
+    # class: /Button/ will find all elements with classes that contain Button
+    # text: "Hello world"
+    # text: /ello/ will find all elements with text that contain ello
+    # package: "com.my.package"
+    # package: /my/ will find all elements with package that contains my
+    # long_clickable: true or false
+    # checkable: true or false
+    # checked: true or false
+    # clickable: true or false
+    # enabled: true or false
+    # focusable: true or false
+    # focused: true or false
+    # index: child index inside of a parent element, index starts from 0
+    # selected: true or false
+    # scrollable: true or false
+    # @param [Hash] hash selectors for finding elements
+    # @param [Boolean] single should the command return first instance or all of matched elements
+    # @return [String] hash selectors converted to xpath command
+    def hash_to_xpath(device, hash, single = true)
+      for_android = device == :android
+
+
+      command = "//"
+
+      if hash[:id] && hash[:id].kind_of?(String) && !hash[:id].match?(/.*:id\//)
+        # shorthand ids like myId make full ids => my.app.package:id/myId
+        if hash[:id][0] == "="
+          id = hash[:id][1..-1]
+        else
+          id = "#{@driver.current_package}:id/#{hash[:id]}"
+        end
+      else
+        id = hash[:id]
+      end
+
+      if for_android
+        if hash[:class] && hash[:class].kind_of?(String)
+          command = "#{ command }#{hash[:class] }"
+        elsif hash[:class] && hash[:class].kind_of?(Regexp)
+          command = "#{ command}*[contains(@class, \"#{ %(#{hash[:class].source }) }\")]"
+        else
+          command = "#{command}*"
+        end
+
+
+        command = "#{ command }[@resource-id=\"#{ %(#{ id }) }\"]" if  id &&  id.kind_of?(String)
+        command = "#{ command }[contains(@resource-id, \"#{ %(#{ id.source }) }\")]" if  id &&  id.kind_of?(Regexp)
+        command = "#{ command }[@content-desc=\"#{ %(#{hash[:desc] }) }\"]" if hash[:desc] && hash[:desc].kind_of?(String)
+        command = "#{ command }[contains(@content-desc, \"#{ %(#{hash[:desc].source }) }\")]" if hash[:desc] && hash[:desc].kind_of?(Regexp)
+        command = "#{ command }[contains(@class, \"#{ %(#{hash[:class].source }) }\")]" if hash[:class] && hash[:class].kind_of?(Regexp)
+        command = "#{ command }[@text=\"#{ %(#{hash[:text] }) }\"]" if hash[:text] && hash[:text].kind_of?(String)
+        command = "#{ command }[contains(@text, \"#{ %(#{hash[:text].source }) }\")]" if hash[:text] && hash[:text].kind_of?(Regexp)
+        command = "#{ command }[@package=\"#{ %(#{hash[:package] }) }\"]" if hash[:package] && hash[:package].kind_of?(String)
+        command = "#{ command }[contains=(@package, \"#{ %(#{hash[:package].source }) }\")]" if hash[:package] && hash[:package].kind_of?(Regexp)
+        command = "#{ command }[@long-clickable=\"#{ hash[:long_clickable] }\"]" if hash[:long_clickable]
+        command = "#{ command }[@checkable=\"#{ hash[:checkable] }\"]" unless hash[:checkable].nil?
+        command = "#{ command }[@checked=\"#{ hash[:checked] }\"]" unless hash[:checked].nil?
+        command = "#{ command }[@clickable=\"#{ hash[:clickable] }\"]" unless hash[:clickable].nil?
+        command = "#{ command }[@enabled=\"#{ hash[:enabled] }\"]" unless hash[:enabled].nil?
+        command = "#{ command }[@focusable=\"#{ hash[:focusable] }\"]" unless hash[:focusable].nil?
+        command = "#{ command }[@focused=\"#{ hash[:focused] }\"]" unless hash[:focused].nil?
+        command = "#{ command }[@index=\"#{ hash[:index] }\"]" unless hash[:index].nil?
+        command = "#{ command }[@selected=\"#{ hash[:selected] }\"]" unless hash[:selected].nil?
+        command = "#{ command }[@scrollable=\"#{ hash[:scrollable] }\"]" unless hash[:scrollable].nil?
+      else
+        if hash[:type] && hash[:type].kind_of?(String)
+          command = "#{ command }#{hash[:type] }"
+        elsif hash[:type] && hash[:type].kind_of?(Regexp)
+          command = "#{ command}*[contains(@type, \"#{ %(#{hash[:type].source }) }\")]"
+        else
+          command = "#{command}*"
+        end
+
+
+        #  # ios specific
+        hash[:label] = hash[:text] unless hash[:text].nil?
+        hash[:name] = hash[:id] unless hash[:id].nil?
+
+        command = "#{ command }[@enabled=\"#{ hash[:enabled] }\"]" unless hash[:enabled].nil?
+        command = "#{ command }[@label=\"#{ %(#{hash[:label] }) }\"]" if hash[:label] && hash[:label].kind_of?(String)
+        command = "#{ command }[contains(@label, \"#{ %(#{hash[:label].source }) }\")]" if hash[:label] && hash[:label].kind_of?(Regexp)
+        command = "#{ command }[@name=\"#{ %(#{hash[:name] }) }\"]" if hash[:name] && hash[:name].kind_of?(String)
+        command = "#{ command }[contains(@name, \"#{ %(#{hash[:name].source }) }\")]" if hash[:name] && hash[:name].kind_of?(Regexp)
+        command = "#{ command }[@value=\"#{ %(#{hash[:value] }) }\"]" if hash[:value] && hash[:value].kind_of?(String)
+        command = "#{ command }[contains(@value, \"#{ %(#{hash[:value].source }) }\")]" if hash[:value] && hash[:value].kind_of?(Regexp)
+        command = "#{ command }[@width=\"#{ hash[:width] }\"]" unless hash[:width].nil?
+        command = "#{ command }[@height=\"#{ hash[:height] }\"]" unless hash[:height].nil?
+        command = "#{ command }[@visible=\"#{ hash[:visible] }\"]" unless hash[:visible].nil?
+      end
+
+
+      command += "[1]" if single
+
+      command
+    end
+
+    # check if selectors are for a scrollable element
+    # @param [Boolean] single should the command return first instance or all of matched elements
+    # @param [Hash] selectors for fetching elements
+    # @return [Boolean] true if element has scrollable attribute true or is class one of (RecyclerView, HorizontalScrollView, ScrollView, ListView)
+    def is_scrollable_selector?(selectors, single)
+      return false unless single
+      return true if selectors[:scrollable]
+      if selectors[:class] == "androidx.recyclerview.widget.RecyclerView" ||
+          selectors[:class] == "android.widget.HorizontalScrollView" ||
+          selectors[:class] == "android.widget.ScrollView" ||
+          selectors[:class] == "android.widget.ListView"
+        return true
+      elsif selectors[:type] == "XCUIElementTypeScrollView"
+        return true
+      end
+      false
+    end
+
+    #noinspection RubyUnnecessaryReturnStatement,RubyUnusedLocalVariable
+    # separate selectors from given hash parameters
+    # @param [Hash] params
+    # @return [Array] first element is params, second are selectors
+    def extract_selectors_from_params(params = {})
+      selectors = params.select { |key, value| [
+          :id,
+          :longClickable,
+          :desc,
+          :class,
+          :text,
+          :package,
+          :checkable,
+          :checked,
+          :clickable,
+          :enabled,
+          :focusable,
+          :focused,
+          :index,
+          :selected,
+          :scrollable,
+
+          # ios specific
+          :type,
+          :label,
+          :x,
+          :y,
+          :width,
+          :height,
+          :visible,
+          :name,
+          :value
+      ].include?(key) }
+      params = Hash[params.to_a - selectors.to_a]
+
+      # default params
+      params[:single] = true if params[:single].nil?
+      params[:scrollable_locator] = nil if params[:scrollable_locator].nil?
+      if params[:default_find_strategy].nil?
+        params[:default_find_strategy] = DEFAULT_ANDROID_FIND_STRATEGY if @driver.device == :android
+        params[:default_find_strategy] = DEFAULT_IOS_FIND_STRATEGY if @driver.device == :ios || @driver.device == :tvos
+      end
+      if params[:default_scroll_strategy].nil?
+        params[:default_scroll_strategy] = DEFAULT_ANDROID_SCROLL_STRATEGY if @driver.device == :android
+        params[:default_scroll_strategy] = DEFAULT_IOS_SCROLL_STRATEGY if @driver.device == :ios || @driver.device == :tvos
+      end
+
+      return params, selectors
+    end
+  end
+end

data/lib/testa_appium_driver/common/locator.rb

@@ -0,0 +1,371 @@
+require_relative 'locator/scroll_actions'
+
+
+module TestaAppiumDriver
+  #noinspection RubyTooManyInstanceVariablesInspection,RubyTooManyMethodsInspection
+  class Locator
+    include Helpers
+
+    attr_accessor :xpath_selector
+    attr_accessor :single
+
+    attr_accessor :driver
+    attr_accessor :strategy
+    attr_accessor :strategy_reason
+    attr_accessor :last_selector_adjacent
+
+    attr_accessor :from_element
+    attr_accessor :scroll_orientation
+    attr_accessor :scroll_deadzone
+    attr_accessor :scrollable_locator
+
+    attr_accessor :default_find_strategy
+    attr_accessor :default_scroll_strategy
+
+
+    # locator parameters are:
+    #   single: true or false
+    #   scrollable_locator: [TestaAppiumDriver::Locator, nil] for scrolling if needed later
+    #   default_find_strategy: default strategy if find element strategy is not enforced
+    #   default_scroll_strategy: default strategy for scrolling if not enforced
+    #
+    # @param [TestaAppiumDriver::Driver] driver
+    # @param [TestaAppiumDriver::Driver, TestaAppiumDriver::Locator, Selenium::WebDriver::Element] from_element from which element to execute the find_element
+    # @param [Hash] params selectors and params for locator
+    def initialize(driver, from_element, params = {})
+      # @type [TestaAppiumDriver::Driver]
+      @driver = driver
+
+      params, selectors = extract_selectors_from_params(params)
+
+      single = params[:single]
+
+      @single = single
+
+      if from_element.instance_of?(Selenium::WebDriver::Element)
+        @xpath_selector = "//*" # to select current element
+        @xpath_selector += hash_to_xpath(@driver.device, selectors, single)[1..-1]
+      else
+        @xpath_selector = hash_to_xpath(@driver.device, selectors, single)
+      end
+
+
+      @from_element = from_element
+      @default_find_strategy = params[:default_find_strategy]
+      @default_scroll_strategy = params[:default_scroll_strategy]
+
+
+      @strategy = params[:strategy]
+      @strategy_reason = params[:strategy_reason]
+
+      # @type [Boolean] used to determine if last selector was one of siblings or children. Only in those selectors we can reliably use xpath array [instance] selector
+      @last_selector_adjacent = false
+
+      init(params, selectors, single)
+    end
+
+
+    # method missing is used to fetch the element before executing additional commands like click, send_key, count
+    def method_missing(method, *args, &block)
+      execute.send(method, *args, &block)
+    end
+
+
+    # @param [Boolean] skip_cache if true it will skip cache check and store
+    # @param [Selenium::WebDriver::Element] force_cache_element, for internal use where we have already the element, and want to execute custom locator methods on it
+    # @return [Selenium::WebDriver::Element, Array]
+    def execute(skip_cache: false, force_cache_element: nil)
+      return force_cache_element unless force_cache_element.nil?
+      # if we are looking for current element, then return from_element
+      # for example when we have driver.element.elements[1].click
+      # elements[2] will be resolved with xpath because we are looking for multiple elements from element
+      # and since we are looking for instance 2, [](instance) method will return new "empty locator"
+      # we are executing click on that "empty locator" so we have to return the instance 2 of elements for the click
+      if @xpath_selector == "//*/*[1]" && @from_element.instance_of?(Selenium::WebDriver::Element)
+        return @from_element
+      end
+      @driver.execute(@from_element, selector, @single, @strategy, @default_find_strategy, skip_cache)
+    end
+
+
+    # @param [Integer] timeout in seconds
+    # @return [TestaAppiumDriver::Locator]
+    def wait_until_exists(timeout = @driver.get_timeouts["implicit"] / 1000)
+      start_time = Time.now.to_f
+      until exists?
+        raise "wait until exists timeout exceeded" if start_time + timeout > Time.now.to_f
+        sleep EXISTS_WAIT
+      end
+      self
+    end
+
+
+    # @param [Integer] timeout in seconds
+    # @return [TestaAppiumDriver::Locator]
+    def wait_while_exists(timeout = @driver.get_timeouts["implicit"] / 1000)
+      start_time = Time.now.to_f
+      while exists?
+        raise "wait until exists timeout exceeded" if start_time + timeout > Time.now.to_f
+        sleep EXISTS_WAIT
+      end
+      self
+    end
+
+
+    # all timeouts are disabled before check, and enabled after check
+    # @return [boolean] true if it exists in the page regardless if visible or not
+    def exists?
+      @driver.disable_wait_for_idle
+      @driver.disable_implicit_wait
+      found = true
+      begin
+        execute(skip_cache: true)
+      rescue StandardError
+        found = false
+      end
+      @driver.enable_implicit_wait
+      @driver.enable_wait_for_idle
+      found
+    end
+
+
+    def [](instance)
+      raise "Cannot add index selector to non-Array" if @single
+
+      if (@strategy.nil? && !@last_selector_adjacent) || @strategy == FIND_STRATEGY_UIAUTOMATOR
+        locator = self.dup
+        locator.strategy = FIND_STRATEGY_UIAUTOMATOR
+        locator.ui_selector = "#{@ui_selector}.instance(#{instance})"
+        locator.single = true
+        locator
+      else
+        from_element = self.execute[instance]
+        params = {}.merge({single: true, scrollable_locator: @scrollable_locator})
+        #params[:strategy] = FIND_STRATEGY_XPATH
+        #params[:strategy_reason] = "retrieved instance of a array"
+        params[:default_find_strategy] = @default_find_strategy
+        params[:default_scroll_strategy] = @default_scroll_strategy
+        Locator.new(@driver, from_element, params)
+      end
+    end
+
+
+    # @param [TestaAppiumDriver::Locator, Selenium::WebDriver::Element, Array] other
+    #noinspection RubyNilAnalysis,RubyUnnecessaryReturnStatement
+    def ==(other)
+      elements = execute
+      other = other.execute if other.kind_of?(TestaAppiumDriver::Locator)
+
+      if elements.kind_of?(Array)
+        return false unless other.kind_of?(Array)
+        return false if other.count != elements.count
+        return (elements - other).empty?
+      else
+        return false if other.kind_of?(Array)
+        return elements == other
+      end
+    end
+
+    def as_json
+      {
+          strategy: @strategy,
+          default_strategy: @default_find_strategy,
+          single: @single,
+          context: @from_element.nil? ? nil : @from_element.to_s,
+          uiautomator: defined?(self.ui_selector) ? ui_selector : nil,
+          xpath: @xpath_selector,
+          scrollable: @scrollable_locator.nil? ? nil : @scrollable_locator.to_s,
+          scroll_orientation: @scroll_orientation
+      }
+    end
+
+    def to_s
+      JSON.dump(as_json)
+    end
+
+    def to_ary
+      [self.to_s]
+    end
+
+
+    # @return [TestaAppiumDriver::Locator]
+    def as_scrollable(orientation: :vertical, top: nil, bottom: nil, right: nil, left: nil)
+      @scroll_orientation = orientation
+      if !top.nil? || !bottom.nil? || !right.nil? || !left.nil?
+        @scroll_deadzone = {}
+        @scroll_deadzone[:top] = top.to_f unless top.nil?
+        @scroll_deadzone[:bottom] = bottom.to_f unless bottom.nil?
+        @scroll_deadzone[:right] = right.to_f unless right.nil?
+        @scroll_deadzone[:left] = left.to_f unless left.nil?
+      end
+      @scrollable_locator = self.dup
+      self
+    end
+
+
+    def first_and_last_leaf
+      @driver.first_and_last_leaf(execute)
+    end
+
+
+    def tap
+      click
+    end
+
+    def click
+      perform_driver_method(:click)
+    end
+
+    def send_key(*args)
+      perform_driver_method(:send_keys, *args)
+    end
+
+    def clear
+      perform_driver_method(:clear)
+    end
+
+
+    # Return parent element
+    # @return [TestaAppiumDriver::Locator]
+    def parent
+      raise StrategyMixException.new(@strategy, @strategy_reason, FIND_STRATEGY_XPATH, "parent") if @strategy != FIND_STRATEGY_XPATH && !@strategy.nil?
+      raise "Cannot add parent selector to a retrieved instance of a class array" if (@xpath_selector == "//*" || @xpath_selector == "//*[1]")  && !@from_element.nil?
+
+      locator = self.dup
+      locator.strategy = FIND_STRATEGY_XPATH
+      locator.strategy_reason = "parent"
+      locator.xpath_selector += "/.."
+      locator
+    end
+
+    # Return all children elements
+    # @return [TestaAppiumDriver::Locator]
+    def children
+      raise "Cannot add children selector to array" unless @single
+      raise StrategyMixException.new(@strategy, @strategy_reason, FIND_STRATEGY_XPATH, "children") if @strategy != FIND_STRATEGY_XPATH && !@strategy.nil?
+
+      locator = self.dup
+      locator.strategy = FIND_STRATEGY_XPATH
+      locator.strategy_reason = "children"
+      locator.xpath_selector += "/*"
+      locator.single = false
+      locator.last_selector_adjacent = true
+      locator
+    end
+
+
+    # Return first child element
+    # @return [TestaAppiumDriver::Locator]
+    def child
+      raise "Cannot add children selector to array" unless @single
+      raise StrategyMixException.new(@strategy, @strategy_reason, FIND_STRATEGY_XPATH, "child") if @strategy != FIND_STRATEGY_XPATH && !@strategy.nil?
+
+      locator = self.dup
+      locator.strategy = FIND_STRATEGY_XPATH
+      locator.strategy_reason = "child"
+      locator.xpath_selector += "/*[1]"
+      locator.single = true
+      locator
+    end
+
+
+    # @return [TestaAppiumDriver::Locator]
+    def siblings
+      raise "Cannot add siblings selector to array" unless @single
+      raise StrategyMixException.new(@strategy, @strategy_reason, FIND_STRATEGY_XPATH, "siblings") if @strategy != FIND_STRATEGY_XPATH && !@strategy.nil?
+      raise "Cannot add siblings selector to a retrieved instance of a class array" if (@xpath_selector == "//*" || @xpath_selector == "//*[1]")  && !@from_element.nil?
+
+      locator = self.dup
+      locator.strategy = FIND_STRATEGY_XPATH
+      locator.strategy_reason = "siblings"
+      locator.xpath_selector += "/../*[not(@index=\"#{index}\")]"
+      locator.single = false
+      locator.last_selector_adjacent = true
+      locator
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def preceding_siblings
+      raise "Cannot add preceding_siblings selector to array" unless @single
+      raise StrategyMixException.new(@strategy, @strategy_reason, FIND_STRATEGY_XPATH, "preceding_siblings") if @strategy != FIND_STRATEGY_XPATH && !@strategy.nil?
+      raise "Cannot add preceding_siblings selector to a retrieved instance of a class array" if (@xpath_selector == "//*" || @xpath_selector == "//*[1]")  && !@from_element.nil?
+
+      locator = self.dup
+      locator.strategy = FIND_STRATEGY_XPATH
+      locator.strategy_reason = "preceding_siblings"
+      locator.xpath_selector += "/../*[position() < #{index + 1}]" # position() starts from 1
+      locator.single = false
+      locator.last_selector_adjacent = true
+      locator
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def preceding_sibling
+      raise "Cannot add preceding_sibling selector to array" unless @single
+      raise StrategyMixException.new(@strategy, @strategy_reason, FIND_STRATEGY_XPATH, "preceding_sibling") if @strategy != FIND_STRATEGY_XPATH && !@strategy.nil?
+      raise "Cannot add preceding siblings selector to a retrieved instance of a class array" if (@xpath_selector == "//*" || @xpath_selector == "//*[1]")  && !@from_element.nil?
+
+      locator = self.dup
+      locator.strategy = FIND_STRATEGY_XPATH
+      locator.strategy_reason = "preceding_sibling"
+      i = index
+      locator.single = true
+      return nil if i == 0
+      locator.xpath_selector += "/../*[@index=\"#{i - 1}\"]"
+      locator.last_selector_adjacent = true
+      locator
+    end
+
+
+    # @return [TestaAppiumDriver::Locator]
+    def following_siblings
+      raise "Cannot add following_siblings selector to array" unless @single
+      raise StrategyMixException.new(@strategy, @strategy_reason, FIND_STRATEGY_XPATH, "following_siblings") if @strategy != FIND_STRATEGY_XPATH && !@strategy.nil?
+      raise "Cannot add following_siblings selector to a retrieved instance of a class array" if (@xpath_selector == "//*" || @xpath_selector == "//*[1]")  && !@from_element.nil?
+
+      locator = self.dup
+      locator.strategy = FIND_STRATEGY_XPATH
+      locator.strategy_reason = "following_siblings"
+      locator.xpath_selector += "/../*[position() > #{index + 1}]" # position() starts from 1
+      locator.single = false
+      locator.last_selector_adjacent = true
+      locator
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def following_sibling
+      raise "Cannot add following_sibling selector to array" unless @single
+      raise StrategyMixException.new(@strategy, @strategy_reason, FIND_STRATEGY_XPATH, "following_sibling") if @strategy != FIND_STRATEGY_XPATH && !@strategy.nil?
+      raise "Cannot add following_sibling selector to a retrieved instance of a class array" if (@xpath_selector == "//*" || @xpath_selector == "//*[1]")  && !@from_element.nil?
+
+      locator = self.dup
+      locator.strategy = FIND_STRATEGY_XPATH
+      locator.strategy_reason = "following_sibling"
+      i = index
+      locator.single = true
+      return nil if i == 0
+      locator.xpath_selector += "/../*[@index=\"#{i + 1}\"]"
+      locator.last_selector_adjacent = true
+      locator
+    end
+
+
+    private
+
+    #noinspection RubyNilAnalysis
+    def perform_driver_method(name, *args)
+      elements = execute
+      if elements.kind_of?(Array)
+        elements.map { |e| e.send(name, *args) }
+      else
+        elements.send(name, *args)
+      end
+    end
+
+    def add_xpath_child_selectors(locator, selectors, single)
+      locator.single = false unless single # switching from single result to multiple
+      locator.xpath_selector += hash_to_xpath(@driver.device, selectors, single)
+    end
+  end
+
+end