watir-classic 3.7.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 73e938bbd43dbc55379ce36d3fc826bb636a65d4
-  data.tar.gz: b9894a14322b0077c26cbfd1d729966f3a355e78
+  metadata.gz: 9b48648a4afcf9526da12f6baf012a4f0fec8411
+  data.tar.gz: 70def43f23d469fbb1de955b8112c6ce7d4e7a11
 SHA512:
-  metadata.gz: b04aa3fde25905e96a31297f6de93dad85618c8a3aef68801ba02c234c9eb44650471355342c349625473cf736f074acc23db1ac8de4d6d74063f031f549d259
-  data.tar.gz: cde4f06da44866e0890e618b91c9e555c7895cfd27d2ae146ccb28ccc8607859d505413ae4a7b43956f01789624f9429ffc4587af8ab0db7ea85d88628147047
+  metadata.gz: 7980313c5a552ed151618b593bc1742d26c7918241a2fac62871fd8ef0b7f0ce593e5bd02d3953feeb0a68411155ea85bd4059fdefd94363e2dca8a4bbdc69dc
+  data.tar.gz: d89a17e83ebf2e1ae901e89808c1b6ceb9f4551089663a263a45e7a38da368af0ad0a4bcf027879ddf6eccb8e423b8e6bec8eddf72f8e25dd8c8861363e6eb09

data/.gitignore

@@ -5,3 +5,5 @@ pkg/
 .idea/
 .yardoc/
 doc/
+
+Gemfile.lock

data/CHANGES

@@ -1,3 +1,9 @@
+== 4.0.0 - 2013/10/05
+
+* Browser#add_checker also accepts block instead of a proc object.
+* Browser#initialize suppresses window only when actual "true" value is given as an argument.
+* Rename Watir::IE to Watir::Browser. Closes #47 and #53.
+
 == 3.7.0 - 2013/05/10
 
 * Add #required? method for input elements.

data/Rakefile

@@ -5,6 +5,8 @@ Bundler::GemHelper.install_tasks
 
 task :default => :spec
 
+task :release => :spec
+
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 

data/VERSION

@@ -1 +1 @@
-3.7.0
+4.0.0

data/lib/watir-classic.rb

@@ -1,8 +1,41 @@
+require 'timeout'
+require 'multi_json'      
+require 'rautomation'
+
 require 'watir-classic/version'
-require 'watir-classic/wait'
-require 'watir-classic/wait_helper'
-require 'watir-classic/element_extensions'
+require 'watir-classic/win32ole'
 require 'watir-classic/util'
 require 'watir-classic/exceptions'
 require 'watir-classic/matches'
+require 'watir-classic/wait'
+require 'watir-classic/wait_helper'
+require 'watir-classic/element_extensions'
+require 'watir-classic/container'
+require 'watir-classic/xpath_locator'
+require 'watir-classic/locator'
+require 'watir-classic/page-container'
+require 'watir-classic/browser_process'
+require 'watir-classic/screenshot'
 require 'watir-classic/browser'
+require 'watir-classic/drag_and_drop_helper'
+require 'watir-classic/element'
+require 'watir-classic/element_collection'
+require 'watir-classic/form'
+require 'watir-classic/frame'
+require 'watir-classic/input_elements'
+require 'watir-classic/non_control_elements'
+require 'watir-classic/table'
+require 'watir-classic/image'
+require 'watir-classic/link'
+require 'watir-classic/window'
+require 'watir-classic/cookies'
+require 'watir-classic/win32'
+require 'watir-classic/modal_dialog'
+require 'watir-classic/module'
+require 'watir-classic/dialogs/file_field'
+require 'watir-classic/dialogs/alert'
+require 'watir-classic/supported_elements'
+
+module Watir
+  autoload :IE, File.expand_path("watir-classic/ie_deprecated", File.dirname(__FILE__))
+end

data/lib/watir-classic/browser.rb

@@ -1,60 +1,83 @@
-require 'watir-classic/options'
 module Watir
-  
-=begin rdoc
+  # Main browser class.
+  class Browser
+    include WaitHelper
+    include Exception
+    include Container
+    include PageContainer
 
-Watir is a family of open-source drivers for automating web browsers. You
-can use it to write tests that are easy to read and maintain. 
+    class << self
+      # Maximum number of seconds to wait when attaching to a window
+      attr_writer :attach_timeout
 
