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

data/lib/regression/legacy.rb

@@ -1,2423 +1,5 @@
 module Legacy
 
-  def run
-    setup
-    set_script_variables
-    run_test
-  rescue
-    fatal_to_log("(#{__LINE__})  #{$!}")
-    browser.close
-    raise
-  end
-
-  # Place holder to prevent method not found error in scripts
-  def set_script_variables
-  # TODO: replace with method_missing?
-  end
-
-  def setup
-    #    if @os_sysname =~ /Windows.+Server\s+2003/
-    ##  'Microsoft(R) Windows(R) Server 2003, Enterprise Edition'
-    #      @vertical_hack_ie   = 110
-    #      @vertical_hack_ff   = 138
-    #      @horizontal_hack_ie = 5
-    #      @horizontal_hack_ff = 4
-    #    elsif @os_sysname =~ /Windows XP Professional/
-    #  'Microsoft Windows XP Professional'
-    @vertical_hack_ie        = 118
-    @vertical_hack_ff        = 144
-    @horizontal_hack_ie      = 5
-    @horizontal_hack_ff      = 4
-    #end
-
-    @settings_display_ids    = Hash[
-        "Currency"       => "row-currencyName",
-        "Description"    => "row-description",
-        "Tx Date"        => "row-fmtDate",
-        "Total"          => "row-amount",
-        "[currencyCode]" => "row-currencyCode",
-        "Date in Millis" => "row-dateInMilliseconds",
-    ]
-    @column_data_display_ids = Hash[
-        "Currency"       => "yui-dt0-th-currencyName",
-        "Description"    => "yui-dt0-th-description",
-        "Tx Date"        => "yui-dt0-th-fmtDate",
-        "Total"          => "yui-dt0-th-fmtDate",
-        "[currencyCode]" => "yui-dt0-th-currencyCode",
-        "Date in Millis" => "yui-dt0-th-dateInMilliseconds",
-    ]
-    @settings_panel_index    = 0
-    @x_tolerance             = 4
-    @y_tolerance             = 4
-  end
-
-# :category: Waits
-  def sleep_for(seconds, dbg = true, desc = '')
-    msg = "Sleeping for #{seconds} seconds."
-    msg << " #{desc}" if desc.length > 0
-    msg << "\n#{get_debug_list}" if dbg
-    info_to_log(msg)
-    sleep(seconds)
-  end
-
-# :category: Helpers
-  def get_mdyy(t = Time.now)
-    "#{t.month}/#{t.day}/#{t.year}"
-  end
-
-# :category: Helpers
-  def get_prefix(strg, offset)
-    a_slice = strg.slice(0, offset)
-    a_slice.downcase
-  end
-
-# :category: Helpers
-  def get_timestamp(format = 'long', offset = nil, offset_unit = :years)
-    t = DateTime.now
-    if offset
-      t = t.advance(offset_unit => offset)
-    end
-    case format
-      when 'dateonly'
-        t.strftime("%m/%d/%Y")
-      when 'condensed'
-        t.strftime("%Y%m%d%H%M")
-      when 'condensed_seconds'
-        t.strftime("%Y%m%d%H%M%S")
-      when 'long'
-        t.strftime("%m/%d/%Y %I:%M %p")
-      when 'mdyy'
-        get_mdyy(t)
-      when 'm/d/y'
-        get_mdyy(t)
-      else
-        Time.now.strftime("%m/%d/%Y %H:%M:%S")
-    end
-  end
-
-  def token_auth(browser, role, token, id = 'token_pass')
-    set_textfield_by_id(browser, id, token)
-    click_button_by_value(browser, 'Continue')
-    if validate_text(browser, 'The requested page requires authentication\.\s*Please enter your Passcode below', nil, true)
-      bail_out(browser, __LINE__, "Token authorization failed on '#{token}'")
-    end
-  end
-
-# :category: Helpers
-  def calc_index(index, every = 1)
-    (index / every) + (every - 1)
-  end
-
-=begin rdoc
-:category: Page Data
-:tags: data, DOM, page
-
-*browser* is any container element.  Best to use is the smallest that contains the desired data.
-
-*types* defaults to all of: :text, :textarea, :select_list, :span, :hidden, :checkbox, and :radio.
-Set types to array of subset of these if fewer elements are desired.
-
-No positive validations are reported but failure is rescued and reported.
-=end
-  def capture_page_data(browser, types = [:text, :textarea, :select_list, :span, :hidden, :checkbox, :radio])
-    start = Time.now
-    debug_to_log("Begin #{__method__}")
-    data         = Hash.new
-    data[:id]    = Hash.new
-    data[:name]  = Hash.new
-    data[:index] = Hash.new
-    types.each do |type|
-      #debug_to_log("#{__method__}: #{type}. . .")
-      data[:id][type], data[:name][type], data[:index][type] = parse_elements(browser, type)
-    end
-    data
-  rescue
-    failed_to_log("#{__method__}: '#{$!}'")
-  ensure
-    stop = Time.now
-    passed_to_log("#{__method__.to_s.titleize} finished. (#{"%.5f" % (stop - start)} secs)")
-    #debug_to_log("End #{__method__}")
-  end
-
-  def compare_page_data(before, after, how, desc = '')
-    [:text, :textarea, :select_list, :span, :checkbox, :radio].each do |type|
-      before[how][type].each_key do |what|
-        msg = "#{desc} #{type} #{how}=#{what}: Expected '#{before[how][type][what]}'."
-        if after[how][type][what] == before[how][type][what]
-          passed_to_log(msg)
-        else
-          failed_to_log("#{msg} Found '#{after[how][type][what]}'")
-        end
-      end
-    end
-  rescue
-    failed_to_log("Unable to compare before and after page data. '#{$!}'")
-  end
-
-=begin rdoc
-:category: Page Data
-:tags:data, DOM
-
-*data* is output of capture_page_data().
-
-*how* is one of :id, :name, :index
-
-*what* is the target value for how
-
-*type* is one of :text,:textarea,:select_list,:span,:hidden,:checkbox,:radio
-
-*get_text* is used for select_list to choose selected option value or text (default)
-
-Note that multiple selections will be captured as arrays so value and text.
-
-=end
-  def fetch_page_data(data, how, what, type, get_text = true)
-    rslt = data[how][type][what]
-    if type == :select_list
-      value, text = rslt.split('::')
-      if get_text
-        rslt = text
-      else
-        rslt = value
-      end
-    end
-    rslt
-  end
-
-# :category: Helpers
-  def capture_screen(browser, ts)
-    browser.maximize
-    browser.bring_to_front
-    caller = get_caller
-    caller.match(/:(\d+):/)
-    lnbr       = $1
-    path       = "#{@myRoot}/screenshot/"
-    screenfile = "#{@myName}_#{@myRun.id}_#{lnbr.to_s}_#{ts.to_f.to_s}.scrsht.jpg"
-    info_to_log("path:#{path} screenfile:#{screenfile}")
-    screenSpec = '"' + path + screenfile + '"'
-    screenSpec.gsub!('/', '\\')
-    screen_capture(screenSpec)
-    screenfile
-  end
-
-# :category: Helpers
-  def bail_out(browser, lnbr, msg)
-    ts  = Time.new
-    msg = "Bailing out at util line #{lnbr} #{ts} " + msg
-    puts "#{msg}"
-    fatal_to_log(msg, nil, 1, lnbr)
-    debug_to_log(dump_caller(lnbr))
-    if is_browser?(browser)
-      if @browserAbbrev == 'IE'
-        hwnd = browser.hwnd
-        kill_browser(hwnd, lnbr, browser)
-        raise(RuntimeError, msg, caller)
-      elsif @browserAbbrev == 'FF'
-        debug_to_log("#{browser.inspect}")
-        debug_to_log("#{browser.to_s}")
-        raise(RuntimeError, msg, caller)
-      end
-    end
-    @status = 'bailout'
-    raise(RuntimeError, msg, caller)
-  end
-
-# :category: Helpers
-  def parse_cookies(browser)
-    cookies = Hash.new
-    strg    = browser.document.cookie
-    ary     = strg.split(';')
-    ary.each do |c|
-      key, value          = c.split('=')
-      cookies[key.lstrip] = value
-    end
-    cookies
-  end
-
-=begin rdoc
-:category: Page Data
-:tags:data, DOM
-
-*browser* is any container element.  best to use is the smallest that contains the desired data.
-
-*type* is one of these symbols: :text,:textarea,:select_list,:span,:hidden,:checkbox,:radio
-
-Returns three hashes: id[type][id] = value, name[type][id] = value, index[type][id] = value
-
-A given element appears once in the set of hashes depending on how is is found: id first
-then name, then index.
-
-Select list value is in the form 'value::text'. parse with x.split('::')
-
-No positive validations are reported but failure is rescued and reported.
-=end
-  def parse_elements(browser, type)
-    id    = Hash.new
-    name  = Hash.new
-    index = Hash.new
-    idx   = 0
-    #debug_to_log("#{__method__}: #{type}")
-    case type
-      when :span
-        collection = browser.spans
-      when :select_list
-        collection = browser.select_lists
-      when :radio
-        collection = browser.radios
-      when :checkbox
-        collection = browser.checkboxes
-      else
-        collection = browser.elements(:type, type.to_s)
-    end
-    #debug_to_log("#{__method__}: collection: #{collection.inspect}")
-    collection.each do |e|
-      case type
-        when :span
-          vlu = e.text
-        when :select_list
-          vlu = "#{e.value}::#{e.selected_options[0]}"
-        when :radio
-          vlu = e.set?
-        when :checkbox
-          vlu = e.set?
-        else
-          vlu = e.value
-      end
-      idx += 1
-      if e.id.length > 0 and not e.id =~ /^__[A-Z]/
-        id[e.id] = vlu
-      elsif e.name.length > 0 and not e.name =~ /^__[A-Z]/
-        name[e.name] = vlu
-      else
-        index[idx] = vlu if not type == :hidden
-      end
-    end
-    [id, name, index]
-
-  rescue
-    failed_to_log("#{__method__}: '#{$!}'")
-  end
-
-  # :category: GUI
-  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
-
-  # :category: GUI
-  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
-
-  # :category: GUI
-  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
-
-  # :category: Page Data
-  def pdf_to_text(file, noblank = true)
-    spec = file.sub(/\.pdf$/, '')
-    `pdftotext #{spec}.pdf`
-    file = File.new("#{spec}.txt")
-    text = []
-    file.readlines.each do |l|
-      l.chomp! if noblank
-      if l.length > 0
-        text << l
-      end
-    end
-    file.close
-    text
-  end
-
-# :category: Bullet-Proofing
-  def kill_browser(hwnd, lnbr, browser = nil, doflag = false)
-    # TODO Firefox
-    logit = false
-    if @browserAbbrev == 'FF'
-      if is_browser?(browser) # and browser.url.length > 1
-        logit = true
-        here  = __LINE__
-        url   = browser.url
-        capture_screen(browser, Time.new.to_f) if @screenCaptureOn
-        browser.close if url.length > 0
-        @status = 'killbrowser'
-        fatal_to_log("Kill browser called from line #{lnbr}")
-      end
-    elsif hwnd
-      pid = Watir::IE::Process.process_id_from_hwnd(hwnd)
-      if pid and pid > 0 and pid < 538976288
-        if browser.exists?
-          here  = __LINE__
-          logit = true
-          url   = browser.url
-          capture_screen(browser, Time.new.to_f) if @screenCaptureOn
-          browser.close
-          sleep(2)
-          if browser.exists?
-            do_taskkill(FATAL, pid)
-          end
-          @status = 'killbrowser'
-        end
-      end
-      if logit
-        debug_to_log("#{@browserName} window hwnd #{hwnd} pid #{pid} #{url} (#{here})")
-        fatal_to_log("Kill browser called from line #{lnbr}")
-      end
-    end
-  end
-
-# :category: Bullet-Proofing
-  def do_taskkill(severity, pid)
-    if pid and pid > 0 and pid < 538976288
-      info_to_log("Executing taskkill for pid #{pid}")
-      log_message(severity, %x[taskkill /t /f /pid #{pid}])
-    end
-  rescue
-    error_to_log("#{$!}  (#{__LINE__})")
-  end
-
-# :category: Bullet-Proofing
-  def check_for_other_browsers
-    cnt1 = find_other_browsers
-    cnt2 = Watir::Process.count 'iexplore.exe'
-    debug_to_log("check_for_other_browsers: cnt1: #{cnt1} cnt2: #{cnt2}")
-  rescue
-    error_to_log("#{$!}  (#{__LINE__})\n#{Kernel.caller.to_yaml}")
-  end
-
-# :category: Bullet-Proofing
-  def check_for_and_clear_other_browsers
-    if @targetBrowser.abbrev == 'IE'
-      debug_to_log("#{__method__}:")
-      cnt1 = find_other_browsers
-      cnt2 = Watir::IE.process_count
-      debug_to_log("#{__method__}: cnt1: #{cnt1} cnt2: #{cnt2}")
-      begin
-        Watir::IE.each do |ie|
-          pid = Watir::IE::Process.process_id_from_hwnd(ie.hwnd)
-          debug_to_log("#{__method__}: Killing browser process: hwnd #{ie.hwnd} pid #{pid} title '#{ie.title}' (#{__LINE__})")
-          do_taskkill(INFO, pid)
-          sleep_for(10)
-        end
-        #Watir::IE.close_all()
-      rescue
-        debug_to_log("#{__method__}: #{$!}  (#{__LINE__})")
-      end
-      sleep(3)
-      cnt1 = find_other_browsers
-      cnt2 = Watir::IE.process_count
-      if cnt1 > 0 or cnt2 > 0
-        debug_to_log("#{__method__}:cnt1: #{cnt1} cnt2: #{cnt2}")
-        begin
-          Watir::IE.each do |ie|
-            pid = Watir::IE::Process.process_id_from_hwnd(ie.hwnd)
-            debug_to_log("#{__method__}: Killing browser process: hwnd #{ie.hwnd} pid #{pid} title '#{ie.title}' (#{__LINE__})")
-            do_taskkill(INFO, pid)
-            sleep_for(10)
-          end
-          #Watir::IE.close_all()
-        rescue
-          debug_to_log("#{__method__}:#{$!}  (#{__LINE__})")
-        end
-      end
-    end
-  rescue
-    error_to_log("#{__method__}: #{$!}  (#{__LINE__})\n#{Kernel.caller.to_yaml}")
-  end
-
-  #--
-    #def attach_browser(browser, how, what)
-    #  debug_to_log("Attaching browser window :#{how}=>'#{what}' ")
-    #  uri_decoded_pattern = URI.encode(what.to_s.gsub('(?-mix:', '').gsub(')', ''))
-    #  case @browserAbbrev
-    #  when 'IE'
-    #    tmpbrowser         = Watir::IE.attach(how, what)
-    #    browser.visible    = true
-    #    tmpbrowser.visible = true
-    #    tmpbrowser.speed   = :fast
-    #    tmpbrowser
-    #  when 'FF'
-    #    tmpbrowser = FireWatir::Firefox.attach(how, /#{uri_decoded_pattern}/)
-    #  when 'S'
-    #    Watir::Safari.attach(how, what)
-    #    tmpbrowser = browser
-    #  when 'C'
-    #    browser.window(how, /#{uri_decoded_pattern}/).use
-    #    tmpbrowser = browser
-    #  end
-    #  debug_to_log("#{__method__}: tmpbrowser:#{tmpbrowser.inspect}")
-    #  tmpbrowser
-    #end
-  #++
-
-# :category: Navigation
-  def attach_browser(browser, how, what, desc = '')
-    debug_to_log("Attaching browser window :#{how}=>'#{what}' #{desc}")
-    uri_decoded_pattern = URI.encode(what.to_s.gsub('(?-mix:', '').gsub(')', ''))
-    case @browserAbbrev
-      when 'IE'
-        tmpbrowser      = Watir::IE.attach(how, what)
-        browser.visible = true
-        if tmpbrowser
-          tmpbrowser.visible = true
-          tmpbrowser.speed   = :fast
-        else
-          raise "Browser window :#{how}=>'#{what}' has at least one doc not in completed ready state."
-        end
-      when 'FF'
-        #TODO: This may be dependent on Firefox version if webdriver doesn't support 3.6.17 and below
-        browser.driver.switch_to.window(browser.driver.window_handles[0])
-        browser.window(how, /#{uri_decoded_pattern}/).use
-        tmpbrowser = browser
-      when 'S'
-        Watir::Safari.attach(how, what)
-        tmpbrowser = browser
-      when 'C'
-        browser.window(how, /#{uri_decoded_pattern}/).use
-        tmpbrowser = browser
-    end
-    debug_to_log("#{__method__}: tmpbrowser:#{tmpbrowser.inspect}")
-    tmpbrowser
-  end
-
-# :category: Navigation
-  def attach_browser_by_url(browser, pattern, desc = '')
-    attach_browser(browser, :url, pattern, desc)
-  end
-
-  alias attach_browser_with_url attach_browser_by_url
-
-# :category: Navigation
-  def attach_popup(browser, how, what, desc = '')
-    msg   = "Attach popup :#{how}=>'#{what}'. #{desc}"
-    popup = attach_browser(browser, how, what, desc)
-    sleep_for(1)
-    debug_to_log("#{popup.inspect}")
-    if is_browser?(popup)
-      title = popup.title
-      passed_to_log("#{msg} title='#{title}'")
-      return popup
-    else
-      failed_to_log(msg)
-    end
-  rescue
-    failed_to_log("Unable to attach popup :#{how}=>'#{what}'. #{desc} '#{$!}' (#{__LINE__})")
-  end
-
-# :category: Navigation
-  def attach_popup_by_title(browser, strg, desc = '')
-    attach_popup(browser, :title, strg, desc)
-  end
-
-# :category: Navigation
-  def attach_popup_by_url(browser, pattern, desc = '')
-    attach_popup(browser, :url, pattern, desc)
-  end
-
-  alias get_popup_with_url attach_popup_by_url
-  alias attach_popup_with_url attach_popup_by_url
-  alias attach_iepopup attach_popup_by_url
-
-  def clear_checkbox(browser, how, what, value = nil, desc = '')
-    msg = "Clear checkbox #{how}=>'#{what}'"
-    msg << " ('#{value}')" if value
-    msg << " #{desc}'" if desc.length > 0
-    browser.checkbox(how, what).clear
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("Unable to #{msg} '#{$!}'")
-  end
-
-  def clear_checkbox_by_name(browser, strg, value = nil, desc = '')
-    clear_checkbox(browser, :name, strg, value, desc)
-  end
-
-  def clear_checkbox_by_id(browser, strg, value = nil, desc = '')
-    clear_checkbox(browser, :id, strg, value, desc)
-  end
-
-# :category: Bullet-Proofing
-  def find_other_browsers
-    cnt = 0
-    if @targetBrowser.abbrev == 'IE'
-      Watir::IE.each do |ie|
-        debug_to_log("#{ie.inspect}")
-        ie.close()
-        cnt = cnt + 1
-      end
-    end
-    debug_to_log("Found #{cnt} IE browser(s).")
-    return cnt
-  rescue
-    error_to_log("#{$!}  (#{__LINE__})\n#{Kernel.caller.to_yaml}", __LINE__)
-    return 0
-  end
-
-# :category: Debug
-  def get_trace(lnbr)
-    callertrace = "\nCaller trace: (#{lnbr})\n"
-    Kernel.caller.each_index do |x|
-      callertrace << '    >> ' + Kernel.caller[x].to_s + "\n"
-    end
-    callertrace
-  end
-
-  alias dump_caller get_trace
-
-# :category: Helpers
-  def translate_var_list(key)
-    if @var[key] and @var[key].length > 0
-      list = @var[key].dup
-      unless list =~ /^\[.+\]$/
-        list = "[#{list}]"
-      end
-      eval(list)
-    end
-  rescue
-    failed_to_log("#{__method__}: '#{$!}'")
-  end
-
-# :category: Helpers
-  def get_variables(file, login = :role, dbg = true)
-    debug_to_log("#{__method__}: file = #{file}")
-    debug_to_log("#{__method__}: role = #{login}")
-
-    @var                   = Hash.new
-    workbook               = Excel.new(file)
-    data_index             = find_sheet_with_name(workbook, 'Data')
-    workbook.default_sheet = workbook.sheets[data_index]
-    var_col                = 0
-
-    2.upto(workbook.last_column) do |col|
-      scriptName = workbook.cell(1, col)
-      if scriptName == @myName
-        var_col = col
-        break
-      end
-    end
-
-    2.upto(workbook.last_row) do |line|
-      name       = workbook.cell(line, 'A')
-      value      = workbook.cell(line, var_col).to_s.strip
-      @var[name] = value
-    end
-
-    @var.keys.sort.each do |name|
-      message_tolog("@var #{name}: '#{@var[name]}'")
-    end if dbg
-
-    @login       = Hash.new
-    login_col    = 0
-    role_col     = 0
-    userid_col   = 0
-    password_col = 0
-    url_col      = 0
-    name_col     = 0
-    role_index   = find_sheet_with_name(workbook, 'Login')
-    if role_index >= 0
-      workbook.default_sheet = workbook.sheets[role_index]
-
-      1.upto(workbook.last_column) do |col|
-        a_cell = workbook.cell(1, col)
-        case a_cell
-          when @myName
-            login_col = col
-            break
-          when 'role'
-            role_col = col
-          when 'userid'
-            userid_col = col
-          when 'password'
-            password_col = col
-          when 'url'
-            url_col = col
-          when 'name'
-            name_col = col
-        end
-      end
-
-      2.upto(workbook.last_row) do |line|
-        role     = workbook.cell(line, role_col)
-        userid   = workbook.cell(line, userid_col)
-        password = workbook.cell(line, password_col)
-        url      = workbook.cell(line, url_col)
-        username = workbook.cell(line, name_col)
-        enabled  = workbook.cell(line, login_col).to_s
-
-        case login
-          when :id
-            key = userid
-          when :role
-            key = role
-          else
-            key = role
-        end
-
-        @login[key]             = Hash.new
-        @login[key]['role']     = role
-        @login[key]['userid']   = userid
-        @login[key]['password'] = password
-        @login[key]['url']      = url
-        @login[key]['name']     = username
-        @login[key]['enabled']  = enabled
-
-      end
-
-      @login.keys.sort.each do |key|
-        message_tolog("@login (by #{login}): #{key}=>'#{@login[key].to_yaml}'")
-      end if dbg
-    end
-
-  rescue
-    fatal_to_log("#{__method__}: '#{$!}'")
-  end
-
-# :category: Debug
-  def grab_window_list(strg)
-    @ai.AutoItSetOption("WinTitleMatchMode", 2)
-    list    = @ai.WinList(strg)
-    stuff   = ''
-    names   = list[0]
-    handles = list[1]
-    max     = names.length - 1
-    rng     = Range.new(0, max)
-    rng.each do |idx|
-      window_handle = "[HANDLE:#{handles[idx]}]"
-      full_text     = @ai.WinGetText(window_handle)
-      stuff << "[#{handles[idx]}]=>#{names[idx]}=>'#{full_text}'\n"
-    end
-    debug_to_log("\n#{stuff}")
-    @ai.AutoItSetOption("WinTitleMatchMode", 1)
-    stuff
-  end
-
-# :category: Debug
-  def debug_call_list(msg)
-    call_array = get_call_array
-    debug_to_log("#{msg}\n#{dump_array(call_array)}")
-  end
-
-  #--
-  ## TODO ugly, gotta lose the hardcoding...
-  #def decode_options(strg)
-  #  idx      = 0
-  #  @options = Hash.new
-  #  strg.each_char do |c|
-  #    idx = idx + 1
-  #    case idx
-  #      when 1
-  #        @options['load'] = c.to_i
-  #      when 2
-  #        @options['screenshot'] = c.to_i
-  #        if c.to_i > 0
-  #          @screenCaptureOn = true
-  #        end
-  #      when 3
-  #        @options['hiderun'] = c.to_i
-  #      #      when 4
-  #      #        @options['another'] = c.to_i
-  #    end
-  #
-  #  end
-  #  #    puts @options.to_yaml
-  #end
-  #++
-
-# :category: User Input
-  def click_popup_button(title, button, waitTime= 9, user_input=nil)
-    #TODO: is winclicker still viable/available?
-    wc = WinClicker.new
-    if wc.clickWindowsButton(title, button, waitTime)
-      passed_to_log("Window '#{title}' button '#{button}' found and clicked.")
-      true
-    else
-      failed_to_log("Window '#{title}' button '#{button}' not found. (#{__LINE__})")
-    end
-    wc = nil
-    # get a handle if one exists
-    #    hwnd = $ie.enabled_popup(waitTime)
-    #    if (hwnd)  # yes there is a popup
-    #      w = WinClicker.new
-    #      if ( user_input )
-    #        w.setTextValueForFileNameField( hwnd, "#{user_input}" )
-    #      end
-    #      # I put this in to see the text being input it is not necessary to work
-    #      sleep 3
-    #      # "OK" or whatever the name on the button is
-    #      w.clickWindowsButton_hwnd( hwnd, "#{button}" )
-    #      #
-    #      # this is just cleanup
-    #      w=nil
-    #    end
-  end
-
-# :category: Locate Elements
-  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
-
-# :category: Page Data
-  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
-
-# :category: Page Data
-  def get_select_options_by_id(browser, strg, dump = false)
-    get_select_options(browser, :id, strg, dump)
-  end
-
-# :category: Page Data
-  def get_select_options_by_name(browser, strg, dump = false)
-    get_select_options(browser, :name, strg, dump)
-  end
-
-# :category: Page Data
-  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
-
-# :category: Page Data
-  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
-
-# :category: Page Data
-  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
-
-# :category: Helpers
-  def sec2hms(s)
-    Time.at(s.to_i).gmtime.strftime('%H:%M:%S')
-  end
-
-# :category: User Input
-  def select(browser, how, what, which, value, desc = '')
-    msg  = "Select option #{which}='#{value}' from list #{how}=#{what}. #{desc}"
-    list = browser.select_list(how, what)
-    case which
-      when :text
-        list.select(value)
-      when :value
-        list.select_value(value)
-      when :index
-        all = list.getAllContents
-        txt = all[value]
-        list.select(txt)
-      else
-        na = "#{__method__} cannot support select by '#{which}'. (#{msg})"
-        debug_to_log(na, __LINE__, true)
-        raise na
-    end
-    passed_to_log(msg)
-  rescue
-    failed_to_log("#Unable to #{msg}': '#{$!}'")
-  end
-
-# :category: User Input
-  def select_option_from_list(list, what, what_strg, desc = '')
-    ok  = true
-    msg = "#{__method__.to_s.titleize} "
-    if list
-      msg << "list id=#{list.id}: "
-      case what
-        when :text
-          list.select(what_strg) #TODO: regex?
-        when :value
-          list.select_value(what_strg) #TODO: regex?
-        when :index
-          list.select(list.getAllContents[what_strg.to_i])
-        else
-          msg << "select by #{what} not supported. #{desc} (#{__LINE__})"
-          failed_to_log(msg)
-          ok = false
-      end
-      if ok
-        msg << "#{what}='#{what_strg}' selected. #{desc}"
-        passed_to_log(msg)
-        true
-      end
-    else
-      failed_to_log("#{__method__.to_s.titleize} list not found. #{desc} (#{__LINE__})")
-    end
-  rescue
-    failed_to_log("#{__method__.to_s.titleize}: #{what}='#{what_strg}' could not be selected: '#{$!}'. #{desc} (#{__LINE__})")
-  end
-
-# :category: User Input
-  def select_option_by_id_and_option_text(browser, strg, option, nofail=false, desc = '')
-    msg = "Select list id=#{strg} option text='#{option}' selected."
-    msg << " #{desc}" if desc.length > 0
-    list = browser.select_list(:id, strg)
-    list.select(option)
-    #      browser.select_list(:id, strg).select(option)   #(browser.select_list(:id, strg).getAllContents[option])
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    if !nofail
-      failed_to_log("#{msg} '#{$!}'")
-    end
-  end
-
-  alias select_option_by_id select_option_by_id_and_option_text
-  alias select_option_by_id_and_text select_option_by_id_and_option_text
-
-# :category: User Input
-  def select_option_by_name_and_option_text(browser, strg, option, desc = '')
-    msg = "Select list name=#{strg} option text='#{option}' selected."
-    msg << " #{desc}" if desc.length > 0
-    begin
-      list = browser.select_list(:name, strg)
-    rescue => e
-      if not rescue_me(e, __method__, "#{__LINE__}: select_list(:name,'#{strg}')", "#{browser.class}")
-        raise e
-      end
-    end
-    begin
-      list.select(option)
-    rescue => e
-      if not rescue_me(e, __method__, "#{__LINE__}: select_list#select('#{option}')", "#{browser.class}")
-        raise e
-      end
-    end
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-  alias select_option_by_name select_option_by_name_and_option_text
-
-# :category: User Input
-  def select_option_by_title_and_option_text(browser, strg, option, desc = '')
-    msg = "Select list name=#{strg} option text='#{option}' selected."
-    msg << " #{desc}" if desc.length > 0
-    browser.select_list(:title, strg).select(option)
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-# :category: User Input
-  def select_option_by_class_and_option_text(browser, strg, option, desc = '')
-    msg = "Select list class=#{strg} option text='#{option}' selected."
-    msg << " #{desc}" if desc.length > 0
-    browser.select_list(:class, strg).select(option)
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-# :category: User Input
-  def select_option_by_name_and_option_value(browser, strg, option, desc = '')
-    msg = "Select list name=#{strg} option value='#{option}' selected."
-    msg << " #{desc}" if desc.length > 0
-    begin
-      list = browser.select_list(:name, strg)
-    rescue => e
-      if not rescue_me(e, __method__, "#{__LINE__}: select_list(:name,'#{strg}')", "#{browser.class}")
-        raise e
-      end
-    end
-    begin
-      list.select_value(option)
-    rescue => e
-      if not rescue_me(e, __method__, "#{__LINE__}: select_list#select_value('#{option}')", "#{browser.class}")
-        raise e
-      end
-    end
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-# :category: User Input
-  def select_option_by_id_and_option_value(browser, strg, option, desc = '')
-    msg = "Select list name=#{strg} option value='#{option}' selected."
-    msg << " #{desc}" if desc.length > 0
-    begin
-      list = browser.select_list(:id, strg)
-    rescue => e
-      if not rescue_me(e, __method__, "#{__LINE__}: select_list(:text,'#{strg}')", "#{browser.class}")
-        raise e
-      end
-    end
-    sleep(0.5) unless @targetBrowser.abbrev == 'IE'
-    begin
-      list.select_value(option)
-    rescue => e
-      if not rescue_me(e, __method__, "#{__LINE__}: select_list#select_value('#{option}')", "#{browser.class}")
-        raise e
-      end
-    end
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-  def select_option_by_id_and_index(browser, strg, idx, desc = '')
-    msg = "Select list id=#{strg} index='#{idx}' selected."
-    msg << " #{desc}" if desc.length > 0
-    list = browser.select_list(:id, strg)
-    all  = list.getAllContents
-    txt  = all[idx]
-    browser.select_list(:id, strg).set(browser.select_list(:id, strg).getAllContents[idx])
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-  # TODO add check that both list and option exist
-  def select_option_by_name_and_index(browser, strg, idx)
-    msg = "Select list name=#{strg} index='#{idx}' selected."
-    msg << " #{desc}" if desc.length > 0
-    browser.select_list(:name, strg).set(browser.select_list(:name, strg).getAllContents[idx])
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-  def select_option_by_xpath_and_index(browser, strg, idx)
-    msg = "Select list xpath=#{strg} index='#{idx}' selected."
-    msg << " #{desc}" if desc.length > 0
-    browser.select_list(:xpath, strg).set(browser.select_list(:xpath, strg).getAllContents[idx])
-    if validate(browser, nil, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-# :category: User Input
-  def set(browser, element, how, what, value = nil, desc = '')
-    msg = "Set #{element} #{how}=>'#{what}' "
-    msg << "('#{value.to_s}')" if value
-    msg << " '#{desc}' " if desc.length > 0
-    case element
-      when :radio
-        browser.radio(how, what, value).set
-      when :checkbox
-        browser.checkbox(how, what, value).set
-      else
-        failed_to_log("#{__method__}: #{element} not supported")
-    end
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-# :category: User Input
-  def set_checkbox(browser, how, what, desc = '')
-    set(browser, :checkbox, how, what, nil, desc)
-  end
-
-# :category: User Input
-  def set_checkbox_by_class(browser, strg, value = nil, desc = '')
-    set(browser, :checkbox, :class, strg, value, desc)
-  end
-
-# :category: User Input
-  def set_checkbox_by_id(browser, strg, value = nil, desc = '')
-    set(browser, :checkbox, :id, strg, value, desc)
-  end
-
-# :category: User Input
-  def set_checkbox_by_name(browser, strg, value = nil, desc = '')
-    set(browser, :checkbox, :name, strg, value, desc)
-  end
-
-# :category: User Input
-  def set_checkbox_by_title(browser, strg, value = nil, desc = '')
-    set(browser, :checkbox, :title, strg, value, desc)
-  end
-
-# :category: User Input
-  def set_checkbox_by_value(browser, strg, desc = '')
-    set(browser, :checkbox, :value, strg, nil, desc)
-  end
-
-# :category: User Input
-  def set_radio(browser, how, what, value = nil, desc = '')
-    if how == :value
-      set_radio_by_value(browser, what, desc)
-    else
-      set(browser, :radio, how, what, value, desc)
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-# :category: User Input
-  def set_radio_two_attributes(browser, how1, what1, how2, what2, desc = '')
-    msg = "Set radio #{how1}='#{what1}', #{how2}= #{what2}"
-    msg << " '#{desc}' " if desc.length > 0
-    browser.radio(how1 => what1, how2 => what2).set
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-# :category: User Input
-  def set_radio_by_class(browser, strg, value = nil, desc = '')
-    set(browser, :radio, :class, strg, value, desc)
-  end
-
-# :category: User Input
-  def set_radio_by_id(browser, strg, value = nil, desc = '')
-    set(browser, :radio, :id, strg, value, desc)
-  end
-
-# :category: User Input
-  def set_radio_by_index(browser, index, desc = '')
-    set(browser, :radio, :index, index, nil, desc)
-  end
-
-# :category: User Input
-  def set_radio_by_name(browser, strg, value = nil, desc = '')
-    set(browser, :radio, :name, strg, value, desc)
-  end
-
-# :category: User Input
-  def set_radio_by_title(browser, strg, value = nil, desc = '')
-    set(browser, :radio, :title, strg, value, desc)
-  end
-
-# :category: User Input
-  def set_radio_no_wait_by_index(browser, index, desc = '')
-    #TODO: Not supported by Watir 1.8.x
-    msg    = "Radio :index=#{index} "
-    radios = browser.radios
-    debug_to_log("\n#{radios}")
-    radio = radios[index]
-    debug_to_log("\n#{radio}")
-    radio.click_no_wait
-    if validate(browser)
-      msg << 'set ' + desc
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    msg << 'not found ' + desc
-    failed_to_log("#{msg} (#{__LINE__})")
-  end
-
-  def set_radio_by_value(browser, strg, desc = '')
-    msg = "Radio :value=>'#{strg}' "
-    msg << " '#{desc}' " if desc.length > 0
-    browser.radio(:value, strg).set
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-  def set_radio_by_name_and_index(browser, name, index, desc = '')
-    set_radio_two_attributes(browser, :name, name, :index, index, desc)
-  end
-
-  def set_radio_by_name_and_text(browser, name, text, desc = '')
-    set_radio_two_attributes(browser, :name, name, :text, text, desc)
-  end
-
-  def set_radio_by_value_and_index(browser, value, index, desc = '')
-    set_radio_two_attributes(browser, :value, value, :index, index, desc)
-  end
-
-  def set_radio_by_name_and_value(browser, strg, value, desc = '')
-    set(browser, :radio, :name, strg, value, desc)
-  end
-
-# No validation
-  def clear(browser, element, how, what, value = nil, desc = '')
-    msg = "Clear #{element} #{how}=>'#{what}' "
-    msg << "('#{value.to_s}')" if value
-    msg << " '#{desc}' " if desc.length > 0
-    case element
-      when :radio
-        browser.radio(how, what, value).clear
-      when :checkbox
-        browser.checkbox(how, what, value).clear
-      when :text_field
-        browser.text_field(how, what).set('')
-      else
-        failed_to_log("#{__method__}: #{element} not supported")
-    end
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-  def clear_radio(browser, how, what, value = nil, desc = '')
-    msg = "Clear radio #{how}=>'#{what.to_s}' "
-    msg << "('#{value.to_s}')" if value
-    msg << " '#{desc}' " if desc.length > 0
-    radio = browser.radio(how, what, value)
-    radio.clear
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("#{msg} '#{$!}'")
-  end
-
-# Set skip_value_check = true when string is altered by application and/or
-# this method will be followed by validate_text
-  def clear_textfield(browser, how, which, skip_value_check = false)
-    if browser.text_field(how, which).exists?
-      tf = browser.text_field(how, which)
-      if validate(browser, @myName, __LINE__)
-        tf.clear
-        if validate(browser, @myName, __LINE__)
-          if tf.value == ''
-            passed_to_log("Textfield #{how}='#{which}' cleared.")
-            true
-          elsif skip_value_check
-            passed_to_log("Textfield  #{how}='#{which}' cleared. (skip value check)")
-            true
-          else
-            failed_to_log("Textfield  #{how}='#{which}' not cleared: Found:'#{tf.value}'. (#{__LINE__})")
-          end
-        end
-      end
-    else
-      failed_to_log("Textfield id='#{id}' to clear. (#{__LINE__})")
-    end
-  rescue
-    failed_to_log("Textfield id='#{id}' could not be cleared: '#{$!}'. (#{__LINE__})")
-  end
-
-  def close_window_by_title(browser, title, desc = '', text = '')
-    msg = "Window '#{title}':"
-    if @ai.WinWait(title, text, WAIT) > 0
-      passed_to_log("#{msg} appeared. #{desc}")
-      myHandle  = @ai.WinGetHandle(title, text)
-      full_text = @ai.WinGetText(title)
-      debug_to_log("#{msg} hwnd: #{myHandle.inspect}")
-      debug_to_log("#{msg} title: '#{title}' text: '#{full_text}'")
-      if @ai.WinClose(title, text) > 0
-        passed_to_log("#{msg} closed successfully. #{desc}")
-      else
-        failed_to_log("#{msg} close failed. (#{__LINE__}) #{desc}")
-      end
-    else
-      failed_to_log("#{msg} did not appear after #{WAIT} seconds. (#{__LINE__}) #{desc}")
-    end
-  rescue
-    failed_to_log("#{msg}: Unable to close: '#{$!}'. (#{__LINE__}) #{desc}")
-  end
-
-  def set_file_field(browser, how, what, filespec, desc = '')
-    msg = "Set file field #{how}=>#{what} to '#{filespec}."
-    msg << " #{desc}" if desc.length > 0
-    ff = browser.file_field(how, what)
-    if ff
-      ff.set filespec
-      sleep_for(8)
-      if validate(browser, @myName, __LINE__)
-        passed_to_log(msg)
-        true
-      end
-    else
-      failed_to_log("#{msg} File field not found.")
-    end
-  rescue
-    failed_to_log("Unable to #{msg} '#{$!}'")
-  end
-
-  def set_file_field_by_name(browser, strg, path, desc = '')
-    set_file_field(browser, :name, strg, path, desc)
-  end
-
-  def set_file_field_by_id(browser, strg, path, desc = '')
-    set_file_field(browser, :id, strg, path, desc)
-  end
-
-  def set_text_field(browser, how, what, value, desc = '', skip_value_check = false)
-    #TODO: fix this to handle Safari password field
-    msg = "Set textfield #{how}='#{what}' to '#{value}'"
-    msg << " #{desc}" if desc.length > 0
-    msg << " (Skip value check)" if skip_value_check
-    if browser.text_field(how, what).exists?
-      tf = browser.text_field(how, what)
-      debug_to_log("#{tf.inspect}")
-      if validate(browser, @myName, __LINE__)
-        tf.set(value)
-        if validate(browser, @myName, __LINE__)
-          if tf.value == value
-            passed_to_log(msg)
-            true
-          elsif skip_value_check
-            passed_to_log(msg)
-            true
-          else
-            failed_to_log("#{msg}: Found:'#{tf.value}'.")
-          end
-        end
-      end
-    else
-      failed_to_log("Textfield #{how}='#{what}' not found to set to '#{value}''")
-    end
-  rescue
-    failed_to_log("Unable to '#{msg}': '#{$!}'")
-  end
-
-  alias set_textfield set_text_field
-
-  def set_textfield_by_name(browser, name, value, desc = '', skip_value_check = false)
-    if browser.text_field(:name, name).exists?
-      tf = browser.text_field(:name, name)
-      # Workaround because browser.text_field doesn't work for password fields in Safari
-    elsif @browserAbbrev.eql?("S")
-      tf = browser.password(:name, name)
-    end
-    if tf.exists?
-      if validate(browser, @myName, __LINE__)
-        tf.set(value)
-        if validate(browser, @myName, __LINE__)
-          if tf.value == value
-            passed_to_log("Set textfield name='#{name}' to '#{value}' #{desc}")
-            true
-          elsif skip_value_check
-            passed_to_log("Set textfield name='#{name}' to '#{value}' #{desc} (skip value check)")
-            true
-          else
-            failed_to_log("Set textfield name='#{name}' to '#{value}': Found:'#{tf.value}'.  #{desc} (#{__LINE__})")
-          end
-        end
-      end
-    else
-      failed_to_log("Textfield name='#{name}' not found to set to '#{value}'.  #{desc} (#{__LINE__})")
-    end
-  rescue
-    failed_to_log("Textfield name='#{name}' could not be set to '#{value}': '#{$!}'. #{desc} (#{__LINE__})")
-  end
-
-# Set skip_value_check = true when string is altered by application and/or
-# this method will be followed by validate_text
-  def set_textfield_by_id(browser, id, value, desc = '', skip_value_check = false)
-    set_text_field(browser, :id, id, value, desc, skip_value_check)
-  end
-
-  def set_textfield_by_title(browser, title, value, desc = '', skip_value_check = false)
-    set_text_field(browser, :title, title, value, desc, skip_value_check)
-  end
-
-  def set_textfield_by_class(browser, strg, value, desc = '', skip_value_check = false)
-    set_text_field(browser, :class, strg, value, desc, skip_value_check)
-  end
-
-  def set_text_field_and_validate(browser, how, what, value, desc = '', valid_value = nil)
-    #NOTE: use when value and valid_value differ as with dollar reformatting
-    if set_text_field(browser, how, what, value, desc, true)
-      expected = valid_value ? valid_value : value
-      validate_textfield_value(browser, how, what, expected)
-    end
-  rescue
-    failed_to_log("Unable to '#{msg}': '#{$!}'")
-  end
-
-=begin rdoc
-:category: Basic
-:tags:logon, login, user, password, url
-TODO: Needs to be more flexible about finding login id and password textfields
-TODO: Parameterize url and remove references to environment
-=end
-  def login(browser, user, password)
-    myURL  = @myAppEnv.url
-    runenv = @myAppEnv.nodename
-    message_tolog("URL: #{myURL}")
-    message_tolog("Beginning login: User: #{user} Environment: #{runenv}")
-    if validate(browser, @myName, __LINE__)
-      browser.goto(myURL)
-      if validate(browser, @myName)
-        set_textfield_by_name(browser, 'loginId', user)
-        set_textfield_by_name(browser, 'password', password)
-        click_button_by_value(browser, 'Login')
-        if validate(browser, @myName)
-          passed_to_log("Login successful.")
-        end
-      else
-        failed_to_log("Unable to login to application: '#{$!}'")
-        #          screen_capture( "#{@myRoot}/screens/#{myName}_#{@runid}_#{__LINE__.to_s}_#{Time.new.to_f.to_s}.jpg")
-      end
-    end
-  rescue
-    failed_to_log("Unable to login to application: '#{$!}'")
-  end
-
-=begin rdoc
-category: Logon
-:tags:logon, login, user, password, url, basic authorization
-=end
-  def basic_auth(browser, user, pswd, url, bypass_validate = false)
-    mark_testlevel("Basic Authorization Login", 0)
-
-    message_to_report ("Login:    #{user}")
-    message_to_report ("URL:      #{url}")
-    message_to_report ("Password: #{pswd}")
-
-    @login_title = "Connect to"
-
-    a = Thread.new {
-      browser.goto(url)
-    }
-
-    sleep_for(2)
-    message_to_log("#{@login_title}...")
-
-    if (@ai.WinWait(@login_title, "", 90) > 0)
-      win_title = @ai.WinGetTitle(@login_title)
-      debug_to_log("Basic Auth Login window appeared: '#{win_title}'")
-      @ai.WinActivate(@login_title)
-      @ai.ControlSend(@login_title, '', "[CLASS:Edit; INSTANCE:2]", '!u')
-      @ai.ControlSend(@login_title, '', "[CLASS:Edit; INSTANCE:2]", user, 1)
-      @ai.ControlSend(@login_title, '', "[CLASS:Edit; INSTANCE:3]", pswd.gsub(/!/, '{!}'), 1)
-      @ai.ControlClick(@login_title, "", '[CLASS:Button; INSTANCE:1]')
-    else
-      debug_to_log("Basic Auth Login window did not appear.")
-    end
-    a.join
-
-    validate(browser, @myName) unless bypass_validate
-
-    message_to_report("URL: [#{browser.url}] User: [#{user}]")
-
-  end
-
-  def logout(browser, where = @myName, lnbr = __LINE__)
-    #TODO Firewatir 1.6.5 does not implement .exists for FireWatir::Firefox class
-    debug_to_log("Logging out in #{where} at line #{lnbr}.", lnbr, true)
-    debug_to_log("#{__method__}: browser: #{browser.inspect} (#{__LINE__})")
-
-    if ['FF', 'S'].include?(@browserAbbrev) || browser.exists?
-      case @browserAbbrev
-        when 'FF'
-          if is_browser?(browser)
-            url   = browser.url
-            title = browser.title
-            debug_to_log("#{__method__}: Firefox browser url: [#{url}]")
-            debug_to_log("#{__method__}: Firefox browser title: [#{title}]")
-            debug_to_log("#{__method__}: Closing browser: #{where} (#{lnbr})")
-            if url and url.length > 1
-              browser.close
-            else
-              browser = FireWatir::Firefox.attach(:title, title)
-              browser.close
-            end
-
-          end
-        when 'IE'
-          hwnd = browser.hwnd
-          pid  = Watir::IE::Process.process_id_from_hwnd(hwnd)
-          debug_to_log("#{__method__}: Closing browser: hwnd #{hwnd} pid #{pid} #{where} (#{lnbr}) (#{__LINE__})")
-          browser.close
-          if browser.exists? and pid > 0 and pid < 538976288 # value of uninitialized memory location
-            debug_to_log("Retry close browser: hwnd #{hwnd} pid #{pid} #{where} #{lnbr} (#{__LINE__})")
-            browser.close
-          end
-          if browser.exists? and pid > 0 and pid < 538976288 # value of uninitialized memory location
-            kill_browser(browser.hwnd, __LINE__, browser, true)
-          end
-        when 'S'
-          if is_browser?(browser)
-            url   = browser.url
-            title = browser.title
-            debug_to_log("Safari browser url: [#{url}]")
-            debug_to_log("Safari browser title: [#{title}]")
-            debug_to_log("Closing browser: #{where} (#{lnbr})")
-            close_modal_s # to close any leftover modal dialogs
-            browser.close
-          end
-        when 'C'
-          if is_browser?(browser)
-            url   = browser.url
-            title = browser.title
-            debug_to_log("Chrome browser url: [#{url}]")
-            debug_to_log("Chrome browser title: [#{title}]")
-            debug_to_log("Closing browser: #{where} (#{lnbr})")
-            if url and url.length > 1
-              browser.close
-              #else
-              #browser = FireWatir::Firefox.attach(:title, title)
-              #browser.close
-            end
-
-          end
-        else
-          raise "Unsupported browser: '#{@browserAbbrev}'"
-      end
-    end
-    #  rescue => e
-    #    if not e.is_a?(Vapir::WindowGoneException)
-    #      raise e
-    #    end
-  end
-
-  #close popup in new window
-  def close_new_window_popup(popup)
-    if is_browser?(popup)
-      url = popup.url
-      debug_to_log("Closing popup '#{url}' ")
-      popup.close
-
-    end
-  end
-
-  def close_panel_by_text(browser, panel, strg = 'Close')
-    if validate(browser, @myName, __LINE__)
-      if @browserAbbrev == 'IE'
-        panel.link(:text, strg).click!
-      elsif $USE_FIREWATIR
-        begin
-          panel.link(:text, strg).click
-        rescue => e
-          if not rescue_me(e, __method__, "link(:text,'#{strg}').click", "#{panel.class}")
-            raise e
-          end
-        end
-      else
-        panel.link(:text, strg).click(:wait => false)
-      end
-      sleep_for(1)
-      if validate(browser, @myName, __LINE__)
-        passed_to_log("Panel '#{strg}' (by :text) closed.")
-        true
-      end
-    else
-      failed_to_log("Panel '#{strg}' (by :text) still open.")
-    end
-  rescue
-    failed_to_log("Click on '#{strg}'(by :text) failed: '#{$!}' (#{__LINE__})")
-  end
-
-  #  def close_modal_ie(title="", button="OK", text='', side = 'primary', wait = WAIT)
-  def close_popup(title, button = "OK", text = '', side = 'primary', wait = WAIT, desc = '', quiet = false)
-    #TODO needs simplifying and debug code cleaned up
-    title = translate_popup_title(title)
-    msg   = "'#{title}'"
-    msg << " with text '#{text}'" if text.length > 0
-    msg << " (#{desc})" if desc.length > 0
-    @ai.Opt("WinSearchChildren", 1) # Match any substring in the title
-    if @ai.WinWait(title, text, wait) > 0
-      myHandle  = @ai.WinGetHandle(title, text)
-      full_text = @ai.WinGetText(title)
-      #debug_to_report("Found popup handle:'#{myHandle}', title:'#{title}', text:'#{full_text}'")
-      if myHandle.length > 0
-        debug_to_log("hwnd: #{myHandle.inspect}")
-        passed_to_log("#{msg} appeared.") unless quiet
-        sleep_for(0.5)
-        @ai.WinActivate(title, text)
-        if @ai.WinActive(title, text) #  > 0   #Hack to prevent fail when windows session locked
-          debug_to_log("#{msg} activated.")
-          if @ai.ControlFocus(title, text, button) #  > 0
-            controlHandle = @ai.ControlGetHandle(title, '', "[CLASS:Button; TEXT:#{button}]")
-            if not controlHandle
-              button        = "&#{button}"
-              controlHandle = @ai.ControlGetHandle(title, '', "[CLASS:Button; TEXT:#{button}]")
-            end
-            debug_to_log("Handle for button '#{button}': [#{controlHandle}]")
-            debug_to_log("#{msg} focus gained.")
-            #              sleep_for(2)
-            if @ai.ControlClick(title, text, button, side) # > 0
-                                                           #            if @ai.ControlClick(title, text, "[Handle:#{controlHandle}]", side) > 0
-                                                           #                debug_to_log("#{msg} #{side} click on 'Handle:#{controlHandle}'." )
-              debug_to_log("#{msg} #{side} click on '#{button}' successful.")
-              sleep_for(1)
-              if @ai.WinExists(title, text) > 0
-                debug_to_log("#{msg} close popup failed on click '#{button}'. Trying WinClose. (#{__LINE__})")
-                @ai.WinClose(title, text)
-                if @ai.WinExists(title, text) > 0
-                  debug_to_log("#{msg} close popup failed with WinClose('#{title}','#{text}'). (#{__LINE__})")
-                  @ai.WinKill(title, text)
-                  if @ai.WinExists(title, text) > 0
-                    debug_to_log("#{msg} close popup failed with WinKill('#{title}','#{text}'). (#{__LINE__})")
-                  else
-                    debug_to_log("#{msg} closed successfully with WinKill('#{title}','#{text}').")
-                  end
-                else
-                  debug_to_log("#{msg} closed successfully with WinClose('#{title}','#{text}').")
-                end
-              else
-                passed_to_log("#{msg} closed successfully.") unless quiet
-              end
-            else
-              failed_to_log("#{msg} #{side} click on '#{button}' failed. (#{__LINE__})")
-            end
-          else
-            failed_to_log("#{msg} Unable to gain focus on button (#{__LINE__})")
-          end
-        else
-          failed_to_log("#{msg} Unable to activate (#{__LINE__})")
-        end
-      else
-        failed_to_log("#{msg} did not appear after #{wait} seconds. (#{__LINE__})")
-      end
-    else
-      failed_to_log("#{msg} did not appear after #{wait} seconds. (#{__LINE__})")
-    end
-  rescue
-    failed_to_log("Close popup title=#{title} failed: '#{$!}' (#{__LINE__})")
-  end
-
-  alias close_popup_validate_text close_popup
-
-  def close_popup_by_text(popup, strg = 'Close', desc = '')
-    count = 0
-    url   = popup.url
-    if validate(popup, @myName, __LINE__)
-      count = string_count_in_string(popup.text, strg)
-      if count > 0
-        #        @waiter.wait_until( browser.link(:text, strg).exists? ) if @waiter
-        begin
-          popup.link(:text, strg).click
-        rescue => e
-          if not rescue_me(e, __method__, "link(:text,'#{strg}')", "#{popup.class}")
-            raise e
-          end
-        end
-        passed_to_log("Popup #{url} closed by clicking link with text '#{strg}'. #{desc}")
-        true
-      else
-        failed_to_log("Link :text=>'#{strg}' for popup #{url} not found. #{desc}")
-      end
-    end
-  rescue
-    failed_to_log("Close popup #{url} with click link :text+>'#{strg}' failed: '#{$!}' (#{__LINE__})")
-    debug_to_log("#{strg} appears #{count} times in popup.text.")
-    raise
-  end
-
-  #  #close a modal dialog
-  def close_modal(browser, title="", button="OK", text='', side = 'primary', wait = WAIT)
-    case @targetBrowser.abbrev
-      when 'IE'
-        close_modal_ie(browser, title, button, text, side, wait)
-      when 'FF'
-        close_modal_ff(browser, title, button, text, side)
-      when 'S'
-        close_modal_s
-      when 'C', 'GC'
-        close_modal_c(browser, title)
-    end
-  end
-
-# TODO: Logging
-  def close_modal_c(browser, title)
-    browser.window(:url, title).close
-  end
-
-# TODO: Logging
-  def close_modal_s
-    # simply closes the frontmost Safari dialog
-    Appscript.app("Safari").activate; Appscript.app("System Events").processes["Safari"].key_code(52)
-  end
-
-  def close_modal_ie(browser, title="", button="OK", text='', side = 'primary', wait = WAIT, desc = '', quiet = false)
-    #TODO needs simplifying, incorporating text verification, and debug code cleaned up
-    title = translate_popup_title(title)
-    msg   = "Modal window (popup) '#{title}'"
-    if @ai.WinWait(title, text, wait)
-      myHandle = @ai.WinGetHandle(title, text)
-      if myHandle.length > 0
-        debug_to_log("hwnd: #{myHandle.inspect}")
-        passed_to_log("#{msg} appeared.") unless quiet
-        window_handle = "[HANDLE:#{myHandle}]"
-        sleep_for(0.5)
-        @ai.WinActivate(window_handle)
-        if @ai.WinActive(window_handle)
-          debug_to_log("#{msg} activated.")
-          controlHandle = @ai.ControlGetHandle(title, '', "[CLASS:Button; TEXT:#{button}]")
-          if not controlHandle.length > 0
-            button        = "&#{button}"
-            controlHandle = @ai.ControlGetHandle(title, '', "[CLASS:Button; TEXT:#{button}]")
-          end
-          debug_to_log("Handle for button '#{button}': [#{controlHandle}]")
-          debug_to_log("#{msg} focus gained.")
-          if @ai.ControlClick(title, '', "[CLASS:Button; TEXT:#{button}]")
-            passed_to_log("#{msg} #{side} click on '[CLASS:Button; TEXT:#{button}]' successful.")
-            sleep_for(0.5)
-            if @ai.WinExists(window_handle)
-              debug_to_log("#{msg} close popup failed on click '#{button}'. Trying WinClose. (#{__LINE__})")
-              @ai.WinClose(title, text)
-              if @ai.WinExists(window_handle)
-                debug_to_log("#{msg} close popup failed with WinClose(#{window_handle}). (#{__LINE__})")
-                @ai.WinKill(window_handle)
-                if @ai.WinExists(window_handle)
-                  debug_to_log("#{msg} close popup failed with WinKill(#{window_handle}). (#{__LINE__})")
-                else
-                  debug_to_log("#{msg} closed successfully with WinKill(#{window_handle}).")
-                end
-              else
-                debug_to_log("#{msg} closed successfully with WinClose(#{window_handle}).")
-              end
-            else
-              passed_to_log("#{msg} closed successfully.")
-            end
-          else
-            failed_to_log("#{msg} #{side} click on '[CLASS:Button; TEXT:#{button}]' failed. (#{window_handle}) (#{__LINE__})")
-          end
-        else
-          failed_to_log("#{msg} Unable to activate (#{window_handle}) (#{__LINE__})")
-        end
-      else
-        failed_to_log("#{msg} did not appear after #{wait} seconds. (#{window_handle}) (#{__LINE__})")
-      end
-    else
-      failed_to_log("#{msg} did not appear after #{wait} seconds.(#{window_handle}) (#{__LINE__})")
-    end
-  rescue
-    failed_to_log("Close popup title=#{title} failed: '#{$!}' (#{__LINE__})")
-  end
-
-  #  private :close_modal_ie
-
-  def close_modal_ff(browser, title="", button=nil, text="", side='')
-    title = translate_popup_title(title)
-    msg   = "Modal dialog (popup): title=#{title} button='#{button}' text='#{text}' side='#{side}':"
-    modal = browser.modal_dialog(:timeout => WAIT)
-    if modal.exists?
-      modal_text = modal.text
-      if text.length > 0
-        if modal_text =~ /#{text}/
-          passed_to_log("#{msg} appeared with match on '#{text}'.")
-        else
-          failed_to_log("#{msg} appeared but did not match '#{text}' ('#{modal_text}).")
-        end
-      else
-        passed_to_log("#{msg} appeared.")
-      end
-      if button
-        modal.click_button(button)
-      else
-        modal.close
-      end
-      if modal.exists?
-        failed_to_log("#{msg} close failed. (#{__LINE__})")
-      else
-        passed_to_log("#{msg} closed successfully.")
-      end
-    else
-      failed_to_log("#{msg} did not appear after #{WAIT} seconds. (#{__LINE__})")
-    end
-  rescue
-    failed_to_log("#{msg} Unable to validate modal popup: '#{$!}'. (#{__LINE__})")
-  end
-
-  def handle_popup(title, text = '', button= 'OK', side = 'primary', wait = WAIT, desc = '')
-    title = translate_popup_title(title)
-    msg   = "'#{title}'"
-    if text.length > 0
-      msg << " with text '#{text}'"
-    end
-    @ai.Opt("WinSearchChildren", 1) # match title from start, forcing default
-
-    if button and button.length > 0
-      if button =~ /ok|yes/i
-        id = '1'
-      else
-        id = '2'
-      end
-    else
-      id = ''
-    end
-
-    if @ai.WinWait(title, '', wait) > 0
-      myHandle      = @ai.WinGetHandle(title, '')
-      window_handle = "[HANDLE:#{myHandle}]"
-      full_text     = @ai.WinGetText(window_handle)
-      debug_to_log("Found popup handle:'#{myHandle}', title:'#{title}', text:'#{full_text}'")
-
-      controlHandle = @ai.ControlGetHandle(window_handle, '', "[CLASS:Button; TEXT:#{button}]")
-      if not controlHandle
-#        button        = "&#{button}"
-        controlHandle = @ai.ControlGetHandle(window_handle, '', "[CLASS:Button; TEXT:&#{button}]")
-      end
-
-      if text.length > 0
-        if full_text =~ /#{text}/
-          passed_to_log("Found popup handle:'#{myHandle}', title:'#{title}', text includes '#{text}'. #{desc}")
-        else
-          failed_to_log("Found popup handle:'#{myHandle}', title:'#{title}', text does not include '#{text}'. Closing it. #{desc}")
-        end
-      end
-
-      @ai.WinActivate(window_handle, '')
-      @ai.ControlClick(window_handle, '', id, side)
-      if @ai.WinExists(title, '') > 0
-        debug_to_log("#{msg} @ai.ControlClick on '#{button}' (ID:#{id}) with handle '#{window_handle}' failed to close window. Trying title.")
-        @ai.ControlClick(title, '', id, side)
-        if @ai.WinExists(title, '') > 0
-          debug_to_report("#{msg} @ai.ControlClick on '#{button}' (ID:#{id}) with title '#{title}' failed to close window.  Forcing closed.")
-          @ai.WinClose(title, '')
-          if @ai.WinExists(title, '') > 0
-            debug_to_report("#{msg} @ai.WinClose on title '#{title}' failed to close window.  Killing window.")
-            @ai.WinKill(title, '')
-            if @ai.WinExists(title, '') > 0
-              failed_to_log("#{msg} @ai.WinKill on title '#{title}' failed to close window")
-            else
-              passed_to_log("Killed: popup handle:'#{myHandle}', title:'#{title}'. #{desc}")
-              true
-            end
-          else
-            passed_to_log("Forced closed: popup handle:'#{myHandle}', title:'#{title}'. #{desc}")
-            true
-          end
-        else
-          passed_to_log("Closed on '#{button}': popup handle:'#{myHandle}', title:'#{title}'. #{desc}")
-          true
-        end
-      else
-        passed_to_log("Closed on '#{button}': popup handle:'#{myHandle}', title:'#{title}'. #{desc}")
-        true
-      end
-
-    else
-      failed_to_log("#{msg} did not appear after #{wait} seconds. #{desc} (#{__LINE__})")
-    end
-  rescue
-    failed_to_log("Unable to handle popup #{msg}: '#{$!}' #{desc} (#{__LINE__})")
-
-  end
-
-# howLong is integer, whatFor is a browser object
-=begin rdoc
-:category: Waits
-:tags:wait
-howLong is the number of seconds, text is a string to be found, threshold is the number of seconds
-after which a fail message is generated even though the text was detected within the howLong limit.
-Use this in place of wait_until_by_text when the wait time needs to be longer than the test automation default.
-=end
-  def hold_for_text(browser, howLong, text, desc = '', threshold = 20, interval = 0.25)
-    countdown = howLong
-    while ((not browser.contains_text(text)) and countdown > 0)
-      sleep(interval)
-      countdown = countdown - interval
-    end
-    if countdown < howLong
-      waittime = howLong - countdown
-      passed_tolog("#{__method__}  '#{text}' found after #{waittime} second(s) #{desc}")
-      if waittime > threshold
-        failed_tolog("#{__method__}  '#{text}' took #{waittime} second(s). (threshold: #{threshold} seconds) #{desc}")
-      end
-      true
-    else
-      failed_tolog("#{__method__}  '#{text}' not found after #{howLong} second(s) #{desc}")
-      false
-    end
-  rescue
-    failed_tolog("Unable to #{__method__} '#{text}'. '#{$!}' #{desc}")
-  end
-
-  alias wait_for_text hold_for_text
-
-  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 get_save_file_path(root, filename)
-    filespec = "#{root}/file/#{filename}"
-    filespec.gsub!('/', '\\')
-  end
-
-  def save_file_orig(filepath, desc = '', wait = WAIT)
-    #    title = translate_popup_title(title)
-    @ai.WinWait("File Download", "", wait)
-    @ai.ControlFocus("File Download", "", "&Save")
-    sleep 1
-    @ai.ControlClick("File Download", "", "&Save", "left")
-    @ai.WinWait("Save As", "", wait)
-    sleep 1
-    @ai.ControlSend("Save As", "", "Edit1", filepath)
-    @ai.ControlClick("Save As", "", "&Save", "left")
-    sleep 1
-    @ai.WinWait("Download complete", "", wait)
-    @ai.ControlClick("Download complete", "", "Close")
-  end
-
-  #TODO This and save_file2 have to be combined somehow.
-  def save_file1(filepath, title = "File Download", desc = '', wait = WAIT)
-    title = translate_popup_title(title)
-    @ai.WinWait(title, '', wait)
-    @ai.WinActivate(title, '')
-    sleep 1
-    @ai.ControlFocus(title, "", "&Save")
-    sleep 3
-    @ai.ControlClick(title, "", "&Save", "primary")
-    sleep 2
-    @ai.ControlClick(title, "", "Save", "primary")
-
-    @ai.WinWait("Save As", "", wait)
-    sleep 1
-    @ai.ControlSend("Save As", "", "Edit1", filepath)
-    @ai.ControlFocus("Save As", "", "&Save")
-    @ai.ControlClick("Save As", "", "&Save", "primary")
-    @ai.ControlClick("Save As", "", "Save", "primary")
-
-    @ai.WinWait("Download complete", "", wait)
-    passed_to_log("Save file '#{filepath}' succeeded. #{desc}")
-    @ai.ControlClick("Download complete", "", "Close")
-  rescue
-    failed_to_log("Save file failed: #{desc} '#{$!}'. (#{__LINE__})")
-  end
-
-  def save_file2(filepath, title = "File Download - Security Warning", desc = '', wait = WAIT)
-    title = translate_popup_title(title)
-    sleep(1)
-    @ai.WinWait(title, '', wait)
-    dl_hndl    = @ai.WinGetHandle(title, '')
-    dl_sv_hndl = @ai.ControlGetHandle(title, '', "&Save")
-    @ai.WinActivate(title, '')
-    sleep 1
-    @ai.ControlFocus(title, "", "&Save")
-    sleep 1
-    @ai.ControlFocus(title, "", "Save")
-    sleep 1
-    @ai.ControlClick(title, "", "&Save", "primary")
-    sleep 1
-    @ai.ControlClick(title, "", "Save", "primary")
-    sleep 1
-    w = WinClicker.new
-    w.clickButtonWithHandle(dl_sv_hndl)
-    sleep 1
-    w.clickWindowsButton_hwnd(dl_hndl, "Save")
-    sleep 1
-    w.clickWindowsButton_hwnd(dl_hndl, "&Save")
-
-    @ai.WinWait("Save As", "", wait)
-    sleep 1
-    @ai.ControlSend("Save As", "", "Edit1", filepath)
-    @ai.ControlFocus("Save As", "", "&Save")
-    @ai.ControlClick("Save As", "", "&Save", "primary")
-
-    @ai.WinWait("Download complete", "", wait)
-    passed_to_log("Save file '#{filepath}' succeeded. #{desc}")
-    @ai.ControlClick("Download complete", "", "Close")
-  rescue
-    failed_to_log("Save file failed: #{desc} '#{$!}'. (#{__LINE__})")
-  end
-
-  #method for handling save dialog
-  #use click_no_wait on the action that triggers the save dialog
-  def save_file(filepath, download_title = "File Download - Security Warning")
-  # TODO need version for Firefox
-  # TODO need to handle first character underline, e.g. 'Cancel' and '&Cancel'
-    download_title   = translate_popup_title(download_title)
-    download_text    = ''
-    download_control = "&Save"
-    saveas_title     = 'Save As'
-    saveas_text      = ''
-    saveas_control   = "Edit1"
-    dnld_cmplt_title = "Download Complete"
-    dnld_cmplt_title = translate_popup_title(dnld_cmplt_title)
-    dnld_cmplt_text  = ""
-    #    save_title = ""
-    side             = 'primary'
-    msgdl            = "Window '#{download_title}':"
-    msgsa            = "Window '#{saveas_title}':"
-    msgdc            = "Window '#{dnld_cmplt_title}':"
-    begin
-      if @ai.WinWait(download_title, download_text, WAIT)
-        @ai.WinActivate(download_title, download_text)
-        if @ai.WinActive(download_title, download_text)
-          dl_title = @ai.WinGetTitle(download_title, download_text)
-          #          dl_hndl  = @ai.WinGetHandle(download_title, download_text)
-          #          dl_text  = @ai.WinGetText(download_title, download_text)
-          #          dl_sv_hndl = @ai.ControlGetHandle(dl_title, '', download_control)
-          #          dl_op_hndl = @ai.ControlGetHandle(dl_title, '', '&Open')
-          #          dl_cn_hndl = @ai.ControlGetHandle(dl_title, '', 'Cancel')
-          debug_to_log("#{msgdl} activated. (#{__LINE__})")
-
-          if @ai.ControlFocus(dl_title, download_text, download_control)
-            debug_to_log("#{msgdl} focus gained. (#{__LINE__})")
-
-            @ai.Send("S")
-            #              @ai.ControlSend(dl_Stitle, download_text, download_control, "{ENTER}")
-            sleep_for 1
-
-            if @ai.ControlClick(dl_title, download_text, download_control, side)
-              debug_to_log("#{msgdl} click succeeded on '#{download_control}'. (#{__LINE__})")
-
-              if @ai.WinWait(saveas_title, saveas_text, WAIT)
-                debug_to_log("#{msgsa} appeared. (#{__LINE__})")
-                sleep_for 1
-                if @ai.ControlSend(saveas_title, saveas_text, saveas_control, filepath)
-                  debug_to_log("#{msgsa} controlsend of '#{saveas_control}' succeeded. (#{__LINE__})")
-
-                  @ai.Send("S")
-                  @ai.ControlSend(saveas_title, saveas_text, saveas_control, "{ENTER}")
-                  sleep_for 1
-
-                  if @ai.ControlClick(saveas_title, saveas_text, saveas_control, side)
-                    passed_to_log("#{msgsa} click succeeded on '#{saveas_control}'. (#{__LINE__})")
-                    if @ai.WinWait(dnld_cmplt_title, dnld_cmplt_text, WAIT)
-                      debug_to_log("#{msgdc} appeared. (#{__LINE__})")
-                      sleep_for 1
-                      if @ai.ControlClick(dnld_cmplt_title, dnld_cmplt_text, "Close", side)
-                        passed_to_log("Save file for #{filepath} succeeded.")
-                      else
-                        failed_to_log("#{msgdc} click failed on 'Close'. (#{__LINE__})")
-                      end
-                    else
-                      failed_to_log("#{msgdc} did not appear after #{WAIT} seconds. (#{__LINE__})")
-                    end
-                  else
-                    failed_to_log("#{msgsa} click failed on '#{saveas_control}'. (#{__LINE__})")
-                  end
-                else
-                  failed_to_log("#{msgsa} controlsend of '#{saveas_control}' failed. (#{__LINE__})")
-                end
-              else
-                failed_to_log("#{msgsa} did not appear after #{WAIT} seconds. (#{__LINE__})")
-              end
-            else
-              failed_to_log("#{msgdl} click failed on '#{download_control}'. (#{__LINE__})")
-            end
-          else
-            failed_to_log("#{msgdl} Unable to gain focus on control '#{dl_title}'. (#{__LINE__})")
-          end
-        else
-          failed_to_log("#{msgdl} Unable to activate. (#{__LINE__})")
-        end
-      else
-        failed_to_log("#{msgdl} did not appear after #{WAIT} seconds. (#{__LINE__})")
-      end
-    rescue
-      failed_to_log("Save file failed: '#{$!}'. (#{__LINE__})")
-    end
-  end
-
-  def close_log(scriptName, lnbr = '')
-    cmplTS = Time.now.to_f.to_s
-    puts ("#{scriptName} finished.  Closing log. #{lnbr.to_s}")
-    passed_to_log("#{scriptName} run complete [#{cmplTS}]")
-    @myLog.close()
-    sleep(2)
-  end
-
-  protected :close_log
-
-  #method for cancelling Print window
-  # TODO need to handle 'Cancel' and '&Cancel' (first character underlined)
-  def close_print(title = 'Print', text = '', button = '&Cancel', side = 'left')
-    msg = "Popup: title=#{title} button='#{button}' text='#{text}' side='#{side}':"
-    if @ai.WinWait(title, text, WAIT)
-      passed_to_log("#{msg} found.")
-      @ai.WinActivate(title)
-      if @ai.WinActive(title, text)
-        passed_to_log("#{msg} activated.")
-        if @ai.ControlFocus(title, text, button)
-          passed_to_log("#{msg} focus attained.")
-          if @ai.ControlClick(title, text, button, side)
-            passed_to_log("#{msg} closed successfully.")
-          else
-            failed_to_log("#{msg} click failed on button (#{__LINE__})")
-          end
-        else
-          failed_to_log("#{msg} Unable to gain focus on button (#{__LINE__})")
-        end
-      else
-        failed_to_log("#{msg} Unable to activate (#{__LINE__})")
-      end
-    else
-      failed_to_log("#{msg} did not appear after #{WAIT} seconds. (#{__LINE__})")
-    end
-  rescue
-    failed_to_log("Close #{msg}: '#{$!}'. (#{__LINE__})")
-  end
-
-  #method for handling file download dialog
-  #use click_no_wait on the action that triggers the save dialog
-  # TODO need version for Firefox
-  # TODO need to handle 'Cancel' and '&Cancel' (first character underlined)
-  # TODO replace call to close_modal_ie with actual file download
-  def file_download(browser = nil)
-    title  = 'File Download'
-    title  = translate_popup_title(title)
-    text   = ''
-    button = 'Cancel'
-    if @browserAbbrev == 'IE'
-      close_popup(title, button, text)
-    else
-
-    end
-  end
-
-  #method for handling file upload dialog
-  #use click_no_wait on the action that triggers the save dialog
-  # TODO need version for Firefox
-  def file_upload(filepath)
-    title   = 'Choose File'
-    title   = translate_popup_title(title)
-    text    = ''
-    button  = "&Open"
-    control = "Edit1"
-    side    = 'primary'
-    msg     = "Window title=#{title} button='#{button}' text='#{text}' side='#{side}':"
-    begin
-      if @ai.WinWait(title, text, WAIT)
-        passed_to_log("#{msg} found.")
-        @ai.WinActivate(title, text)
-        if @ai.WinActive(title, text)
-          passed_to_log("#{msg} activated.")
-          if @ai.ControlSend(title, text, control, filepath)
-            passed_to_log("#{msg} #{control} command sent.")
-            sleep_for 1
-            if @ai.ControlClick(title, text, button, "primary")
-              passed_to_log("#{msg} Upload of #{filepath} succeeded.")
-            else
-              failed_to_log("#{msg} Upload of #{filepath} failed. (#{__LINE__})")
-            end
-          else
-            failed_to_log("#{msg} Unable to select #{filepath}. (#{__LINE__})")
-          end
-        else
-          failed_to_log("#{msg} Unable to activate. (#{__LINE__})")
-        end
-      else
-        failed_to_log("#{msg} did not appear after #{WAIT} seconds. (#{__LINE__})")
-      end
-    rescue
-      failed_to_log("#{msg} Unable to upload: '#{$!}'. (#{__LINE__})")
-    end
-
-  end
-
-  def find_popup(browser, how, what, desc = '')
-    msg   = "Find popup :#{how}=>'#{what}'. #{desc}"
-    popup = Watir::IE.find(how, what) # TODO: too browser specific
-    sleep_for(1)
-    debug_to_log("#{popup.inspect}")
-    if is_browser?(popup)
-#      title = popup.title
-      passed_to_log(msg)
-      return popup
-    else
-      failed_to_log(msg)
-    end
-  rescue
-    failed_to_log("Unable to find popup :#{how}=>'#{what}'. #{desc} '#{$!}' (#{__LINE__})")
-  end
-
-  def find_sheet_with_name(workbook, sheet_name)
-    sheets = workbook.sheets
-    idx    = 0
-    found  = false
-    sheets.each do |s|
-      if s == sheet_name
-        found = true
-        break
-      end
-      idx += 1
-    end
-    if found
-      idx
-    else
-      -1
-    end
-  end
-
-  # howLong is integer, whatFor is a browser object
-  def wait_for_text(browser, howLong, text)
-    countdown = howLong
-    while ((not browser.contains_text(text)) and countdown > 0)
-      sleep(1)
-      countdown = countdown - 1
-    end
-    if countdown
-      passed_tolog("wait_for_text '#{text}' found after #{howLong} second(s)")
-    else
-      failed_tolog("wait_for_text '#{text}' not foundafter #{howLong} second(s)")
-    end
-    countdown
-  end
-
-  def wait_for_element_to_reappear(browser, how, what, desc = '', timeout = 20)
-    msg = "Element #{how}=#{what} exists. #{desc}"
-    wait_while(browser, "While: #{msg}", timeout) { browser.element(how, what).exists? }
-    wait_until(browser, "Until: #{msg}", timeout) { browser.element(how, what).exists? }
-  end
-
-  # howLong is integer, whatFor is a browser object
-  def wait_for_exists(howLong, whatFor)
-    wait_for(howLong, whatFor)
-  end
-
-  def wait_for(howLong, whatFor)
-    countdown = howLong
-    while ((not whatFor.exists?) and countdown > 0)
-      sleep(1)
-      puts whatFor.inspect+':'+countdown.to_s
-      countdown = countdown - 1
-    end
-    if countdown
-      puts 'found '+whatFor.inspect
-      passed_tolog("wait_for (#{howLong} found "+whatFor.inspect)
-    else
-      puts 'Did not find '+whatFor.inspect
-      failed_tolog("wait_for (#{howLong} did not find "+whatFor.inspect)
-    end
-    countdown
-  end
-
-  def wait_the_hard_way(browser, how, what, wait = 6, intvl = 0.25)
-    count = (wait / intvl).to_i + 1
-    tally = 0
-    ok    = (1 / intvl).to_i + 1
-    debug_to_log("#{__method__}: wait: #{wait} secs; intvl: #{intvl} secs; count; #{count}; thresh: #{ok}")
-    (1..count).each do |x|
-      begin
-        if browser.element(how, what).exists?
-          tally += 1
-          debug_to_log("#{x}: #{(x - 1) * intvl}: #{what} exists.")
-        else
-          tally = 0
-          debug_to_log("#{x}: #{(x - 1) * intvl}: #{what} does not exist.")
-        end
-      rescue
-        tally = 0
-        debug_to_log("#{x}: #{(x - 1) * intvl}: #{what} rescue: #{$!}")
-      end
-      if tally >= ok
-        return true
-      end
-      sleep(intvl)
-    end
-  end
-
-  def is_browser?(browser)
-    myClass = browser.class.to_s
-    case @targetBrowser.abbrev
-      when 'IE'
-        myClass =~ /Watir::/i # TODO: should this be /Watir::IE/i ?
-      when 'FF'
-        if @version.to_f < 4.0
-          myClass =~ /FireWatir::/i
-        else
-          myClass =~ /Watir::Browser/i
-        end
-      when 'S'
-        myClass =~ /Watir::Safari/i
-      when 'C'
-        myClass =~ /Watir::Browser/i
-    end
-  end
-
-  alias is_browser is_browser?
-
-  def nice_array(arr, space_to_underscore = false)
-    new_arr = Array.new
-    if space_to_underscore
-      arr.each do |nty|
-        new_arr << nty.gsub(/\s/, '_')
-      end
-    else
-      new_arr = arr
-    end
-    "['#{new_arr.join("','")}']"
-  end
-
-  def open_browser(url = nil)
-    debug_to_log("Opening browser: #{@targetBrowser.name}")
-    debug_to_log("#{__method__}: [#{get_caller_line}] #{get_callers}")
-    case @targetBrowser.abbrev
-      when 'IE'
-        @myBrowser = open_ie
-        @myHwnd    = @myBrowser.hwnd
-      #@waiter    = Watir::Waiter.new(WAIT)
-      when 'FF'
-        #version    = "11"
-        #@myBrowser = open_ff_for_version(version)
-        @myBrowser = open_ff_for_version
-      when 'S'
-        debug_to_log("Opening browser: #{@targetBrowser.name} legacy.rb:#{__LINE__}")
-        aBrowser = Watir::Safari.new
-        debug_to_log("Browser instantiated")
-        @myBrowser = aBrowser
-      #require 'shamisen/awetest_legacy/safari_waiter'
-      #@waiter    = Watir::Waiter
-      when 'C', 'GC'
-        @myBrowser = open_chrome
-      ##require 'shamisen/awetest_legacy/webdriver_waiter'
-      #require 'shamisen/support/webdriver_ext/browser'
-      #@waiter    = Watir::Waiter
-
-      else
-        raise "Unsupported browser: #{@targetBrowser.name}"
-    end
-    get_browser_version(@myBrowser)
-    if url
-      go_to_url(@myBrowser, url)
-    end
-    @myBrowser
-  end
-
-  def open_ie(process = true)
-    check_for_and_clear_other_browsers
-    Watir::Browser.default = 'ie'
-    #if process && !IS_WIN_2008
-    #  browser = Watir::IE.new_process
-    #else
-    browser                = Watir::IE.new
-    #end
-    browser
-  end
-
-  def open_ff_for_version(version = @targetVersion)
-    if version.to_f < 4.0
-      browser = open_ff
-      #waiter  = Watir::Waiter.new(WAIT)
-    else
-      browser = Watir::Browser.new(:firefox)
-      #require 'shamisen/awetest_legacy/webdriver_waiter'
-      #waiter = Watir::Waiter
-    end
-    browser
-  end
-
-  def open_ff
-    Watir::Browser.default = 'firefox'
-    browser                = Watir::Browser.new
-  end
-
-  def open_chrome
-    browser = Watir::Browser.new(:chrome)
-  end
-
-  #Get the browser to navigate to a given url.  If not supplied in the second argument,
-  #defaults to value of FullScript.myURL, which is populated from ApplicationEnvironment.url.
-
-  def go_to_url(browser, url = nil, redirect = nil)
-    if url
-      @myURL = url
-    end
-    message_tolog("URL: #{@myURL}")
-    browser.goto(@myURL)
-    if validate(browser, @myName, __LINE__)
-#      TODO .url method returns blank in Firewatir
-      if redirect
-        passed_to_log("Redirected to url '#{browser.url}'.")
-        true
-      elsif browser.url =~ /#{@myURL}/i # or @browserAbbrev == 'FF'
-        passed_to_log("Navigated to url '#{@myURL}'.")
-        true
-      else
-        failed_to_log("Navigated to url '#{browser.url}' but expected '#{@myURL}'.")
-      end
-    end
-  rescue
-    fatal_to_log("Unable to navigate to '#{@myURL}': '#{$!}'")
-  end
-
-
   #--
   ##def open_log
   #  start = Time.now.to_f.to_s
@@ -2441,2283 +23,18 @@ Use this in place of wait_until_by_text when the wait time needs to be longer th
   #end
   #++
 
-# :category: User Input
-  def click(browser, element, how, what, desc = '')
-    #debug_to_log("#{__method__}: #{element}, #{how}, #{what}")
-    msg = "Click #{element} :#{how}=>'#{what}'"
-    msg << ", '#{desc}'" if desc.length > 0
-    msg1 = "#{element}(#{how}, '#{what}')"
-    begin
-      case element
-        when :link
-          browser.link(how, what).click
-        when :button
-          browser.button(how, what).click
-        when :image
-          browser.image(how, what).click
-        when :radio
-          case how
-            when :index
-              set_radio_by_index(browser, what, desc)
-            else
-              browser.radio(how, what).set
-          end
-        when :span
-          browser.span(how, what).click
-        when :div
-          browser.div(how, what).click
-        when :cell
-          browser.cell(how, what).click
-        else
-          browser.element(how, what).click
-      end
-    rescue => e
-      if not rescue_me(e, __method__, "browser(#{msg1}).click", "#{browser.class}")
-        raise e
-      end
-    end
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("Unable to #{msg}. '#{$!}'")
-  end
-
-# :category: User Input
-  def click_no_wait(browser, element, how, what, desc = '')
-    debug_to_log("#{__method__}: #{element}, #{how}, #{what}")
-    msg = "Click no wait #{element} :#{how}=>'#{what}'"
-    msg << ", '#{desc}'" if desc.length > 0
-    msg1 = "#{element}(#{how}, '#{what}'"
-    begin
-      case element
-        when :link
-          browser.link(how, what).click_no_wait
-        when :button
-          browser.button(how, what).click_no_wait
-        when :image
-          browser.image(how, what).click_no_wait
-        when :radio
-          case how
-            when :index
-              set_radio_no_wait_by_index(browser, what, desc)
-            else
-              browser.radio(how, what).click_no_wait
-          end
-        when :span
-          browser.span(how, what).click_no_wait
-        when :div
-          browser.div(how, what).click_no_wait
-        when :checkbox
-          browser.checkbox(how, what).click_no_wait
-        when :cell
-          browser.cell(how, what).click_no_wait
-        else
-          browser.element(how, what).click_no_wait
-      end
-    rescue => e
-      if not rescue_me(e, __method__, "browser(#{msg1}').click_no_wait", "#{browser.class}")
-        raise e
-      end
-    end
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("Unable to #{msg}  '#{$!}'")
-    sleep_for(1)
-  end
-
-# :category: User Input
-  def click_button_by_id(browser, strg, desc = '')
-    click(browser, :button, :id, strg, desc)
-  end
-# :category: User Input
-  def click_link_by_index(browser, strg, desc = '')
-    click(browser, :link, :index, strg, desc)
-  end
-# :category: User Input
-  def click_link_by_href(browser, strg, desc = '')
-    click(browser, :link, :href, strg, desc)
-  end
-
-  alias click_href click_link_by_href
-# :category: User Input
-  def click_link_no_wait_by_href(browser, strg, desc = '')
-    click_no_wait(browser, :link, :href, strg, desc)
-  end
-
-  alias click_href_no_wait click_link_no_wait_by_href
-# :category: User Input
-  def click_button_by_index(browser, index, desc = '')
-    click(browser, :button, :index, index, desc)
-  end
-# :category: User Input
-  def click_button_by_name(browser, strg, desc = '')
-    click(browser, :button, :name, strg, desc)
-  end
-# :category: User Input
-  def click_button_by_text(browser, strg, desc = '')
-    click(browser, :button, :text, strg, desc)
-  end
-# :category: User Input
-  def click_button_by_class(browser, strg, desc = '')
-    click(browser, :button, :class, strg, desc)
-  end
-# :category: User Input
-  def click_button_no_wait_by_id(browser, strg, desc = '')
-    click_no_wait(browser, :button, :id, strg, desc)
-  end
-
-  alias click_button_by_id_no_wait click_button_no_wait_by_id
-# :category: User Input
-  def click_button_no_wait_by_name(browser, strg, desc = '')
-    click_no_wait(browser, :button, :name, strg, desc)
-  end
-# :category: User Input
-  def click_button_no_wait_by_class(browser, strg, desc = '')
-    click_no_wait(browser, :button, :class, strg, desc)
-  end
-
-  alias click_button_by_class_no_wait click_button_no_wait_by_class
-# :category: User Input
-  def click_button_by_value(browser, strg, desc = '')
-    click(browser, :button, :value, strg, desc)
-  end
-# :category: User Input
-  def click_button_by_title(browser, strg, desc = '')
-    click(browser, :button, :title, strg, desc)
-  end
-# :category: User Input
-  def click_button_by_xpath_and_id(browser, strg, desc = '')
-    msg = "Click button by xpath and id '#{strg}' #{desc}"
-    if browser.button(:xpath, "//a[@id = '#{strg}']").click
-      passed_to_log(msg)
-      true
-    else
-      failed_to_log(msg)
-    end
-  rescue
-    failed_to_log("Unable to click button by xpath and id '#{strg}' #{desc} '#{$!}' (#{__LINE__})")
-  end
-
-  alias click_button_by_xpath click_button_by_xpath_and_id
-# :category: User Input
-  def click_link_by_id(browser, strg, desc = '')
-    click(browser, :link, :id, strg, desc)
-  end
-
-  alias click_id click_link_by_id
-# :category: User Input
-  def click_link_by_name(browser, strg, desc = '')
-    click(browser, :link, :name, strg, desc)
-  end
-
-  alias click_name click_link_by_name
-# :category: User Input
-  def click_link_by_xpath_and_id(browser, strg, desc = '')
-    msg = "Click link by xpath and id '#{strg}' #{desc}"
-    if browser.link(:xpath, "//a[@id = '#{strg}']").click
-      passed_to_log(msg)
-      true
-    else
-      failed_to_log(msg)
-    end
-  rescue
-    failed_to_log("Unable click on link by xpath and id '#{strg}' #{desc} '#{$!}' (#{__LINE__})")
-  end
-
-  alias click_link_by_xpath click_link_by_xpath_and_id
-# :category: User Input
-  def click_link_no_wait_by_id(browser, strg, desc = '')
-    click_no_wait(browser, :link, :id, strg, desc)
-  end
-
-  alias click_no_wait_id click_link_no_wait_by_id
-  alias click_no_wait_by_id click_link_no_wait_by_id
-  alias click_id_no_wait click_link_no_wait_by_id
-  alias click_no_wait_link_by_id click_link_no_wait_by_id
-# :category: User Input
-  def click_file_field_by_id(browser, strg, desc = '')
-    click(browser, :file_field, :id, strg, desc)
-  end
-# :category: User Input
-  def click_img_by_alt(browser, strg, desc = '')
-    click(browser, :image, :alt, strg, desc)
-  end
-# :category: User Input
-  def click_img_by_title(browser, strg, desc = '')
-    click(browser, :image, :title, strg, desc)
-  end
-# :category: User Input
-  def click_img_by_xpath_and_name(browser, strg, desc = '')
-    msg = "Click image by xpath where name='#{strg}' #{desc}"
-    if browser.link(:xpath, "//input[@name = '#{strg}']").click
-      passed_to_log(msg)
-      true
-    else
-      failed_to_log(msg)
-    end
-  rescue
-    failed_to_log("Unable to click image by xpath where name='#{strg}' #{desc} '#{$!}'")
-  end
-
-  alias click_img_by_xpath click_img_by_xpath_and_name
-  alias click_image_by_xpath click_img_by_xpath_and_name
-  alias click_image_by_xpath_and_name click_img_by_xpath_and_name
-# :category: User Input
-  def click_img_no_wait_by_alt(browser, strg, desc = '')
-    click_no_wait(browser, :image, :alt, strg, desc)
-  end
-
-  alias click_img_by_alt_no_wait click_img_no_wait_by_alt
-# :category: User Input
-  def click_img_by_src(browser, strg, desc = '')
-    click(browser, :image, :src, strg, desc)
-  end
-# :category: User Input
-  def click_img_by_src_and_index(browser, strg, index, desc = '')
-    msg = "Click image by src='#{strg}' and index=#{index}"
-    msg << " #{desc}" if desc.length > 0
-    browser.image(:src => strg, :index => index).click
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("Unable to #{msg} '#{$!}'")
-  end
-# :category: User Input
-  def click_link_by_value(browser, strg, desc = '')
-    click(browser, :link, :value, strg, desc)
-  end
-# :category: User Input
-  def click_link_by_text(browser, strg, desc = '')
-    click(browser, :link, :text, strg, desc)
-  end
-
-  alias click_link click_link_by_text
-  alias click_text click_link_by_text
-  alias click_js_button click_link_by_text
-# :category: User Input
-  def click_link_by_class(browser, strg, desc = '')
-    click(browser, :link, :class, strg, desc)
-  end
-
-  alias click_class click_link_by_class
-# :category: User Input
-  def click_button_no_wait_by_text(browser, strg, desc = '')
-    click_no_wait(browser, :button, :text, strg, desc)
-  end
-# :category: User Input
-  def click_button_no_wait_by_value(browser, strg, desc = '')
-    click_no_wait(browser, :button, :value, strg, desc)
-  end
-# :category: User Input
-  def click_link_by_name_no_wait(browser, strg, desc = '')
-    click_no_wait(browser, :link, :name, strg, desc)
-  end
-
-  alias click_no_wait_name click_link_by_name_no_wait
-  alias click_name_no_wait click_link_by_name_no_wait
-# :category: User Input
-  def click_link_by_text_no_wait(browser, strg, desc = '')
-    click_no_wait(browser, :link, :text, strg, desc)
-  end
-
-  alias click_no_wait_text click_link_by_text_no_wait
-  alias click_text_no_wait click_link_by_text_no_wait
-# :category: User Input
-  def click_span_by_text(browser, strg, desc = '')
-    if not desc and not strg.match(/Save|Open|Close|Submit|Cancel/)
-      desc = 'to navigate to selection'
-    end
-    msg = "Click span containing text '#{strg}'."
-    msg << " #{desc}" if desc.length > 0
-    if validate(browser, @myName, __LINE__)
-      passed_to_log("#{msg}")
-    end
-  rescue
-    failed_to_log("Unable to #{msg}: '#{$!}'")
-  end
-
-# TODO no logging yet.  slow.# :category: User Input
-  def click_span_with_text(browser, trgt, desc = '')
-    msg = "Find and click span containing text '#{trgt}'."
-    msg << " #{desc}" if desc.length > 0
-    spans = browser.spans
-    x     = 0
-    spans.each do |span|
-      x += 1
-      debug_to_log("Span #{x}: #{span.text}")
-      aText = span.text
-      if aText and aText.size > 0
-        if aText =~ /#{trgt}/
-          break
-        end
-      end
-    end
-    spans[x].click
-  end
-# :category: User Input
-  def click_link_by_title(browser, strg, desc = '')
-    click(browser, :link, :title, strg, desc)
-  end
-
-  alias click_title click_link_by_title
-# :category: User Input
-  def click_title_no_wait(browser, strg, desc = '')
-    click_no_wait(browser, :link, :title, strg, desc)
-  end
-# :category: User Input
-  def click_table_row_with_text_by_id(browser, ptrn, strg, column = nil)
-    msg   = "id=#{ptrn} row with text='#{strg}"
-    table = get_table_by_id(browser, /#{ptrn}/)
-    if table
-      index = get_index_of_row_with_text(table, strg, column)
-      if index
-        table[index].click
-        if validate(browser, @myName, __LINE__)
-          passed_to_log("Click #{msg} row index=#{index}.")
-          index
-        end
-      else
-        failed_to_log("Table #{msg} not found to click.")
-      end
-    else
-      failed_to_log("Table id=#{ptrn} not found.")
-    end
-  rescue
-    failed_to_log("Unable to click table #{msg}: '#{$!}' (#{__LINE__}) ")
-  end
-# :category: User Input
-  def click_table_row_with_text_by_index(browser, idx, strg, column = nil)
-    msg   = "index=#{idx} row with text='#{strg}"
-    table = get_table_by_index(browser, idx)
-    if table
-      index = get_index_of_row_with_text(table, strg, column)
-      if index
-        table[index].click
-        if validate(browser, @myName, __LINE__)
-          passed_to_log("Click #{msg} row index=#{index}.")
-          index
-        end
-      else
-        failed_to_log("Table #{msg} not found to click.")
-      end
-    else
-      failed_to_log("Table id=#{ptrn} not found.")
-    end
-  rescue
-    failed_to_log("Unable to click table #{msg}: '#{$!}' (#{__LINE__}) ")
-  end
-
-  def double_click_table_row_with_text_by_id(browser, ptrn, strg, column = nil)
-    msg   = "id=#{ptrn} row with text='#{strg}"
-    table = get_table_by_id(browser, /#{ptrn}/)
-    if table
-      index = get_index_of_row_with_text(table, strg, column)
-      if index
-        table[index].fire_event('ondblclick')
-        if validate(browser, @myName, __LINE__)
-          passed_to_log("Double click #{msg} row index=#{index}.")
-          index
-        end
-      else
-        failed_to_log("Table #{msg} not found to double click.")
-      end
-    else
-      failed_to_log("Table id=#{ptrn} not found.")
-    end
-  rescue
-    failed_to_log("Unable to double click table #{msg}: '#{$!}' (#{__LINE__}) ")
-  end
-
-  def double_click_table_row_with_text_by_index(browser, idx, strg, column = nil)
-    msg   = "index=#{idx} row with text='#{strg}"
-    table = get_table_by_index(browser, idx)
-    if table
-      index = get_index_of_row_with_text(table, strg, column)
-      if index
-        row = table[index]
-        table[index].fire_event('ondblclick')
-        row.fire_event('ondblclick')
-        if validate(browser, @myName, __LINE__)
-          passed_to_log("Double click #{msg} row index=#{index}.")
-          index
-        end
-      else
-        failed_to_log("Table #{msg} not found to double click.")
-      end
-    else
-      failed_to_log("Table id=#{ptrn} not found.")
-    end
-  rescue
-    failed_to_log("Unable to double click table #{msg}: '#{$!}' (#{__LINE__}) ")
-  end
-
-  def flash_text(browser, strg, count, desc = '')
-    msg = "Flash link text='#{strg}' #{count} times."
-    msg << " #{desc}" if desc.length > 0
-    strgCnt = string_count_in_string(browser.text, strg)
-    if strgCnt > 0
-      browser.link(:text, strg).flash(count)
-      if validate(browser, @myName, __LINE__)
-        passed_to_log(msg)
-        true
-      end
-    else
-      failed_to_log("#{msg} Link not found.")
-    end
-  rescue
-    failed_to_log("Unable to #{msg} '#{$!}'")
-  end
-
-  def flash_id(browser, strg, count)
-    msg = "Flash link id='#{strg}' #{count} times."
-    msg << " #{desc}" if desc.length > 0
-    browser.link(:id, strg).flash(count)
-    if validate(browser, @myName, __LINE__)
-      passed_to_log(msg)
-      true
-    end
-  rescue
-    failed_to_log("Unable to #{msg} '#{$!}'")
-  end
-
-  def flash(element, count = 4)
-    element.flash(count)
-    debug_to_log("'#{element.inspect}' flashed #{count} times.")
-    true
-  rescue
-    debug_to_log("Flash '#{element.inspect}' failed: '#{$!}' (#{__LINE__})")
-  end
-
-  def upload_file(data_path)
-    limit = 180 # .seconds
-    Timeout::timeout(limit) {
-      wait = 20
-      @ai.WinWait("Choose File to Upload", "", wait)
-      sleep 1
-      @ai.ControlSend("Choose File to Upload", "", "Edit1", data_path)
-      @ai.ControlClick("Choose File to Upload", "", "[CLASS:Button; INSTANCE:2]", "left")
-      sleep 4
-      #sleep 1
-    }
-    failed_to_log("Choose File to Upload not found after #{limit} '#{$!}'")
-  rescue Timeout::Error
-    failed_to_log("File Upload timeout after #{limit} '#{$!}'")
-  end
-
-  #TODO put rescue inside the do loop
-  #parameters: browser and a list of column link text values
-  #example: exercise_sorting(browser,['Division', 'Payee', 'Date'], 'Sortable columns on this page')
-
-  def exercise_sorting(browser, columnList, desc = '')
-    columnList.each do |column|
-      click(browser, :link, :text, column, desc)
-    end
-  end
-
-  alias validate_sorting exercise_sorting
-
-  def focus_on_textfield_by_id(browser, strg, desc = '')
-    msg = "Set focus on textfield name='#{strg}' "
-    msg << " #{desc}" if desc.length > 0
-    tf = browser.text_field(:id, strg)
-    if validate(browser, @myName, __LINE__)
-      tf.focus
-      if validate(browser, @myName, __LINE__)
-        passed_to_log(msg)
-        true
-      end
-    end
-  rescue
-    failed_to_log("Unable to #{msg} '#{$!}'")
-  end
-
-  def open_popup_through_link_title(browser, title, pattern, name)
-    click_title(browser, title)
-    #TODO need some kind of wait for process here
-    sleep_for 2
-    attach_iepopup(browser, pattern, name)
-  rescue
-    failed_to_log("Unable to open popup '#{name}': '#{$!}' (#{__LINE__})")
-  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
-
-  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
-
-  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_textfield_value(browser, how, what, desc = '')
-    msg = "Return value in textfield #{how}='#{what}'"
-    msg << " #{desc}" if desc.length > 0
-    tf = browser.text_field(how, what)
-    if validate(browser, @myName, __LINE__)
-      if tf
-        debug_to_log("#{tf.inspect}")
-        vlu = tf.value
-        passed_to_log("#{msg} Value='#{vlu}'")
-        vlu
-      else
-        failed_to_log("#{msg}")
-      end
-    end
-  rescue
-    failed_to_log("Unable to #{msg}: '#{$!}'")
-  end
-
-  def get_textfield_value_by_name(browser, strg, desc = '')
-    get_textfield_value(browser, :name, strg, desc)
-  end
-
-  def get_textfield_value_by_id(browser, strg)
-    get_textfield_value(browser, :id, strg)
-  end
-
-  def string_count_in_string(strg, substrg)
-    count = strg.scan(substrg).length
-    count
-  end
-
-# :category: Helpers
-  def translate_popup_title(title)
-    new_title = title
-    case @browserAbbrev
-      when 'IE'
-        if @browserVersion
-          case @browserVersion
-            when '8.0'
-              case title
-                when "Microsoft Internet Explorer"
-                  new_title = "Message from webpage"
-                when "The page at"
-                  new_title = "Message from webpage"
-              end
-            when '7.0'
-              case title
-                when "Message from webpage"
-                  new_title = "Microsoft Internet Explorer"
-                when "The page at"
-                  new_title = "Windows Internet Explorer"
-              end
-            when '6.0'
-              case title
-                when "Message from webpage"
-                  new_title = "Microsoft Internet Explorer"
-                when "The page at"
-                  new_title = "Microsoft Internet Explorer"
-              end
-            else
-              case title
-                when "Microsoft Internet Explorer"
-                  new_title = "Message from webpage"
-                when "The page at"
-                  new_title = "Message from webpage"
-              end
-          end
-        else
-          case title
-            when "Microsoft Internet Explorer"
-              new_title = "Message from webpage"
-            when "The page at"
-              new_title = "Message from webpage"
-          end
-        end
-      when 'FF'
-        case title
-          when 'File Download'
-            new_title = 'Opening'
-          when "Microsoft Internet Explorer"
-            new_title = 'The page at'
-          when "Message from webpage"
-            new_title = 'The page at'
-        end
-      when 'C'
-        case title
-          when 'File Download'
-            new_title = 'Save As'
-          when "Microsoft Internet Explorer"
-            new_title = 'The page at'
-          when "Message from webpage"
-            new_title = 'The page at'
-        end
-    end
-    new_title
-  end
-
-  #--
-  #def translate_popup_title(title)
-  #  new_title = title
-  #  case @browserAbbrev
-  #    when 'IE'
-  #
-  #
-  #      case title
-  #        when "Microsoft Internet Explorer"
-  #          new_title = "Message from webpage"
-  #        when "The page at"
-  #          new_title = "Message from webpage"
-  #      end
-  #
-  #
-  #
-  #
-  #    when 'FF'
-  #      case title
-  #        when 'File Download'
-  #          new_title = 'Opening'
-  #        when "Microsoft Internet Explorer"
-  #          new_title = 'The page at'
-  #        when "Message from webpage"
-  #          new_title = 'The page at'
-  #      end
-  #
-  #    when 'C'
-  #      case title
-  #        when 'File Download'
-  #          new_title = 'Save As'
-  #        when "Microsoft Internet Explorer"
-  #          new_title = 'The page at'
-  #        when "Message from webpage"
-  #          new_title = 'The page at'
-  #      end
-  #  end
-  #  new_title
+  #def find_me(where, how, what)
+  #  me = where.element(how, what)
+  #  puts me.inspect
+  #rescue
+  #  error_to_log("#{where.inspect} doesn't seem to respond to element() #{$!}")
   #end
-  #++
-
-  def get_browser_version(browser)
-    debug_to_log("starting get_browser_version")
-    case @targetBrowser.abbrev
-      when 'IE'
-        @browserAbbrev  = 'IE'
-        @browserName    = 'Internet Explorer'
-        @browserAppInfo = browser.document.invoke('parentWindow').navigator.appVersion
-        @browserAppInfo =~ /MSIE\s(.*?);/
-        @browserVersion = $1
-      when 'FF'
-        #@browserAbbrev = 'FF'
-        #@browserName   = 'Firefox'
-        #js_stuff       = <<-end_js_stuff
-        #var info = Components.classes["@mozilla.org/xre/app-info;1"]
-        #.getService(Components.interfaces.nsIXULAppInfo);
-        #[info, info.name, info.version];
-        #end_js_stuff
-        #js_stuff.gsub!("\n", " ")
-        #info = browser.execute_script(js_stuff)
-        #info, aName, @browserVersion = info.split(',')
-        #debug_to_log("FF info: [#{info}]")
-        #debug_to_log("FF name: [#{aName}]")
-        #debug_to_log("FF vrsn: [#{@browserVersion}]")
-        @browserAbbrev  = 'FF'
-        @browserName    = 'Firefox'
-        @browserVersion = '6.01' #TODO: get actual version from browser
-        debug_to_log("Firefox, in get_browser_version (#{@browserVersion})")
-      when 'S'
-        @browserAbbrev  = 'S'
-        @browserName    = 'Safari'
-        @browserVersion = '5.0.4' #TODO: get actual version from browser itself
-        debug_to_log("Safari, in get_browser_version (#{@browserVersion})")
-      when 'C'
-        @browserAbbrev  = 'C'
-        @browserName    = 'Chrome'
-        @browserVersion = '11.0' #TODO: get actual version from browser
-        debug_to_log("Chrome, in get_browser_version (#{@browserVersion})")
-    end
-    # if [notify_queue, notify_class, notify_id].all?
-    #  Resque::Job.create(notify_queue, notify_class, :id => notify_id, :browser_used => "#{@browserName} #{@browserVersion}")
-    #end
-  rescue
-    debug_to_log("Unable to determine #{@browserAbbrev} browser version: '#{$!}' (#{__LINE__})")
-
-    # TODO: can we get rid of this?
-    # js for getting firefox version information
-    #      function getAppID() {
-    #        var id;
-    #        if("@mozilla.org/xre/app-info;1" in Components.classes) {
-    #          // running under Mozilla 1.8 or later
-    #          id = Components.classes["@mozilla.org/xre/app-info;1"]
-    #                         .getService(Components.interfaces.nsIXULAppInfo).ID;
-    #        } else {
-    #          try {
-    #            id = Components.classes["@mozilla.org/preferences-service;1"]
-    #                           .getService(Components.interfaces.nsIPrefBranch)
-    #                           .getCharPref("app.id");
-    #          } catch(e) {
-    #            // very old version
-    #            dump(e);
-    #          }
-    #        }
-    #        return id;
-    #      }
-    #      alert(getAppID());
-    # another snippet that shows getting attributes from object
-    #      var info = Components.classes["@mozilla.org/xre/app-info;1"]
-    #                 .getService(Components.interfaces.nsIXULAppInfo);
-    #      // Get the name of the application running us
-    #      info.name; // Returns "Firefox" for Firefox
-    #      info.version; // Returns "2.0.0.1" for Firefox version 2.0.0.1
-  ensure
-    message_to_log("Browser: [#{@browserAbbrev} #{@browserVersion}]")
-  end
-
-  protected :get_browser_version
-
-  def fire_event(browser, element, how, what, event, desc = '')
-    msg  = "#{element.to_s.titlecase}: #{how}=>'#{what}' event:'#{event}'"
-    msg1 = "#{element.to_s.titlecase}(#{how}, '#{what}')"
-    begin
-      case element
-        when :link
-          browser.link(how, what).fire_event(event)
-        when :button
-          browser.button(how, what).fire_event(event)
-        when :image
-          browser.image(how, what).fire_event(event)
-        when :span
-          browser.span(how, what).fire_event(event)
-        when :div
-          browser.div(how, what).fire_event(event)
-        else
-          browser.element(how, what).fire_event(event)
-      end
-    rescue => e
-      if not rescue_me(e, __method__, "browser(#{msg1}).fire_event('#{event}')", "#{browser.class}")
-        raise e
-      end
-    end
-    if validate(browser, @myName, __LINE__)
-      passed_to_log("Fire event: #{msg}. #{desc}")
-      true
-    end
-  rescue
-    failed_to_log("Unable to fire event: #{msg}. '#{$!}' #{desc}")
-  end
-
-  def fire_event_on_link_by_text(browser, strg, event = 'onclick', desc = '')
-    fire_event(browser, :link, :text, strg, event, desc)
-  end
-
-  alias fire_event_text fire_event_on_link_by_text
-  alias fire_event_by_text fire_event_on_link_by_text
-
-  def fire_event_on_link_by_id(browser, strg, event = 'onclick', desc = '')
-    fire_event(browser, :link, :id, strg, event, desc)
-  end
-
-  alias fire_event_id fire_event_on_link_by_id
-  alias fire_event_by_id fire_event_on_link_by_id
-
-  def fire_event_on_image_by_src(browser, strg, event = 'onclick', desc = '')
-    fire_event(browser, :img, :src, strg, event, desc)
-  end
-
-  alias fire_event_src fire_event_on_image_by_src
-  alias fire_event_image_by_src fire_event_on_image_by_src
-
-# :category: Waits
-  def wait_until_exists(browser, element, how, what, desc = '')
-    msg = "Wait until (#{element} :#{how}=>#{what}) exists."
-    msg << " #{desc}" if desc.length > 0
-    start = Time.now.to_f
-    # TODO: try Watir::Wait.until { browser.element(how, what).exists? } instead of this (cumbersome) case statement
-    # TODO: above fails on frame
-    begin
-      case element
-        when :link
-          Watir::Wait.until { browser.link(how, what).exists? }
-        when :button
-          Watir::Wait.until { browser.button(how, what).exists? }
-        when :radio
-          Watir::Wait.until { browser.radio(how, what).exists? }
-        when :checkbox
-          Watir::Wait.until { browser.checkbox(how, what).exists? }
-        when :div
-          Watir::Wait.until { browser.div(how, what).exists? }
-        when :select_list
-          Watir::Wait.until { browser.select_list(how, what).exists? }
-        when :text_field
-          Watir::Wait.until { browser.text_field(how, what).exists? }
-        when :frame
-          Watir::Wait.until { browser.frame(how, what).exists? }
-        when :form
-          Watir::Wait.until { browser.form(how, what).exists? }
-        when :cell
-          Watir::Wait.until { browser.cell(how, what).exists? }
-        when :image
-          Watir::Wait.until { browser.image(how, what).exists? }
-        else
-          Watir::Wait.until { browser.element(how, what).exists? }
-      end
-    rescue => e
-      if e.class.to_s =~ /TimeOutException/
-        failed_to_log("#{msg}: '#{$!}'")
-        return false
-      elsif not rescue_me(e, __method__, "#{block.to_s}", "#{browser.class}")
-        raise e
-      end
-    end
-    stop = Time.now.to_f
-    #debug_to_log("#{__method__}: start:#{start} stop:#{stop}")
-    #    sleep 1
-    if validate(browser, @myName, __LINE__)
-      passed_to_log("#{msg} (#{stop - start} seconds)")
-      true
-    end
-  rescue
-    failed_to_log("Unable to complete #{msg}: '#{$!}'")
-  end
-
-# :category: Waits
-  def wait_while(browser, desc, timeout = 45, &block)
-  #TODO: Would like to be able to see the block code in the log message instead of the identification
-    msg   = "Wait while #{desc}:"
-    start = Time.now.to_f
-    begin
-      #Watir::Wait.until(timeout) { block.call(nil) }
-      if block.call(nil)
-        Watir::Wait.while(timeout) { block.call(nil) }
-      end
-    rescue => e
-      if e.class.to_s =~ /TimeOutException/ or e.message =~ /timed out/
-        failed_to_log("#{msg}: '#{$!}' ")
-        return false
-      elsif not rescue_me(e, __method__, "#{block.to_s}", "#{browser.class}")
-        raise e
-      end
-    end
-    stop = Time.now.to_f
-    #debug_to_log("#{__method__}: start:#{start} stop:#{stop} block: #{block.to_s}")
-    #    sleep 1
-    if validate(browser, @myName, __LINE__)
-      passed_to_log("#{msg} (#{"%.5f" % (stop - start)} seconds)") #  {#{block.to_s}}")
-      true
-    end
-  rescue
-    failed_to_log("Unable to complete #{msg}. '#{$!}'")
-  end
-
-  alias wait_while_true wait_while
-
-# :category: Waits
-  def wait_until(browser, desc, timeout = 45, skip_pass = false, &block)
-  #TODO: Would like to be able to see the block code in the log message instead of the identification
-    msg   = "Wait until #{desc}"
-    start = Time.now.to_f
-    begin
-      Watir::Wait.until(timeout) { block.call(nil) }
-    rescue => e
-      if e.class.to_s =~ /TimeOutException/ or e.message =~ /timed out/
-        failed_to_log("#{msg} '#{$!}'")
-        return false
-      elsif not rescue_me(e, __method__, "#{block.to_s}", "#{browser.class}")
-        raise e
-      end
-    end
-    stop = Time.now.to_f
-    #debug_to_log("#{__method__}: start:#{start} stop:#{stop} block: #{block.to_s}")
-    #    sleep 1
-    if validate(browser, @myName, __LINE__)
-      passed_to_log("#{msg} (#{"%.5f" % (stop - start)} seconds)") unless skip_pass #  {#{block.to_s}}")
-      true
-    end
-  rescue
-    failed_to_log("Unable to complete #{msg}  '#{$!}'")
-  end
-
-  alias wait_until_true wait_until
-
-# :category: Waits
-  def wait_until_by_radio_value(browser, strg, desc = '')
-    wait_until_exists(browser, :radio, :value, strg, desc)
-  end
-
-# :category: Waits
-  def wait_until_ready(browser, how, what, desc = '', timeout = 90, verbose = false)
-    msg = "#{__method__.to_s.titleize}: element: #{how}='#{what}'"
-    msg << " #{desc}" if desc.length > 0
-    proc_exists  = Proc.new { browser.element(how, what).exists? }
-    proc_enabled = Proc.new { browser.element(how, what).enabled? }
-    case how
-      when :href
-        proc_exists  = Proc.new { browser.link(how, what).exists? }
-        proc_enabled = Proc.new { browser.link(how, what).enabled? }
-    end
-    if verbose
-      if wait_until(browser, "#{msg} Element exists.", timeout) { proc_exists.call(nil) }
-        if wait_until(browser, "#{msg} Element enabled.", timeout) { proc_enabled.call(nil) }
-          passed_to_log(msg)
-          true
-        else
-          failed_to_log(msg)
-        end
-      else
-        failed_to_log(msg)
-      end
-    else
-      start = Time.now.to_f
-      if Watir::Wait.until(timeout) { proc_exists.call(nil) }
-        if Watir::Wait.until(timeout) { proc_enabled.call(nil) }
-          stop = Time.now.to_f
-          #debug_to_log("#{__method__}: start:#{"%.5f" % start} stop:#{"%.5f" % stop}")
-          passed_to_log("#{msg} (#{"%.5f" % (stop - start)} seconds)")
-          true
-        else
-          failed_to_log(msg)
-        end
-      else
-        failed_to_log(msg)
-      end
-    end
-  rescue
-    failed_to_log("Unable to #{msg}. '#{$!}'")
-  end
-
-# :category: Waits
-  def wait_until_ready_quiet(browser, how, what, desc = '', timeout = 45, quiet = true)
-    msg = "#{__method__.to_s.titleize}: element: #{how}='#{what}'"
-    msg << " #{desc}" if desc.length > 0
-    proc_exists  = Proc.new { browser.element(how, what).exists? }
-    proc_enabled = Proc.new { browser.element(how, what).enabled? }
-    case how
-      when :href
-        proc_exists  = Proc.new { browser.link(how, what).exists? }
-        proc_enabled = Proc.new { browser.link(how, what).enabled? }
-    end
-    start = Time.now.to_f
-    if Watir::Wait.until(timeout) { proc_exists.call(nil) }
-      if Watir::Wait.until(timeout) { proc_enabled.call(nil) }
-        stop = Time.now.to_f
-        #debug_to_log("#{msg}: start:#{"%.5f" % start} stop:#{"%.5f" % stop}")
-        passed_to_log("#{msg} (#{"%.5f" % (stop - start)} seconds)") unless quiet
-        true
-      else
-        failed_to_log(msg)
-      end
-    else
-      failed_to_log(msg)
-    end
-  rescue
-    failed_to_log("Unable to #{msg}. '#{$!}'")
-  end
-
-# :category: Waits
-  def wait_until_text(browser, strg, desc = '', timeout = 60)
-    if not strg.class.to_s.match('String')
-      raise "#{__method__} requires String for search target. #{strg.class} is not supported."
-    end
-    wait_until(browser, "'#{strg}' #{desc}", timeout) { browser.text.include? strg }
-  end
-
-  alias wait_until_by_text wait_until_text
-
-# :category: Waits
-  def wait_until_by_link_text(browser, strg, desc = '')
-    wait_until_exists(browser, :link, :text, strg, desc)
-  end
-
-# :category: Waits
-  def wait_until_enabled(browser, what, how, value, desc = '')
-    # TODO: This can be simplified
-    start = Time.now.to_f
-    begin
-      case what
-        when :link
-          Watir::Wait.until { browser.link(how, value).enabled? }
-        when :button
-          Watir::Wait.until { browser.button(how, value).enabled? }
-        when :radio
-          Watir::Wait.until { browser.radio(how, value).enabled? }
-        when :checkbox
-          Watir::Wait.until { browser.checkbox(how, value).enabled? }
-        when :div
-          Watir::Wait.until { browser.div(how, value).enabled? }
-        when :select_list
-          Watir::Wait.until { browser.select_list(how, value).enabled? }
-        when :text_field
-          Watir::Wait.until { browser.text_field(how, value).enabled? }
-        when :table
-          Watir::Wait.until { browser.table(how, value).enabled? }
-        else
-          raise "#{__method__}: Element #{what} not supported."
-      end
-    rescue => e
-      if e.class.to_s =~ /TimeOutException/
-        failed_to_log("Wait until (#{what} :#{how}=>#{value}) enabled. #{desc}: '#{$!}' #{desc}")
-        return false
-      elsif not rescue_me(e, __method__, "#{block.to_s}", "#{browser.class}")
-        raise e
-      end
-    end
-    stop = Time.now.to_f
-    #debug_to_log("#{__method__}: start:#{start} stop:#{stop}")
-    #    sleep 1
-    if validate(browser, @myName, __LINE__)
-      passed_to_log("Wait until (#{what} :#{how}=>#{value}) enabled. #{desc} (#{stop - start} seconds)")
-      true
-    end
-  rescue
-    failed_to_log("Unable to complete wait until (#{what} :#{how}=>#{value}) enabled. #{desc}: '#{$!}'")
-  end
-
-# :category: Waits
-  def wait_until_visible(browser, element, how, what, desc = '')
-    start = Time.now.to_f
-    Watir::Wait.until(20) { browser.element(how, what).exists? }
-    begin
-      case element
-        when :link
-          Watir::Wait.until { browser.link(how, what).visible? }
-        when :button
-          Watir::Wait.until { browser.button(how, what).visible? }
-        when :radio
-          Watir::Wait.until { browser.radio(how, what).visible? }
-        when :checkbox
-          Watir::Wait.until { browser.checkbox(how, what).visible? }
-        when :div
-          Watir::Wait.until { browser.div(how, what).visible? }
-        when :select_list
-          Watir::Wait.until { browser.select_list(how, what).visible? }
-        when :text_field
-          Watir::Wait.until { browser.text_field(how, what).visible? }
-        else
-          Watir::Wait.until { browser.element(how, what).visible? }
-#          raise "#{__method__}: Element #{what} not supported."
-      end
-    rescue => e
-      if e.class.to_s =~ /TimeOutException/
-        failed_to_log("Wait until (#{what} :#{how}=>#{what}) visible. #{desc}: '#{$!}' #{desc}")
-        return false
-      elsif not rescue_me(e, __method__, '', "#{browser.class}")
-        raise e
-      end
-    end
-    stop = Time.now.to_f
-    #debug_to_log("#{__method__}: start:#{start} stop:#{stop}")
-    #    sleep 1
-    if validate(browser, @myName, __LINE__)
-      passed_to_log("Wait until (#{element} :#{how}=>#{what}) visible. #{desc} (#{stop - start} seconds)")
-      true
-    end
-  rescue
-    failed_to_log("Unable to complete wait until (#{element} :#{how}=>#{what}) visible. #{desc}: '#{$!}'")
-  end
-
-# :category: Bullet-Proofing
-  def rescue_me(e, me = nil, what = nil, where = nil, who = nil)
-    #TODO: these are rescues from exceptions raised in Watir/Firewatir
-    debug_to_log("#{__method__}: Enter")
-    ok = false
-    begin
-      gaak    = who.inspect
-      located = gaak =~ /located=true/i
-    rescue
-      debug_to_log("#{__method__}: gaak: '#{gaak}'")
-    end
-    msg = e.message
-    debug_to_log("#{__method__}: msg = #{msg}")
-    if  msg =~ /undefined method\s+.join.\s+for/i # firewatir to_s implementation error
-      ok = true
-    elsif msg =~ /undefined method\s+.match.\s+for.+WIN32OLERuntimeError/i # watir and firewatir
-      ok = true
-    elsif msg =~ /undefined method\s+.match.\s+for.+UnknownObjectException/i # watir
-      ok = true
-    elsif msg =~ /window\.getBrowser is not a function/i # firewatir
-      ok = true
-    elsif msg =~ /WIN32OLERuntimeError/i # watir
-      ok = true
-    elsif msg =~ /undefined method\s+.match.\s+for/i # watir
-      ok = true
-    elsif msg =~ /wrong number of arguments \(1 for 0\)/i
-      ok = true
-    elsif (msg =~ /unable to locate element/i)
-      if located
-        ok = true
-      elsif where == 'Watir::Div'
-        ok = true
-      end
-    elsif (msg =~ /HRESULT error code:0x80070005/)
-      ok = true
-                                                  #elsif msg =~ /missing\s+\;\s+before statement/
-                                                  #  ok = true
-    end
-    if ok
-      debug_to_log("#{__method__}: RESCUED: \n#{who.to_yaml}=> #{what} in #{me}()\n=> '#{$!}'")
-      debug_to_log("#{__method__}: #{who.inspect}") if who
-      debug_to_log("#{__method__}: #{where.inspect}")
-      debug_to_log("#{__method__}: #{get_callers(6, true)}")
-    else
-      debug_to_log("#{__method__}: NO RESCUE: #{e.message}")
-      debug_to_log("#{__method__}: NO RESCUE: \n#{get_callers(6, true)}")
-    end
-    debug_to_log("#{__method__}: Exit")
-    ok
-  end
-
-# :category: Browser
-  def close_popup_by_button_title(popup, strg, desc = '')
-    click(popup, :link, :title, strg, desc)
-  end
-
-# :category: GUI
-  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
-
-# :category: GUI
-  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 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_element_text(browser, element, how, what, desc = '')
-    msg = "Return text in #{element} #{how}='#{what}'"
-    msg << " #{desc}" if desc.length > 0
-    text = browser.element(how, what).text
-    if validate(browser, @myName, __LINE__)
-      passed_to_log("#{msg} text='#{text}'")
-      text
-    end
-  rescue
-    failed_to_log("Unable to #{msg}: '#{$!}'")
-  end
-
-# :category: GUI
-  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
-
-# :category: GUI
-  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
-
-# :category: Table Handling
-  def get_index_for_column_head(panel, table_index, strg)
-    rgx = Regexp.new(strg)
-    panel.tables[table_index].each do |row|
-      if row.text =~ rgx
-        index = 1
-        row.each do |cell|
-          if cell.text =~ rgx
-            return index
-          end
-          index += 1
-        end
-      end
-    end
-  end
-
-# :category: Table Handling
-  def get_index_of_last_row(table, pad = 2, every = 1)
-    index = calc_index(table.row_count, every)
-    index = index.to_s.rjust(pad, '0')
-    #debug_to_log("#{__method__}: index='#{index}' row_count=#{table.row_count} pad=#{pad} every=#{every}")
-    index
-  end
-
-  alias get_index_for_last_row get_index_of_last_row
-
-# :category: Table Handling
-  def get_index_of_last_row_with_text(table, strg, column_index = nil)
-    debug_to_log("#{__method__}: #{get_callers(5)}")
-    msg = "Find last row in table :id=#{table.id} with text '#{strg}'"
-    msg << " in column #{column_index}" if column_index
-    dbg = "#{__method__}: #{table.id} text by row "
-    dbg << "in column #{column_index}" if column_index
-    index    = 0
-    found    = false
-    at_index = 0
-    #row_count = table.row_count
-    table.rows.each do |row|
-      cell_count = get_cell_count(row)
-      index      += 1
-      text       = ''
-      if column_index
-        col_idx = column_index.to_i
-        if cell_count >= col_idx
-          text = row[col_idx].text
-        end
-      else
-        text = row.text
-      end
-      dbg << "\n#{index}. [#{text}]"
-      if text =~ /#{strg}/
-        found    = true
-        at_index = index
-      end
-    end
-    debug_to_log(dbg)
-    if found
-      passed_to_log("#{msg} at index #{index}.")
-      at_index
-    else
-      failed_to_log("#{msg}")
-      nil
-    end
-  rescue
-    failed_to_log("Unable to #{msg}. '#{$!}'")
-  end
-
-  alias get_index_for_last_row_with_text get_index_of_last_row_with_text
-
-# :category: Table Handling
-  def get_index_of_row_with_text(table, strg, column_index = nil, fail_if_found = false)
-    debug_to_log("#{__method__}: #{get_callers(5)}")
-    if fail_if_found
-      msg = 'No '
-    else
-      msg = 'Find '
-    end
-    msg << "row in table :id=#{table.id} with text '#{strg}'"
-    msg << " in column #{column_index}" if column_index
-    dbg = "#{__method__}: #{table.id} text by row "
-    dbg << "in column #{column_index}" if column_index
-    index = 0
-    found = false
-    table.rows.each do |row|
-      cell_count = row.cells.length
-      index      += 1
-      text       = ''
-      if column_index
-        col_idx = column_index.to_i
-        if cell_count >= col_idx
-          text = row[col_idx].text
-        end
-      else
-        text = row.text
-      end
-      dbg << "\n#{index}. [#{text}]"
-      if text =~ /#{strg}/
-        found = true
-        break
-      end
-    end
-    debug_to_log(dbg)
-    if found
-      if fail_if_found
-        failed_to_log("#{msg} at index #{index}.")
-      else
-        passed_to_log("#{msg} at index #{index}.")
-      end
-      index
-    else
-      if fail_if_found
-        passed_to_log("#{msg}")
-      else
-        failed_to_log("#{msg}")
-      end
-      nil
-    end
-  rescue
-    failed_to_log("Unable to #{msg}. '#{$!}'")
-  end
-
-# :category: Table Handling
-  def get_index_of_row_with_textfield_value(table, strg, how, what, column_index = nil)
-    msg = "Find row in table :id=#{table.id} with value '#{strg}' in text_field #{how}=>'#{what} "
-    msg << " in column #{column_index}" if column_index
-    index = 0
-    found = false
-    table.rows.each do |row|
-      cell_count = get_cell_count(row)
-      index      += 1
-      text       = ''
-      if column_index
-        col_idx = column_index.to_i
-        if cell_count >= col_idx
-          if  row[col_idx].text_field(how, what).exists?
-            value = row[col_idx].text_field(how, what).value
-          end
-        end
-      else
-        if  row.text_field(how, what).exists?
-          value = row.text_field(how, what).value
-          sleep(0.25)
-        end
-      end
-      if value and value =~ /#{strg}/
-        found = true
-        break
-      end
-    end
-    if found
-      passed_to_log("#{msg} at index #{index}.")
-    else
-      failed_to_log("#{msg}")
-    end
-    index
-  rescue
-    failed_to_log("Unable to #{msg}. '#{$!}'")
-  end
-
-# :category: Table Handling
-  def get_index_for_table_containing_text(browser, strg, ordinal = 1)
-    msg   = "Get index for table containing text '#{strg}'"
-    index = 0
-    found = 0
-    browser.tables.each do |t|
-      index += 1
-      if t.text =~ /#{strg}/
-        found += 1
-        if ordinal > 0 and found == ordinal
-          break
-        end
-      end
-    end
-    if found
-      passed_to_log("#{msg}: #{index}")
-      index
-    else
-      passed_to_log("#{msg}.")
-      nil
-    end
-  rescue
-    failed_to_log("Unable to find index of table containing text '#{strg}' '#{$!}' ")
-  end
-
-  def get_table_containing_text(browser, strg, ordinal = 1)
-    msg   = "Get table #{ordinal} containing text '#{strg}'"
-    index = get_index_for_table_containing_text(browser, strg, ordinal)
-    if index
-      passed_to_log(msg)
-      browser.tables[index]
-    else
-      failed_to_log(msg)
-      nil
-    end
-  rescue
-    failed_to_log("Unable to find index of table containing text '#{strg}' '#{$!}' ")
-  end
-
-# :category: Table Handling
-  def get_cell_text_from_row_with_string(nc_element, table_index, column_index, strg)
-    rgx  = Regexp.new(strg)
-    text = ''
-    debug_to_log("strg:'#{strg}', rgx:'#{rgx}', table_index:'#{table_index}', column_index:'#{column_index}'")
-    nc_element.tables[table_index].each do |row|
-      cell_count = get_cell_count(row)
-      if cell_count >= column_index
-        #TODO this assumes column 1 is a number column
-        #        debug_to_log("row:'#{row.cells}'")
-        cell_1 = row[1].text
-        if cell_1 =~ /\d+/
-          row_text = row.text
-          if row_text =~ rgx
-            text = row[column_index].text
-            break
-          end
-        end
-      end
-    end
-    text
-  end
-
-# :category: Table Handling
-  def count_rows_with_string(container, table_index, strg)
-    hit = 0
-    container.tables[table_index].each do |row|
-      if get_cell_count(row) >= 1
-        #        debug_to_log("#{__method__}: #{row.text}")
-        #TODO this assumes column 1 is a number column
-        if row[1].text =~ /\d+/
-          if row.text =~ /#{strg}/i
-            hit += 1
-            debug_to_log("#{__method__}: #{row.text}")
-          end
-        end
-      end
-    end
-    debug_to_log("#{__method__}: hit row count: #{hit}")
-    hit
-  end
-
-# :category: Table Handling
-  def fetch_array_for_table_column(nc_element, table_index, column_index)
-    ary = []
-    nc_element.tables[table_index].each do |row|
-      if get_cell_count(row) >= column_index
-        #TODO this assumes column 1 is a number column
-        if row[1].text =~ /\d+/
-          ary << row[column_index].text
-        end
-      end
-    end
-    return ary f
-  end
-
-# :category: Table Handling
-  def fetch_hash_for_table_column(table, column_index, start_row = 2)
-    hash      = Hash.new
-    row_count = 0
-    table.each do |row|
-      row_count += 1
-      if get_cell_count(row) >= column_index
-        if row_count >= start_row
-          hash[row_count] = row[column_index].text
-        end
-      end
-    end
-    hash
-  end
-
-# :category: Table Handling
-  def get_row_cells_text_as_array(row)
-    ary = []
-    row.each do |cell|
-      ary << cell.text
-    end
-    ary
-  end
-
-# :category: Table Handling
-  def count_data_rows(container, data_index, column_index)
-    cnt   = 0
-    #  get_objects(container, :tables, true)
-    table = container.tables[data_index]
-    dump_table_and_rows(table)
-    if table
-      table.rows.each do |row|
-        if get_cell_count(row) >= column_index
-          #TODO this assumes column 1 is a number column
-          if row[column_index].text =~ /\d+/
-            cnt += 1
-          end
-        end
-      end
-    end
-    sleep_for(2)
-    cnt
-  end
-
-# :category: GUI
-  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
-
-# :category: GUI
-  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 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
-
-# :category: GUI
-  def right_click(element)
-    x = element.left_edge_absolute + 2
-    y = element.top_edge_absolute + 2
-    @ai.MouseClick("secondary", x, y)
-  end
-
-# :category: GUI
-  def left_click(element)
-    x = element.left_edge_absolute + 2
-    y = element.top_edge_absolute + 2
-    @ai.MouseClick("primary", x, y)
-  end
-
-  def get_cell_count(row)
-    #    if @browserAbbrev == 'IE' or $use_firewatir
-    row.cells.length
-    #    else
-    #      row.cell_count
-    #    end
-  end
-
-# :category: GUI
-  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
-
-# :category: GUI
-  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
-
-  #TODO unlikely to work...
-  def find_me(where, how, what)
-    me = where.element(how, what)
-    puts me.inspect
-  rescue
-    error_to_log("#{where.inspect} doesn't seem to respond to element() #{$!}")
-  end
-
-# :category: User Input
-  def click_me(element)
-    element.click
-  rescue
-    error_to_log("#{element.inspect} doesn't seem to respond to click() #{$!}")
-  end
-
-  def filter_bailout_from_rescue(err, msg)
-    if msg =~ /bailing out/i
-      raise err
-    else
-      error_to_log(msg)
-    end
-  end
-
-# :category: Debug
-  def get_caller_line
-    last_caller = get_callers[0]
-    line        = last_caller.split(':', 3)[1]
-    line
-  end
-
-# :category: Debug
-  def get_call_list(depth = 9, dbg = false)
-    myList    = []
-    call_list = Kernel.caller
-    puts call_list if dbg
-    call_list.each_index do |x|
-      myCaller = call_list[x].to_s
-      break if x > depth or myCaller =~ /:in .run.$/
-      myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
-      myList << "[#{$1.gsub(/eval/, @myName)}] "
-    end
-    myList
-  end
-
-  alias get_callers get_call_list
-
-# :category: Debug
-  def get_call_list_new(depth = 9, dbg = false)
-    myList    = []
-    call_list = Kernel.caller
-    puts call_list if dbg
-    call_list.each_index do |x|
-      myCaller = call_list[x].to_s
-      break if x > depth or myCaller =~ /:in .run.$/
-      if myCaller.include? @myName
-        myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
-        myList << "[#{$1.gsub(/eval/, @myName)}] "
-        break
-      end
-    end
-    if @projName
-      call_list.each_index do |x|
-        myCaller = call_list[x].to_s
-        break if x > depth or myCaller =~ /:in .run.$/
-        if myCaller.include? @projName
-          myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
-          myList << "[#{$1.gsub(/eval/, @projName)}] "
-          break
-        end
-      end
-    end
-    myList
-  end
-
-# :category: Debug
-  def get_call_array(depth = 9)
-    arr       = []
-    call_list = Kernel.caller
-    call_list.each_index do |x|
-      myCaller = call_list[x].to_s
-      break if x > depth or myCaller =~ /:in .run.$/
-      myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
-      arr << $1.gsub(/eval/, @myName)
-    end
-    arr
-  end
-
-# :category: Debug
-  def get_debug_list(dbg = false)
-    calls = get_call_array(10)
-    puts "#{calls.to_yaml}" if dbg
-    arr = []
-    calls.each_index do |ix|
-      if ix > 1 # skip this method and the logging method
-        arr << calls[ix]
-      end
-    end
-    puts "#{arr.to_yaml}" if dbg
-    if arr.length > 0
-      list = 'TRACE:'
-      arr.reverse.each { |l| list << "=>#{l}" }
-      " [[#{list}]]"
-    else
-      nil
-    end
-  end
-
-# :category: Debug
-  def dump_all_tables(browser, to_report = false)
-    tables  = browser.tables
-    msg     = ''
-    tbl_cnt = 0
-    tables.each do |tbl|
-      tbl_cnt += 1
-      row_cnt = 0
-      msg <<"\n=================\ntable: #{tbl_cnt}\n=================\n#{tbl}\ntext:\n#{tbl.text}"
-      tbl.rows.each do |row|
-        row_cnt  += 1
-        cell_cnt = 0
-        msg <<"\n=================\ntable: #{tbl_cnt} row: #{row_cnt}\n#{row.inspect}\n#{row}\ntext:'#{row.text}'"
-        row.each do |cell|
-          cell_cnt += 1
-          msg <<"\n==== cell: #{cell_cnt}\n#{cell.inspect}\n#{row}\ntext: '#{cell.text}'"
-        end
-      end
-    end
-    if to_report
-      debug_to_report(msg)
-    else
-      debug_to_log(msg)
-    end
-  end
-
-# :category: Debug
-  def dump_table_and_rows(table, to_report = false)
-    msg = "\n=================\ntable\n=================\nn#{table}\n#{table.to_yaml}\nrows:"
-    cnt = 0
-    table.rows.each do |r|
-      cnt += 1
-      msg << "\n#{cnt}: #{r.text}"
-    end
-    msg << "\n=================\n================="
-    if to_report
-      debug_to_report(msg)
-    else
-      debug_to_log(msg)
-    end
-  end
-
-# :category: Debug
-  def dump_table_rows_and_cells(tbl)
-    msg     = ''
-    row_cnt = 0
-    msg <<"\n=================\ntable: #{tbl.inspect}\n=================\n#{tbl}\ntext:\n#{tbl.text}"
-    tbl.rows.each do |row|
-      row_cnt  += 1
-      cell_cnt = 0
-      msg <<"\n=================\nrow: #{row_cnt}\n#{row.inspect}\n#{row}\ntext:'#{row.text}'"
-      row.each do |cell|
-        cell_cnt += 1
-        msg <<"\n==== cell: #{cell_cnt}\n#{cell.inspect}\n#{row}\ntext: '#{cell.text}'"
-      end
-    end
-    debug_to_log(msg)
-  end
-
-  alias dump_table_rows dump_table_rows_and_cells
-
-# :category: Debug
-  def dump_array(arr, space_to_underscore = false)
-    dump = "  #{arr.inspect}\n"
-    arr.each_index do |x|
-      value = arr[x].to_s
-      value.gsub!(/\s/, '_') if space_to_underscore
-      dump << " #{x.to_s.rjust(5)}>> '#{arr[x].to_s}'\n"
-    end
-    dump
-  end
-
-# :category: Debug
-  def dump_ole_methods(ole)
-    rtrn = ''
-    ole.ole_methods.each do |m|
-      prms = ''
-      m.params.each do |p|
-        prms << "#{p}, "
-      end
-      rtrn << "#{m.name}(#{prms.chop.chop})\n"
-    end
-    rtrn
-  end
-
-# :category: Debug
-  def dump_ole_get_methods(ole)
-    rtrn = ''
-    ole.ole_get_methods.each do |m|
-      prms = ''
-      m.params.each do |p|
-        prms << "#{p}, "
-      end
-      rtrn << "#{m.name}(#{prms.chop.chop})\n"
-    end
-    rtrn
-  end
-
-# :category: Debug
-  def dump_ole_help(ole)
-    rtrn = ''
-    ole.ole_obj_help.each do |m|
-      prms = ''
-      m.params.each do |p|
-        prms << "#{p}, "
-      end
-      rtrn << "#{m.name}(#{prms.chop.chop})\n"
-    end
-    rtrn
-  end
 
-# :category: Debug
-  def dump_row_cells(row)
-    msg      = ''
-    cell_cnt = 0
-    msg <<"\n=================\nrow: #{row.inspect}\n#{row}\ntext:'#{row.text}'"
-    row.each do |cell|
-      cell_cnt += 1
-      msg <<"\n==== cell: #{cell_cnt}\n#{cell.inspect}\n#{row}\ntext: '#{cell.text}'"
-    end
-    debug_to_log(msg)
-  end
+#  def click_me(element)
+#    element.click
+#  rescue
+#    error_to_log("#{element.inspect} doesn't seem to respond to click() #{$!}")
+#  end
 
-# :category: Debug
-  def dump_select_list_options(element)
-    msg     = "#{element.inspect}"
-    options = element.options
-    cnt     = 1
-    options.each do |o|
-      msg << "\n\t#{cnt}:\t'#{o}"
-      cnt += 1
-    end
-    debug_to_log(msg)
-  end
 
 end