awetestlib 0.1.30-x86-mingw32 → 1.2.4-x86-mingw32

data/lib/awetestlib/regression/utilities.rb

@@ -15,13 +15,13 @@ module Awetestlib
       end
 
       def setup
-        #    if @os.name =~ /Windows.+Server\s+2003/
+        #    if $os.name =~ /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.name =~ /Windows XP Professional/
+        #    elsif $os.name =~ /Windows XP Professional/
         #  'Microsoft Windows XP Professional'
         @vertical_hack_ie        = 118
         @vertical_hack_ff        = 144
@@ -50,39 +50,24 @@ module Awetestlib
         @y_tolerance             = 4
       end
 
-      def build_message(strg1, desc = '', strg2 = '', strg3 = '', strg4 = '')
+      def build_message(strg1, *strings)
         msg = "#{strg1}"
-        msg << " #{desc}" if desc and desc.length > 0
-        msg << " #{strg2}" if strg2 and strg2.length > 0
-        msg << " #{strg3}" if strg3 and strg3.length > 0
-        msg << " #{strg4}" if strg4 and strg4.length > 0
+        strings.each do |strg|
+          if strg.is_a?(Array)
+            strg.each do |str|
+              msg << " #{str}" if str and str.length > 0
+            end
+          else
+            msg << " #{strg}" if strg and strg.length > 0
+          end
+        end if strings
         msg
+      rescue
+        failed_to_log(unable_to)
       end
 
-      def get_date_names(date = Date.today)
-        this_month = date.month
-        if this_month == 12
-          next_month = 1
-        else
-          next_month = this_month + 1
-        end
-        if this_month == 1
-          prev_month = 12
-        else
-          prev_month = this_month - 1
-        end
-
-        month_arr = ['', 'January', 'February', 'March', 'April', 'May', 'June',
-                     'July', 'August', 'September', 'October', 'November', 'December']
-
-        this_month_name = month_arr[this_month]
-        next_month_name = month_arr[next_month]
-        prev_month_name = month_arr[prev_month]
-
-        arr = [date.year, date.day, this_month_name, next_month_name, prev_month_name]
-        debug_to_log("#{__method__} #{nice_array(arr)}")
-        arr
-      end
+      alias build_msg build_message
+      alias bld_msg build_message
 
       def get_trace(lnbr)
         callertrace = "\nCaller trace: (#{lnbr})\n"
@@ -94,44 +79,43 @@ module Awetestlib
 
       alias dump_caller get_trace
 
-      def get_mdyy(t = Time.now)
-        "#{t.month}/#{t.day}/#{t.year}"
-      end
-
       def get_prefix(strg, offset)
         a_slice = strg.slice(0, offset)
         a_slice.downcase
       end
 
-      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 calc_index(index, every = 1)
         (index / every) + (every - 1)
       end
 
-      def get_variables(file, key_type = :role, dbg = true)
+      def get_upload_file_control_indexes
+        case $win_major
+          when '5'
+            case @browserAbbrev
+              when 'IE'
+                ['1', '1', '2', 'Choose File to Upload']
+              when 'FF'
+                ['1', '1', '2', 'File Upload']
+              when 'GC', 'C'
+                ['1', '1', '2', 'Open']
+            end
+          when '6'
+            case @browserAbbrev
+              when 'IE'
+                ['1', '1', '2', 'Choose File to Upload']
+              when 'FF'
+                ['1', '1', '2', 'File Upload']
+              when 'GC', 'C'
+                ['1', '1', '2', 'Open']
+            end
+        end
+      end
+
+      def get_variables(file, key_type = :role, enabled_only = true, dbg = true)
+
+        #TODO: support for xlsx files
         #TODO refactor this
+
         debug_to_log("#{__method__}: file = #{file}")
         debug_to_log("#{__method__}: key  = #{key_type}")
 
@@ -164,60 +148,75 @@ module Awetestlib
         end if dbg
 
         @login       = Hash.new
-        login_col    = 0
+        script_col   = 0
         role_col     = 0
         userid_col   = 0
+        company_col  = 0
         password_col = 0
         url_col      = 0
+        env_col      = 0
         name_col     = 0
         login_index  = find_sheet_with_name(workbook, 'Login')
         if login_index and login_index >= 0
           workbook.default_sheet = workbook.sheets[login_index]
 
           1.upto(workbook.last_column) do |col|
-            a_cell = workbook.cell(1, col)
+            a_cell = workbook.cell(1, col).downcase
             case a_cell
-              when @myName
-                login_col             = col
+              when @myName.downcase
+                script_col            = col
                 script_found_in_login = true
                 break
               when 'role'
                 role_col = col
