page-object 1.0.2 → 1.0.3

data/lib/page-object/elements.rb

@@ -55,5 +55,6 @@ require 'page-object/elements/canvas'
 require 'page-object/elements/media'
 require 'page-object/elements/audio'
 require 'page-object/elements/video'
+require 'page-object/elements/bold'
 
 

data/lib/page-object/elements/bold.rb

@@ -0,0 +1,11 @@
+module PageObject
+  module Elements
+    class Bold < Element
+
+    end
+
+    ::PageObject::Elements.tag_to_class[:b] = ::PageObject::Elements::Bold
+
+    
+  end
+end

data/lib/page-object/elements/element.rb

@@ -59,6 +59,17 @@ module PageObject
         attribute 'class'
       end
 
+      #
+      # specify plural form of element
+      #
+      def self.plural_form
+        "#{self.to_s.split('::')[-1].
+            gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+            gsub(/([a-z\d])([A-Z])/,'\1_\2').
+            tr("-", "_").
+            downcase}s"
+      end
+
       # @private
       def self.watir_identifier_for identifier
         if should_build_watir_xpath(identifier)
@@ -107,7 +118,7 @@ module PageObject
       protected
 
       def self.should_build_watir_xpath identifier
-        ['table', 'span', 'div', 'td', 'li', 'ul', 'ol', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'label', 'area', 'canvas', 'audio', 'video'].include? identifier[:tag_name] and identifier[:name]
+        ['table', 'span', 'div', 'td', 'li', 'ul', 'ol', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'label', 'area', 'canvas', 'audio', 'video', 'b'].include? identifier[:tag_name] and identifier[:name]
       end
 
       def self.build_xpath_for identifier

data/lib/page-object/elements/table.rb

@@ -1,4 +1,3 @@
-
 module PageObject
   module Elements
     class Table < Element
@@ -38,6 +37,18 @@ module PageObject
         self[-1]
       end
 
+      #
+      # return the table as hashes
+      #
+      # @return Hash
+      #
+      def hashes
+        headers = self.first_row.map(&:text)
+        self.entries[1..-1].map do |row|
+          Hash[headers.zip(row.map(&:text))]
+        end
+      end
+
       protected
 
       def child_xpath

data/lib/page-object/indexed_properties.rb

@@ -1,25 +1,5 @@
 module PageObject
   module IndexedProperties
-    class RowOfElements
-      include PageObject
-      include LoadsPlatform
-      extend Accessors
-
-      def initialize (browser, index, identifier_list)
-        initialize_browser(browser)
-
-        identifier_list.each do |identifier|
-          type = identifier[0]
-          name = identifier[1]
-          how_and_what = identifier[2].clone # Cannot modify the original...
-          how_and_what.each do |key, value|
-            how_and_what[key] = value % index
-          end
-          self.class.send type, name, how_and_what unless self.class.instance_methods.include? name
-        end
-      end
-    end
-
     class TableOfElements
       include PageObject
       include LoadsPlatform
@@ -27,10 +7,29 @@ module PageObject
       def initialize (browser, identifier_list)
         initialize_browser(browser)
         @identifier_list = identifier_list
+        @indexed_property_class = Class.new {
+          include PageObject
+          include LoadsPlatform
+          extend Accessors
+
+          def initialize (browser, index, identifier_list)
+            initialize_browser(browser)
+
+            identifier_list.each do |identifier|
+              type = identifier[0]
+              name = identifier[1]
+              how_and_what = identifier[2].clone # Cannot modify the original...
+              how_and_what.each do |key, value|
+                how_and_what[key] = value % index
+              end
+              self.class.send type, name, how_and_what unless self.class.instance_methods.include? name
+            end
+          end
+        }
       end
 
       def [] (index)
-        RowOfElements.new(@browser, index, @identifier_list)
+        @indexed_property_class.new(@browser,index,@identifier_list)
       end
     end
   end

data/lib/page-object/javascript/angularjs.rb

@@ -0,0 +1,14 @@
+module PageObject
+  module Javascript
+
+    module AngularJS
+      #
+      # return the number of pending ajax requests
+      #
+      def self.pending_requests
+        'return angular.element(document.body).injector().get(\'$http\').pendingRequests.length;'
+      end
+    end
+
+  end
+end

data/lib/page-object/javascript_framework_facade.rb

@@ -1,6 +1,7 @@
 require 'page-object/javascript/jquery'
 require 'page-object/javascript/prototype'
 require 'page-object/javascript/yui'
+require 'page-object/javascript/angularjs'
 
 
 module PageObject
@@ -19,8 +20,8 @@ module PageObject
       #
       # Set the framework to use.
       #
-      # @param[Symbol] the framework to use.  :jquery and :prototype
-      # are supported
+      # @param[Symbol] the framework to use.  :jquery, :prototype, :yui,
+      # and :angularjs are supported
       #
       def framework=(framework)
         initialize_script_builder unless @builder
@@ -63,6 +64,7 @@ module PageObject
           :jquery => ::PageObject::Javascript::JQuery,
           :prototype => ::PageObject::Javascript::Prototype,
           :yui => ::PageObject::Javascript::YUI,
+          :angularjs => ::PageObject::Javascript::AngularJS
         }
       end
 

data/lib/page-object/locator_generator.rb

@@ -101,6 +101,7 @@ module PageObject
                          :canvas,
                          :audio,
                          :video,
+                         :b,
                          :svg]
 
     def self.generate_locators(target)

data/lib/page-object/page_populator.rb

@@ -51,7 +51,6 @@ module PageObject
 
     def populate_radiobutton(key, value)
       return self.send "select_#{key}" if value
-      return self.send "clear_#{key}"
     end
 
     def populate_radiobuttongroup(key, value)

data/lib/page-object/platforms/selenium_webdriver/button.rb

@@ -4,7 +4,7 @@ module PageObject
       module Button
         #
         # Override PageObject::PLatforms::SeleniumElement#text because
-        # #text does not reliabably return a value in Selenium
+        # #text does not reliably return a value in Selenium
         #
         def text
           raise "text is not available on button element in Selenium"

