High-Impact Java Strategies to Build Scalable Test Automation Frameworks

SDETs and QA: Learn with the runnable Core Java Playbook for Interview Preparation Practice. View the Core Java playbook in action in the video below.

Summary: Many test automation frameworks fail not because of tools, but because of weak Java design decisions. This post explains high-impact Java strategies that help you build scalable, stable, and professional test automation frameworks.

Introduction: The SDET’s Hidden Hurdle

Moving from manual testing to automation is a big career milestone. Writing scripts that click buttons and validate text feels good at first.

Then reality hits. As the test suite grows, maintenance effort explodes. Tests become fragile, execution slows down, and engineers spend more time fixing automation than testing the application.

This problem is often called automation rot. It happens when automation is treated as scripting instead of engineering.

The solution is not a new tool. It is mastering Java as an engineering language for automation. By applying proven Java design and concurrency strategies, you can turn brittle scripts into a scalable, industrial-grade framework.

1. Why Singleton and Factory Patterns Are Non-Negotiable

In professional frameworks, WebDriver management determines stability. Creating drivers inside individual tests is a fast path to flaky behavior and resource conflicts.

The Singleton pattern ensures that only one driver instance exists per execution context. It acts as a guardrail, preventing accidental multiple browser launches.

The Factory pattern centralizes browser creation logic. Instead of hard-coding Chrome or Firefox inside tests, the framework decides which browser to launch at runtime.

// Singleton: ensure a single driver instance
public static WebDriver getDriver() {
    if (driver == null) {
        driver = new ChromeDriver();
    }
    return driver;
}

// Factory: centralize browser creation
public static WebDriver getDriver(String browser) {
    switch (browser.toLowerCase()) {
        case "chrome": return new ChromeDriver();
        case "firefox": return new FirefoxDriver();
        default: throw new IllegalArgumentException("Unsupported browser");
    }
}
  

Centralizing browser creation gives you one place to manage updates, configuration, and scaling as the framework grows.

2. The Finally Block Is Your Best Defense Against Resource Leaks

Exception handling is not just about catching failures. It is about protecting your execution environment.

The finally block always executes, whether a test passes or fails. This makes it the correct place to clean up critical resources such as browser sessions.

try {
    WebElement button = driver.findElement(By.id("submit"));
    button.click();
} catch (NoSuchElementException e) {
    System.out.println("Element not found: " + e.getMessage());
} finally {
    driver.quit();
}
  

Without proper cleanup, failed tests leave behind ghost browser processes. Over time, these processes consume memory and crash CI runners.

Using finally consistently keeps both local machines and CI pipelines stable.

3. Speed Up Feedback with Multi-Threading and Parallel Execution

Sequential execution is one of the biggest bottlenecks in modern automation. Long feedback cycles slow teams down and reduce confidence.

Java provides powerful concurrency tools that allow tests to run in parallel. Instead of managing threads manually, professional frameworks use ExecutorService to control a pool of threads.

This approach allows multiple test flows or user simulations to run at the same time, cutting execution time dramatically.

Engineers who understand thread safety, shared resources, and controlled parallelism are the ones who design frameworks that scale.

4. Decouple Test Data with the Strategy Pattern

Hard-coding test data tightly couples your tests to a specific source. This makes frameworks rigid and difficult to extend.

The Strategy pattern solves this by defining a contract for data access and allowing implementations to change at runtime.

// Strategy interface
public interface DataStrategy {
    List<String> getData();
}

// Runtime selection
DataStrategy strategy = new CSVDataStrategy();
List<String> testData = strategy.getData();
  

With this approach, switching from CSV to JSON or a database requires no changes to test logic. The test focuses on validation, not data plumbing.

5. Stabilize Tests by Mocking Dependencies with Mockito

Automation should fail only when the application is broken. External systems such as databases or third-party services introduce noise and false failures.

Mockito allows you to isolate the unit under test by mocking dependencies and controlling their behavior.

// Mock dependency
Service mockService = Mockito.mock(Service.class);

// Stub behavior
when(mockService.getData()).thenReturn("Mock Data");
  

Mocking removes instability and keeps tests focused on the logic being validated. This dramatically increases trust in automation results.

Conclusion: From Tester to Automation Engineer

Strong automation frameworks are built, not scripted.

By applying Java design patterns, proper resource management, parallel execution, data decoupling, and mocking, you move from writing tests that merely run to engineering systems that scale.

These skills separate automation engineers from automation scripters.

Final thought: is your current framework just running tests, or is it engineered to grow with your product?

