awetestlib 0.0.3-x86-mingw32 → 0.1.0-x86-mingw32

data/lib/regression/drag_and_drop.rb

@@ -0,0 +1,374 @@
+module DragAndDrop
+
+  def verify_element_inside(inner_element, outer_element, desc = '')
+    mark_testlevel("#{__method__.to_s.titleize}", 3)
+    msg = "#{inner_element.class.to_s} (:id=#{inner_element.id}) is fully enclosed by #{outer_element.class.to_s} (:id=#{outer_element.id})."
+    msg << " #{desc}" if desc.length > 0
+    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
+
+  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 = "#{above_element.to_s.titleize} #{above_how}=>#{above_what} does not overlap "+
+        "#{below_element.to_s.titleize} #{below_how}=>#{below_what} at the #{side}."
+    msg << " #{desc}" if desc.length > 0
+    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(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
+
+end

data/lib/regression/find.rb

@@ -0,0 +1,426 @@
+module Find
+
+  def get_select_list(browser, how, what, desc = '')
+    list = browser.select_list(how, what)
+    if validate(browser, @myName, __LINE__)
+      passed_to_log("Select list #{how}='#{what}' found and returned.")
+      return list
+    end
+  rescue
+    failed_to_log("Unable to return select list #{how}='#{what}': '#{$!}' (#{__LINE__})")
+  end
+
+  def get_select_options(browser, how, what, dump = false)
+    list = browser.select_list(how, what)
+    dump_select_list_options(list) if dump
+    list.options
+  rescue
+    failed_to_log("Unable to get select options for #{how}=>#{what}.  '#{$!}'")
+  end
+
+  def get_select_options_by_id(browser, strg, dump = false)
+    get_select_options(browser, :id, strg, dump)
+  end
+
+  def get_select_options_by_name(browser, strg, dump = false)
+    get_select_options(browser, :name, strg, dump)
+  end
+
+  def get_selected_options(browser, how, what)
+    begin
+      list = browser.select_list(how, what)
+    rescue => e
+      if not rescue_me(e, __method__, "browser.select_list(#{how}, '#{what}')", "#{browser.class}")
+        raise e
+      end
+    end
+    list.selected_options
+  end
+
+  def get_selected_options_by_id(browser, strg)
+    get_selected_options(browser, :id, strg)
+  end
+
+  alias get_selected_option_by_id get_selected_options_by_id
+
+  def get_selected_options_by_name(browser, strg)
+    get_selected_options(browser, :name, strg)
+  end
+
+  alias get_selected_option_by_name get_selected_options_by_name
+
+=begin rdoc
+  :category: A_rdoc_test
+Returns a reference to a division element.  Used to assign a div element to a variable
+which can then be passed to methods that require a *browser* parameter.
+
+_Parameters_::
+
+*browser* - a reference to the browser window or container element to be tested
+
+*how* - the element attribute used to identify the specific element. Valid values depend on the kind of element.
+Common values: :text, :id, :title, :name, :class, :href (:link only)
+
+*what* - a string or a regular expression to be found in the *how* attribute that uniquely identifies the element.
+
+*desc* - a string containing a message or description intended to appear in the log and/or report output
+
+_Example_
+
+  mainwindow = open_browser('www.myapp.com')  # open a browser to www.google.com
+  click(mainwindow, :button, :id, 'an id string')  # click a button that opens another browser window
+  popup = attach_browser(mainwindow, :url, '[url of new window]') *or*
+  popup = attach_browser(mainwindow, :title, '[title of new window]')
+
+=end
+
+  def get_div(browser, how, what, desc = '', dbg = false)
+    msg = "Get division #{how}=>#{what}."
+    msg << " #{desc}" if desc.length > 0
+    Watir::Wait.until { browser.div(how, what).exists? }
+    div = browser.div(how, what)
+    debug_to_log(div.inspect) if dbg
+    if validate(browser, @myName, __LINE__)
+      if div
+        passed_to_log(msg)
+        return div
+      else
+        failed_to_log(msg)
+      end
+    end
+  rescue
+    failed_to_log("Unable to '#{msg}' '#{$!}'")
+  end
+
+  def get_div_by_id(browser, strg, desc = '', dbg = false)
+    get_div(browser, :id, strg, desc, dbg)
+  end
+
+=begin rdoc
+  :category: A_rdoc_test
+Returns a reference to a division element identified by the value in its class attribute. Calls get_div()
+
+_Parameters_::
+
+*browser* - a reference to the browser window or container element to be tested
+
+*strg* - a string or a regular expression to be found in the *how* attribute that uniquely identifies the element.
+
+*desc* - a string containing a message or description intended to appear in the log and/or report output
+
+_Example_
+
+  mainwindow = open_browser('www.myapp.com')  # open a browser to www.google.com
+  click(mainwindow, :button, :id, 'an id string')  # click a button that opens another browser window
+  popup = attach_browser(mainwindow, :url, '[url of new window]') *or*
+  popup = attach_browser(mainwindow, :title, '[title of new window]')
+
+=end
+
+  def get_div_by_class(browser, strg, desc = '', dbg = false)
+    get_div(browser, :class, strg, desc, dbg)
+  end
+
+  def get_div_by_text(browser, strg, desc = '', dbg = false)
+    get_div(browser, :text, strg, desc, dbg)
+  end
+
+  def get_form(browser, how, strg)
+    begin
+      #       Watir::Wait.until( browser.form(how, strg).exists? )  # fails in wait_until
+    rescue => e
+      if not rescue_me(e, __method__, "browser.form(#{how}, '#{strg}').exists?", "#{browser.class}")
+        raise e
+      end
+    end
+    myForm = browser.form(how, strg)
+    if validate(browser, @myName, __LINE__)
+      passed_to_log("Form #{how}='#{strg}' found and returned.")
+      return myForm
+    end
+  rescue
+    failed_to_log("Unable to return form #{how}='#{strg}': '#{$!}' (#{__LINE__})")
+  end
+
+  def get_form_by_id(browser, strg)
+    get_form(browser, :id, strg)
+  end
+
+  def get_frame(browser, how, strg, desc = '')
+    #    begin
+    #      Watir::Wait.until(browser.frame(how, strg).exists?) # fails in wait_until
+    #    rescue => e
+    #      if not rescue_me(e, __method__, "browser.frame(#{how}, '#{strg}').exists?", "#{browser.class}")
+    #        raise e
+    #      end
+    #    end
+    begin
+      frame = browser.frame(how, strg)
+    rescue => e
+      if not rescue_me(e, __method__, "browser.frame(#{how}, '#{strg}').exists?", "#{browser.class}")
+        raise e
+      end
+    end
+    if validate(browser, @myName, __LINE__)
+      passed_to_log("Frame #{how}='#{strg}' found and returned. #{desc}")
+      return frame
+    end
+  rescue
+    failed_to_log("Unable to return frame #{how}='#{strg}'. #{desc}: '#{$!}' (#{__LINE__})")
+  end
+
+  def get_frame_by_id(browser, strg, desc = '')
+    get_frame(browser, :id, strg, desc)
+  end
+
+  def get_frame_by_index(browser, index, desc = '')
+    get_frame(browser, :index, index, desc)
+  end
+
+  def get_frame_by_name(browser, strg, desc = '')
+    get_frame(browser, :name, strg, desc)
+  end
+
+  def get_span(browser, how, strg, desc = '')
+    begin
+      #TODO: use LegacyExtensions#wait_until
+      Watir::Wait.until { browser.span(how, strg).exists? }
+    rescue => e
+      if not rescue_me(e, __method__, "browser.span(#{how}, '#{strg}').exists?", "#{browser.class}")
+        raise e
+      end
+    end
+    begin
+      span = browser.span(how, strg)
+    rescue => e
+      if not rescue_me(e, __method__, "browser.span(#{how}, '#{strg}').exists?", "#{browser.class}")
+        raise e
+      end
+    end
+    if validate(browser, @myName, __LINE__)
+      passed_to_log("Span #{how}='#{strg}' found and returned. #{desc}")
+      return span
+    end
+  rescue
+    failed_to_log("Unable to return span #{how}='#{strg}'. #{desc}: '#{$!}' (#{__LINE__})")
+  end
+
+  def get_span_by_id(browser, strg, desc = '')
+    get_span(browser, :id, strg, desc)
+  end
+
+=begin rdoc
+  :category: A_rdoc_test
+Returns a reference to a table element.  Used to assign a table element to a variable
+which can then be used directly or passed to methods that require a *browser* or *table* parameter.
+
+_Parameters_::
+
+*browser* - a reference to the browser window or container element to be tested
+
+*how* - the element attribute used to identify the specific element. Valid values depend on the kind of element.
+Common values: :text, :id, :title, :name, :class, :href (:link only)
+
+*what* - a string or a regular expression to be found in the *how* attribute that uniquely identifies the element.
+
+*desc* - a string containing a message or description intended to appear in the log and/or report output
+
+_Example_
+
+  a_table = get_table(browser, :id, 'table1')
+  a_table_cell = a_table[2][1]   # The cell in the first column of the second row of the table
+
+=end
+
+  def get_table(browser, how, what, desc = '')
+    msg = "Return table :#{how}='#{what}'. #{desc}"
+    tbl = browser.table(how, what)
+    if validate(browser, @myName, __LINE__)
+      passed_to_log(msg)
+      tbl
+    end
+  rescue
+    failed_to_log("#{msg}': '#{$!}'")
+  end
+
+  def get_table_by_id(browser, strg, desc = '')
+    get_table(browser, :id, strg, desc)
+  end
+
+  def get_table_by_index(browser, idx)
+    get_table(browser, :index, idx, desc)
+  end
+
+  def get_table_by_text(browser, strg)
+    get_table(browser, :text, strg, desc)
+  end
+
+  def get_table_headers(table, header_index = 1)
+    headers          = Hash.new
+    headers['index'] = Hash.new
+    headers['name']  = Hash.new
+    count            = 1
+    table[header_index].each do |cell|
+      if cell.text.length > 0
+        name                    = cell.text.gsub(/\s+/, ' ')
+        headers['index'][count] = name
+        headers['name'][name]   = count
+      end
+      count += 1
+    end
+    #debug_to_log("#{__method__}:****** headers:\n#{headers.to_yaml}")
+    headers
+  rescue
+    failed_to_log("Unable to get content headers. '#{$!}'")
+  end
+
+  def get_element(browser, element, how, what, value = nil)
+    target = nil
+    what = Regexp.new(Regexp.escape(what)) unless how == :index or what.is_a?(Regexp)
+    case element
+      when :link
+        target = browser.link(how, what)
+      when :button
+        target = browser.button(how, what)
+      when :div
+        target = browser.div(how, what)
+      when :checkbox
+        target = browser.checkbox(how, what, value)
+      when :text_field, :textfield
+        target = browser.text_field(how, what)
+      when :image
+        target = browser.image(how, what)
+      when :file_field, :filefield
+        target = browser.file_field(how, what)
+      when :form
+        target = browser.form(how, what)
+      when :frame
+        target = browser.frame(how, what)
+      when :radio
+        target = browser.radio(how, what, value)
+      when :span
+        target = browser.span(how, what)
+      when :table
+        target = browser.table(how, what)
+      when :li
+        target = browser.li(how, what)
+      when :select_list, :selectlist
+        target = browser.select_list(how, what)
+      when :hidden
+        target = browser.hidden(how, what)
+      when :area
+        target = browser.area(how, what)
+    end
+    if target.exists?
+      target
+    else
+      nil
+    end
+  rescue => e
+    if not rescue_me(e, __method__, "browser.#{element}(#{how}, '#{what}')", "#{browser.class}", target)
+      raise e
+    end
+  end
+
+  def get_objects(browser, which, dbg=false)
+    cnt = 0
+    case which
+      when :links
+        list = browser.links
+        sleep(1)
+      when :tables
+        list = browser.tables
+      when :divs
+        list = browser.divs
+      when :buttons
+        list = browser.buttons
+      when :checkboxes
+        list = browser.checkboxes
+      when :radios
+        list = browser.radios
+      when :selectlists
+        list = browser.selectlists
+      when :textfields
+        list = browser.textfields
+      when :lis
+        list = browser.lis
+      else
+        debug_to_log("Unrecognized dom object '#{which}'")
+    end
+    if dbg
+      list.each do |obj|
+        cnt += 1
+        debug_to_log("\n==========#{which}:\nindex:     #{cnt}\n#{obj}\n#{obj.to_yaml}")
+      end
+    end
+    list
+  end
+
+  def get_ole(element)
+    ole = element.ole_object
+    if ole
+      passed_to_log("Found ole_object for #{element}.")
+      ole
+    else
+      failed_to_log("Did not find ole_object for #{element}.")
+    end
+  rescue
+    failed_to_log("Unable to find ole_object for #{element}.  #{$!}")
+  end
+
+  def find_all_links_with_exact_href(browser, href)
+    links = browser.links
+    hash  = Hash.new
+    idx   = 0
+    links.each do |l|
+      idx     += 1
+      an_href = href
+      my_href = l.href
+      if my_href == an_href
+        hash[idx] = l
+        debug_to_log("#{__method__}:#{idx}\n********\n#{l.to_s}\n\n#{l.to_yaml}")
+      end
+    end
+    hash
+  end
+
+  def find_link_with_exact_href(browser, href)
+    links = browser.links
+    link  = nil
+    index = 0
+    links.each do |l|
+      index   += 1
+      an_href = href
+      my_href = l.href
+      if my_href == an_href
+        link = l
+#        debug_to_log("#{__method__}:#{__LINE__}\n********\n#{l.to_s}\n\n#{l.to_yaml}")
+        break
+      end
+    end
+    link
+  end
+
+  def find_index_for_object(browser, obj, how, ord, strg)
+    obj_sym = (obj.to_s.pluralize).to_sym
+    how_str = how.to_s
+    ptrn    = /#{how}:\s+#{strg}/i
+    list    = get_objects(browser, obj_sym, true)
+    cnt     = 0
+    idx     = 0
+    list.each do |nty|
+      s = nty.to_s
+      #      a    = nty.to_a
+      if s =~ ptrn
+        cnt += 1
+        if cnt == ord
+          break
+        end
+      end
+      idx += 1
+    end
+    idx
+  end
+
+
+end