watir 1.9.2 → 2.0.0.rc2

data/unittests/selectbox_test.rb

@@ -100,28 +100,28 @@ class TC_SelectList < Test::Unit::TestCase
     assert_raises(UnknownObjectException) { browser.select_list(:index, 199).disabled }  
     assert_raises(UnknownObjectException) { browser.select_list(:index, 199).type }  
     
-    assert_equal("o3"   ,    browser.select_list(:index, 1).value)  
-    assert_equal("sel1" ,    browser.select_list(:index, 1).name)  
-    assert_equal(""     ,    browser.select_list(:index, 1).id)  
-    assert_equal("select-one",         browser.select_list(:index, 1).type)  
-    assert_equal("select-multiple",    browser.select_list(:index, 2).type)  
+    assert_equal("o3"   ,    browser.select_list(:index, 0).value)  
+    assert_equal("sel1" ,    browser.select_list(:index, 0).name)  
+    assert_equal(""     ,    browser.select_list(:index, 0).id)  
+    assert_equal("select-one",         browser.select_list(:index, 0).type)  
+    assert_equal("select-multiple",    browser.select_list(:index, 1).type)  
     
-    browser.select_list(:index,1).select(/1/)
-    assert_equal("o1", browser.select_list(:index, 1).value)  
+    browser.select_list(:index,0).select(/1/)
+    assert_equal("o1", browser.select_list(:index, 0).value)  
     
-    assert_false( browser.select_list(:index, 1).disabled)
-    assert(browser.select_list(:index, 4).disabled)
+    assert_false( browser.select_list(:index, 0).disabled)
+    assert(browser.select_list(:index, 3).disabled)
     assert(browser.select_list(:id, 'selectbox_4').disabled)
   end
   
   def test_iterator
     assert_equal(4, browser.select_lists.length)
-    assert_equal("o3"   ,    browser.select_lists[1].value)  
-    assert_equal("sel1" ,    browser.select_lists[1].name )  
-    assert_equal("select-one",         browser.select_lists[1].type )  
-    assert_equal("select-multiple" ,   browser.select_lists[2].type )  
+    assert_equal("o3"   ,    browser.select_lists[0].value)  
+    assert_equal("sel1" ,    browser.select_lists[0].name )  
+    assert_equal("select-one",         browser.select_lists[0].type )  
+    assert_equal("select-multiple" ,   browser.select_lists[1].type )  
     
-    index = 1
+    index = 0
     browser.select_lists.each do |l|
       assert_equal( browser.select_list(:index, index).name, l.name)
       assert_equal( browser.select_list(:index, index).id, l.id)
@@ -129,7 +129,7 @@ class TC_SelectList < Test::Unit::TestCase
       assert_equal( browser.select_list(:index, index).value, l.value)
       index += 1
     end
-    assert_equal(index - 1, browser.select_lists.length)
+    assert_equal(index, browser.select_lists.length)
   end
 end
 

data/unittests/speed_settings_test.rb

@@ -33,7 +33,7 @@ class TC_class_options < Test::Unit::TestCase
 		@previous = IE.options
 	end
 	def test_class_defaults
-		assert_equal({:speed => IE.speed, :visible => IE.visible, :attach_timeout => IE.attach_timeout}, IE.options)
+		assert_equal({:speed => IE.speed, :visible => IE.visible, :attach_timeout => IE.attach_timeout, :zero_based_indexing => IE.zero_based_indexing}, IE.options)
 	end
 	def test_change_defaults
 		IE.set_options(:speed => :fast)
@@ -64,4 +64,4 @@ class TC_class_options < Test::Unit::TestCase
 		@ie2.close if @ie2
     @ie3.close if @ie3
 	end
-end
+end

data/unittests/table_and_tablerow_to_a_test.rb

@@ -79,38 +79,38 @@ class TC_Table_TableRow_to_a < Test::Unit::TestCase
   end
 
   def test_tablerow_to_a_works_with_regular_row
