firewatir 1.2.1 → 1.6.2

data/unittests/links_xpath_test.rb

@@ -1,79 +1,79 @@
 # feature tests for Links
 # revision: $Revision: 1.0 $
 
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') unless $SETUP_LOADED
 require 'unittests/setup'
 
 class TC_Links_XPath < Test::Unit::TestCase
-    include FireWatir
-
+    
     def setup()
-        $ff.goto($htmlRoot + "links1.html")
+        goto_page("links1.html")
     end
     
     def xtest_new_link_exists
-        assert(exists?{$ff.link(:xpath , "//a[contains(.,'test1')]")})
-        assert(exists?{$ff.link(:xpath, "//a[contains(., /TEST/i)]")})   
-        assert_false(exists?{$ff.link(:xpath , "//a[contains(.,'missing')]")})
-        assert_false(exists?{$ff.link(:xpath, "//a[contains(., /miss/)]")})   
+        assert(exists?{browser.link(:xpath , "//a[contains(.,'test1')]")})
+        assert(exists?{browser.link(:xpath, "//a[contains(., /TEST/i)]")})   
+        assert_false(exists?{browser.link(:xpath , "//a[contains(.,'missing')]")})
+        assert_false(exists?{browser.link(:xpath, "//a[contains(., /miss/)]")})   
     end
         
+    tag_method :test_element_by_xpath_class, :fails_on_ie
     def test_element_by_xpath_class
         # TODO: If element is not present this should return null
-        #element = $ff.element_by_xpath("//a[contains(., /miss/)]")
+        #element = browser.element_by_xpath("//a[contains(., /miss/)]")
         #assert(element.instance_of?(Link),"element class should be #{Link}; got #{element.class}")
-        #element = $ff.element_by_xpath("//a[contains(.,'missing')]")
+        #element = browser.element_by_xpath("//a[contains(.,'missing')]")
         #assert(element.instance_of?(Link),"element class should be #{Link}; got #{element.class}")
-        element = $ff.element_by_xpath("//a[contains(., /TEST/i)]")
-        assert(element.instance_of?(Link),"element class should be #{Link}; got #{element.class}")
-        element = $ff.element_by_xpath("//a[contains(.,'test1')]")
-        assert(element.instance_of?(Link),"element class should be #{Link}; got #{element.class}")
+        element = browser.element_by_xpath("//a[contains(., /TEST/i)]")
+        assert_class(element, 'Link')
+        element = browser.element_by_xpath("//a[contains(.,'test1')]")
+        assert_class(element, 'Link')
     end
 
     def test_element_by_xpath_behavior
       # TODO implement this, acquiring objects through element_by_xpath and 
       # then testing their properties to see if they behave normally, as if 
-      # they had been created with $ff.link
+      # they had been created with browser.link
     end
     
     def test_Link_Exists
-       assert($ff.link(:xpath , "//a[contains(.,'test1')]").exists?)
-       assert($ff.link(:xpath, "//a[contains(., /TEST/i)]").exists?)   
-       assert_false($ff.link(:xpath , "//a[contains(.,'missing')]").exists?)
+       assert(browser.link(:xpath , "//a[contains(.,'test1')]").exists?)
+       assert(browser.link(:xpath, "//a[contains(., /TEST/i)]").exists?)   
+       assert_false(browser.link(:xpath , "//a[contains(.,'missing')]").exists?)
 
-       assert_false($ff.link(:xpath , "//a[@url='alsomissing.html']").exists?)
+       assert_false(browser.link(:xpath , "//a[@url='alsomissing.html']").exists?)
 
-       assert($ff.link(:xpath , "//a[@id='link_id']").exists?)
-       assert_false($ff.link(:xpath , "//a[@id='alsomissing']").exists?)
+       assert(browser.link(:xpath , "//a[@id='link_id']").exists?)
+       assert_false(browser.link(:xpath , "//a[@id='alsomissing']").exists?)
 
