watir 6.13.0 → 6.14.0

data/spec/unit/logger_spec.rb

@@ -44,8 +44,9 @@ module Watir
     end
 
     it 'allows to selectively ignore deprecations with Strings' do
-      Watir.logger.ignore("old deprecated")
-      expect { Watir.logger.deprecate('#old', '#new', ids: ['old deprecated']) }.to_not output.to_stdout_from_any_process
+      Watir.logger.ignore('old deprecated')
+      expect { Watir.logger.deprecate('#old', '#new', ids: ['old deprecated']) }
+        .to_not output.to_stdout_from_any_process
     end
 
     it 'allows to selectively ignore deprecations with Symbols' do
@@ -69,10 +70,9 @@ module Watir
     end
 
     it 'allows to ignore multiple ids' do
-      Watir.logger.ignore([:foo, :bar])
+      Watir.logger.ignore(%i[foo bar])
       expect { Watir.logger.warn('warning', ids: [:foo]) }.to_not output.to_stdout_from_any_process
       expect { Watir.logger.warn('warning', ids: [:bar]) }.to_not output.to_stdout_from_any_process
     end
-
   end
 end

data/spec/unit/unit_helper.rb

@@ -2,5 +2,3 @@ require 'watirspec'
 WatirSpec::Runner.execute = false
 
 require_relative '../watirspec_helper'
-
-

data/spec/unit/wait_spec.rb

@@ -1,92 +1,90 @@
 require_relative 'unit_helper'
 
 describe Watir::Wait do
-  describe "#until" do
-    it "waits until the block returns true" 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
+    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
+    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
+    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")
+        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
+    it 'uses provided interval' do
+      expect {
         Watir::Wait.until(timeout: 0.4, interval: 0.2) do
           @result = @result.nil? ? 1 : @result + 1
           false
         end
-      rescue Watir::Wait::TimeoutError
-      end
+      }.to raise_timeout_exception
       expect(@result).to eq 2
     end
 
-    it "uses timer for waiting" do
+    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
+  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
+    it 'executes block if timeout is zero' do
       expect(Watir::Wait.while(timeout: 0) { false }).to be_nil
     end
 
-    it "times out" do
+    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
+    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")
+        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
+    it 'uses provided interval' do
+      expect {
         Watir::Wait.while(timeout: 0.4, interval: 0.2) do
           @result = @result.nil? ? 1 : @result + 1
           true
         end
-      rescue Watir::Wait::TimeoutError
-      end
+      }.to raise_timeout_exception
       expect(@result).to eq 2
     end
 
-    it "uses timer for waiting" do
+    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
+  describe '#timer' do
+    it 'returns default timer' do
       expect(Watir::Wait.timer).to be_a(Watir::Wait::Timer)
     end
   end
 
-  describe "#timer=" do
+  describe '#timer=' do
     after { Watir::Wait.timer = nil }
 
-    it "changes default timer" do
+    it 'changes default timer' do
       timer = Class.new
       Watir::Wait.timer = timer
       expect(Watir::Wait.timer).to eq(timer)

data/spec/watirspec/adjacent_spec.rb

@@ -1,69 +1,69 @@
-require "watirspec_helper"
+require 'watirspec_helper'
 
-describe "Adjacent Elements" do
+describe 'Adjacent Elements' do
   before(:all) do
-    browser.goto(WatirSpec.url_for("nested_elements.html"))
+    browser.goto(WatirSpec.url_for('nested_elements.html'))
   end
 
-  describe "#parent" do
-    it "gets immediate parent of an element by default" do
-      expect(browser.div(id: "first_sibling").parent.id).to eq 'parent'
-      expect(browser.div(id: "first_sibling").parent).to be_a Watir::HTMLElement
+  describe '#parent' do
+    it 'gets immediate parent of an element by default' do
+      expect(browser.div(id: 'first_sibling').parent.id).to eq 'parent'
+      expect(browser.div(id: 'first_sibling').parent).to be_a Watir::HTMLElement
     end
 
