firewatir 1.1.1

data/unittests/attach_to_new_window_test.rb

@@ -0,0 +1,34 @@
+# feature tests for attaching to new Firefox windows
+# revision: $Revision: 1.0 $
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
+require 'unittests/setup'
+
+class TC_NewWindow < Test::Unit::TestCase
+    include FireWatir
+
+    def setup
+      $ff.goto($htmlRoot + "new_browser.html")
+    end
+
+    def test_simply_attach_to_new_window_using_title
+        $ff.link(:text, 'New Window').click
+        ff_new = $ff.attach(:title, 'Pass Page')
+        assert(ff_new.text.include?('PASS'))
+        ff_new.close
+        #$ff.link(:text, 'New Window').click
+    end
+    
+    def test_simply_attach_to_new_window_using_url
+        $ff.link(:text, 'New Window').click
+        ff_new = $ff.attach(:url, /pass\.html/)
+        assert(ff_new.text.include?('PASS'))
+        ff_new.close
+        #$ff.link(:text, 'New Window').click
+    end
+
+    def test_new_window_exists
+        assert_raises(NoMatchingWindowFoundException , "NoMatchingWindowFoundException was supposed to be thrown" ) {   $ff.attach(:title, "missing_title")   }  
+        assert_raises(NoMatchingWindowFoundException , "NoMatchingWindowFoundException was supposed to be thrown" ) {   $ff.attach(:url, "missing_url")   }  
+    end
+end

data/unittests/bug_fixes_test.rb