-       assert($ff.link(:xpath , "//a[@name='link_name']").exists?)
-       assert_false($ff.link(:xpath , "//a[@name='alsomissing']").exists?)
-       assert($ff.link(:xpath , "//a[@title='link_title']").exists?)
+       assert(browser.link(:xpath , "//a[@name='link_name']").exists?)
+       assert_false(browser.link(:xpath , "//a[@name='alsomissing']").exists?)
+       assert(browser.link(:xpath , "//a[@title='link_title']").exists?)
 
     end
 
     def test_Link_click
-        $ff.link(:xpath , "//a[contains(.,'test1')]").click
-        assert( $ff.text.include?("Links2-Pass") )
+        browser.link(:xpath , "//a[contains(.,'test1')]").click
+        assert( browser.text.include?("Links2-Pass") )
     end
     
     def test_link_properties
             
-        assert_match( /links2/ ,$ff.link(:xpath , "//a[contains(.,'test1')]").href )
-        assert_equal( ""      , $ff.link(:xpath , "//a[contains(.,'test1')]").value)
-        assert_equal( "test1" , $ff.link(:xpath , "//a[contains(.,'test1')]").text )
-        assert_equal( ""      , $ff.link(:xpath , "//a[contains(.,'test1')]").name )
-        assert_equal( ""      , $ff.link(:xpath , "//a[contains(.,'test1')]").id )
-        #assert_equal( false   , $ff.link(:xpath , "//a[contains(.,'test1')]").disabled )  
-        assert_equal( ""      , $ff.link(:xpath , "//a[contains(.,'test1')]").class_name)
-        assert_equal( "link_class_1"      , $ff.link(:xpath , "//a[@class='link_class_1']").class_name)
+        assert_match( /links2/ ,browser.link(:xpath , "//a[contains(.,'test1')]").href )
+        assert_equal( ""      , browser.link(:xpath , "//a[contains(.,'test1')]").value)
+        assert_equal( "test1" , browser.link(:xpath , "//a[contains(.,'test1')]").text )
+        assert_equal( ""      , browser.link(:xpath , "//a[contains(.,'test1')]").name )
+        assert_equal( ""      , browser.link(:xpath , "//a[contains(.,'test1')]").id )
+        assert_equal( false   , browser.link(:xpath , "//a[contains(.,'test1')]").disabled )  
+        assert_equal( ""      , browser.link(:xpath , "//a[contains(.,'test1')]").class_name)
+        assert_equal( "link_class_1"      , browser.link(:xpath , "//a[@class='link_class_1']").class_name)
         
-        assert_equal( "link_id"   , $ff.link(:xpath , "//a[@id='link_id']").id )
-        assert_equal( "link_name" , $ff.link(:xpath , "//a[@name='link_name']").name )
+        assert_equal( "link_id"   , browser.link(:xpath , "//a[@id='link_id']").id )
+        assert_equal( "link_name" , browser.link(:xpath , "//a[@name='link_name']").name )
         
-        assert_equal( "" , $ff.link(:xpath , "//a[@name='link_name']").title)
+        assert_equal( "" , browser.link(:xpath , "//a[@name='link_name']").title)
         
-        assert_equal( "link_title" , $ff.link(:xpath , "//a[@title='link_title']").title)
+        assert_equal( "link_title" , browser.link(:xpath , "//a[@title='link_title']").title)
     end 
 end
 

data/unittests/mozilla_all_tests.rb

@@ -1,19 +1,7 @@
-# these are the tests that run reliably and invisibly
-
 TOPDIR = File.expand_path(File.join(File.dirname(__FILE__), '..'))
 $LOAD_PATH.unshift TOPDIR
-
-puts $LOAD_PATH
-require 'unittests/setup.rb'
+require 'unittests/setup'
 
 Dir.chdir TOPDIR
+$all_tests.each {|x| require x }
 
-#tests = ["unittests/test.rb",
-#        "unittests/test_xpath.rb"
-#       ]
-
-#tests.each { |x| require x }
-$core_tests.each {|x| require x }
-
-#$HIDE_IE = true
-#$ff.visible = false

data/unittests/pre_test.rb