data/lib/page-object/platforms/selenium_webdriver/element.rb

@@ -235,7 +235,7 @@ module PageObject
         #
         # @param [Integer] (defaults to: 5) seconds to wait before timing out
         # @param [String] the message to display if the event timeouts
-        # @param the block to execute when the event occurrs
+        # @param the block to execute when the event occurs
         #
         def wait_until(timeout=::PageObject.default_element_wait, message=nil, &block)
           wait = Object::Selenium::WebDriver::Wait.new({:timeout => timeout, :message => message})

data/lib/page-object/platforms/selenium_webdriver/page_object.rb

@@ -425,16 +425,6 @@ module PageObject
           end
         end
 
-        #
-        # platform method to clear a radio button
-        # See PageObject::Accessors#radio_button
-        #
-        def clear_radio(identifier)
-          process_selenium_call(identifier, Elements::RadioButton, 'input', :type => 'radio') do |how, what|
-            @browser.find_element(how, what).click if @browser.find_element(how, what).selected?
-          end
-        end
-
         #
         # platform method to determine if a radio button is selected
         # See PageObject::Accessors#radio_button
@@ -1012,6 +1002,32 @@ module PageObject
           find_selenium_elements(identifier, Elements::Element, 'svg')
         end
 
+
+        #
+        # platform method to retrieve the text from a b
+        # See PageObject::Accessors#b
+        #
+        def b_text_for(identifier)
+          process_selenium_call(identifier, Elements::Bold, 'b') do |how, what|
+            @browser.find_element(how, what).text
+          end
+        end
+
+        #
+        # platform method to retrieve the h1 element
+        # See PageObject::Accessors#b
+        #
+        def b_for(identifier)
+          find_selenium_element(identifier, Elements::Bold, 'b')
+        end
+
+        #
+        # platform method to retrieve all b elements
+        #
+        def bs_for(identifier)
+          find_selenium_elements(identifier, Elements::Bold, 'b')
+        end
+
         private
 
         def process_selenium_call(identifier, type, tag, other=nil)

data/lib/page-object/platforms/selenium_webdriver/radio_button.rb

@@ -9,13 +9,6 @@ module PageObject
         def select
           element.click unless selected?
         end
-        
-        #
-        # clear the radiobutton
-        #
-        def clear
-          element.click if selected?
-        end
 
         #
         # return if it is selected

data/lib/page-object/platforms/watir_webdriver/element.rb

@@ -200,7 +200,7 @@ module PageObject
         #
         # @param [Integer] (defaults to: 5) seconds to wait before timing out
         # @param [String] the message to display if the event timeouts
-        # @param the block to execute when the event occurrs
+        # @param the block to execute when the event occurs
         #
         def wait_until(timeout=::PageObject.default_element_wait, message=nil, &block)
           Object::Watir::Wait.until(timeout, message, &block)

data/lib/page-object/platforms/watir_webdriver/page_object.rb

@@ -388,14 +388,6 @@ module PageObject
           process_watir_call("radio(identifier).set", Elements::RadioButton, identifier)
         end
 
-        #
-        # platform method to clear a radio button
-        # See PageObject::Accessors#radio_button
-        #
-        def clear_radio(identifier)
-          process_watir_call("radio(identifier).clear", Elements::RadioButton, identifier)
-        end
-
         #
         # platform method to determine if a radio button is selected
         # See PageObject::Accessors#radio_button
@@ -938,6 +930,29 @@ module PageObject
         def svgs_for(identifier)
           find_watir_elements("element(identifier)", Elements::Element, identifier)
         end
+
+        #
+        # platform method to retrieve the text for a b
+        # See PageObject::Accessors#b
+        #
+        def b_text_for(identifier)
+          process_watir_call("b(identifier).text", Elements::Bold, identifier, nil, 'b')
+        end
+
+        #
+        # platform method to retrieve the b element
+        # See PageObject::Accessors#h1
+        #
+        def b_for(identifier)
+          find_watir_element("b(identifier)", Elements::Bold, identifier, 'b')
+        end
+
+        #
+        # platform method to retrieve an array of bs
+        #
+        def bs_for(identifier)
+          find_watir_elements("bs(identifier)", Elements::Bold, identifier, 'b')
+        end
  
         private
 

data/lib/page-object/platforms/watir_webdriver/radio_button.rb

@@ -10,13 +10,6 @@ module PageObject
           element.set
         end
 
-        #
-        # clear the radiobutton
-        #
-        def clear
-          element.clear
-        end
-
         #
         # return if it is selected
         #

data/lib/page-object/version.rb

@@ -1,4 +1,4 @@
 module PageObject
   # @private
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 end

data/lib/page-object/widgets.rb

@@ -46,6 +46,13 @@ module PageObject
             widget_class.accessor_methods(self, name)
           end
         end
+        define_method widget_class.plural_form do |name, *identifier_args, &block|
+          define_method("#{name}_elements") do
+            return call_block(&block) unless block.nil?
+            platform_method = "#{widget_tag.to_s}s_for"
+            platform.send platform_method, (identifier_args.first ? identifier_args.first.clone : {})
+          end
+        end
       end
 
       base.send(:include, accessors_module)

data/page-object.gemspec

@@ -20,11 +20,11 @@ Gem::Specification.new do |s|
   s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency 'watir-webdriver', '>= 0.6.9'
-  s.add_dependency 'selenium-webdriver', '>= 2.42.0'
+  s.add_dependency 'watir-webdriver', '>= 0.6.11'
+  s.add_dependency 'selenium-webdriver', '>= 2.44.0'
   s.add_dependency 'page_navigation', '>= 0.9'
 
-  s.add_development_dependency 'rspec', '< 3.0'
+  s.add_development_dependency 'rspec'
   s.add_development_dependency 'cucumber', '>= 1.3.0'
   s.add_development_dependency 'yard', '>= 0.7.2'
   s.add_development_dependency 'rack', '>= 1.0'

