watir 1.4.1 → 1.5.2

data/watir/elements.rb

@@ -0,0 +1,65 @@
+module Watir
+  class Ul < NonControlElement
+    TAG = 'UL'
+  end
+  module Container
+    def ul(how, what)
+      return Ul.new(self, how, what)
+    end
+  end
+  
+  class H1 < NonControlElement
+    TAG = 'H1'
+  end
+  module Container
+    def h1(how, what)
+      return H1.new(self, how, what)
+    end
+  end
+  
+  class H2 < NonControlElement
+    TAG = 'H2'
+  end
+  module Container
+    def h2(how, what)
+      return H2.new(self, how, what)
+    end
+  end
+
+  class H3 < NonControlElement
+    TAG = 'H3'
+  end
+  module Container
+    def h3(how, what)
+      return H3.new(self, how, what)
+    end
+  end
+
+  class H4 < NonControlElement
+    TAG = 'H4'
+  end
+  module Container
+    def h4(how, what)
+      return H4.new(self, how, what)
+    end
+  end
+
+  class H5 < NonControlElement
+    TAG = 'H5'
+  end
+  module Container
+    def h5(how, what)
+      return H5.new(self, how, what)
+    end
+  end
+  class H6 < NonControlElement
+    TAG = 'H6'
+  end
+
+  module Container
+    def h6(how, what)
+      return H6.new(self, how, what)
+    end
+  end
+
+end

data/watir/exceptions.rb

@@ -9,52 +9,34 @@ module Watir
     end
     
     # This exception is thrown if an attempt is made to access an object that doesn't exist
-    class UnknownObjectException < WatirException
-    end
-    
+    class UnknownObjectException < WatirException; end
     # This exception is thrown if an attempt is made to access an object that is in a disabled state
-    class ObjectDisabledException   < WatirException
-    end
-    
+    class ObjectDisabledException   < WatirException; end
     # This exception is thrown if an attempt is made to access a frame that cannot be found 
-    class UnknownFrameException< WatirException
-    end
-    
+    class UnknownFrameException< WatirException; end
     # This exception is thrown if an attempt is made to access a form that cannot be found 
-    class UnknownFormException< WatirException
-    end
-    
+    class UnknownFormException< WatirException; end
     # This exception is thrown if an attempt is made to access an object that is in a read only state
-    class ObjectReadOnlyException  < WatirException
-    end
-    
+    class ObjectReadOnlyException  < WatirException; end
     # This exception is thrown if an attempt is made to access an object when the specified value cannot be found
-    class NoValueFoundException < WatirException
-    end
-    
+    class NoValueFoundException < WatirException; end
     # This exception gets raised if part of finding an object is missing
-    class MissingWayOfFindingObjectException < WatirException
-    end
-
-    # This exception is raised if an attempt is made to access a table that doesn't exist
-    class UnknownTableException < WatirException
-    end
-
+    class MissingWayOfFindingObjectException < WatirException; end
     # this exception is raised if an attempt is made to  access a table cell that doesnt exist
-    class UnknownCellException < WatirException
-    end
-    
+    class UnknownCellException < WatirException; end
     # This exception is thrown if the window cannot be found
-    class NoMatchingWindowFoundException < WatirException
-    end
-
+    class NoMatchingWindowFoundException < WatirException; end
     # This exception is thrown if an attemp is made to acces the status bar of the browser when it doesnt exist
-    class NoStatusBarException < WatirException
-    end
-
+    class NoStatusBarException < WatirException; end
     # This exception is thrown if an http error, such as a 404, 500 etc is encountered while navigating
-    class NavigationException < WatirException
+    class NavigationException < WatirException; end
+    # This exception is raised if a timeout is exceeded
+    class TimeOutException < WatirException
+      def initialize(duration, timeout)
+        @duration, @timeout = duration, timeout
+      end 
+      attr_reader :duration, :timeout
     end
-
+    
   end
 end

data/watir/ie-process.rb