If you want any of the following, send a message using the Contact Us (right pane) or message Inder P Singh (19 years' experience in Test Automation and QA) in LinkedIn at https://www.linkedin.com/in/inderpsingh/

• Production-grade Java for Test Automation automation templates with playbooks
• Working Java for Test Automation projects for your portfolio
• Deep-dive hands-on Java for Test Automation training
• Java for Test Automation resume updates

Java Test Automation: 5 Advanced Techniques for Robust SDET Frameworks

Summary: Learn five practical, Java-based techniques that make test automation resilient, fast, and maintainable. Move beyond brittle scripts to engineer scalable SDET frameworks using design patterns, robust cleanup, mocking, API-first testing, and Java Streams.

Why this matters

Test suites that rot into fragility waste time and reduce confidence. The difference between a brittle suite and a reliable safety net is applying engineering discipline to test code. These five techniques are high-impact, immediately applicable, and suited for SDETs and QA engineers who write automation in Java. First view my Java Test Automation video. Then read on.

1. Think like an architect: apply design patterns

Treat your test framework as a software project. Use the Page Object Model to centralize locators and UI interactions so tests read like business flows and breakages are easy to fix. Use a Singleton to manage WebDriver lifecycle and avoid orphan browsers and resource conflicts.

// Example: concise POM usage
LoginPage loginPage = new LoginPage(driver);
loginPage.enterUsername("testuser");
loginPage.enterPassword("password123");
loginPage.clickLogin();

2. Master the finally block: guaranteed cleanup

Always place cleanup logic in finally so resources are released even when tests fail. That prevents orphaned processes and unpredictable behavior on subsequent runs.

try {
    // test steps
} catch (Exception e) {
    // handle or log
} finally {
    driver.quit();
}

3. Test in isolation: use mocking for speed and determinism

Mock external dependencies to test logic reliably and quickly. Mockito lets you simulate APIs or DBs so unit and integration tests focus on component correctness. Isolate logic with mocks, then validate integrations with a small set of end-to-end tests.

// Example: Mockito snippet
when(paymentApi.charge(any())).thenReturn(new ChargeResponse(true));
assertTrue(paymentService.process(order));

To get FREE Resume points and Headline, send a message to  Inder P Singh in LinkedIn at https://www.linkedin.com/in/inderpsingh/

4. Go beyond the browser: favor API tests for core logic

API tests are faster, less brittle, and better for CI feedback. Use REST Assured to validate business logic directly and reserve UI tests for flows that truly require the browser. This reduces test execution time and improves reliability.

// Rest Assured example
given()
  .contentType("application/json")
  .body(requestBody)
.when()
  .post("/cart/coupon")
.then()
  .statusCode(400)
  .body("error", equalTo("Invalid coupon"));

5. Write less code, express intent with Java Streams

Streams make collection processing declarative and readable. Replace verbose loops with expressive stream pipelines that show intent and reduce boilerplate code.

// Traditional loop
List<String> passedTests = new ArrayList<>();
for (String result : testData) {
    if (result.equals("pass")) {
        passedTests.add(result);
    }
}

// Streams version
List<String> passedTests = testData.stream()
.filter(result -> result.equals("pass"))
.collect(Collectors.toList()); 

Putting it together

Adopt software engineering practices for tests. Use POM and Singletons to organize and manage state. Ensure cleanup with finally. Isolate components with mocking. Shift verification to APIs for speed and stability. Use Streams to keep code concise and expressive. These five habits reduce maintenance time, increase confidence, and make your automation an engineering asset.

Quick checklist to apply this week

Refactor one fragile test into POM, move one slow validation to an API test, add finally cleanup to any tests missing it, replace one large loop with a Stream, and add one mock-based unit test to isolate a flaky dependency.

Send a message using the Contact Us (right pane) or message Inder P Singh (18 years' experience in Test Automation and QA) in LinkedIn at https://www.linkedin.com/in/inderpsingh/ if you want deep-dive Test Automation and QA projects-based Training.

Java Test Automation Interview Questions and Answers with Java code

Here are my Java Test Automation Interview Questions and Answers for SDETs, QA and Test Automation Architects. Read the interview questions for Java Test Automation on Java Fundamentals for Test Automation, Core Java Programming Skills for Test Automation, Java and Object-Oriented Design Patterns in Test Automation, Java Frameworks and Libraries for Automated Testing, Java Interview Questions for Automation Testing Roles, Java and Selenium WebDriver for UI Automation, Data-Driven Testing with Java and API Test Automation with Java.

If you want my complete set of Java Test Automation Interview Questions and Answers as a document that additionally contain the following topics, you can message me on my LinkedIn profile or send me a message in the Contact Us form in the right pane:
Intermediate Java Concepts for Test Automation, Advanced Java Techniques for Automation Testing, Building a Java Test Automation Framework, Best Practices in Java Automated Testing, Java for Test Automation Tips, Tricks, and Common Pitfalls, and FAQs and Practice Questions for Java Test Automation.

Question: Why is Java popularly used in test automation, and how does it benefit testing roles?
Answer: Java’s platform independence, extensive library support, and large community make it highly suited for test automation frameworks like Selenium, JUnit, and TestNG. Java works with object-oriented principles and error-handling mechanisms, allowing SDETs and QA testers to create modular, reusable, and maintainable tests.

Question: What are the advantages of using Java over other languages in automation testing?
Answer: Java has the following advantages:
- Strong Typing: Helps catch many potential type-related issues at compile time.
- Comprehensive Libraries: Useful for handling data, file I/O, and complex test scenarios.
- Concurrency Support: Enables multi-threading, making it useful for performance testing.
- Integration with Testing Tools: Java integrates with many automation tools.

Question: What are the key data types in Java, and how do they support automation?
Answer: Java has two main data types:
- Primitive Types (e.g., int, double, boolean) are used for simple operations like counting or asserting values in tests.
- Reference Types (e.g., String, Arrays, Lists) are used for handling collections of data or complex assertions.
Example: Checking form validation where multiple strings or arrays may need validation.

Question: How does control flow work in Java test automation in Java?
Answer: Control flow (using statements like if, for, while, switch) allows automated test scripts to make decisions and repeat actions. It can handle scenarios like:
- Conditional Validation: Validating if a user is logged in and running appropriate test steps.
- Looping: Iterating through data sets or UI elements to ensure thorough testing.
Example: 

Question: How can you use variables effectively in your test automation scripts?
Answer: Variables in Java can store test data (e.g., URLs, credentials) that might change across environments. They make scripts easy to update.

Question: What is the role of exception handling (try-catch) in automation?
Answer: Exception handling deals with unexpected events (like missing elements or timeouts) without halting the entire test suite. It allows graceful error handling and makes the test less flaky (more robust).
Example: 

Question: How can you write classes and objects in Java to create modular test scripts?
Answer: Classes encapsulate test functions, reducing code redundancy. Objects represent specific test cases or actions, helping testers organize code in reusable modules.
Example: 

Question: How can you use inheritance to simplify test case creation?
Answer: Inheritance allows a class to reuse fields and methods of another class, which is helpful for creating shared test functions.
Example: 

Question: What is polymorphism, and how can you use it to optimize test cases?
Answer: Polymorphism allows testers to use a common method in different ways, making scripts more flexible. For instance, a click() function can work on various UI elements.
Example: 

Question: What is java.util, and why is it important for testers?
Answer: The java.util package provides data structures (like ArrayList, HashMap) that are can handle collections of data in tests, such as lists of web elements or data sets.
Example: Using ArrayList to store a list of test data inputs. 

Question: How does java.lang help in test automation?
Answer: The java.lang package includes core classes like String, Math, and System, for tasks like string manipulation, mathematical operations, and logging in test automation.
Example: Generating a random number for unique input generation. 

Question: Can you name some methods in java.util.Date that are useful in test automation?
Answer: java.util.Date and java.time have methods for handling date and time, which can be important for scheduling tests or validating time-based features. Note: Prefer java.time (Java 8+) over java.util.Date for new code.
Example: Using LocalDate for date-based validation. 

Question: As an Automation Test Architect or Lead, what are some practical tips for SDETs and QA on Java fundamentals?
Answer: 1. Understand Data Types: Knowing when to use specific data types (int vs. double, ArrayList vs. LinkedList) can impact memory usage and test speed.
2. Write Reusable Methods: Encapsulate common actions (like logging in or navigating) in reusable methods to make tests more readable and maintainable.
3. Handle Exceptions: Use specific exception handling (NoSuchElementException, TimeoutException) to catch errors accurately, making test results more informative.
4. Use Libraries: Use java.util collections for handling data sets and java.lang for efficient code execution.

Want to learn more? View my Java Interview Questions and Answers videos:
- https://youtu.be/HBQxq1UUNAM
- https://youtu.be/1gRuQMhydgs
- https://youtu.be/e5BLn9IGrF0

 

Question: How is exception handling useful in test automation, and how does the try-catch mechanism work in Java?
Answer: Exception handling allows test automation scripts to handle unexpected situations gracefully, such as missing elements or timeout errors, without halting the complete test run. The try block contains code that might throw an exception, and the catch block handles it.
Example: 

Question: What is the role of the finally block in exception handling?
Answer: The finally block executes irrespective if an exception occurred or not. It’s useful for cleanup activities, such as closing a browser or logging out.
Example: 

Question: How can you create a custom exception for test automation in Java?
Answer: Custom exceptions are defined by extending the Exception class. They allow specific error messages or handling specific test failures.
Example: 

Question: How can you handle files in test automation, and which classes can you use in Java for this purpose?
Answer: File handling allows tests to read data inputs from and write results to files, supporting data-driven testing. The commonly used classes are FileReader, BufferedReader for reading, and FileWriter, BufferedWriter for writing. 

Example: Reading from a file 

Example: Writing to a file 

Question: How can you use file handling or data-driven testing?
Answer: By reading test data from external sources (e.g., CSV or text files), QA testers can parameterize tests, reducing hard-coded values and making tests work with multipledatasets.

Question: What are the advantages of using collections in test automation?
Answer: Collections, like ArrayList, HashSet, and LinkedList, are useful for managing dynamic data sets, such as lists of test cases or elements, with features like sorting, searching, and filtering.
Example: Using an ArrayList to store and iterate through test data 

Question: How can you use Maps for test data management in automation testing?
Answer: Maps store key-value pairs, making them useful for data like configurations or credentials where values can be retrieved by specific keys.
Example: Using a HashMap for storing and retrieving login credentials 

Question: What is the benefit of multi-threading benefit in test automation, especially for parallel execution?
Answer: Multi-threading allows concurrent test execution, reducing overall test execution time. In test automation, it allows tests to run in parallel, simulating multiple user interactions.

Question: What are the basic steps of implementing multi-threading in Java for parallel test runs?
Answer: Multi-threading in Java can be implemented by extending Thread or implementing Runnable. Each test case can be run as a separate thread, enabling simultaneous execution.
Example: Creating multiple threads for parallel tests 

Question: How can you use Executors to manage a pool of threads in Java?
Answer: The ExecutorService interface provides methods to manage a thread pool, allowing multiple tests to run concurrently while efficiently managing resources.
Example: Using Executors for parallel execution 

Question: What is the Page Object Model (POM), and why is it needed in test automation?
Answer: The Page Object Model is a design pattern where each web page in the application is mapped as a class with methods encapsulating actions users can perform on that page. It makes tests more readable and maintainable (by centralizing element locators and interactions in one place). You can view the working example of SeleniumJava POM implemented below.

Example: POM for a Login Page 

Question: What problem does the Singleton pattern solve, and how can you use it in test automation?
Answer: The Singleton pattern restricts the instantiation (meaning creating objects) of a class to one object. In test automation, it uses only one instance of the WebDriver during a test session, preventing resource conflicts and allowing better browser control.
Example: Singleton WebDriver instance 

Question: How can you use the Factory pattern in test automation?
Answer: The Factory pattern creates objects without specifying the exact class of object that will be created. It’s useful for managing browser-specific configurations by centralizing the logic for initializing different WebDriver instances.
Example: Factory pattern for WebDriver 

Question: How can you use the Strategy pattern, and how does it support data management in test automation?
Answer: The Strategy pattern defines a family of algorithms with interchangeability at runtime. It is useful for test automation where multiple strategies are needed to handle different types of data sources (e.g., CSV, database, JSON).
Example: Strategy pattern for test data input 

Question: How can the Strategy pattern manage different configurations in test automation?
Answer: The Strategy pattern allows dynamically switching between configurations (e.g., different test environments or data sets) by implementing different configuration strategies.

Question: What is Dependency Injection, and how does it work in test automation?
Answer: Dependency Injection (DI) is a design pattern where an object receives its dependencies from an external source rather than creating them. DI improves test reusability and flexibility by allowing dependencies like WebDriver or configurations to be injected instead of hardcoded.
Example: Dependency Injection in test 

Question: How does Inversion of Control (IoC) differ from Dependency Injection, and how does it work in Java testing frameworks?
Answer: IoC is a bigger concept where control is transferred from the object to an external source, while DI is a specific implementation of IoC. In Java testing frameworks like Spring, IoC containers manage dependencies, allowing components to be loosely coupled and more modular.
Example: IoC with Spring Framework in test automation 

Question: What are JUnit and TestNG, and why are they so popular in Java test automation?
Answer: JUnit and TestNG are Java testing frameworks for unit, integration, and end-to-end testing. JUnit is simple (view JUnit with Selenium Java demonstration here) and widely used for unit tests. TestNG has advanced features like parameterized tests and parallel execution.
Example: JUnit Test 

Example: Basic TestNG Test 

Question: How do JUnit and TestNG support different testing scopes (unit, integration, and UI)?
Answer: JUnit needs a minimal setup, while TestNG has features like parallel execution and dependency-based test configuration. Both frameworks are compatible with Selenium for browser-based tests.

Question: What are the functionality differences between JUnit and TestNG?
Answer:
- Annotations: TestNG offers more annotations (@BeforeSuite, @AfterSuite) compared to JUnit.
- Parameterized Tests: TestNG provides @DataProvider for parameterized tests, and modern JUnit (JUnit 5) supports parameterized tests natively via @ParameterizedTest with providers such as @ValueSource and @CsvSource.
- Parallel Execution: TestNG supports parallel execution and suites, while JUnit may need additional configuration first.
- Exception Handling: TestNG allows configuring expected exceptions and retry mechanisms easily.

Question: In which test automation projects, would you choose TestNG over JUnit?
Answer: TestNG is preferred for complex test suites that require parallel execution, detailed configuration, or dependency management among tests. For simple projects with unit tests, JUnit is more efficient due to its basic features.

Question: Why are Maven and Gradle needed for Java test automation?
Answer: Maven and Gradle are build automation tools that manage project dependencies, compile source code, and run tests. They allow adding libraries (like Selenium or REST-assured) by automatically downloading dependencies.

Question: How do you add dependencies in Maven and Gradle for a test automation project?
Answer: In Maven: Add dependencies in the pom.xml file under the <dependencies> tag. In Gradle: Use the dependencies block in the build.gradle file.
Example: Adding Selenium dependency in Maven 

Example: Adding Selenium dependency in Gradle 

Question: How do Maven and Gradle improve test automation workflows?
Answer: Maven and Gradle handle dependency conflicts, generate reports, and automate builds. They also support plugins to run tests, generate reports, and integrate with CI/CD systems like Jenkins, optimizing test automation workflows.

Question: What is mocking in test automation, and how does Mockito support it?
Answer: Mocking simulates the behavior of dependencies, such as databases or web services, to isolate the functionality under test. Mockito is a popular library that allows you to create and control mock objects in Java tests, making it easier to write tests that don't rely on external dependencies.
Example: Basic Mockito Mocking 

Question: How is stubbing different from mocking?
Answer: Stubbing is a specific type of mocking in which predefined responses are set up for particular method calls. While mocking controls the behavior of objects in tests, stubbing defines what happens when certain methods are invoked.

Question: How does Mockito help in writing isolated unit tests?
Answer: Mockito has functions like when, verify, and spy that allow fine-grained control over test dependencies, letting you validate your system, without the need for external systems or real data.

Question: Write a Java method to reverse a string. Why is it relevant for the SDET role?
Answer: Reversing a string is used in test automation for validating outputs, URL parsing, or log validation in automation scripts.
Example:

public String reverseString(String str) {

 return new StringBuilder(str).reverse().toString();

}

Question: Write a program to check if a number is prime.
Answer: 

Question: How you would design a test framework that validates login functionality?
Answer: A framework includes a modular test structure, page objects for UI elements, and reusable functions for key actions like login, logout, and navigation. I would use configuration files for environment-specific values like URLs and credentials.
Example:
- Framework Structure: Page Objects (LoginPage, HomePage) for element management.
- Test Methodology: Implement assertions to validate login success or failure.
- Test Data: Parameterize test data using JSON or an external CSV file.

Question: How would you handle a scenario where a test case intermittently fails due to network latency?
Answer: By implementing retry logic in the test framework to rerun a failed test a specified number of times before marking it as a failure. Additionally, I would use waits (explicit or fluent waits) instead of static delays to dynamically handle loading times.
Example: View Selenium Java waits demonstration in my Selenium Java Alerts video here.

Question: How would you identify and resolve a NullPointerException in a test script?
Answer: NullPointerException occurs when trying to use a null object reference. To resolve it:
- Use null checks before accessing objects.
- Debug and check initialization of objects.
- Use Optional to handle potential nulls more safely.
Example: Debugging Code 

Question: What approach would you take if your test fails due to StaleElementReferenceException in Selenium?
Answer: This exception occurs if the element is no longer attached to the DOM. To fix:
- Use try-catch with a re-fetch of the element.
- Implement explicit waits to allow the DOM to refresh.
- Use the ExpectedConditions.refreshed method to retry locating the element.
Example:

WebDriverWait wait = new WebDriverWait(driver, 10);

wait.until(ExpectedConditions.stalenessOf(element));

Question: How would you optimize tests that involve frequent database queries in a test automation suite?
Answer: Caching and efficient database handling reduce latency and speed up test execution. To optimize:
- Use connection pooling for efficient database access.
- Cache frequently used data to minimize repetitive database calls.
- Batch database requests when querying or updating multiple records.
Example: Example Code for Caching 

Question: How would you structure tests to validate complex workflows like e-commerce checkout?
Answer: For complex workflows:
- Use a modular structure with page objects for each step (e.g., LoginPage, ProductPage, CheckoutPage).
- Parameterize test data for items and quantities.
- Implement data-driven tests to validate different scenarios (e.g., cart with multiple items, invalid coupon). 

Question: How do you set up a basic Selenium WebDriver project in Java?
Answer: Start by adding Selenium dependencies (e.g., via Maven), initializing WebDriver, and creating a basic test script.
Steps:
1. Add Selenium dependencies in the pom.xml if using Maven.
2. Initialize WebDriver.
Example:

WebDriver driver = new ChromeDriver();

driver.get("https://inderpsingh.blogspot.com/");

Question: Explain the use of findElement, click, and sendKeys methods in Selenium WebDriver.
Answer: These are methods in Selenium for interacting with UI elements. The examples of Selenium WebDriver methods are shown in my highly popular Selenium Java Questionsand Answers video at https://youtu.be/e5BLn9IGrF0. 

Examples:

WebElement button = driver.findElement(By.id("submit"));

button.click();

driver.findElement(By.id("username")).sendKeys("testUser");

Question: How do you handle errors if an element is not found on the page?
Answer: Exception handling prevents test failures, especially when elements load dynamically. I would use try-catch for exception handling with WebDriver and implement waits to allow the page to load fully.
Example: 

Question: What are dynamic web elements, and how do you handle them in Selenium?
Answer: Dynamic web elements change their properties (e.g., IDs or class names) between page loads. Handling dynamic elements is needed for web testing, as modern web applications often have dynamically generated content. XPath and waits help manage these elements and reduce flaky tests. Use relative locators, XPath, CSS selectors, or dynamic waits (e.g., explicit waits) to handle such elements. View the SelectorsHub dynamic locators video here to know how to get the reliable locators.

Question: How would you handle a scenario where multiple elements have the same attributes (e.g., same class name)?
Answer: Use findElements to locate all matching elements and select the desired one based on index or other distinguishing characteristics.

Question: What are the best practices for writing maintainable Selenium tests in Java?
Answer: Key practices include using Page Object Model (POM), parameterizing data, and implementing reusable methods.
Examples:
1. Page Object Model (POM): Create a class for each page and manage elements and actions there. 

Parameterizing Test Data: Use external data files (CSV, JSON) to store test data, which makes tests more flexible and reusable. 

Reusable Utility Methods: Create utility methods for repetitive actions (e.g., wait for an element, scroll, etc.).
 

Question: How do you reduce tests "flakiness" against minor UI changes?
Answer: Use flexible locators (like relative XPath or CSS selectors) and avoid brittle locators tied to frequently changing attributes (like IDs). Implement custom retry mechanisms and avoid hard-coded waits in favor of explicit waits.

Question: How would you organize test code for a large-scale UI test automation project?
Answer: Organize the project with:
- Modular structure for tests and reusable functions.
- Separate packages for pages (Page Objects), test cases, utilities, and configurations.
- TestNG or JUnit for managing and running tests.
- Reporting with tools like ExtentReports or Allure for detailed insights.

Question: How can you read data from an Excel file in Java for test automation?
Answer: The Apache POI library allows us to interact with Excel files. Use XSSFWorkbook for .xlsx files and HSSFWorkbook for .xls files. You can view my video on Selenium Java Excel Read here.
Example: 

Question: How can you write data to an Excel file in Java using Apache POI?
Answer: To write data to Excel, we use XSSFWorkbook to create a new workbook and specify cell values.
Example: Writing data to Excel files allows us to store test results or logs, supporting validation and reporting in automated test suites. 

Question: How can you set up a parameterized test in JUnit?
Answer: Parameterized tests allow multiple data sets to be tested using a single test method. JUnit allows parameterized tests using @ParameterizedTest with a @ValueSource or custom provider method.
Example: Example of Parameterized Test Using JUnit 5 

Question: How can you do parameterized testing in TestNG?
Answer: TestNG provides @DataProvider to supply parameters to test methods. Using DataProvider in TestNG allows for parameterized tests with multiple test inputs.
Example: Example of Using DataProvider in TestNG 

Question: How can you read JSON test data in Java?
Answer: Libraries like Jackson or Gson can parse JSON data into Java objects for testing.
Example: Example Using Jackson to Parse JSON Data 

Question: How can you use XML for test data management in Java tests?
Answer: The javax.xml.parsers package provides utilities for XML parsing in Java.
Example:

import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.*;

import java.io.File;

public class XMLReader {

 public void readXML(String filePath) throws Exception {

 Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new File(filePath));

 doc.getDocumentElement().normalize();

 NodeList nodeList = doc.getElementsByTagName("data");

 for (int i = 0; i < nodeList.getLength(); i++) {

 Element element = (Element) nodeList.item(i);

 System.out.println("Element Data: " + element.getTextContent());

 }

 }

}

Question: What are the design patterns that you can use in data-driven testing?
Answer: Design patterns for data-driven testing include the Factory Pattern and Singleton Pattern.
- Factory Pattern: Used to create test data objects dynamically based on test needs.
- Singleton Pattern: It uses only one instance of a data provider class exists to manage data centrally across tests.

Question: What are best practices for managing data-driven tests in Java?
Answer: Key best practices include:
- Externalize Test Data: Use external files (JSON, XML, Excel) for data instead of hardcoding it into scripts.
- Modularize Data Access Code: Create reusable methods for data access to reduce redundancy.
- Centralize Data: Centralizing data in one repository simplifies maintenance.

If you have questions, you can message me after connecting with me on LinkedIn at https://www.linkedin.com/in/inderpsingh/

Question: What is REST Assured, and why is it popular for Java-based API testing?
Answer: REST Assured is a Java library specifically designed for testing RESTful APIs. It simplifies HTTP requests and responses handling, using concise syntax for validating responses. REST Assured integrates with JUnit and TestNG, making it popular for API testing.
Example: Basic GET Request with REST Assured 

Question: How can you use HttpClient for API testing in Java?
Answer: Apache HttpClient is a library that supports more complex HTTP operations. It’s suitable for test scenarios where we need custom headers, cookies, or advanced request configurations.
Example: Example of GET Request Using HttpClient:

import org.apache.http.HttpResponse;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.impl.client.CloseableHttpClient;

import org.apache.http.impl.client.HttpClients;

import java.io.BufferedReader;

import java.io.InputStreamReader;

public class HttpClientExample {

 public void sendGetRequest() throws Exception {

 CloseableHttpClient client = HttpClients.createDefault();

 HttpGet request = new HttpGet("https://jsonplaceholder.typicode.com/posts/1");

 HttpResponse response = client.execute(request);

 BufferedReader reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));

 String line;

 while ((line = reader.readLine()) != null) {

 System.out.println(line);

 }

 client.close();

 }

}