-Watir drives browsers the same way people do. It clicks links, fills in forms,
-presses buttons. Watir also checks results, such as whether expected text 
-appears on a page.
+      def attach_timeout
+        @attach_timeout ||= 2
+      end
 
-The Watir Classic is a driver for Internet Explorer (on Windows).
+      # Return the options used when creating new instances of {Browser}.
+      # BUG: this interface invites misunderstanding/misuse such as Browser.options[:speed] = :zippy]
+      def options
+        {:speed => self.speed, :visible => self.visible, :attach_timeout => self.attach_timeout}
+      end
 
-Project Homepage: http://watir.com
+      # set values for options used when creating new instances of {Browser}.
+      def set_options options
+        options.each do |name, value|
+          send "#{name}=", value
+        end
+      end
 
-@example usage
+      # The speed in which browser will type keys etc. Possible values are
+      # :slow (default), :fast and :zippy.
+      attr_writer :speed
 
-  require 'watir-classic'
-  browser = Watir::Browser.new
-  browser.goto 'http://google.com'
-  browser.text_field(:name => 'q').set 'pickaxe'  
-  browser.button(:name => 'btnG').click
-  if browser.text.include? 'Programming Ruby'
-    puts 'Text was found'
-  else
-    puts 'Text was not found'
-  end
+      def speed
+        @speed ||= :slow
+      end
 
-=end rdoc
-  
-  class Browser
-    # @private
-    @@browser_classes = {}
+      # Set browser window to visible or hidden. Defaults to true.
+      attr_writer :visible
 
-    # @private
-    @@sub_options = {}
+      def visible
+        @visible ||= true
+      end
 
-    # @private
-    @@default = nil
+      # Create a new IE window.
+      def new_window
+        ie = new true
+        ie._new_window_init
+        ie
+      end
 
-    class << self
+      # Create a new IE, starting at the specified url.
+      # @param [String] url url to navigate to.
+      def start(url=nil)
+        start_window url
+      end
+
+      # Create a new IE window, starting at the specified url.
+      # @param [String] url url to navigate to.
+      def start_window(url=nil)
+        ie = new_window
+        ie.goto url if url
+        ie
+      end
 
-      # Create a new instance of the {Browser} object
-      # @param [Object] ignored Argument is only needed to make
-      #   watir-classic more compatible with watir-webdriver and is really ignored.
-      def new(ignored=nil)
-        set_sub_options
-        klass.new
+      # Create a new IE window in a new process. 
+      # @note This method will not work when
+      #   Watir/Ruby is run under a service (instead of a user).
+      def new_process
+        ie = new true
+        ie._new_process_init
+        ie
       end
 
-      # Create a new {Browser} instance as with {.new} and start the browser on the
-      # specified url.
-      # @param [String] url Url to start the browser at.
-      def start(url)
-        set_sub_options
-        klass.start url
+      # Create a new IE window in a new process, starting at the specified URL. 
+      # @param [String] url url to navigate to.
+      def start_process(url=nil)
+        ie = new_process
+        ie.goto url if url
+        ie
       end
 
       # Attach to an existing IE {Browser}.
@@ -74,99 +97,574 @@ Project Homepage: http://watir.com
       # @param [Symbol] how type of the locator. Can be :title, :url or :hwnd.
       # @param [Symbol] what value of the locator. Can be {String}, {Regexp} or {Fixnum}
       #   depending of the type parameter.
+      #
+      # @note This method will not work when
+      #   Watir/Ruby is run under a service (instead of a user).
       def attach(how, what)
-        set_sub_options
-        klass.attach(how, what)
-      end
-      
-      # Set options for the {Browser}.
-      def set_options(options)
-        return unless klass.respond_to?(:set_options)
-        klass.set_options options
+        ie = new true # don't create window
+        ie._attach_init(how, what)
+        ie
       end
 
-      # @return [Hash] options of the {Browser}.
-      def options
-        return {} unless klass.respond_to?(:options)
-        klass.options
+      # Yields successively to each IE window on the current desktop. Takes a block.
+      # @note This method will not work when
+      #   Watir/Ruby is run under a service (instead of a user).
+      # @yieldparam [Browser] ie instances of IE found.
+      def each
+        shell = WIN32OLE.new('Shell.Application')
+        ie_browsers = []
+        shell.Windows.each do |window|
+          next unless (window.path =~ /Internet Explorer/ rescue false)
+          next unless (hwnd = window.hwnd rescue false)
+          ie = bind(window)
+          ie.hwnd = hwnd
+          ie_browsers << ie
+        end
+        ie_browsers.each do |ie|
+          yield ie
+        end
       end
 
