AJITH KUMAR M

[email protected]

Deloitte Interview Questions and Answers for QA Automation Testing:

Core Java

Difference between ArrayList and LinkedList:

ArrayList: Implements a resizable array, supports fast random access (O(1) time
complexity for get() and set() operations), and slower insertions and deletions (O(n)
in the worst case) since elements may need to be shifted.

LinkedList: Implements a doubly linked list, with slower random access (O(n) for
get() and set()), but faster insertions and deletions (O(1)) at both ends (head and
tail).

Multithreading in Java:

Multithreading allows a program to perform multiple tasks concurrently. Java

provides the Thread class and the Runnable interface to create and manage
threads. Multithreading is used to make applications more responsive, such as in
GUI applications or when performing I/O operations. Threads can be synchronized to
prevent issues like race conditions using synchronized blocks or methods.

Difference between Abstract Class and Interface:

Abstract Class: Can have both abstract and concrete methods (methods with
implementation). It can have constructors and member variables. A class can inherit
only one abstract class.

Interface: Can only have abstract methods (until Java 8, after which default and
static methods can be implemented). It cannot have member variables (only
constants). A class can implement multiple interfaces.

Garbage Collection in Java:

Garbage collection is the automatic process of reclaiming memory from objects that
are no longer in use. It is managed by the JVM. Objects are eligible for garbage
collection when there are no references to them. The garbage collector works by
identifying unreachable objects and freeing their memory space. There are different
GC algorithms like Serial, Parallel, CMS, and G1.
Serialization and Deserialization in Java:

Serialization: The process of converting an object into a byte stream so that it can be
saved to a file or transmitted over a network. It is achieved using the Serializable
interface.

Deserialization: The process of converting a byte stream back into an object.

Abstraction, Encapsulation, Inheritance, and Polymorphism:

Abstraction: Hiding the implementation details and showing only the necessary
functionality.

Encapsulation: Wrapping the data (variables) and methods into a single unit (class)
and restricting access to some of the object's components.

Inheritance: A mechanism where one class inherits properties and behaviors

(methods) from another class.
Polymorphism: The ability to perform the same action in different ways. It is achieved
through method overloading (compile-time) and method overriding (runtime).

Difference between Overloading and Overriding:

Overloading: Defining multiple methods with the same name but different parameters
within the same class.

Overriding: Redefining a method in a subclass with the same signature as the

method in the parent class to provide specific behavior.

Difference between String, StringBuffer, and StringBuilder:

String: Immutable, meaning it cannot be changed once created. Operations on

strings create new objects.

StringBuffer: Mutable and synchronized, which makes it thread-safe but slower than
StringBuilder.

StringBuilder: Mutable and not synchronized, making it faster but not thread-safe.

How to achieve abstraction in Java:

Abstraction in Java can be achieved using abstract classes or interfaces. An abstract
class can have abstract methods (without implementation), and a class that inherits it
must provide the implementation. An interface allows defining methods without
implementation, and classes implementing the interface must provide concrete
methods.

Selenium

Difference between WebDriver and RemoteWebDriver:

WebDriver is the interface for controlling the browser, while RemoteWebDriver is a

subclass of WebDriver that allows executing tests on a remote machine or in a
distributed testing environment (like Selenium Grid).

Handling dynamic elements in Selenium:

Dynamic elements often change attributes (like IDs) during execution. You can
handle them using dynamic locators like XPath with conditions, CSS selectors, or
waiting mechanisms like WebDriverWait to handle waiting for elements to appear or
change.

Page Object Model (POM) in Selenium:

The Page Object Model is a design pattern in Selenium where each page of the
application is represented by a separate Java class. The class contains methods that
define the actions and elements of that page. It improves maintainability and reduces
code duplication.

Handling multiple browser windows/tabs in Selenium:

Use getWindowHandles() to get all window handles, then switch between them using
switchTo().window(windowHandle). You can identify the window or tab by the handle
string.

Handling iFrames in Selenium:

Use driver.switchTo().frame(index) or driver.switchTo().frame(nameOrId) to switch to

the iframe. After performing actions inside the iframe, switch back to the main
content with driver.switchTo().defaultContent().
Automation Frameworks
Types of Automation Frameworks:

Data-Driven Framework: Test data is stored externally (e.g., Excel, CSV), and tests
are run with different data inputs.
Keyword-Driven Framework: Test cases are created using keywords that represent
actions, like "click," "enter," etc.

Hybrid Framework: A combination of data-driven and keyword-driven frameworks.

Behavior-Driven Framework: Uses natural language to define test cases (e.g.,

Cucumber).

Designing a Hybrid Automation Framework:

A Hybrid Framework integrates both keyword-driven and data-driven approaches. It

uses external data sources (Excel, CSV) for parameterization and keywords for
defining actions. The framework should support modular test cases, reusable
functions, and clear reporting.

Role of Test Data Management Tool in Automation Framework:

A Test Data Management tool stores, manages, and provides test data for
automation tests. It ensures that different sets of test data are used during execution
and supports reusability.

Test Data Parameterization in Automation Framework:

Test data can be parameterized using external data sources like Excel, CSV, or
databases. In frameworks like TestNG or JUnit, data providers can be used to pass
different data sets into the test methods.

API Testing

Difference between SOAP and REST APIs:

SOAP (Simple Object Access Protocol) is a protocol that uses XML and provides a
strict standard for communication.

REST (Representational State Transfer) is an architectural style that uses standard

HTTP methods and supports multiple data formats (JSON, XML, etc.).
HTTP Methods in REST APIs:

GET: Retrieves data from the server.

POST: Sends data to the server, typically to create a resource.

PUT: Updates an existing resource.

DELETE: Deletes a resource.

Handling Authentication and Authorization in REST APIs:

Use OAuth, API keys, JWT tokens, or basic authentication to secure APIs.
Authentication ensures the user is who they say they are, while authorization
ensures the user has permission to access the requested resource.

Best Practices for Designing and Testing REST APIs:

Use proper HTTP status codes, implement statelessness, ensure resources are
accessible via unique URIs, and handle error cases effectively. In testing, check for
response time, correctness, and security.

Testing the performance of a REST API:

Use tools like JMeter or Postman to simulate traffic and measure the response time,
throughput, and load handling capabilities of the API.

BDD (Cucumber)

Gherkin Syntax in Cucumber:

Gherkin is a domain-specific language used in Cucumber to define behavior

scenarios. It uses keywords like Given (context), When (action), Then (expected
result), And, and But.

Components of Cucumber:

Feature Files: Contain the test scenarios written in Gherkin.

Step Definitions: Define the actions for each step in a scenario.

Hooks: Used to perform actions before or after tests (e.g., setup or teardown).
Handling Data Parameterization in Cucumber:

Use Examples in scenario outlines or integrate with external data sources like Excel,
CSV files, or databases to pass parameters into scenarios.
Integrating Cucumber with Selenium:

In Cucumber, define step definitions that use Selenium WebDriver methods to

interact with the UI. You can then execute Cucumber tests using the Selenium
WebDriver for browser automation.

Maven/Gradle

Purpose of Maven/Gradle:

Maven and Gradle are build automation tools that manage project dependencies,
build processes, and project lifecycle. They ensure consistent builds, version
management, and project configuration.

Maven Build Lifecycle Phases:

Validate, Compile, Test, Package, Install, Deploy.

Handling Dependencies in Maven/Gradle:

Use dependency management sections in the pom.xml (Maven) or build.gradle

(Gradle) to specify external libraries.

Benefits of Maven/Gradle:

Simplifies project build management, dependency management, and continuous

integration.

Creating and Managing Plugins in Maven/Gradle:

You can create custom plugins in Maven or Gradle for extending functionality, such
as custom build tasks.

Git

Difference between Git and GitHub:

Git is a version control system used for tracking changes in code. GitHub is a hosting
service for Git repositories, allowing collaboration and version control in the cloud.

Git Commands:
commit: Saves changes to the local repository.

push: Sends local commits to the remote repository.

pull: Retrieves changes from the remote repository.

merge: Combines changes from different branches.

Handling Conflicts in Git:

Resolve conflicts manually by editing the conflicted files, then mark them as resolved
using git add and complete the merge with git commit.

Purpose of Branching in Git:

Branching allows you to develop features or fixes in isolation from the main
codebase, enabling parallel development and minimizing disruption.

Reverting to a Previous Commit in Git:

Use git checkout <commit> or git reset to revert changes. For safe revert, use git
revert <commit> to create a new commit that undoes the changes.