Thread.sleep() Method in Java – Complete Tutorial With Example
Published: 2023-07-27 07:29:45

### Thread.sleep() Method in Java — Complete Tutorial With Example

Steve (a fresher) recently joined our team as a Test Engineer. He was passionate and eager to learn new techniques and technologies and gain expertise in [software testing](https://www.lambdatest.com/learning-hub/software-testing?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub). We were working on an application that eased the customers’ pain of making offline medical payments by standing in queues to bring it all at their fingertips and make the payments online.

It was a web application that helped customers to make payments easily using their Debit and Credit Cards. It had an intuitive interface that could be easily learned to use.

As it was a web application, our team agreed to use [Selenium WebDriver with Java](https://www.lambdatest.com/blog/selenium-with-java/?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=blog), as most of the application was written using Java. Steve was given one task of automating the payment page. It had some fields related to the Credit/Debit Card numbers, CVV, and some fields to accept user details like First Name, Last Name, Address, etc.

It was an easy task; however, since Steve was new to the [test automation](https://www.lambdatest.com/learning-hub/automation-testing?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub) field, he could automate most of the stuff. However, he struggled with one automation test case where he had to click on the Continue button of a pop-up message after entering the card details for making a payment. As he could not find a solution, he approached me with the query, and we decided to debug the test further for the failure.

We thought it might be an issue related to the incorrect locator of the Continue button. [Locators in Selenium](https://www.lambdatest.com/learning-hub/selenium-locators?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub) play a significant role in interacting with the web elements. Initially, XPath was used to locate the Continue button, so we changed it to [CSS Selector](https://www.lambdatest.com/learning-hub/css-selectors?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub) as it is faster and simpler than XPath. However, the test was still unable to click on the Continue button.

To debug the issue, we decided to use *Thread.sleep()* in the code to pause the code for 3 seconds and place it above the code statement where we were clicking on the Continue button. Voila, the test ran successfully!!

When we investigated the problem further, we found that it took some time for the pop-up to appear on the screen. However, by the time the pop-up appeared, the code had passed the lines where it needed to click on the Continue button. Due to this, the test failed. Many test automation engineers might have faced a similar issue as well. The learnings of this blog on using *Thread.sleep()* in Java can be useful in resolving such issues.

In this [Selenium Java](https://www.lambdatest.com/learning-hub/selenium-java?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub) tutorial, we will be talking about *Thread.sleep()* in Java to pause the code execution for some time and will move towards the best practices of using [Selenium’s Implicit, Explicit and Fluent Waits](https://www.lambdatest.com/blog/types-of-waits-in-selenium/?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=blog) in the code for saving the time in test automation code execution.

***Learn the essential concepts, techniques, and strategies for high-quality software through effective*** [***Software Quality Assurance***](https://www.lambdatest.com/learning-hub/software-quality-assurance?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub)***. This guide covers its importance, benefits, practical tips, and best practices***

### What is Thread.sleep()?

*Thread* class is present in java.lang package and contains the *sleep()* method in it.  
*Thread.sleep()* stops the execution of a program in the current thread for a certain time as per the duration specified as a parameter.

This is a blocking wait unless any other thread generates an interrupt. So, when it comes to using T*hread.sleep()* in test automation, it can have huge repercussions if the delay is high.

The *sleep()* method does not return any value as the method is void. It throws an *InterruptedException* in case any other thread interrupts the current thread.

The following image explains the life cycle of a thread –

![image](https://cdn-images-1.medium.com/max/800/0*oOfSl0YW85xKwhm8.png)

When a thread is created, it is in a New state meaning its code is yet to be run and is not started to execute.

Next, it moves to a Runnable instance, which means the code is in the state to run and can be executed at any time.

Running instance is where the code execution starts, after which the timed wait may be called for blocking or making the program wait for a fixed time duration, and the program will return to a runnable/running state after the duration has passed. For example, the *sleep()* method is called in Thread to make the thread wait for a timed duration.

Finally, the thread is Terminated either due to the program execution being complete or any error occurred, causing the program to exit abruptly. For example, an unhandled exception occurred.

There are two overloaded *sleep()* methods in the *Thread* class as follows:

* *sleep(long millis)*
    
* *sleep(long millis, int nanos)*
    

***Discover the ins and outs of*** [***UX testing***](https://www.lambdatest.com/learning-hub/ux-testing?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub) ***with this comprehensive guide. Explore various testing methods, tools, and best practices for measuring success***

### sleep(long millis)

This method accepts one parameter (i.e., duration of time in milliseconds). It throws an *InterruptedException* if any other thread interrupts the current thread.

Another exception this method can throw is an *IllegalArgumentException* when the value of milliseconds supplied in the parameter is negative or not in the range from *0–999999.*

**Example**

The following code shows a simple implementation of how to use *Thread.sleep()* to pause your automation tests for debugging purposes.

```plaintext
import java.lang.Thread;

@Test
public void testThreadSleep() throws InterruptedException {
WebDriver driver = new ChromeDriver();
driver.get("https://ecommerce-playground.lambdatest.io/");

Thread.sleep(3000);
String title = driver.getTitle();

System.out.println(title);
driver.quit();
}
```

The above snippet will create a new instance of *ChromeDriver* and navigate to the LambdaTest eCommerce playground. It will halt the test execution using *Thread.sleep* for 3 seconds(3000 milliseconds = 3 seconds). It will get the web page’s title and print it in the console. Finally, the *quit()* method of Selenium is called to quit the driver instance gracefully.

**Test Execution**

On executing the tests, the page title *“Your Store”* gets printed in the console. The total time taken to execute the tests is `10 seconds 561 ms`, which includes the `3000 milliseconds (3 seconds)` of *Thread.sleep()* method.

![image](https://cdn-images-1.medium.com/max/800/0*3FaLL9jT_EL7jLfn.png )

### sleep(long millis, int nanos)

This is an overloaded version of the *sleep()* method we discussed in the earlier section of this blog on using *Thread.sleep()* in Java. It accepts two parameters, the first duration of time in milliseconds, and the second is the time in nanoseconds that is provided as additional time for the thread to sleep.

It throws an *InterruptedException* in case any other thread interrupts the current thread. *IllegalArgumentException* is thrown when the values in any of the two parameters are provided as negative or are not in the range *0–999999.*

**Example**

The following snippet shows a simple implementation of how to use *Thread.sleep()* to pause your automation tests for debugging purposes.

```plaintext
import java.lang.Thread;

@Test
public void testThreadSleep() throws InterruptedException {
WebDriver driver = new ChromeDriver();
driver.get("https://ecommerce-playground.lambdatest.io/");

Thread.sleep(3000);
String title = driver.getTitle();

System.out.println(title);
driver.quit();
}
```

The above snippet creates a new instance of *ChromeDriver*and navigates to the eCommerce playground. The execution is halted for 3000 milliseconds and 2 nanoseconds.

Next, it will fetch the current URL using Selenium’s *getCurrentUrl()* method and print the URL’s text in the console. Finally, Selenium’s *quit()* method will be called to quit the driver gracefully.

**Test Execution**

Here is the screenshot from IntelliJ that shows the [test execution](https://www.lambdatest.com/learning-hub/test-execution?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub).

![image](https://cdn-images-1.medium.com/max/800/0*0lMxlIoiqTtr3GtW.png )

The total time taken to execute tests is `11 seconds 161 ms`, including the time duration `(3000 milliseconds and 2000 nanoseconds)` added in the *Thread.sleep()* method.

***Explore our comprehensive guide on*** [***GUI Testing***](https://www.lambdatest.com/learning-hub/gui-testing?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub)***, uncovering its vital role in software development. Learn about its different types, best practices, and steps for effective implementation to enhance your software’s user interaction.***

### Thread.sleep() example in a multi-threaded program

In the previous examples, we used *Thread.sleep()* in a single-threaded program, meaning only one thread was Running.

Let’s see how *Thread.sleep()* can be used in a multi-threaded program.

*FileName:* [*ThreadLocalExample.java*](http://ThreadLocalExample.java)

```plaintext
public class ThreadLocalExample implements Runnable {

private final ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>();

@Override
public void run() {
final long startTime = System.currentTimeMillis();
this.threadLocal.set((int) (Math.random() * 40D));
try {
Thread.sleep(2000);

} catch (final InterruptedException e) {
throw new RuntimeException(e);

}
final long endTime = System.currentTimeMillis();
final NumberFormat formatter = new DecimalFormat("#0.00000");
System.out.println("Thread Id - " + this.threadLocal.get() + " Execution time is " + formatter.format((endTime - startTime) / 1000d) + " seconds" + "\n");
}

public static void main(final String[] args) {
final ThreadLocalExample threadLocalExample = new ThreadLocalExample();
final Thread t1 = new Thread(threadLocalExample);
final Thread t2 = new Thread(threadLocalExample);
t1.start();
t2.start();
}
}
```

In this example, *ThreadLocalExample* class implements a Runnable interface that helps execute the thread. Runnable interface’s *run()* method is implemented in this class that sets the *ThreadLocal* value and gets the program’s start and end time in milliseconds.

*Thread.sleep()* blocks the thread for 2000 milliseconds (i.e., 2 seconds). Finally, the total time to run the program is printed in decimals.

**Test Execution**

The following screenshot from IntelliJ shows that the total time to execute the program was `2.00500 seconds`. This includes 2 seconds blocked by *Thread.sleep().*

![image](https://cdn-images-1.medium.com/max/800/0*xc_1Gz8BOOmgrSDL.png )

### Why is using Thread.sleep() discouraged?

[*Thread.sleep()*](https://www.lambdatest.com/blog/threadsleep-java-selenium/?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=blog) is a blocking call that halts the execution for some time and helps the automation tests to proceed successfully, with all the respective elements getting loaded for interaction.

**Problem 1**

Imagine putting *Thread.sleep()* in Java with 5 seconds stop time at 5 different places in the test. We are putting in *25 seconds* of hard waits in the test.

*Thread.sleep()* once set is set for the session’s lifetime.

**Problem 2**

Next problem we may face with *Thread.sleep()* in Java is that we might need to change the time duration if the time required for locating the element or performing action over the element keeps changing. For example, while running the test for the first time, the 3 seconds wait time worked fine with the *sleep()* method to locate an element and perform a click on it. However, in the next run, tests failed, and the duration was required to increase to 5 seconds.

This happens as fixed time duration is a flaky approach as locating elements also depends on external factors like rendering time, internet speeds, etc., some of which are not under our control. Flaky internet speeds can also cause the tests to fail even after adding *Thread.sleep().*

**Problem 3**

Another problem is the repetitive code we would require to add by adding the *Thread.sleep()* statement multiple times in the code. The statement must be applied before locating the web element or performing an action. In case multiple elements need some wait, we will have to add *Thread.sleep()* statements multiple times in the code, and there will be a time when our code will be mostly covered with *Thread.sleep()* statements.

We can use Selenium’s Waits to overcome this problem of hard waits. In the next section of this blog on the *Thread.sleep()* in Java, let’s study different types of Selenium Waits and how to implement them in the tests.

***Looking to manage your tests more efficiently? In this blog, explore a variety of*** [***test case management***](https://www.lambdatest.com/blog/best-test-management-tools/?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=blog) ***tools and select the one that suits your team’s needs:*** 

### Selenium Waits

Selenium Waits are the best replacement for *Thread.sleep()* as they help execute the [automated UI tests](https://www.lambdatest.com/automated-ui-testing?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=webpage) seamlessly on the browser. The issues that may arise due to variations in time lag can be easily handled using Selenium Waits. There are three types of Waits in [Selenium WebDriver](https://www.lambdatest.com/learning-hub/webdriver?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub):

* Implicit Wait
    
* Explicit Wait
    
* Fluent Wait
    

### Implicit Wait in Selenium WebDriver

Implicit wait is useful when certain elements on the web page are not available immediately and need some time to load. This wait polls the DOM for a certain duration as specified in the wait. By default, implicit wait is set to 0 and is disabled. Once set in tests, it is set for the session’s life.

*implicitlyWait()* method is available in the *timeouts()* interface in Selenium WebDriver. It accepts one parameter, that is, duration of time. This parameter can be supplied using the *Duration* class from java.time package.

Once implicit wait is set in the test, it is non-blocking and does not wait for the entire time duration like *Thread.sleep()*. This saves 5 seconds, whereas *Thread.sleep()* will halt the code execution in the current thread for a full 10 seconds and then only move to the next line.

If the web element is not found in the time duration set for the implicit wait, *NoSuchElementException* will be thrown. You can learn more about it through this blog on [Common Selenium Exceptions](https://www.lambdatest.com/blog/49-common-selenium-exceptions-automation-testing/?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=blog).

**Syntax**

![image](https://cdn-images-1.medium.com/max/800/0*Wrzvrv-cf-eqWcR5.png )

**Code Example**

```plaintext
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
```

### Explicit Wait in Selenium WebDriver

Explicit wait allows the test to wait for a certain time until the expected condition as specified in wait is met. It is applied for a single web element to load, unlike implicit wait, which applies to all the elements on the web page.

Applying explicit wait is non-blocking and does not wait for the entire session life cycle like *Thread.sleep()*.

When the expected condition is not met within the specified time, explicit wait throws *TimeoutException.*

**Syntax**

![image](https://cdn-images-1.medium.com/max/800/0*qhJG5YQ_fJDpnHeK.png )

For setting the explicit wait, we first need to instantiate the *WebDriverWait* class. This class needs an instance of *WebDriver* and time duration as constructor values. The *ExpectedConditions* can be set next by using the *until()* method.

Here is the list of some commonly used *ExpectedConditions* in explicit wait:

<table>
    <tr>
        <td>Expected Condition</td>
        <td>Description </td>
    </tr>
    <tr>
        <td>visibilityOfElementLocated(By locator)</td>
        <td>This condition checks that the element is present in the DOM and visible. This condition expects a By locator as a parameter for the method. </td>
    </tr>
    <tr>
        <td>visibilityOf(WebElement element)</td>
        <td>This condition checks that the element is present in the DOM and is visible. It expects a WebElement as a parameter for the method. </td>
    </tr>
    <tr>
        <td>alertIsPresent()</td>
        <td>This condition checks if the alert is present. </td>
    </tr>
    <tr>
        <td>elementToBeClickable(By locator)</td>
        <td>This condition checks that the element is present and visible and can be clicked. It expects a By locator as a parameter for the method. </td>
    </tr>
    <tr>
        <td>elementToBeClickable(WebElement element)</td>
        <td>This condition checks that the element is present, visible, and can be clicked. It expects a WebElement as a parameter for the method. </td>
    </tr>
    <tr>
        <td>presenceOfElementLocated(By locator)</td>
        <td>This condition checks that the element is present on the page using its By locator. </td>
    </tr>
    <tr>
        <td>textToBePresentInElement(WebElement element, final String text)</td>
        <td>This condition checks that the text is present in the WebElement. </td>
    </tr>
    <tr>
        <td>textToBePresentInElementLocated(By locator, final String text)</td>
        <td>This condition checks that the text in the WebElement matches the given locator.</td>
    </tr>
</table>

You can learn more about it through this blog on [*ExpectedConditions* in Selenium](https://www.lambdatest.com/blog/expected-conditions-in-selenium-examples/?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=blog).

The ultimate guide to [software testing metrics](https://www.lambdatest.com/learning-hub/software-testing-metrics?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub): definition, types, and examples explained for informed decisions. Enhance your testing process now.

**Code Example**

```plaintext
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
WebElement checkoutBtn = driver().findElement(By.cssSelector("#check"));
wait.until(ExpectedConditions.visibilityOf(checkoutBtn));
```

In the example above, the Checkout button on the web page is located using explicit wait. First, the *WebDriverWait* class is instantiated, providing the driver instance and time duration for the explicit wait. Next, the Checkout button is located and stored as a *WebElement*. Finally, the expected condition is written to wait until the Checkout button is visible.

As per [Selenium’s best practice](https://www.lambdatest.com/blog/selenium-best-practices-for-web-testing/?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=blog), it is recommended not to mix the implicit and explicit waits as it might lead to unpredictable wait times. For example, if an implicit wait of 10 seconds is

provided and an explicit wait of 15 seconds is also used, it might cause a timeout to occur after 20 seconds.

### Fluent Wait in Selenium WebDriver

Fluent wait allows you to wait for a maximum amount of time for a condition. It also allows to add the following two additional parameters to wait for that are not allowed in implicit and explicit waits –

* Polling Frequency
    
* Ignore Exceptions
    

**Polling Frequency**

It sets the frequency in which the condition should be checked. For example, the total timeout can be set for 10 seconds with a polling frequency of 2 seconds, i.e., the condition will be checked for 10 seconds in every 2 seconds frequency.

**Ignore Exceptions**

With fluent waits, we can also set it to ignore the exception that can appear while waiting for the condition. For example, the total timeout can be set to 10 seconds polling every 2 seconds and ignoring *“NoSuchElementException”*.

Note: If the fluent wait condition is not fulfilled within the specified time, it will throw TimeoutException.

**Syntax**

![image](https://cdn-images-1.medium.com/max/800/0*-33hN-uEhTH0HlZ7.png )

For setting fluent wait, we need to use the Wait interface and instantiate an instance of FluentWait class. After instantiating the FluentWait class, we can chain its following methods:

* *withTimeout():* Accepts the total time for which the wait needs to be implemented.
    
* *pollingEvery():* Accepts the polling frequency time duration.
    
* *ignoring():* Provides the exception name, which the fluent wait needs to ignore while waiting for the condition to be fulfilled.
    

**Code Example**

```plaintext
public String successMessageText() {
Wait<WebDriver> wait = new FluentWait<>(driver)
.withTimeout(Duration.ofSeconds(10))
.pollingEvery(Duration.ofSeconds(2))
.ignoring(NoSuchElementException.class);


WebElement successMessage = wait.until(driver -> notificationPopUp().findElement(By.tagName("p")));
return successMessage.getText();
```

In the above code example, a fluent wait has been implemented for 10 seconds that will be polling at a frequency of 2 seconds ignoring *NoSuchElementException.* This fluent wait will be used for locating the *successMessage* text from a web element, and finally, the text will be returned in String format.

Let’s now delve into coding and check out how to use *Thread.Sleep()* in Java. We will also check out how to use implicit, explicit, and fluent waits using Selenium WebDriver.

***This tutorial focuses on*** [***mobile ui testing***](https://www.lambdatest.com/learning-hub/mobile-ui-testing?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub)***, its significance, benefits, strategies, challenges, and best practices.***

### How to use Thread.sleep(), Implicit Wait, Explicit Wait, and Fluent Waits?

Before I take you on the tour of *Thread.sleep()* in Java and Selenium Waits, let’s first discuss the Application Under Test (AUT), the tools used, and the [test automation strategy](https://www.lambdatest.com/blog/effective-test-automation-strategy/?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=blog).

**Application Under Test:**

We will use LambdaTest’s eCommerce playground to demo Thread.sleep() in Java and the different Selenium Waits.

**Tools/Language used for running tests**

Following tools/language has been used in writing and running the tests:

* Programming Language: Java
    
* Mobile App Automation Tool: Selenium WebDriver (Version 4.10.0)
    
* Test Runner: [TestNG](https://www.lambdatest.com/learning-hub/testng?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub) (Version 7.8.0)
    
* Build Tool: [Maven](https://www.lambdatest.com/blog/getting-started-with-maven-for-selenium-testing/?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=blog)
    
* Cloud Platform to run the tests: LambdaTest.
    

**Test Scenario**

1. Launch the LambdaTest’s eCommerce playground.
    
2. Search for a product using the search box on the Home Screen.
    
3. On the product page, hover the mouse on the product.
    
4. Click on the Add to Cart button.
    
5. Click on the Checkout button on the pop-up message displayed.
    

![image](https://cdn-images-1.medium.com/max/800/0*thBDtV3hzofC7Yvw.png )

We must wait for the pop-up to appear and get the success message text. Next, we need to click on the Checkout button to checkout the product from the cart.

In the demo, we will first use the *Thread.sleep()* in Java to pause the test execution and then will use the explicit and fluent waits to replace *Thread.sleep()* and remove the hard waits from the test.

Before we move to product checkout, we need to perform two steps: logging in to the website and searching for a product, and finally, adding the product to the cart.

The following screen will be used to log in to the website.

![image](https://cdn-images-1.medium.com/max/800/0*MYlSn552pC7w4-QD.png )

The following screen will be used to search for the product.

![image](https://cdn-images-1.medium.com/max/800/0*9gX3P3RRs6ftI_As.png )

As this blog on [Java automation testing](https://www.lambdatest.com/java-automation-testing?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=webpage) focuses more on *Thread.sleep()* in Java and Selenium Waits, I will provide a minimal explanation of the two steps, i.e., logging in to the website and searching for a product.

![image](https://cdn-images-1.medium.com/max/800/0*QSyBM__b7X41hAqF.png )

**Implementation**

The project has been created using Maven, and the following image shows the structure of the project.

![image](https://cdn-images-1.medium.com/max/800/0*ypnYSlESmczmt1Yy.png )

Once the project is built, we need to add the dependencies for Selenium WebDriver and TestNG in the pom.xml. I preferably follow the best practice of including all the dependencies in the properties tab block in the pom.xml file. You can find out the details in the following screenshots:

*Dependencies in pom.xml*

![image](https://cdn-images-1.medium.com/max/800/0*S3dX1OpKyaH0od_W.png )

*Properties block in pom.xml*

![image](https://cdn-images-1.medium.com/max/800/0*wAx23CnNLPQrxvy8.png )

*FileName — pom.xml*

```plaintext

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>io.github.mfaisalkhatri</groupId>
<artifactId>selenium-wait-demo</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>

<name>selenium-wait-demo</name>
<url>http://maven.apache.org</url>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<selenium.java.version>4.10.0</selenium.java.version>
<testng.version>7.8.0</testng.version>
<maven.compiler.version>3.11.0</maven.compiler.version>
<surefire-version>3.1.2</surefire-version>
<java.release.version>17</java.release.version>
<maven.source.encoding>UTF-8</maven.source.encoding>
<suite-xml>testng.xml</suite-xml>
<argLine>-Dfile.encoding=UTF-8 -Xdebug -Xnoagent</argLine>
</properties>

<dependencies>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>${selenium.java.version}</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.testng/testng -->
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>${testng.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${maven.compiler.version}</version>
<configuration>
<release>${java.release.version}</release>
<encoding>${maven.source.encoding}</encoding>
<forceJavacCompilerUse>true</forceJavacCompilerUse>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>${surefire-version}</version>
<executions>
<execution>
<goals>
<goal>test</goal>
</goals>
</execution>
</executions>
<configuration>
<useSystemClassLoader>false</useSystemClassLoader>
<properties>
<property>
<name>usedefaultlisteners</name>
<value>false</value>
</property>
</properties>
<suiteXmlFiles>
<suiteXmlFile>${suite-xml}</suiteXmlFile>
</suiteXmlFiles>
<argLine>${argLine}</argLine>
</configuration>
</plugin>
</plugins>
</build>
</project>
```

The tests will be run on the Google Chrome browser on LambdaTest’s Cloud grid using Windows 10 Operating System. To set the browser, OS, and its respective version, we can use the [LambdaTest Capabilities Generator](https://www.lambdatest.com/capabilities-generator/?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=webpage).

***Discover the ins and outs of*** [***UX testing***](https://www.lambdatest.com/learning-hub/ux-testing?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub) ***with this comprehensive guide. Explore various testing methods, tools, and best practices for measuring success***

![image](https://cdn-images-1.medium.com/max/800/0*1p-fTN5xnmvm9YYh.png )

### Implementing Implicit Wait in Selenium

Once we know what capabilities we need to set in the cloud, we will create a *DriverManager* class that will help set up the browser in the cloud.

Following is the code implementation of the *DriverManager* class.

*FileName — DriverManager.class*

```plaintext

public class DriverManager {

WebDriver driver;
private static final String LT_USERNAME = System.getProperty("LT_USERNAME");
private static final String LT_ACCESS_KEY = System.getProperty("LT_ACCESS_KEY");
private static final String GRID_URL = "@hub.lambdatest.com/wd/hub";

public void createChromeDriverInCloud() {
final ChromeOptions browserOptions = new ChromeOptions();
browserOptions.setPlatformName("Windows 10");
browserOptions.setBrowserVersion("114.0");
final HashMap<String, Object> ltOptions = new HashMap<>();
ltOptions.put("username", LT_USERNAME);
ltOptions.put("accessKey", LT_ACCESS_KEY);
ltOptions.put("resolution", "2560x1440");
ltOptions.put("selenium_version", "4.0.0");
ltOptions.put("build", "LambdaTest ECommerce Playground Build");
ltOptions.put("name", "LambdaTest ECommerce Playground Tests");
ltOptions.put("w3c", true);
ltOptions.put("plugin", "java-testNG");
browserOptions.setCapability("LT:Options", ltOptions);
try {
driver = new RemoteWebDriver(new URL(format("https://{0}:{1}{2}", LT_USERNAME, LT_ACCESS_KEY, GRID_URL)), browserOptions);
} catch (MalformedURLException e) {
throw new Error("RemoteDriver's URL not set correctly!");
}
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
}

public void createChromeDriverLocal() {
driver = new ChromeDriver();
}

public WebDriver getDriver() {
return this.driver;
}

public void quitDriver() {
driver.quit();
}
}
```

**Code Walkthrough**

The first two variables declared in the class will help us read LambdaTest’s cloud login credentials, i.e., Username and AccessKey, on runtime, as these are secret variables and can not be declared as hard-coded values in the code. These values will be set in the *createChromeDriverInCloud()* method.

*createChromeDriverInCloud()* method in *DriverManager* class

![image](https://cdn-images-1.medium.com/max/800/0*JLQdiZ3rF05Fzp-7.png )

This method will create a new Chrome browser instance on LambdaTest Cloud Grid. After the driver is set, the implicit wait will be set for 10 seconds using the following statement in the above method –

![image](https://cdn-images-1.medium.com/max/800/0*J0FHz_NN23ySsF-G.png )

**Implementing the Test Scenarios**

**Scenario 1**

The first scenario we need to implement is the Login Scenario. This will help you log in to the website and perform further actions of adding the product to the cart and checking out easily. The code snippet of the *testLogin()* method is available in the *LambdaTestEcommerceTests* class.

[*LambdaTestEcommerceTests*](https://github.com/mfaisalkhatri/selenium-wait-demo/blob/main/src/test/java/io/github/mfaisalkhatri/tests/LambdaTestEcommerceTests.java) class

```plaintext
public class LambdaTestEcommerceTests extends BaseTest{

@Test
public void testLogin() {
HomePage homePage = new HomePage(driverManager.getDriver());
homePage.navigateToLoginPage();
LoginPage loginPage = new LoginPage(driverManager.getDriver());
loginPage.login(System.getProperty("username"),System.getProperty("password"));
assertEquals(loginPage.getMyAccountPageHeader(),"My Account");
}
}
```

The *testLogin()* method will help in navigating to the Login Page and allow performing the login to the LambdaTest eCommerce website. The Username and Password for login will be supplied on run time. Finally, assertions will be performed to check that the page header should be “My Account” after successful login.

*Login link on Home Page*

![image](https://cdn-images-1.medium.com/max/800/0*vp4NjDPa5t2A7GSG.png )

*Login Page*

![image](https://cdn-images-1.medium.com/max/800/0*9efur-Zcz71clZc6.png )

*Account Page after successful login*

![image](https://cdn-images-1.medium.com/max/800/0*Jvq5DQMaUMUity2K.png )

Below is the code snippet from the *HomePage* class that has all the Page Objects for Home Page.

***Explore our comprehensive guide on*** [***GUI Testing***](https://www.lambdatest.com/learning-hub/gui-testing?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub)***, uncovering its vital role in software development. Learn about its different types, best practices, and steps for effective implementation to enhance your software’s user interaction.***

The [Page Object Model](https://www.lambdatest.com/blog/selenium-java-testing-page-object-model/?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=blog) helps segregate the page objects with the actions, enabling easy code maintenance. It is a popular design pattern used in test automation to enhance the maintainability and reusability of test code, particularly in web-based applications. It achieves this by segregating the web elements on a page from the test actions performed on those elements.

```plaintext
public class HomePage {
WebDriver driver;

public HomePage(WebDriver driver) {
this.driver = driver;
}

private WebElement searchField() {
return driver.findElement(By.name("search"));
}

private WebElement searchBtn() {
return driver.findElement(By.cssSelector("button[type='submit'][class='type-text']"));
}

public void searchProduct(String productName) {
searchField().clear();
searchField().sendKeys(productName);
searchBtn().click();
}

public String searchResultText() {
return driver.findElement(By.cssSelector("div.product-layout:nth-child(1) div:nth-child(1) h4 > a.text-ellipsis-2")).getText();
}

public void navigateToLoginPage() {
driver.findElement(By.linkText("My account"))
.click();
driver.findElement(By.linkText("Login")).click();
}
}
```

The *BaseTest* class is extended by *LambdaTestEcommerceTests* class. The *BaseTest* class has two methods, namely, *testSetup()* and *tearDown()*. The *testSetup()* method helps instantiate the *DriverManager* class and calls the *createChromeDriverInCloud()* to run the tests on the Chrome browser in the LambdaTest cloud grid. The *tearDown()* method helps in gracefully quitting the WebDriver after the tests are run.

```plaintext
public class BaseTest {

DriverManager driverManager;

@BeforeTest(alwaysRun = true)
public void testSetup() {
driverManager = new DriverManager();
driverManager.createChromeDriverInCloud();
driverManager.getDriver().get("https://ecommerce-playground.lambdatest.io/");
}

@AfterTest(alwaysRun = true)
public void tearDown() {
driverManager.quitDriver();
}
}
```

**Scenario 2**

The next scenario is to search for a product from the Home Page after logging in to the website.

*Search products from the Home Page*

![image](https://cdn-images-1.medium.com/max/800/0*CCgMenVa1bxdeGG5.png )

*Search results*

![image](https://cdn-images-1.medium.com/max/800/0*s4nCA4dl33vDcsdv.png )

Following is the test to search for the product.

```plaintext
@Test
public void testSearchProduct() {
String productName = "Palm Treo Pro";
HomePage homePage = new HomePage(driverManager.getDriver());
homePage.searchProduct(productName);
assertEquals(homePage.searchResultText(), productName);
}
```

“*Palm Treo Pro*” is the product that will be searched from the website’s Home Page; after the results appear, the text will be asserted against it.

The following method — *searchProduct()* from the *HomePage* class will help us search the product, and the *searchresultText()* method will help us verify the search result text.

***Looking to manage your tests more efficiently? In this blog, explore a variety of*** [***test case management***](https://www.lambdatest.com/blog/best-test-management-tools/?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub) ***tools and select the one that suits your team’s needs.***

![image](https://cdn-images-1.medium.com/max/800/0*kP8rv06RSeLfall8.png )

**Scenario 3**

In this scenario, the add product to the cart step will be automated. To add products to the cart, we need to hover on the product and click on the “*add to cart*” icon after the hovering toolbar appears.

![image](https://cdn-images-1.medium.com/max/800/0*SUOiO9DVF6hov9Se.png )

Next, a pop-up message will appear showing the success message for adding the product to the cart with the Checkout button. We will be asserting the success message and clicking on the Checkout button.

### Implementing Thread.sleep() in Selenium

Below code is of the *testAddProductToCart()* method that performs all the actions mentioned in the earlier paragraph.

*testAddProductToCart()* in *LambdaTestEcommerceTests* class

```plaintext
@Test
public void testAddProductToCart() {
ProductPage productPage = new ProductPage(driverManager.getDriver());
productPage.addPalmTreoCameraLensToCart();
final String expectedMessage = "{0}\n{1}\n{2}\n{3}\n{4}";
assertEquals(productPage.successMessageText(), format(expectedMessage, "Success: You have added", "Palm Treo Pro", "to your",
"shopping cart", "!"));
productPage.checkoutProduct();
}
```

*ProductPage* class is created for storing the product page web elements and interacting with them.

```plaintext
public class ProductPage {
WebDriver driver;

public ProductPage(WebDriver driver) {
this.driver = driver;
}

public void addPalmTreoCameraLensToCart() {
final Actions actions = new Actions(driver);
actions.moveToElement(palmTreoCameraLens())
.pause(200)
.moveToElement(addToCartBtn())
.pause(100)
.click()
.perform();
}

public void checkoutProduct() {
checkoutBtn().click();
}

public String successMessageText() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
return notificationPopUp().findElement(By.tagName("p")).getText();
}

private WebElement addToCartBtn() {
return driver.findElement(By.cssSelector("div.product-action > button.btn.btn-cart.cart-29"));
}

private WebElement checkoutBtn() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
return notificationPopUp().findElement(By.cssSelector("div.form-row > div:nth-child(2) > a"));
}

private WebElement notificationPopUp() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
return driver.findElement(By.id("notification-box-top"));
}

private WebElement palmTreoCameraLens() {
return driver.findElement(By.cssSelector(".product-layout"));
}
}
```

As mentioned earlier, we need to wait for the pop-up notification to appear. The following method *notificationPopUp()* has *Thread.sleep()* implemented, which pauses the test for 2 seconds to wait for the notification to appear. In this method, *try catch* block is used for implementing *Thread.sleep()* as it is more convenient and helps catch the run time exceptions. Once try catch is implemented, we don’t have to put the words throws *InterruptedException* in every method that uses this *notificationPopUp()* method, which has *Thread.sleep()* in it.

![image](https://cdn-images-1.medium.com/max/800/0*R72INpAHdjPUpfj3.png )

Likewise, *Thread.sleep()* in Java is used in the *successMessageText()* method as well, as we need to wait for a success message to appear to get its text.

![image](https://cdn-images-1.medium.com/max/800/0*80myATZ7sCUcx8mq.png )

Similarly, *Thread.sleep()* in Java pauses the test for locating the Checkout button. Here is the code snippet for the *checkoutBtn()* method that returns the web element for the checkout button.

![image](https://cdn-images-1.medium.com/max/800/0*zYAHrd_5dSh7FVAq.png )

**Test Execution**

Let’s execute the tests using *testng.xml* by right-clicking on the file and selecting the option `Run ...\testng.xml`. Here we are using the cloud testing platform, LambdaTest to execute the tests.

LambdaTest is a digital experience cloud platform that lets you perform [automation testing](https://www.lambdatest.com/automation-testing?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=webpage) at scale on over 3000+ real desktop and mobile browsers. Just like the *Thread.sleep()* in Java helps you pause test execution for a certain amount of time, running tests on a cloud-based grid will further improve the accuracy of your tests.

***The ultimate guide to*** [***software testing metrics***](https://www.lambdatest.com/learning-hub/software-testing-metrics?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub)***: definition, types, and examples explained for informed decisions. Enhance your testing process now.***

Moreover, running your automated tests in parallel will cut down your test execution time, enabling faster [Selenium Java testing](https://www.lambdatest.com/selenium-java-testing?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=webpage) to ensure a quality web experience.

To run tests on LambdaTest, we need to enter the following values to execute the tests successfully.

1. LambdaTest Username
    
2. LambdaTest AccessKey
    
3. Username of LambdaTest eCommerce Website
    
4. Password of LambdaTest eCommerce Website
    

Username and Password for LambdaTest’s eCommerce Website must be supplied for successfully logging in to the website.

All the values can be supplied using the Edit configuration window and supplying the values as

*\-DLT\_USERNAME=&lt; LambdaTest Username&gt; -DLT\_ACCESS\_KEY=&lt; LambdaTest Access Key &gt; -Dusername=&lt; Website username for login scenario &gt; -Dpassword=&lt; Website password for login scenario &gt;*

```plaintext
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="LambdaTest ecommerce playground website test suite ">
<test name="Search Product tests " >
<classes>
<class name="io.github.mfaisalkhatri.tests.LambdaTestEcommerceTests">
<methods>
<include name="testLogin"/>
<include name="testSearchProduct"/>
<include name="testAddProductToCart"/>
</methods>
</class>
</classes>
</test> <!-- Test -->
</suite> <!-- Suite -->
```

*Screenshot of the test run locally using TestNG in IntelliJ*

![image](https://cdn-images-1.medium.com/max/800/0*u6xts-RrQ6rIIRIa.png )

The total time taken to run the tests can be seen as `37 Seconds and 307 ms`, this includes the hard waits we have implemented using *Thread.sleep()* in the tests.

Let’s now check out how to replace the *Thread.sleep()* in Java with the explicit and fluent wait to take down the hard waits from the tests and save test execution time.

### Implementing Explicit Wait and Fluent Wait in Selenium

There are three methods in the *ProductPage* class, namely, *notificationPopUp()*, *successMessageText()*, and *checkoutBtn()*, where we have used *Thread.sleep()* in Java for pausing the test execution. Hence, our tests run smoothly by locating and interacting with the web elements on the Product Page. The *Thread.sleep()* statements in the code are commented out and have been kept to let us know that it was replaced with explicit and fluent waits in its place, so we know where the hard waits were replaced.

***Note:*** *It is not a good practice to keep commented code in the class. Once the code refactoring is done, the commented code should be removed.*

**Replacing Thread.sleep() with Fluent Wait**

Let’s use the fluent wait in the *successMessageText()* method and replace it with *Thread.sleep()* in Java.

*successMessageText()* method in *ProductPage* class

![image](https://cdn-images-1.medium.com/max/800/0*6MzXPSlpw1moxd2n.png )

The fluent wait is defined for 10 seconds polling every 2 seconds ignoring *NoSuchElementException*. So, if the element is located within 10 seconds, it will move to the next statement of code rather than waiting for a full timeout of 10 seconds to complete. This is the benefit of using Selenium Waits.

Once the web element for *successMessage* is located using the fluent wait condition. *successMessageText()* method will return its text.

***Note:*** *If the web element is not located within 10 seconds, the fluent wait will throw TimeoutException. The following screenshot shows the TimeoutException printed in the console in IntelliJ.*

![image](https://cdn-images-1.medium.com/max/800/0*3KdrGuhKLsqghyzO.png )

**Replacing Thread.sleep() with Explicit Wait**

It is now time to refactor the *notificationPopup()* method and *checkoutBtn()* method by removing the *Thread.sleep()* in Java and replacing it with the explicit wait. As we will be using the explicit wait in two methods, it is better to declare it globally, instantiate it in the class’s constructor, and use it in the respective methods.

***This tutorial focuses on*** [***mobile ui testing***](https://www.lambdatest.com/learning-hub/mobile-ui-testing?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub)***, its significance, benefits, strategies, challenges, and best practices.***

*Declaring WebDriverWait*

![image](https://cdn-images-1.medium.com/max/800/0*icFuRbgF90agdZm4.png )

Once the instantiation of the *WebDriverWait* class is done, we are good to use it in the *notificationPopUp()* and *checkoutBtn()* methods.

*notificationPopUp() method*

![image](https://cdn-images-1.medium.com/max/800/0*tdKEwU5-mchBQ-PK.png )

Using explicit wait, *ExpectedCondition* — *visibilityOfElementLocated()* using By locator is used in this method to wait for the notification box to appear.

If the element is not located within the explicit wait timeout of 10 seconds, *TimeoutException* will be thrown.

The following screenshot shows the *TimeoutException* printed in the console in IntelliJ.

![image](https://cdn-images-1.medium.com/max/800/0*L5Aam5h2cb48Yfmj.png )

Coming to the *checkoutBtn()* method, *Thread.sleep()* in Java has been replaced by using the *ExpectedCondition* — *visibilityOf()* method, where a web element is supplied in its parameter.

![image](https://cdn-images-1.medium.com/max/800/0*MJQ5d-GLVNFPPf42.png )

Before running the tests, let’s remove the implicit wait that we had added in the *createChromeDriverInCloud()* method in *DriverManager* class.

![image](https://cdn-images-1.medium.com/max/800/0*AHmvZczJVzPGQPGl.png )

**Test Execution**

Let’s execute the tests using testng.xml by right-clicking on the file and selecting the option `Run ...\testng.xml`. As discussed earlier, the following values can be supplied using the Edit configuration window.

![image](https://cdn-images-1.medium.com/max/800/0*nB3mAzEZ_r8UgMeD.png )

Screenshot of the test run locally using TestNG in IntelliJ:

![image](https://cdn-images-1.medium.com/max/800/0*LilettKn7FVhEwwX.png )

It can be seen that the test execution time has reduced to `24 seconds 707 ms.` This shows that Selenium’s explicit and fluent waits are powerful and can help in bringing down the test execution time and also make the code more readable, maintainable, and less flaky.

If you desire to excel in automation testing and improve your Java skills, enrolling in a [Selenium Java 101](https://www.lambdatest.com/certifications/selenium-java-101) certification program is an excellent first step toward becoming an automation testing expert. This program will equip you with a robust understanding of using Selenium Java for testing and pave the way for a promising career in this field.

***Explore our in-depth guide comparing*** [***Protractor vs Selenium***](https://www.lambdatest.com/learning-hub/protractor-vs-selenium?utm_source=devto&utm_medium=organic&utm_campaign=jul_27&utm_term=ap&utm_content=learning_hub) ***to make informed decisions for your test automation needs. Gain valuable insights into the key differences, advantages, and ideal use cases of these widely-used testing frameworks.***

### Conclusion

Though *Thread.sleep()* in Java can be used for pausing the test execution for a certain time, it is not a good option to use it in your automation tests as it is a kind of hard wait and can eat up most of the test execution time.

Instead, *implicit*, *explicit*, and fluent waits in Selenium WebDriver can be used. These are more advanced waits and can help to pause the test for a certain time to find the locator/wait for the expected condition to be fulfilled and execute the rest of the code as soon as the element is found. It is recommended to refactor your code and use Selenium Waits wherever possible to save the test execution time and keep your tests less flaky.

Happy Testing!!