-      def klass
-        key = Watir.options[:browser]
-        eval @@browser_classes[key] # this triggers the autoload
+      # @return [String] the IE browser version number as a string.
+      def version
+        @ie_version ||= begin
+                          require 'win32/registry'
+                          ::Win32::Registry::HKEY_LOCAL_MACHINE.open("SOFTWARE\\Microsoft\\Internet Explorer") do |ie_key|
+                            begin
+                              ie_key['svcVersion']
+                            rescue ::Win32::Registry::Error
+                              ie_key['Version']
+                            end
+                          end
+                        end
       end
-      private :klass
-
-      # Add support for the browser option, using the specified class, 
-      # provided as a string. Optionally, additional options supported by
-      # the class can be specified as an array of symbols. Options specified
-      # by the user and included in this list will be passed (as a hash) to 
-      # the set_options class method (if defined) before creating an instance.
-      # @todo remove this and autoloading since now only IE is supported.
-      # @private
-      def support hash_args
-        option = hash_args[:name]
-        class_string = hash_args[:class]
-        additional_options = hash_args[:options]
-        library = hash_args[:library]
-        gem = hash_args[:gem] || library
 
-        @@browser_classes[option] = class_string        
-        @@sub_options[option] = additional_options
+      # @return [Array<String>] the IE browser version numbers split by "." in an Array.
+      def version_parts
+        version.split('.')
+      end
 
-        autoload class_string, library
-        activate_gem gem, option
+      # Find existing IE window with locators.
+      # @see .attach
+      def find(how, what)
+        ie_ole = _find(how, what)
+        bind ie_ole if ie_ole
       end
-      
+
+      # Return an Browser object that wraps the given window, typically obtained from
+      # Shell.Application.windows.
       # @private
-      def default
-        @@default
+      def bind(window)
+        ie = new true
+        ie.ie = window
+        ie.initialize_options
+        ie
       end
 
-      # Specifies a default browser. Must be specified before options are parsed.
-      # @todo remove this since only IE is supported.
       # @private
-      def default= option
-        @@default = option
+      def _find(how, what)
+        _find_all(how, what).first
       end
 
-      # Returns the names of the browsers that are supported by this module.
-      # These are the options for 'watir_browser' (env var) or 'browser:' (yaml).
-      # @todo remove this since only IE is supported.
       # @private