-              when 'userid'
+              when 'userid', 'user_id'
                 userid_col = col
+              when 'companyid', 'company_id'
+                company_col = col
               when 'password'
                 password_col = col
               when 'url'
                 url_col = col
+              when 'environment'
+                env_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
+            role      = workbook.cell(line, role_col)
+            userid    = workbook.cell(line, userid_col)
+            password  = workbook.cell(line, password_col)
+            url       = workbook.cell(line, url_col)
+            env       = workbook.cell(line, env_col)
+            username  = workbook.cell(line, name_col)
+            companyid = workbook.cell(line, company_col)
+            enabled   = workbook.cell(line, script_col).to_s
 
             case key_type
               when :id, :userid
                 key = userid
+              when :environment
+                key = env
               when :role
                 key = role
               else
                 key = userid
             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
+            if enabled_only and enabled.length == 0
+              next
+            end
+
+            @login[key]              = Hash.new
+            @login[key]['role']      = role
+            @login[key]['userid']    = userid
+            @login[key]['companyid'] = companyid
+            @login[key]['password']  = password
+            @login[key]['url']       = url
+            @login[key]['name']      = username
+            @login[key]['enabled']   = enabled
 
           end
 
@@ -232,7 +231,46 @@ module Awetestlib
           failed_to_log("Script found: in Login = #{script_found_in_login}; in Data = #{script_found_in_data}")
         end
       rescue
-        failed_to_log("#{__method__}: '#{$!}'")
+        failed_to_log(unable_to)
+      end
+
+      def translate_color_name(color)
+        if color and color.length > 0
+          HTML_COLORS[color.camelize.downcase].downcase
+        else
+          color
+        end
+      end
+
+      def translate_tag_name(element)
+        rtrn = ''
+        tag  = ''
+        typ  = ''
+        if element.respond_to?(:tag_name)
+          tag  = element.tag_name
+          typ  = element.type if element.respond_to?(:type)
+          rtrn = tag
+          case tag
+            when 'a'
+              rtrn = 'link'
+            when 'input'
+              case typ
+                when 'text'
+                  rtrn = 'textfield'
+                when 'textarea'
+                  rtrn = 'textarea'
+                when 'submit', 'button'
+                  rtrn = 'button'
+                else
+                  rtrn = tag
+              end
+            else
+              rtrn = tag
+          end
+        end
+        rtrn
+      rescue
+        failed_to_log(unable_to(tag, typ))
       end
 
       def translate_var_list(key)
@@ -247,6 +285,66 @@ module Awetestlib
         failed_to_log("#{__method__}: '#{$!}'")
       end
 
