watir 6.5.0 → 6.6.0

data/spec/watirspec/elements/span_spec.rb

@@ -113,16 +113,18 @@ describe "Span" do
   end
 
   # Other
-  describe "#click" do
-    it "fires events" do
-      expect(browser.span(class: 'footer').text).to_not include('Javascript')
-      browser.span(class: 'footer').click
-      expect(browser.span(class: 'footer').text).to include('Javascript')
-    end
-
-    it "raises UnknownObjectException if the span doesn't exist" do
-      expect { browser.span(id: "no_such_id").click }.to raise_unknown_object_exception
-      expect { browser.span(title: "no_such_title").click }.to raise_unknown_object_exception
+    not_compliant_on :headless do
+    describe "#click" do
+      it "fires events" do
+        expect(browser.span(class: 'footer').text).to_not include('Javascript')
+        browser.span(class: 'footer').click
+        expect(browser.span(class: 'footer').text).to include('Javascript')
+      end
+
+      it "raises UnknownObjectException if the span doesn't exist" do
+        expect { browser.span(id: "no_such_id").click }.to raise_unknown_object_exception
+        expect { browser.span(title: "no_such_title").click }.to raise_unknown_object_exception
+      end
     end
   end
 

data/spec/watirspec/elements/table_spec.rb

@@ -41,17 +41,19 @@ describe "Table" do
   end
 
   # Other
-  describe "#strings" do
-    it "returns a two-dimensional array representation of the table" do
-      expect(browser.table(id: 'inner').strings).to eq [
-        ["Table 2, Row 1, Cell 1",
-         "Table 2, Row 1, Cell 2"]
-      ]
-      expect(browser.table(id: 'outer').strings).to eq [
-        ["Table 1, Row 1, Cell 1", "Table 1, Row 1, Cell 2"],
-        ["Table 1, Row 2, Cell 1", "Table 1, Row 2, Cell 2\nTable 2, Row 1, Cell 1 Table 2, Row 1, Cell 2"],
-        ["Table 1, Row 3, Cell 1", "Table 1, Row 3, Cell 2"]
-     ]
+  bug "Safari does not strip text", :safari do
+    describe "#strings" do
+      it "returns a two-dimensional array representation of the table" do
+        expect(browser.table(id: 'inner').strings).to eq [
+          ["Table 2, Row 1, Cell 1",
+           "Table 2, Row 1, Cell 2"]
+        ]
+        expect(browser.table(id: 'outer').strings).to eq [
+          ["Table 1, Row 1, Cell 1", "Table 1, Row 1, Cell 2"],
+          ["Table 1, Row 2, Cell 1", "Table 1, Row 2, Cell 2\nTable 2, Row 1, Cell 1 Table 2, Row 1, Cell 2"],
+          ["Table 1, Row 3, Cell 1", "Table 1, Row 3, Cell 2"]
+       ]
+      end
     end
   end
 

data/spec/watirspec/elements/tbody_spec.rb

@@ -50,17 +50,19 @@ describe "TableBody" do
     end
   end
 
-  describe "#[]" do
-    it "returns the row at the given index (page context)" do
-      expect(browser.tbody(id: 'first')[0].text).to eq 'March 2008'
-      expect(browser.tbody(id: 'first')[1][0].text).to eq 'Gregory House'
-      expect(browser.tbody(id: 'first')[2][0].text).to eq 'Hugh Laurie'
-    end
-
-    it "returns the row at the given index (table context)" do
-      expect(browser.table(index: 0).tbody(id: 'first')[0].text).to eq 'March 2008'
-      expect(browser.table(index: 0).tbody(id: 'first')[1][0].text).to eq 'Gregory House'
-      expect(browser.table(index: 0).tbody(id: 'first')[2][0].text).to eq 'Hugh Laurie'
+  bug "Safari does not strip text", :safari do
+    describe "#[]" do
+      it "returns the row at the given index (page context)" do
+        expect(browser.tbody(id: 'first')[0].text).to eq 'March 2008'
+        expect(browser.tbody(id: 'first')[1][0].text).to eq 'Gregory House'
+        expect(browser.tbody(id: 'first')[2][0].text).to eq 'Hugh Laurie'
+      end
+
+      it "returns the row at the given index (table context)" do
+        expect(browser.table(index: 0).tbody(id: 'first')[0].text).to eq 'March 2008'
+        expect(browser.table(index: 0).tbody(id: 'first')[1][0].text).to eq 'Gregory House'
+        expect(browser.table(index: 0).tbody(id: 'first')[2][0].text).to eq 'Hugh Laurie'
+      end
     end
   end
 

data/spec/watirspec/elements/td_spec.rb

@@ -47,10 +47,12 @@ describe "TableCell" do
   end
 
   # Attribute methods