-    it "accepts index argument" do
-      expect(browser.div(id: "first_sibling").parent(index: 2).id).to eq 'grandparent'
-      expect(browser.div(id: "first_sibling").parent(index: 2)).to be_a Watir::HTMLElement
+    it 'accepts index argument' do
+      expect(browser.div(id: 'first_sibling').parent(index: 2).id).to eq 'grandparent'
+      expect(browser.div(id: 'first_sibling').parent(index: 2)).to be_a Watir::HTMLElement
     end
 
-    it "accepts tag_name argument" do
-      expect(browser.div(id: "first_sibling").parent(tag_name: :div).id).to eq 'parent'
-      expect(browser.div(id: "first_sibling").parent(tag_name: :div)).to be_a Watir::Div
+    it 'accepts tag_name argument' do
+      expect(browser.div(id: 'first_sibling').parent(tag_name: :div).id).to eq 'parent'
+      expect(browser.div(id: 'first_sibling').parent(tag_name: :div)).to be_a Watir::Div
     end
 
-    it "accepts custom tag_name argument" do
-      expect(browser.div(id: "regular_child").parent(tag_name: :grandelement).id).to eq 'custom_grandparent'
-      expect(browser.div(id: "regular_child").parent(tag_name: :grandelement)).to be_a Watir::HTMLElement
+    it 'accepts custom tag_name argument' do
+      expect(browser.div(id: 'regular_child').parent(tag_name: :grandelement).id).to eq 'custom_grandparent'
+      expect(browser.div(id: 'regular_child').parent(tag_name: :grandelement)).to be_a Watir::HTMLElement
     end
 
-    it "accepts class_name argument" do
-      expect(browser.div(id: "first_sibling").parent(class_name: 'parent').id).to eq 'parent_span'
+    it 'accepts class_name argument' do
+      expect(browser.div(id: 'first_sibling').parent(class_name: 'parent').id).to eq 'parent_span'
     end
 
-    it "accepts index and tag_name arguments" do
-      expect(browser.div(id: "first_sibling").parent(tag_name: :div, index: 1).id).to eq 'grandparent'
-      expect(browser.div(id: "first_sibling").parent(tag_name: :div, index: 1)).to be_a Watir::Div
+    it 'accepts index and tag_name arguments' do
+      expect(browser.div(id: 'first_sibling').parent(tag_name: :div, index: 1).id).to eq 'grandparent'
+      expect(browser.div(id: 'first_sibling').parent(tag_name: :div, index: 1)).to be_a Watir::Div
     end
 
-    it "does not error when no parent element of an index exists" do
+    it 'does not error when no parent element of an index exists' do
       expect(browser.body.parent(index: 2)).to_not exist
     end
 
-    it "does not error when no parent element of a tag_name exists" do
-      expect(browser.div(id: "first_sibling").parent(tag_name: :table)).to_not exist
+    it 'does not error when no parent element of a tag_name exists' do
+      expect(browser.div(id: 'first_sibling').parent(tag_name: :table)).to_not exist
     end
   end
 
-  describe "#siblings" do
-    it "gets collection of all siblings of an element" do
-      expect(browser.div(id: "second_sibling").siblings).to be_a Watir::HTMLElementCollection
-      expect(browser.div(id: "second_sibling").siblings.size).to eq 5
+  describe '#siblings' do
+    it 'gets collection of all siblings of an element' do
+      expect(browser.div(id: 'second_sibling').siblings).to be_a Watir::HTMLElementCollection
+      expect(browser.div(id: 'second_sibling').siblings.size).to eq 5
     end
 
-    it "accepts a tag name argument" do
-      siblings = browser.div(id: "second_sibling").siblings(tag_name: :div)
+    it 'accepts a tag name argument' do
+      siblings = browser.div(id: 'second_sibling').siblings(tag_name: :div)
       expect(siblings.size).to eq 3
       expect(siblings.all? { |sib| sib.is_a? Watir::Div }).to eq true
     end
 