+      def get_awetestlib_metadata
+        $metadata = YAML.load(`gem spec awetestlib metadata`.chomp)
+      end
+
+      def parse_list(string, delim = ',', limit = -1)
+        string.split(/#{delim}\s*/, limit)
+      rescue
+        failed_to_log(unable_to("string:[#{string}]"))
+      end
+
+      def get_project_git(proj_name, proj_dir = Dir.pwd)
+        debug_to_log(with_caller(proj_dir))
+        sha    = nil
+        branch = nil
+        date   = nil
+
+        curr_dir = Dir.pwd
+        version_file = "#{proj_name.downcase.gsub(' ', '_')}_version"
+
+        if Dir.exists?(proj_dir)
+
+          Dir.chdir(proj_dir) unless proj_dir == curr_dir
+
+          if Dir.exists?('.git')
+            require 'git'
+            git    = Git.open(Dir.pwd)
+            branch = git.current_branch
+            commit = git.gblob(branch).log(5).first
+            sha    = commit.sha
+            date   = commit.date
+
+            version_file = File.join(proj_dir, version_file)
+            file         = File.open(version_file, 'w')
+            file.puts "#{branch}, #{date}, #{sha}"
+            file.close
+
+          end
+
+          Dir.chdir(curr_dir) unless proj_dir == curr_dir
+
+        end
+
+        unless branch
+          version_file = File.join(Dir.pwd, version_file)
+          if File.exists?(version_file)
+            vers              = File.open(version_file).read
+            branch, date, sha = parse_list(vers.chomp)
+          end
+        end
+
+        [branch, date, sha]
+      end
+
+      def git_sha1(file)
+        if File.exists?(file)
+          size, sha1 = `ruby git_sha1.rb #{file}`.chomp.split(/\n/)
+          debug_to_log("#{file} #{size} sha1 is #{sha1}")
+        end
+      end
+
       def grab_window_list(strg)
         @ai.AutoItSetOption("WinTitleMatchMode", 2)
         list    = @ai.WinList(strg)
@@ -265,25 +363,21 @@ module Awetestlib
         stuff
       end
 
+      def count_duplicates(arr)
+        counts = {}
+        dups   = {}
+        arr.each do |id|
+          counts[id] = counts[id] ? counts[id] + 1 : 1
+          dups[id]   = counts[id] if counts[id] > 1
+        end
+        [dups, counts]
+      end
+
       def debug_call_list(msg)
         call_array = get_call_array
         debug_to_log("#{msg}\n#{dump_array(call_array)}")
       end
 
-      def sec2hms(s)
-        Time.at(s.to_i).gmtime.strftime('%H:%M:%S')
-      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
-
       def find_sheet_with_name(workbook, sheet_name)
         sheets = workbook.sheets
         idx    = 0
@@ -321,33 +415,76 @@ module Awetestlib
         sprintf(ptrn, number).gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,")
       end
 
-      def pad_date(dt)
-       if dt and dt.length > 0
-         a, d1, b, d2, c = dt.split(/([\/\.-])/)
-         a = a.rjust(2, '0') unless a and a.length > 1
-         b = b.rjust(2, '0') unless b and b.length > 1
-         c = c.rjust(2, '0') unless c and c.length > 1
-         a + d1 + b + d2 + c
-       else
-         ''
-       end
-     end
+      def normalize_color_value(value, rgba = true)
+        case value
+          when /^#/
+            html_to_rgb(value, rgba)
+          when /^rgba/i
+            value
+          when /^rgb()/i
+            rgb_to_rgba(value)
+          when /^transparent/i, /^0$/i
+            'rgba(0, 0, 0, 0)'
+          when /white/
+            'rgba(255, 255, 255, 1)'
+          else
+            html_to_rgb(translate_color_name(value), rgba)
+        end
+      end
+
+      def number_to_word(nbr)
+        map = { 1  => 'one', 2 => 'two', 3 => 'three', 4 => 'four', 5 => 'five',
+                6  => 'six', 7 => 'seven', 8 => 'eight', 9 => 'nine', 10 => 'ten',
+                11 => 'eleven', 12 => 'twelve', 13 => 'thirteen', 14 => 'fourteen', 15 => 'fifteen',
+                16 => 'sixteen', 17 => 'seventeen', 18 => 'eighteen', 19 => 'nineteen', 20 => 'twenty'
+        }
+        if nbr > 20
+          'more than twenty'
+        else
+          map[nbr]
+        end
+      end
+
+      alias nbr2word number_to_word
+
+      def string_array_numeric_sort(arr)
+        #TODO: almost certainly a more 'rubyish' and less clunky way to do this
+        trgt = arr.dup
+        narr = []
+        trgt.each do |n|
+          narr << n.to_i
+        end
+        narr.sort!
+        sarr = []
+        narr.each do |n|
+          sarr << n.to_s
+        end
+        sarr
+      end
+
+      alias strg_arr_numeric_sort string_array_numeric_sort
 
       def string_count_in_string(strg, substrg)
         count = strg.scan(substrg).length
         count
       end
 
+      def string_to_hex(strg, format = 'U')
+        strg.unpack(format*strg.length)
+        # strg.split(//).collect do |x|
+        #   x.match(/\d/) ? x : x.unpack('U')[0].to_s(16)
+        # end
+      end
+
       def strip_regex_mix(strg)
         rslt = strg.dup
-        while match = rslt.match(/(\(\?-mix:(.+)\))/)
-          rslt.sub!(match[1], "/#{match[2]}/")
-        end
+        mtch = rslt.match(/(\(\?-mix:(.+)\))/)
+        rslt.sub!(mtch[1], "/#{mtch[2]}/")
         rslt
       end
 
       def rescue_me(e, me = nil, what = nil, where = nil, who = nil)
-        #TODO: these are rescues from exceptions raised in Watir/Firewatir
+        #TODO: these are rescues from exceptions raised in Watir or Watir-webdriver
         debug_to_log("#{__method__}: Begin rescue")
         ok = false
         begin
@@ -358,7 +495,7 @@ module Awetestlib
         end
         msg = e.message
         debug_to_log("#{__method__}: msg = #{msg}")
-        if  msg =~ /undefined method\s+.join.\s+for/i # firewatir to_s implementation error
+        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
@@ -372,106 +509,105 @@ module Awetestlib
           ok = true
         elsif msg =~ /wrong number of arguments \(1 for 0\)/i
           ok = true
-        elsif (msg =~ /unable to locate element/i)
+        elsif msg =~ /unable to locate element/i
           if located
             ok = true
           elsif where == 'Watir::Div'
             ok = true
           end
-        elsif (msg =~ /HRESULT error code:0x80070005/)
+        elsif msg =~ /(The SafariDriver does not interact with modal dialogs)/i
+          to_report = $1
+          ok        = true
+        elsif msg =~ /HRESULT error code:0x80070005/
           ok = true
-                                                      #elsif msg =~ /missing\s+\;\s+before statement/
-                                                      #  ok = true
+          #elsif msg =~ /missing\s+\;\s+before statement/
+          #  ok = true
         end
+        call_list = get_call_list(6, true)
         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)}")