@@ -0,0 +1,188 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
+require 'unittests/setup'
+
+class TC_Bugs< Test::Unit::TestCase
+  include FireWatir
+  
+    def setup
+        $ff.goto($htmlRoot + "frame_buttons.html")
+    end
+  
+    def test_frame_objects_bug3
+        frame = $ff.frame("buttonFrame")
+        button = frame.button(:name, "b1")
+        assert_equal("buttonFrame", frame.name)
+        assert_equal("b2", button.id)
+        text1 = frame.text_field(:id, "text_id")
+        text1.set("NewValue")
+        assert("NewValue",frame.text_field(:id, "text_id").value)
+    end
+        
+    def test_link_object_bug9
+        $ff.goto($htmlRoot + "links1.html")
+        link =  $ff.link(:text, "nameDelet")
+        assert_equal("test_link", link.name)
+    end
+
+
+    # element_by_xpath should return an element that's instance of the
+    # appropriate class, not the generic Element class. So if it's a div,
+    # it should return an instance of Div, if it's a checkbox, CheckBox,
+    # and so on. TODO write tests for all classes
+    def test_element_by_xpath_bug01
+      $ff.goto($htmlRoot + "div.html")
+      element = $ff.element_by_xpath("//div[@id='div1']")
+      assert_not_nil(element) # helder
+      # next assert always breaks, dunno why (error, not failure)
+      #assert_instance_of(Div, element, "wrong constructor was used")
+      # using this hack instead
+      assert(element.instance_of?(Div),
+               "element class should be: #{Div}; got: #{element.class}.")
+    end
+    
+    def test_elements_by_xpath_bug10
+        $ff.goto($htmlRoot + "links1.html")
+        elements = $ff.elements_by_xpath("//a")
+        assert_equal(11, elements.length)
+        assert_equal("links2.html", elements[0].href)
+        assert_equal("link_class_1", elements[1].className)
+        assert_equal("link_id", elements[5].id)
+        assert_equal("Link Using an ID", elements[5].text)
+    end
+
+    def test_button_by_value_bug8
+        $ff.goto($htmlRoot + "buttons1.html")
+        assert_equal("Sign In", $ff.button(:value,"Sign In").value)
+    end
+       
+    def test_html_bug7
+        $ff.goto($htmlRoot + "links1.html")
+        html = $ff.html
+        assert_match(/.*<a id="linktos" *>*/,html)
+    end
+
+    def test_span_onclick_bug14
+        $ff.goto($htmlRoot + "div.html")
+        $ff.span(:id, "span1").fireEvent("onclick")
+        assert($ff.text.include?("PASS") )
+    end
+
+    def test_file_field_value_bug20
+        actual_file_name = "c:\\Program Files\\TestFile.html"
+        $ff.goto($htmlRoot + "fileupload.html")
+        $ff.file_field(:name, "file3").set(actual_file_name)
+        set_file_name = $ff.file_field(:name, "file3").value
+        # make sure correct value for upload file is posted.
+        assert(actual_file_name, set_file_name)
+    end    
+
+    def test_attribute_value_bug22
+        $ff.goto($htmlRoot + "div.html")
+        assert("Test1", $ff.element_by_xpath("//div[@id='div1']").attribute_value("title"))
+    end
+    
+    def test_url_value_bug23
+        $ff.goto($htmlRoot + "buttons1.html")
+        $ff.button(:id, "b2").click
+        assert($htmlRoot + "pass.html", $ff.url)
+    end
+
+    def test_contains_text_bug28
+        $ff.goto($htmlRoot + "buttons1.html")
+        $ff.button(:id, "b2").click
+        assert_false($ff.contains_text("passed"))
+        assert($ff.contains_text("PASS"))
+        assert($ff.contains_text("PAS"))
+        assert($ff.contains_text(/PAS/))
+        assert($ff.contains_text(/pass/i))
+        assert_false($ff.contains_text(/pass/))
+    end
+
+    def test_frame_bug_21
+        $ff.goto($htmlRoot + "frame_buttons.html")
+        frame1 = $ff.frame(:name, "buttonFrame")
+        frame2 = $ff.frame(:name, "buttonFrame2")
+        assert_equal("buttons1.html", frame1.src)
+        assert_equal("blankpage.html", frame2.src)
+    end
+    
+    def test_quotes_bug_11
+        $ff.goto($htmlRoot + "textfields1.html")
+        $ff.text_field(:name, "text1").set("value with quote (\")")
+        assert_equal("value with quote (\")", $ff.text_field(:name, "text1").value)
+        $ff.text_field(:name, "text1").set("value with backslash (\\)")
+        assert_equal("value with backslash (\\)", $ff.text_field(:name, "text1").value)
+    end
+
+    def test_close_bug_26
+        if ! (RUBY_PLATFORM =~ /darwin/i)
+            $ff.close()
+            $ff = Firefox.new
+        end    
+    end
+
+    def test_class_bug_29
+        $ff.goto($htmlRoot + "div.html")
+        div = $ff.div(:class, "blueText")
+        assert_equal("div2", div.id)
+    end
+
+    def test_element_using_any_attribute
+        $ff.goto($htmlRoot + "div.html")
+        div = $ff.div(:title, "Test1")
+        assert_equal("div1", div.id)
+    end
+    
+    def test_element_using_any_attribute2
+        $ff.goto($htmlRoot + "div.html")
+        div = $ff.div(:attribute, "attribute")
+        assert_equal("div1", div.id)
+    end
+
+    def test_file_field_bug_20
+        $ff.goto($htmlRoot + "fileupload.html")
+        # Enter dummy path.
+        if(RUBY_PLATFORM =~ /.*mswin.*/)
+            $ff.file_field(:name, "file3").set("c:\\results.txt")
+        else    
+            $ff.file_field(:name, "file3").set("/user/lib/results.txt")
+        end    
+        $ff.button(:name, "upload").click()
+        url = $ff.url
+        assert_match(/.*results.txt&upload=upload$/,url)
+    end
+    
+    def test_button_bug2
+        $ff.goto($htmlRoot + "buttons1.html")
+        btn = $ff.button(:id, "b7")
+        assert_equal("b7", btn.id)
+    end
+    
+    def test_getAllContents_bug25
+        $ff.goto($htmlRoot + "select_tealeaf.html")
+        $ff.select_lists.each do |select|
+            contents =  select.getAllContents().to_s
+            puts contents
+            assert_equal("=<>>=<=", contents)
+            break
+        end
+    end
+
+    def test_fire_event_bug31
+        $ff.goto($htmlRoot + "div.html")
+        div = $ff.div(:attribute, "attribute")
+        div.fire_event("ondblclick")
+        assert("PASS", $ff.text)
+        $ff.goto($htmlRoot + "div.html")
+        div = $ff.div(:id, "div1")
+        div.fireEvent("ondblclick")
+        assert("PASS", $ff.text)
+    end
+
+    def test_contains_text_bug37
+        $ff.goto($htmlRoot + "frame_buttons.html")
+        frame = $ff.frame(:name, "buttonFrame")
+        assert(frame.contains_text("second button"))
+        assert_false(frame.contains_text("second button second"))
+    end
+end 