-  describe "#text" do
-    it "returns the text inside the table cell" do
-      expect(browser.td(id: 't1_r2_c1').text).to eq 'Table 1, Row 2, Cell 1'
-      expect(browser.td(id: 't2_r1_c1').text).to eq 'Table 2, Row 1, Cell 1'
+  bug "Safari does not strip text", :safari do
+    describe "#text" do
+      it "returns the text inside the table cell" do
+        expect(browser.td(id: 't1_r2_c1').text).to eq 'Table 1, Row 2, Cell 1'
+        expect(browser.td(id: 't2_r1_c1').text).to eq 'Table 2, Row 1, Cell 1'
+      end
     end
   end
 

data/spec/watirspec/elements/text_field_spec.rb

@@ -204,27 +204,29 @@ describe "TextField" do
   end
 
   # Manipulation methods
-  describe "#append" do
-    it "appends the text to the text field" do
-      browser.text_field(name: "new_user_occupation").append(" Append This")
-      expect(browser.text_field(name: "new_user_occupation").value).to eq "Developer Append This"
-    end
+  not_compliant_on :safari do
+    describe "#append" do
+      it "appends the text to the text field" do
+        browser.text_field(name: "new_user_occupation").append(" Append This")
+        expect(browser.text_field(name: "new_user_occupation").value).to eq "Developer Append This"
+      end
 
-    it "appends multi-byte characters" do
-      browser.text_field(name: "new_user_occupation").append(" ijij")
-      expect(browser.text_field(name: "new_user_occupation").value).to eq "Developer ijij"
-    end
+      it "appends multi-byte characters" do
+        browser.text_field(name: "new_user_occupation").append(" ijij")
+        expect(browser.text_field(name: "new_user_occupation").value).to eq "Developer ijij"
+      end
 
-    it "raises ObjectReadOnlyException if the object is read only" do
-      expect { browser.text_field(id: "new_user_code").append("Append This") }.to raise_object_read_only_exception
-    end
+      it "raises ObjectReadOnlyException if the object is read only" do
+        expect { browser.text_field(id: "new_user_code").append("Append This") }.to raise_object_read_only_exception
+      end
 
-    it "raises ObjectDisabledException if the object is disabled" do
-      expect { browser.text_field(name: "new_user_species").append("Append This") }.to raise_object_disabled_exception
-    end
+      it "raises ObjectDisabledException if the object is disabled" do
+        expect { browser.text_field(name: "new_user_species").append("Append This") }.to raise_object_disabled_exception
+      end
 
-    it "raises UnknownObjectException if the object doesn't exist" do
-      expect { browser.text_field(name: "no_such_name").append("Append This") }.to raise_unknown_object_exception
+      it "raises UnknownObjectException if the object doesn't exist" do
+        expect { browser.text_field(name: "no_such_name").append("Append This") }.to raise_unknown_object_exception
+      end
     end
   end
 

data/spec/watirspec/elements/tr_spec.rb

@@ -36,19 +36,23 @@ describe "TableRow" do
 
   describe "#click" do
     bug "http://github.com/watir/watir/issues/issue/32", :internet_explorer, :chrome do
-      it "fires the row's onclick event" do
-        browser.tr(id: 'inner_first').click
-        expect(messages).to include('tr')
+      not_compliant_on :firefox do
+        it "fires the row's onclick event" do
+          browser.tr(id: 'inner_first').click
+          expect(messages).to include('tr')
+        end
       end
     end
   end
 
-  describe "#[]" do
-    let(:table) { browser.table(id: 'outer') }
+  bug "Safari does not strip text", :safari do
+    describe "#[]" do
+      let(:table) { browser.table(id: 'outer') }
 
-    it "returns the nth cell of the row" do
-      expect(table[0][0].text).to eq "Table 1, Row 1, Cell 1"
-      expect(table[2][0].text).to eq "Table 1, Row 3, Cell 1"
+      it "returns the nth cell of the row" do
+        expect(table[0][0].text).to eq "Table 1, Row 1, Cell 1"
+        expect(table[2][0].text).to eq "Table 1, Row 3, Cell 1"
+      end
     end
   end
 

data/spec/watirspec/html/javascript/helpers.js