+          debug_to_log("#{__method__}: #{call_list}")
+          failed_to_log("#{to_report}  #{call_list}")
         else
           debug_to_log("#{__method__}: NO RESCUE: #{e.message}")
-          debug_to_log("#{__method__}: NO RESCUE: \n#{get_callers(6, true)}")
+          debug_to_log("#{__method__}: NO RESCUE: \n#{call_list}")
         end
         debug_to_log("#{__method__}: Exit")
         ok
       end
 
-      def get_caller_line
-        last_caller = get_call_list[0]
-        line        = last_caller.split(':', 3)[1]
-        line
+      def convert_color_value(value, rgba = false)
+        if value =~ /^#/
+          html_to_rgb(value, rgba)
+        else
+          rgb_to_html(value)
+        end
       end
 
-      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
-          myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
-          myList << "[#{$1.gsub(/eval/, @myName)}] "
-          break if x > depth or myCaller =~ /:in .run.$/
+      def rgb_to_html(rgb)
+        rgb =~ /rgba?\((.+)\)/
+        if $1
+          r, g, b, a = $1.split(/,\s*/)
+          "#%02x%02x%02x" % [r, g, b]
+        else
+          rgb
         end
-        myList
       end
 
-      alias get_callers get_call_list
-
-      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
-          if myCaller.include? @myName
-            myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
-            myList << "[#{$1.gsub(/eval/, @myName)}] "
-            break
-          end
-          break if x > depth or myCaller =~ /:in .run.$/  # this break causes error in Ruby 1.9.x
-        end
-        if @projName
-          call_list.each_index do |x|
-            myCaller = call_list[x].to_s
-            if myCaller.include? @projName
-              myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
-              myList << "[#{$1.gsub(/eval/, @projName)}] "
-              break
-            end
-          end
-          break if x > depth or myCaller =~ /:in .run.$/  # this break causes error in Ruby 1.9.
+      def rgb_to_rgba(rgb)
+        if rgb =~ /^rgb\(\s*(\d+),\s*(\d+),\s*(\d+)\s*\)/i
+          r    = $1
+          g    = $2
+          b    = $3
+          op   = rgb =~ /[1-9]/ ? '1' : '0'
+          rtrn = "rgba(#{r}, #{g}, #{b}, #{op})" #waft-1148
+        else
+          rtrn = rgb
         end
-        myList
+        rtrn
       end
 