-    it "accepts custom tag name argument" do
-      siblings = browser.div(id: "regular_child").siblings(tag_name: :childelement)
+    it 'accepts custom tag name argument' do
+      siblings = browser.div(id: 'regular_child').siblings(tag_name: :childelement)
       expect(siblings.size).to eq 3
       expect(siblings.all? { |sib| sib.is_a? Watir::HTMLElement }).to eq true
     end
 
-    it "accepts a class_name argument" do
-      siblings = browser.div(id: "second_sibling").siblings(class_name: 'b')
+    it 'accepts a class_name argument' do
+      siblings = browser.div(id: 'second_sibling').siblings(class_name: 'b')
       expect(siblings.first).to be_a Watir::Div
       expect(siblings[0]).to be_a Watir::Div
       expect(siblings.size).to eq 2
@@ -71,182 +71,182 @@ describe "Adjacent Elements" do
     end
   end
 
-  describe "#following_sibling" do
-    it "gets immediate following sibling of an element by default" do
-      expect(browser.div(id: "first_sibling").following_sibling.id).to eq 'between_siblings1'
-      expect(browser.div(id: "first_sibling").following_sibling).to be_a Watir::HTMLElement
+  describe '#following_sibling' do
+    it 'gets immediate following sibling of an element by default' do
+      expect(browser.div(id: 'first_sibling').following_sibling.id).to eq 'between_siblings1'
+      expect(browser.div(id: 'first_sibling').following_sibling).to be_a Watir::HTMLElement
     end
 
-    it "accepts index argument" do
-      expect(browser.div(id: "first_sibling").following_sibling(index: 2).id).to eq 'between_siblings2'
-      expect(browser.div(id: "first_sibling").following_sibling(index: 2)).to be_a Watir::HTMLElement
+    it 'accepts index argument' do
+      expect(browser.div(id: 'first_sibling').following_sibling(index: 2).id).to eq 'between_siblings2'
+      expect(browser.div(id: 'first_sibling').following_sibling(index: 2)).to be_a Watir::HTMLElement
     end
 
-    it "accepts tag_name argument" do
-      expect(browser.div(id: "first_sibling").following_sibling(tag_name: :div).id).to eq 'second_sibling'
-      expect(browser.div(id: "first_sibling").following_sibling(tag_name: :div)).to be_a Watir::Div
+    it 'accepts tag_name argument' do
+      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: :div).id).to eq 'second_sibling'
+      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: :div)).to be_a Watir::Div
     end
 
-    it "accepts class_name argument" do
-      expect(browser.div(id: "first_sibling").following_sibling(class_name: 'b').id).to eq 'second_sibling'
+    it 'accepts class_name argument' do
+      expect(browser.div(id: 'first_sibling').following_sibling(class_name: 'b').id).to eq 'second_sibling'
     end
 
-    it "accepts index and tag_name arguments" do
-      expect(browser.div(id: "first_sibling").following_sibling(tag_name: :div, index: 1).id).to eq 'third_sibling'
-      expect(browser.div(id: "first_sibling").following_sibling(tag_name: :div, index: 1)).to be_a Watir::Div
+    it 'accepts index and tag_name arguments' do
+      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: :div, index: 1).id).to eq 'third_sibling'
+      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: :div, index: 1)).to be_a Watir::Div
     end
 
-    it "accepts text as Regexp" do
-      expect(browser.div(id: "first_sibling").following_sibling(text: /t/).id).to eq 'third_sibling'
+    it 'accepts text as Regexp' do
+      expect(browser.div(id: 'first_sibling').following_sibling(text: /t/).id).to eq 'third_sibling'
     end
 
-    it "accepts text as String" do
-      expect(browser.div(id: "first_sibling").following_sibling(text: 'text').id).to eq 'third_sibling'
+    it 'accepts text as String' do
+      expect(browser.div(id: 'first_sibling').following_sibling(text: 'text').id).to eq 'third_sibling'
     end
 
-    it "does not error when no next sibling of an index exists" do
+    it 'does not error when no next sibling of an index exists' do
       expect(browser.body.following_sibling(index: 1)).to_not exist
     end
 