@@ -2,11 +2,11 @@ var WatirSpec = function() {
     
   return {
     addMessage: function(string) {
-        var text = document.createTextNode(string)
+        var text = document.createTextNode(string);
         var message = document.createElement('div');
         var messages = document.getElementById('messages');
 
-        message.appendChild(text)
+        message.appendChild(text);
         messages.appendChild(message);
     }
   };

data/spec/watirspec/html/nested_elements.html

@@ -8,7 +8,7 @@
 <body>
 <span id="grandparent_span">
         <div id="grandparent">
-            <span id="parent_span">
+            <span class="parent" id="parent_span">
                 <div id="parent">
                     <div id="first_sibling">
                         <span id="child_span">
@@ -22,10 +22,10 @@
                             <div id="youngest_child"></div>
                         </span>
                     </div>
-                    <span id="between_siblings1"></span>
-                    <div id="second_sibling"></div>
-                    <span id="between_siblings2"></span>
-                    <div id="third_sibling"></div>
+                    <span class="a" id="between_siblings1"></span>
+                    <div class="b" id="second_sibling"></div>
+                    <span class="a" id="between_siblings2"></span>
+                    <div class="a b" id="third_sibling">text</div>
                 </div>
             </span>
         </div>

data/spec/watirspec/relaxed_locate_spec.rb

@@ -26,10 +26,10 @@ describe 'Watir#relaxed_locate?' do
       context 'when acting on an element that is already present' do
         it 'does not wait' do
           begin
-            Watir.default_timeout = 2
+            Watir.default_timeout = 5
             start_time = ::Time.now
             expect { browser.link.click }.to_not raise_exception
-            expect(::Time.now - start_time).to be < 2
+            expect(::Time.now - start_time).to be < 5
           ensure
             Watir.default_timeout = 30
           end
@@ -37,15 +37,17 @@ describe 'Watir#relaxed_locate?' do
       end
 
       context 'when acting on an element that eventually becomes present' do
-        it 'waits until present and then takes action' do
-          begin
-            Watir.default_timeout = 3
-            start_time = ::Time.now
-            browser.a(id: 'show_bar').click
-            expect { browser.div(id: 'bar').click }.to_not raise_exception
-            expect(::Time.now - start_time).to be < 3
-          ensure
-            Watir.default_timeout = 30
+        bug "https://github.com/SeleniumHQ/selenium/issues/4380", %i{remote firefox} do
+          it 'waits until present and then takes action' do
+            begin
+              Watir.default_timeout = 3
+              start_time = ::Time.now
+              browser.a(id: 'show_bar').click
+              expect { browser.div(id: 'bar').click }.to_not raise_exception
+              expect(::Time.now - start_time).to be < 3
+            ensure
+              Watir.default_timeout = 30
+            end
           end
         end
       end
@@ -92,14 +94,6 @@ describe 'Watir#relaxed_locate?' do
           expect(::Time.now - start_time).to be < 1
         end
       end
-
-      it 'receives a warning for using #when_present' do
-        message = /#when_present has been deprecated and is unlikely to be needed; replace this with #wait_until_present if a wait is still needed/
-        browser.a(id: 'show_bar').click
-        expect do
-          browser.div(id: 'bar').when_present.click
-        end.to output(message).to_stderr
-      end
     end
   end
 end

data/spec/watirspec/wait_spec.rb

@@ -1,398 +1,376 @@
 require "watirspec_helper"
 
-not_compliant_on :safari do
-  describe Watir::Wait do
-    describe "#until" do
-      it "waits until the block returns true" do
-        Watir::Wait.until(timeout: 0.5) { @result = true }
-        expect(@result).to be true
-      end
+describe Watir::Wait do
+  describe "#until" do
+    it "waits until the block returns true" do
+      Watir::Wait.until(timeout: 0.5) { @result = true }
+      expect(@result).to be true
+    end
 
-      it "executes block if timeout is zero" do
-        Watir::Wait.until(timeout: 0) { @result = true }
-        expect(@result).to be true
-      end
+    it "executes block if timeout is zero" do
+      Watir::Wait.until(timeout: 0) { @result = true }
+      expect(@result).to be true
+    end
 
-      it "times out" do
-        expect { Watir::Wait.until(timeout: 0.5) { false } }.to raise_error(Watir::Wait::TimeoutError)
-      end
+    it "times out" do
+      expect { Watir::Wait.until(timeout: 0.5) { false } }.to raise_error(Watir::Wait::TimeoutError)
+    end
 
-      it "times out with a custom message" do
-        expect {
-          Watir::Wait.until(timeout: 0.5, message: "oops") { false }
-        }.to raise_error(Watir::Wait::TimeoutError, "timed out after 0.5 seconds, oops")
-      end
+    it "times out with a custom message" do
+      expect {
+        Watir::Wait.until(timeout: 0.5, message: "oops") { false }
+      }.to raise_error(Watir::Wait::TimeoutError, "timed out after 0.5 seconds, oops")
+    end
 
-      it "uses provided interval" do
-        begin
-          Watir::Wait.until(timeout: 0.4, interval: 0.2) do
-            @result = @result.nil? ? 1 : @result + 1
-            false
-          end
-        rescue Watir::Wait::TimeoutError
+    it "uses provided interval" do
+      begin
+        Watir::Wait.until(timeout: 0.4, interval: 0.2) do
+          @result = @result.nil? ? 1 : @result + 1
+          false
         end
-        expect(@result).to eq 2
-      end
-
-      it "uses timer for waiting" do
-        timer = Watir::Wait.timer
-        expect(timer).to receive(:wait).with(0.5).and_call_original
-        Watir::Wait.until(timeout: 0.5) { true }
+      rescue Watir::Wait::TimeoutError
       end
+      expect(@result).to eq 2
+    end
 
-      it "ordered pairs are deprecated" do
-        message = /Instead of passing arguments into Wait#until method, use keywords/
-        expect { Watir::Wait.until(0) { true } }.to output(message).to_stderr
-      end
+    it "uses timer for waiting" do
+      timer = Watir::Wait.timer
+      expect(timer).to receive(:wait).with(0.5).and_call_original
+      Watir::Wait.until(timeout: 0.5) { true }
     end
+  end
 
-    describe "#while" do
-      it "waits while the block returns true" do
-        expect(Watir::Wait.while(timeout: 0.5) { false }).to be_nil
-      end
+  describe "#while" do
+    it "waits while the block returns true" do
+      expect(Watir::Wait.while(timeout: 0.5) { false }).to be_nil
+    end
 
-      it "executes block if timeout is zero" do
-        expect(Watir::Wait.while(timeout: 0) { false }).to be_nil
-      end
+    it "executes block if timeout is zero" do
+      expect(Watir::Wait.while(timeout: 0) { false }).to be_nil
+    end
 
-      it "times out" do
-        expect { Watir::Wait.while(timeout: 0.5) { true } }.to raise_error(Watir::Wait::TimeoutError)
-      end
+    it "times out" do
+      expect { Watir::Wait.while(timeout: 0.5) { true } }.to raise_error(Watir::Wait::TimeoutError)
+    end
 
-      it "times out with a custom message" do
-        expect {
-          Watir::Wait.while(timeout: 0.5, message: "oops") { true }
-        }.to raise_error(Watir::Wait::TimeoutError, "timed out after 0.5 seconds, oops")
-      end
+    it "times out with a custom message" do
+      expect {
+        Watir::Wait.while(timeout: 0.5, message: "oops") { true }
+      }.to raise_error(Watir::Wait::TimeoutError, "timed out after 0.5 seconds, oops")
+    end
 
-      it "uses provided interval" do
-        begin
-          Watir::Wait.while(timeout: 0.4, interval: 0.2) do
-            @result = @result.nil? ? 1 : @result + 1
-            true
-          end
-        rescue Watir::Wait::TimeoutError
+    it "uses provided interval" do
+      begin
+        Watir::Wait.while(timeout: 0.4, interval: 0.2) do
+          @result = @result.nil? ? 1 : @result + 1
+          true
         end
-        expect(@result).to eq 2
-      end
-
-      it "uses timer for waiting" do
-        timer = Watir::Wait.timer
-        expect(timer).to receive(:wait).with(0.5).and_call_original
-        Watir::Wait.while(timeout: 0.5) { false }
+      rescue Watir::Wait::TimeoutError
       end
+      expect(@result).to eq 2
+    end
 
-      it "ordered pairs are deprecated" do
-        message = /Instead of passing arguments into Wait#while method, use keywords/
-        expect { Watir::Wait.while(0) { false } }.to output(message).to_stderr
-      end
+    it "uses timer for waiting" do
+      timer = Watir::Wait.timer
+      expect(timer).to receive(:wait).with(0.5).and_call_original
+      Watir::Wait.while(timeout: 0.5) { false }
     end
+  end
 
-    describe "#timer" do
-      it "returns default timer" do
-        expect(Watir::Wait.timer).to be_a(Watir::Wait::Timer)
-      end
+  describe "#timer" do
+    it "returns default timer" do
+      expect(Watir::Wait.timer).to be_a(Watir::Wait::Timer)
     end
+  end
 
-    describe "#timer=" do
-      after { Watir::Wait.timer = nil }
+  describe "#timer=" do
+    after { Watir::Wait.timer = nil }
 
-      it "changes default timer" do
-        timer = Class.new
-        Watir::Wait.timer = timer
-        expect(Watir::Wait.timer).to eq(timer)
-      end
+    it "changes default timer" do
+      timer = Class.new
+      Watir::Wait.timer = timer
+      expect(Watir::Wait.timer).to eq(timer)
     end
   end
+end
 
-  describe Watir::Element do
-    before do
-      browser.goto WatirSpec.url_for("wait.html")
-    end
+describe Watir::Element do
+  before do
+    browser.goto WatirSpec.url_for("wait.html")
+  end
 
-    # TODO: This is deprecated; remove in future version
-    not_compliant_on :relaxed_locate do
-      describe "#when_present" do
-        it "invokes subsequent method calls when the element becomes present" do
-          browser.a(id: 'show_bar').click
+  # TODO: This is deprecated; remove in future version
+  not_compliant_on :relaxed_locate do
+    describe "#when_present" do
+      it "invokes subsequent method calls when the element becomes present" do
+        browser.a(id: 'show_bar').click
 
-          bar = browser.div(id: 'bar')
-          bar.when_present(2).click
-          expect(bar.text).to eq "changed"
-        end
+        bar = browser.div(id: 'bar')
+        bar.when_present(2).click
+        expect(bar.text).to eq "changed"
+      end
 
-        it "times out when given a block" do
-          expect { browser.div(id: 'bar').when_present(1) {} }.to raise_error(Watir::Wait::TimeoutError)
-        end
+      it "times out when given a block" do
+        expect { browser.div(id: 'bar').when_present(1) {} }.to raise_error(Watir::Wait::TimeoutError)
+      end
 
-        it "times out when not given a block" do
-          message = /^timed out after 1 seconds, waiting for (\{:id=>"bar", :tag_name=>"div"\}|\{:tag_name=>"div", :id=>"bar"\}) to become present$/
-          expect { browser.div(id: 'bar').when_present(1).click }.to raise_error(Watir::Wait::TimeoutError, message)
-        end
+      it "times out when not given a block" do
+        message = /^timed out after 1 seconds, waiting for (\{:id=>"bar", :tag_name=>"div"\}|\{:tag_name=>"div", :id=>"bar"\}) to become present$/
+        expect { browser.div(id: 'bar').when_present(1).click }.to raise_error(Watir::Wait::TimeoutError, message)
+      end
 
-        it "responds to Element methods" do
-          decorator = browser.div.when_present
+      it "responds to Element methods" do
+        decorator = browser.div.when_present
 
-          expect(decorator).to respond_to(:exist?)
-          expect(decorator).to respond_to(:present?)
-          expect(decorator).to respond_to(:click)
-        end
+        expect(decorator).to respond_to(:exist?)
+        expect(decorator).to respond_to(:present?)
+        expect(decorator).to respond_to(:click)
+      end
 
-        it "delegates present? to element" do
-          Object.class_eval do
-            def present?
-              false
-            end
+      it "delegates present? to element" do
+        Object.class_eval do
+          def present?
+            false
           end
-          element = browser.a(id: "show_bar").when_present(1)
-          expect(element).to be_present
         end
+        element = browser.a(id: "show_bar").when_present(1)
+        expect(element).to be_present
+      end
 
-        it "processes before calling present?" do
-          browser.a(id: 'show_bar').click
-          expect(browser.div(id: 'bar').when_present.present?).to be true
-        end
+      it "processes before calling present?" do
+        browser.a(id: 'show_bar').click
+        expect(browser.div(id: 'bar').when_present.present?).to be true
       end
     end
+  end
 
-    not_compliant_on :relaxed_locate do
-      describe "#wait_until &:enabled?" do
-        it "invokes subsequent method calls when the element becomes enabled" do
-          browser.a(id: 'enable_btn').click
+  not_compliant_on :relaxed_locate do
+    describe "#wait_until &:enabled?" do
+      it "invokes subsequent method calls when the element becomes enabled" do
+        browser.a(id: 'enable_btn').click
 
-          btn = browser.button(id: 'btn')
-          btn.wait_until(timeout: 2, &:enabled?).click
-          Watir::Wait.while { btn.enabled? }
-          expect(btn.disabled?).to be true
-        end
+        btn = browser.button(id: 'btn')
+        btn.wait_until(timeout: 2, &:enabled?).click
+        Watir::Wait.while { btn.enabled? }
+        expect(btn.disabled?).to be true
+      end
 
-        it "times out" do
-          error = Watir::Wait::TimeoutError
-          inspected = '#<Watir::Button: located: false; {:id=>"btn", :tag_name=>"button"}>'
-          message = "timed out after 1 seconds, waiting for true condition on #{inspected}"
-          element = browser.button(id: 'btn')
-          expect { element.wait_until(timeout: 1, &:enabled?).click }.to raise_error(error, message)
-        end
+      it "times out" do
+        error = Watir::Wait::TimeoutError
+        inspected = '#<Watir::Button: located: false; {:id=>"btn", :tag_name=>"button"}>'
+        message = "timed out after 1 seconds, waiting for true condition on #{inspected}"
+        element = browser.button(id: 'btn')
+        expect { element.wait_until(timeout: 1, &:enabled?).click }.to raise_error(error, message)
+      end
 
-        it "responds to Element methods" do
-          element = browser.button.wait_until { true }
+      it "responds to Element methods" do
+        element = browser.button.wait_until { true }
 
-          expect(element).to respond_to(:exist?)
-          expect(element).to respond_to(:present?)
-          expect(element).to respond_to(:click)
-        end
+        expect(element).to respond_to(:exist?)
+        expect(element).to respond_to(:present?)
+        expect(element).to respond_to(:click)
+      end
 
-        it "can be chained with #wait_until &:present?" do
-          browser.a(id: 'show_and_enable_btn').click
-          browser.button(id: 'btn2').wait_until(&:present?).wait_until(&:enabled?).click
+      it "can be chained with #wait_until &:present?" do
+        browser.a(id: 'show_and_enable_btn').click
+        browser.button(id: 'btn2').wait_until(&:present?).wait_until(&:enabled?).click
 
-          expect(browser.button(id: 'btn2')).to exist
-          expect(browser.button(id: 'btn2')).to be_enabled
-        end
+        expect(browser.button(id: 'btn2')).to exist
+        expect(browser.button(id: 'btn2')).to be_enabled
       end
     end
+  end
 
-    describe "#wait_until_present" do
-      it "waits until the element appears" do
-        browser.a(id: 'show_bar').click
-        expect { browser.div(id: 'bar').wait_until_present(timeout: 5) }.to_not raise_exception
-      end
-
-      it "times out if the element doesn't appear" do
-        inspected = '#<Watir::Div: located: false; {:id=>"bar", :tag_name=>"div"}>'
-        error = Watir::Wait::TimeoutError
-        message = "timed out after 1 seconds, waiting for true condition on #{inspected}"
-
-        expect { browser.div(id: 'bar').wait_until_present(timeout: 1) }.to raise_error(error, message)
-      end
+  describe "#wait_until_present" do
+    it "waits until the element appears" do
+      browser.a(id: 'show_bar').click
+      expect { browser.div(id: 'bar').wait_until_present(timeout: 5) }.to_not raise_exception
+    end
 
-      it "uses provided interval" do
-        element = browser.div(id: 'bar')
-        expect(element).to receive(:present?).twice
+    it "times out if the element doesn't appear" do
+      inspected = '#<Watir::Div: located: false; {:id=>"bar", :tag_name=>"div"}>'
+      error = Watir::Wait::TimeoutError
+      message = "timed out after 1 seconds, waiting for true condition on #{inspected}"
 
-        begin
-          element.wait_until_present(timeout: 0.4, interval: 0.2)
-        rescue Watir::Wait::TimeoutError
-        end
-      end
+      expect { browser.div(id: 'bar').wait_until_present(timeout: 1) }.to raise_error(error, message)
+    end
 
-      it "ordered pairs are deprecated" do
-        browser.a(id: 'show_bar').click
-        message = /Instead of passing arguments into #wait_until_present method, use keywords/
-        expect { browser.div(id: 'bar').wait_until_present(5) }.to output(message).to_stderr
-      end
+    it "uses provided interval" do
+      element = browser.div(id: 'bar')
+      expect(element).to receive(:present?).twice
 
-      it 'waits to select an option' do
-        browser.a(id: 'add_select').click
-        select_list = browser.select_list(id: 'languages')
-        Watir.default_timeout = 1
-        begin
-          start_time = ::Time.now
-          expect { select_list.select('No') }.to raise_error Watir::Exception::NoValueFoundException
-          expect(::Time.now - start_time).to be > 1
-        ensure
-          Watir.default_timeout = 30
-        end
+      begin
+        element.wait_until_present(timeout: 0.4, interval: 0.2)
+      rescue Watir::Wait::TimeoutError
       end
     end
 
-    describe "#wait_while_present" do
-      it "waits until the element disappears" do
-        browser.a(id: 'hide_foo').click
-        expect { browser.div(id: 'foo').wait_while_present(timeout: 2) }.to_not raise_exception
+    it 'waits to select an option' do
+      browser.a(id: 'add_select').click
+      select_list = browser.select_list(id: 'languages')
+      Watir.default_timeout = 1
+      begin
+        start_time = ::Time.now
+        expect { select_list.select('No') }.to raise_error Watir::Exception::NoValueFoundException
+        expect(::Time.now - start_time).to be > 1
+      ensure
+        Watir.default_timeout = 30
       end
+    end
+  end
 
-      it "times out if the element doesn't disappear" do
-        error = Watir::Wait::TimeoutError
-        inspected = '#<Watir::Div: located: false; {:id=>"foo", :tag_name=>"div"}>'
-        message = "timed out after 1 seconds, waiting for false condition on #{inspected}"
-        expect { browser.div(id: 'foo').wait_while_present(timeout: 1) }.to raise_error(error, message)
-      end
+  describe "#wait_while_present" do
+    it "waits until the element disappears" do
+      browser.a(id: 'hide_foo').click
+      expect { browser.div(id: 'foo').wait_while_present(timeout: 2) }.to_not raise_exception
+    end
 
-      it "uses provided interval" do
-        element = browser.div(id: 'foo')
-        expect(element).to receive(:present?).twice
+    it "times out if the element doesn't disappear" do
+      error = Watir::Wait::TimeoutError
+      inspected = '#<Watir::Div: located: false; {:id=>"foo", :tag_name=>"div"}>'
+      message = "timed out after 1 seconds, waiting for false condition on #{inspected}"
+      expect { browser.div(id: 'foo').wait_while_present(timeout: 1) }.to raise_error(error, message)
+    end
 
-        begin
-          element.wait_until_present(timeout: 0.4, interval: 0.2)
-        rescue Watir::Wait::TimeoutError
-        end
-      end
+    it "uses provided interval" do
+      element = browser.div(id: 'foo')
+      expect(element).to receive(:present?).twice
 
-      it "ordered pairs are deprecated" do
-        browser.a(id: 'hide_foo').click
-        message = /Instead of passing arguments into #wait_while_present method, use keywords/
-        expect { browser.div(id: 'foo').wait_while_present(5) }.to output(message).to_stderr
+      begin
+        element.wait_until_present(timeout: 0.4, interval: 0.2)
+      rescue Watir::Wait::TimeoutError
       end
+    end
 
-      it "does not error when element goes stale" do
-        element = browser.div(id: 'foo')
+    it "does not error when element goes stale" do
+      element = browser.div(id: 'foo')
 
-        allow(element).to receive(:stale?).and_return(false, true)
-        allow(element.wd).to receive(:displayed?).and_raise(Selenium::WebDriver::Error::StaleElementReferenceError)
+      allow(element).to receive(:stale?).and_return(false, true)
+      allow(element.wd).to receive(:displayed?).and_raise(Selenium::WebDriver::Error::StaleElementReferenceError)
 
-        browser.a(id: 'hide_foo').click
-        expect { element.wait_while_present(timeout: 1) }.to_not raise_exception
-      end
+      browser.a(id: 'hide_foo').click
+      expect { element.wait_while_present(timeout: 1) }.to_not raise_exception
+    end
 
-      it "waits until the selector no longer matches" do
-        Watir.default_timeout = 1
-        element = browser.link(name: 'add_select').wait_until(&:exists?)
-        begin
-          start_time = ::Time.now
-          browser.link(id: 'change_select').click
-          expect { element.wait_while_present }.not_to raise_error
-        ensure
-          Watir.default_timeout = 30
-        end
+    it "waits until the selector no longer matches" do
+      Watir.default_timeout = 1
+      element = browser.link(name: 'add_select').wait_until(&:exists?)
+      begin
+        start_time = ::Time.now
+        browser.link(id: 'change_select').click
+        expect { element.wait_while_present }.not_to raise_error
+      ensure
+        Watir.default_timeout = 30
       end
     end
+  end
 
-    describe "#wait_until" do
-      it "returns element for additional actions" do
-        element = browser.div(id: 'foo')
-        expect(element.wait_until(&:exist?)).to eq element
-      end
+  describe "#wait_until" do
+    it "returns element for additional actions" do
+      element = browser.div(id: 'foo')
+      expect(element.wait_until(&:exist?)).to eq element
+    end
 
-      it "accepts self in block" do
-        element = browser.div(id: 'bar')
-        browser.a(id: 'show_bar').click
-        expect { element.wait_until { |el| el.text == 'bar' } }.to_not raise_exception
-      end
+    it "accepts self in block" do
+      element = browser.div(id: 'bar')
+      browser.a(id: 'show_bar').click
+      expect { element.wait_until { |el| el.text == 'bar' } }.to_not raise_exception
+    end
 
-      it "accepts any values in block" do
-        element = browser.div(id: 'bar')
-        expect { element.wait_until { true } }.to_not raise_exception
-      end
+    it "accepts any values in block" do
+      element = browser.div(id: 'bar')
+      expect { element.wait_until { true } }.to_not raise_exception
+    end
 
-      it "accepts just a timeout parameter" do
-        element = browser.div(id: 'bar')
-        expect { element.wait_until(timeout: 0) { true } }.to_not raise_exception
-      end
+    it "accepts just a timeout parameter" do
+      element = browser.div(id: 'bar')
+      expect { element.wait_until(timeout: 0) { true } }.to_not raise_exception
+    end
 
-      it "accepts just a message parameter" do
-        element = browser.div(id: 'bar')
-        expect { element.wait_until(message: 'no') { true } }.to_not raise_exception
-      end
+    it "accepts just a message parameter" do
+      element = browser.div(id: 'bar')
+      expect { element.wait_until(message: 'no') { true } }.to_not raise_exception
+    end
 
-      it "accepts just an interval parameter" do
-        element = browser.div(id: 'bar')
-        expect { element.wait_until(interval: 0.1) { true } }.to_not raise_exception
-      end
+    it "accepts just an interval parameter" do
+      element = browser.div(id: 'bar')
+      expect { element.wait_until(interval: 0.1) { true } }.to_not raise_exception
     end
+  end
 
-    describe "#wait_while" do
-      it "returns element for additional actions" do
-        element = browser.div(id: 'foo')
-        browser.a(id: 'hide_foo').click
-        expect(element.wait_while(&:present?)).to eq element
-      end
+  describe "#wait_while" do
+    it "returns element for additional actions" do
+      element = browser.div(id: 'foo')
+      browser.a(id: 'hide_foo').click
+      expect(element.wait_while(&:present?)).to eq element
+    end
 
+    not_compliant_on :safari do
       it "accepts self in block" do
         element = browser.div(id: 'foo')
         browser.a(id: 'hide_foo').click
         expect { element.wait_while { |el| el.text == 'foo' } }.to_not raise_exception
       end
+    end
 
-      it "accepts any values in block" do
-        element = browser.div(id: 'foo')
-        expect { element.wait_while { false } }.to_not raise_exception
-      end
+    it "accepts any values in block" do
+      element = browser.div(id: 'foo')
+      expect { element.wait_while { false } }.to_not raise_exception
+    end
 
-      it "accepts just a timeout parameter" do
-        element = browser.div(id: 'foo')
-        expect { element.wait_while(timeout: 0) { false } }.to_not raise_exception
-      end
+    it "accepts just a timeout parameter" do
+      element = browser.div(id: 'foo')
+      expect { element.wait_while(timeout: 0) { false } }.to_not raise_exception
+    end
 
-      it "accepts just a message parameter" do
-        element = browser.div(id: 'foo')
-        expect { element.wait_while(message: 'no') { false } }.to_not raise_exception
-      end
+    it "accepts just a message parameter" do
+      element = browser.div(id: 'foo')
+      expect { element.wait_while(message: 'no') { false } }.to_not raise_exception
+    end
 
-      it "accepts just an interval parameter" do
-        element = browser.div(id: 'foo')
-        expect { element.wait_while(interval: 0.1) { false } }.to_not raise_exception
-      end
+    it "accepts just an interval parameter" do
+      element = browser.div(id: 'foo')
+      expect { element.wait_while(interval: 0.1) { false } }.to_not raise_exception
     end
   end
+end
 
-  describe Watir do
-    describe "#default_timeout" do
-      before do
-        Watir.default_timeout = 1
+describe Watir do
+  describe "#default_timeout" do
+    before do
+      Watir.default_timeout = 1
 
-        browser.goto WatirSpec.url_for("wait.html")
-      end
+      browser.goto WatirSpec.url_for("wait.html")
+    end
 
-      after do
-        # Reset the default timeout
-        Watir.default_timeout = 30
-      end
+    after do
+      # Reset the default timeout
+      Watir.default_timeout = 30
+    end
 
-      context "when no timeout is specified" do
-        it "is used by Wait#until" do
-          expect {
-            Watir::Wait.until { false }
-          }.to raise_error(Watir::Wait::TimeoutError)
-        end
+    context "when no timeout is specified" do
+      it "is used by Wait#until" do
+        expect {
+          Watir::Wait.until { false }
+        }.to raise_error(Watir::Wait::TimeoutError)
+      end
 
-        it "is used by Wait#while" do
-          expect {
-            Watir::Wait.while { true }
-          }.to raise_error(Watir::Wait::TimeoutError)
-        end
+      it "is used by Wait#while" do
+        expect {
+          Watir::Wait.while { true }
+        }.to raise_error(Watir::Wait::TimeoutError)
+      end
 
-        it "is used by Element#wait_until_present" do
-          expect {
-            browser.div(id: 'bar').wait_until_present
-          }.to raise_error(Watir::Wait::TimeoutError)
-        end
+      it "is used by Element#wait_until_present" do
+        expect {
+          browser.div(id: 'bar').wait_until_present
+        }.to raise_error(Watir::Wait::TimeoutError)
+      end
 
-        it "is used by Element#wait_while_present" do
-          expect {
-            browser.div(id: 'foo').wait_while_present
-          }.to raise_error(Watir::Wait::TimeoutError)
-        end
+      it "is used by Element#wait_while_present" do
+        expect {
+          browser.div(id: 'foo').wait_while_present
+        }.to raise_error(Watir::Wait::TimeoutError)
       end
     end
   end