@@ -1,63 +1,65 @@
 # feature tests for Pre
 # revision: $Revision: 1.0 $
 
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') unless $SETUP_LOADED
 require 'unittests/setup'
 
 class TC_Pre < Test::Unit::TestCase
-  include FireWatir
+  
   
   def setup
-    $ff.goto($htmlRoot + "pre.html")
+    goto_page("pre.html")
   end
   
   def test_Pre_Count
-    assert( $ff.pres.length == 3 )
+    assert( browser.pres.length == 3 )
   end
   
   def test_Pre_Exists
-    assert(! $ff.pre( :id, 'missingPre' ).exists? )
-    assert(! $ff.pre( :index, 33 ).exists? )
+    assert_false( browser.pre( :id, 'missingPre' ).exists? )
+    assert_false( browser.pre( :index, 33 ).exists? )
     
-    assert( $ff.pre( :id, '1' ).exists? )
-    assert( $ff.pre( :id, /[3-9]/ ).exists? )
+    assert( browser.pre( :id, '1' ).exists? )
+    assert( browser.pre( :id, /[3-9]/ ).exists? )
     
-    assert(! $ff.pre( :id, /missing_pre/ ).exists? )
+    assert_false( browser.pre( :id, /missing_pre/ ).exists? )
     
-    assert( $ff.pre( :index, 1 ).exists? )
-    assert( $ff.pre( :index, 2 ).exists? )
-    assert( $ff.pre( :index, 3 ).exists? )
+    assert( browser.pre( :index, 1 ).exists? )
+    assert( browser.pre( :index, 2 ).exists? )
+    assert( browser.pre( :index, 3 ).exists? )
     
-    assert( $ff.pre( :name, '3' ).exists? )
-    assert(! $ff.pre( :name, "name_missing" ).exists? )
+    assert( browser.pre( :name, '3' ).exists? )
+    assert_false( browser.pre( :name, "name_missing" ).exists? )
   end
   
   def test_simple_access
-    pre = $ff.pre( :index, 1 )
+    pre = browser.pre( :index, 1 )
     assert( pre.text.include?( "simple pre space" ) )
-    assert(! pre.text.include?( "A second block" ) )
+    assert_false( pre.text.include?( "A second block" ) )
     
-    pre = $ff.pre( :index, 2 )
+    pre = browser.pre( :index, 2 )
     assert( pre.text.include?( "A second block" ) )
-    assert(! pre.text.include?( "this is the last block" ) )
-    
-    pre = $ff.pre( :index, 3 )
+    assert_false( pre.text.include?( "this is the last block" ) )
+  end
+
+  tag_method :test_embedded_spaces, :fails_on_firefox # http://jira.openqa.org/browse/WTR-267
+  def test_embedded_spaces
+    pre = browser.pre( :index, 3 )
     assert( pre.text.include?( "continue    to work" ) )
-    assert(! pre.text.include?( "Pre Tag Test" ) )
-    
+    assert_false( pre.text.include?( "Pre Tag Test" ) )
   end
   
 end
 
 
 class TC_Pres_Display < Test::Unit::TestCase
-  include FireWatir
   include MockStdoutTestCase
 
+  tag_method :test_showPres, :fails_on_ie
   def test_showPres
-    $ff.goto($htmlRoot + "pre.html")
+    goto_page("pre.html")
     $stdout = @mockout
-    $ff.showPres
+    browser.showPres
     assert_equal(<<END_OF_MESSAGE, @mockout)
 There are 3 pres
 pre:     id: 1

data/unittests/radios_test.rb

@@ -1,164 +1,164 @@
 # feature tests for Radio Buttons
 # revision: $Revision: 1.0 $
 
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') unless $SETUP_LOADED
 require 'unittests/setup'
 
 class TC_Radios < Test::Unit::TestCase
-    include FireWatir
+    
 
     def setup()
-        $ff.goto($htmlRoot + "radioButtons1.html")
+        goto_page("radioButtons1.html")
     end
     
     def test_Radio_Exists