-      def get_call_array(depth = 9)
-        arr       = []
-        call_list = Kernel.caller
-        call_list.each_index do |x|
-          myCaller = call_list[x].to_s
-          myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
-          arr << $1.gsub(/eval/, @myName)
-          break if x > depth or myCaller =~ /:in .run.$/
+      def html_to_rgb(html, a = true)
+        if html and html.length > 0
+          html = html.gsub(%r{[#;]}, '')
+          case html.size
+            when 3
+              colors = html.scan(%r{[0-9A-Fa-f]}).map { |el| (el * 2).to_i(16) }
+            when 6
+              colors = html.scan(%r<[0-9A-Fa-f]{2}>).map { |el| el.to_i(16) }
+          end
+          rgb = 'rgb'
+          rgb << 'a' if a
+          rgb << '('
+          colors.each do |c|
+            rgb << "#{c}, "
+          end
+          if a
+            rgb << '1)'
+          else
+            rgb.strip!.chop!
+            rgb << ')'
+          end
+          rgb
+        else
+          html
         end
-        arr
       end
 
-      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]
+      def analyse_element_presence(container, element, how, what, max_seconds = 30, interval = 0.25)
+        duration = 0
+        code     = build_webdriver_fetch(element, how, what) + '.present?'
+        debug_to_log("#{__method__}: code=>[#{code}")
+        until duration > max_seconds do
+          begin
+            debug_to_log("#{eval(code)} #{duration}")
+          rescue => e
+            debug_to_log("#{__method__}: #{e.inspect}")
           end
-        end
-        puts "#{arr.to_yaml}" if dbg
-        if arr.length > 0
-          list = 'TRACE:'
-          arr.reverse.each { |l| list << "=>#{l}" }
-          " [[#{list}]]"
-        else
-          nil
+          duration += interval
+          sleep(interval)
         end
       end
 
@@ -536,23 +672,10 @@ module Awetestlib
         end
       end
 
-      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 << " \ncell: #{cell_cnt}\n#{cell.inspect}\n#{row}\ntext: '#{cell.text}'"
-            end
-          end
+      def dump_option_array(options, desc = '', to_report = false)
+        msg = with_caller(desc, "\n")
+        options.each do |option|
+          msg << "text: '#{option.text}' value: '#{option.value}' selected: #{option.selected?}\n"
         end
         if to_report
           debug_to_report(msg)
@@ -561,59 +684,193 @@ module Awetestlib
         end
       end
 
-      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}"
+      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
-        msg << "\n=================\n================="
-        if to_report
-          debug_to_report(msg)
+        cookies
+      end
+
+      def parse_test_flag(string)
+        test = false
+        refs = nil
+        if string
+          if string == true or string == false
+            test = string
+          else
+            if string.length > 0
+              unless string =~ /^no$/i
+                test = true
+                unless string =~ /^yes$/i
+                  refs = format_refs(string)
+                end
+              end
+            end
+          end
+        end
+        [test, refs]
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def build_webdriver_fetch(element, how, what, more = {})
+        code = "container.#{element}(:#{how} => "
+        what = escape_stuff(what) unless how == :index
+        if what.is_a?(Regexp)
+          code << "/#{what.source}/"
+        elsif how == :index
+          code << "#{what}"
         else
-          debug_to_log(msg)
+          code << "'#{what}'"
         end
+        if more and not more.empty?
+          more.each do |key, vlu|
+            next if key == :desc or key == :flash or key == :exists_only
+            code << ", :#{key} => "
+            if vlu.is_a?(Regexp)
+              code << "/#{vlu}/"
+            elsif vlu.is_a?(String)
+              code << "'#{vlu.gsub('/', '\/')}'"
+            else
+              code << "#{vlu}"
+            end
+          end
+        end
+        code << ')'
+        #debug_to_log("code: '#{code}'")
+        code
+      rescue
+        failed_to_log(unable_to)
       end
 
-      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 << "\ncell: #{cell_cnt}\n#{cell.inspect}\n#{row}\ntext: '#{cell.text}'"
+      def element_action_message(element, action, how = nil, what = nil, value = nil, desc = '', refs = '')
+        name      = element.respond_to?(:tag_name) ? element.tag_name.upcase : element.to_s
+        how, what = extract_locator(element, how)[1, 2] unless how and what
+        build_message(desc, action, "#{name}",
+                      (what ? "with #{how}=>'#{what}'" : nil),
+                      (value ? "and value=>'#{value}'" : nil), refs)
+      end
+
+      def element_query_message(element, query, how = nil, what = nil, value = nil, desc = '', refs = '')
+        if element.exists?
+          name = element.respond_to?(:tag_name) ? element.tag_name.upcase : element.to_s
+        else
+          name = '(unknown)'
+        end
+        build_message(desc, "#{name}",
+                      (what ? "with #{how}=>' #{what}'" : nil),
+                      (value ? "and value=>'#{value}'" : nil),
+                      query, refs)
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def end_processes(*names)
+        pattern = ''
+        names.each { |n| pattern << "#{n}|" }
+        pattern.chop!
+        # puts pattern
+        targets = {}
+
+        if USING_OSX
+          p_io = IO.popen("ps axo comm,pid,sess,fname")
+        else
+          p_io = IO.popen("tasklist /nh")
+        end
+
+        p_io.readlines.each do |prc|
+          # puts prc.chop
+          if prc =~ /#{pattern}/
+            name, pid    = prc.split(/\s+/)[0, 2]
+            # puts "#{name} #{pid}"
+            base         = File.basename(name)
+            targets[pid] = base
           end
         end
-        debug_to_log(msg)
+
+        debug_to_log("End these processes:\n#{targets.to_yaml}")
+
+        if USING_OSX
+          kill_cmd = 'kill -9 @@@@@'
+        else
+          kill_cmd = 'taskkill /f /pid @@@@@'
+        end
+
+        targets.each do |pid, name|
+          cmd = kill_cmd.sub('@@@@@', pid)
+          debug_to_log("[#{cmd}]")
+          kill_io = IO.popen(cmd, :err => :out)
+          debug_to_log(kill_io.read.chomp)
+        end
+
+        if targets.length > 0
+          sleep_for(10)
+        end
       end
 
-      alias dump_table_rows dump_table_rows_and_cells
+      def escape_stuff(strg)
+        if strg.respond_to?(:dup)
+          rslt = strg.dup
+          unless rslt.is_a?(Regexp)
+            if rslt.match(/[\/\(\)]/)
+              rslt.gsub!('/', '\/')
+              rslt.gsub!('(', '\(')
+              rslt.gsub!(')', '\)')
+              rslt = Regexp.new(rslt)
+            end
+          end
+        else
+          rslt = strg
+        end
+        rslt
+      rescue
+        failed_to_log(unable_to("#{rslt}"))
+      end
 
-      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 << "\ncell: #{cell_cnt}\n#{cell.inspect}\n#{row}\ntext: '#{cell.text}'"
+      def extract_selected(selected_options, which = :text)
+        arr = Array.new
+        selected_options.each do |so|
+          case which
+            when :text
+              arr << so.text
+            else
+              arr << so.value
+          end
         end
-        debug_to_log(msg)
+        arr.sort
+      rescue
+        failed_to_log(unable_to)
       end
 
-      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
+      def extract_locator(element, how = nil)
+        # html_to_log(element)
+        if element.respond_to?(:tag_name)
+          tag = element.tag_name.to_sym
+        else
+          element = element.body.elements[0]
+          tag     = element.tag_name.to_sym
         end
-        cookies
+        what = nil
+        case how
+          when nil
+            [:id, :name, :title, :class, :value].each do |attr|
+              what = element.attribute_value(attr.to_s)
+              if what and what.length > 0
+                how = attr
+                break
+              end
+            end
+          else
+            what = element.attribute_value(how.to_s)
+        end
+        # debug_to_log(with_caller("#{tag}:#{how}:#{what}"))
+        [tag, how, what]
+      rescue
+        failed_to_log(unable_to(build_message(":#{tag}, :#{how}='#{what}'")))
       end
 
       def capture_screen(browser, ts)
@@ -657,12 +914,30 @@ module Awetestlib
         failed_to_log("Unable to #{msg} '#{$!}'")
       end
 
-      def flash(element, count = 4)
-        element.flash(count)
-        debug_to_log("'#{element.inspect}' flashed #{count} times.")
-        true
+      def flash(container, element, how, what, value = nil, desc = '', refs = '', options = {})
+        if @flash
+          value, desc, refs, options = capture_value_desc(value, desc, refs, options) # for backwards compatibility
+          code                       = build_webdriver_fetch(element, how, what, options)
+          target                     = eval(code)
+          flash_element(target, desc, refs)
+        end
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def flash_element(element, desc = '', refs = '')
+        if @flash
+          if element
+            element.wd.location_once_scrolled_into_view
+            # scroll_to(element.browser, element, desc, refs)
+            if element.respond_to?(:flash)
+              # sleep(0.1)
+              element.flash
+            end
+          end
+        end
       rescue
-        debug_to_log("Flash '#{element.inspect}' failed: '#{$!}' (#{__LINE__})")
+        failed_to_log(unable_to)
       end
 
       def get_save_file_path(root, filename)
@@ -747,6 +1022,28 @@ module Awetestlib
         failed_to_log("Save file failed: #{desc} '#{$!}'. (#{__LINE__})")
       end
 
+      def rotate_array(arr, stop = 0, index = 0, target = '')
+        rotated = arr.dup
+        length  = rotated.size
+        (1..length).each do |itr|
+          rotated.push(rotated.shift)
+          if stop > 0
+            break if itr == stop
+          else
+            break if rotated[index] == target
+          end
+        end
+        rotated
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def running_thread_count
+        running = Thread.list.select { |thread| thread.status == "run" }.count
+        asleep  = Thread.list.select { |thread| thread.status == "sleep" }.count
+        [running, asleep]
+      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")
@@ -887,7 +1184,7 @@ module Awetestlib
       #use click_no_wait on the action that triggers the save dialog
       # TODO need version for Firefox
       def file_upload(filepath, title = 'Choose File', text = '', button = '&Open',
-          control = 'Edit1', side = 'primary')
+                      control = 'Edit1', side = 'primary')
         title = translate_popup_title(title)
         msg   = "Window title=#{title} button='#{button}' text='#{text}' side='#{side}':"
         begin