-    it "does not error when no next sibling of a tag_name exists" do
-      expect(browser.div(id: "first_sibling").following_sibling(tag_name: :table)).to_not exist
+    it 'does not error when no next sibling of a tag_name exists' do
+      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: :table)).to_not exist
     end
   end
 
-  describe "#following_siblings" do
-    it "gets collection of subsequent siblings of an element by default" do
-      expect(browser.div(id: "second_sibling").following_siblings).to be_a Watir::HTMLElementCollection
-      expect(browser.div(id: "second_sibling").following_siblings.size).to eq 2
+  describe '#following_siblings' do
+    it 'gets collection of subsequent siblings of an element by default' do
+      expect(browser.div(id: 'second_sibling').following_siblings).to be_a Watir::HTMLElementCollection
+      expect(browser.div(id: 'second_sibling').following_siblings.size).to eq 2
     end
 
-    it "accepts tag_name argument" do
-      expect(browser.div(id: "second_sibling").following_siblings(tag_name: :div).size).to eq 1
-      expect(browser.div(id: "second_sibling").following_siblings(tag_name: :div).first).to be_a Watir::Div
+    it 'accepts tag_name argument' do
+      expect(browser.div(id: 'second_sibling').following_siblings(tag_name: :div).size).to eq 1
+      expect(browser.div(id: 'second_sibling').following_siblings(tag_name: :div).first).to be_a Watir::Div
     end
 
-    it "accepts class_name argument for single class" do
-      expect(browser.div(id: "second_sibling").following_siblings(class_name: 'b').size).to eq 1
-      expect(browser.div(id: "second_sibling").following_siblings(class_name: 'b').first).to be_a Watir::Div
+    it 'accepts class_name argument for single class' do
+      expect(browser.div(id: 'second_sibling').following_siblings(class_name: 'b').size).to eq 1
+      expect(browser.div(id: 'second_sibling').following_siblings(class_name: 'b').first).to be_a Watir::Div
     end
 
-    it "accepts class_name argument for multiple classes" do
-      expect(browser.div(id: "second_sibling").following_siblings(class_name: ['a','b']).size).to eq 1
-      expect(browser.div(id: "second_sibling").following_siblings(class_name: ['a', 'b']).first).to be_a Watir::Div
+    it 'accepts class_name argument for multiple classes' do
+      expect(browser.div(id: 'second_sibling').following_siblings(class_name: %w[a b]).size).to eq 1
+      expect(browser.div(id: 'second_sibling').following_siblings(class_name: %w[a b]).first).to be_a Watir::Div
     end
   end
 
-  describe "#previous_sibling" do
-    it "gets immediate preceeding sibling of an element by default" do
-      expect(browser.div(id: "third_sibling").previous_sibling.id).to eq 'between_siblings2'
-      expect(browser.div(id: "third_sibling").previous_sibling).to be_a Watir::HTMLElement
+  describe '#previous_sibling' do
+    it 'gets immediate preceeding sibling of an element by default' do
+      expect(browser.div(id: 'third_sibling').previous_sibling.id).to eq 'between_siblings2'
+      expect(browser.div(id: 'third_sibling').previous_sibling).to be_a Watir::HTMLElement
     end
 
-    it "accepts index argument" do
-      expect(browser.div(id: "third_sibling").previous_sibling(index: 2).id).to eq 'between_siblings1'
-      expect(browser.div(id: "third_sibling").previous_sibling(index: 2)).to be_a Watir::HTMLElement
+    it 'accepts index argument' do
+      expect(browser.div(id: 'third_sibling').previous_sibling(index: 2).id).to eq 'between_siblings1'
+      expect(browser.div(id: 'third_sibling').previous_sibling(index: 2)).to be_a Watir::HTMLElement
     end
 
-    it "accepts tag_name argument" do
-      expect(browser.div(id: "third_sibling").previous_sibling(tag_name: :div).id).to eq 'second_sibling'
-      expect(browser.div(id: "third_sibling").previous_sibling(tag_name: :div)).to be_a Watir::Div
+    it 'accepts tag_name argument' do
+      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: :div).id).to eq 'second_sibling'
+      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: :div)).to be_a Watir::Div
     end
 