data/unittests/buttons_test.rb

@@ -0,0 +1,215 @@
+# feature tests for Buttons of type <input type = "button">
+# revision: $Revision: 1.0 $
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
+require 'unittests/setup'
+
+class TC_Buttons < Test::Unit::TestCase
+    include FireWatir
+    
+    def setup
+        $ff.goto($htmlRoot + "buttons1.html")
+    end
+    
+    def goto_frames_page()
+        $ff.goto($htmlRoot + "frame_buttons.html")
+    end
+    
+    #def test_Spinner
+    #   s = Spinner.new
+    #   i = 0
+    #   while(i < 100)
+    #       sleep 0.05
+    #       print s.next
+    #        i+=1
+    #    end
+    #    s = nil
+    #end
+    
+    def test_Button_to_s
+        # i think the tests for to_s should be dropped. The output is not in a nice format to be tested, and the
+        # individual properties are tested in the test_properties method
+        
+        b4 = ['name:         b4',
+        'type:         button',
+        'id:           b5',
+        'value:        Disabled Button',
+        'disabled:     true']
+        b1 = ['name:         b1',
+        'type:         button',
+        'id:           b2',
+        'value:        Click Me',
+        'disabled:     false']
+        
+        assert_equal(b4, $ff.button(:name, "b4").to_s)
+        assert_equal(b1, $ff.button(:caption, "Click Me").to_s)
+        assert_equal(b1, $ff.button(:index, 1).to_s)
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:name, "noName").to_s   }  
+    end
+   
+    def test_properties
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:name, "noName").id   }  
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:name, "noName").name   }  
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:name, "noName").disabled   }  
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:name, "noName").type   }  
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:name, "noName").value   }  
+        
+        assert_equal("b1"  , $ff.button(:index, 1).name ) 
+        assert_equal("b2"  , $ff.button(:index, 1).id ) 
+        assert_equal("button"  , $ff.button(:index, 1).type  ) 
+        assert_equal("Click Me"  , $ff.button(:index, 1).value  ) 
+        assert_equal(false  , $ff.button(:index, 1).disabled  ) 
+        assert_equal("italic_button"  , $ff.button(:name, "b1").class_name  ) 
+        assert_equal(""  , $ff.button(:name , "b4").class_name  ) 
+
+        
+        assert_equal("b1"  , $ff.button(:id, "b2").name  ) 
+        assert_equal("b2"  , $ff.button(:id, "b2").id  ) 
+        assert_equal("button"  , $ff.button(:id, "b2").type  ) 
+        
+        assert_equal("b4"  , $ff.button(:index, 2).name  ) 
+        assert_equal("b5"  , $ff.button(:index, 2).id  ) 
+        assert_equal("button"  , $ff.button(:index, 2).type  ) 
+        assert_equal("Disabled Button"  , $ff.button(:index, 2).value  ) 
+        assert_equal(true  , $ff.button(:index, 2).disabled  ) 
+        
+        assert_equal( "" , $ff.button(:index, 2).title )
+        assert_equal( "this is button1" , $ff.button(:index, 1).title )
+    end
+    
+    
+    def test_button_using_default
+        # since most of the time, a button will be accessed based on its caption, there is a default way of accessing it....
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button( "Missing Caption").click   }  
+        
+        $ff.button("Click Me").click
+        assert($ff.text.include?("PASS") )
+    end
+    
+    def test_Button_click_only
+        $ff.button(:caption, "Click Me").click
+        assert($ff.text.include?("PASS") )
+    end
+    
+    def test_button_click
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:caption, "Missing Caption").click   }  
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:id, "missingID").click   }  
+        
+        assert_raises(ObjectDisabledException , "ObjectDisabledException was supposed to be thrown" ) {   $ff.button(:caption, "Disabled Button").click   }  
+        
+        $ff.button(:caption, "Click Me").click
+        assert($ff.text.include?("PASS") )
+    end
+    
+    def test_Button_Exists
+        assert($ff.button(:caption, "Click Me").exists?)   
+        assert($ff.button(:caption, "Submit").exists?)   
+        assert($ff.button(:name, "b1").exists?)   
+        assert($ff.button(:id, "b2").exists?)   
+        assert($ff.button(:caption, /sub/i).exists?)   
+        
+        assert_false($ff.button(:caption, "missingcaption").exists?)   
+        assert_false($ff.button(:name, "missingname").exists?)   
+        assert_false($ff.button(:id, "missingid").exists?)   
+        assert_false($ff.button(:caption, /missing/i).exists?)   
+    end
+    
+    def test_Button_Enabled
+        assert($ff.button(:caption, "Click Me").enabled?)   
+        assert_false($ff.button(:caption, "Disabled Button").enabled?)   
+        assert_false($ff.button(:name, "b4").enabled?)   
+        assert_false($ff.button(:id, "b5").enabled?)   
+        
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:name, "noName").enabled?  }  
+     end
+
+     def test_button2
+        assert($ff.button(:caption, "Click Me2").exists?, 'Can\'t find Button with caption "Click Me2"')   
+       
+        assert($ff.button(:caption, "Disabled Button2").exists?, 'Can\'t find Button with caption "Disabled Button2"') 
+        assert($ff.button(:caption, "Sign In").exists?, 'Can\'t find Button with caption "Sign In"')
+        
+        assert_equal("b6"  , $ff.button(:id, "b7").name ) 
+        assert_equal("b7"  , $ff.button(:name, "b6").id ) 
+        assert_equal("Click Me2"  , $ff.button(:id, "b7").value  ) 
+        assert_equal(false  , $ff.button(:id, "b7").disabled  ) 
+        assert_equal("italic_button"  , $ff.button(:name, "b6").class_name  ) 
+        
+        assert_equal("b8"  , $ff.button(:id, "b9").name ) 
+        assert_equal("b9"  , $ff.button(:name, "b8").id ) 
+        assert_equal("Disabled Button2"  , $ff.button(:id, "b9").value  ) 
+        assert_equal(false  , $ff.button(:id, "b9").enabled?) 
+        assert_equal(""  , $ff.button(:name, "b8").class_name  ) 
+        assert_equal("Sign In", $ff.button(:caption, "Sign In").value)
+        
+        assert($ff.button(:caption, "Click Me").enabled?, 'Button wih caption "Click Me" should be enabled')   
+      
+        assert_false($ff.button(:caption, "Disabled Button2").enabled?, 'Button wih caption "Disabled Button2" should be disabled')   
+        
+        
+        assert_raises(ObjectDisabledException , "ObjectDisabledException was supposed to be thrown" ) {   $ff.button(:caption, "Disabled Button2").click   }  
+        
+        $ff.button(:caption, "Click Me2").click
+        assert($ff.text.include?("PASS"), 'Clicking on "Click Me2" button should\'ve taken to the "PASS" page') 
+
+     end
+    
+    def test_frame
+        goto_frames_page()
+        f = $ff.frame("buttonFrame")
+        assert(f.button(:caption, "Click Me").enabled?)   
+        #assert_raises(  UnknownObjectException , "UnknownObjectException was supposed to be thrown ( no frame name supplied) " ) { $ff.button(:caption, "Disabled Button").enabled?}  
+    end
+    
+    def test_buttons
+	    arrButtons = $ff.buttons
+	    assert_equal(7, arrButtons.length)
+        #arrButtons.each do |button|
+            #puts button.to_s
+       #end
+      assert_equal("b2", arrButtons[1].id)
+      assert_equal("b5", arrButtons[2].id)
+      assert_equal("Submit", arrButtons[3].value)
+      assert_equal("sub3", arrButtons[4].name)
+      assert_equal("b7", arrButtons[5].id)
+      assert_equal("b9", arrButtons[6].id)
+      assert_equal("Sign In", arrButtons[7].value)
+    end
+
+    # Tests collection class
+    def test_class_buttons
+      arr_buttons = $ff.buttons
+      arr_buttons.each do |b|
+        assert(b.instance_of?(Button),"element class should be #{Button}; got #{b.class}")
+      end
+      # test properties
+      assert_equal("b2", arr_buttons[1].id)
+      assert_equal("b1", arr_buttons[1].name) 
+      assert_equal("button", arr_buttons[1].type) 
+      assert_equal("Click Me", arr_buttons[1].value) 
+      assert_equal(false, arr_buttons[1].disabled) 
+      assert_equal("italic_button", arr_buttons[1].class_name) 
+      assert_equal( "this is button1", arr_buttons[1].title)
+ 
+      assert_equal("b5", arr_buttons[2].id)
+      assert_equal("b4", arr_buttons[2].name) 
+      assert_equal("button", arr_buttons[2].type) 
+      assert_equal("Disabled Button", arr_buttons[2].value) 
+      assert_equal(true, arr_buttons[2].disabled) 
+      assert_equal( "", arr_buttons[2].title)
+      assert_equal("", arr_buttons[2].class_name) 
+
+      assert_equal("Submit", arr_buttons[3].value)
+      assert_equal("sub3", arr_buttons[4].name)
+      assert_equal("b7", arr_buttons[5].id)
+      assert_equal("b9", arr_buttons[6].id)
+      assert_equal("Sign In", arr_buttons[7].value)
+
+
+
+
+    end
+
+
+end
+