Question: How can you build a basic API test scenario for a POST request using REST Assured?
Answer: REST Assured allows construction of POST requests to verify data creation endpoints. For testing purposes, JSON data can be sent in the request body.
Example: POST Request Using REST Assured 

Question: How can you chain multiple API requests in REST Assured?
Answer: REST Assured supports response extraction and chaining, enabling us to use the result of one request as input for another. This is useful for test flows that require dependencies across API calls.
Example: Chaining API Requests 

Question: How can you validate JSON responses in REST Assured?
Answer: REST Assured offers easy-to-use syntax to validate JSON responses. The body method lets us directly assert JSON path values.
Example: JSON Validation 

Question: How can you validate XML responses in Java with REST Assured?
Answer: REST Assured can parse XML responses, enabling XPath expressions for field-level validation.
Example: XML Validation Using REST Assured 

Question: How can you handle authentication for API tests in REST Assured?
Answer: REST Assured supports various authentication mechanisms, including basic, OAuth, and API keys. REST Assured also supports token-based authentication for test scenarios with OAuth or API keys.
Example: Basic Authentication 

Question: How can you add headers and cookies to API requests in REST Assured?
Answer: REST Assured allows to specify headers and cookies, allowing us to test complex API calls.
Example: Adding Headers and Cookies 