@@ -922,20 +1219,22 @@ module Awetestlib
 
       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} '#{$!}'")
+      def upload_file(browser, data_path, wait = 20)
+        #mark_test_level(data_path)
+        message_to_report(with_caller(data_path))
+        data_path.gsub!('/', '\\') if USING_WINDOWS
+
+        file, open, cancel, title = get_upload_file_control_indexes
+
+        @ai.WinWait(title, "", wait)
+        sleep_for(1)
+        @ai.ControlSend(title, '', "[CLASS:Edit; INSTANCE:#{file}]", '!u')
+        @ai.ControlSetText(title, '', "[CLASS:Edit; INSTANCE:#{file}]", data_path)
+        sleep_for(0.5)
+        @ai.ControlClick(title, "", "[CLASS:Button; INSTANCE:#{open}]", "primary")
+
+      rescue
+        failed_to_log(unable_to)
       end
 
       def focus_on_textfield_by_id(browser, strg, desc = '')
@@ -981,25 +1280,43 @@ module Awetestlib
         loc
       end
 
-      def method_to_title(method, no_sub = false)
+      def rescue_msg_for_validation(desc, refs = nil)
+        failed_to_log(unable_to(build_message(desc, refs), NO_DOLLAR_BANG, VERIFY_MSG), 2)
+      end
+
+      def method_to_title(method, no_sub = false, subs = { /And/ => '&', /^Ac / => 'AC ' })
         title = method.to_s.titleize