data/spec/page-object/accessors_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+class GenericPage
+  include PageObject
+
+  wait_for_expected_title 'expected title'
+end
+
+describe  'accessors' do
+  let(:browser) { mock_watir_browser }
+  let(:page) { GenericPage.new browser }
+
+  context '#wait_for_expected_title' do
+    before(:each) do
+      allow(browser).to receive(:wait_until).and_yield
+    end
+
+    it 'true if already there' do
+      allow(browser).to receive(:title).and_return 'expected title'
+      expect(page.wait_for_expected_title?).to be_truthy
+    end
+
+    it 'does not wait if it already is there' do
+      allow(browser).to receive(:title).and_return 'expected title'
+      expect(browser).to_not receive(:wait_until)
+
+      expect(page.wait_for_expected_title?).to be_truthy
+    end
+
+    it 'errors when it does not match' do
+      allow(browser).to receive(:title).and_return 'wrong title'
+      expect { page.wait_for_expected_title? }.to raise_error "Expected title 'expected title' instead of 'wrong title'"
+    end
+
+    it 'picks up when the title changes' do
+      allow(browser).to receive(:title).and_return 'wrong title', 'expected title'
+      expect(page.wait_for_expected_title?).to be_truthy
+    end
+  end
+end

data/spec/page-object/element_locators_spec.rb

@@ -12,677 +12,699 @@ describe PageObject::ElementLocators do
     let(:watir_page_object) { ElementLocatorsTestPageObject.new(watir_browser) }
     
     it "should find a button element" do
-      watir_browser.should_receive(:button).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:button).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.button_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Button
+      expect(element).to  be_instance_of PageObject::Elements::Button
     end
 
     it "should find a button element using a default identifier" do
-      watir_browser.should_receive(:button).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:button).with(:index => 0).and_return(watir_browser)
       watir_page_object.button_element
     end
 
     it "should find all button elements" do
-      watir_browser.should_receive(:buttons).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:buttons).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.button_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Button
+      expect(elements[0]).to  be_instance_of PageObject::Elements::Button
     end
 
     it "should find all buttons with no identifier" do
-      watir_browser.should_receive(:buttons).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:buttons).with({}).and_return([watir_browser])
       watir_page_object.button_elements
     end
     
     it "should find a text field element" do
-      watir_browser.should_receive(:text_field).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:text_field).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.text_field_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::TextField
+      expect(element).to be_instance_of PageObject::Elements::TextField
     end
 
     it "should find a text field element using a default identifier" do
-      watir_browser.should_receive(:text_field).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:text_field).with(:index => 0).and_return(watir_browser)
       watir_page_object.text_field_element
     end
 
     it "should find all text field elements" do
-      watir_browser.should_receive(:text_fields).with(:id => 'blah').and_return([watir_browser])
-      watir_browser.should_receive(:tag_name).and_return('input')
+      expect(watir_browser).to receive(:text_fields).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:tag_name).and_return('input')
       elements = watir_page_object.text_field_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::TextField
+      expect(elements[0]).to be_instance_of PageObject::Elements::TextField
     end
 
     it "should find all text fields with no identifier" do
-      watir_browser.should_receive(:text_fields).with({}).and_return([watir_browser])
-      watir_browser.should_receive(:tag_name).and_return('input')
+      expect(watir_browser).to receive(:text_fields).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:tag_name).and_return('input')
       watir_page_object.text_field_elements
     end
     
     it "should find a hidden field element" do
-      watir_browser.should_receive(:hidden).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:hidden).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.hidden_field_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::HiddenField
+      expect(element).to be_instance_of PageObject::Elements::HiddenField
     end
 
     it "should find a hidden field using a default identifier" do
-      watir_browser.should_receive(:hidden).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:hidden).with(:index => 0).and_return(watir_browser)
       watir_page_object.hidden_field_element
     end
 
     it "should find all hidden field elements" do
-      watir_browser.should_receive(:hiddens).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:hiddens).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.hidden_field_elements(:id => 'blah')
-      elements[0].should be_instance_of(PageObject::Elements::HiddenField)
+      expect(elements[0]).to be_instance_of(PageObject::Elements::HiddenField)
     end
 
     it "should find all hidden field elements using no identifier" do
-      watir_browser.should_receive(:hiddens).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:hiddens).with({}).and_return([watir_browser])
       watir_page_object.hidden_field_elements
     end
     
     it "should find a text area element" do
-      watir_browser.should_receive(:textarea).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:textarea).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.text_area_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::TextArea
+      expect(element).to be_instance_of PageObject::Elements::TextArea
     end
 
     it "should find a text area using a default identifier" do
-      watir_browser.should_receive(:textarea).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:textarea).with(:index => 0).and_return(watir_browser)
       watir_page_object.text_area_element
     end
 
     it "should find all text area elements" do
-      watir_browser.should_receive(:textareas).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:textareas).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.text_area_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::TextArea 
+      expect(elements[0]).to be_instance_of PageObject::Elements::TextArea 
     end
 
     it "should find all text area elements using no identifier" do
-      watir_browser.should_receive(:textareas).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:textareas).with({}).and_return([watir_browser])
       watir_page_object.text_area_elements
     end
     
     it "should find a select list element" do
-      watir_browser.should_receive(:select_list).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:select_list).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.select_list_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::SelectList
+      expect(element).to be_instance_of PageObject::Elements::SelectList
     end
 
     it "should find a select list using a default identifier" do
-      watir_browser.should_receive(:select_list).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:select_list).with(:index => 0).and_return(watir_browser)
       watir_page_object.select_list_element
     end
 
     it "should find all select list elements" do
-      watir_browser.should_receive(:select_lists).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:select_lists).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.select_list_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::SelectList 
+      expect(elements[0]).to be_instance_of PageObject::Elements::SelectList 
     end
 
     it "should find all select list elements using no identifier" do
-      watir_browser.should_receive(:select_lists).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:select_lists).with({}).and_return([watir_browser])
       watir_page_object.select_list_elements
     end
     
     it "should find a link element" do
