eyes_selenium 2.16.0 → 2.17.0

data/lib/applitools/selenium/element.rb

@@ -25,7 +25,7 @@ module Applitools::Selenium
     end
 
     def ==(other)
-      other.kind_of?(web_element.class) && web_element == other
+      other.is_a?(web_element.class) && web_element == other
     end
     alias_method :eql?, :==
 
@@ -41,13 +41,18 @@ module Applitools::Selenium
 
     def region
       point = location
-      left, top, width, height  = point.x, point.y, 0, 0
+      left = point.x
+      top = point.y
+      width = 0
+      height = 0
 
       begin
         dimension = size
-        width, height = dimension.width, dimension.height
-      rescue
+        width = dimension.width
+        height = dimension.height
+      rescue => e
         # Not supported on all platforms.
+        Applitools::EyesLogger.error("Failed extracting size using JavaScript: (#{e.message})")
       end
 
       if left < 0
@@ -60,7 +65,7 @@ module Applitools::Selenium
         top = 0
       end
 
-      return Applitools::Base::Region.new(left, top, width, height)
+      Applitools::Base::Region.new(left, top, width, height)
     end
   end
 end

data/lib/applitools/selenium/match_window_data.rb

@@ -10,7 +10,7 @@ module Applitools::Selenium
       @screenshot = screenshot
     end
 