Question: How can you use REST Assured to validate headers in a response?
Answer: REST Assured allows to assert headers in the response using the header method.
Example: Response Header Validation 

Need quick revision? View the following videos:
- https://youtu.be/HBQxq1UUNAM
https://youtu.be/1gRuQMhydgs
https://youtu.be/e5BLn9IGrF0
https://youtu.be/KTrde1KZPjw
https://youtube.com/shorts/TCidbCMUBiM
https://youtube.com/shorts/t1sfVp-3xDM
https://youtube.com/shorts/BjzJwg9QTyQ
https://youtube.com/shorts/3axOjPJYrw8
https://youtu.be/49BnC2awJ1U
https://youtu.be/2G3of2qRylo

Want to learn more? In order to get my full set of Java Test Automation Interview Questions and Answers with Java code, you are welcome to message me by connecting or following me on LinkedIn. Thank you!

Selenium Java Interview Questions and Answers with Selenium 4 code

Here are my Selenium Java Interview Questions and Answers. If you want my complete set of 100+ Selenium Java Questions and Answers as a document, you can message me on LinkedIn at Inder P Singh.

Question: What is Selenium?
Answer: suite of tools for automating web browsers, to automate interactions and verify expected behavior

Question: What are the Selenium components?
Answer: Selenium IDE, Selenium WebDriver, and Selenium Grid