-    first_row = browser.table(:id => "normal")[1]
+    first_row = browser.table(:id => "normal")[0]
     assert_equal(["1", "2", "3"], first_row.to_a)
   end
 
   def test_tablerow_to_a_works_with_headers_in_row
-    first_row = browser.table(:id => "headers")[1]
+    first_row = browser.table(:id => "headers")[0]
     assert_equal(["1", "2", "3", "4"], first_row.to_a)
   end
 
   def test_tablerow_to_a_works_with_nested_tables
-    second_row = browser.table(:id => "nested")[2]
+    second_row = browser.table(:id => "nested")[1]
     assert_equal([[["11", "12"], ["13", "14"]], "3"], second_row.to_a(2))
   end
 
   def test_tablerow_to_a_works_with_deep_nested_tables
-    second_row = browser.table(:id => "deepnested")[2]
+    second_row = browser.table(:id => "deepnested")[1]
     expected_row = [[["11", "12"],
                      [[["404", "405"], ["406", "407"]], "14"]], "3"]
     assert_equal(expected_row, second_row.to_a(3))
   end
 
   def test_tablerow_to_a_works_with_colspan
-    second_row = browser.table(:id => "colspan")[2]
+    second_row = browser.table(:id => "colspan")[1]
     assert_equal(["3"], second_row.to_a)
   end
 
   def test_tablerow_to_a_works_with_rowspan
     t = browser.table(:id => "rowspan")
-    second_row = t[2]
+    second_row = t[1]
     assert_equal(["3", "4"], second_row.to_a)
 
-    third_row = t[3]
+    third_row = t[2]
     assert_equal(["5"], third_row.to_a)
   end
 end

data/unittests/table_test.rb

@@ -21,7 +21,7 @@ class TC_Tables < Test::Unit::TestCase
     assert !browser.table(:id, 'missingTable').exists?
     assert !browser.table(:id, /missing_table/).exists?
     
-    assert browser.table(:index, 1).exists?
+    assert browser.table(:index, 0).exists?
     assert !browser.table(:index, 33).exists?
   end
   
@@ -38,15 +38,15 @@ class TC_Tables < Test::Unit::TestCase
     end
   end
   def test_rows
-    assert_equal(2, browser.table(:index, 1).row_count)
-    assert_equal(2, browser.table(:index, 1).rows.length)
+    assert_equal(2, browser.table(:index, 0).row_count)
+    assert_equal(2, browser.table(:index, 0).rows.length)
     
     assert_equal(5, browser.table(:id, 't1').row_count)  # 4 rows and a header 
-    assert_equal(5, browser.table(:index, 2).row_count)  # same table as above, just accessed by index 
+    assert_equal(5, browser.table(:index, 1).row_count)  # same table as above, just accessed by index 
     assert_equal(5, browser.table(:id, 't1').rows.length)   
     
     # test the each iterator on rows - ie, go through each cell
-    row = browser.table(:index, 2)[2]
+    row = browser.table(:index, 1)[1]
     result = []
     row.each do |cell|
       result << cell.to_s.strip
@@ -78,22 +78,22 @@ class TC_Tables < Test::Unit::TestCase
     assert_raises UnknownObjectException do
       browser.table(:index, 77).column_count
     end
-    assert_equal(2, browser.table(:index, 1).column_count)
+    assert_equal(2, browser.table(:index, 0).column_count)
     assert_equal(1, browser.table(:id, 't1').column_count)   # row one has 1 cell with a colspan of 2
   end
   
   def test_to_a
     expected = [ ["Row 1 Col1" , "Row 1 Col2"],
                  [ "Row 2 Col1" , "Row 2 Col2"] ]
-    assert_equal(expected, browser.table(:index , 1).to_a)
+    assert_equal(expected, browser.table(:index , 0).to_a)
   end
   
   def test_links_and_images_in_table
     table = browser.table(:id, 'pic_table')
-    image = table[1][2].image(:index,1)
+    image = table[0][1].image(:index,0)
     assert_equal("106", image.width)
     
-    link = table[1][4].link(:index,1)
+    link = table[0][3].link(:index,0)
     assert_equal("Google", link.innerText)
   end
   