-        title.gsub!(/And/, '&') unless no_sub
+        unless no_sub
+          subs.each do |ptrn, rplc|
+            title.gsub!(ptrn, rplc)
+          end
+        end
         title
       rescue
-        debug_to_log("#{__method__}: #{method} #{$!}")
+        debug_to_log(unable_to(": #{method}"))
       end
 
-      def unable_to(message = '', no_dolbang = false, verify_that = false)
-        call_arr                          = get_call_array()
-        call_script, call_line, call_meth = parse_caller(call_arr[1])
+      def unable_to(message = '', no_dolbang = false, verify_that = false, caller_index = 1)
+        call_arr = get_call_array
+        puts call_arr
+        call_script, call_line, call_meth = parse_caller(call_arr[caller_index])
         strg                              = "Unable to"
         strg << " verify" if verify_that
         strg << " #{call_meth.titleize}:"
+        strg << '?' if call_meth =~ /\?/
+        strg << ':'
         strg << " #{message}" if message.length > 0
         strg << " '#{$!}'" unless no_dolbang
         strg
       end
 
+      def pad_id_end_count(id, delim = '_', pad = 6)
+        mtch = id.match(/^(.*)#{delim}(\d+)$/)
+        mtch[1] + delim + mtch[2].rjust(pad, '0')
+      rescue
+        failed_to_log(unable_to("id: '#{id}' delim: '#{delim}' pad: #{pad}"))
+      end
+
       def parse_caller(caller)
         call_script, call_line, call_meth = caller.split(':')
         call_script.gsub!(/\.rb/, '')
@@ -1009,45 +1326,197 @@ module Awetestlib
         [call_script, call_line, call_meth]
       end
 
-      def get_test_level
-        arr       = []
-        each_line = 0
-        call_list = Kernel.caller
-        #debug_to_log("#{call_list.to_yaml}")
-        call_list.each_index do |x|
-          myCaller = call_list[x].to_s
-          myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
-          string = $1
-          unless string =~ /logging\.rb|mark_testlevel|mark_test_level|debug_to_report|debug_toreport/
-            if string.length > 0
-              if string =~ /each|each_key/
-                each_line = string.match(/\:(\d+)\:/)[1]
-              elsif string.match(/\:(\d+)\:/)[1] == each_line
-                next
+      def insert_id_pswd_in_url(userid, password, url)
+        http = url.match(/^(http)(s?)(:\/\/)/)
+        path = url.gsub(http[0], '')
+        URI.encode("#{http[0]}#{userid}:#{password}@#{path}")
+      end
+
+      def get_basic_auth_control_indexes
+        case $win_major
+          when '5'
+            case @browserAbbrev
+              when 'IE'
+                ['2', '3', '1', 'Connect to']
+              when 'FF'
+                ['2', '3', '1', 'Authentication Required']
+              when 'GC', 'C'
+                ['2', '1', '2', 'Authentication Required']
+            end
+          when '6'
+            case @browserAbbrev
+              when 'IE'
+                ['1', '2', '2', 'Windows Security']
+              when 'FF'
+                ['2', '1', '2', 'Authentication Required']
+              when 'GC', 'C'
+                ['2', '1', '2', 'Authentication Required']
+            end
+        end
+      end
+
+      def windows_to_log(browser)
+        msg = ("===== Current windows (#{where_am_i?(2)})")
+        idx = 0
+        browser.windows.each do |w|
+          msg << "\n  #{idx}: #{w.title} current?=#{w.current?}" #" (#{w.url})"
+          idx += 1
+        end
+        debug_to_log(msg)
+      rescue => e
+        debug_to_log(unable_to("#{where_am_i?(2)}: #{e.inspect}"))
+      end
+
+      # def where_am_i?(index = 1)
+      #   get_call_list_new[index].to_s
+      # end
+
+      def get_windows_version
+        ver          = `ver`.gsub("\n", '')
+        mtch         = ver.match(/(.*)\s\[Version\s*(\d+)\.(\d+)\.(\d+)\]/)
+        $win_name    = mtch[1]
+        $win_major   = mtch[2]
+        $win_minor   = mtch[3]
+        $win_build   = mtch[4]
+        $win_version = "#{$win_major}.#{$win_minor}.#{$win_build}"
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def set_env_name(xls = @xls_path, fix = :prefix, strg = 'toad')
+        if fix == :prefix
+          pattern = /#{strg}_([\w\d]+)\.xls$/
+        else
+          pattern = /([\w\d]+)_#{strg}\.xls$/
+        end
+        if awetestlib?
+          if @runenv
+            @env_name = @myAppEnv.name.downcase.underscore
+          else
+            @env_name = 'dev'
+            #if xls
+            #  xls =~ pattern
+            #  @env_name = $1
+            #else
+            #  @env_name = 'sit'
+            #end
+          end
+        else
+          @env_name = @myAppEnv.name.downcase # .underscore #.gsub(/^toad./, '')
+        end
+        debug_to_report("#{__LINE__}: @env_name=#{@env_name}")
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def set_xls_spec(proj_acro = 'unknown', env = @env_name.downcase.underscore, fix = :prefix, xlsx = @xlsx)
+        env = env.split(/:[\s_]*/)[1] if env =~ /:/
+        case fix
+          when :prefix
+            xls_name = "#{proj_acro}_#{env}.xls"
+          when :suffix
+            xls_name = "#{env}_#{proj_acro}.xls"
+          when :none
+            xls_name = "#{env.gsub('-', '_')}.xls"
+          else
+            failed_to_log(with_caller("Unknown fix type: '#{fix}'.  Must be 'prefix', 'suffix', or 'none'."))
+            return nil
+        end
+        spec = "#{@myRoot}/#{xls_name}"
+        spec << 'x' if xlsx
+        debug_to_log("#{where_am_i?}: #{spec}")
+        spec
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def format_refs(list)
+        refs = ''
+        if list
+          list.split(/,\s*/).each do |ref|
+            refs << "*** #{ref} *** "
+          end
+        end
+        refs
+      end
+
+      def force_regexp(target)
+        if target.respond_to?(:dup)
+          rslt = target.dup
+          unless rslt.is_a?(Regexp)
+            rslt = Regexp.new(Regexp.escape(target.to_s))
+          end
+        else
+          rslt = target
+        end
+        rslt
+      rescue
+        failed_to_log(unable_to("'#{target}'"))
+      end
+
+      def force_string(target, slash_regexp = true)
+        if target
+          if target.respond_to?(:dup)
+            rslt = target.dup
+            if rslt.is_a?(Regexp)
+              if slash_regexp
+                rslt = "/#{rslt.source}/"
               else
-                arr << string.gsub(/eval/, @myName)
+                rslt = rslt.source
               end
             end
+          else
+            rslt = target.to_s
+          end
+        else
+          rslt = ''
+        end
+        rslt
+      rescue
+        failed_to_log(unable_to("'#{target}'"))
+      end
+
+      def array_neighbors(arr, target)
+        less_than    = []
+        greater_than = []
+        arr.each do |elmt|
+          if elmt < target
+            less_than << elmt
+          elsif elmt > target
+            greater_than << elmt
+          end
+        end
+        [less_than.max, greater_than.min]
+      end
+
+      def array_to_list(arr, delim = ',')
+        list = ''
+        arr.each do |entry|
+          if entry =~ /#{delim}/
+            list << "\"#{entry}\""
+          else
+            list << entry
           end
-          break if myCaller =~ /:in .run.$|runner\.rb/
+          list << "#{delim} " unless entry == arr.last
         end
-        #debug_to_log("#{arr.length} #{nice_array(arr)}")
-        [arr.length, arr]
+        list
       end
 
+      alias arr2list array_to_list
+
       def awetestlib?
-        not Awetestlib::Runner.nil?
+        defined? Awetestlib::Runner
       rescue
         return false
       end
 
       def get_os
-        @os = OpenStruct.new(
-          :name     => Sys::Uname.sysname,
-          :version  => Sys::Uname.version,
-          :release  => Sys::Uname.release,
-          :nodename => Sys::Uname.nodename,
-          :machine  => Sys::Uname.machine
+        $os = OpenStruct.new(
+            :name     => Sys::Uname.sysname,
+            :version  => Sys::Uname.version,
+            :release  => Sys::Uname.release,
+            :nodename => Sys::Uname.nodename,
+            :machine  => Sys::Uname.machine
         )
       end