-      watir_browser.should_receive(:link).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:link).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.link_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Link
+      expect(element).to be_instance_of PageObject::Elements::Link
     end
 
     it "should find a link element using a default identifier" do
-      watir_browser.should_receive(:link).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:link).with(:index => 0).and_return(watir_browser)
       watir_page_object.link_element
     end
 
     it "should find all link elements" do
-      watir_browser.should_receive(:links).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:links).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.link_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Link 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Link 
     end
 
     it "should find all links using no identifier" do
-      watir_browser.should_receive(:links).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:links).with({}).and_return([watir_browser])
       watir_page_object.link_elements
     end
     
     it "should find a check box" do
-      watir_browser.should_receive(:checkbox).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:checkbox).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.checkbox_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::CheckBox
+      expect(element).to be_instance_of PageObject::Elements::CheckBox
     end
 
     it "should find a check box using a default identifier" do
-      watir_browser.should_receive(:checkbox).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:checkbox).with(:index => 0).and_return(watir_browser)
       watir_page_object.checkbox_element
     end
 
     it "should find all check box elements" do
-      watir_browser.should_receive(:checkboxes).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:checkboxes).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.checkbox_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::CheckBox 
+      expect(elements[0]).to be_instance_of PageObject::Elements::CheckBox 
     end
 
     it "should find all check box elements using no identifier" do
-      watir_browser.should_receive(:checkboxes).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:checkboxes).with({}).and_return([watir_browser])
       watir_page_object.checkbox_elements
     end
     
     it "should find a radio button" do
-      watir_browser.should_receive(:radio).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:radio).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.radio_button_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::RadioButton
+      expect(element).to be_instance_of PageObject::Elements::RadioButton
     end
 
     it "should find a radio button using a default identifier" do
-      watir_browser.should_receive(:radio).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:radio).with(:index => 0).and_return(watir_browser)
       watir_page_object.radio_button_element
     end
 
     it "should find all radio buttons" do
-      watir_browser.should_receive(:radios).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:radios).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.radio_button_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::RadioButton 
+      expect(elements[0]).to be_instance_of PageObject::Elements::RadioButton 
     end
 
     it "should find all radio buttons using no identifier" do
-      watir_browser.should_receive(:radios).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:radios).with({}).and_return([watir_browser])
       watir_page_object.radio_button_elements
     end
     
     it "should find a div" do
-      watir_browser.should_receive(:div).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:div).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.div_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Div
+      expect(element).to be_instance_of PageObject::Elements::Div
     end
 
     it "should find a div using a default identifier" do
-      watir_browser.should_receive(:div).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:div).with(:index => 0).and_return(watir_browser)
       watir_page_object.div_element
     end
 
     it "should find all div elements" do
-      watir_browser.should_receive(:divs).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:divs).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.div_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Div 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Div 
     end
 
     it "should find all div elements using no identifier" do
-      watir_browser.should_receive(:divs).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:divs).with({}).and_return([watir_browser])
       watir_page_object.div_elements
     end
     
     it "should find a span" do
-      watir_browser.should_receive(:span).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:span).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.span_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Span
+      expect(element).to be_instance_of PageObject::Elements::Span
     end
 
     it "should find a span using a default identifier" do
-      watir_browser.should_receive(:span).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:span).with(:index => 0).and_return(watir_browser)
       watir_page_object.span_element
     end
 
     it "should find all span elements" do
-      watir_browser.should_receive(:spans).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:spans).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.span_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Span 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Span 
     end
 
     it "should find all span elements using no identifier" do
-      watir_browser.should_receive(:spans).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:spans).with({}).and_return([watir_browser])
       watir_page_object.span_elements
     end
     
     it "should find a table" do
-      watir_browser.should_receive(:table).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:table).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.table_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Table
+      expect(element).to be_instance_of PageObject::Elements::Table
     end
 
     it "should find a table using a default identifier" do
-      watir_browser.should_receive(:table).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:table).with(:index => 0).and_return(watir_browser)
       watir_page_object.table_element
     end
 
     it "should find all table elements" do
-      watir_browser.should_receive(:tables).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:tables).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.table_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Table 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Table 
     end
 
     it "should find all table elements using no identifier" do
-      watir_browser.should_receive(:tables).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:tables).with({}).and_return([watir_browser])
       watir_page_object.table_elements
     end
     
     it "should find a table cell" do
-      watir_browser.should_receive(:td).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:td).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.cell_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::TableCell
+      expect(element).to be_instance_of PageObject::Elements::TableCell
     end
 
     it "should find a table cell using a default identifier" do
-      watir_browser.should_receive(:td).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:td).with(:index => 0).and_return(watir_browser)
       watir_page_object.cell_element
     end
 
     it "should find all table cells" do
-      watir_browser.should_receive(:tds).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:tds).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.cell_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::TableCell 
+      expect(elements[0]).to be_instance_of PageObject::Elements::TableCell 
     end
 
     it "should find all table cells using no identifier" do
-      watir_browser.should_receive(:tds).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:tds).with({}).and_return([watir_browser])
       watir_page_object.cell_elements
     end
     
     it "should find an image" do
-      watir_browser.should_receive(:image).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:image).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.image_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Image
+      expect(element).to be_instance_of PageObject::Elements::Image
     end
 
     it "should find an image using a default identifier" do
-      watir_browser.should_receive(:image).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:image).with(:index => 0).and_return(watir_browser)
       watir_page_object.image_element
     end
 
     it "should find all images" do
-      watir_browser.should_receive(:images).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:images).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.image_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Image
+      expect(elements[0]).to be_instance_of PageObject::Elements::Image
     end
 
     it "should find all images using no identifier" do
-      watir_browser.should_receive(:images).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:images).with({}).and_return([watir_browser])
       watir_page_object.image_elements
     end
     
     it "should find a form" do
-      watir_browser.should_receive(:form).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:form).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.form_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Form
+      expect(element).to be_instance_of PageObject::Elements::Form
     end
 
     it "should find a form using a default identifier" do