@@ -104,7 +104,7 @@ class TC_Tables < Test::Unit::TestCase
   end
   
   def test_cell_another_way
-    assert_equal( "Row 1 Col1", browser.table(:index,1)[1][1].to_s.strip)
+    assert_equal( "Row 1 Col1", browser.table(:index,0)[0][0].to_s.strip)
   end
   
   def test_row_directly
@@ -112,7 +112,7 @@ class TC_Tables < Test::Unit::TestCase
     assert ! browser.row(:id, 'no_exist').exists?
   end
   def test_row_another_way
-    assert_equal('Row 2 Col1',  browser.row(:id, 'row1')[1].to_s.strip)
+    assert_equal('Row 2 Col1',  browser.row(:id, 'row1')[0].to_s.strip)
   end
 
   tag_method :test_row_in_table, :fails_on_firefox
@@ -122,45 +122,33 @@ class TC_Tables < Test::Unit::TestCase
   end
   
   def test_row_iterator
-    t = browser.table(:index, 1)
-    count = 1 
+    t = browser.table(:index, 0)
+    count = 1
     t.each do |row|
-      if count == 1
-        assert("Row 1 Col1", row[1].text)
-        assert("Row 1 Col2", row[2].text)
-      elsif count == 2
-        assert("Row 2 Col1", row[1].text)
-        assert("Row 2 Col2", row[2].text)
-      end
+      assert("Row #{count} Col1", row[0].text)
+      assert("Row #{count} Col2", row[1].text)
       count += 1
     end
   end
   
   def test_row_collection
-    t = browser.table(:index,1)
-    count = 1
-    t.rows.each do |row|
-      if count == 1
-        assert("Row 1 Col1", row[1].text)
-        assert("Row 1 Col2", row[2].text)
-      elsif count == 2
-        assert("Row 2 Col1", row[1].text)
-        assert("Row 2 Col2", row[2].text)
-      end
-      count += 1
+    t = browser.table(:index,0)
+    t.rows.each_with_index do |row, i|
+      assert("Row #{i + 1} Col1", row[0].text)
+      assert("Row #{i + 1} Col2", row[1].text)
     end
   end 
   
   tag_method :test_cell_collection, :fails_on_firefox
   def test_cell_collection
-    t = browser.table(:index,1)
+    t = browser.table(:index,0)
     contents = t.cells.collect {|c| c.text}
     assert_equal(["Row 1 Col1","Row 1 Col2","Row 2 Col1","Row 2 Col2"], contents)
   end    
    
   tag_method :test_table_body, :fails_on_firefox
   def test_table_body
-    assert_equal(1, browser.table(:index, 1).bodies.length)
+    assert_equal(1, browser.table(:index, 0).bodies.length)
     assert_equal(3, browser.table(:id, 'body_test').bodies.length)
     
     count = 1
@@ -174,20 +162,19 @@ class TC_Tables < Test::Unit::TestCase
       when 3 
         compare_text = "This text is in the THIRD TBODY."
       end
-      assert_equal(compare_text, n[1][1].to_s.strip )   # this is the 1st cell of the first row of this particular body
+      assert_equal(compare_text, n[0][0].to_s.strip )   # this is the 1st cell of the first row of this particular body
       count += 1
     end
     assert_equal( count - 1, browser.table(:id, 'body_test').bodies.length )
-    assert_equal( "This text is in the THIRD TBODY." ,browser.table(:id, 'body_test' ).body(:index,3)[1][1].to_s.strip ) 
+    assert_equal( "This text is in the THIRD TBODY." ,browser.table(:id, 'body_test' ).body(:index,2)[0][0].to_s.strip ) 
     
     # iterate through all the rows in a table body
     count = 1
-    browser.table(:id, 'body_test').body(:index, 2).each do | row |
-      # row.flash    # this line commented out, to speed up the tests
+    browser.table(:id, 'body_test').body(:index, 1).each do | row |
       if count == 1
