From a5ea744e797733deadc4554b606b7877a07863f8 Mon Sep 17 00:00:00 2001
From: CrispusDH <qacrispus@gmail.com>
Date: Thu, 8 Nov 2018 11:45:26 +0200
Subject: [PATCH 1/2] chore(test): move expected_conditions_spec off of the
 control flow

---
 spec/basic/expected_conditions_spec.js | 465 ++++++++++++-------------
 spec/basicConf.js                      |   3 +-
 spec/ciFullConf.js                     |   3 +-
 3 files changed, 234 insertions(+), 237 deletions(-)

diff --git a/spec/basic/expected_conditions_spec.js b/spec/basic/expected_conditions_spec.js
index e91155070..7efe6aa52 100644
--- a/spec/basic/expected_conditions_spec.js
+++ b/spec/basic/expected_conditions_spec.js
@@ -1,255 +1,250 @@
-var EC = protractor.ExpectedConditions;
-
-describe('expected conditions', function() {
-  beforeEach(function() {
-    browser.get('index.html#/form');
-  });
-
-  it('should have alertIsPresent', function() {
-    var alertIsPresent = EC.alertIsPresent();
-    expect(alertIsPresent.call()).toBe(false);
-
-    var alertButton = $('#alertbutton');
-    alertButton.click();
-    browser.wait(protractor.ExpectedConditions.alertIsPresent(), 5000);
-    browser.switchTo().alert().accept();
-  });
-
-  it('should have presenceOf', function() {
-    var presenceOfInvalid = EC.presenceOf($('#INVALID'));
-    var presenceOfHideable = EC.presenceOf($('#shower'));
-
-    expect(presenceOfInvalid.call()).toBe(false);
-    expect(presenceOfHideable.call()).toBe(true);
-    element(by.model('show')).click();
-    expect(presenceOfHideable.call()).toBe(true); // Should be able to reuse.
-  });
-
-  it('should have stalenessOf', function() {
-    var stalenessOfInvalid = EC.stalenessOf($('#INVALID'));
-    var stalenessOfHideable = EC.stalenessOf($('#shower'));
-
-    expect(stalenessOfInvalid.call()).toBe(true);
-    expect(stalenessOfHideable.call()).toBe(false);
-    element(by.model('show')).click();
-    expect(stalenessOfHideable.call()).toBe(false);
-  });
-
-  it('should have visibilityOf', function() {
-    var visibilityOfInvalid = EC.visibilityOf($('#INVALID'));
-    var visibilityOfHideable = EC.visibilityOf($('#shower'));
-
-    expect(visibilityOfInvalid.call()).toBe(false);
-    expect(visibilityOfHideable.call()).toBe(true);
-    element(by.model('show')).click();
-    expect(visibilityOfHideable.call()).toBe(false);
-  });
-
-  it('should have invisibilityOf', function() {
-    var invisibilityOfInvalid = EC.invisibilityOf($('#INVALID'));
-    var invisibilityOfHideable = EC.invisibilityOf($('#shower'));
-
-    expect(invisibilityOfInvalid.call()).toBe(true);
-    expect(invisibilityOfHideable.call()).toBe(false);
-    element(by.model('show')).click();
-    expect(invisibilityOfHideable.call()).toBe(true);
-  });
-
-  it('should have titleContains', function() {
-    expect(EC.titleContains('My Angular').call()).toBe(true);
-    expect(EC.titleContains('My AngularJS App').call()).toBe(true);
-  });
-
-  it('should have titleIs', function() {
-    expect(EC.titleIs('My Angular').call()).toBe(false);
-    expect(EC.titleIs('My AngularJS App').call()).toBe(true);
-  });
-
-  it('should have urlContains', function() {
-      var baseUrlFromSpec = browser.baseUrl;
-      expect(EC.urlContains('/form').call()).toBe(true);
-      expect(EC.urlContains(baseUrlFromSpec+ 'index.html#/form').call()).toBe(true);
-  });
-
-  it('should have urlIs', function() {
-      var baseUrlFromSpec = browser.baseUrl;
-      expect(EC.urlIs(browser.baseUrl).call()).toBe(false);
-      expect(EC.urlIs(baseUrlFromSpec+'index.html#/form').call()).toBe(true);
-  });
-
-  it('should have elementToBeClickable', function() {
-    var invalidIsClickable = EC.elementToBeClickable($('#INVALID'));
-    var buttonIsClickable = EC.elementToBeClickable($('#disabledButton'));
-
-    expect(invalidIsClickable.call()).toBe(false);
-    expect(buttonIsClickable.call()).toBe(true);
-    element(by.model('disabled')).click();
-    expect(buttonIsClickable.call()).toBe(false);
-  });
-
-  it('should have textToBePresentInElement', function() {
-    var invalidHasText = EC.textToBePresentInElement($('#INVALID'), 'shouldnt throw');
-    var hideableHasText = EC.textToBePresentInElement($('#shower'), 'Shown');
-
-    expect(invalidHasText.call()).toBe(false);
-    expect(hideableHasText.call()).toBe(true);
-    element(by.model('show')).click();
-    expect(hideableHasText.call()).toBe(false);
-  });
-
-  it('should have textToBePresentInElementValue', function() {
-    var invalid = $('#INVALID');
-    var about = element(by.model('aboutbox'));
-
-    expect(EC.textToBePresentInElementValue(invalid, 'shouldnt throw').call()).toBe(false);
-    expect(EC.textToBePresentInElementValue(about, 'text box').call()).toBe(true);
-  });
-
-  it('should have elementToBeSelected', function() {
-    var checkbox = element(by.model('show'));
-
-    expect(EC.elementToBeSelected(checkbox).call()).toBe(true);
-    checkbox.click();
-    expect(EC.elementToBeSelected(checkbox).call()).toBe(false);
-  });
-
-  it('should have not', function() {
-    var presenceOfValidElement = EC.presenceOf($('#shower'));
-    expect(presenceOfValidElement.call()).toBe(true);
-    expect(EC.not(presenceOfValidElement).call()).toBe(false);
-  });
-
-  it('should have and', function() {
-    var presenceOfValidElement = EC.presenceOf($('#shower'));
-    var presenceOfInvalidElement = EC.presenceOf($('#INVALID'));
-    var validityOfTitle = EC.titleIs('My AngularJS App');
-
-    expect(EC.and(presenceOfValidElement, validityOfTitle).call()).toBe(true);
+const EC = protractor.ExpectedConditions;
+
+describe('expected conditions', () => {
+  beforeEach(async () => {
+    await browser.get('index.html#/form');
+  });
+  
+  it('should have alertIsPresent', async () => {
+    const alertIsPresent = EC.alertIsPresent();
+    expect(await alertIsPresent.call()).toBe(false);
+    
+    const alertButton = $('#alertbutton');
+    await alertButton.click();
+    await browser.wait(protractor.ExpectedConditions.alertIsPresent(), 5000);
+    await browser.switchTo().alert().accept();
+  });
+  
+  it('should have presenceOf', async () => {
+    const presenceOfInvalid = EC.presenceOf($('#INVALID'));
+    const presenceOfHideable = EC.presenceOf($('#shower'));
+    
+    expect(await presenceOfInvalid.call()).toBe(false);
+    expect(await presenceOfHideable.call()).toBe(true);
+    await element(by.model('show')).click();
+    expect(await presenceOfHideable.call()).toBe(true); // Should be able to reuse.
+  });
+  
+  it('should have stalenessOf', async () => {
+    const stalenessOfInvalid = EC.stalenessOf($('#INVALID'));
+    const stalenessOfHideable = EC.stalenessOf($('#shower'));
+    
+    expect(await stalenessOfInvalid.call()).toBe(true);
+    expect(await stalenessOfHideable.call()).toBe(false);
+    await element(by.model('show')).click();
+    expect(await stalenessOfHideable.call()).toBe(false);
+  });
+  
+  it('should have visibilityOf', async () => {
+    const visibilityOfInvalid = EC.visibilityOf($('#INVALID'));
+    const visibilityOfHideable = EC.visibilityOf($('#shower'));
+    
+    expect(await visibilityOfInvalid.call()).toBe(false);
+    expect(await visibilityOfHideable.call()).toBe(true);
+    await element(by.model('show')).click();
+    expect(await visibilityOfHideable.call()).toBe(false);
+  });
+  
+  it('should have invisibilityOf', async () => {
+    const invisibilityOfInvalid = EC.invisibilityOf($('#INVALID'));
+    const invisibilityOfHideable = EC.invisibilityOf($('#shower'));
+    
+    expect(await invisibilityOfInvalid.call()).toBe(true);
+    expect(await invisibilityOfHideable.call()).toBe(false);
+    await element(by.model('show')).click();
+    expect(await invisibilityOfHideable.call()).toBe(true);
+  });
+  
+  it('should have titleContains', async () => {
+    expect(await EC.titleContains('My Angular').call()).toBe(true);
+    expect(await EC.titleContains('My AngularJS App').call()).toBe(true);
+  });
+  
+  it('should have titleIs', async () => {
+    expect(await EC.titleIs('My Angular').call()).toBe(false);
+    expect(await EC.titleIs('My AngularJS App').call()).toBe(true);
+  });
+  
+  it('should have urlContains', async () => {
+    const baseUrlFromSpec = browser.baseUrl;
+    expect(await EC.urlContains('/form').call()).toBe(true);
+    expect(await EC.urlContains(baseUrlFromSpec+ 'index.html#/form').call()).toBe(true);
+  });
+  
+  it('should have urlIs', async () => {
+    const baseUrlFromSpec = browser.baseUrl;
+    expect(await EC.urlIs(browser.baseUrl).call()).toBe(false);
+    expect(await EC.urlIs(baseUrlFromSpec+'index.html#/form').call()).toBe(true);
+  });
+  
+  it('should have elementToBeClickable', async () => {
+    const invalidIsClickable = EC.elementToBeClickable($('#INVALID'));
+    const buttonIsClickable = EC.elementToBeClickable($('#disabledButton'));
+    
+    expect(await invalidIsClickable.call()).toBe(false);
+    expect(await buttonIsClickable.call()).toBe(true);
+    await element(by.model('disabled')).click();
+    expect(await buttonIsClickable.call()).toBe(false);
+  });
+  
+  it('should have textToBePresentInElement', async () => {
+    const invalidHasText = EC.textToBePresentInElement($('#INVALID'), 'shouldnt throw');
+    const hideableHasText = EC.textToBePresentInElement($('#shower'), 'Shown');
+    
+    expect(await invalidHasText.call()).toBe(false);
+    expect(await hideableHasText.call()).toBe(true);
+    await element(by.model('show')).click();
+    expect(await hideableHasText.call()).toBe(false);
+  });
+  
+  it('should have textToBePresentInElementValue', async () => {
+    const invalid = $('#INVALID');
+    const about = element(by.model('aboutbox'));
+    
+    expect(await EC.textToBePresentInElementValue(invalid, 'shouldnt throw').call()).toBe(false);
+    expect(await EC.textToBePresentInElementValue(about, 'text box').call()).toBe(true);
+  });
+  
+  it('should have elementToBeSelected', async () => {
+    const checkbox = element(by.model('show'));
+    
+    expect(await EC.elementToBeSelected(checkbox).call()).toBe(true);
+    await checkbox.click();
+    expect(await EC.elementToBeSelected(checkbox).call()).toBe(false);
+  });
+  
+  it('should have not', async () => {
+    const presenceOfValidElement = EC.presenceOf($('#shower'));
+    expect(await presenceOfValidElement.call()).toBe(true);
+    expect(await EC.not(presenceOfValidElement).call()).toBe(false);
+  });
+  
+  it('should have and', async () => {
+    const presenceOfValidElement = EC.presenceOf($('#shower'));
+    const presenceOfInvalidElement = EC.presenceOf($('#INVALID'));
+    const validityOfTitle = EC.titleIs('My AngularJS App');
+    
+    expect(await EC.and(presenceOfValidElement, validityOfTitle).call()).toBe(true);
     // support multiple conditions
-    expect(EC.and(presenceOfValidElement,
-       validityOfTitle, presenceOfInvalidElement).call()).toBe(false);
-  });
-
-  it('and should shortcircuit', function() {
-    var invalidElem = $('#INVALID');
-
-    var presenceOfInvalidElement = EC.presenceOf(invalidElem);
-    var isDisplayed = invalidElem.isDisplayed.bind(invalidElem);
-
+    expect(await EC.and(presenceOfValidElement, validityOfTitle, presenceOfInvalidElement).call()).toBe(false);
+  });
+  
+  it('and should shortcircuit', async () => {
+    const invalidElem = $('#INVALID');
+    
+    const presenceOfInvalidElement = EC.presenceOf(invalidElem);
+    const isDisplayed = invalidElem.isDisplayed.bind(invalidElem);
+    
     // check isDisplayed on invalid element
-    var condition = EC.and(presenceOfInvalidElement, isDisplayed);
-
+    const condition = EC.and(presenceOfInvalidElement, isDisplayed);
+    
     // Should short circuit after the first condition is false, and not throw error
-    expect(condition.call()).toBe(false);
-  });
-
-  it('should have or', function() {
-    var presenceOfValidElement = EC.presenceOf($('#shower'));
-    var presenceOfInvalidElement = EC.presenceOf($('#INVALID'));
-    var presenceOfInvalidElement2 = EC.presenceOf($('#INVALID2'));
-
-    expect(EC.or(presenceOfInvalidElement, presenceOfInvalidElement2).call()).toBe(false);
+    expect(await condition.call()).toBe(false);
+  });
+  
+  it('should have or', async () => {
+    const presenceOfValidElement = EC.presenceOf($('#shower'));
+    const presenceOfInvalidElement = EC.presenceOf($('#INVALID'));
+    const presenceOfInvalidElement2 = EC.presenceOf($('#INVALID2'));
+    
+    expect(await EC.or(presenceOfInvalidElement, presenceOfInvalidElement2).call()).toBe(false);
     // support multiple conditions
-    expect(EC.or(presenceOfInvalidElement,
-        presenceOfInvalidElement2, presenceOfValidElement).call()).toBe(true);
-  });
-
-  it('or should shortcircuit', function() {
-    var validElem = $('#shower');
-    var invalidElem = $('#INVALID');
-
-    var presenceOfValidElement = EC.presenceOf(validElem);
-    var isDisplayed = invalidElem.isDisplayed.bind(invalidElem);
-
+    expect(await EC.or(presenceOfInvalidElement, presenceOfInvalidElement2, presenceOfValidElement).call()).toBe(true);
+  });
+  
+  it('or should shortcircuit', async () => {
+    const validElem = $('#shower');
+    const invalidElem = $('#INVALID');
+    
+    const presenceOfValidElement = EC.presenceOf(validElem);
+    const isDisplayed = invalidElem.isDisplayed.bind(invalidElem);
+    
     // check isDisplayed on invalid element
-    var condition = EC.or(presenceOfValidElement, isDisplayed);
-
+    const condition = EC.or(presenceOfValidElement, isDisplayed);
+    
     // Should short circuit after the first condition is true, and not throw error
-    expect(condition.call()).toBe(true);
-  });
-
-  it('should be able to mix conditions', function() {
-    var valid = EC.presenceOf($('#shower'));
-    var invalid = EC.presenceOf($('#INVALID'));
-
-    expect(EC.or(valid, EC.and(valid, invalid)).call()).toBe(true);
-    expect(EC.or(EC.not(valid), EC.and(valid, invalid)).call()).toBe(false);
-  });
-
-  describe('for forked browsers', function() {
+    expect(await condition.call()).toBe(true);
+  });
+  
+  it('should be able to mix conditions', async () => {
+    const valid = EC.presenceOf($('#shower'));
+    const invalid = EC.presenceOf($('#INVALID'));
+    
+    expect(await EC.or(valid, await EC.and(valid, invalid)).call()).toBe(true);
+    expect(await EC.or(EC.not(valid), EC.and(valid, invalid)).call()).toBe(false);
+  });
+  
+  describe('for forked browsers', () => {
     // ensure that we can run EC on forked browser instances
-    it('should have alertIsPresent', function() {
-      var browser2 = browser.forkNewDriverInstance();
-      browser2.get('index.html#/form');
-      var EC2 = browser2.ExpectedConditions;
-      var alertIsPresent = EC2.alertIsPresent();
-      expect(alertIsPresent.call()).toBe(false);
-
-      var alertButton = browser2.$('#alertbutton');
-      alertButton.click();
-      browser2.wait(EC2.alertIsPresent(), 1000);
-
-      // TODO: Remove sleep when this is fixed:
-      //    https://bugs.chromium.org/p/chromedriver/issues/detail?id=1500
-      browser2.sleep(250);
-      browser2.switchTo().alert().accept();
+    it('should have alertIsPresent', async () => {
+      const browser2 = browser.forkNewDriverInstance();
+      await browser2.get('index.html#/form');
+      const EC2 = browser2.ExpectedConditions;
+      const alertIsPresent = EC2.alertIsPresent();
+      expect(await alertIsPresent.call()).toBe(false);
+      
+      const alertButton = browser2.$('#alertbutton');
+      await alertButton.click();
+      await browser2.wait(EC2.alertIsPresent(), 1000);
+      
+      await browser2.switchTo().alert().accept();
     });
   });
-
-  describe('race condition handling', function () {
-
-    var disabledButton;
-
-    beforeEach(function () {
+  
+  describe('race condition handling', () => {
+    
+    let disabledButton;
+    
+    beforeEach(() => {
       disabledButton = $('#disabledButton[disabled="disabled"]');
     });
-
-    function enableButtonBeforeCallToUnmatchSelector(testElement, fnName) {
-      var originalFn = testElement[fnName];
-
-      testElement[fnName] = function () {
-        element(by.model('disabled')).click();
+    
+    const enableButtonBeforeCallToUnmatchSelector = async (testElement, fnName) => {
+      const originalFn = testElement[fnName];
+      
+      testElement[fnName] = async () => {
+        await element(by.model('disabled')).click();
         return originalFn.apply(this, arguments);
       };
-
+      
       // save original fn with _ prefix
-      testElement['_' + fnName] = originalFn;
-    }
-
-    it('can deal with missing elements in visibilityOf', function() {
-      enableButtonBeforeCallToUnmatchSelector(disabledButton, 'isDisplayed');
-
-      element(by.model('disabled')).click();
-
-      expect(disabledButton._isDisplayed()).toBe(true);
-      expect(EC.visibilityOf(disabledButton).call()).toBe(false);
+      testElement[`_${fnName}`] = originalFn;
+    };
+    
+    it('can deal with missing elements in visibilityOf', async () => {
+      await enableButtonBeforeCallToUnmatchSelector(disabledButton, 'isDisplayed');
+      
+      await element(by.model('disabled')).click();
+      
+      expect(await disabledButton._isDisplayed()).toBe(true);
+      expect(await EC.visibilityOf(disabledButton).call()).toBe(false);
     });
-
-    it('can deal with missing elements in textToBePresentInElement', function() {
-      enableButtonBeforeCallToUnmatchSelector(disabledButton, 'getText');
-
-      element(by.model('disabled')).click();
-
-      expect(disabledButton._getText()).toBe('Dummy');
-      expect(EC.textToBePresentInElement(disabledButton, 'Dummy').call()).toBe(false);
+    
+    it('can deal with missing elements in textToBePresentInElement', async () => {
+      await enableButtonBeforeCallToUnmatchSelector(disabledButton, 'getText');
+      
+      await element(by.model('disabled')).click();
+      
+      expect(await disabledButton._getText()).toBe('Dummy');
+      expect(await EC.textToBePresentInElement(disabledButton, 'Dummy').call()).toBe(false);
     });
-
-    it('can deal with missing elements in textToBePresentInValue', function() {
-      enableButtonBeforeCallToUnmatchSelector(disabledButton, 'getAttribute');
-
-      element(by.model('disabled')).click();
-
-      expect(disabledButton._getAttribute('value')).toBe('');
-      expect(EC.textToBePresentInElementValue(disabledButton, '').call()).toBe(false);
+    
+    it('can deal with missing elements in textToBePresentInValue', async () => {
+      await enableButtonBeforeCallToUnmatchSelector(disabledButton, 'getAttribute');
+      
+      await element(by.model('disabled')).click();
+      
+      expect(await disabledButton._getAttribute('value')).toBe('');
+      expect(await EC.textToBePresentInElementValue(disabledButton, '').call()).toBe(false);
     });
-
-    it('can deal with missing elements in elementToBeClickable', function() {
-      enableButtonBeforeCallToUnmatchSelector(disabledButton, 'isEnabled');
-
-      element(by.model('disabled')).click();
-
-      expect(disabledButton._isEnabled()).toBe(false);
-      expect(EC.elementToBeClickable(disabledButton).call()).toBe(false);
+    
+    it('can deal with missing elements in elementToBeClickable', async () => {
+      await enableButtonBeforeCallToUnmatchSelector(disabledButton, 'isEnabled');
+      
+      await element(by.model('disabled')).click();
+      
+      expect(await disabledButton._isEnabled()).toBe(false);
+      expect(await EC.elementToBeClickable(disabledButton).call()).toBe(false);
     });
   });
 });
diff --git a/spec/basicConf.js b/spec/basicConf.js
index dda89b6c2..2d9d0a17b 100644
--- a/spec/basicConf.js
+++ b/spec/basicConf.js
@@ -11,7 +11,8 @@ exports.config = {
   specs: [
     'basic/elements_spec.js',
     'basic/lib_spec.js',
-    'basic/handling_spec.js'
+    'basic/handling_spec.js',
+    'basic/expected_conditions_spec.js'
   ],
 
   // Exclude patterns are relative to this directory.
diff --git a/spec/ciFullConf.js b/spec/ciFullConf.js
index d69381691..d80cb04c5 100644
--- a/spec/ciFullConf.js
+++ b/spec/ciFullConf.js
@@ -12,7 +12,8 @@ exports.config = {
   specs: [
     'basic/elements_spec.js',
     'basic/lib_spec.js',
-    'basic/handling_spec.js'
+    'basic/handling_spec.js',
+    'basic/expected_conditions_spec.js'
   ],
 
   // Exclude patterns are relative to this directory.

From 2c5eba376f9da0f407e30c3c6e984a7a64efa07a Mon Sep 17 00:00:00 2001
From: CrispusDH <qacrispus@gmail.com>
Date: Thu, 8 Nov 2018 23:46:28 +0200
Subject: [PATCH 2/2] fix indentation in empty lines

---
 spec/basic/expected_conditions_spec.js | 116 ++++++++++++-------------
 1 file changed, 58 insertions(+), 58 deletions(-)

diff --git a/spec/basic/expected_conditions_spec.js b/spec/basic/expected_conditions_spec.js
index 7efe6aa52..b537a7cb5 100644
--- a/spec/basic/expected_conditions_spec.js
+++ b/spec/basic/expected_conditions_spec.js
@@ -4,176 +4,176 @@ describe('expected conditions', () => {
   beforeEach(async () => {
     await browser.get('index.html#/form');
   });
-  
+
   it('should have alertIsPresent', async () => {
     const alertIsPresent = EC.alertIsPresent();
     expect(await alertIsPresent.call()).toBe(false);
-    
+
     const alertButton = $('#alertbutton');
     await alertButton.click();
     await browser.wait(protractor.ExpectedConditions.alertIsPresent(), 5000);
     await browser.switchTo().alert().accept();
   });
-  
+
   it('should have presenceOf', async () => {
     const presenceOfInvalid = EC.presenceOf($('#INVALID'));
     const presenceOfHideable = EC.presenceOf($('#shower'));
-    
+
     expect(await presenceOfInvalid.call()).toBe(false);
     expect(await presenceOfHideable.call()).toBe(true);
     await element(by.model('show')).click();
     expect(await presenceOfHideable.call()).toBe(true); // Should be able to reuse.
   });
-  
+
   it('should have stalenessOf', async () => {
     const stalenessOfInvalid = EC.stalenessOf($('#INVALID'));
     const stalenessOfHideable = EC.stalenessOf($('#shower'));
-    
+
     expect(await stalenessOfInvalid.call()).toBe(true);
     expect(await stalenessOfHideable.call()).toBe(false);
     await element(by.model('show')).click();
     expect(await stalenessOfHideable.call()).toBe(false);
   });
-  
+
   it('should have visibilityOf', async () => {
     const visibilityOfInvalid = EC.visibilityOf($('#INVALID'));
     const visibilityOfHideable = EC.visibilityOf($('#shower'));
-    
+
     expect(await visibilityOfInvalid.call()).toBe(false);
     expect(await visibilityOfHideable.call()).toBe(true);
     await element(by.model('show')).click();
     expect(await visibilityOfHideable.call()).toBe(false);
   });
-  
+
   it('should have invisibilityOf', async () => {
     const invisibilityOfInvalid = EC.invisibilityOf($('#INVALID'));
     const invisibilityOfHideable = EC.invisibilityOf($('#shower'));
-    
+
     expect(await invisibilityOfInvalid.call()).toBe(true);
     expect(await invisibilityOfHideable.call()).toBe(false);
     await element(by.model('show')).click();
     expect(await invisibilityOfHideable.call()).toBe(true);
   });
-  
+
   it('should have titleContains', async () => {
     expect(await EC.titleContains('My Angular').call()).toBe(true);
     expect(await EC.titleContains('My AngularJS App').call()).toBe(true);
   });
-  
+
   it('should have titleIs', async () => {
     expect(await EC.titleIs('My Angular').call()).toBe(false);
     expect(await EC.titleIs('My AngularJS App').call()).toBe(true);
   });
-  
+
   it('should have urlContains', async () => {
     const baseUrlFromSpec = browser.baseUrl;
     expect(await EC.urlContains('/form').call()).toBe(true);
     expect(await EC.urlContains(baseUrlFromSpec+ 'index.html#/form').call()).toBe(true);
   });
-  
+
   it('should have urlIs', async () => {
     const baseUrlFromSpec = browser.baseUrl;
     expect(await EC.urlIs(browser.baseUrl).call()).toBe(false);
     expect(await EC.urlIs(baseUrlFromSpec+'index.html#/form').call()).toBe(true);
   });
-  
+
   it('should have elementToBeClickable', async () => {
     const invalidIsClickable = EC.elementToBeClickable($('#INVALID'));
     const buttonIsClickable = EC.elementToBeClickable($('#disabledButton'));
-    
+
     expect(await invalidIsClickable.call()).toBe(false);
     expect(await buttonIsClickable.call()).toBe(true);
     await element(by.model('disabled')).click();
     expect(await buttonIsClickable.call()).toBe(false);
   });
-  
+
   it('should have textToBePresentInElement', async () => {
     const invalidHasText = EC.textToBePresentInElement($('#INVALID'), 'shouldnt throw');
     const hideableHasText = EC.textToBePresentInElement($('#shower'), 'Shown');
-    
+
     expect(await invalidHasText.call()).toBe(false);
     expect(await hideableHasText.call()).toBe(true);
     await element(by.model('show')).click();
     expect(await hideableHasText.call()).toBe(false);
   });
-  
+
   it('should have textToBePresentInElementValue', async () => {
     const invalid = $('#INVALID');
     const about = element(by.model('aboutbox'));
-    
+
     expect(await EC.textToBePresentInElementValue(invalid, 'shouldnt throw').call()).toBe(false);
     expect(await EC.textToBePresentInElementValue(about, 'text box').call()).toBe(true);
   });
-  
+
   it('should have elementToBeSelected', async () => {
     const checkbox = element(by.model('show'));
-    
+
     expect(await EC.elementToBeSelected(checkbox).call()).toBe(true);
     await checkbox.click();
     expect(await EC.elementToBeSelected(checkbox).call()).toBe(false);
   });
-  
+
   it('should have not', async () => {
     const presenceOfValidElement = EC.presenceOf($('#shower'));
     expect(await presenceOfValidElement.call()).toBe(true);
     expect(await EC.not(presenceOfValidElement).call()).toBe(false);
   });
-  
+
   it('should have and', async () => {
     const presenceOfValidElement = EC.presenceOf($('#shower'));
     const presenceOfInvalidElement = EC.presenceOf($('#INVALID'));
     const validityOfTitle = EC.titleIs('My AngularJS App');
-    
+
     expect(await EC.and(presenceOfValidElement, validityOfTitle).call()).toBe(true);
     // support multiple conditions
     expect(await EC.and(presenceOfValidElement, validityOfTitle, presenceOfInvalidElement).call()).toBe(false);
   });
-  
+
   it('and should shortcircuit', async () => {
     const invalidElem = $('#INVALID');
-    
+
     const presenceOfInvalidElement = EC.presenceOf(invalidElem);
     const isDisplayed = invalidElem.isDisplayed.bind(invalidElem);
-    
+
     // check isDisplayed on invalid element
     const condition = EC.and(presenceOfInvalidElement, isDisplayed);
-    
+
     // Should short circuit after the first condition is false, and not throw error
     expect(await condition.call()).toBe(false);
   });
-  
+
   it('should have or', async () => {
     const presenceOfValidElement = EC.presenceOf($('#shower'));
     const presenceOfInvalidElement = EC.presenceOf($('#INVALID'));
     const presenceOfInvalidElement2 = EC.presenceOf($('#INVALID2'));
-    
+
     expect(await EC.or(presenceOfInvalidElement, presenceOfInvalidElement2).call()).toBe(false);
     // support multiple conditions
     expect(await EC.or(presenceOfInvalidElement, presenceOfInvalidElement2, presenceOfValidElement).call()).toBe(true);
   });
-  
+
   it('or should shortcircuit', async () => {
     const validElem = $('#shower');
     const invalidElem = $('#INVALID');
-    
+
     const presenceOfValidElement = EC.presenceOf(validElem);
     const isDisplayed = invalidElem.isDisplayed.bind(invalidElem);
-    
+
     // check isDisplayed on invalid element
     const condition = EC.or(presenceOfValidElement, isDisplayed);
-    
+
     // Should short circuit after the first condition is true, and not throw error
     expect(await condition.call()).toBe(true);
   });
-  
+
   it('should be able to mix conditions', async () => {
     const valid = EC.presenceOf($('#shower'));
     const invalid = EC.presenceOf($('#INVALID'));
-    
+
     expect(await EC.or(valid, await EC.and(valid, invalid)).call()).toBe(true);
     expect(await EC.or(EC.not(valid), EC.and(valid, invalid)).call()).toBe(false);
   });
-  
+
   describe('for forked browsers', () => {
     // ensure that we can run EC on forked browser instances
     it('should have alertIsPresent', async () => {
@@ -182,67 +182,67 @@ describe('expected conditions', () => {
       const EC2 = browser2.ExpectedConditions;
       const alertIsPresent = EC2.alertIsPresent();
       expect(await alertIsPresent.call()).toBe(false);
-      
+
       const alertButton = browser2.$('#alertbutton');
       await alertButton.click();
       await browser2.wait(EC2.alertIsPresent(), 1000);
-      
+
       await browser2.switchTo().alert().accept();
     });
   });
-  
+
   describe('race condition handling', () => {
-    
+
     let disabledButton;
-    
+
     beforeEach(() => {
       disabledButton = $('#disabledButton[disabled="disabled"]');
     });
-    
+
     const enableButtonBeforeCallToUnmatchSelector = async (testElement, fnName) => {
       const originalFn = testElement[fnName];
-      
+
       testElement[fnName] = async () => {
         await element(by.model('disabled')).click();
         return originalFn.apply(this, arguments);
       };
-      
+
       // save original fn with _ prefix
       testElement[`_${fnName}`] = originalFn;
     };
-    
+
     it('can deal with missing elements in visibilityOf', async () => {
       await enableButtonBeforeCallToUnmatchSelector(disabledButton, 'isDisplayed');
-      
+
       await element(by.model('disabled')).click();
-      
+
       expect(await disabledButton._isDisplayed()).toBe(true);
       expect(await EC.visibilityOf(disabledButton).call()).toBe(false);
     });
-    
+
     it('can deal with missing elements in textToBePresentInElement', async () => {
       await enableButtonBeforeCallToUnmatchSelector(disabledButton, 'getText');
-      
+
       await element(by.model('disabled')).click();
-      
+
       expect(await disabledButton._getText()).toBe('Dummy');
       expect(await EC.textToBePresentInElement(disabledButton, 'Dummy').call()).toBe(false);
     });
-    
+
     it('can deal with missing elements in textToBePresentInValue', async () => {
       await enableButtonBeforeCallToUnmatchSelector(disabledButton, 'getAttribute');
-      
+
       await element(by.model('disabled')).click();
-      
+
       expect(await disabledButton._getAttribute('value')).toBe('');
       expect(await EC.textToBePresentInElementValue(disabledButton, '').call()).toBe(false);
     });
-    
+
     it('can deal with missing elements in elementToBeClickable', async () => {
       await enableButtonBeforeCallToUnmatchSelector(disabledButton, 'isEnabled');
-      
+
       await element(by.model('disabled')).click();
-      
+
       expect(await disabledButton._isEnabled()).toBe(false);
       expect(await EC.elementToBeClickable(disabledButton).call()).toBe(false);
     });