-       assert($ff.radio(:name, "box1").exists?)   
-       assert($ff.radio(:id, "box5").exists?)   
+       assert(browser.radio(:name, "box1").exists?)   
+       assert(browser.radio(:id, "box5").exists?)   
 
-       assert_false($ff.radio(:name, "missingname").exists?)   
-       assert_false($ff.radio(:id, "missingid").exists?)   
+       assert_false(browser.radio(:name, "missingname").exists?)   
+       assert_false(browser.radio(:id, "missingid").exists?)   
     end
 
     def test_radio_class
-       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.radio(:name, "noName").class_name }  
-       assert_equal("radio_style" , $ff.radio(:name, "box1").class_name)   
-       assert_equal("" , $ff.radio(:id, "box5").class_name)   
+       assert_raises(UnknownObjectException) {   browser.radio(:name, "noName").class_name }  
+       assert_equal("radio_style" , browser.radio(:name, "box1").class_name)   
+       assert_equal("" , browser.radio(:id, "box5").class_name)   
     end
 
     def test_Radio_Enabled
-       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.radio(:name, "noName").enabled?  }  
-       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.radio(:id, "noName").enabled?  }  
-       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.radio(:name, "box4" , 6).enabled?  }  
+       assert_raises(UnknownObjectException) {   browser.radio(:name, "noName").enabled?  }  
+       assert_raises(UnknownObjectException) {   browser.radio(:id, "noName").enabled?  }  
+       assert_raises(UnknownObjectException) {   browser.radio(:name, "box4" , 6).enabled?  }  
 
-       assert_false($ff.radio(:name, "box2").enabled?)   
-       assert($ff.radio(:id, "box5").enabled?)   
-       assert($ff.radio(:name, "box1").enabled?)   
+       assert_false(browser.radio(:name, "box2").enabled?)   
+       assert(browser.radio(:id, "box5").enabled?)   
+       assert(browser.radio(:name, "box1").enabled?)   
     end
 
    def test_little
-       assert_false($ff.button(:value , "foo").enabled?)
+       assert_false(browser.button(:value , "foo").enabled?)
    end
 
    def test_onClick
 
-       assert_false($ff.radio(:name, "box5").isSet?)
-       assert_false($ff.button(:value , "foo").enabled?)
+       assert_false(browser.radio(:name, "box5").isSet?)
+       assert_false(browser.button(:value , "foo").enabled?)
 
        # first click the button is enabled and the radio is set
-       $ff.radio(:name, "box5" , 1).click
-       assert($ff.radio(:name, "box5",1).isSet?)
-       #assert($ff.button(:value , "foo").enabled?)
+       browser.radio(:name, "box5" , 1).click
+       assert(browser.radio(:name, "box5",1).isSet?)
+       #assert(browser.button(:value , "foo").enabled?)
 
        # second click the button is disabled and the radio is still set
-       $ff.radio(:name, "box5", 1).click
-       assert($ff.radio(:name, "box5",1).isSet?)
-       assert_false($ff.button(:value , "foo").enabled?)
+       browser.radio(:name, "box5", 1).click
+       assert(browser.radio(:name, "box5",1).isSet?)
+       assert_false(browser.button(:value , "foo").enabled?)
 
        # third click the button is enabled and the radio is still set
-       $ff.radio(:name, "box5", 1).click
-       assert($ff.radio(:name, "box5",1 ).isSet?)
-       assert($ff.button(:value , "foo").enabled?)
+       browser.radio(:name, "box5", 1).click
+       assert(browser.radio(:name, "box5",1 ).isSet?)
+       assert(browser.button(:value , "foo").enabled?)
 
        # click the radio with a value of 2 , button is disabled and the radio is still set
-       $ff.radio(:name, "box5", 2).click
-       assert_false($ff.radio(:name, "box5" ,1).isSet?)
-       assert($ff.radio(:name, "box5" ,2).isSet?)
-       assert_false($ff.button(:value , "foo").enabled?)
+       browser.radio(:name, "box5", 2).click
+       assert_false(browser.radio(:name, "box5" ,1).isSet?)
+       assert(browser.radio(:name, "box5" ,2).isSet?)
+       assert_false(browser.button(:value , "foo").enabled?)
     end
 
     def test_Radio_isSet