-        assert_equal('This text is in the SECOND TBODY.', row[1].text.strip )
-      elsif count == 1 # BUG: Huh?
-        assert_equal('This text is also in the SECOND TBODY.', row[1].text.strip )
+        assert_equal('This text is in the SECOND TBODY.', row[0].text.strip )
+      elsif count == 2
+        assert_equal("This text is also in the SECOND TBODY.", row[0].text.strip )        
       end
       count+=1
     end
@@ -199,7 +186,7 @@ class TC_Tables < Test::Unit::TestCase
   
   def test_multiple_selector
     assert_equal('Second table with css class', 
-      browser.table(:class => 'sample', :index => 2)[1][1].text)
+      browser.table(:class => 'sample', :index => 1)[0][0].text)
   end
 end    
 
@@ -211,10 +198,10 @@ class TC_Tables_Simple < Test::Unit::TestCase
   end
   
   def test_simple_table_access
-    table = browser.table(:index,1)
-    assert_equal("Row 3 Col1", table[3][1].text.strip)
-    assert_equal("Row 1 Col1", table[1][1].text.strip)
-    assert_equal("Row 3 Col2", table[3][2].text.strip)
+    table = browser.table(:index,0)
+    assert_equal("Row 3 Col1", table[2][0].text.strip)
+    assert_equal("Row 1 Col1", table[0][0].text.strip)
+    assert_equal("Row 3 Col2", table[2][1].text.strip)
     assert_equal(2, table.column_count)
   end
 end
@@ -226,56 +213,56 @@ class TC_Tables_Buttons < Test::Unit::TestCase
   end
   
   def test_simple_table_buttons
-    table = browser.table(:index, 1)
+    table = browser.table(:index, 0)
     
-    table[1][1].button(:index, 1).click
+    table[0][0].button(:index, 0).click
     assert(browser.text_field(:name,"confirmtext").verify_contains(/CLICK1/i))
-    table[2][1].button(:index, 1).click
+    table[1][0].button(:index, 0).click
     assert(browser.text_field(:name,"confirmtext").verify_contains(/CLICK2/i))
     
-    table[1][1].button(:id, 'b1').click
+    table[0][0].button(:id, 'b1').click
     assert(browser.text_field(:name,"confirmtext").verify_contains(/CLICK1/i))
     
-    assert_raises(UnknownObjectException   ) { table[1][1].button(:id,'b_missing').click }
+    assert_raises(UnknownObjectException   ) { table[0][0].button(:id,'b_missing').click }
     
-    table[3][1].button(:index, 2).click
+    table[2][0].button(:index, 1).click
     assert(browser.text_field(:name,"confirmtext").verify_contains(/TOO/i))
     
-    table[3][1].button(:value, "Click too").click
+    table[2][0].button(:value, "Click too").click
     assert(browser.text_field(:name,"confirmtext").verify_contains(/TOO/i))
     
-    browser.table(:index, 1)[4][1].text_field(:index,1).set("123")
-    assert(browser.text_field(:index,2).verify_contains("123"))
+    browser.table(:index, 0)[3][0].text_field(:index,0).set("123")
+    assert(browser.text_field(:index,1).verify_contains("123"))
     
     # check when a cell contains 2 objects
     
     # if there were 2 different html objects in the same cell, some weird things happened ( button caption could change for example)
-    assert_equal( 'Click ->' , browser.table(:index,1)[5][1].text_field(:index,1).value )
-    browser.table(:index,1)[5][1].text_field(:index,1).click
-    assert_equal( 'Click ->' , browser.table(:index,1)[5][1].text_field(:index,1).value )
+    assert_equal( 'Click ->' , browser.table(:index,0)[4][0].text_field(:index,0).value )
+    browser.table(:index,0)[4][0].text_field(:index,0).click
+    assert_equal( 'Click ->' , browser.table(:index,0)[4][0].text_field(:index,0).value )
     