-      watir_browser.should_receive(:form).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:form).with(:index => 0).and_return(watir_browser)
       watir_page_object.form_element
     end
 
     it "should find all forms" do
-      watir_browser.should_receive(:forms).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:forms).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.form_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Form
+      expect(elements[0]).to be_instance_of PageObject::Elements::Form
     end
 
     it "should find all forms using no identifier" do
-      watir_browser.should_receive(:forms).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:forms).with({}).and_return([watir_browser])
       watir_page_object.form_elements
     end
     
     it "should find a list item" do
-      watir_browser.should_receive(:li).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:li).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.list_item_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::ListItem
+      expect(element).to be_instance_of PageObject::Elements::ListItem
     end
 
     it "should find a list item using a default identifier" do
-      watir_browser.should_receive(:li).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:li).with(:index => 0).and_return(watir_browser)
       watir_page_object.list_item_element
     end
 
     it "should find all list items" do
-      watir_browser.should_receive(:lis).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:lis).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.list_item_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::ListItem 
+      expect(elements[0]).to be_instance_of PageObject::Elements::ListItem 
     end
 
     it "should find all list items using no parameter" do
-      watir_browser.should_receive(:lis).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:lis).with({}).and_return([watir_browser])
       watir_page_object.list_item_elements
     end
     
     it "should find an unordered list" do
-      watir_browser.should_receive(:ul).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:ul).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.unordered_list_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::UnorderedList
+      expect(element).to be_instance_of PageObject::Elements::UnorderedList
     end
 
     it "should find an unordered list using a default identifier" do
-      watir_browser.should_receive(:ul).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:ul).with(:index => 0).and_return(watir_browser)
       watir_page_object.unordered_list_element
     end
 
     it "should find all unordered lists" do
-      watir_browser.should_receive(:uls).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:uls).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.unordered_list_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::UnorderedList 
+      expect(elements[0]).to be_instance_of PageObject::Elements::UnorderedList 
     end
 
     it "should find all unordered lists using no parameters" do
-      watir_browser.should_receive(:uls).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:uls).with({}).and_return([watir_browser])
       watir_page_object.unordered_list_elements
     end
     
     it "should find an ordered list" do
-      watir_browser.should_receive(:ol).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:ol).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.ordered_list_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::OrderedList
+      expect(element).to be_instance_of PageObject::Elements::OrderedList
     end
 
     it "should find an orderd list using a default identifier" do
-      watir_browser.should_receive(:ol).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:ol).with(:index => 0).and_return(watir_browser)
       watir_page_object.ordered_list_element
     end
 
     it "should find all ordered lists" do
-      watir_browser.should_receive(:ols).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:ols).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.ordered_list_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::OrderedList 
+      expect(elements[0]).to be_instance_of PageObject::Elements::OrderedList 
     end
 
     it "should find all orderd lists using no parameters" do
-      watir_browser.should_receive(:ols).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:ols).with({}).and_return([watir_browser])
       watir_page_object.ordered_list_elements
     end
     
     it "should find a h1 element" do
-      watir_browser.should_receive(:h1).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:h1).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.h1_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
 
     it "should find a h1 element using a default identifier" do
-      watir_browser.should_receive(:h1).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:h1).with(:index => 0).and_return(watir_browser)
       watir_page_object.h1_element
     end
 
     it "should find all h1 elements" do
-      watir_browser.should_receive(:h1s).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:h1s).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.h1_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Heading 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Heading 
     end
 
     it "should find all h1 elements using no parameters" do
-      watir_browser.should_receive(:h1s).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:h1s).with({}).and_return([watir_browser])
       watir_page_object.h1_elements
     end
 
     it "should find a h2 element" do
-      watir_browser.should_receive(:h2).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:h2).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.h2_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
 
     it "should find a h2 element using default identifier" do
-      watir_browser.should_receive(:h2).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:h2).with(:index => 0).and_return(watir_browser)
       watir_page_object.h2_element
     end
 
     it "should find all h2 elements" do
-      watir_browser.should_receive(:h2s).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:h2s).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.h2_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Heading 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Heading 
     end
 
     it "should find all h2 elements using no identifier" do
-      watir_browser.should_receive(:h2s).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:h2s).with({}).and_return([watir_browser])
       watir_page_object.h2_elements
     end
 
     it "should find a h3 element" do
-      watir_browser.should_receive(:h3).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:h3).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.h3_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
 
     it "should find a h3 element using a default identifier" do
-      watir_browser.should_receive(:h3).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:h3).with(:index => 0).and_return(watir_browser)
       watir_page_object.h3_element
     end
 
     it "should find all h3 elements" do
-      watir_browser.should_receive(:h3s).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:h3s).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.h3_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Heading 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Heading 
     end
 
     it "should find all h3 elements using no identifiers" do
-      watir_browser.should_receive(:h3s).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:h3s).with({}).and_return([watir_browser])
       watir_page_object.h3_elements
     end
 
     it "should find a h4 element" do
-      watir_browser.should_receive(:h4).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:h4).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.h4_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
 
     it "should find a h4 element using a default identifier" do
-      watir_browser.should_receive(:h4).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:h4).with(:index => 0).and_return(watir_browser)
       watir_page_object.h4_element
     end
 
     it "should find all h4 elements" do
-      watir_browser.should_receive(:h4s).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:h4s).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.h4_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Heading 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Heading 
     end
 
     it "should find all h4 elements using no identifier" do
-      watir_browser.should_receive(:h4s).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:h4s).with({}).and_return([watir_browser])
       watir_page_object.h4_elements
     end
 
     it "should find a h5 element" do
-      watir_browser.should_receive(:h5).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:h5).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.h5_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
 
     it "should find a h5 element using a default identifier" do
-      watir_browser.should_receive(:h5).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:h5).with(:index => 0).and_return(watir_browser)
       watir_page_object.h5_element
     end
 
     it "should find all h5 elements" do
-      watir_browser.should_receive(:h5s).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:h5s).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.h5_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Heading 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Heading 
     end
 
     it "should find all h5 elements using no identifier" do