@@ -0,0 +1,40 @@
+require 'win32/process'
+
+module Watir
+  class IE
+    class Process
+      def self.start
+        program_files = ENV['ProgramFiles'] || "c:\\Program Files"
+        startup_command = "#{program_files}\\Internet Explorer\\iexplore.exe"
+        process_info = ::Process.create('app_name' => "#{startup_command} about:blank")
+        process_id = process_info.process_id
+        new process_id
+      end
+      
+      def initialize process_id
+        @process_id = process_id
+      end
+      attr_reader :process_id
+      
+      def window
+        Waiter.wait_until do
+          IE.each do | ie |
+            window = ie.ie
+            hwnd = ie.hwnd
+            process_id = Process.process_id_from_hwnd hwnd        
+            return window if process_id == @process_id
+          end
+        end
+      end
+      
+      # Returns the process id for the specifed hWnd.
+      def self.process_id_from_hwnd hwnd
+        pid_info = ' ' * 32
+        Win32API.new('user32', 'GetWindowThreadProcessId', 'ip', 'i').
+        call(hwnd, pid_info)
+        process_id =  pid_info.unpack("L")[0]
+      end
+      
+    end
+  end
+end

data/watir/irb-history.rb

@@ -0,0 +1,31 @@
+# snarfed from http://blog.nicksieger.com/articles/2006/04/23/tweaking-irb
+module Readline
+  module History
+    @@log ||= File.join(Dir.pwd, 'console.log')
+    
+    def self.log= log
+      @@log = log
+    end
+    
+    def self.write_log(line)
+      begin
+        File.open(@@log, 'ab') {|f| f << "#{line}\n"}
+      rescue
+      end
+    end 
+
+    def self.start_session_log
+      write_log("# session start: #{Time.now}")
+      at_exit { write_log("# session stop: #{Time.now}\n") }
+    end
+  end
+
+  alias :old_readline :readline
+  def readline(*args)
+    ln = old_readline(*args)
+    History.write_log(ln)
+    ln
+  end
+end
+
+Readline::History.start_session_log

data/watir/process.rb

@@ -0,0 +1,20 @@
+module Watir
+  module Process
+    
+    # Returns the number of windows processes running with the specified name.
+    def self.count name
+      mgmt = WIN32OLE.connect('winmgmts:\\\\.')
+      processes = mgmt.InstancesOf('win32_process')
+      processes.extend Enumerable
+      processes.select{|x| x.name == name}.length
+    end
+    
+  end
+  
+  class IE
+    # Returns the number of IEXPLORE processes currently running.
+    def self.process_count
+      Watir::Process.count 'iexplore.exe'
+    end    
+  end
+end

data/watir/testUnitAddons.rb

@@ -1,47 +1,8 @@
-
-        
 module Test::Unit::Assertions
-
-
-   def assert_false(boolean, message=nil)
+    def assert_false(boolean, message=nil)
         _wrap_assertion do
-          assert_block("assert should not be called with a block.") { !block_given? }
-          assert_block(build_message(message, "<?> is not false.", boolean)) { !boolean }
+            assert_block("assert should not be called with a block.") { !block_given? }
+            assert_block(build_message(message, "<?> is not false.", boolean)) { !boolean }
         end
-      end
-
-
-     def compareArrays( expectArray, actualArray)
-             result = true
-             expectArray.each_with_index do |element,i|
-                 #puts "Comparing #{element} #{element.class} with #{actualArray[i]} #{actualArray[i].class} "
-                 if element != actualArray[i]
-                     result = false
-                     break
-                 end
-            end  
-
-        return result
-
     end
-
-    def assert_arrayEquals(expectArray, actualArray, message = nil )
-        _wrap_assertion do
-          assert_block("assert should not be called with a block.") { !block_given? }
-          assert_equal(expectArray.length, actualArray.length, "Lengths did not match")
-
-          assert_block("contents are different." ){  compareArrays( expectArray, actualArray)  }
-       end  #_wrap
-    end #def
-
-
-    def assert_arrayContains(array, string , message =nil)
-
-         _wrap_assertion do
-          assert_block("assert should not be called with a block.") { !block_given? }
-          assert(array.kind_of?(Array) , "Must have an array")
-          assert(array.include?(string) , message)
-        end
-    end
-
 end # module test

data/watir/testcase.rb