-       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.radio(:name, "noName").isSet?  }  
+       assert_raises(UnknownObjectException) {   browser.radio(:name, "noName").isSet?  }  
 
-       assert_false($ff.radio(:name, "box1").isSet?)   
-       assert( $ff.radio(:name, "box3").isSet?)   
-       assert_false($ff.radio(:name, "box2").isSet?)   
-       assert( $ff.radio(:name, "box4" , 1 ).isSet?)   
-       assert_false($ff.radio(:name, "box4" , 2 ).isSet?)   
+       assert_false(browser.radio(:name, "box1").isSet?)   
+       assert( browser.radio(:name, "box3").isSet?)   
+       assert_false(browser.radio(:name, "box2").isSet?)   
+       assert( browser.radio(:name, "box4" , 1 ).isSet?)   
+       assert_false(browser.radio(:name, "box4" , 2 ).isSet?)   
     end
 
     def test_radio_clear
-       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.radio(:name, "noName").clear  }  
+       assert_raises(UnknownObjectException) {   browser.radio(:name, "noName").clear  }  
 
-       $ff.radio(:name, "box1").clear
-       assert_false($ff.radio(:name, "box1").isSet?)   
+       browser.radio(:name, "box1").clear
+       assert_false(browser.radio(:name, "box1").isSet?)   
 
-       assert_raises(ObjectDisabledException, "ObjectDisabledException was supposed to be thrown" ) {   $ff.radio(:name, "box2").clear  } 
-       assert_false($ff.radio(:name, "box2").isSet?)   
+       assert_raises(ObjectDisabledException, "ObjectDisabledException was supposed to be thrown" ) {   browser.radio(:name, "box2").clear  } 
+       assert_false(browser.radio(:name, "box2").isSet?)   
 
-       $ff.radio(:name, "box3").clear
-       assert_false($ff.radio(:name, "box3").isSet?)   
+       browser.radio(:name, "box3").clear
+       assert_false(browser.radio(:name, "box3").isSet?)   
 
-       $ff.radio(:name, "box4" , 1).clear
-       assert_false($ff.radio(:name, "box4" , 1).isSet?)   
+       browser.radio(:name, "box4" , 1).clear
+       assert_false(browser.radio(:name, "box4" , 1).isSet?)   
     end
 
     def test_radio_getState
-       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.radio(:name, "noName").getState  }  
+       assert_raises(UnknownObjectException) {   browser.radio(:name, "noName").getState  }  
 
-       assert_equal( false , $ff.radio(:name, "box1").getState )   
-       assert_equal( true , $ff.radio(:name, "box3").getState)   
+       assert_equal( false , browser.radio(:name, "box1").getState )   
+       assert_equal( true , browser.radio(:name, "box3").getState)   
 
        # radioes that have the same name but different values
-       assert_equal( false , $ff.radio(:name, "box4" , 2).getState )   
-       assert_equal( true , $ff.radio(:name, "box4" , 1).getState)   
+       assert_equal( false , browser.radio(:name, "box4" , 2).getState )   
+       assert_equal( true , browser.radio(:name, "box4" , 1).getState)   
     end
 
     def test_radio_set
-       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.radio(:name, "noName").set  }  
-       $ff.radio(:name, "box1").set
-       assert($ff.radio(:name, "box1").isSet?)   
+       assert_raises(UnknownObjectException) {   browser.radio(:name, "noName").set  }  
+       browser.radio(:name, "box1").set
+       assert(browser.radio(:name, "box1").isSet?)   
 
-       assert_raises(ObjectDisabledException, "ObjectDisabledException was supposed to be thrown" ) {   $ff.radio(:name, "box2").set  }  
+       assert_raises(ObjectDisabledException, "ObjectDisabledException was supposed to be thrown" ) {   browser.radio(:name, "box2").set  }  
 