Question: What is Selenium IDE?
Answer: Browser extension or add-on (Chrome, Firefox & Edge) to record scripts, which can run on any browser or Selenium Grid. Used for bug reproduction scripts and website exploration.

Question: How does Selenium WebDriver work?
Answer: It interacts with a web browser or a remote web server. It sends commands to a browser and retrieves the results.

Question: What is the latest version of Selenium WebDriver?
Answer: version 4 (Find element(s) methods, Capabilities and Actions class are different from version 3)

Question: What is Selenium Grid?
Answer: Tool to run Selenium tests on multiple machines simultaneously, reducing the time to test the web application on multiple browsers or operating systems

Question: What are the Selenium advantages?
Answer: free to use, supports multiple programming languages e.g. Java, Python, C#, supports multiple browsers e.g. Chrome, Firefox (each browser has it's own driver)

Question: What are the Selenium limitations?
Answer: no support for testing desktop applications, limited support for testing mobile applications, no inbuilt reporting features

Question: How to get the correct browser driver for a Selenium WebDriver session in Java?
Answer: download the correct browser driver or by using WebDriverManager e.g.

import io.github.bonigarcia.wdm.WebDriverManager;
WebDriverManager.chromedriver().setup();
  

Question: How to create a Selenium WebDriver session in Java?
Answer: by using WebDriver interface e.g.