-    browser.table(:index,1)[5][1].button(:index,1).click
-    assert_equal( '' , browser.table(:index,1)[5][1].text_field(:index,1).value )
+    browser.table(:index,0)[4][0].button(:index,0).click
+    assert_equal( '' , browser.table(:index,0)[4][0].text_field(:index,0).value )
   end
   
   def test_simple_table_gif
-    table = browser.table(:index,2)
-    assert_match(/1\.gif/, table[1][1].image(:index, 1).src)
-    assert_match(/2\.gif/, table[1][2].image(:index, 1).src)
-    assert_match(/3\.gif/, table[1][3].image(:index, 1).src)
+    table = browser.table(:index,1)
+    assert_match(/1\.gif/, table[0][0].image(:index, 0).src)
+    assert_match(/2\.gif/, table[0][1].image(:index, 0).src)
+    assert_match(/3\.gif/, table[0][2].image(:index, 0).src)
     
-    assert_match(/1\.gif/, table[3][1].image(:index, 1).src)
-    assert_match(/2\.gif/, table[3][2].image(:index, 1).src)
-    assert_match(/3\.gif/, table[3][3].image(:index, 1).src)
+    assert_match(/1\.gif/, table[2][0].image(:index, 0).src)
+    assert_match(/2\.gif/, table[2][1].image(:index, 0).src)
+    assert_match(/3\.gif/, table[2][2].image(:index, 0).src)
     
-    table = browser.table(:index,3)
-    assert_match(/1\.gif/, table[1][1].image(:index, 1).src)
-    assert_match(/2\.gif/, table[1][1].image(:index, 2).src)
-    assert_match(/3\.gif/, table[1][1].image(:index, 3).src)
+    table = browser.table(:index,2)
+    assert_match(/1\.gif/, table[0][0].image(:index, 0).src)
+    assert_match(/2\.gif/, table[0][0].image(:index, 1).src)
+    assert_match(/3\.gif/, table[0][0].image(:index, 2).src)
     
-    assert_match(/1\.gif/, table[3][1].image(:index, 1).src)
-    assert_match(/2\.gif/, table[3][1].image(:index, 2).src)
-    assert_match(/3\.gif/, table[3][1].image(:index, 3).src)
+    assert_match(/1\.gif/, table[2][0].image(:index, 0).src)
+    assert_match(/2\.gif/, table[2][0].image(:index, 1).src)
+    assert_match(/3\.gif/, table[2][0].image(:index, 2).src)
   end
   
   def test_table_with_hidden_or_visible_rows
@@ -283,13 +270,13 @@ class TC_Tables_Buttons < Test::Unit::TestCase
     
     # expand the table
     t.each do |r|
-      r[1].image(:src, /plus/).click if r[1].image(:src, /plus/).exists?
+      r[0].image(:src, /plus/).click if r[0].image(:src, /plus/).exists?
     end
     
     # shrink rows 1,2,3
     count = 1
     t.each do |r|
-      r[1].image(:src, /minus/).click if r[1].image(:src, /minus/).exists? and (1..3) === count 
+      r[0].image(:src, /minus/).click if r[0].image(:src, /minus/).exists? and (1..3) === count 
       count = 2
     end
   end
@@ -299,7 +286,7 @@ class TC_Tables_Buttons < Test::Unit::TestCase
     button = browser.button(:id, "b1")
     table = Watir::Table.create_from_element(browser, button)
     
-    table[2][1].button(:index, 1).click
+    table[1][0].button(:index, 0).click
     assert(browser.text_field(:name, "confirmtext").verify_contains(/CLICK2/i))
   end
 end
@@ -311,37 +298,37 @@ class TC_Table_Columns < Test::Unit::TestCase
   end
   
   def test_get_columnvalues_single_column
-    assert_equal(["R1C1", "R2C1", "R3C1"], browser.table(:index, 1).column_values(1))
+    assert_equal(["R1C1", "R2C1", "R3C1"], browser.table(:index, 0).column_values(0))
   end
   
   def test_colspan
