On Weekend

Day 7 : Automation Testing Interview Questions

/Junaid Aziz /Qasim Nazir

On Weekend

Q : Among all the given locator which locator is fastest of all?

Ans :

The fastest locator in Selenium is the ID locator.

Reasons:

1. Uniqueness: IDs are typically unique in the DOM, allowing Selenium to locate elements directly
without additional filtering.

2. Native Browser Optimization: Browsers optimize ID lookups internally, making them much faster
compared to other locators.

3. Direct Mapping: ID locators directly map to an element in the DOM, bypassing the need for complex
parsing or evaluation.

Q : If the method fails to find the element which of the two methods throws you the exceptions?

Ans :

In Selenium, if a method fails to find an element, two primary types of exceptions may be thrown depending on the
method being used:

1. findElement() Method

 Exception Thrown: NoSuchElementException

 Reason: When you use findElement() and the element cannot be located in the DOM, Selenium
throws a NoSuchElementException.

 Behavior:

o This method expects the element to exist in the DOM at the time of execution.
o It does not return null; it throws the exception immediately if the element is not found.
2. findElements() Method

 Exception Thrown: None

 Behavior:

o If the elements cannot be found, this method does not throw an exception.
o Instead, it returns an empty list (List<WebElement>), allowing the script to handle the absence of
elements gracefully.

Q : What is selenium?

Ans :

Selenium is an open-source framework used for automating web applications across different browsers and
platforms. It provides tools and libraries for writing test scripts in various programming languages such as Java,
Python, C#, Ruby, JavaScript, etc. Selenium is widely used for functional testing, regression testing, and cross-
browser testing.

/Junaid Aziz /Qasim Nazir

On Weekend

Q : How to execute multiple Test cases at a time in TestNG?

Ans :

In TestNG, multiple test cases can be executed simultaneously by creating a testng.xml file, listing the test classes,
and running the XML configuration. This allows batch execution of tests efficiently.

Q : Which method allows you to change control from one window to other?

Ans :

In Selenium, the switchTo().window() method allows you to change control from one window to another. This method
is used to interact with multiple browser windows or tabs during test automation.

Q : How do you optimize your Selenium tests for performance?

Ans :

Optimizing Selenium tests for performance ensures they execute quickly and efficiently while maintaining reliability.
Below are several strategies to achieve this:

 Use Explicit Waits Instead of Implicit Waits

 Avoid Using Thread.sleep()
 Optimize Locators
 Parallel Test Execution
 Use Headless Browsers for Testing
 Minimize Browser Interactions
 Reuse Browser Sessions
 Avoid Redundant Assertions

Q : What is Selenium Grid and how do you use it to run parallel tests across multiple browsers and machines?

Ans :

Selenium Grid is a component of the Selenium suite that allows you to execute tests in parallel across multiple
browsers, operating systems, and machines. It enables distributed test execution, making it ideal for large test suites
or scenarios requiring cross-browser testing.

Key Features of Selenium Grid:

1. Parallel Execution: Run multiple tests simultaneously.

2. Cross-Browser Testing: Supports various browsers like Chrome, Firefox, Safari, Edge, etc.

3. Cross-Platform Support: Tests can be executed on Windows, macOS, and Linux.

4. Centralized Control: Tests are managed from a single machine (Hub).

public class SeleniumGridExample {

public static void main(String[] args) throws MalformedURLException {
// Define desired capabilities
DesiredCapabilities capabilities = new DesiredCapabilities(); capabilities.setBrowserName("chrome");
capabilities.setPlatformName("WINDOWS");

/Junaid Aziz /Qasim Nazir

On Weekend

// Connect to the Hub

WebDriver driver = new RemoteWebDriver(new URL("http://<hub-ip>:4444/wd/hub"), capabilities);

// Execute test
driver.get("https://example.com"); System.out.println("Page title is: " +
driver.getTitle());

driver.quit();
}
}
Q : Explain the concept of cross-browser compatibility testing with Selenium ?

