From 91b49434bf792e3971c84e30c8af546b95fa6755 Mon Sep 17 00:00:00 2001 From: Sergey Knysh Date: Thu, 13 Feb 2020 10:27:26 +0300 Subject: [PATCH 1/3] #29 specified intervals for conditional wait tests --- .../waitings/BaseConditionalWaitTest.java | 2 +- .../tests/waitings/WaitForObjectTests.java | 58 ++++++++++--------- .../java/tests/waitings/WaitForTests.java | 4 +- .../java/tests/waitings/WaitForTrueTests.java | 2 +- src/test/java/utils/Timer.java | 4 +- 5 files changed, 35 insertions(+), 35 deletions(-) diff --git a/src/test/java/tests/waitings/BaseConditionalWaitTest.java b/src/test/java/tests/waitings/BaseConditionalWaitTest.java index 247d592..40b5cd9 100644 --- a/src/test/java/tests/waitings/BaseConditionalWaitTest.java +++ b/src/test/java/tests/waitings/BaseConditionalWaitTest.java @@ -17,7 +17,7 @@ class BaseConditionalWaitTest { static final long waitForTimeoutCondition = 10; static final long waitForTimeoutPolling = 150; - static final long accuracy = 3; + static final double accuracy = 0.5; static final Collection> ignoredExceptions = Collections.singleton(IllegalStateException.class); ThreadLocal timer = ThreadLocal.withInitial(Timer::new); protected Provider application = AqualityServices.getServiceProvider().getProvider(IApplication.class); diff --git a/src/test/java/tests/waitings/WaitForObjectTests.java b/src/test/java/tests/waitings/WaitForObjectTests.java index c5d38c0..a2dce9b 100644 --- a/src/test/java/tests/waitings/WaitForObjectTests.java +++ b/src/test/java/tests/waitings/WaitForObjectTests.java @@ -37,15 +37,15 @@ public Object[][] failWaitForAction() { } @Test(dataProvider = "failWaitForAction") - public void testShouldThrowTimeoutExceptionIfConditionIsNotMetAndTimeoutIsOver(Callable failedAction, long timeout) throws Exception { + public void testShouldThrowTimeoutExceptionIfConditionIsNotMetAndTimeoutIsOver(Callable failedAction, long timeout, double pollingInterval) throws Exception { timer.get().start(); try { failedAction.call(); } catch (TimeoutException e) { double duration = timer.get().stop(); - long interval = 2 * timeout + accuracy; + double interval = timeout + pollingInterval / 1000 + accuracy; assertTrue(duration >= timeout && duration < interval, - String.format("Duration '%s' should be between '%s' and '%s' (timeout and (2*timeout + accuracy)) when condition is not satisfied. ", + String.format("Duration '%s' should be between '%s' and '%s' (timeout and (timeout + pollingInterval + accuracy)) when condition is not satisfied.", duration, timeout, interval)); } } @@ -56,13 +56,14 @@ public Object[][] successWaitForAction() { } @Test(dataProvider = "successWaitForAction") - public void testShouldReturnAnObjectIfConditionIsMetAndTimeoutIsNotOver(Callable successAction, long timeout) throws Exception { + public void testShouldReturnAnObjectIfConditionIsMetAndTimeoutIsNotOver(Callable successAction, long timeout, double pollingInterval) throws Exception { timer.get().start(); String result = successAction.call(); double duration = timer.get().stop(); - assertTrue(duration <= timeout, - String.format("Duration '%s' should be less than accuracyTimeout '%s'", - duration, timeout)); + double accuracyPollingInterval = pollingInterval / 1000 + accuracy; + assertTrue(duration < accuracyPollingInterval, + String.format("Duration '%s' should be less than accuracy polling interval '%s'", + duration, accuracyPollingInterval)); assertEquals(result, RESULT_STRING, "Method should return correct object"); } @@ -74,15 +75,16 @@ public Object[][] throwWaitForAction() { } @Test(dataProvider = "throwWaitForAction") - public void testShouldThrowException(Callable throwAction, long timeout) throws Exception { + public void testShouldThrowException(Callable throwAction, long timeout, double pollingInterval) throws Exception { try { timer.get().start(); throwAction.call(); } catch (IllegalArgumentException e) { double duration = timer.get().stop(); - assertTrue(duration <= timeout, - String.format("Duration '%s' should be less than accuracyTimeout '%s'", - duration, timeout)); + double accuracyPollingInterval = pollingInterval / 1000 + accuracy; + assertTrue(duration < accuracyPollingInterval, + String.format("Duration '%s' should be less than accuracy polling interval '%s'", + duration, accuracyPollingInterval)); assertEquals(e.getMessage(), "I am exception", "It should be custom exception"); } } @@ -91,39 +93,39 @@ public void testShouldThrowException(Callable throwAction, long timeout) public void testShouldIgnoreExceptionForWaitingWithoutCustomParameters() { AtomicBoolean atomicBoolean = new AtomicBoolean(true); BooleanSupplier actionWithExceptions = () -> conditionalWait.waitFor((driver) -> throwNewException(atomicBoolean).getAsBoolean(), ignoredExceptions); - checkWaitForMethodForPassedCondition(actionWithExceptions, timeoutConfiguration.getCondition()); + checkWaitForMethodForPassedCondition(actionWithExceptions, timeoutConfiguration.getPollingInterval()); } @Test public void testShouldIgnoreExceptionForWaitingWithDefaultTimeout() { AtomicBoolean atomicBoolean = new AtomicBoolean(true); BooleanSupplier actionWithMessageAndExceptions = () -> conditionalWait.waitFor((driver) -> throwNewException(atomicBoolean).getAsBoolean(), "Condition should be true", ignoredExceptions); - checkWaitForMethodForPassedCondition(actionWithMessageAndExceptions, timeoutConfiguration.getCondition()); + checkWaitForMethodForPassedCondition(actionWithMessageAndExceptions, timeoutConfiguration.getPollingInterval()); } @Test public void testShouldIgnoreExceptionWaitingWithCustomTimeoutAndExceptions() { AtomicBoolean atomicBoolean = new AtomicBoolean(true); BooleanSupplier actionWithAllParameters = () -> conditionalWait.waitFor((driver) -> throwNewException(atomicBoolean).getAsBoolean(), waitForTimeoutCondition, waitForTimeoutPolling, ignoredExceptions); - checkWaitForMethodForPassedCondition(actionWithAllParameters, waitForTimeoutCondition); + checkWaitForMethodForPassedCondition(actionWithAllParameters, waitForTimeoutPolling); } @Test public void testShouldIgnoreExceptionWaitingWithCustomTimeout() { AtomicBoolean atomicBoolean = new AtomicBoolean(true); BooleanSupplier actionWithAllParameters = () -> conditionalWait.waitFor((driver) -> throwNewException(atomicBoolean).getAsBoolean(), waitForTimeoutCondition, waitForTimeoutPolling, "Condition should be true", ignoredExceptions); - checkWaitForMethodForPassedCondition(actionWithAllParameters, waitForTimeoutCondition); + checkWaitForMethodForPassedCondition(actionWithAllParameters, waitForTimeoutPolling); } - private void checkWaitForMethodForPassedCondition(BooleanSupplier waitAction, long timeout) { - long accuracyTimeout = timeout + accuracy; + private void checkWaitForMethodForPassedCondition(BooleanSupplier waitAction, double pollingInterval) { timer.get().start(); boolean result = waitAction.getAsBoolean(); double duration = timer.get().stop(); + double doubleAccuracyPollingInterval = 2 * pollingInterval / 1000 + accuracy; assertTrue(result, "waitFor should return true when condition is satisfied."); - assertTrue(duration <= accuracyTimeout, - String.format("Duration '%s' should be less than accuracyTimeout '%s'", - duration, accuracyTimeout)); + assertTrue(duration < doubleAccuracyPollingInterval, + String.format("Duration '%s' should be less than double accuracy polling interval '%s'", + duration, doubleAccuracyPollingInterval)); } private Object[][] getDataProvider(ExpectedCondition action) { @@ -136,14 +138,14 @@ private Object[][] getDataProvider(ExpectedCondition action) { Callable actionWithCustomTimeoutsAndExceptions = () -> conditionalWait.waitFor(action, waitForTimeoutCondition, waitForTimeoutPolling, Collections.emptyList()); Callable actionWithAllParameters = () -> conditionalWait.waitFor(action, waitForTimeoutCondition, waitForTimeoutPolling, "Condition should be true", Collections.emptyList()); return new Object[][]{ - {onlyAction, timeoutConfiguration.getCondition()}, - {actionWithMessage, timeoutConfiguration.getCondition()}, - {actionWithExceptions, timeoutConfiguration.getCondition()}, - {actionWithMessageAndExceptions, timeoutConfiguration.getCondition()}, - {actionWithCustomTimeouts, waitForTimeoutCondition}, - {actionWithCustomTimeoutsAndMessage, waitForTimeoutCondition}, - {actionWithCustomTimeoutsAndExceptions, waitForTimeoutCondition}, - {actionWithAllParameters, waitForTimeoutCondition}, + {onlyAction, timeoutConfiguration.getCondition(), timeoutConfiguration.getPollingInterval()}, + {actionWithMessage, timeoutConfiguration.getCondition(), timeoutConfiguration.getPollingInterval()}, + {actionWithExceptions, timeoutConfiguration.getCondition(), timeoutConfiguration.getPollingInterval()}, + {actionWithMessageAndExceptions, timeoutConfiguration.getCondition(), timeoutConfiguration.getPollingInterval()}, + {actionWithCustomTimeouts, waitForTimeoutCondition, waitForTimeoutPolling}, + {actionWithCustomTimeoutsAndMessage, waitForTimeoutCondition, waitForTimeoutPolling}, + {actionWithCustomTimeoutsAndExceptions, waitForTimeoutCondition, waitForTimeoutPolling}, + {actionWithAllParameters, waitForTimeoutCondition, waitForTimeoutPolling} }; } } diff --git a/src/test/java/tests/waitings/WaitForTests.java b/src/test/java/tests/waitings/WaitForTests.java index b8ded4d..289b933 100644 --- a/src/test/java/tests/waitings/WaitForTests.java +++ b/src/test/java/tests/waitings/WaitForTests.java @@ -23,7 +23,7 @@ public void testFalseShouldBeReturnedIfConditionIsNotMetAndTimeoutIsOver(Boolean Date startTime = new Date(); boolean result = waitAction.getAsBoolean(); long duration = (new Date().getTime() - startTime.getTime()) / 1000; - long interval = 2 * timeout + accuracy; + double interval = 2 * timeout + accuracy; assertFalse(result, "waitFor should return false when condition is not satisfied."); assertTrue(duration >= timeout && duration < interval, String.format("Duration '%s' should be between '%s' and '%s' (timeout and (2*timeout + accuracy)) when condition is not satisfied. ", @@ -69,7 +69,7 @@ public void testShouldIgnoreExceptionWaitingWithCustomTimeout() { } private void checkWaitForMethodForPassedCondition(BooleanSupplier waitAction, long timeout) { - long accuracyTimeout = timeout + accuracy; + double accuracyTimeout = timeout + accuracy; timer.get().start(); boolean result = waitAction.getAsBoolean(); double duration = timer.get().stop(); diff --git a/src/test/java/tests/waitings/WaitForTrueTests.java b/src/test/java/tests/waitings/WaitForTrueTests.java index f3bf3f0..62c9c13 100644 --- a/src/test/java/tests/waitings/WaitForTrueTests.java +++ b/src/test/java/tests/waitings/WaitForTrueTests.java @@ -26,7 +26,7 @@ public void testTimeoutExceptionShouldBeThrownIfConditionIsMetAndTimeoutIsOver(C waitForTrueAction.call(); } catch (TimeoutException e) { double duration = timer.get().stop(); - long interval = 2 * timeout + accuracy; + double interval = 2 * timeout + accuracy; assertTrue(duration >= timeout && duration < interval, String.format("Duration '%s' should be between '%s' and '%s' (timeout and (2*timeout + accuracy)) when condition is not satisfied.", duration, timeout, interval)); diff --git a/src/test/java/utils/Timer.java b/src/test/java/utils/Timer.java index 01c5095..4cdcaa4 100644 --- a/src/test/java/utils/Timer.java +++ b/src/test/java/utils/Timer.java @@ -4,9 +4,7 @@ public class Timer { private double startTime; public void start() { - if (startTime == 0) { - startTime = getCurrentTimeInSeconds(); - } + startTime = getCurrentTimeInSeconds(); } public double stop() { From 121f5b2c810ba3fdbf6568d1c154ae5a4637631e Mon Sep 17 00:00:00 2001 From: Sergey Knysh Date: Thu, 13 Feb 2020 10:46:13 +0300 Subject: [PATCH 2/3] #29 specified intervals for conditional wait tests --- .../java/tests/waitings/WaitForTests.java | 58 ++++++++++--------- 1 file changed, 31 insertions(+), 27 deletions(-) diff --git a/src/test/java/tests/waitings/WaitForTests.java b/src/test/java/tests/waitings/WaitForTests.java index 289b933..977112a 100644 --- a/src/test/java/tests/waitings/WaitForTests.java +++ b/src/test/java/tests/waitings/WaitForTests.java @@ -19,15 +19,15 @@ public Object[][] falseWaitForAction() { } @Test(dataProvider = "falseWaitForAction") - public void testFalseShouldBeReturnedIfConditionIsNotMetAndTimeoutIsOver(BooleanSupplier waitAction, long timeout) { - Date startTime = new Date(); + public void testFalseShouldBeReturnedIfConditionIsNotMetAndTimeoutIsOver(BooleanSupplier waitAction, long timeout, double pollingInterval) { + timer.get().start(); boolean result = waitAction.getAsBoolean(); - long duration = (new Date().getTime() - startTime.getTime()) / 1000; - double interval = 2 * timeout + accuracy; + double duration = timer.get().stop(); + double accuracyPollingInterval = timeout + pollingInterval / 1000 + accuracy; assertFalse(result, "waitFor should return false when condition is not satisfied."); - assertTrue(duration >= timeout && duration < interval, - String.format("Duration '%s' should be between '%s' and '%s' (timeout and (2*timeout + accuracy)) when condition is not satisfied. ", - duration, timeout, interval)); + assertTrue(duration >= timeout && duration < accuracyPollingInterval, + String.format("Duration '%s' should be between '%s' and '%s' (timeout and (timeout + pollingInterval + accuracy)) when condition is not satisfied.", + duration, timeout, accuracyPollingInterval)); } @DataProvider(name = "trueWaitForAction", parallel = true) @@ -36,47 +36,51 @@ public Object[][] trueWaitForAction() { } @Test(dataProvider = "trueWaitForAction") - public void testTrueShouldBeReturnedIfConditionIsMetAndTimeoutIsNotOver(BooleanSupplier waitAction, long timeout) { - checkWaitForMethodForPassedCondition(waitAction, timeout); + public void testTrueShouldBeReturnedIfConditionIsMetAndTimeoutIsNotOver(BooleanSupplier waitAction, long timeout, double pollingInterval) { + double checkedTimeout = pollingInterval / 1000 + accuracy; + checkWaitForMethodForPassedCondition(waitAction, checkedTimeout); } @Test public void testShouldIgnoreExceptionForWaitingWithoutCustomParameters() { AtomicBoolean atomicBoolean = new AtomicBoolean(true); BooleanSupplier actionWithExceptions = () -> conditionalWait.waitFor(throwNewException(atomicBoolean), ignoredExceptions); - checkWaitForMethodForPassedCondition(actionWithExceptions, timeoutConfiguration.getCondition()); + double checkedTimeout = (double) timeoutConfiguration.getPollingInterval() * 2 / 1000 + accuracy; + checkWaitForMethodForPassedCondition(actionWithExceptions, checkedTimeout); } @Test public void testShouldIgnoreExceptionForWaitingWithDefaultTimeout() { AtomicBoolean atomicBoolean = new AtomicBoolean(true); BooleanSupplier actionWithMessageAndExceptions = () -> conditionalWait.waitFor(throwNewException(atomicBoolean), "Condition should be true", ignoredExceptions); - checkWaitForMethodForPassedCondition(actionWithMessageAndExceptions, timeoutConfiguration.getCondition()); + double checkedTimeout = (double) timeoutConfiguration.getPollingInterval() * 2 / 1000 + accuracy; + checkWaitForMethodForPassedCondition(actionWithMessageAndExceptions, checkedTimeout); } @Test public void testShouldIgnoreExceptionWaitingWithCustomTimeoutAndException() { AtomicBoolean atomicBoolean = new AtomicBoolean(true); BooleanSupplier actionWithAllParameters = () -> conditionalWait.waitFor(throwNewException(atomicBoolean), waitForTimeoutCondition, waitForTimeoutPolling, ignoredExceptions); - checkWaitForMethodForPassedCondition(actionWithAllParameters, waitForTimeoutCondition); + double checkedTimeout = (double) waitForTimeoutPolling * 2 / 1000 + accuracy; + checkWaitForMethodForPassedCondition(actionWithAllParameters, checkedTimeout); } @Test public void testShouldIgnoreExceptionWaitingWithCustomTimeout() { AtomicBoolean atomicBoolean = new AtomicBoolean(true); BooleanSupplier actionWithAllParameters = () -> conditionalWait.waitFor(throwNewException(atomicBoolean), waitForTimeoutCondition, waitForTimeoutPolling, "Condition should be true", ignoredExceptions); - checkWaitForMethodForPassedCondition(actionWithAllParameters, waitForTimeoutCondition); + double checkedTimeout = (double) waitForTimeoutPolling * 2 / 1000 + accuracy; + checkWaitForMethodForPassedCondition(actionWithAllParameters, checkedTimeout); } - private void checkWaitForMethodForPassedCondition(BooleanSupplier waitAction, long timeout) { - double accuracyTimeout = timeout + accuracy; + private void checkWaitForMethodForPassedCondition(BooleanSupplier waitAction, double checkedTimeout) { timer.get().start(); boolean result = waitAction.getAsBoolean(); double duration = timer.get().stop(); assertTrue(result, "waitFor should return true when condition is satisfied."); - assertTrue(duration <= timeout, - String.format("Duration '%s' should be less than accuracyTimeout '%s'", - duration, accuracyTimeout)); + assertTrue(duration < checkedTimeout, + String.format("Duration '%s' should be less than timeout '%s'", + duration, checkedTimeout)); } @DataProvider(name = "throwExceptionAction", parallel = true) @@ -88,7 +92,7 @@ public Object[][] throwExceptionAction() { } @Test(dataProvider = "throwExceptionAction", expectedExceptions = StaleElementReferenceException.class) - public void testShouldThrowException(BooleanSupplier waitAction, long timeout) { + public void testShouldThrowException(BooleanSupplier waitAction, long timeout, double pollingInterval) { waitAction.getAsBoolean(); } @@ -107,14 +111,14 @@ private Object[][] getDataProvider(BooleanSupplier action) { BooleanSupplier actionWithCustomTimeoutsAndExceptions = () -> conditionalWait.waitFor(action, waitForTimeoutCondition, waitForTimeoutPolling, Collections.emptyList()); BooleanSupplier actionWithAllParameters = () -> conditionalWait.waitFor(action, waitForTimeoutCondition, waitForTimeoutPolling, "Condition should be true", Collections.emptyList()); return new Object[][]{ - {onlyAction, timeoutConfiguration.getCondition()}, - {actionWithMessage, timeoutConfiguration.getCondition()}, - {actionWithExceptions, timeoutConfiguration.getCondition()}, - {actionWithMessageAndExceptions, timeoutConfiguration.getCondition()}, - {actionWithCustomTimeouts, waitForTimeoutCondition}, - {actionWithCustomTimeoutsAndMessage, waitForTimeoutCondition}, - {actionWithCustomTimeoutsAndExceptions, waitForTimeoutCondition}, - {actionWithAllParameters, waitForTimeoutCondition}, + {onlyAction, timeoutConfiguration.getCondition(), timeoutConfiguration.getPollingInterval()}, + {actionWithMessage, timeoutConfiguration.getCondition(), timeoutConfiguration.getPollingInterval()}, + {actionWithExceptions, timeoutConfiguration.getCondition(), timeoutConfiguration.getPollingInterval()}, + {actionWithMessageAndExceptions, timeoutConfiguration.getCondition(), timeoutConfiguration.getPollingInterval()}, + {actionWithCustomTimeouts, waitForTimeoutCondition, waitForTimeoutPolling}, + {actionWithCustomTimeoutsAndMessage, waitForTimeoutCondition, waitForTimeoutPolling}, + {actionWithCustomTimeoutsAndExceptions, waitForTimeoutCondition, waitForTimeoutPolling}, + {actionWithAllParameters, waitForTimeoutCondition, waitForTimeoutPolling}, }; } } From 059f60a70a5e6bcedfc7de890002c4ce882af8ef Mon Sep 17 00:00:00 2001 From: Sergey Knysh Date: Thu, 13 Feb 2020 11:57:09 +0300 Subject: [PATCH 3/3] #29 specified intervals for conditional wait tests --- .../tests/waitings/WaitForObjectTests.java | 3 + .../java/tests/waitings/WaitForTrueTests.java | 76 ++++++++++--------- 2 files changed, 45 insertions(+), 34 deletions(-) diff --git a/src/test/java/tests/waitings/WaitForObjectTests.java b/src/test/java/tests/waitings/WaitForObjectTests.java index a2dce9b..f4a20fb 100644 --- a/src/test/java/tests/waitings/WaitForObjectTests.java +++ b/src/test/java/tests/waitings/WaitForObjectTests.java @@ -2,6 +2,7 @@ import org.openqa.selenium.TimeoutException; import org.openqa.selenium.support.ui.ExpectedCondition; +import org.testng.Assert; import org.testng.annotations.AfterMethod; import org.testng.annotations.BeforeMethod; import org.testng.annotations.DataProvider; @@ -41,6 +42,7 @@ public void testShouldThrowTimeoutExceptionIfConditionIsNotMetAndTimeoutIsOver(C timer.get().start(); try { failedAction.call(); + Assert.fail("TimeoutException should be thrown but not"); } catch (TimeoutException e) { double duration = timer.get().stop(); double interval = timeout + pollingInterval / 1000 + accuracy; @@ -79,6 +81,7 @@ public void testShouldThrowException(Callable throwAction, long timeout, try { timer.get().start(); throwAction.call(); + Assert.fail("IllegalArgumentException should be thrown but not"); } catch (IllegalArgumentException e) { double duration = timer.get().stop(); double accuracyPollingInterval = pollingInterval / 1000 + accuracy; diff --git a/src/test/java/tests/waitings/WaitForTrueTests.java b/src/test/java/tests/waitings/WaitForTrueTests.java index 62c9c13..908e4e1 100644 --- a/src/test/java/tests/waitings/WaitForTrueTests.java +++ b/src/test/java/tests/waitings/WaitForTrueTests.java @@ -1,6 +1,7 @@ package tests.waitings; import org.openqa.selenium.StaleElementReferenceException; +import org.testng.Assert; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; @@ -20,16 +21,17 @@ public Object[][] falseWaitForAction() { } @Test(dataProvider = "falseWaitForTrueAction") - public void testTimeoutExceptionShouldBeThrownIfConditionIsMetAndTimeoutIsOver(Callable waitForTrueAction, long timeout) throws Exception { + public void testTimeoutExceptionShouldBeThrownIfConditionIsMetAndTimeoutIsOver(Callable waitForTrueAction, long timeout, double pollingInterval) throws Exception { timer.get().start(); try { waitForTrueAction.call(); + Assert.fail("TimeoutException should be thrown but not"); } catch (TimeoutException e) { double duration = timer.get().stop(); - double interval = 2 * timeout + accuracy; - assertTrue(duration >= timeout && duration < interval, - String.format("Duration '%s' should be between '%s' and '%s' (timeout and (2*timeout + accuracy)) when condition is not satisfied.", - duration, timeout, interval)); + double accuracyPollingInterval = timeout + pollingInterval / 1000 + accuracy; + assertTrue(duration >= timeout && duration < accuracyPollingInterval, + String.format("Duration '%s' should be between '%s' and '%s' (timeout and (timeout + pollingInterval + accuracy)) when condition is not satisfied.", + duration, timeout, accuracyPollingInterval)); } } @@ -39,13 +41,13 @@ public Object[][] successWaitForAction() { } @Test(dataProvider = "successWaitForAction") - public void testTimeoutExceptionShouldNotBeThrownIfConditionIsMetAndTimeoutIsNotOver(Callable waitForTrueAction, long timeout) throws Exception { + public void testTimeoutExceptionShouldNotBeThrownIfConditionIsMetAndTimeoutIsNotOver(Callable waitForTrueAction, long timeout, double pollingInterval) throws Exception { timer.get().start(); waitForTrueAction.call(); double duration = timer.get().stop(); - assertTrue(duration < timeout, - String.format("Duration '%s' should be less than timeout '%s' when condition is satisfied.", - duration, timeout)); + double accuracyPollingInterval = pollingInterval / 1000 + accuracy; + assertTrue(duration < accuracyPollingInterval, + String.format("Duration '%s' should be less than accuracy polling interval '%s'", duration, accuracyPollingInterval)); } @DataProvider(name = "throwExceptionAction", parallel = true) @@ -56,14 +58,19 @@ public Object[][] throwExceptionAction() { return getDataProvider(throwEx); } - @Test(dataProvider = "throwExceptionAction", expectedExceptions = StaleElementReferenceException.class) - public void testCustomExceptionShouldBeThrown(Callable waitForTrueAction, long timeout) throws Exception { - timer.get().start(); - waitForTrueAction.call(); - double duration = timer.get().stop(); - assertTrue(duration < timeout, - String.format("Duration '%s' should be less than timeout '%s' when condition is satisfied.", - duration, timeout)); + @Test(dataProvider = "throwExceptionAction") + public void testCustomExceptionShouldBeThrown(Callable waitForTrueAction, long timeout, double pollingInterval) throws Exception { + + try { + timer.get().start(); + waitForTrueAction.call(); + Assert.fail("StaleElementReferenceException should be thrown but not"); + } catch (StaleElementReferenceException e) { + double duration = timer.get().stop(); + double accuracyPollingInterval = pollingInterval / 1000 + accuracy; + assertTrue(duration < accuracyPollingInterval, + String.format("Duration '%s' should be less than accuracy polling interval '%s'", duration, accuracyPollingInterval)); + } } @Test(expectedExceptions = IllegalArgumentException.class) @@ -77,7 +84,7 @@ public void testCustomExceptionShouldBeIgnoredWithoutCustomParameters() throws E checkExceptionIsIgnored(() -> { conditionalWait.waitForTrue(throwNewException(atomicBoolean), ignoredExceptions); return true; - }, timeoutConfiguration.getCondition()); + }, timeoutConfiguration.getPollingInterval()); } @Test @@ -86,7 +93,7 @@ public void testCustomExceptionShouldBeIgnoredWithDefaultTimeout() throws Except checkExceptionIsIgnored(() -> { conditionalWait.waitForTrue(throwNewException(atomicBoolean), "Condition should be true", ignoredExceptions); return true; - }, timeoutConfiguration.getCondition()); + }, timeoutConfiguration.getPollingInterval()); } @Test @@ -95,7 +102,7 @@ public void testCustomExceptionShouldBeIgnoredWithCustomTimeoutAndException() th checkExceptionIsIgnored(() -> { conditionalWait.waitForTrue(throwNewException(atomicBoolean), waitForTimeoutCondition, waitForTimeoutPolling, ignoredExceptions); return true; - }, waitForTimeoutCondition); + }, waitForTimeoutPolling); } @Test @@ -104,16 +111,17 @@ public void testCustomExceptionShouldBeIgnoredWithCustomTimeout() throws Excepti checkExceptionIsIgnored(() -> { conditionalWait.waitForTrue(throwNewException(atomicBoolean), waitForTimeoutCondition, waitForTimeoutPolling, "Condition should be true", ignoredExceptions); return true; - }, waitForTimeoutCondition); + }, waitForTimeoutPolling); } - private void checkExceptionIsIgnored(Callable waitForTrueAction, long timeout) throws Exception { + private void checkExceptionIsIgnored(Callable waitForTrueAction, double pollingInterval) throws Exception { timer.get().start(); waitForTrueAction.call(); double duration = timer.get().stop(); - assertTrue(duration < timeout, - String.format("Duration '%s' should be less than timeout '%s' when condition is satisfied.", - duration, timeout)); + double doubleAccuracyPollingInterval = 2 * pollingInterval / 1000 + accuracy; + assertTrue(duration < doubleAccuracyPollingInterval, + String.format("Duration '%s' should be less than double accuracy polling interval '%s'", + duration, doubleAccuracyPollingInterval)); } private Object[][] getDataProvider(BooleanSupplier action) { @@ -134,7 +142,7 @@ private Object[][] getDataProvider(BooleanSupplier action) { }; Callable actionWithMessageAndExceptions = () -> { - conditionalWait.waitFor(action, "Condition should be true", Collections.emptyList()); + conditionalWait.waitForTrue(action, "Condition should be true", Collections.emptyList()); return true; }; @@ -159,14 +167,14 @@ private Object[][] getDataProvider(BooleanSupplier action) { }; return new Object[][]{ - {onlyAction, timeoutConfiguration.getCondition()}, - {actionWithMessage, timeoutConfiguration.getCondition()}, - {actionWithExceptions, timeoutConfiguration.getCondition()}, - {actionWithMessageAndExceptions, timeoutConfiguration.getCondition()}, - {actionWithCustomTimeouts, waitForTimeoutCondition}, - {actionWithCustomTimeoutsAndMessage, waitForTimeoutCondition}, - {actionWithCustomTimeoutsAndException, waitForTimeoutCondition}, - {actionWithAllParameters, waitForTimeoutCondition}, + {onlyAction, timeoutConfiguration.getCondition(), timeoutConfiguration.getPollingInterval()}, + {actionWithMessage, timeoutConfiguration.getCondition(), timeoutConfiguration.getPollingInterval()}, + {actionWithExceptions, timeoutConfiguration.getCondition(), timeoutConfiguration.getPollingInterval()}, + {actionWithMessageAndExceptions, timeoutConfiguration.getCondition(), timeoutConfiguration.getPollingInterval()}, + {actionWithCustomTimeouts, waitForTimeoutCondition, waitForTimeoutPolling}, + {actionWithCustomTimeoutsAndMessage, waitForTimeoutCondition, waitForTimeoutPolling}, + {actionWithCustomTimeoutsAndException, waitForTimeoutCondition, waitForTimeoutPolling}, + {actionWithAllParameters, waitForTimeoutCondition, waitForTimeoutPolling}, }; } }