-      watir_browser.should_receive(:h5s).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:h5s).with({}).and_return([watir_browser])
       watir_page_object.h5_elements
     end
 
     it "should find a h6 element" do
-      watir_browser.should_receive(:h6).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:h6).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.h6_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
 
     it "should find a h6 element using a default identifier" do
-      watir_browser.should_receive(:h6).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:h6).with(:index => 0).and_return(watir_browser)
       watir_page_object.h6_element
     end
 
     it "should find all h6 elements" do
-      watir_browser.should_receive(:h6s).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:h6s).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.h6_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Heading 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Heading 
     end
 
     it "should find all h6 elements using no identifier" do
-      watir_browser.should_receive(:h6s).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:h6s).with({}).and_return([watir_browser])
       watir_page_object.h6_elements
     end
 
     it "should find a paragraph element" do
-      watir_browser.should_receive(:p).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:p).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.paragraph_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Paragraph
+      expect(element).to be_instance_of PageObject::Elements::Paragraph
     end
 
     it "should find a paragraph element using a default identifier" do
-      watir_browser.should_receive(:p).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:p).with(:index => 0).and_return(watir_browser)
       watir_page_object.paragraph_element
     end
 
     it "should find all paragraph elements" do
-      watir_browser.should_receive(:ps).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:ps).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.paragraph_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Paragraph 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Paragraph 
     end
 
     it "should find all paragraph elements using no identifier" do
-      watir_browser.should_receive(:ps).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:ps).with({}).and_return([watir_browser])
       watir_page_object.paragraph_elements
     end
 
     it "should find a label" do
-      watir_browser.should_receive(:label).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:label).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.label_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Label
+      expect(element).to be_instance_of PageObject::Elements::Label
     end
 
     it "should find a label element using default parameters" do
-      watir_browser.should_receive(:label).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:label).with(:index => 0).and_return(watir_browser)
       watir_page_object.label_element
     end
 
     it "should find all label elements" do
-      watir_browser.should_receive(:labels).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:labels).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.label_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Label
+      expect(elements[0]).to be_instance_of PageObject::Elements::Label
     end
 
     it "should find all label elements using no parameters" do
-      watir_browser.should_receive(:labels).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:labels).with({}).and_return([watir_browser])
       watir_page_object.label_elements
     end
 
     it "should find a file field element" do
-      watir_browser.should_receive(:file_field).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:file_field).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.file_field_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::FileField
+      expect(element).to be_instance_of PageObject::Elements::FileField
     end
 
     it "should find a file field element using a default identifier" do
-      watir_browser.should_receive(:file_field).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:file_field).with(:index => 0).and_return(watir_browser)
       watir_page_object.file_field_element
     end
 
     it "should find all file field elements" do
-      watir_browser.should_receive(:file_fields).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:file_fields).with(:id => 'blah').and_return([watir_browser])
       element = watir_page_object.file_field_elements(:id => 'blah')
-      element[0].should be_instance_of PageObject::Elements::FileField
+      expect(element[0]).to be_instance_of PageObject::Elements::FileField
     end
 
     it "should find all file fields using no identifier" do
-      watir_browser.should_receive(:file_fields).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:file_fields).with({}).and_return([watir_browser])
       watir_page_object.file_field_elements
     end
 
     it "should find an area element" do
-      watir_browser.should_receive(:area).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:area).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.area_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Area
+      expect(element).to be_instance_of PageObject::Elements::Area
     end
 
     it "should find an area element using a default identifier" do
-      watir_browser.should_receive(:area).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:area).with(:index => 0).and_return(watir_browser)
       watir_page_object.area_element
     end
 
     it "should find all area elements" do
-      watir_browser.should_receive(:areas).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:areas).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.area_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Area
+      expect(elements[0]).to be_instance_of PageObject::Elements::Area
     end
 
     it "should find all areas with no identifier" do
-      watir_browser.should_receive(:areas).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:areas).with({}).and_return([watir_browser])
       watir_page_object.area_elements
     end
     
     it "should find a canvas element" do
-      watir_browser.should_receive(:canvas).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:canvas).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.canvas_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Canvas
+      expect(element).to be_instance_of PageObject::Elements::Canvas
     end
 
     it "should find a canvas element using a default identifier" do
-      watir_browser.should_receive(:canvas).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:canvas).with(:index => 0).and_return(watir_browser)
       watir_page_object.canvas_element
     end
 
     it "should find all canvas elements" do
-      watir_browser.should_receive(:canvases).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:canvases).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.canvas_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Canvas
+      expect(elements[0]).to be_instance_of PageObject::Elements::Canvas
     end
 
     it "should find all canvases with no identifier" do
-      watir_browser.should_receive(:canvases).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:canvases).with({}).and_return([watir_browser])
       watir_page_object.canvas_elements
     end
 
     it "should find an audio element" do
-      watir_browser.should_receive(:audio).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:audio).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.audio_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Audio
+      expect(element).to be_instance_of PageObject::Elements::Audio
     end
 
     it "should find an audio element using a default identifier" do
-      watir_browser.should_receive(:audio).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:audio).with(:index => 0).and_return(watir_browser)
       watir_page_object.audio_element
     end
 
     it "should find all audio elements" do
-      watir_browser.should_receive(:audios).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:audios).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.audio_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Audio
+      expect(elements[0]).to be_instance_of PageObject::Elements::Audio
     end
 
     it "should find all audio elements with no identifier" do
-      watir_browser.should_receive(:audios).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:audios).with({}).and_return([watir_browser])
       watir_page_object.audio_elements
     end
 
     it "should find a video element" do
-      watir_browser.should_receive(:video).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:video).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.video_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Video
+      expect(element).to be_instance_of PageObject::Elements::Video
     end
 
     it "should find a video element using a default identifier" do
-      watir_browser.should_receive(:video).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:video).with(:index => 0).and_return(watir_browser)
       watir_page_object.video_element
     end
 
     it "should find all video elements" do