-       $ff.radio(:name, "box3").set
-       assert($ff.radio(:name, "box3").isSet?)   
+       browser.radio(:name, "box3").set
+       assert(browser.radio(:name, "box3").isSet?)   
 
        # radioes that have the same name but different values
-       $ff.radio(:name, "box4" , 3).set
-       assert($ff.radio(:name, "box4" , 3).isSet?)   
+       browser.radio(:name, "box4" , 3).set
+       assert(browser.radio(:name, "box4" , 3).isSet?)   
     end
 
     def test_radio_properties
 
-        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   $ff.radio(:index, 199).value}  
-        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   $ff.radio(:index, 199).name }  
-        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   $ff.radio(:index, 199).id }  
-        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   $ff.radio(:index, 199).disabled }  
-        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   $ff.radio(:index, 199).type }  
+        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   browser.radio(:index, 199).value}  
+        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   browser.radio(:index, 199).name }  
+        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   browser.radio(:index, 199).id }  
+        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   browser.radio(:index, 199).disabled }  
+        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   browser.radio(:index, 199).type }  
 
-        assert_equal("on"   ,    $ff.radio(:index, 1).value)  
-        assert_equal("box1" ,    $ff.radio(:index, 1).name )  
-        assert_equal(""     ,    $ff.radio(:index, 1).id )  
-        assert_equal("radio",    $ff.radio(:index, 1).type )  
+        assert_equal("on"   ,    browser.radio(:index, 1).value)  
+        assert_equal("box1" ,    browser.radio(:index, 1).name )  
+        assert_equal(""     ,    browser.radio(:index, 1).id )  
+        assert_equal("radio",    browser.radio(:index, 1).type )  
 
-        assert_equal( false, $ff.radio(:index, 1).disabled )
-        assert_equal( true,  $ff.radio(:index, 3).disabled )
+        assert_equal( false, browser.radio(:index, 1).disabled )
+        assert_equal( true,  browser.radio(:index, 3).disabled )
 
-        assert_equal("box5"  ,    $ff.radio(:index, 2).id )  
-        assert_equal(""      ,    $ff.radio(:index, 2).name )  
+        assert_equal("box5"  ,    browser.radio(:index, 2).id )  
+        assert_equal(""      ,    browser.radio(:index, 2).name )  
 
-        assert_equal("box4-value5", $ff.radio(:name , "box4" , 5 ).title  )
-        assert_equal("", $ff.radio(:name , "box4" , 4 ).title  )
+        assert_equal("box4-value5", browser.radio(:name , "box4" , 5 ).title  )
+        assert_equal("", browser.radio(:name , "box4" , 4 ).title  )
 
 
     end
 
     def test_radio_iterators
         
-        assert_equal(11, $ff.radios.length)
-        assert_equal("box5" , $ff.radios[2].id )
-        assert_equal(true ,  $ff.radios[3].disabled )
-        assert_equal(false ,  $ff.radios[1].disabled )
+        assert_equal(11, browser.radios.length)
+        assert_equal("box5" , browser.radios[2].id )
+        assert_equal(true ,  browser.radios[3].disabled )
+        assert_equal(false ,  browser.radios[1].disabled )
         index = 1
-        $ff.radios.each do |r|
-            assert_equal( $ff.radio(:index, index).name , r.name )
-            assert_equal( $ff.radio(:index, index).id , r.id )
-            assert_equal( $ff.radio(:index, index).value, r.value)
-            assert_equal( $ff.radio(:index, index).disabled , r.disabled )
-            assert_equal( $ff.radio(:index, index).isSet? , r.isSet? )
+        browser.radios.each do |r|
+            assert_equal( browser.radio(:index, index).name , r.name )
+            assert_equal( browser.radio(:index, index).id , r.id )
+            assert_equal( browser.radio(:index, index).value, r.value)
+            assert_equal( browser.radio(:index, index).disabled , r.disabled )
+            assert_equal( browser.radio(:index, index).isSet? , r.isSet? )
             index+=1
         end
-        assert_equal(index -1, $ff.radios.length)
+        assert_equal(index -1, browser.radios.length)
     end