awetestlib 0.1.28 → 0.1.29pre1

data/lib/awetestlib/regression/drag_and_drop.rb

@@ -1,420 +1,421 @@
-module Awetestlib
-  module Regression
-    # Methods for moving and resizing elements, manipulating the mouse, and checking for relative positioning of elements,
-    # including overlap, overlay, etc.
-    # @note Still experimental. Works with IE but not fully tested with Firefox or Chrome in Windows.
-    #   Not compatible with Mac
-    #   Rdoc is work in progress
-    module DragAndDrop
-
-      # Verify that specified *inner_element* is fully enclosed by *outer_element*.
-      # @param [Watir::Element] inner_element A reference to a DOM element
-      # @param [Watir::Element] outer_element A reference to a DOM element
-      # @param [String] desc Contains a message or description intended to appear in the log and/or report output
-      def verify_element_inside(inner_element, outer_element, desc = '')
-        mark_testlevel("#{__method__.to_s.titleize}", 3)
-        msg = build_message("#{inner_element.class.to_s} (:id=#{inner_element.id}) is fully enclosed by "+
-                            "#{outer_element.class.to_s} (:id=#{outer_element.id}).", desc)
-        if overlay?(inner_element, outer_element, :inside)
-          failed_to_log(msg)
-        else
-          passed_to_log(msg)
-          true
-        end
-      rescue
-        failed_to_log("Unable to verify that #{msg} '#{$!}'")
-      end
-
-      # Verify that two elements, identified by specified attribute and value, do not overlap on a given *side*.
-      # @param [Symbol] above_element The element type for the first element, e.g. :div, :span, etc.
-      # @param [Symbol] above_how The element attribute used to identify the *above_element*.
-      #   Valid values depend on the kind of element.
-      #   Common values: :text, :id, :title, :name, :class, :href (:link only)
-      # @param [String, Regexp] above_what A string or a regular expression to be found in the *above_how* attribute that uniquely identifies the element.
-      # @param [Symbol] below_element The element type for the second element, e.g. :div, :span, etc.
-      # @param [Symbol] below_how The element attribute used to identify the *below_element*.
-      # @param [String, Regexp] below_what A string or a regular expression to be found in the *below_how* attribute that uniquely identifies the element.
-      # @param [Symbol] side :top, :bottom, :left, :right, :inside, or :outside
-      # @param [String] desc Contains a message or description intended to appear in the log and/or report output
-      def verify_no_element_overlap(browser, above_element, above_how, above_what, below_element, below_how, below_what, side, desc = '')
-        mark_testlevel("#{__method__.to_s.titleize}", 3)
-        msg = build_message("#{above_element.to_s.titleize} #{above_how}=>#{above_what} does not overlap "+
-                            "#{below_element.to_s.titleize} #{below_how}=>#{below_what} at the #{side}.", desc)
-        above = browser.element(above_how, above_what)
-        below = browser.element(below_how, below_what)
-        if overlay?(above, below, side)
-          failed_to_log(msg)
-        else
-          passed_to_log(msg)
-          true
-        end
-      rescue
-        failed_to_log("Unable to verify that #{msg} '#{$!}'")
-      end
-
-      def overlay?(inner, outer, side = :bottom)
-        #mark_testlevel("#{__method__.to_s.titleize}", 3)
-        inner_t, inner_b, inner_l, inner_r = inner.bounding_rectangle_offsets
-        outer_t, outer_b, outer_l, outer_r = outer.bounding_rectangle_offsets
-        #overlay = false
-        case side
-          when :bottom
-            overlay = inner_b > outer_t
-          when :top
-            overlay = inner_t > outer_t
-          when :left
-            overlay = inner_l < outer_r
-          when :right
-            overlay = inner_r > outer_r
-          when :inside
-            overlay = !(inner_t > outer_t and
-                inner_r < outer_r and
-                inner_l > outer_l and
-                inner_b < outer_b)
-          else
-            overlay = (inner_t > outer_b or
-                inner_r > outer_l or
-                inner_l < outer_r or
-                inner_b < outer_t)
-        end
-        overlay
-      rescue
-        failed_to_log("Unable to determine overlay. '#{$!}'")
-      end
-
-      def hover(browser, element, wait = 2)
-        w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
-        @ai.MoveMouse(xc1, yc1)
-        sleep_for(1)
-      end
-
-      def move_element_with_handle(browser, element, handle_id, dx, dy)
-        #    msg = "Move element "
-        #    w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
-        #    newx   = w1 + dx
-        #    newy   = h1 + dy
-        #    msg << " by [#{dx}, #{dy}] to expected [[#{newx}, #{newy}] "
-        #    handle = get_resize_handle(element, handle_id)
-        #    hw, hh, hx, hy, hxc, hyc, hxlr, hylr  = get_element_coordinates(browser, handle, true)
-
-        #    drag_and_drop(hxc, hyc, dx, dy)
-
-        #    w2, h2, x2, y2, xc2, yc2, xlr2, ylr2 = get_element_coordinates(browser, element, true)
-
-        #    xerr = x2 - newx
-        #    yerr = y2 - newy
-        #    xdsp = (x1 - x2).abs
-        #    ydsp = (y1 - y2).abs
-
-        #    if x2 == newx and y2 == newy
-        #      msg << "succeeded."
-        #      passed_to_log(msg)
-        #    else
-        #      msg << "failed. "
-        #      failed_to_log(msg)
-        #      debug_to_log("x: actual #{x2}, error #{xerr}, displace #{xdsp}. y: actual #{y2}, error #{yerr}, displace #{ydsp}.")
-        #    end
-
-      end
-
-      def resize_element_with_handle(browser, element, target, dx, dy=nil)
-        #TODO enhance to accept differing percentages in each direction
-        msg                                  = "Resize element "
-        w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
-        if dy
-          deltax = dx
-          deltay = dy
-          neww   = w1 + dx
-          newh   = h1 + dy
-          msg << " by [#{dx}, #{dy}] " #"" to expected dimension [#{neww}, #{newh}] "
-        else
-          deltax, deltay, neww, newh = adjust_dimensions_by_percent(w1, h1, dx, true)
-          msg << "by #{dx} percent " #"" to expected dimension [#{neww}, #{newh}] "
-        end
-        handle = get_resize_handle_by_class(element, target) #, true)
-        sleep_for(0.5)
-        hw, hh, hx, hy, hxc, hyc, hxlr, hylr = get_element_coordinates(browser, handle, true)
-        hxlr_diff                            = 0
-        hylr_diff                            = 0
-
-        # TODO These adjustments are adhoc and empirical. Need to be derived more rigorously
-        if @browserAbbrev == 'IE'
-          hxlr_diff = (xlr1 - hxlr)
-          hylr_diff = (ylr1 - hylr)
-          x_start   = hxlr - 2
-          y_start   = hylr - 2
-        else
-          hxlr_diff = (xlr1 - hxlr) / 2 unless (xlr1 - hxlr) == 0
-          hylr_diff = (ylr1 - hylr) / 2 unless (ylr1 - hylr) == 0
-          x_start = hxlr
-          y_start = hylr
-        end
-
-        newxlr = xlr1 + deltax
-        newylr = ylr1 + deltay
-        #    msg << ", lower right [#{newxlr}, #{newylr}] - "
-        sleep_for(0.5)
-
-        drag_and_drop(x_start, y_start, deltax, deltay)
-
-        sleep_for(1.5)
-        w2, h2, x2, y2, xc2, yc2, xlr2, ylr2 = get_element_coordinates(browser, element, true)
-
-        werr   = w2 - neww
-        herr   = h2 - newh
-
-        # TODO This adjustment is adhoc and empirical. Needs to be derived more rigorously
-        xlrerr = xlr2 - newxlr + hxlr_diff
-        ylrerr = ylr2 - newylr + hylr_diff
-
-        xlrdsp = (xlr1 - xlr2).abs
-        ylrdsp = (ylr1 - ylr2).abs
-
-        debug_to_log("\n" +
-                         "\t\t  hxlr_diff: #{hxlr_diff}\n" +
-                         "\t\t  hylr_diff: #{hylr_diff}\n" +
-                         "\t\t       werr: #{werr}\n" +
-                         "\t\t       herr: #{herr}\n" +
-                         "\t\t     xlrerr: #{xlrerr}\n" +
-                         "\t\t     ylrerr: #{ylrerr}\n" +
-                         "\t\t     xlrdsp: #{xlrdsp}\n" +
-                         "\t\t     ylrdsp: #{ylrdsp}\n" +
-                         "\t\t @min_width: #{@min_width}\n" +
-                         "\t\t@min_height: #{@min_height}\n" +
-                         "\t\t      x tol: #{@x_tolerance}\n" +
-                         "\t\t      y tol: #{@y_tolerance}\n"
-        )
-
-        #TODO Add check that window _was_ resized.
-        x_ok, x_msg = validate_move(w2, xlrerr, @x_tolerance, @min_width, xlr2)
-        y_ok, y_msg = validate_move(h2, ylrerr, @y_tolerance, @min_height, ylr2)
-        msg         = msg + "x: #{x_msg}, y: #{y_msg}"
-
-        if x_ok and y_ok
-          passed_to_log(msg)
-        else
-          failed_to_log(msg)
-          debug_to_log("x - actual #{xlr2}, error #{xlrerr}, displace #{xlrdsp}, y - actual #{ylr2}, error #{ylrerr}, displace #{ylrdsp}.")
-        end
-        sleep_for(1)
-      rescue
-        failed_to_log("Unable to validate resize. #{$!} (#{__LINE__})")
-        sleep_for(1)
-      end
-
-    # :category: GUI
-      def get_resize_handle_by_id(element, id, dbg=nil)
-        handle = get_div_by_id(element, id, dbg)
-        sleep_for(1)
-        handle.flash(5)
-        return handle
-      end
-
-    # :category: GUI
-      def get_resize_handle_by_class(element, strg, dbg=nil)
-        handle = get_div_by_class(element, strg, dbg)
-        sleep_for(0.5)
-        handle.flash(5)
-        return handle
-      end
-
-    # :category: GUI
-      def get_element_coordinates(browser, element, dbg=nil)
-        bx, by, bw, bh = get_browser_coord(browser, dbg)
-        if @browserAbbrev == 'IE'
-          x_hack = @horizontal_hack_ie
-          y_hack = @vertical_hack_ie
-        elsif @browserAbbrev == 'FF'
-          x_hack = @horizontal_hack_ff
-          y_hack = @vertical_hack_ff
-        end
-        sleep_for(1)
-        w, h   = element.dimensions.to_a
-        xc, yc = element.client_offset.to_a
-        #    xcc, ycc = element.client_center.to_a
-        xcc    = xc + w/2
-        ycc    = yc + h/2
-        # screen offset:
-        xs     = bx + x_hack + xc - 1
-        ys     = by + y_hack + yc - 1
-        # screen center:
-        xsc    = xs + w/2
-        ysc    = ys + h/2
-        xslr   = xs + w
-        yslr   = ys + h
-        if dbg
-          debug_to_log(
-              "\n\t\tElement: #{element.inspect}"+
-                  "\n\t\tbrowser screen offset: x: #{bx} y: #{by}"+
-                  "\n\t\t           dimensions: x: #{w} y: #{h}"+
-                  "\n\t\t         client offset x: #{xc} y: #{yc}"+
-                  "\n\t\t         screen offset x: #{xs} y: #{ys}"+
-                  "\n\t\t         client center x: #{xcc} y: #{ycc}"+
-                  "\n\t\t         screen center x: #{xsc} y: #{ysc}"+
-                  "\n\t\t    screen lower right x: #{xslr} y: #{yslr}")
-        end
-        [w, h, xs, ys, xsc, ysc, xslr, yslr]
-      end
-
-      def adjust_dimensions_by_percent(w, h, p, returnnew=nil)
-        p      += 100
-        nw     = (w * (p/100.0)).to_i
-        nh     = (h * (p/100.0)).to_i
-        deltaw = nw - w
-        deltah = nh - h
-        if returnnew
-          [deltaw, deltah, nw, nh]
-        else
-          [deltaw, deltah]
-        end
-      end
-
-      def get_browser_coord(browser=nil, dbg=nil)
-        browser = @myBrowser if not browser
-        title = browser.title
-        x     = @ai.WinGetPosX(title)
-        y     = @ai.WinGetPosY(title)
-        w     = @ai.WinGetPosWidth(title)
-        h     = @ai.WinGetPosHeight(title)
-        if dbg
-          debug_to_log("\n\t\tBrowser #{browser.inspect}\n"+
-                           "\t\tdimensions:   x: #{w} y: #{h}"+
-                           "\t\tscreen offset x: #{x} y: #{y}")
-        end
-        [x, y, w, h]
-      end
-
-      def drag_and_drop(browser, how, what, delta_x, delta_y, desc = '')
-        #TODO: webdriver
-        msg = "Drag and drop element :#{how}=>#{what} by x=>#{delta_x} y=>#{delta_y}."
-        msg << " #{desc}" if desc.length > 0
-        drag_me = browser.div(how, what)
-        drag_me.drag_and_drop_by(delta_x, delta_y)
-        passed_to_log(msg)
-        true
-      rescue
-        failed_to_log("Unable to #{msg} '#{$!}'")
-      end
-
-      def drag_and_drop(x1, y1, dx, dy, speed=nil)
-        speed = 10 if not speed
-        x2 = x1 + dx
-        y2 = y1 + dy
-        debug_to_log("drag_and_drop: start: [#{x1}, #{y1}] end: [#{x2}, #{y2}]")
-
-        @ai.MouseMove(x1, y1, speed)
-        @ai.MouseClick("primary", x1, y1)
-        sleep_for(0.5)
-        @ai.MouseClick("primary", x1, y1)
-        sleep_for(0.5)
-        @ai.MouseClickDrag("primary", x1, y1, x2, y2, speed)
-      end
-
-      def drag_and_drop_element(browser, element, dx, dy, speed = nil)
-        speed = 10 if not speed
-        w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
-        msg                                  = "Move #{element} by [#{dx}, #{dy}] from center[#{xc1}, #{yc1}] "
-        newxc                                = xc1 + dx
-        newyc                                = yc1 + dy
-        msg << "to center[[#{newxc}, #{newyc}]"
-        sleep_for(0.5)
-
-        drag_and_drop(xc1, yc1, dx, dy)
-
-        sleep_for(1)
-        w2, h2, x2, y2, xc2, yc2, xlr2, ylr2 = get_element_coordinates(browser, element, true)
-
-        # TODO This adjustment is adhoc and empirical. Needs to be derived more rigorously
-        xcerr                                = xc2 - xc1
-        ycerr                                = yc2 - yc1
-
-        debug_to_log("\n" +
-                         "\t\t   xc1: #{xc1}\n" +
-                         "\t\t   yc1: #{yc1}\n" +
-                         "\t\t   xc2: #{xc2}\n" +
-                         "\t\t   yc2: #{yc2}\n" +
-                         "\t\t xcerr: #{xlrerr}\n" +
-                         "\t\t ycerr: #{ylrerr}\n" +
-                         "\t\t x tol: #{@x_tolerance}\n" +
-                         "\t\t y tol: #{@y_tolerance}\n"
-        )
-
-        #TODO Add check that window _was_ resized.
-        x_ok, x_msg = validate_drag_drop(xcerr, @x_tolerance, newxc, xc2)
-        y_ok, y_msg = validate_drag_drop(ycerr, @y_tolerance, newyc, yc2)
-        msg         = msg + "x: #{x_msg}, y: #{y_msg}"
-
-        if x_ok and y_ok
-          passed_to_log(msg)
-        else
-          failed_to_log(msg)
-        end
-        sleep_for(1)
-      rescue
-        failed_to_log("Unable to validate drag and drop. #{$!} (#{__LINE__})")
-        sleep_for(1)
-      end
-
-      def right_click(element)
-        x = element.left_edge_absolute + 2
-        y = element.top_edge_absolute + 2
-        @ai.MouseClick("secondary", x, y)
-      end
-
-      def left_click(element)
-        x = element.left_edge_absolute + 2
-        y = element.top_edge_absolute + 2
-        @ai.MouseClick("primary", x, y)
-      end
-
-      def screen_offset(element, browser=nil)
-        bx, by, bw, bh = get_browser_coord(browser)
-        ex             = element.left_edge
-        ey             = element.top_edge
-        [bx + ex, by + ey]
-      end
-
-      def screen_center(element, browser=nil)
-        bx, by, bw, bh = get_browser_coord(browser)
-        w, h           = element.dimensions.to_a
-        cx             = bx + w/2
-        cy             = by + h/2
-        [cx, cy]
-      end
-
-      def screen_lower_right(element, browser=nil)
-        bx, by, bw, bh = get_browser_coord(browser)
-        w, h           = element.dimensions.to_a
-        [bx + w, by + h]
-      end
-
-      def verify_resize(d, err, tol, min, act)
-        ary = [false, "failed, actual #{act} err #{err}"]
-        if err == 0
-          ary = [true, 'succeeded ']
-          #TODO need to find way to calculate this adjustment
-        elsif d <= min + 4
-          ary = [true, "reached minimum (#{min}) "]
-        elsif err.abs <= tol
-          ary = [true, "within tolerance (+-#{tol}px) "]
-        end
-        ary
-      end
-
-      alias validate_move verify_resize
-      alias validate_resize verify_resize
-
-      def validate_drag_drop(err, tol, exp, act)
-        ary = [false, "failed, expected: #{exp}, actual: #{act}, err: #{err}"]
-        if err == 0
-          ary = [true, 'succeeded ']
-        elsif err.abs <= tol
-          ary = [true, "within tolerance (+-#{tol}px) "]
-        end
-        ary
-      end
-
-    end
-  end
-end
-
+module Awetestlib
+  module Regression
+    # Methods for moving and resizing elements, manipulating the mouse, and checking for relative positioning of elements,
+    # including overlap, overlay, etc.
+    # @note Still experimental. Works with IE but not fully tested with Firefox or Chrome in Windows using Watir-webdriver.
+    #   Not compatible with Mac
+    #   Rdoc is work in progress
+    module DragAndDrop
+
+      # Verify that specified *inner_element* is fully enclosed by *outer_element*.
+      # @param [Watir::Element] inner_element A reference to a DOM element
+      # @param [Watir::Element] outer_element A reference to a DOM element
+      # @param [String] desc Contains a message or description intended to appear in the log and/or report output
+      def verify_element_inside(inner_element, outer_element, desc = '')
+        mark_testlevel("#{__method__.to_s.titleize}", 3)
+        msg = build_message("#{inner_element.class.to_s} (:id=#{inner_element.id}) is fully enclosed by "+
+                            "#{outer_element.class.to_s} (:id=#{outer_element.id}).", desc)
+        if overlay?(inner_element, outer_element, :inside)
+          failed_to_log(msg)
+        else
+          passed_to_log(msg)
+          true
+        end
+      rescue
+        failed_to_log("Unable to verify that #{msg} '#{$!}'")
+      end
+
+      # Verify that two elements, identified by specified attribute and value, do not overlap on a given *side*.
+      # @param [Symbol] above_element The element type for the first element, e.g. :div, :span, etc.
+      # @param [Symbol] above_how The element attribute used to identify the *above_element*.
+      #   Valid values depend on the kind of element.
+      #   Common values: :text, :id, :title, :name, :class, :href (:link only)
+      # @param [String, Regexp] above_what A string or a regular expression to be found in the *above_how* attribute that uniquely identifies the element.
+      # @param [Symbol] below_element The element type for the second element, e.g. :div, :span, etc.
+      # @param [Symbol] below_how The element attribute used to identify the *below_element*.
+      # @param [String, Regexp] below_what A string or a regular expression to be found in the *below_how* attribute that uniquely identifies the element.
+      # @param [Symbol] side :top, :bottom, :left, :right, :inside, or :outside
+      # @param [String] desc Contains a message or description intended to appear in the log and/or report output
+      def verify_no_element_overlap(browser, above_element, above_how, above_what, below_element, below_how, below_what, side, desc = '')
+        mark_testlevel("#{__method__.to_s.titleize}", 3)
+        msg = build_message("#{above_element.to_s.titleize} #{above_how}=>#{above_what} does not overlap "+
+                            "#{below_element.to_s.titleize} #{below_how}=>#{below_what} at the #{side}.", desc)
+        above = browser.element(above_how, above_what)
+        below = browser.element(below_how, below_what)
+        if overlay?(above, below, side)
+          failed_to_log(msg)
+        else
+          passed_to_log(msg)
+          true
+        end
+      rescue
+        failed_to_log("Unable to verify that #{msg} '#{$!}'")
+      end
+
+      def overlay?(inner, outer, side = :bottom)
+        #mark_testlevel("#{__method__.to_s.titleize}", 3)
+        inner_t, inner_b, inner_l, inner_r = inner.bounding_rectangle_offsets
+        outer_t, outer_b, outer_l, outer_r = outer.bounding_rectangle_offsets
+        #overlay = false
+        case side
+          when :bottom
+            overlay = inner_b > outer_t
+          when :top
+            overlay = inner_t > outer_t
+          when :left
+            overlay = inner_l < outer_r
+          when :right
+            overlay = inner_r > outer_r
+          when :inside
+            overlay = !(inner_t > outer_t and
+                inner_r < outer_r and
+                inner_l > outer_l and
+                inner_b < outer_b)
+          else
+            overlay = (inner_t > outer_b or
+                inner_r > outer_l or
+                inner_l < outer_r or
+                inner_b < outer_t)
+        end
+        overlay
+      rescue
+        failed_to_log("Unable to determine overlay. '#{$!}'")
+      end
+
+      def hover(browser, element, wait = 2)
+        w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
+        @ai.MoveMouse(xc1, yc1)
+        sleep_for(1)
+      end
+
+      def move_element_with_handle(browser, element, handle_id, dx, dy)
+        #    msg = "Move element "
+        #    w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
+        #    newx   = w1 + dx
+        #    newy   = h1 + dy
+        #    msg << " by [#{dx}, #{dy}] to expected [[#{newx}, #{newy}] "
+        #    handle = get_resize_handle(element, handle_id)
+        #    hw, hh, hx, hy, hxc, hyc, hxlr, hylr  = get_element_coordinates(browser, handle, true)
+
+        #    drag_and_drop(hxc, hyc, dx, dy)
+
+        #    w2, h2, x2, y2, xc2, yc2, xlr2, ylr2 = get_element_coordinates(browser, element, true)
+
+        #    xerr = x2 - newx
+        #    yerr = y2 - newy
+        #    xdsp = (x1 - x2).abs
+        #    ydsp = (y1 - y2).abs
+
+        #    if x2 == newx and y2 == newy
+        #      msg << "succeeded."
+        #      passed_to_log(msg)
+        #    else
+        #      msg << "failed. "
+        #      failed_to_log(msg)
+        #      debug_to_log("x: actual #{x2}, error #{xerr}, displace #{xdsp}. y: actual #{y2}, error #{yerr}, displace #{ydsp}.")
+        #    end
+
+      end
+
+      def resize_element_with_handle(browser, element, target, dx, dy=nil)
+        #TODO enhance to accept differing percentages in each direction
+        msg                                  = "Resize element "
+        w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
+        if dy
+          deltax = dx
+          deltay = dy
+          neww   = w1 + dx
+          newh   = h1 + dy
+          msg << " by [#{dx}, #{dy}] " #"" to expected dimension [#{neww}, #{newh}] "
+        else
+          deltax, deltay, neww, newh = adjust_dimensions_by_percent(w1, h1, dx, true)
+          msg << "by #{dx} percent " #"" to expected dimension [#{neww}, #{newh}] "
+        end
+        handle = get_resize_handle_by_class(element, target) #, true)
+        sleep_for(0.5)
+        hw, hh, hx, hy, hxc, hyc, hxlr, hylr = get_element_coordinates(browser, handle, true)
+        hxlr_diff                            = 0
+        hylr_diff                            = 0
+
+        # TODO These adjustments are adhoc and empirical. Need to be derived more rigorously
+        if @browserAbbrev == 'IE'
+          hxlr_diff = (xlr1 - hxlr)
+          hylr_diff = (ylr1 - hylr)
+          x_start   = hxlr - 2
+          y_start   = hylr - 2
+        else
+          hxlr_diff = (xlr1 - hxlr) / 2 unless (xlr1 - hxlr) == 0
+          hylr_diff = (ylr1 - hylr) / 2 unless (ylr1 - hylr) == 0
+          x_start = hxlr
+          y_start = hylr
+        end
+
+        newxlr = xlr1 + deltax
+        newylr = ylr1 + deltay
+        #    msg << ", lower right [#{newxlr}, #{newylr}] - "
+        sleep_for(0.5)
+
+        drag_and_drop(x_start, y_start, deltax, deltay)
+
+        sleep_for(1.5)
+        w2, h2, x2, y2, xc2, yc2, xlr2, ylr2 = get_element_coordinates(browser, element, true)
+
+        werr   = w2 - neww
+        herr   = h2 - newh
+
+        # TODO This adjustment is adhoc and empirical. Needs to be derived more rigorously
+        xlrerr = xlr2 - newxlr + hxlr_diff
+        ylrerr = ylr2 - newylr + hylr_diff
+
+        xlrdsp = (xlr1 - xlr2).abs
+        ylrdsp = (ylr1 - ylr2).abs
+
+        debug_to_log("\n" +
+                         "\t\t  hxlr_diff: #{hxlr_diff}\n" +
+                         "\t\t  hylr_diff: #{hylr_diff}\n" +
+                         "\t\t       werr: #{werr}\n" +
+                         "\t\t       herr: #{herr}\n" +
+                         "\t\t     xlrerr: #{xlrerr}\n" +
+                         "\t\t     ylrerr: #{ylrerr}\n" +
+                         "\t\t     xlrdsp: #{xlrdsp}\n" +
+                         "\t\t     ylrdsp: #{ylrdsp}\n" +
+                         "\t\t @min_width: #{@min_width}\n" +
+                         "\t\t@min_height: #{@min_height}\n" +
+                         "\t\t      x tol: #{@x_tolerance}\n" +
+                         "\t\t      y tol: #{@y_tolerance}\n"
+        )
+
+        #TODO Add check that window _was_ resized.
+        x_ok, x_msg = validate_move(w2, xlrerr, @x_tolerance, @min_width, xlr2)
+        y_ok, y_msg = validate_move(h2, ylrerr, @y_tolerance, @min_height, ylr2)
+        msg         = msg + "x: #{x_msg}, y: #{y_msg}"
+
+        if x_ok and y_ok
+          passed_to_log(msg)
+        else
+          failed_to_log(msg)
+          debug_to_log("x - actual #{xlr2}, error #{xlrerr}, displace #{xlrdsp}, y - actual #{ylr2}, error #{ylrerr}, displace #{ylrdsp}.")
+        end
+        sleep_for(1)
+      rescue
+        failed_to_log("Unable to validate resize. #{$!} (#{__LINE__})")
+        sleep_for(1)
+      end
+
+    # :category: GUI
+      def get_resize_handle_by_id(element, id, dbg=nil)
+        handle = get_div_by_id(element, id, dbg)
+        sleep_for(1)
+        handle.flash(5)
+        return handle
+      end
+
+    # :category: GUI
+      def get_resize_handle_by_class(element, strg, dbg=nil)
+        handle = get_div_by_class(element, strg, dbg)
+        sleep_for(0.5)
+        handle.flash(5)
+        return handle
+      end
+
+    # :category: GUI
+      def get_element_coordinates(browser, element, dbg=nil)
+        bx, by, bw, bh = get_browser_coord(browser, dbg)
+        if @browserAbbrev == 'IE'
+          x_hack = @horizontal_hack_ie
+          y_hack = @vertical_hack_ie
+        elsif @browserAbbrev == 'FF'
+          x_hack = @horizontal_hack_ff
+          y_hack = @vertical_hack_ff
+        end
+        sleep_for(1)
+        w, h   = element.dimensions.to_a
+        xc, yc = element.client_offset.to_a
+        #    xcc, ycc = element.client_center.to_a
+        xcc    = xc + w/2
+        ycc    = yc + h/2
+        # screen offset:
+        xs     = bx + x_hack + xc - 1
+        ys     = by + y_hack + yc - 1
+        # screen center:
+        xsc    = xs + w/2
+        ysc    = ys + h/2
+        xslr   = xs + w
+        yslr   = ys + h
+        if dbg
+          debug_to_log(
+              "\n\t\tElement: #{element.inspect}"+
+                  "\n\t\tbrowser screen offset: x: #{bx} y: #{by}"+
+                  "\n\t\t           dimensions: x: #{w} y: #{h}"+
+                  "\n\t\t         client offset x: #{xc} y: #{yc}"+
+                  "\n\t\t         screen offset x: #{xs} y: #{ys}"+
+                  "\n\t\t         client center x: #{xcc} y: #{ycc}"+
+                  "\n\t\t         screen center x: #{xsc} y: #{ysc}"+
+                  "\n\t\t    screen lower right x: #{xslr} y: #{yslr}")
+        end
+        [w, h, xs, ys, xsc, ysc, xslr, yslr]
+      end
+
+      def adjust_dimensions_by_percent(w, h, p, returnnew=nil)
+        p      += 100
+        nw     = (w * (p/100.0)).to_i
+        nh     = (h * (p/100.0)).to_i
+        deltaw = nw - w
+        deltah = nh - h
+        if returnnew
+          [deltaw, deltah, nw, nh]
+        else
+          [deltaw, deltah]
+        end
+      end
+
+      def get_browser_coord(browser=nil, dbg=nil)
+        browser = @myBrowser if not browser
+        title = browser.title
+        x     = @ai.WinGetPosX(title)
+        y     = @ai.WinGetPosY(title)
+        w     = @ai.WinGetPosWidth(title)
+        h     = @ai.WinGetPosHeight(title)
+        if dbg
+          debug_to_log("\n\t\tBrowser #{browser.inspect}\n"+
+                           "\t\tdimensions:   x: #{w} y: #{h}"+
+                           "\t\tscreen offset x: #{x} y: #{y}")
+        end
+        [x, y, w, h]
+      end
+
+      def drag_and_drop_div(browser, how, what, delta_x, delta_y, desc = '')
+        #TODO: webdriver
+        #TODO: assumes element is div
+        msg = "Drag and drop element :#{how}=>#{what} by x=>#{delta_x} y=>#{delta_y}."
+        msg << " #{desc}" if desc.length > 0
+        drag_me = browser.div(how, what)
+        drag_me.drag_and_drop_by(delta_x, delta_y)
+        passed_to_log(msg)
+        true
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def drag_and_drop(x1, y1, dx, dy, speed=nil)
+        speed = 10 if not speed
+        x2 = x1 + dx
+        y2 = y1 + dy
+        debug_to_log("drag_and_drop: start: [#{x1}, #{y1}] end: [#{x2}, #{y2}]")
+
+        @ai.MouseMove(x1, y1, speed)
+        @ai.MouseClick("primary", x1, y1)
+        sleep_for(0.5)
+        @ai.MouseClick("primary", x1, y1)
+        sleep_for(0.5)
+        @ai.MouseClickDrag("primary", x1, y1, x2, y2, speed)
+      end
+
+      def drag_and_drop_element(browser, element, dx, dy, speed = nil)
+        speed = 10 if not speed
+        w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
+        msg                                  = "Move #{element} by [#{dx}, #{dy}] from center[#{xc1}, #{yc1}] "
+        newxc                                = xc1 + dx
+        newyc                                = yc1 + dy
+        msg << "to center[[#{newxc}, #{newyc}]"
+        sleep_for(0.5)
+
+        drag_and_drop(xc1, yc1, dx, dy)
+
+        sleep_for(1)
+        w2, h2, x2, y2, xc2, yc2, xlr2, ylr2 = get_element_coordinates(browser, element, true)
+
+        # TODO This adjustment is adhoc and empirical. Needs to be derived more rigorously
+        xcerr                                = xc2 - xc1
+        ycerr                                = yc2 - yc1
+
+        debug_to_log("\n" +
+                         "\t\t   xc1: #{xc1}\n" +
+                         "\t\t   yc1: #{yc1}\n" +
+                         "\t\t   xc2: #{xc2}\n" +
+                         "\t\t   yc2: #{yc2}\n" +
+                         "\t\t xcerr: #{xlrerr}\n" +
+                         "\t\t ycerr: #{ylrerr}\n" +
+                         "\t\t x tol: #{@x_tolerance}\n" +
+                         "\t\t y tol: #{@y_tolerance}\n"
+        )
+
+        #TODO Add check that window _was_ resized.
+        x_ok, x_msg = validate_drag_drop(xcerr, @x_tolerance, newxc, xc2)
+        y_ok, y_msg = validate_drag_drop(ycerr, @y_tolerance, newyc, yc2)
+        msg         = msg + "x: #{x_msg}, y: #{y_msg}"
+
+        if x_ok and y_ok
+          passed_to_log(msg)
+        else
+          failed_to_log(msg)
+        end
+        sleep_for(1)
+      rescue
+        failed_to_log("Unable to validate drag and drop. #{$!} (#{__LINE__})")
+        sleep_for(1)
+      end
+
+      def right_click(element)
+        x = element.left_edge_absolute + 2
+        y = element.top_edge_absolute + 2
+        @ai.MouseClick("secondary", x, y)
+      end
+
+      def left_click(element)
+        x = element.left_edge_absolute + 2
+        y = element.top_edge_absolute + 2
+        @ai.MouseClick("primary", x, y)
+      end
+
+      def screen_offset(element, browser=nil)
+        bx, by, bw, bh = get_browser_coord(browser)
+        ex             = element.left_edge
+        ey             = element.top_edge
+        [bx + ex, by + ey]
+      end
+
+      def screen_center(element, browser=nil)
+        bx, by, bw, bh = get_browser_coord(browser)
+        w, h           = element.dimensions.to_a
+        cx             = bx + w/2
+        cy             = by + h/2
+        [cx, cy]
+      end
+
+      def screen_lower_right(element, browser=nil)
+        bx, by, bw, bh = get_browser_coord(browser)
+        w, h           = element.dimensions.to_a
+        [bx + w, by + h]
+      end
+
+      def verify_resize(d, err, tol, min, act)
+        ary = [false, "failed, actual #{act} err #{err}"]
+        if err == 0
+          ary = [true, 'succeeded ']
+          #TODO need to find way to calculate this adjustment
+        elsif d <= min + 4
+          ary = [true, "reached minimum (#{min}) "]
+        elsif err.abs <= tol
+          ary = [true, "within tolerance (+-#{tol}px) "]
+        end
+        ary
+      end
+
+      alias validate_move verify_resize
+      alias validate_resize verify_resize
+
+      def validate_drag_drop(err, tol, exp, act)
+        ary = [false, "failed, expected: #{exp}, actual: #{act}, err: #{err}"]
+        if err == 0
+          ary = [true, 'succeeded ']
+        elsif err.abs <= tol
+          ary = [true, "within tolerance (+-#{tol}px) "]
+        end
+        ary
+      end
+
+    end
+  end
+end
+