data/unittests/buttons_xpath_test.rb

@@ -0,0 +1,87 @@
+# feature tests for Buttons
+# revision: $Revision: 1.0 $
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
+require 'unittests/setup'
+
+class TC_Buttons_XPath < Test::Unit::TestCase
+    include FireWatir
+    
+    def setup
+        $ff.goto($htmlRoot + "buttons1.html")
+    end
+    
+    def test_properties
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:xpath, "//input[@name='noName']").id   }  
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:xpath, "//input[@name='noName']").name   }  
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:xpath, "//input[@name='noName']").disabled   }  
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:xpath, "//input[@name='noName']").type   }  
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:xpath, "//input[@name='noName']").value   }  
+        
+        assert_equal("b1"  , $ff.button(:xpath, "//input[@id='b2']").name  ) 
+        assert_equal("b2"  , $ff.button(:xpath, "//input[@id='b2']").id  ) 
+        assert_equal("button"  , $ff.button(:xpath, "//input[@id='b2']").type  ) 
+    end
+        
+    def test_button_using_default
+        # since most of the time, a button will be accessed based on its caption, there is a default way of accessing it....
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:xpath, "//input[@value='Missing Caption']").click   }  
+        
+        $ff.button(:xpath, "//input[@value='Click Me']").click
+        assert($ff.text.include?("PASS") )
+    end
+    
+    def test_Button_click_only
+        $ff.button(:xpath, "//input[@value='Click Me']").click
+        assert($ff.text.include?("PASS") )
+    end
+    
+    def test_button_click
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:xpath, "//input[@value='Missing Caption']").click   }  
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:xpath, "//input[@id='MissingId']").click   }  
+        
+        assert_raises(ObjectDisabledException , "ObjectDisabledException was supposed to be thrown" ) {   $ff.button(:xpath, "//input[@value='Disabled Button']").click   }  
+        
+        $ff.button(:xpath, "//input[@value='Click Me']").click
+        assert($ff.text.include?("PASS") )
+    end
+    
+    def test_Button_Exists
+        assert($ff.button(:xpath, "//input[@value='Click Me']").exists?)   
+        assert($ff.button(:xpath, "//input[@value='Submit']").exists?)   
+        assert($ff.button(:xpath, "//input[@name='b1']").exists?)   
+        assert($ff.button(:xpath, "//input[@id='b2']").exists?)   
+        
+        assert_false($ff.button(:xpath, "//input[@value='Missing Caption']").exists?)   
+        assert_false($ff.button(:xpath, "//input[@name='missingname']").exists?)   
+        assert_false($ff.button(:xpath, "//input[@id='missingid']").exists?)   
+    end
+
+    def test_element_by_xpath_class
+      element = $ff.element_by_xpath("//input[@value='Click Me']")
+      assert(element.instance_of?(Button),"element class should be #{Button}; got #{element.class}")
+      element = $ff.element_by_xpath("//input[@value='Submit']")
+      assert(element.instance_of?(Button),"element class should be #{Button}; got #{element.class}")
+      element = $ff.element_by_xpath("//input[@name='b1']")
+      assert(element.instance_of?(Button),"element class should be #{Button}; got #{element.class}")
+      element = $ff.element_by_xpath("//input[@id='b2']")
+      assert(element.instance_of?(Button),"element class should be #{Button}; got #{element.class}")
+      # TODO: If object is not there this should return null
+      #element = $ff.element_by_xpath("//input[@value='Missing Caption']")
+      #assert(element.instance_of?(Button),"element class should be #{Button}; got #{element.class}")
+      #element = $ff.element_by_xpath("//input[@name='missingname']")
+      #assert(element.instance_of?(Button),"element class should be #{Button}; got #{element.class}")
+      #element = $ff.element_by_xpath("//input[@id='missingid']")
+      #assert(element.instance_of?(Button),"element class should be #{Button}; got #{element.class}")
+    end
+    
+    def test_Button_Enabled
+        assert($ff.button(:xpath, "//input[@value='Click Me']").enabled?)   
+        assert_false($ff.button(:xpath, "//input[@value='Disabled Button']").enabled?)   
+        assert_false($ff.button(:xpath, "//input[@name='b4']").enabled?)   
+        assert_false($ff.button(:xpath, "//input[@id='b5']").enabled?)   
+        
+        assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.button(:xpath, "//input[@name='noName']").enabled?  }  
+    end
+end
+