-    it "accepts class_name argument" do
-      expect(browser.div(id: "third_sibling").previous_sibling(class_name: 'a').id).to eq 'between_siblings2'
+    it 'accepts class_name argument' do
+      expect(browser.div(id: 'third_sibling').previous_sibling(class_name: 'a').id).to eq 'between_siblings2'
     end
 
-    it "accepts index and tag_name arguments" do
-      expect(browser.div(id: "third_sibling").previous_sibling(tag_name: :div, index: 1).id).to eq 'first_sibling'
-      expect(browser.div(id: "third_sibling").previous_sibling(tag_name: :div, index: 1)).to be_a Watir::Div
+    it 'accepts index and tag_name arguments' do
+      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: :div, index: 1).id).to eq 'first_sibling'
+      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: :div, index: 1)).to be_a Watir::Div
     end
 
-    it "does not error when no next sibling of an index exists" do
+    it 'does not error when no next sibling of an index exists' do
       expect(browser.body.previous_sibling(index: 1)).to_not exist
     end
 
-    it "does not error when no next sibling of a tag_name exists" do
-      expect(browser.div(id: "third_sibling").previous_sibling(tag_name: :table)).to_not exist
+    it 'does not error when no next sibling of a tag_name exists' do
+      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: :table)).to_not exist
     end
   end
 
-  describe "#previous_siblings" do
-    it "gets collection of previous siblings of an element by default" do
-      expect(browser.div(id: "second_sibling").previous_siblings).to be_a Watir::HTMLElementCollection
-      expect(browser.div(id: "second_sibling").previous_siblings.size).to eq 2
+  describe '#previous_siblings' do
+    it 'gets collection of previous siblings of an element by default' do
+      expect(browser.div(id: 'second_sibling').previous_siblings).to be_a Watir::HTMLElementCollection
+      expect(browser.div(id: 'second_sibling').previous_siblings.size).to eq 2
     end
 
-    it "accepts tag_name argument" do
-      expect(browser.div(id: "second_sibling").previous_siblings(tag_name: :div).size).to eq 1
-      expect(browser.div(id: "second_sibling").previous_siblings(tag_name: :div).first).to be_a Watir::Div
+    it 'accepts tag_name argument' do
+      expect(browser.div(id: 'second_sibling').previous_siblings(tag_name: :div).size).to eq 1
+      expect(browser.div(id: 'second_sibling').previous_siblings(tag_name: :div).first).to be_a Watir::Div
     end
 
-    it "accepts class_name argument" do
-      expect(browser.div(id: "second_sibling").previous_siblings(class_name: 'a').size).to eq 1
-      expect(browser.div(id: "second_sibling").previous_siblings(class_name: 'a').first.id).to eq 'between_siblings1'
+    it 'accepts class_name argument' do
+      expect(browser.div(id: 'second_sibling').previous_siblings(class_name: 'a').size).to eq 1
+      expect(browser.div(id: 'second_sibling').previous_siblings(class_name: 'a').first.id).to eq 'between_siblings1'
     end
   end
 
-  describe "#child" do
-    it "gets immediate child of an element by default" do
-      expect(browser.div(id: "parent").child.id).to eq 'first_sibling'
-      expect(browser.div(id: "parent").child).to be_a Watir::HTMLElement
+  describe '#child' do
+    it 'gets immediate child of an element by default' do
+      expect(browser.div(id: 'parent').child.id).to eq 'first_sibling'
+      expect(browser.div(id: 'parent').child).to be_a Watir::HTMLElement
     end
 
-    it "accepts index argument" do
-      expect(browser.div(id: "parent").child(index: 2).id).to eq 'second_sibling'
-      expect(browser.div(id: "parent").child(index: 2)).to be_a Watir::HTMLElement
+    it 'accepts index argument' do
+      expect(browser.div(id: 'parent').child(index: 2).id).to eq 'second_sibling'
+      expect(browser.div(id: 'parent').child(index: 2)).to be_a Watir::HTMLElement
     end
 