-    # IMPORTANT This method returns a hash WITHOUT the screenshot property. This is on purspose! The screenshot should
+    # IMPORTANT This method returns a hash WITHOUT the screenshot property. This is on purpose! The screenshot should
     # not be included as part of the json.
     def to_hash
       {

data/lib/applitools/selenium/match_window_task.rb

@@ -25,26 +25,31 @@ module Applitools::Selenium
       Applitools::EyesLogger.debug "Retry timeout set to: #{retry_timeout}"
 
       start = Time.now
-      res = if retry_timeout.zero?
-        run(region, tag, rotation)
-      elsif run_once_after_wait
-        run(region, tag, rotation, retry_timeout)
-      else
-        run_with_intervals(region, tag, rotation, retry_timeout)
-      end
+      res =
+        if retry_timeout.zero?
+          run(region, tag, rotation)
+        elsif run_once_after_wait
+          run(region, tag, rotation, retry_timeout)
+        else
+          run_with_intervals(region, tag, rotation, retry_timeout)
+        end
       elapsed_time = Time.now - start
 
       Applitools::EyesLogger.debug "match_window(): Completed in #{format('%.2f', elapsed_time)} seconds"
 
       @last_checked_window = @current_screenshot
-      @last_screenshot_bounds = region.empty? ? Applitools::Base::Region.new(0, 0, last_checked_window.width,
-        last_checked_window.height) : region
+      @last_screenshot_bounds =
+        if region.empty?
+          Applitools::Base::Region.new(0, 0, last_checked_window.width, last_checked_window.height)
+        else
+          region
+        end
       driver.clear_user_inputs
 
       res
     end
 
-    def run(region, tag, rotation, wait_before_run=nil)
+    def run(region, tag, rotation, wait_before_run = nil)
       Applitools::EyesLogger.debug 'Trying matching once...'
 
       if wait_before_run
@@ -85,10 +90,12 @@ module Applitools::Selenium
     private
 
     def get_clipped_region(region, image)
-      left, top = [region.left, 0].max, [region.top, 0].max
+      left = [region.left, 0].max
+      top = [region.top, 0].max
       max_width = image.width - left
       max_height = image.height - top
-      width, height = [region.width, max_width].min, [region.height, max_height].min
+      width = [region.width, max_width].min
+      height = [region.height, max_height].min
       Applitools::Base::Region.new(left, top, width, height)
     end
 
@@ -130,12 +137,12 @@ module Applitools::Selenium
               trigger.control.intersect(last_screenshot_bounds)
               if trigger.control.empty?
                 trigger_left -= - last_screenshot_bounds.left
-                trigger_top = trigger_top - last_screenshot_bounds.top
+                trigger_top -= last_screenshot_bounds.top
                 updated_trigger = Applitools::Base::MouseTrigger.new(trigger.mouse_action, trigger.control,
                   Applitools::Base::Point.new(trigger_left, trigger_top))
               else
-                trigger_left = trigger_left - trigger.control.left
-                trigger_top = trigger_top - trigger.control.top
+                trigger_left -= trigger.control.left
+                trigger_top -= trigger.control.top
                 control_left = trigger.control.left - last_screenshot_bounds.left
                 control_top = trigger.control.top - last_screenshot_bounds.top
                 updated_control = Applitools::Base::Region.new(control_left, control_top, trigger.control.width,
@@ -149,9 +156,9 @@ module Applitools::Selenium
               Applitools::EyesLogger.info "Trigger ignored: #{trigger} (out of bounds)"
             end
           elsif trigger.is_a?(Applitools::Base::TextTrigger)
-            unless trigger.control.empty?
+            if !trigger.control.empty?
               trigger.control.intersect(last_screenshot_bounds)
-              unless trigger.control.empty?
+              if !trigger.control.empty?
                 control_left = trigger.control.left - last_screenshot_bounds.left
                 control_top = trigger.control.top - last_screenshot_bounds.top
                 updated_control = Applitools::Base::Region.new(control_left, control_top, trigger.control.width,
@@ -179,7 +186,7 @@ module Applitools::Selenium
       match_window_data_obj
     end
 
-    def match(region, tag, rotation, ignore_mismatch=false)
+    def match(region, tag, rotation, ignore_mismatch = false)
       Applitools::EyesLogger.debug 'Match called...'
       data = prep_match_data(region, tag, rotation, ignore_mismatch)
       match_result = Applitools::Base::ServerConnector.match_window(session, data)

data/lib/applitools/selenium/mouse.rb

@@ -35,16 +35,16 @@ module Applitools::Selenium
       current_control = Applitools::Base::Region.new(0, 0, *location.values)
       driver.user_inputs << Applitools::Base::MouseTrigger.new(:move, current_control, location)
       element = element.web_element if element.is_a?(Applitools::Selenium::Element)
-      mouse.move_to(element,right_by, down_by)
+      mouse.move_to(element, right_by, down_by)
     end
 
     def move_by(right_by, down_by)
       right = [0, right_by].max.round
       down = [0, down_by].max.round
-      location = Applitools::Base::Point.new(right,down)
+      location = Applitools::Base::Point.new(right, down)
       current_control = Applitools::Base::Region.new(0, 0, right, down)
       driver.user_inputs << Applitools::Base::MouseTrigger.new(:move, current_control, location)
-      mouse.move_by(right_by,down_by)
+      mouse.move_by(right_by, down_by)
     end
 
     private

data/lib/applitools/selenium/viewport_size.rb

@@ -1,37 +1,41 @@
 module Applitools::Selenium
   class ViewportSize
-    JS_GET_VIEWPORT_HEIGHT = <<-EOF
-      var height = undefined;
-      if (window.innerHeight) {
-        height = window.innerHeight;
-      }
-      else if (document.documentElement && document.documentElement.clientHeight) {
-        height = document.documentElement.clientHeight;
-      } else {
-        var b = document.getElementsByTagName("body")[0];
-        if (b.clientHeight) {
-          height = b.clientHeight;
+    JS_GET_VIEWPORT_HEIGHT = (<<-JS).freeze
+      return (function() {
+        var height = undefined;
+        if (window.innerHeight) {
+          height = window.innerHeight;
         }
-      }
-
-      return height;
-    EOF
-
-    JS_GET_VIEWPORT_WIDTH  = <<-EOF
-      var width = undefined;
-      if (window.innerWidth) {
-        width = window.innerWidth
-      } else if (document.documentElement && document.documentElement.clientWidth) {
-        width = document.documentElement.clientWidth;
-      } else {
-        var b = document.getElementsByTagName("body")[0];
-        if (b.clientWidth) {
-          width = b.clientWidth;
+        else if (document.documentElement && document.documentElement.clientHeight) {
+          height = document.documentElement.clientHeight;
+        } else {
+          var b = document.getElementsByTagName("body")[0];
+          if (b.clientHeight) {
+            height = b.clientHeight;
+          }
         }
-      }
 
-      return width;
-    EOF
+        return height;
+      }());
+    JS
+
+    JS_GET_VIEWPORT_WIDTH = (<<-JS).freeze
+      return (function() {
+        var width = undefined;
+        if (window.innerWidth) {
+          width = window.innerWidth
+        } else if (document.documentElement && document.documentElement.clientWidth) {
+          width = document.documentElement.clientWidth;
+        } else {
+          var b = document.getElementsByTagName("body")[0];
+          if (b.clientWidth) {
+            width = b.clientWidth;
+          }
+        }
+
+        return width;
+      }());
+    JS
 
     VERIFY_SLEEP_PERIOD = 1.freeze
     VERIFY_RETRIES = 3.freeze
@@ -54,7 +58,8 @@ module Applitools::Selenium
     end
 
     def extract_viewport_from_browser
-      width, height = nil, nil
+      width = nil
+      height = nil
       begin
         width  = extract_viewport_width
         height = extract_viewport_height
@@ -63,51 +68,52 @@ module Applitools::Selenium
       end
 
       if width.nil? || height.nil?
-        Applitools::EyesLogger.info "Using window size as viewport size."
+        Applitools::EyesLogger.info 'Using window size as viewport size.'
 
         width, height = *browser_size.values
-        width, height = width.ceil, height.ceil
+        width = width.ceil
+        height = height.ceil
 
         if @driver.landscape_orientation? && height > width
           width, height = height, width
         end
       end
 
-      Applitools::Base::Dimension.new(width,height)
+      Applitools::Base::Dimension.new(width, height)
     end
 
     alias_method :viewport_size, :extract_viewport_from_browser
 
     def set
-      if @dimension.is_a?(Hash) && @dimension.has_key?(:width) && @dimension.has_key?(:height)
+      if @dimension.is_a?(Hash) && @dimension.key?(:width) && @dimension.key?(:height)
         # If @dimension is hash of width/height, we convert it to a struct with width/height properties.
         @dimension = Struct.new(:width, :height).new(@dimension[:width], @dimension[:height])
       elsif !@dimension.respond_to?(:width) || !@dimension.respond_to?(:height)
-        raise ArgumentError, "expected #{@dimension.inspect}:#{@dimension.class} to respond to #width and #height, or be "\
-          ' a hash with these keys.'
+        raise ArgumentError, "expected #{@dimension.inspect}:#{@dimension.class} to respond to #width and #height, or "\
+          'be  a hash with these keys.'
       end
 
-      set_browser_size(@dimension)
+      resize_browser(@dimension)
       verify_size(:browser_size)
 
-      cur_viewport_size = extract_viewport_from_browser
+      current_viewport_size = extract_viewport_from_browser
 
-      set_browser_size(Applitools::Base::Dimension.new((2 * browser_size.width) - cur_viewport_size.width,
-        (2 * browser_size.height) - cur_viewport_size.height))
+      resize_browser(Applitools::Base::Dimension.new((2 * browser_size.width) - current_viewport_size.width,
+        (2 * browser_size.height) - current_viewport_size.height))
       verify_size(:viewport_size)
     end
 
-    def verify_size(to_verify, sleep_time = VERIFY_SLEEP_PERIOD, retries = VERIFY_RETRIES)
-      cur_size = nil
+    def verify_size(to_verify)
+      current_size = nil
 
-      retries.times do
-        sleep(sleep_time)
-        cur_size = send(to_verify)
+      VERIFY_RETRIES.times do
+        sleep(VERIFY_SLEEP_PERIOD)
+        current_size = send(to_verify)
 
-        return if cur_size.values == @dimension.values
+        return if current_size.values == @dimension.values
       end
 
-      err_msg = "Failed setting #{to_verify} to #{@dimension.values} (current size: #{cur_size.values})"
+      err_msg = "Failed setting #{to_verify} to #{@dimension.values} (current size: #{current_size.values})"
 
       Applitools::EyesLogger.error(err_msg)
       raise Applitools::TestFailedError.new(err_msg)
@@ -117,7 +123,10 @@ module Applitools::Selenium
       @driver.manage.window.size
     end
 
-    def set_browser_size(other)
+    def resize_browser(other)
+      # Before resizing the window, set its position to the upper left corner (otherwise, there might not be enough
+      # "space" below/next to it and the operation won't be successful).
+      @driver.manage.window.position = Selenium::WebDriver::Point.new(0, 0)
       @driver.manage.window.size = other
     end
 

data/lib/applitools/utils/image_delta_compressor.rb

@@ -1,150 +1,148 @@
-require 'oily_png'
-
-module Applitools::Utils
-  module ImageDeltaCompressor
-    extend self
-
-    BLOCK_SIZE = 10.freeze
-
-    # Compresses the target image based on the source image.
-    #
-    # +target+:: +ChunkyPNG::Canvas+ The image to compress based on the source image.
-    # +target_encoded+:: +Array+ The uncompressed image as binary string.
-    # +source+:: +ChunkyPNG::Canvas+ The source image used as a base for compressing the target image.
-    # +block_size+:: +Integer+ The width/height of each block.
-    #
-    # Returns +String+ The binary result (either the compressed image, or the uncompressed image if the compression
-    # is greater in length).
-    def compress_by_raw_blocks(target, target_encoded, source, block_size = BLOCK_SIZE)
-      # If we can't compress for any reason, return the target image as is.
-      if source.nil? || (source.height != target.height) || (source.width != target.width)
-        # Returning a COPY of the target binary string.
-        return String.new(target_encoded)
-      end
-
-      # Preparing the variables we need.
-      target_pixels = target.to_rgb_stream.unpack('C*')
-      source_pixels = source.to_rgb_stream.unpack('C*')
-      image_size = Dimension.new(target.width, target.height)
-      block_columns_count = (target.width / block_size) + ((target.width % block_size) == 0 ? 0 : 1)
-      block_rows_count = (target.height / block_size) + ((target.height % block_size) == 0 ? 0 : 1)
-
-      # IMPORTANT: The "-Zlib::MAX_WBITS" tells ZLib to create raw deflate compression, without the
-      # "Zlib headers" (this isn't documented in the Zlib page, I found this in some internet forum).
-      compressor = Zlib::Deflate.new(Zlib::BEST_COMPRESSION, -Zlib::MAX_WBITS)
-
-      compression_result = ''
-
-      # Writing the data header.
-      compression_result += PREAMBLE.encode('UTF-8')
-      compression_result += [FORMAT_RAW_BLOCKS].pack('C')
-      compression_result += [0].pack('S>') #Source id, Big Endian
-      compression_result += [block_size].pack('S>') #Big Endian
-
-      # We perform the compression for each channel.
-      3.times do |channel|
-        block_number = 0
-        block_rows_count.times do |block_row|
-          block_columns_count.times do |block_column|
-            actual_channel_index = 2 - channel # Since the image bytes are BGR and the server expects RGB...
-            compare_result = compare_and_copy_block_channel_data(source_pixels, target_pixels, image_size, 3, block_size,
-              block_column, block_row, actual_channel_index)
-
-            unless compare_result.identical
-              channel_bytes = compare_result.channel_bytes
-              string_to_compress = [channel].pack('C')
-              string_to_compress += [block_number].pack('L>')
-              string_to_compress += channel_bytes.pack('C*')
-
-              compression_result += compressor.deflate(string_to_compress)
-
-              # If the compressed data so far is greater than the uncompressed representation of the target, just return
-              # the target.
-              if compression_result.length > target_encoded.length
-  	             compressor.finish
-                compressor.close
-                # Returning a copy of the target bytes.
-                return String.new(target_encoded)
-              end
-            end
-
-            block_number += 1
-          end
-        end
-      end
-
-      # Compress and flush any remaining uncompressed data in the input buffer.
-      compression_result += compressor.finish
-      compressor.close
-
-      # Returning the compressed result as a byte array.
-      compression_result
-    end
-
-    private
-
-    PREAMBLE = 'applitools'.freeze
-    FORMAT_RAW_BLOCKS = 3.freeze
-
-    Dimension = Struct.new(:width, :height)
-    CompareAndCopyBlockChannelDataResult = Struct.new(:identical, :channel_bytes)
-
-    # Computes the width and height of the image data contained in the block at the input column and row.
-    # +image_size+:: +Dimension+ The image size in pixels.
-    # +block_size+:: The block size for which we would like to compute the image data width and height.
-    # +block_column+:: The block column index.
-    # +block_row+:: The block row index.
-    # ++
-    # Returns the width and height of the image data contained in the block are returned as a +Dimension+.
-    def get_actual_block_size(image_size, block_size, block_column, block_row)
-      actual_width = [image_size.width - (block_column * block_size), block_size].min
-      actual_height = [image_size.height - (block_row * block_size), block_size].min
-      Dimension.new(actual_width, actual_height)
-    end
-
-    # Compares a block of pixels between the source and target and copies the target's block bytes to the result.
-    # +source_pixels+:: +Array+ of bytes, representing the pixels of the source image.
-    # +target_pixels+:: +Array+ of bytes, representing the pixels of the target image.
-    # +image_size+:: +Dimension+ The size of the source/target image (remember they must be the same size).
-    # +pixel_length+:: +Integer+ The number of bytes composing a pixel
-    # +block_size+:: +Integer+ The width/height of the block (block is a square, theoretically).
-    # +block_column+:: +Integer+ The block column index (when looking at the images as a grid of blocks).
-    # +block_row+:: +Integer+ The block row index (when looking at the images as a grid of blocks).
-    # +channel+:: +Integer+ The index of the channel we're comparing.
-    # ++
-    # Returns +CompareAndCopyBlockChannelDataResult+ object containing a flag saying whether the blocks are identical
-    # and a copy of the target block's bytes.
-    def compare_and_copy_block_channel_data(source_pixels, target_pixels, image_size, pixel_length, block_size,
-        block_column, block_row, channel)
-      identical = true
-
-      actual_block_size = get_actual_block_size(image_size, block_size, block_column, block_row)
-
-      # Getting the actual amount of data in the block we wish to copy.
-      actual_block_height = actual_block_size.height
-      actual_block_width = actual_block_size.width
-
-      stride = image_size.width * pixel_length
-
-      # Iterating the block's pixels and comparing the source and target.
-      channel_bytes = []
-      actual_block_height.times do |h|
-        offset = (((block_size * block_row) + h) * stride) + (block_size * block_column * pixel_length) + channel
-        actual_block_width.times do |w|
-          source_byte = source_pixels[offset]
-          target_byte = target_pixels[offset]
-          if source_byte != target_byte
-            identical = false
-          end
-          channel_bytes << target_byte
-          offset += pixel_length
-        end
-      end
-
-      # Returning the compare-and-copy result.
-      CompareAndCopyBlockChannelDataResult.new(identical, channel_bytes)
-    end
-
-    include Applitools::MethodTracer
-  end
-end
+require 'oily_png'
+
+module Applitools::Utils
+  module ImageDeltaCompressor
+    extend self
+
+    BLOCK_SIZE = 10.freeze
+
+    # Compresses the target image based on the source image.
+    #
+    # +target+:: +ChunkyPNG::Canvas+ The image to compress based on the source image.
+    # +target_encoded+:: +Array+ The uncompressed image as binary string.
+    # +source+:: +ChunkyPNG::Canvas+ The source image used as a base for compressing the target image.
+    # +block_size+:: +Integer+ The width/height of each block.
+    #
+    # Returns +String+ The binary result (either the compressed image, or the uncompressed image if the compression
+    # is greater in length).
+    def compress_by_raw_blocks(target, target_encoded, source, block_size = BLOCK_SIZE)
+      # If we can't compress for any reason, return the target image as is.
+      if source.nil? || (source.height != target.height) || (source.width != target.width)
+        # Returning a COPY of the target binary string.
+        return String.new(target_encoded)
+      end
+
+      # Preparing the variables we need.
+      target_pixels = target.to_rgb_stream.unpack('C*')
+      source_pixels = source.to_rgb_stream.unpack('C*')
+      image_size = Dimension.new(target.width, target.height)
+      block_columns_count = (target.width / block_size) + ((target.width % block_size) == 0 ? 0 : 1)
+      block_rows_count = (target.height / block_size) + ((target.height % block_size) == 0 ? 0 : 1)
+
+      # IMPORTANT: The "-Zlib::MAX_WBITS" tells ZLib to create raw deflate compression, without the
+      # "Zlib headers" (this isn't documented in the Zlib page, I found this in some internet forum).
+      compressor = Zlib::Deflate.new(Zlib::BEST_COMPRESSION, -Zlib::MAX_WBITS)
+
+      compression_result = ''
+
+      # Writing the data header.
+      compression_result += PREAMBLE.encode('UTF-8')
+      compression_result += [FORMAT_RAW_BLOCKS].pack('C')
+      compression_result += [0].pack('S>') # Source id, Big Endian
+      compression_result += [block_size].pack('S>') # Big Endian
+
+      # We perform the compression for each channel.
+      3.times do |channel|
+        block_number = 0
+        block_rows_count.times do |block_row|
+          block_columns_count.times do |block_column|
+            actual_channel_index = 2 - channel # Since the image bytes are BGR and the server expects RGB...
+            compare_result = compare_and_copy_block_channel_data(source_pixels, target_pixels, image_size, 3,
+              block_size, block_column, block_row, actual_channel_index)
+
+            unless compare_result.identical
+              channel_bytes = compare_result.channel_bytes
+              string_to_compress = [channel].pack('C')
+              string_to_compress += [block_number].pack('L>')
+              string_to_compress += channel_bytes.pack('C*')
+
+              compression_result += compressor.deflate(string_to_compress)
+
+              # If the compressed data so far is greater than the uncompressed representation of the target, just return
+              # the target.
+              if compression_result.length > target_encoded.length
+                compressor.finish
+                compressor.close
+                # Returning a copy of the target bytes.
+                return String.new(target_encoded)
+              end
+            end
+
+            block_number += 1
+          end
+        end
+      end
+
+      # Compress and flush any remaining uncompressed data in the input buffer.
+      compression_result += compressor.finish
+      compressor.close
+
+      # Returning the compressed result as a byte array.
+      compression_result
+    end
+
+    private
+
+    PREAMBLE = 'applitools'.freeze
+    FORMAT_RAW_BLOCKS = 3.freeze
+
+    Dimension = Struct.new(:width, :height)
+    CompareAndCopyBlockChannelDataResult = Struct.new(:identical, :channel_bytes)
+
+    # Computes the width and height of the image data contained in the block at the input column and row.
+    # +image_size+:: +Dimension+ The image size in pixels.
+    # +block_size+:: The block size for which we would like to compute the image data width and height.
+    # +block_column+:: The block column index.
+    # +block_row+:: The block row index.
+    # ++
+    # Returns the width and height of the image data contained in the block are returned as a +Dimension+.
+    def get_actual_block_size(image_size, block_size, block_column, block_row)
+      actual_width = [image_size.width - (block_column * block_size), block_size].min
+      actual_height = [image_size.height - (block_row * block_size), block_size].min
+      Dimension.new(actual_width, actual_height)
+    end
+
+    # Compares a block of pixels between the source and target and copies the target's block bytes to the result.
+    # +source_pixels+:: +Array+ of bytes, representing the pixels of the source image.
+    # +target_pixels+:: +Array+ of bytes, representing the pixels of the target image.
+    # +image_size+:: +Dimension+ The size of the source/target image (remember they must be the same size).
+    # +pixel_length+:: +Integer+ The number of bytes composing a pixel
+    # +block_size+:: +Integer+ The width/height of the block (block is a square, theoretically).
+    # +block_column+:: +Integer+ The block column index (when looking at the images as a grid of blocks).
+    # +block_row+:: +Integer+ The block row index (when looking at the images as a grid of blocks).
+    # +channel+:: +Integer+ The index of the channel we're comparing.
+    # ++
+    # Returns +CompareAndCopyBlockChannelDataResult+ object containing a flag saying whether the blocks are identical
+    # and a copy of the target block's bytes.
+    def compare_and_copy_block_channel_data(source_pixels, target_pixels, image_size, pixel_length, block_size,
+        block_column, block_row, channel)
+      identical = true
+
+      actual_block_size = get_actual_block_size(image_size, block_size, block_column, block_row)
+
+      # Getting the actual amount of data in the block we wish to copy.
+      actual_block_height = actual_block_size.height
+      actual_block_width = actual_block_size.width
+
+      stride = image_size.width * pixel_length
+
+      # Iterating the block's pixels and comparing the source and target.
+      channel_bytes = []
+      actual_block_height.times do |h|
+        offset = (((block_size * block_row) + h) * stride) + (block_size * block_column * pixel_length) + channel
+        actual_block_width.times do |_w|
+          source_byte = source_pixels[offset]
+          target_byte = target_pixels[offset]
+          identical = false if source_byte != target_byte
+          channel_bytes << target_byte
+          offset += pixel_length
+        end
+      end
+
+      # Returning the compare-and-copy result.
+      CompareAndCopyBlockChannelDataResult.new(identical, channel_bytes)
+    end
+
+    include Applitools::MethodTracer
+  end
+end