data/unittests/checkbox_test.rb

@@ -0,0 +1,154 @@
+# feature tests for Check Boxes
+# revision: $Revision: 1.0 $
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
+require 'unittests/setup'
+
+class TC_CheckBox < Test::Unit::TestCase
+    include FireWatir
+
+    def setup()
+        $ff.goto($htmlRoot + "checkboxes1.html")
+    end
+    
+    def test_checkbox_properties
+       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.checkbox(:name, "noName").id   }  
+       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.checkbox(:name, "noName").name   }  
+       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.checkbox(:name, "noName").disabled   }  
+       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.checkbox(:name, "noName").type   }  
+       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ff.checkbox(:name, "noName").value   }  
+
+       assert_equal("box1"  , $ff.checkbox(:index, 1).name  ) 
+       assert_instance_of(CheckBox,$ff.checkbox(:index,1))
+       assert_equal(""  , $ff.checkbox(:index, 1).id  ) 
+       assert_equal("checkbox"  , $ff.checkbox(:index, 1).type  ) 
+       assert_equal("on"  , $ff.checkbox(:index, 1).value  ) 
+       assert_equal(false  , $ff.checkbox(:index, 1).disabled  ) 
+
+       assert_equal("check_box_style" , $ff.checkbox(:name, "box1").class_name) 
+       assert_equal("" , $ff.checkbox(:name, "box2").class_name) 
+
+       assert_equal("1" , $ff.checkbox(:name,"box4").value )
+       assert_equal("3" , $ff.checkbox(:name,"box4" , 3).value )
+       assert_equal("checkbox" , $ff.checkbox(:name,"box4" , 3).type )
+       assert_equal(false , $ff.checkbox(:name,"box4" , 3).disabled )
+       assert_equal("" , $ff.checkbox(:name,"box4" , 3).id )
+
+       assert_equal("box4-value5" , $ff.checkbox(:name,"box4" , 5).title)
+       assert_equal("" , $ff.checkbox(:name,"box4" , 4).title)
+    end
+
+    def test_onClick
+       assert_false($ff.button(:value , "foo").enabled?)
+       $ff.checkbox(:name, "box5").set
+       assert($ff.button(:value , "foo").enabled?)
+
+       $ff.checkbox(:name, "box5").clear
+       assert_false($ff.button(:value , "foo").enabled?)
+
+       $ff.checkbox(:name, "box5").clear
+       assert_false($ff.button(:value , "foo").enabled?)
+    end
+
+    def test_CheckBox_Exists
+       assert($ff.checkbox(:name, "box1").exists?)   
+       assert_false($ff.checkbox(:name, "missing").exists?)   
+    
+       assert($ff.checkbox(:name, "box4" , 1).exists?)   
+       assert_false($ff.checkbox(:name, "box4" , 22).exists?)   
+    end
+
+    #def test_checkbox_Enabled
+    #  assert_raises(UnknownObjectException) { $ff.checkbox(:name, "noName").enabled? }  
+    #   assert_raises(UnknownObjectException) { $ff.checkbox(:id, "noName").enabled? }  
+    #  assert_raises(UnknownObjectException) { $ff.checkbox(:name, "box4" , 6).enabled? }  
+    #
+    #   assert($ff.checkbox(:name, "box1").enabled?)   
+    #    assert_false($ff.checkbox(:name, "box2").enabled?)   
+    #
+    #   assert($ff.checkbox(:name, "box4", 4).enabled?)   
+    #  assert_false($ff.checkbox(:name, "box4" , 5 ).enabled?)   
+    #end
+
+    def test_checkbox_isSet
+       assert_raises(UnknownObjectException ) { $ff.checkbox(:name, "noName").isSet? }  
+
+       assert_false($ff.checkbox(:name, "box1").isSet?)   
+       assert_false($ff.checkbox(:name, "box2").isSet?)   
+       assert($ff.checkbox(:name, "box3").isSet?)   
+
+       assert_false($ff.checkbox(:name, "box4" , 2 ).isSet?)   
+       assert($ff.checkbox(:name, "box4" , 1 ).isSet?)   
+    end
+
+    def test_checkbox_clear
+       assert_raises(UnknownObjectException) { $ff.checkbox(:name, "noName").clear }  
+       $ff.checkbox(:name, "box1").clear
+       assert_false($ff.checkbox(:name, "box1").isSet?)   
+
+       assert_raises(ObjectDisabledException) { $ff.checkbox(:name, "box2").clear } 
+       assert_false($ff.checkbox(:name, "box2").isSet?)   
+
+       $ff.checkbox(:name, "box3").clear
+       assert_false($ff.checkbox(:name, "box3").isSet?)   
+
+       $ff.checkbox(:name, "box4" , 1).clear
+       assert_false($ff.checkbox(:name, "box4" , 1).isSet?)   
+    end
+
+    def test_checkbox_getState
+       assert_raises(UnknownObjectException) { $ff.checkbox(:name, "noName").getState }  
+       assert_equal( false , $ff.checkbox(:name, "box1").getState )   
+       assert_equal( true , $ff.checkbox(:name, "box3").getState)   
+
+       # checkboxes that have the same name but different values
+       assert_equal( false , $ff.checkbox(:name, "box4" , 2).getState )   
+       assert_equal( true , $ff.checkbox(:name, "box4" , 1).getState)   
+    end
+
+    def test_checkbox_set
+       assert_raises(UnknownObjectException) { $ff.checkbox(:name, "noName").set }  
+       $ff.checkbox(:name, "box1").set
+       assert($ff.checkbox(:name, "box1").isSet?)   
+
+       assert_raises(ObjectDisabledException) { $ff.checkbox(:name, "box2").set }  
+
+       $ff.checkbox(:name, "box3").set
+       assert($ff.checkbox(:name, "box3").isSet?)   
+
+       # checkboxes that have the same name but different values
+       $ff.checkbox(:name, "box4" , 3).set
+       assert($ff.checkbox(:name, "box4" , 3).isSet?)   
+
+       # test set using the optinal true/false
+       # assumes the checkbox is already checked
+       $ff.checkbox(:name, "box1").set( false )
+       assert_false($ff.checkbox(:name, "box1").isSet?)   
+
+       $ff.checkbox(:name, "box1").set( true )
+       assert($ff.checkbox(:name, "box1").isSet?)   
+
+
+
+
+    end
+
+    def test_checkbox_iterator
+
+        assert_equal(11, $ff.checkboxes.length)
+        assert_equal("box1" , $ff.checkboxes[1].name )
+
+        index=1
+        $ff.checkboxes.each do |c|
+            assert_equal( $ff.checkbox(:index, index).name , c.name )
+            assert_equal( $ff.checkbox(:index, index).id, c.id )
+            assert_equal( $ff.checkbox(:index, index).value, c.value )
+            assert_equal( $ff.checkbox(:index, index).isSet?, c.isSet? )
+            index+=1
+        end
+        assert_equal(index-1, $ff.checkboxes.length)
+ 
+    end
+
+
+end