WebDriver driver = new ChromeDriver();
  

Question: How to create a local Selenium WebDriver in Java?
Answer: by giving path to driver executable and using WebDriver interface e.g.

System.setProperty("webdriver.chrome.driver", "/path/to/chromedriver");
WebDriver driver = new ChromeDriver();

Question: How to create a remote Selenium WebDriver in Java?
Answer: by using RemoteWebDriver class with ChromeOptions e.g.

ChromeOptions options = new ChromeOptions();
WebDriver driver = new RemoteWebDriver(new URL("https://inderpsingh.blogspot.com/"), options);

Question: In Selenium Java, browser navigation can be done by which command(s)?
Answer: driver.get(), driver.navigate().to(), driver.navigate().back(), driver.navigate().forward() and driver.navigate().refresh();

Question: How to maximize the browser window?
Answer: driver.manage().window().maximize();
Example: You can follow me on LinkedIn at https://www.linkedin.com/in/inderpsingh/

Question: How to get the web page title and the URL in the address bar?
Answer: driver.getTitle(); driver.getCurrentUrl();

Question: How to verify the expected result?
Answer: By using JUnit e.g.

Assert.assertTrue(driver.getTitle().contains("Software and Testing Training"));

Question: What are the different locator strategies in Selenium WebDriver with Java?
Answer: WebDriver can find element By id, By name, By class name, By tag name, By link text, By partial link text, By CSS selector or By XPath