-      watir_browser.should_receive(:videos).with(:id => 'blah').and_return([watir_browser])
+      expect(watir_browser).to receive(:videos).with(:id => 'blah').and_return([watir_browser])
       elements = watir_page_object.video_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Video
+      expect(elements[0]).to be_instance_of PageObject::Elements::Video
     end
 
     it "should find all video elements with no identifier" do
-      watir_browser.should_receive(:videos).with({}).and_return([watir_browser])
+      expect(watir_browser).to receive(:videos).with({}).and_return([watir_browser])
       watir_page_object.video_elements
     end
 
     it "should find an element" do
-      watir_browser.should_receive(:audio).with(:id => 'blah').and_return(watir_browser)
+      expect(watir_browser).to receive(:audio).with(:id => 'blah').and_return(watir_browser)
       element = watir_page_object.element(:audio, :id => 'blah')
-      element.should be_instance_of PageObject::Elements::Element
+      expect(element).to be_instance_of PageObject::Elements::Element
     end
 
     it "should find an element using a default identifier" do
-      watir_browser.should_receive(:audio).with(:index => 0).and_return(watir_browser)
+      expect(watir_browser).to receive(:audio).with(:index => 0).and_return(watir_browser)
       watir_page_object.element(:audio)
     end
+
+    it "should find a b element" do
+      expect(watir_browser).to receive(:b).with(:id => 'blah').and_return(watir_browser)
+      element = watir_page_object.b_element(:id => 'blah')
+      expect(element).to be_instance_of PageObject::Elements::Bold
+    end
+
+    it "should find a b element using a default identifier" do
+      expect(watir_browser).to receive(:b).with(:index => 0).and_return(watir_browser)
+      watir_page_object.b_element
+    end
+
+    it "should find all b elements" do
+      expect(watir_browser).to receive(:bs).with(:id => 'blah').and_return([watir_browser])
+      elements = watir_page_object.b_elements(:id => 'blah')
+      expect(elements[0]).to be_instance_of PageObject::Elements::Bold
+    end
+
+    it "should find all b elements using no parameters" do
+      expect(watir_browser).to receive(:bs).with({}).and_return([watir_browser])
+      watir_page_object.b_elements
+    end
   end
 
   context "when using Selenium" do
@@ -690,376 +712,389 @@ describe PageObject::ElementLocators do
     let(:selenium_page_object) { ElementLocatorsTestPageObject.new(selenium_browser) }
     
     it "should find a button element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.button_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Button
+      expect(element).to be_instance_of PageObject::Elements::Button
     end
 
     it "should find all button elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.button_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Button
+      expect(elements[0]).to be_instance_of PageObject::Elements::Button
     end
 
     it "should find a text field element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.text_field_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::TextField
+      expect(element).to be_instance_of PageObject::Elements::TextField
     end
 
     it "should find all text field elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.text_field_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::TextField
+      expect(elements[0]).to be_instance_of PageObject::Elements::TextField
     end
 
     it "should find a hidden field element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.hidden_field_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::HiddenField
+      expect(element).to be_instance_of PageObject::Elements::HiddenField
     end
 
     it "should find all hidden field elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, "blah").and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, "blah").and_return([selenium_browser])
       elements = selenium_page_object.hidden_field_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::HiddenField 
+      expect(elements[0]).to be_instance_of PageObject::Elements::HiddenField 
 
     end
     
     it "should find a text area element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.text_area_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::TextArea
+      expect(element).to be_instance_of PageObject::Elements::TextArea
     end
 
     it "should find all text area elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.text_area_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::TextArea 
+      expect(elements[0]).to be_instance_of PageObject::Elements::TextArea 
     end
     
     it "should find a select list element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.select_list_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::SelectList
+      expect(element).to be_instance_of PageObject::Elements::SelectList
     end
 
     it "should find all select list elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.select_list_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::SelectList 
+      expect(elements[0]).to be_instance_of PageObject::Elements::SelectList 
     end
     
     it "should find a link element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.link_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Link
+      expect(element).to be_instance_of PageObject::Elements::Link
     end
 
     it "should find all link elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.link_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Link 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Link 
     end
     
     it "should find a check box" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.checkbox_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::CheckBox
+      expect(element).to be_instance_of PageObject::Elements::CheckBox
     end
 
     it "should find all checkbox elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.checkbox_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::CheckBox 
+      expect(elements[0]).to be_instance_of PageObject::Elements::CheckBox 
     end
     
     it "should find a radio button" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.radio_button_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::RadioButton
+      expect(element).to be_instance_of PageObject::Elements::RadioButton
     end
 
     it "should find all radio button elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.radio_button_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::RadioButton 
+      expect(elements[0]).to be_instance_of PageObject::Elements::RadioButton 
     end
     
     it "should find a div" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.div_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Div
+      expect(element).to be_instance_of PageObject::Elements::Div
     end
 
     it "should find all div elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.div_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Div 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Div 
     end
     
     it "should find a span" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.span_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Span
+      expect(element).to be_instance_of PageObject::Elements::Span
     end
 
     it "should find all span elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.span_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Span 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Span 
     end
     
     it "should find a table" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.table_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Table
+      expect(element).to be_instance_of PageObject::Elements::Table
     end
     
     it "should find all table elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.table_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Table 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Table 
     end
     
     it "should find a table cell" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.cell_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::TableCell
+      expect(element).to be_instance_of PageObject::Elements::TableCell
     end
 
     it "should find all table cell elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.cell_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::TableCell 
+      expect(elements[0]).to be_instance_of PageObject::Elements::TableCell 
     end
 
     it "should find an image" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.image_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Image
+      expect(element).to be_instance_of PageObject::Elements::Image
     end
 
     it "should find all image elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.image_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Image
+      expect(elements[0]).to be_instance_of PageObject::Elements::Image
     end
     
     it "should find a form" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.form_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Form
+      expect(element).to be_instance_of PageObject::Elements::Form
     end
     
     it "should find all forms" do
-       selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+       expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
        elements = selenium_page_object.form_elements(:id => 'blah')