-      def browser_names
-        @@browser_classes.keys
-      end      
-      
-      private
-
-      # @todo remove this since only IE is supported.
-      def autoload class_string, library
-        mod, klass = class_string.split('::')
-        eval "module ::#{mod}; autoload :#{klass}, '#{library}'; end"
-      end
-
-      # Activate the gem (if installed). The default browser will be set
-      # to the first gem that activates.
-      # @todo remove this since only IE is supported.
-      def activate_gem gem_name, option
+      def _find_all(how, what)
+        ies = []
+        count = -1
+        each do |ie|
+          window = ie.ie
+
+          case how
+          when :url
+            ies << window if (what.matches(window.locationURL))
+          when :title
+            # normal windows explorer shells do not have document
+            # note window.document will fail for "new" browsers
+            begin
+              title = window.locationname
+              title = window.document.title
+            rescue WIN32OLERuntimeError
+            end
+            ies << window if what.matches(title)
+          when :hwnd
+            begin
+              ies << window if what == window.HWND
+            rescue WIN32OLERuntimeError
+            end
+          when :index
+            count += 1
+            if count == what
+              ies << window
+              break
+            end
+          when nil
+            ies << window
+          else
+            raise ArgumentError
+          end
+        end      
+
+        ies
+      end
+
+    end
+
+    # Used internally to determine when IE has finished loading a page.
+    # @private
+    READYSTATES = {:complete => 4}
+
+    # The default color for highlighting objects as they are accessed.
+    # @private
+    HIGHLIGHT_COLOR = 'yellow'
+
+    # The time, in seconds, it took for the new page to load after executing
+    # the last command.
+    attr_reader :down_load_time
+
+    # The OLE Internet Explorer object.
+    attr_accessor :ie
+
+    # The list of unique urls that have been visited.
+    attr_reader :url_list
+
+    # @private
+    attr_writer :hwnd
+
+    # Create an IE browser instance.
+    # @param [Boolean] suppress_new_window set to true for not creating a IE
+    #   window.
+    def initialize(suppress_new_window=nil)
+      _new_window_init unless suppress_new_window == true 
+    end
+
+    # Specifies the speed that commands will be executed at.
+    # Possible choices are:
+    # * :slow (default)
+    # * :fast 
+    # * :zippy
+    # 
+    # With :zippy, text fields will be entered at once, instead of
+    # character by character.
+    #
+    # @note :zippy speed does not trigger JavaScript events like onChange etc.
+    #
+    # @param [Symbol] how_fast possible choices are :slow (default), :fast and
+    #   :zippy
+    # @raise [ArgumentError] when invalid speed is specified.
+    def speed=(how_fast)
+      case how_fast
+      when :zippy
+        @typingspeed = 0
+        @pause_after_wait = 0.01
+        @type_keys = false
+        @speed = :fast
+      when :fast
+        @typingspeed = 0
+        @pause_after_wait = 0.01
+        @type_keys = true
+        @speed = :fast
+      when :slow
+        @typingspeed = 0.08
+        @pause_after_wait = 0.1
+        @type_keys = true
+        @speed = :slow
+      else
+        raise ArgumentError, "Invalid speed: #{how_fast}. Possible choices are :slow, :fast and :zippy."
+      end
+    end
+
+    # @return [Symbol] current speed setting. May be :slow, :fast or :zippy.
+    def speed
+      return @speed if @speed == :slow
+      return @type_keys ? :fast : :zippy
+    end
+
+    # @deprecated Use {#speed=} with :fast argument instead.
+    def set_fast_speed
+      Kernel.warn "Deprecated(Browser.set_fast_speed) - use Browser#speed = :fast instead."
+      self.speed = :fast
+    end
+
+    # @deprecated Use {#speed=} with :slow argument instead.
+    def set_slow_speed
+      Kernel.warn "Deprecated(Browser.set_slow_speed) - use Browser#speed = :slow instead."
+      self.speed = :slow
+    end
+
+    # @return [Boolean] true when window is visible, false otherwise.
+    def visible
+      @ie.visible
+    end
+    
+    # Set the visibility of IE window.
+    # @param [Boolean] boolean set to true if IE window should be visible, false
+    #   otherwise.
+    def visible=(boolean)
+      @ie.visible = boolean if boolean != @ie.visible
+    end
+
+    # @return [Fixnum] current IE window handle.
+    # @raise [RuntimeError] when not attached to a browser.
+    def hwnd
+      raise "Not attached to a browser" if @ie.nil?
+      @hwnd ||= @ie.hwnd
+    end
+
+    # @return [Symbol] the name of the browser. Is always :internet_explorer.
+    def name
+      :internet_explorer
+    end
+
+    # @return [Boolean] true when IE window exists, false otherwise.
+    def exists?
+      !!(@ie.name =~ /Internet Explorer/)
+    rescue WIN32OLERuntimeError, NoMethodError
+      false
+    end
+
+    alias :exist? :exists?
+
+    # @return [String] the title of the document.
+    def title
+      @ie.document.title
+    end
+
+    # @return [String] the status text of the window, typically from the status bar at the bottom.
+    #   Will be empty if there's no status or when there are problems accessing status text.
+    def status
+      @ie.statusText
+    rescue WIN32OLERuntimeError
+      ""
+    end
+
+    #
+    # Navigation
+    #
+
+    # Navigate to the specified URL.
+    # @param [String] url url to navigate to.
+    # @return [Fixnum] time in seconds the page took to load.
+    def goto(url)
+      url = "http://" + url unless url =~ %r{://} || url == "about:blank"
+      @ie.navigate(url)
+      wait
+      return @down_load_time
+    end
+
+    # Go to the previous page - the same as clicking the browsers back button.
+    # @raise [WIN32OLERuntimeError] when the browser can't go back.
+    def back
+      @ie.GoBack
+      wait
+    end
+
+    # Go to the next page - the same as clicking the browsers forward button.
+    # @raise [WIN32OLERuntimeError] when the browser can't go forward.
+    def forward
+      @ie.GoForward
+      wait
+    end
+
+    # Refresh the current page - the same as clicking the browsers refresh button.
+    # @raise [WIN32OLERuntimeError] when the browser can't refresh.
+    def refresh
+      @ie.refresh2(3)
+      wait
+    end
+
+    def inspect
+      '#<%s:0x%x url=%s title=%s>' % [self.class, hash*2, url.inspect, title.inspect]
+    end
+
+    # Clear the list of urls that have been visited.
+    def clear_url_list
+      @url_list.clear
+    end
+
+    # Close the {Browser}.
+    def close
+      return unless exists?
+      @ie.stop
+      wait rescue nil
+      chwnd = @ie.hwnd.to_i
+      @ie.quit
+      t = ::Time.now
+      while exists?
+        # just in case to avoid possible endless loop if failing to close some
+        # window or tab
+        break if ::Time.now - t > 10
+        sleep 0.3
+      end
+    end
+
+    # Maximize the window (expands to fill the screen).
+    def maximize
+      rautomation.maximize
+    end
+
+    # Minimize the window (appears as icon on taskbar).
+    def minimize
+      rautomation.minimize
+    end
+
+    # @return [Boolean] true when window is minimized, false otherwise.
+    def minimized?
+      rautomation.minimized?
+    end
+
+    # Restore the window (after minimizing or maximizing).
+    def restore
+      rautomation.restore
+    end
+
+    # Make the window come to the front.
+    def activate
+      rautomation.activate
+    end
+
+    alias :bring_to_front :activate
+
+    # @return [Boolean] true when window is in front e.g. in focus, false otherwise.
+    def active?
+      rautomation.active?
+    end
+
+    alias :front? :active?
+
+    # @return [RAutomation::Window] the RAutomation instance for this IE window.
+    # @see https://github.com/jarmo/rautomation
+    def rautomation
+      @rautomation ||= ::RAutomation::Window.new(:hwnd => hwnd)
+    end
+
+    # @deprecated use {#rautomation} instead.
+    def autoit
+      Kernel.warn "Deprecated(Browser#autoit) - use Browser#rautomation instead. Refer to https://github.com/jarmo/RAutomation for updating your scripts."
+      @autoit ||= ::RAutomation::Window.new(:hwnd => hwnd, :adapter => :autoit)
+    end
+
+    # Activates the window and sends keys to it.
+    #
+    # @example
+    #   browser.send_keys("Hello World", :enter)
+    #
+    # @see https://github.com/jarmo/RAutomation/blob/master/lib/rautomation/adapter/win_32/window.rb RAutomation::Window#send_keys documentation.
+    def send_keys(*keys)
+      rautomation.send_keys *keys
+    end
+
+    #
+    # Document and Document Data
+    #
+
+    # @return [WIN32OLE] current IE document.
+    def document
+      @ie.document
+    end
+
+    # @return [String] current url, as displayed in the address bar of the browser.
+    def url
+      @ie.LocationURL
+    end
+
+    # Create a {Screenshot} instance.
+    def screenshot
+      Screenshot.new(hwnd)
+    end
+
+    # Retrieve a {Window} instance.
+    # 
+    # @example Retrieve a different window without block.
+    #   browser.window(:title => /other window title/).use
+    #   browser.title # => "other window title"
+    #
+    # @example Use different window with block.
+    #   browser.window(:title => /other window title/) do
+    #     browser.title # => "other window title"
+    #   end
+    #   browser.title # => "current window title"
+    #
+    # @param [Hash] specifiers options for finding window.
+    # @option specifiers [String,Regexp] :title Title of the window.
+    # @option specifiers [String,Regexp] :url Url of the window.
+    # @option specifiers [Fixnum] :index The index of the window.
+    # @yield yield optionally to the found window.
+    # @return [Window] found window instance.
+    def window(specifiers={}, &blk)
+      win = Window.new(self, specifiers, &blk)
+      win.use &blk if blk
+      win
+    end
+
+    # @see #window
+    # @return [Array<Window>] array of found windows.
+    def windows(specifiers={})
+      self.class._find_all(specifiers.keys.first, specifiers.values.first).map {|ie| Window.new(self, specifiers, self.class.bind(ie))}
+    end
+
+    # Retrieve {Cookies} instance.
+    def cookies
+      Cookies.new(self)
+    end
+
+    # Add an error checker that gets executed after every page load, click etc.
+    #
+    # @example
+    #   browser.add_checker lambda { |browser| raise "Error!" if browser.text.include? "Error" }
+    #
+    # @param [Proc] checker Proc object which gets yielded with {Browser} instance.
+    def add_checker(checker = nil, &block)
+      if block_given?
+        @error_checkers << block
+      elsif checker.respond_to? :call
+        @error_checkers << checker
+      else
+        raise ArgumentError, "expected block or object responding to #call"
+      end
+    end
+
+    # Disable an error checker added via {#add_checker}.
+    #
+    # @param [Proc] checker Proc object to be removed from error checkers.
+    def disable_checker(checker)
+      @error_checkers.delete(checker)
+    end
+
+    # Gives focus to the window frame.
+    def focus
+      active_element = document.activeElement
+      active_element.blur if active_element && active_element.tagName != "BODY"
+      document.focus
+    end
+
+    # @private
+    def attach_command
+      "Watir::Browser.attach(:hwnd, #{hwnd})"
+    end
+
+    # @private
+    def _new_window_init
+      create_browser_window
+      initialize_options
+      goto 'about:blank' # this avoids numerous problems caused by lack of a document
+    end
+
+    # @private
+    def _new_process_init
+      iep = Process.start
+      @ie = iep.window
+      @process_id = iep.process_id
+      initialize_options
+      goto 'about:blank'
+    end
+
+    # this method is used internally to attach to an existing window
+    # @private
+    def _attach_init how, what
+      attach_browser_window how, what
+      initialize_options
+      wait
+    end
+
+    # @private
+    def initialize_options
+      self.visible = self.class.visible
+      self.speed = self.class.speed
+
+      @ole_object = nil
+      @page_container = self
+      @error_checkers = []
+      @active_object_highlight_color = HIGHLIGHT_COLOR
+      @url_list = []
+    end
+
+    #
+    # Synchronization
+    #
+
+    # Block execution until the page has loaded.
+    #
+    # Will raise Timeout::Error if page hasn't been loaded within 5 minutes.
+    # Note: This code needs to be prepared for the ie object to be closed at 
+    # any moment!
+    #
+    # @private
+    def wait(no_sleep=false)
+      @xml_parser_doc = nil
+      @down_load_time = 0.0
+      interval = 0.05
+      start_load_time = ::Time.now
+
+      Timeout::timeout(5*60) do
         begin
-          gem gem_name 
-          @@default ||= option
-        rescue Gem::LoadError
+          while @ie.busy
+            sleep interval
+          end
+
+          until READYSTATES.has_value?(@ie.readyState)
+            sleep interval
+          end
+
+          until @ie.document
+            sleep interval
+          end
+
+          documents_to_wait_for = [@ie.document]
+        rescue WIN32OLERuntimeError # IE window must have been closed
+          @down_load_time = ::Time.now - start_load_time
+          return @down_load_time
+        end
+
+        while doc = documents_to_wait_for.shift
+          begin
+            until READYSTATES.has_key?(doc.readyState.to_sym)
+              sleep interval
+            end
+            @url_list << doc.location.href unless @url_list.include?(doc.location.href)
+            doc.frames.length.times do |n|
+              begin
+                documents_to_wait_for << doc.frames[n.to_s].document
+              rescue WIN32OLERuntimeError, NoMethodError
+              end
+            end
+          rescue WIN32OLERuntimeError
+          end
         end
       end
 
-      # @todo remove this since only IE is supported.
-      def set_sub_options
-        sub_options = @@sub_options[Watir.options[:browser]]
-        return if sub_options.nil?
-        specified_options = Watir.options.reject {|k, v| !sub_options.include? k}
-        self.set_options specified_options
+      @down_load_time = ::Time.now - start_load_time
+      run_error_checks
+      sleep @pause_after_wait unless no_sleep
+      @down_load_time
+    end
+
+    # Error checkers
+
+    # Run the predefined error checks.
+    #
+    # @private
+    def run_error_checks
+      @error_checkers.each { |e| e.call(self) }
+    end
+
+    private
+
+    def create_browser_window
+      @ie = WIN32OLE.new('InternetExplorer.Application')
+    end
+
+    def attach_browser_window how, what
+      ieTemp = nil
+      begin
+        Wait.until(self.class.attach_timeout) do
+          ieTemp = self.class._find how, what
+        end
+      rescue Wait::TimeoutError
+        raise NoMatchingWindowFoundException,
+        "Unable to locate a window with #{how} of #{what}"
       end
+      @ie = ieTemp
     end
-  end
 
-end
 
-require 'watir-classic/browsers'
+  end
+end