Ans :
Cross-browser compatibility testing ensures that a web application works consistently and as expected across
different web browsers, operating systems, and devices. This is essential because users may access the application
using various browsers like Chrome, Firefox, Safari, and Edge, each of which may interpret and render HTML, CSS,
and JavaScript differently.

Role of Selenium in Cross-Browser Compatibility Testing

Selenium provides a unified interface to automate web testing across multiple browsers and platforms. It enables
testers to validate that their application behaves the same way in different browser environments.

Key Concepts in Cross-Browser Compatibility Testing with Selenium

1. Browser Support: Selenium supports popular browsers:
o Google Chrome: Using ChromeDriver
o Mozilla Firefox: Using GeckoDriver
o Microsoft Edge: Using EdgeDriver
o Safari: Using SafariDriver
2. Platform Support: Selenium can test applications on different operating systems like Windows,
macOS, and Linux.
3. Parallel Testing: Selenium Grid allows you to run tests simultaneously on multiple browsers and platforms
to save time.
4. Handling Browser-Specific Behaviors: Some browsers may behave differently with certain features (e.g.,
date pickers, file uploads). Selenium allows testers to write scripts that handle such quirks.

Q : How do you handle iFrames and JavaScript execution in Selenium ?

Ans :
Handling iFrames and JavaScript execution are essential aspects of automating tests in Selenium. These features
help interact with elements embedded within frames and perform actions that may not be directly supported by
Selenium’s built-in methods.

Handling iFrames and JavaScript execution are essential aspects of automating tests in Selenium. These features
help interact with elements embedded within frames and perform actions that may not be directly supported by
Selenium’s built-in methods.

driver.switchTo().frame(0); // Switch to the first iFrame

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

/Junaid Aziz /Qasim Nazir

On Weekend

WebElement iframeElement = driver.findElement(By.tagName("iframe"));

driver.switchTo().frame(iframeElement);

Handling JavaScript Execution in Selenium

Sometimes, Selenium's standard methods may not be sufficient to interact with certain elements or perform
specific actions. For such scenarios, Selenium provides the JavascriptExecutor interface to execute JavaScript
code directly.

JavascriptExecutor js = (JavascriptExecutor) driver;

js.executeScript("alert('Hello World');");

Q : Explain the WebDriver architecture and how it interacts with different browsers ?

Ans :

Client Libraries: Selenium provides libraries (APIs) for various programming languages like Java, Python, C#, Ruby,
JavaScript, etc. These libraries are used to write automation scripts.

JSON Wire Protocol / W3C WebDriver Protocol:

 WebDriver uses either the JSON Wire Protocol (older versions) or the W3C WebDriver Protocol
(standardized version) to communicate between the client and the browser driver.

 The protocol encapsulates requests and responses in JSON format over HTTP.

Browser Drivers: Each browser has its own driver (e.g., ChromeDriver for Chrome, GeckoDriver for Firefox) that acts
as a bridge between WebDriver commands and the actual browser.

Browsers: WebDriver interacts with browsers (Chrome, Firefox, Edge, Safari, etc.) through their respective drivers to
execute the commands specified in the test scripts.

Q : What are the different types of waits in Selenium ?

Ans :

In Selenium, waits are used to handle dynamic content and ensure that elements are available for interaction before
performing actions like clicking, sending keys, or retrieving text. There are three main types of waits in Selenium:

1. Implicit Wait

 Definition: Implicit Wait is a global wait that is applied to all elements in the WebDriver instance. It
tells the WebDriver to wait for a certain amount of time before throwing a
NoSuchElementException if an element is not immediately available.
 How it Works: If the element is not found, the driver will poll the DOM for the specified duration, and
once the element is found, it will proceed with the execution.

 Use Case: Use Implicit Wait when you know elements may take a little time to appear, but it's not necessary
to wait for specific elements.

// Set an implicit wait of 10 seconds driver.manage().timeouts().implicitlyWait(10,