-       elements[0].should be_instance_of PageObject::Elements::Form
+       expect(elements[0]).to be_instance_of PageObject::Elements::Form
     end
 
     it "should find a list item" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.list_item_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::ListItem
+      expect(element).to be_instance_of PageObject::Elements::ListItem
     end
 
     it "should find all list items" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       element = selenium_page_object.list_item_elements(:id => 'blah')
-      element[0].should be_instance_of PageObject::Elements::ListItem 
+      expect(element[0]).to be_instance_of PageObject::Elements::ListItem 
     end
     
     it "should find an unordered list" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.unordered_list_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::UnorderedList
+      expect(element).to be_instance_of PageObject::Elements::UnorderedList
     end
 
     it "should find all unordered lists" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.unordered_list_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::UnorderedList 
+      expect(elements[0]).to be_instance_of PageObject::Elements::UnorderedList 
     end
     
     it "should find an ordered list" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.ordered_list_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::OrderedList
+      expect(element).to be_instance_of PageObject::Elements::OrderedList
     end
 
     it "should find all orderd list elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.ordered_list_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::OrderedList 
+      expect(elements[0]).to be_instance_of PageObject::Elements::OrderedList 
     end
     
     it "should find a h1 element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.h1_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
 
     it "should find all h1 elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, "blah").and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, "blah").and_return([selenium_browser])
       elements = selenium_page_object.h1_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Heading 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Heading 
     end
 
     it "should find a h2 element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.h2_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
 
     it "should find all h2 elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.h2_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Heading 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Heading 
     end
 
     it "should find a h3 element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.h3_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
 
     it "should find all h3 elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.h3_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Heading 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Heading 
     end
 
     it "should find a h4 element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.h4_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
 
     it "should find all h4 elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.h4_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Heading
+      expect(elements[0]).to be_instance_of PageObject::Elements::Heading
     end
 
     it "should find a h5 element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.h5_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
 
     it "should find all h5 elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.h5_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Heading 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Heading 
     end
 
     it "should find a h6 element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.h6_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
 
     it "should find all h6 elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.h6_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Heading 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Heading 
     end
 
     it "should find a paragraph element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.paragraph_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Paragraph
+      expect(element).to be_instance_of PageObject::Elements::Paragraph
     end
 
     it "should find all paragraph elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.paragraph_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Paragraph 
+      expect(elements[0]).to be_instance_of PageObject::Elements::Paragraph 
     end
 
     it "should find a label" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.label_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Label
+      expect(element).to be_instance_of PageObject::Elements::Label
     end
 
     it "should find all label elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.label_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Label
+      expect(elements[0]).to be_instance_of PageObject::Elements::Label
     end    
 
     it "should find a file field element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.file_field_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::FileField
+      expect(element).to be_instance_of PageObject::Elements::FileField
     end
 
         it "should find an area element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.area_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Area
+      expect(element).to be_instance_of PageObject::Elements::Area
     end
 
     it "should find an area element using a default identifier" do
-      selenium_browser.should_receive(:find_element).with(:xpath, '(.//area)[1]').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:xpath, '(.//area)[1]').and_return(selenium_browser)
       selenium_page_object.area_element
     end
 
     it "should find all area elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.area_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Area
+      expect(elements[0]).to be_instance_of PageObject::Elements::Area
     end
 
     it "should find all areas with no identifier" do
-      selenium_browser.should_receive(:find_elements).with(:tag_name, 'area').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:tag_name, 'area').and_return([selenium_browser])
       selenium_page_object.area_elements
     end
 
     it "should find a canvas element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.canvas_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Canvas
+      expect(element).to be_instance_of PageObject::Elements::Canvas
     end
 
     it "should find a canvas element using a default identifier" do
-      selenium_browser.should_receive(:find_element).with(:xpath, '(.//canvas)[1]').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:xpath, '(.//canvas)[1]').and_return(selenium_browser)
       selenium_page_object.canvas_element
     end
 
     it "should find all canvas elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.canvas_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Canvas
+      expect(elements[0]).to be_instance_of PageObject::Elements::Canvas
     end
 
     it "should find all canvases with no identifier" do
-      selenium_browser.should_receive(:find_elements).with(:tag_name, 'canvas').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:tag_name, 'canvas').and_return([selenium_browser])
       selenium_page_object.canvas_elements
     end
 
     it "should find an audio element" do
-      selenium_browser.should_receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
       element = selenium_page_object.audio_element(:id => 'blah')
-      element.should be_instance_of PageObject::Elements::Audio
+      expect(element).to be_instance_of PageObject::Elements::Audio
     end
 
     it "should find an audio element using a default identifier" do
-      selenium_browser.should_receive(:find_element).with(:xpath, '(.//audio)[1]').and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).with(:xpath, '(.//audio)[1]').and_return(selenium_browser)
       selenium_page_object.audio_element
     end
 
     it "should find all audio elements" do
-      selenium_browser.should_receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
       elements = selenium_page_object.audio_elements(:id => 'blah')
-      elements[0].should be_instance_of PageObject::Elements::Audio
+      expect(elements[0]).to be_instance_of PageObject::Elements::Audio
     end
 
     it "should find all audio elements with no identifier" do
-      selenium_browser.should_receive(:find_elements).with(:tag_name, 'audio').and_return([selenium_browser])
+      expect(selenium_browser).to receive(:find_elements).with(:tag_name, 'audio').and_return([selenium_browser])
       selenium_page_object.audio_elements
     end
+    it "should find a b element" do
+      expect(selenium_browser).to receive(:find_element).with(:id,'blah').and_return(selenium_browser)
+      element = selenium_page_object.b_element(:id => 'blah')
+      expect(element).to be_instance_of PageObject::Elements::Bold
+    end
+
+
+    it "should find all b elements" do
+      expect(selenium_browser).to receive(:find_elements).with(:id, 'blah').and_return([selenium_browser])
+      elements = selenium_page_object.b_elements(:id => 'blah')
+      expect(elements[0]).to be_instance_of PageObject::Elements::Bold
+    end
+
   end
 end