-    it "accepts tag_name argument" do
-      expect(browser.div(id: "parent").child(tag_name: :span).id).to eq 'between_siblings1'
-      expect(browser.div(id: "parent").child(tag_name: :span)).to be_a Watir::Span
+    it 'accepts tag_name argument' do
+      expect(browser.div(id: 'parent').child(tag_name: :span).id).to eq 'between_siblings1'
+      expect(browser.div(id: 'parent').child(tag_name: :span)).to be_a Watir::Span
     end
 
-    it "accepts custom tag_name argument" do
-      expect(browser.element(id: "custom_parent").child(tag_name: :childelement).id).to eq 'custom_child'
-      expect(browser.element(id: "custom_parent").child(tag_name: :childelement)).to be_a Watir::HTMLElement
+    it 'accepts custom tag_name argument' do
+      expect(browser.element(id: 'custom_parent').child(tag_name: :childelement).id).to eq 'custom_child'
+      expect(browser.element(id: 'custom_parent').child(tag_name: :childelement)).to be_a Watir::HTMLElement
     end
 
-    it "accepts class_name argument" do
-      expect(browser.div(id: "parent").child(class_name: 'b').id).to eq 'second_sibling'
+    it 'accepts class_name argument' do
+      expect(browser.div(id: 'parent').child(class_name: 'b').id).to eq 'second_sibling'
     end
 
-    it "accepts index and tag_name arguments" do
-      expect(browser.div(id: "parent").child(tag_name: :div, index: 1).id).to eq 'second_sibling'
-      expect(browser.div(id: "parent").child(tag_name: :div, index: 1)).to be_a Watir::Div
+    it 'accepts index and tag_name arguments' do
+      expect(browser.div(id: 'parent').child(tag_name: :div, index: 1).id).to eq 'second_sibling'
+      expect(browser.div(id: 'parent').child(tag_name: :div, index: 1)).to be_a Watir::Div
     end
 
-    it "does not error when no next sibling of an index exists" do
-      expect(browser.div(id: "second_sibling").child(index: 1)).to_not exist
+    it 'does not error when no next sibling of an index exists' do
+      expect(browser.div(id: 'second_sibling').child(index: 1)).to_not exist
     end
 
-    it "does not error when no next sibling of a tag_name exists" do
-      expect(browser.div(id: "parent").child(tag_name: :table)).to_not exist
+    it 'does not error when no next sibling of a tag_name exists' do
+      expect(browser.div(id: 'parent').child(tag_name: :table)).to_not exist
     end
   end
 
-  describe "#children" do
-    it "gets collection of children of an element by default" do
-      expect(browser.div(id: "parent").children).to be_a Watir::HTMLElementCollection
-      expect(browser.div(id: "parent").children.size).to eq 5
+  describe '#children' do
+    it 'gets collection of children of an element by default' do
+      expect(browser.div(id: 'parent').children).to be_a Watir::HTMLElementCollection
+      expect(browser.div(id: 'parent').children.size).to eq 5
     end
 
-    it "accepts tag_name argument" do
-      children = browser.div(id: "parent").children(tag_name: :div)
+    it 'accepts tag_name argument' do
+      children = browser.div(id: 'parent').children(tag_name: :div)
       expect(children.size).to eq 3
       expect(children.all? { |child| child.is_a? Watir::Div }).to eq true
     end
 
-    it "accepts custom tag_name argument" do
-      children = browser.element(id: "custom_parent").children(tag_name: :childelement)
+    it 'accepts custom tag_name argument' do
+      children = browser.element(id: 'custom_parent').children(tag_name: :childelement)
       expect(children.size).to eq 3
       expect(children.all? { |child| child.is_a? Watir::HTMLElement }).to eq true
     end
 
-    it "accepts a class_name argument" do
-      children = browser.div(id: "parent").children(class_name: 'b')
+    it 'accepts a class_name argument' do
+      children = browser.div(id: 'parent').children(class_name: 'b')
       expect(children.size).to eq 2
       expect(children.all? { |child| child.is_a? Watir::Div }).to eq true
     end
   end
-end
+end