Question: Why are relative XPaths preferred instead of absolute XPaths as locators of elements?
Answer: Relative XPaths are more stable than absolute (complete) XPaths, which fail if any part of the path changes even slightly.

Question: What is InvalidSelectorException in Selenium WebDriver with Java?
Answer: It is thrown when an invalid selector is used to locate an element. To fix this issue, check the selector to see if it is correct and that it is being used correctly.

Question: Relative locators in Selenium 4?
Answer: They identify the location, above, below, toLeftOf, toRightOf or near (less than 50 px) another Web Element with a simple(r) locator.

By submitLocator = RelativeLocator.withTagName("button").below(By.id("simpleID"));

Question: How do you chain relative locators in Selenium 4?
Answer: Chaining relative locators means using multiple relative locators e.g.

By login = RelativeLocator.withTagName(By.tagName("button")).below(By.id("Password")).toRightOf(By.id("Cancel"));

Question: How do you interact with an input box in Selenium WebDriver with Java?
Answer:

WebElement i = driver.findElement(By.id("inputId"));
  i.sendKeys("some value" + Keys.ENTER);

Question: How do you clear an input box in Selenium WebDriver with Java?
Answer: By using the clear method. Note it only works if the input element is enabled and editable. e.g.

WebElement i = driver.findElement(By.id("inputId"));
i.clear();