-    assert_equal(2, browser.table(:index, 3)[2][1].colspan)
-    assert_equal(1, browser.table(:index, 3)[1][1].colspan)
-    assert_equal(3, browser.table(:index, 3)[4][1].colspan)
+    assert_equal(2, browser.table(:index, 2)[1][0].colspan)
+    assert_equal(1, browser.table(:index, 2)[0][0].colspan)
+    assert_equal(3, browser.table(:index, 2)[3][0].colspan)
   end
   
   def test_get_columnvalues_multiple_column
-    assert_equal(["R1C1", "R2C1", "R3C1"], browser.table(:index, 2).column_values(1))
-    assert_equal(["R1C3", "R2C3", "R3C3"], browser.table(:index, 2).column_values(3))
+    assert_equal(["R1C1", "R2C1", "R3C1"], browser.table(:index, 1).column_values(0))
+    assert_equal(["R1C3", "R2C3", "R3C3"], browser.table(:index, 1).column_values(2))
   end
   
   tag_method :test_get_columnvalues_with_colspan, :fails_on_firefox
   def test_get_columnvalues_with_colspan
-    assert_equal(["R1C1", "R2C1", "R3C1", "R4C1", "R5C1", "R6C2"], browser.table(:index, 3).column_values(1))
-     (2..4).each{|x|assert_raises(UnknownCellException){browser.table(:index, 3).column_values(x)}}
+    assert_equal(["R1C1", "R2C1", "R3C1", "R4C1", "R5C1", "R6C2"], browser.table(:index, 2).column_values(0))
+     (1..3).each{|x|assert_raises(UnknownCellException){browser.table(:index, 2).column_values(x)}}
   end
   
   def test_get_rowvalues_full_row
-    assert_equal(["R1C1", "R1C2", "R1C3"], browser.table(:index, 3).row_values(1))
+    assert_equal(["R1C1", "R1C2", "R1C3"], browser.table(:index, 2).row_values(0))
   end
   
   def test_get_rowvalues_with_colspan
-    assert_equal(["R2C1", "R2C2"], browser.table(:index, 3).row_values(2))
+    assert_equal(["R2C1", "R2C2"], browser.table(:index, 2).row_values(1))
   end
   
   def test_getrowvalues_with_rowspan
-    assert_equal(["R5C1", "R5C2", "R5C3"], browser.table(:index, 3).row_values(5))
-    assert_equal(["R6C2", "R6C3"], browser.table(:index, 3).row_values(6))
+    assert_equal(["R5C1", "R5C2", "R5C3"], browser.table(:index, 2).row_values(4))
+    assert_equal(["R6C2", "R6C3"], browser.table(:index, 2).row_values(5))
   end
 end
 
@@ -351,16 +338,16 @@ class TC_Tables_Complex < Test::Unit::TestCase
   end
   
   def test_complex_table_access
-    table = browser.table(:index,1)
-    assert_equal("subtable1 Row 1 Col1",table[1][1].table(:index,1)[1][1].text.strip)
-    assert_equal("subtable1 Row 1 Col2",table[1][1].table(:index,1)[1][2].text.strip)
-    assert_equal("subtable2 Row 1 Col2",table[2][1].table(:index,1)[1][2].text.strip)
-    assert_equal("subtable2 Row 1 Col1",table[2][1].table(:index,1)[1][1].text.strip)
+    table = browser.table(:index,0)
+    assert_equal("subtable1 Row 1 Col1",table[0][0].table(:index,0)[0][0].text.strip)
+    assert_equal("subtable1 Row 1 Col2",table[0][0].table(:index,0)[0][1].text.strip)
+    assert_equal("subtable2 Row 1 Col2",table[1][0].table(:index,0)[0][1].text.strip)
+    assert_equal("subtable2 Row 1 Col1",table[1][0].table(:index,0)[0][0].text.strip)
   end
   
   def test_each_itterator
     # for WTR-324: keep Watir::Table.each from crashing when run on nested tables
-    table = browser.table(:index,1)
+    table = browser.table(:index,0)
     assert_equal(table.row_count, 4)
     assert_equal(table.row_count_excluding_nested_tables, 2)
     example_row_count = 0