TimeUnit.SECONDS);

/Junaid Aziz /Qasim Nazir

On Weekend

2. Explicit Wait

 Definition: Explicit Wait allows you to wait for a specific condition to occur before proceeding with further
actions. It is more flexible compared to Implicit Wait, as it is applied only to a specific element or condition.
 How it Works: It waits for a particular condition to be true, such as an element becoming visible, clickable,
or present, and if the condition is met, the script proceeds. If the condition is not met within the specified
timeout, a TimeoutException is thrown.

 Use Case: Use Explicit Wait when you want to wait for a specific element or condition to be met before
performing an action.

WebDriverWait wait = new WebDriverWait(driver, 10);

WebElement element =
wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("someId")));
element.click();

3. Fluent Wait
 Definition: Fluent Wait is similar to Explicit Wait but with more control over the frequency of condition
checking. You can specify the maximum wait time and the polling interval (how often Selenium should check
the condition).
 How it Works: Fluent Wait allows you to set both the maximum time to wait and the interval between each
check. It also lets you ignore certain exceptions while waiting.
 Use Case: Fluent Wait is useful when you want to repeatedly check a condition at specific intervals (e.g.,
wait for an element to appear with retries).

Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)

.withTimeout(30, TimeUnit.SECONDS)
.pollingEvery(5, TimeUnit.SECONDS)
.ignoring(NoSuchElementException.class);

WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("someId")));

element.click();

Q : What are some common Selenium exceptions you have encountered and how did you troubleshoot them?

Ans :
NoSuchElementException
 Cause: This exception is thrown when WebDriver is unable to find an element on the page using the
specified locator.
 Troubleshooting:
o Check the locator: Ensure that the locator (e.g., id, name, xpath, etc.) is correct and uniquely
identifies the element.
o Check element visibility: Ensure the element is visible and not hidden behind other elements or
not rendered yet.
TimeoutException
 Cause: This exception occurs when a command takes longer than the specified wait time.
 Troubleshooting:
o Increase the wait time: If your application is slow, increase the wait time or polling interval.
o Use explicit waits: Use WebDriverWait to wait for specific conditions to occur.
o Check element readiness: Ensure that the element is actually ready to interact with by checking

/Junaid Aziz /Qasim Nazir

On Weekend

visibility, enabled state, or other conditions.

Q : What is Page Object Model design pattern?

Ans :

The Page Object Model (POM) design pattern is a popular and effective approach to organizing and structuring
Selenium test cases. POM promotes code reusability, maintainability, and separation of concerns by representing
web pages as classes.

Q : What are Hooks in Cucumber?

Ans :
Types of Hooks in Cucumber @Before Hook
o The @Before hook runs before each scenario or test.
o It is typically used to set up any preconditions, such as initializing objects, setting up databases, or
starting web browsers.
@After Hook
 The @After hook runs after each scenario or test.
 It is typically used for cleanup tasks, such as closing browsers, clearing data, or logging out from
applications.
@BeforeStep Hook
 The @BeforeStep hook runs before each step in a scenario.
 It is useful for actions that need to happen before each step, such as logging or validation before
executing steps.
@AfterStep Hook
 The @AfterStep hook runs after each step in a scenario.
 It can be used for logging, taking screenshots, or validating the state after each step is executed.

Q : Difference between List and Set ?

Ans :

Feature List Set

Order Maintains insertion order Does not guarantee order
Duplicates Allows duplicates Does not allow duplicates
Implementations ArrayList, LinkedList, etc. HashSet, TreeSet, etc.
Access by Index Yes No
Performance Random access by index (fast) Faster operations (e.g.,
HashSet O(1))
Null Elements Can contain null Can contain null (except
TreeSet)
Methods Methods for index-based Methods for set-based
access operations (e.g., add(),
remove())
Use Case When order or duplicate When uniqueness is required
elements matter

/Junaid Aziz /Qasim Nazir