Question: What is the difference between WebDriver close() and quit() methods?
Answer: close() method closes the main browser window but the quit() method (recommended) closes all the browser windows and deletes the session.

Question: How to write the if statement in Java?
Answer: 1) if (condition) { // code block to run if the condition is true } else { // code block to run if the condition is false}
2) variable = (condition) ? expressionTrue : expressionFalse;

Question: How to execute some JavaScript in Selenium with Java?
Answer:

import org.openqa.selenium.JavascriptExecutor;
JavascriptExecutor js = (JavascriptExecutor) driver;
// open a blank tab in the browser
js.executeScript("window.open();");

Question: How do you interact with a link in Selenium WebDriver with Java?
Answer:

WebElement l = driver.findElement(By.linkText("Link Text"));
l.click();

Question: What if the link text is long or can change?
Answer: It is better to use partialLinkText with the stable part of the link text e.g.

WebDriverWait w = new WebDriverWait(driver, 30);
WebElement l = w.until(ExpectedConditions.elementToBeClickable(
  By.partialLinkText("Partial Link Text")));
l.click();

Question: Which element will WebDriver find if there are multiple matching elements for the locator, as in

WebElement a = driver.findElement(By.className("answer"));

Answer: The first matching web element in the DOM

Question: How to find the 2nd or another element instead of the first element?
Answer: By limiting the scope of finding it e.g.

WebElement question2 = driver.findElement(By.id("q2"));
WebElement a = question2.findElement(By.className("answer"));

Question: How to find the 2nd element using a single WebDriver command?
Answer: By using CSS selector or XPath with # for ID and . for class name e.g.

WebElement a = driver.findElement(By.cssSelector("#q2 .answer"));

Question: Which WebDriver command works on any web element?
Answer: click – it clicks the web element in the middle of the element.

Question: How to get the text shown in the browser by an element?
Answer: By using the getText() method e.g.

String t = driver.findElement(By.cssSelector("#q1")).getText();

Question: How to get some attribute's value of a web element?
Answer: By using the getAttribute() method e.g.

String answer = driver.findElement(By.name("answer1")).getAttribute("value");

Question: When invoked on a web element, what does the submit() method do?
Answer: It is used to submit a form. It works on any web element. But in Selenium 4, it is recommended to click the specific form submission button.

Question: How do you handle dropdowns?
Answer: by using Select class

WebElement dropdown = driver.findElement(By.id("dropdown"));
Select s = new Select(dropdown);
s.selectByVisibleText("Option 1");

Question: How to know if a dropdown is multi select dropdown?
Answer: HTML: the select tag contains "multiple" attribute.

d.isMultiple();

Question: Which method works for the multi select dropdown but NOT for the single select dropdown?
Answer: deselectByVisibleText()

Question: How do you verify the state e.g. visible or enabled of a web element?
Answer: By using .isDisplayed() or .isEnabled() methods on the element. .isSelected() method is to verify if a check box, radio button and so on is selected.

Question: How do you handle alerts?
Answer: by using Alert class

Alert a = driver.switchTo().alert();
a.accept();
  

Question: What is NoAlertPresentException?
Answer: It is thrown when there is no alert present on the page. To fix this, verify that an alert is present before interacting with it. Also, follow me in LinkedIn at https://www.linkedin.com/in/inderpsingh/

Question: How do you handle confirmations?
Answer: by using Alert class, a confirmation may be accepted (OK) or dismissed (Cancel)

Alert c = driver.switchTo().alert();
c.dismiss();
  

Question: How can WebDriver handle the JavaScript popup with 2 buttons?
Answer: These are Confirmation (Confirm box) and Prompt alert. Both have accept() (for OK) and dismiss() (for Cancel) methods. Prompt has sendKeys() for text input.

Question: How do you handle frames in Selenium?
Answer: iframes (elements from any domain), switch to iframe e.g.

driver.switchTo().frame("frameName");
  

Question: What is element not found exception in Selenium with Java?
Answer: It can occur when the web element is not present on the web page (e.g. DOM not loaded fully) or not interactable or is within an iframe or shadow root or the element's locator has changed.

Question: How do you interact with an element in an iframe?
Answer:

driver.switchTo().frame("iframeId");
WebElement element = driver.findElement(By.id("elementId"));
element.click();
  

Question: In Selenium with Java, how can you switch to an iframe with duplicate ID & name?
Answer: driver.switchTo().frame() switches to the first iframe with the duplicate ID or name. driver.findElement() can find the iframe as a WebElement to switch to it. The frame index can also be used to switch to it.

Question: In Selenium with Java, what is NoSuchFrameException?
Answer: It is thrown when the frame you are trying to switch to is not present on the page. To fix this, verify that the frame is present on the page before attempting to switch to it.

Question: How to print the data of all the iframes on a web page?
Answer:

for (WebElement f : driver.findElements(By.tagName("iframe"))) {
    String frameData = "iframe id=" + f.getAttribute("id")
        + ", name=" + f.getAttribute("name")
        + ", source=" + f.getAttribute("src");
    System.out.println(frameData);
}
  

Question: What is a window handle?
Answer: It is a unique alphanumeric string of every window. The window handle is generated and controlled by the browser for a single session.

I have explained all these questions and answers and many more Selenium Java questions and answers in my video below. Please view it. Thank you!