@@ -0,0 +1,58 @@
+require 'test/unit'
+require 'watir/assertions'
+
+module Watir
+
+  class TestCase < Test::Unit::TestCase
+    include Watir::Assertions
+    @@order = :sequentially
+    def initialize name
+      throw :invalid_test if name == :default_test && self.class == Watir::TestCase
+      super
+    end        
+    class << self
+      attr_accessor :test_methods, :order
+      def test_methods
+        @test_methods ||= []
+      end
+      def order
+        @order || @@order
+      end
+      def default_order= order
+        @@order = order
+      end
+      def sorted_test_methods
+        case order
+        when :alphabetically:          test_methods.sort
+        when :sequentially:            test_methods
+        when :reversed_sequentially:   test_methods.reverse
+        when :reversed_alphabetically: test_methods.sort.reverse
+        else raise ArgumentError, "Execute option not supported: #{@order}"
+        end
+      end
+      def suite
+        suite = Test::Unit::TestSuite.new(name)
+        sorted_test_methods.each do |test|
+          catch :invalid_test do
+            suite << new(test)
+          end
+        end
+        if (suite.empty?)
+          catch :invalid_test do
+            suite << new(:default_test)
+          end
+        end
+        return suite
+      end
+      def method_added id
+        name = id.id2name
+        test_methods << name if name =~ /^test./
+      end
+      def execute order
+        @order = order
+      end
+    end
+    public :add_assertion
+  end    
+
+end  

data/watir/utils.rb

@@ -0,0 +1,20 @@
+# watir/utils.rb
+
+module Watir
+  module Utils
+      
+    # Eval the provided block. If a WIN32OLERuntimeError is raised by the block,
+    # return false.
+    def suppress_ole_error
+      begin
+        yield
+        true
+      rescue WIN32OLERuntimeError
+        false
+      end
+    end
+    
+  end
+end
+  
+  

data/watir/waiter.rb

@@ -0,0 +1,88 @@
+require 'watir/exceptions'
+
+module Watir
+
+class TimeKeeper
+  attr_reader :sleep_time
+  def initialize 
+    @sleep_time = 0.0
+  end
+  def sleep seconds
+    @sleep_time += Kernel.sleep seconds    
+  end
+  def now
+    Time.now
+  end
+end
+
+class Waiter
+  # This is an interface to a TimeKeeper which proxies
+  # calls to "sleep" and "Time.now".
+  # Useful for unit testing Waiter.
+  attr_accessor :timer
+
+  # How long to wait between each iteration through the wait_until
+  # loop. In seconds.
+  attr_accessor :polling_interval
+
+  # Timeout for wait_until.
+  attr_accessor :timeout
+  
+  @@default_polling_interval = 0.5
+  @@default_timeout = 60.0
+
+  def initialize(timeout=@@default_timeout,
+                 polling_interval=@@default_polling_interval)
+    @timeout = timeout
+    @polling_interval = polling_interval
+    @timer = TimeKeeper.new
+  end
+
+  # Execute the provided block until either (1) it returns true, or
+  # (2) the timeout (in seconds) has been reached. If the timeout is reached,
+  # a TimeOutException will be raised. The block will always
+  # execute at least once.  
+  # 
+  # waiter = Waiter.new(5)
+  # waiter.wait_until {puts 'hello'}
+  # 
+  # This code will print out "hello" for five seconds, and then raise a 
+  # Watir::TimeOutException.
+  def wait_until # block
+    start_time = now
+    until yield do
+      if (duration = now - start_time) > @timeout
+        raise Watir::Exception::TimeOutException.new(duration, @timeout),
+          "Timed out after #{duration} seconds."
+      end
+      sleep @polling_interval
+    end
+  end  
+
+  # Execute the provided block until either (1) it returns true, or
+  # (2) the timeout (in seconds) has been reached. If the timeout is reached,
+  # a TimeOutException will be raised. The block will always
+  # execute at least once.  
+  # 
+  # Waiter.wait_until(5) {puts 'hello'}
+  # 
+  # This code will print out "hello" for five seconds, and then raise a 
+  # Watir::TimeOutException.  
+
+  # IDEA: wait_until: remove defaults from Waiter.wait_until
+  def self.wait_until(timeout=@@default_timeout,
+                      polling_interval=@@default_polling_interval)
+    waiter = new(timeout, polling_interval)
+    waiter.wait_until { yield }
+  end
+     
+  private
+  def sleep seconds
+    @timer.sleep seconds
+  end
+  def now
+    @timer.now
+  end
+end  
+    
+end # module