Author: vibssingh

vibssingh

How to install Playwright in Windows?

HOME

In this tutorial, I will explain the steps to install Playwright on a Window machine. To install Playwright on a Windows machine, you will typically use Node.js and the npm (Node Package Manager).

Table of Contents

  1. System Requirements
  2. Implementation Steps
    1. Install Node.js and npm
    2. Create a Project Directory
    3. Install Playwright
    4. Create a new Playwright project
    5. Running the Example Test through Terminal
    6. HTML Test Reports

System Requirements:

  • Node.js version 18 or higher
  • npm (comes with Node.js)
  • Windows 10+, macOS 12+, or Ubuntu 20.04+
  • At least 2GB free disk space for browser binaries
  • Visual Studio for Code is already installed.

Visual Studio for Code must be installed. If it is not already installed, please refer to this tutorial – How to Install Visual Studio Code on Windows.

Below are the step-by-step instructions to get Playwright up and running on Windows:

Implementation Steps:

1. Install Node.js and npm

Please refer the below tutorial to install node.js.

How to install node.js on windows 11

2. Create a Project Directory

Open Command Prompt or PowerShell. Make a new directory for your Playwright project and navigate into it:

The new empty folder “playwright-demo-project” is created in Documents/Playwright folder.

3. Install Playwright

Open Visual Studio for Code. Install “Playwright Test for VSCode” from Microsoft via the Extensions tab.

Once the plugin is installed. We can see a new Funnel icon called Testing as shown in the image.

4. Create a new Playwright project

Go to File and select Open Folder we have created earlier – playwright-demo-project.

We can see the project is opened in VS code.

Go to the terminal in this project and open a New Terminal.

Type the below command in the terminal

npm init playwright@latest

When prompted, choose / confirm:

  • TypeScript or JavaScript (default: TypeScript)
  • Tests folder name (default: tests, or e2e if tests already exists)
  • Add a GitHub Actions workflow (recommended for CI) – Initial project, so mentioned False
  • Install Playwright browsers (default: yes)

Playwright downloads required browser binaries and creates the scaffold below.

playwright.config.ts         # Test configuration
package.json
package-lock.json            # Or yarn.lock / pnpm-lock.yaml
tests/
  example.spec.ts            # Minimal example test

The playwright.config centralizes configuration: target browsers, timeouts, retries, projects, reporters and more. In existing projects dependencies are added to your current package.json.

tests/ contains a minimal starter test. tests-examples/ provides richer samples (e.g. a todo app) to explore patterns.

5. Running the Example Test through Terminal

By default tests run headless in parallel across Chromium, Firefox and WebKit (configurable in playwright.config). Output and aggregated results display in the terminal.

npx playwright test

6. HTML Test Reports

After a test run, the HTML Reporter provides a dashboard filterable by the browser, passed, failed, skipped, flaky and more. Click a test to inspect errors, attachments and steps. It auto-opens only when failures occur; open manually with the command below.

npx playwright show-report

The report is also present in playwright-report folder with the name of “index.html”.

Summary:
1. Install Node.js.
2. Initialize npm project.
3. Install Playwright.
4. Run a test script to verify your setup.
5. View Test report – Index.html report

To know more about Playwright, please refer to this documentation – https://playwright.dev/docs.

vibssingh

Playwright Tutorials

Last Updated Date

HOME

Playwright is a modern and powerful end-to-end testing framework developed by Microsoft, specifically designed for the automation of web applications.  It supports programming languages like Java, Python, C#, and NodeJS. Playwright comes with Apache 2.0 License and is most popular with NodeJS with Javascript/Typescript.

Chapter 1 How to install node.js on windows 11
Chapter 2 How to Install Visual Studio Code on Windows
Chapter 3 Why Choose Playwright for Browser Automation?
Chapter 4 How to install Playwright in Windows?
Chapter 5 How to run tests in UI mode in Playwright
Chapter 6 How to Specify Browsers in Playwright Tests
Chapter 7 Automate Playwright Tests with Command-Line Options
Chapter 8 How to Attach Screenshots in Playwright for Failed Tests
Chapter 9 Unlocking Playwright: Test Reports with Tags and Annotations – NEW
Chapter 10 Mastering Snapshot Testing with Playwright – NEW

API Testing

Chapter 1 How to Execute GET Requests in Playwright
Chapter 2 How to Execute POST Requests in Playwright
Chapter 3 How to Execute PUT Requests in Playwright – NEW
Chapter 4 How to Execute PATCH Requests in Playwright – NEW
Chapter 5 How to Execute DELETE Requests in Playwright – Coming Soon
Chapter 6 How to add custom headers in Playwright? – Coming Soon
Chapter 7 Handle Query Parameters in Playwright – Coming Soon
Chapter 8 Send JSON File as Payload in Playwright – Coming Soon
Chapter 9 Send XML File as Payload in Playwright – Coming Soon
vibssingh

Why Choose Playwright for Browser Automation?

HOME

Table of Contents

  1. What is Playwright?
  2. Features of Playwright
  3. Disadvantages of Playwright
  4. Why choose Playwright Automation?

What is Playwright?

Playwright is a modern and powerful end-to-end testing framework developed by Microsoft, specifically designed for the automation of web applications.  It supports programming languages like Java, Python, C#, and NodeJS. Playwright comes with Apache 2.0 License and is most popular with NodeJS with Javascript/Typescript.

Playwright was created by the same engineering team that built Puppeteer. The Playwright team created Playwright to extend Puppeteer’s UI automation capabilities to all rendering engines, no longer just supporting Chromium.

Features of Playwright

Cross-Browser Support:

Playwright can automate web pages across all major browsers. This includes Chromium, which is used by Google Chrome, Firefox, and WebKit, which is used by Safari. These capabilities allow for extensive cross-browser testing.

2. Multi-Language Support:

Playwright is available in several programming languages, including JavaScript, TypeScript, Python, .NET, and Java, making it accessible to a wide range of developers.

3. Multi-Platform Compatibility:

 It supports running tests on various operating systems, including Windows, macOS, and Linux.

4. Auto-Waiting

Playwright waits for elements to be actionable prior to performing actions. It also has a rich set of introspection events. The combination of the two eliminates the need for artificial timeouts – the primary cause of flaky tests.

5. Mobile Emulation

Playwright allows you to emulate mobile devices, such as iPhones and iPads. You can test how your web application behaves on different screen sizes and orientations.

6. Headless Mode

Playwright run tests in visible or headless mode efficiently. It allows testing in headless mode, that means executing browser actions without displaying the UI. This method is faster and suitable for CI/CD pipelines.

7. Video Recording

Playwright automatically records videos of your tests, which can be useful for debugging and for creating visual regression tests.

8. Built-in Test Assertions and Features

Playwright supports assertions and various testing features directly integrated within its framework, allowing testers to verify results seamlessly. Checks are automatically retried until the necessary conditions are met.

9. Visual and Screenshot Testing

Playwright supports visual and screenshot testing helping you capture full-page screenshots, element snapshots, and video recordings.

10. Network Interception and Customization

It allows manipulation and interception of network requests. This feature can be used for testing API calls in isolation. Additionally, it helps in simulating network conditions like offline mode.

11. Code Generation

Playwright includes a code generator. It can generate code for your tests. This feature saves you time and reduces the risk of errors.

12. Shadow DOM and iframe support

Playwright selectors can pierce deep DOM structures and handle nested frames seamlessly.

13. Browser contexts

Playwright creates a browser context for each test. Browser context is equivalent to a brand new browser profile. This delivers full test isolation with zero overhead. Creating a new browser context only takes a handful of milliseconds.

14. Authentication state reuse

Save the authentication state of the context and reuse it in all the tests. This bypasses repetitive log-in operations in each test, yet delivers full isolation of independent tests.

15. Accessibility testing

It includes tools for testing web accessibility, helping ensure that web applications are usable by people with disabilities.

Disadvantages of Playwright

1.Community and Ecosystem

The Playwright ecosystem and community are growing. However, they are smaller compared to more established tools like Selenium. This size difference can affect the availability of plugins and extensions.

2. Learning Curve:

Playwright’s API can be somewhat complex for users new to web testing frameworks. The ability to handle multiple contexts and browsers simultaneously might be overwhelming for beginners who are more familiar with simpler tools.

3. Resource Consumption

Running tests across multiple browsers simultaneously can be resource-intensive. Ensuring that the testing environment can handle the load without affecting performance might require additional infrastructure or optimizations.

4. Rapid Development Changes

As Playwright is actively developed, frequent changes and version updates are necessary. These changes help to keep up with the latest features and fixes. However, they can potentially impact long-term project stability.

5. Limited Built-in Integrations

Compared to some other tools like Cypress, Playwright has fewer out-of-the-box integrations with third-party services (e.g., dashboards).

6. Debugging Complexity

Debugging may require deeper knowledge of asynchronous code, especially where modern applications have complex behaviors needing careful handling within tests.

Why choose Playwright Automation?

Deciding when to use the Playwright framework for web testing involves evaluating several factors. These factors relate to your project’s specific requirements. You should also consider the capabilities of Playwright and your existing infrastructure.

As of end of 2025, the current snapshot of Microsoft Playwright on Github:

  • Active Users: 426.0k
  • Forks (copy of a repository that you manage): 4.8k
  • Releases: 154 (This shows how active they are in fixing and releasing new features)

Ease of Installation and Setup

Playwright’s setup is straightforward. It includes automatic download of compatible browsers. This reduces initial configuration overhead. Other frameworks require manual installation of browser drivers.

Cross-Browser Testing Needs

Playwright offers robust support for Chromium, Firefox, and WebKit, enabling comprehensive cross-browser testing from a single API. If this is critical for your project, Playwright is a strong candidate.

Parallel execution

Playwright’s ability to run tests in parallel across isolated browser contexts significantly reduces execution time.

CI/CD Integration Support

Playwright supports CI/CD integration. It even provides docker images for some language bindings.

To know more about Playwright, please refer to this website – https://playwright.dev/.

vibssingh

How to update XML Documents Using Java DOM Parser

Last Updated On

HOME

In this article, we will explain how to update an existing XML file. We will do this by adding new elements using the DOM (Document Object Model) parser. 

Table of Contents

  1. Updating existing Element
  2. Creating and Appending New Elements
  3. Limitations of JAVA DOM

Below is the sample XML which is created and saved in resources/Payloads as SimpleXML.xml. We are going to modify this XML.

Updating existing Element:

Here, I’m updating the position of employee id “1” from “Software Engineer” to “Consultant”.

The complete program looks like as shown below:

package XML.DOM;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.File;
import java.io.IOException;

public class DOM_ModifyXMLDemo {

    public static void main(String[] args) {

        try {

            //Create a DocumentBuilderFactory and DocumentBuilder
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();

            // Parse the XML file into a Document
            Document document = builder.parse(new File("src/test/resources/Payloads/SimpleXML.xml"));

            // Normalize XML structure
            document.getDocumentElement().normalize();

            // Step 3: Update the XML content
            NodeList nodeList = document.getElementsByTagName("employee");

            for (int i = 0; i < nodeList.getLength(); i++) {
                Element employee = (Element) nodeList.item(i);
                String id = employee.getAttribute("id");

                if ("1".equals(id)) {
                    Element position = (Element) employee.getElementsByTagName("position").item(0);
                    position.setTextContent("Consultant");
                }
            }

            //Traverse the nodes to normalize spaces in text nodes
            Node rootNode = document.getDocumentElement();
            normalizeSpace(rootNode);

            //Write changes back to the XML file
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");

            //Writing updated content into the file
            DOMSource domSource = new DOMSource(document);

            StreamResult fileResult = new StreamResult(new File("src/test/resources/Payloads/UpdatedXML.xml"));
            transformer.transform(domSource, fileResult);

            // Print updated XML to console
            StreamResult consoleResult = new StreamResult(System.out);
            transformer.transform(domSource, consoleResult);

            System.out.println("\n XML file updated successfully!");

        } catch (ParserConfigurationException | TransformerException | IOException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            throw new RuntimeException(e);
        }
    }

    private static void normalizeSpace(Node node) {
        if (node.getNodeType() == Node.TEXT_NODE) {
            String trimmedText = node.getTextContent().trim().replaceAll("\\s+", " ");
            node.setTextContent(trimmedText);
        }
        NodeList children = node.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            normalizeSpace(children.item(i));
        }
    }
}

Explanation

Here’s a detailed breakdown of the code:

1. Creating a DocumentBuilder Object

It has ‘newDocumentBuilder()’ method that creates an instance of the class ‘DocumentBuilder’. This DocumentBuilder class is used to get input in the form of streams, files, URLs and SAX InputSources.

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();

2. Parsing the XML File

The code parses “SimpleXML.xml” from the specified path and normalizes the XML structure (i.e., adjusts the whitespace within the document).

Document document = builder.parse(new File("src/test/resources/Payloads/SimpleXML.xml"));

3. Normalize XML Structure

The method normalize() is invoked on the document’s root element. It cleans up the XML by merging adjacent text nodes. It also removes empty ones.

 document.getDocumentElement().normalize();

4. Update XML Content

A NodeList of “employee” elements is retrieved, and each element is iterated over. The code checks each “employee” element’s “id” attribute. If an employee with id=”1″ is found, its “position” element’s text content is updated to “Consultant”.

  NodeList nodeList = document.getElementsByTagName("employee");

            for (int i = 0; i < nodeList.getLength(); i++) {
                Element employee = (Element) nodeList.item(i);
                String id = employee.getAttribute("id");

                if ("1".equals(id)) {
                    Element position = (Element) employee.getElementsByTagName("position").item(0);
                    position.setTextContent("Consultant");
                }
            }

5. Normalize Spaces in Text Nodes

The normalizeSpace method is defined to recursively traverse nodes, trimming and normalizing spaces in text nodes to ensure consistent formatting. This is called with the root node as an argument.

private static void normalizeSpace(Node node) {
        if (node.getNodeType() == Node.TEXT_NODE) {
            String trimmedText = node.getTextContent().trim().replaceAll("\\s+", " ");
            node.setTextContent(trimmedText);
        }
        NodeList children = node.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            normalizeSpace(children.item(i));
        }
    }

6. Write Changes Back to XML File

After building the elements inside the document with their corresponding attributes, we must write this content into an XML file. We do this by creating a Transformer object, which transforms our source document into StreamResult. It then stores the result in the specified file path with the given name.

TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();

transformer.setOutputProperty(OutputKeys.INDENT, "yes"); // Pretty print the XML
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");

DOMSource domSource = new DOMSource(document);

 // Write XML to file
 StreamResult fileResult = new StreamResult(new File("src/test/resources/Payloads/UpdatedXML.xml"));
transformer.transform(domSource, fileResult);

7. Printing the output on the console

We can test our XML file by printing it on the console. This is an optional step.

StreamResult consoleResult = new StreamResult(System.out);
transformer.transform(domSource, consoleResult);

8. Exception Handling

The code handles exceptions that arise from parser configuration, transformation, I/O operations, or SAX parsing.

try {
 } catch (ParserConfigurationException | TransformerException | IOException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            throw new RuntimeException(e);
        }
    }

Creating and Appending New Elements:

It reads an existing XML file. It adds a new “employee” element with nested elements (“name” and “position”). It normalizes spaces within text nodes. Then, it writes the updated content back to an XML file. 

package XML.DOM;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.File;
import java.io.IOException;

import static org.apache.commons.lang3.StringUtils.normalizeSpace;

public class DOM_ModifyXMLAddElementsDemo {

    public static void main(String[] args) {

        try {

            //Create a DocumentBuilderFactory and DocumentBuilder
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();

            // Parse the XML file into a Document
            Document document = builder.parse(new File("src/test/resources/Payloads/SimpleXML.xml"));

            // Normalize XML structure
            document.getDocumentElement().normalize();

            //Locate the root element
            Element rootElement = document.getDocumentElement();

            // Create a new employee element
            Element employee = document.createElement("employee");
            employee.setAttribute("id", "4");

            // Create name element
            Element name = document.createElement("name");
            name.appendChild(document.createTextNode("Milly Mathew"));
            employee.appendChild(name);

            // Create position element
            Element position = document.createElement("position");
            position.appendChild(document.createTextNode("Architect"));
            employee.appendChild(position);

            //Append the new employee node to the root element
            rootElement.appendChild(employee);

            //Traverse the nodes to normalize spaces in text nodes
            Node rootNode = document.getDocumentElement();
            normalizeSpace(rootNode);

            //Write changes back to the XML file
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");

            //Writing updated content into the file
            DOMSource domSource = new DOMSource(document);

            StreamResult fileResult = new StreamResult(new File("src/test/resources/Payloads/UpdatedXML1.xml"));
            transformer.transform(domSource, fileResult);

            // Print updated XML to console
            StreamResult consoleResult = new StreamResult(System.out);
            transformer.transform(domSource, consoleResult);

            System.out.println("\n XML file updated successfully!");

        } catch (ParserConfigurationException | TransformerException | IOException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            throw new RuntimeException(e);
        }
    }

    private static void normalizeSpace(Node node) {
        if (node.getNodeType() == Node.TEXT_NODE) {
            String trimmedText = node.getTextContent().trim().replaceAll("\\s+", " ");
            node.setTextContent(trimmedText);
        }
        NodeList children = node.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            normalizeSpace(children.item(i));
        }
    }

}

The output of the above program is

Explanation

Step 1, 2 and 3 are same as the above program.

4. Locating the Root Element

It retrieves the root element of the XML document using getDocumentElement().

Element rootElement = document.getDocumentElement();

5. Creating and Appending New Elements

A new “employee” element with an attribute “id” is created. Nested elements “name” and “position” are created with relevant text nodes “Milly Mathew” and “Architect”. These elements are appended to the “employee” element, which is then appended to the root element of the XML document.

 // Create a new employee element
 Element employee = document.createElement("employee");
employee.setAttribute("id", "4");

// Create name element
Element name = document.createElement("name");
name.appendChild(document.createTextNode("Milly Mathew"));
employee.appendChild(name);

// Create position element
Element position = document.createElement("position");
position.appendChild(document.createTextNode("Architect"));
employee.appendChild(position);

//Append the new employee node to the root element
rootElement.appendChild(employee);

Step 6, 7 and 8 are same as the above program.

Limitations of JAVA DOM

  1. DOM loads the entire XML file into memory as a tree structure. For very large XML files, this can consume a significant amount of memory. It may lead to potential memory exhaustion. This affects system performance.
  2. Parsing large XML files with DOM can be slower compared to other parsers, such as SAX. This is because the entire document must be read and loaded into memory before any processing can begin.

We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

vibssingh

How to Install Visual Studio Code on Windows

HOME

Visual Studio Code (VS Code) is a free, lightweight, and open-source code editor developed by Microsoft. It supports multiple operating systems, including Windows, macOS, and Linux.

Installation Steps:

Download Visual Studio Code

Step 1: Visit the Official Website of the Visual Studio Code using any web browser like Google Chrome, Microsoft Edge, etc.

This website download the Visual Studio Code Application.

Step 2: When the download finishes, then the Visual Studio Code Icon appears in the downloads folder.

Run Installer

Step 3: Locate the downloaded installer file (it’s usually saved in the “Downloads” folder). Click on the Installer icon to start the installation process of the Visual Studio Code.

Setup Installation

Step 4: After the Installer opens, it will ask you to accept the terms and conditions of the Visual Studio Code. Click on “I accept the agreement” and then click the “Next” button.

Step 5: Choose the location data for running the Visual Studio Code. It will then ask you to browse the location. Then click on the “Next” button.

Step 6: Assign a program name to the VisualStudio Code to appear in the Start Menu folder.

Step 7: Select the additional tasks as per your requirement. I have selected to Create a desktop icon. register code as an editor and app to PATH.

 Step 8: The program will ask to begin the installation setup. Click on the “Install” button.

Install Visual Studio Code

Step 9: Click “Install” to begin the installation. After clicking on Install, it will take about 1 minute to install the Visual Studio Code on your device.

Step 10: Once installation is complete, you’ll be given the option to launch Visual Studio Code immediately. Click “Finish” to complete the setup.

Launch Visual Studio Code

Step 11: After the previous step, the Visual Studio Code window opens successfully. Now you can create a new file in the Visual Studio Code window and choose a language of yours to begin your programming journey

That’s it! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

vibssingh

Highlighting Elements in Selenium Java

Last Updated On

HOME

Highlighting an element in Selenium can be useful for debugging purposes. It visually distinguishes the element being interacted with. This small addition can improve debugging, make demo videos clearer, and reduce false positives in your test results. 

In Selenium Java, you can achieve this by using JavaScript. You can alter the element’s style, such as adding a border around it.

In the below example, we want to highlight the text – English.

Below is the Selenium program that will highlight the text.

package Web;

import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;

import java.time.Duration;

public class HighlightText_Example {

    public static void main(String args[]) {

        ChromeOptions chromeOptions = new ChromeOptions();
        WebDriver driver = new ChromeDriver(chromeOptions);
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
        driver.manage().window().maximize();

        try {
            driver.get("https://www.selenium.dev/");

            // identify the element
            WebElement element = driver.findElement(By.xpath("//*[@id='main_navbar']/ul/li[7]/div/a"));

            // Optionally, we wait to observe the element before changing the color
            Thread.sleep(1000);

            // Set the background color to yellow and the border to red
            JavascriptExecutor js = (JavascriptExecutor) driver;
            js.executeScript("arguments[0].style.backgroundColor = 'yellow'; arguments[0].style.border = '3px solid red';", element);

            // Optionally, we can wait to observe the highlight effect
            Thread.sleep(2000);
            System.out.println("Text is highlighted");

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally{
            // Closing browser
            driver.quit();
        }
    }
}

The output of the above program is

Below is the image of yellow highlighted background with red border.

Explanation:

1. Set Up Chrome Options and WebDriver

ChromeOptions is created. A ChromeDriver object driver is created to control the Chrome browser. implicitlyWait is set to 10 seconds to wait for elements to be present before throwing an exception. The browser window is maximized for better visibility during the test.

ChromeOptions chromeOptions = new ChromeOptions();
WebDriver driver = new ChromeDriver(chromeOptions);
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
driver.manage().window().maximize();

2. Navigate to a Webpage

The get() method of driver is used to navigate to the specified URL.

driver.get("https://www.selenium.dev/");

3. Find Element

An element is located using an XPath expression.

WebElement element = driver.findElement(By.xpath("//*[@id='main_navbar']/ul/li[7]/div/a"));

4. Execute JavaScript

Use the JavaScriptExecutor to apply styling to the element. This can include adding a border or changing the background color temporarily.

  // Set the background color to yellow and the border to red
 JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("arguments[0].style.backgroundColor = 'yellow'; arguments[0].style.border = '3px solid red';", element);

5.  Pause for visualization

This is an optional step. We have added it so that the user can see the color change.

 Thread.sleep(2000);

6.  Clean Up

The finally block ensures that the browser is closed irrespective of whether the test passes or fails, using driver.quit() to close all browser windows and end the session.

// Close the browser
driver.quit();

Summary:
1. Initialize a WebDriver and direct it to interact with your target webpage.
2. Identify the desired web element using suitable locators.
3. By using arguments[0].style.border=’3px solid red’, you can add a red border around the element, effectively highlighting it.

That’s it! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

vibssingh

Retrieve Font Properties with Selenium in Java

HOME

Last Updated On

Retrieving font properties using Selenium in Java is essential for testing and validating the styling of web applications. We can verify font-related CSS attributes such as font-family, font-size, and font-weight and so on. This ensures that your application’s user interface adheres to design specifications. It provides a consistent user experience across different browsers and environments.

To find the font properties of a web element in Selenium (Java), use the getCssValue method. We will use the getCssValue to extract properties of font like font-family, font-size, and many more.

In the below example, we want to find the font properties of the highlighted text, that is “LEARN MORE”.

Below is the Selenium program that find the font properties of the highlighted text.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import java.io.IOException;
import java.time.Duration;

public class Font_Example {

    public static void main(String args[]) throws IOException {

        ChromeOptions chromeOptions = new ChromeOptions();
        WebDriver driver = new ChromeDriver(chromeOptions);
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(5));
        driver.manage().window().maximize();

        try {
            // Navigate to Url
            driver.get("https://www.selenium.dev/");

            WebElement element = driver.findElement(By.xpath("//*[@class='selenium-button-container']/a"));

            // Retrieve the font color
            String fontFamily  = element.getCssValue("font-family");
            System.out.println("fontFamily  : " + fontFamily );

            // Retrieve the font size
            String fontSize = element.getCssValue("font-size");
            System.out.println("fontSize : " + fontSize);

            // Retrieve the font weight
            String fontWeight = element.getCssValue("font-weight");
            System.out.println("fontWeight : " + fontWeight);

            // Retrieve the font style
            String fontStyle  = element.getCssValue("font-style");
            System.out.println("fontStyle : " + fontStyle);

            // Retrieve the font variation
            String fontVariant  = element.getCssValue("font-variant");
            System.out.println("fontVariant : " + fontVariant);

            // Retrieve the line height
            String lineHeight  = element.getCssValue("line-height");
            System.out.println("lineHeight : " + lineHeight);

            // Retrieve the letter spacing
            String letterSpacing  = element.getCssValue("letter-spacing");
            System.out.println("letterSpacing : " + letterSpacing);

            // Retrieve the text transform
            String textTransform  = element.getCssValue("text-transform");
            System.out.println("textTransform : " + textTransform);

            // Retrieve the text decoration
            String textDecoration  = element.getCssValue("text-decoration");
            System.out.println("textDecoration : " + textDecoration);

            System.out.println("####################### Verify the font properties #########################");

            // Verify the font family
            if (fontFamily.contains("Arial")) {
                System.out.println("fontFamily is as expected.");
            } else {
                System.out.println("fontFamily is not as expected. Found: " + fontFamily);
            }

            // Verify the font size
            if (fontSize.equals("16px")) {
                System.out.println("fontSize is as expected.");
            } else {
                System.out.println("fontSize is not as expected. Found: " + fontSize);
            }

            // Verify the font weight
            if (fontWeight.equals("500")) {
                System.out.println("fontWeight is as expected.");
            } else {
                System.out.println("fontWeight is not as expected. Found: " + fontWeight);
            }

            // Verify the font style
            if (fontStyle.equals("italic")) {
                System.out.println("fontStyle is as expected.");
            } else {
                System.out.println("fontStyle is not as expected. Found: " + fontStyle);
            }

            // Verify the font variant
            if (fontVariant.equals("small-caps")) {
                System.out.println("fontVariant is as expected.");
            } else {
                System.out.println("fontVariant is not as expected. Found: " + fontVariant);
            }

            // Verify the line height
            if (lineHeight.equals("24px")) {
                System.out.println("lineHeight is as expected.");
            } else {
                System.out.println("lineHeight is not as expected. Found: " + lineHeight);
            }

            // Verify the letter Spacing
            if (letterSpacing.equals("normal")) {
                System.out.println("letterSpacing is as expected.");
            } else {
                System.out.println("letterSpacing is not as expected. Found: " + letterSpacing);
            }

            // Verify the text Transform
            if (textTransform.equals("lowercase")) {
                System.out.println("textTransform is as expected.");
            } else {
                System.out.println("textTransform is not as expected. Found: " + textTransform);
            }

            // Verify the text Decoration
            if (textDecoration.equals("underline")) {
                System.out.println("textDecoration is as expected.");
            } else {
                System.out.println("textDecoration is not as expected. Found: " + textDecoration);
            }

        } finally {
            // Close the browser
            driver.quit();
        }
    }
}

The output of the above program is

Explanation:

1. Set Up Chrome Options and WebDriver

ChromeOptions is created. A ChromeDriver object driver is created to control the Chrome browser. implicitlyWait is set to 5 seconds to wait for elements to be present before throwing an exception. The browser window is maximized for better visibility during the test.

ChromeOptions chromeOptions = new ChromeOptions();
WebDriver driver = new ChromeDriver(chromeOptions);
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(5));
driver.manage().window().maximize();

2. Navigate to the Webpage

The get() method of driver is used to navigate to the specified URL.

driver.get("https://www.selenium.dev/");

3. Find Element

An element is located using an XPath expression that targets an anchor tag within a specific container class. 

WebElement element = driver.findElement(By.xpath("//*[@class='selenium-button-container']/a"));

4. Retrieve and Print CSS Font Properties

The script fetches various font-related CSS properties using getCssValue().

  1. font-family – Specifies the typeface to be applied to the text. (e.g. Arial, Helvetica, sans-serif)
  2. font-size – Determines the size of the font displayed in the element. (e.g. 16px)
  3. font-weight – Defines the weight (or thickness) of the font.(e.g. 100, 200, 400, 700)
  4. font-style – Applies styles such as italics to the text. (e.g. normal, italic, oblique)
  5. font-variant – Adjusts the appearance of text for typographic effects(e.g. small-caps, normal)
  6. line-height – Controls the vertical space between lines of text. (e.g. 24px)
  7. letter-spacing – Adjusts the space between individual letters. (e.g. normal)
  8. text-transform – Modifies the capitalization of text. (e.g. uppercase, lowercase, capitalize)
  9. text-decoration – Applies decorative lines to text. (e.g. underline, strikethrough)
// Retrieve the font color
String fontFamily  = element.getCssValue("font-family");
System.out.println("fontFamily  : " + fontFamily );

// Retrieve the font size
String fontSize = element.getCssValue("font-size");
System.out.println("fontSize : " + fontSize);

// Retrieve the font weight
String fontWeight = element.getCssValue("font-weight");
System.out.println("fontWeight : " + fontWeight);

// Retrieve the font style
String fontStyle  = element.getCssValue("font-style");
System.out.println("fontStyle : " + fontStyle);

// Retrieve the font variation
String fontVariant  = element.getCssValue("font-variant");
System.out.println("fontVariant : " + fontVariant);

// Retrieve the line height
String lineHeight  = element.getCssValue("line-height");
System.out.println("lineHeight : " + lineHeight);

// Retrieve the letter spacing
String letterSpacing  = element.getCssValue("letter-spacing");
System.out.println("letterSpacing : " + letterSpacing);

// Retrieve the text transform
String textTransform  = element.getCssValue("text-transform");
System.out.println("textTransform : " + textTransform);

// Retrieve the text decoration
String textDecoration  = element.getCssValue("text-decoration");
System.out.println("textDecoration : " + textDecoration);

5.  Verification of CSS Properties

Each retrieved property is compared against expected values with individual checks. It prints corresponding messages based on whether the actual properties match the expected ones.

// Verify the font family
if (fontFamily.contains("Arial")) {
    System.out.println("fontFamily is as expected.");
} else {
    System.out.println("fontFamily is not as expected. Found: " + fontFamily);
}

// Verify the font size
if (fontSize.equals("16px")) {
    System.out.println("fontSize is as expected.");
} else {
    System.out.println("fontSize is not as expected. Found: " + fontSize);
}

// Verify the font weight
if (fontWeight.equals("500")) {
    System.out.println("fontWeight is as expected.");
} else {
    System.out.println("fontWeight is not as expected. Found: " + fontWeight);
}

// Verify the font style
if (fontStyle.equals("italic")) {
    System.out.println("fontStyle is as expected.");
} else {
    System.out.println("fontStyle is not as expected. Found: " + fontStyle);
}

// Verify the font variant
if (fontVariant.equals("small-caps")) {
    System.out.println("fontVariant is as expected.");
} else {
    System.out.println("fontVariant is not as expected. Found: " + fontVariant);
}

// Verify the line height
if (lineHeight.equals("24px")) {
    System.out.println("lineHeight is as expected.");
} else {
    System.out.println("lineHeight is not as expected. Found: " + lineHeight);
}

// Verify the letter Spacing
if (letterSpacing.equals("normal")) {
    System.out.println("letterSpacing is as expected.");
} else {
    System.out.println("letterSpacing is not as expected. Found: " + letterSpacing);
}

// Verify the text Transform
if (textTransform.equals("lowercase")) {
    System.out.println("textTransform is as expected.");
} else {
    System.out.println("textTransform is not as expected. Found: " + textTransform);
}

// Verify the text Decoration
if (textDecoration.equals("underline")) {
    System.out.println("textDecoration is as expected.");
} else {
    System.out.println("textDecoration is not as expected. Found: " + textDecoration);
}

6.  Clean Up

The finally block ensures that the browser is closed irrespective of whether the test passes or fails, using driver.quit() to close all browser windows and end the session.

// Close the browser
driver.quit();

Summary:
1. Initialize a WebDriver and direct it to interact with your target webpage.
2. Identify the desired web element using suitable locators.
3. Retrieve and print out the CSS values for font attributes using getCssValue.

That’s it! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

vibssingh

How to Retrieve Text and Background Colors with Selenium in Java

Last Updated On

HOME

In the web development, user experience plays a crucial part. Testers should ensure that style guides are followed across different pages. They should also be applied consistently to components. Verifying that the colors on a web page match design specifications helps maintain brand consistency. It ensures that the user interface looks as intended. There are chances that colors render differently across browsers and devices. Testing across different environments ensures that no matter where the website is accessed, the experience remains consistent.

To find the text color and background color of a web element in Selenium (Java), use the “getCssValue” method. Use “color” for the text color. Use “background-color” for the background color. You can convert the result to HEX using

org.openqa.selenium.support.Color.

Find Text color

In the below example, we want to find the text color of the highlighted text.

Below is the Selenium program that find the text color and match it with the expected color.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.support.Color;
import java.io.IOException;
import java.time.Duration;

public class Color_Example {

    public static void main(String args[]) throws IOException {

        String expectedColor = "#ffffff"; // White color in HEX

        ChromeOptions chromeOptions = new ChromeOptions();
        WebDriver driver = new ChromeDriver(chromeOptions);
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
        driver.manage().window().maximize();

        try {
            // Navigate to Url
            driver.get("https://www.selenium.dev/");

            WebElement element = driver.findElement(By.id("dev-partners"));

            // Retrieve the font color CSS property as RGBA
            String rgbaColor = element.getCssValue("color");
            System.out.println("rgbaColor : " + rgbaColor);

            // Convert the RGBA color to hex using the Color class
            String hexColor = Color.fromString(rgbaColor).asHex();
            System.out.println("hexColor : " + hexColor);

            // Convert the RGBA color to RGB using the Color class
            String rgbColor = Color.fromString(rgbaColor).asRgb();
            System.out.println("rgbColor : " + rgbColor);

            // Verify the color (example: verifying against expected #ffffff color)
            if (hexColor.equals(expectedColor)) {
                System.out.println("Hex color is as expected.");
            } else {
                System.out.println("Hex color is not as expected. Found: " + hexColor);
            }

        } finally {
            // Close the browser
            driver.quit();
        }
    }
}

The output of the above program is

Explanation:

1.Define Expected Color

Variable expectedColor is defined to hold the expected hexadecimal color value (`#ffffff`, representing white).

 String expectedColor = "#ffffff"; // White color in HEX

2. Set Up Chrome Options and WebDriver

ChromeOptions is created. A ChromeDriver object driver is created to control the Chrome browser. implicitlyWait is set to 10 seconds to wait for elements to be present before throwing an exception. The browser window is maximized for better visibility during the test.

ChromeOptions chromeOptions = new ChromeOptions();
WebDriver driver = new ChromeDriver(chromeOptions);
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
driver.manage().window().maximize();

3. Navigate to a Webpage

The get() method of driver is used to navigate to the specified URL.

driver.get("https://www.selenium.dev/");

4. Find Element and Retrieve CSS Property

The element is located by the specified id, “dev-partners”. The getCssValue method retrieves the color of the element in RGBA format.

WebElement element = driver.findElement(By.id("dev-partners"));

// Retrieve the font color CSS property as RGBA
String rgbaColor = element.getCssValue("color");
System.out.println("rgbaColor : " + rgbaColor);

5. Convert Color Formats

RGBA to Hex: `Color.fromString(rgbaColor).asHex()` converts the RGBA color to hexadecimal format.
RGBA to RGB: `Color.fromString(rgbaColor).asRgb()` converts the RGBA color to RGB format for additional representation.

 // Convert the RGBA color to hex using the Color class
String hexColor = Color.fromString(rgbaColor).asHex();
System.out.println("hexColor : " + hexColor);

// Convert the RGBA color to RGB using the Color class
String rgbColor = Color.fromString(rgbaColor).asRgb();
System.out.println("rgbColor : " + rgbColor);

6. Verify Color

The hexadecimal color of the element is compared with expectedColor. If they match, it prints a confirmation message. If they do not match, it prints a message indicating the color did not match the expected value.

 // Verify the color (example: verifying against expected #ffffff color)
 if (hexColor.equals(expectedColor)) {
          System.out.println("Hex color is as expected.");
} else {
          System.out.println("Hex color is not as expected. Found: " + hexColor);
}

7.  Clean Up

The finally block ensures that the browser is closed irrespective of whether the test passes or fails, using driver.quit() to close all browser windows and end the session.

// Close the browser
driver.quit();

Find Background color

If we want to find the background color, then use the below command:

getCssValue("background-color")

Below is an example to find the background color.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.support.Color;

import java.io.IOException;
import java.time.Duration;

public class BackgroundColor_Example {

    public static void main(String args[]) throws IOException {

        ChromeOptions chromeOptions = new ChromeOptions();
        WebDriver driver = new ChromeDriver(chromeOptions);
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
        driver.manage().window().maximize();

        try {
            // Navigate to Url
            driver.get("https://www.selenium.dev/");

            WebElement element = driver.findElement(By.id("dev-partners"));

            // Retrieve the background color CSS property
            String bgColorValue = element.getCssValue("background-color");
            System.out.println("color : " + bgColorValue);

            // Convert the background color to HEX format
            String hexColor = Color.fromString(bgColorValue).asHex();
            System.out.println("hexColor : " + hexColor);

            // Convert the background color to RGB format
            String rgbColor = Color.fromString(bgColorValue).asRgb();
            System.out.println("rgbColor : " + rgbColor);

            // Verify the color (example: verifying against expected #43b02a color)
            String expectedColor = "#43b02a"; // Green color in HEX
            if (hexColor.equals(expectedColor)) {
                System.out.println("Background color is as expected.");
            } else {
                System.out.println("Background color is not as expected. Found: " + hexColor);
            }
        } finally {
            // Close the browser
            driver.quit();
        }
    }
}

The output of the above program is

Summary:
1. Initialize a WebDriver and direct it to interact with your target webpage.
2. Identify the desired web element using suitable locators.
3. Retrieve and print out the CSS values for text and background colors using getCssValue.

More details about colors in Selenium can be found from this page – https://www.selenium.dev/documentation/webdriver/support_features/colors/

That’s it! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

vibssingh

Performance Testing – Multiple Choice Questions and Answers – MCQ1

Last Updated On

HOME

Welcome to the Performance Testing Quiz! This blog post features 25 multiple-choice questions that explore basic concepts of Performance Testing.

1. What is the primary goal of performance testing?

a) To identify issues in navigation flow
b) To ensure that an application performs well under expected load
c) To validate user interface design
d) To test security vulnerabilities

Answer 1

b) To ensure that an application performs well under expected load

Performance testing evaluates how an application behaves under expected or stress conditions to ensure it meets performance criteria.

2. Which tool is commonly used for Performance Testing?

a) Selenium
b) Apache JMeter
c) Visual Studio Code
d) Postman

Answer 2

b) Apache JMeter

Apache JMeter is a popular open-source tool for performing load and performance testing.

3. What is Throughput in Performance Testing?

Choose one option

a) Number of lines of code executed
b) Response time of the system
c) Number of transactions processed in a given timeframe
d) Number of errors per second

Answer 3

c) Number of transactions processed in a given timeframe

Throughput measures the number of transactions or requests processed in a given period.

4. What type of performance testing aims to find out how a system operates under heavy loads?

Choose one option

a) Load Testing
b) Stress Testing
c) Soak Testing
d) Security Testing

Answer 4

c) Stress Testing

Stress testing determines how a system performs under peak or extreme conditions, beyond normal operational capacity.

5. What is the main objective of load testing?

a) To break the system
b) To evaluate software scalability
c) To test the system’s reaction under varying traffic loads
d) To check system breaches

Answer 5

c) To test the system’s reaction under varying traffic loads

Load testing evaluates how a software application behaves when it is subjected to varying loads, usually simulating multiple users.

6. Performance Testing is a type of

Choose one option

a) Functional Testing
b) Non-Functional Testing
c) Security Testing
d) None of the above

Answer 6

b) Non-Functional Testing

7. Performance is concerned with achieving ………………… that meet the performance objectives for the project or product

Choose one option

a) Response times, Throughput, and Stress levels
b) Response times, Throughput, and Resource-utilization levels
c) Reason times, Throughput, and Resource-utilization levels
d) Response times, Click-through, and Resource-utilization levels

Answer 7

b) Response times, Throughput, and Resource-utilization levels

8. What is Spike Testing in Performance Testing?

Choose one option

a) Sudden large increases in system load
b) Gradually increasing system load
c) Reducing system performance
d) Testing system updates

Answer 8

a) Sudden large increases in system load

Spike testing measures how a system reacts to sudden and significant increases in load.

9. What is endurance testing?

a) Testing the system’s ability to handle high traffic during peak hours
b) Testing the system’s compatibility with different operating systems
c) Testing the system’s performance under normal conditions
d) Testing the system’s ability to handle an increasing load over an extended period

Answer 9

d) Testing the system’s ability to handle an increasing load over an extended period

Endurance testing involves testing a system over a prolonged period to determine its ability to perform under sustained load without performance degradation.

10. What is the purpose of a baseline test in performance testing?

a) To test under maximum load
b) To establish a benchmark for future tests
c) To identify security issues
d) To simulate network failures

Answer 10

b) To establish a benchmark for future tests

11. What is transaction response time?

Choose one option

a) Time to write transaction
b) Time to complete entire business transaction
c) Time to start transaction
d) Time to log transaction

Answer 11

b) Time to complete entire business transaction

12.  Which of the following is NOT a goal of performance testing?

Choose one option

a) Detecting memory leakage
b) Determining system sustainability
c) Evaluating error handling
d) Reducing hardware requirements

Answer 12

d) Reducing hardware requirements

13. What does KPI stand for in the context of performance testing?

Choose one option

a) Key Performance Indicator
b) Knowledge Program Initiative
c) Key Process Integration
d) Kernel Performance Index

Answer 13

a) Key Performance Indicator

14. When should performance testing be conducted?

Choose one option

a) Only after code changes
b) Regularly throughout the development lifecycle
c) After production deployment
d) Only during the initial phases of development

Answer 14

b) Regularly throughout the development lifecycle

15. Which of the following can impact performance testing results?

Choose one option

a) Developer skill levels
b) Network capacity and configuration
c) HR policies
d) Office location

Answer 15

b) Network capacity and configuration

16. What does ‘Think Time’ refer to in Load Testing?

Choose one option

a) The delay between user actions
b) Time required for machine learning predictions
c) AI decision-making time
d) Load balancing wait time

Answer 16

a) The delay between user actions

17.  What is the primary concern of resource utilization testing?

Choose one option

a) Adequate electricity supply
b) Efficient use of time during testing
c) The impact of an application on system resources
d) Cost of the software tools

Answer 17

c) The impact of an application on system resources

18. What does ‘concurrency’ refer to in performance testing?

a) Parallel software development processes
b) Simultaneous execution of multiple tasks
c) Single user testing multiple features
d) Continuous testing cycles

Answer 18

b) Simultaneous execution of multiple tasks

 19.  Which of the following is true about cloud performance testing?

a) It is more cost-effective than traditional methods
b) It cannot simulate real-world traffic
c) It requires dedicated on-premise hardware
d) It doesn’t support network latency measurements

Answer 19

a) It is more cost-effective than traditional methods

20. Which metric is used to measure the speed at which a system returns to a steady state after a particular load?

Choose one option

a) Response time
b) Throughput
c) Recovery time
d) Load time

Answer 20

c) Recovery time

21. Which factors impact system performance during Performance Testing?

Choose one option

a) Only font sizes and text placement
b) Browser color schemes and UI themes
c) User location and screen resolution
d) CPU, Memory, Database, Network latency

Answer 21

d) CPU, Memory, Database, Network latency

22. Which of the following is not a type of performance test?

Choose one option

a) Endurance testing
b) Load testing
c) Compatibility testing
d) Stress testing

Answer 22

c) Compatibility testing

23. Performance Testing environment should be scaled at least up to 50% of the production environment?

Choose one option

a) Yes
b) No

Answer 23

a) Yes

24. Which metric is NOT typically measured in performance testing?

a) Response time
b) Throughput
c) Code coverage
d) Resource utilization

Answer 24

c) Code coverage  

25. What is steady state in performance testing?

a) System startup phase
b) Period of constant load
c) System shutdown phase
d) Error state

Answer 25

b) Period of constant load

We would love to hear from you! Please leave your comments and share your scores in the section below

vibssingh

How to create XML Documents Using Java DOM Parser

Last Updated On

HOME

An XML file contains data between the tags. This makes it complex to read compared to other file formats like docx and txt. There are two types of parsers which parse an XML file:

  1. Event-Based (e.g. SAX, StAX)
  2. Object-Based (e.g. D.O.M)

In this article, we will discuss how to create a XML document using Java DOM parser. There is another tutorial to read XML – How to read XML using Java DOM Parser.

Java DOM parser API has methods, interfaces and classes to create XML documents. Using this API, we can create XML documents from the scratch through our Java applications. The createElement() method creates new elements and the appendChild() method appends the created elements to already existing elements.

Below is the sample XML which is created and saved in resources/Payloads as output.xml.

The complete program looks like as shown below:

import org.w3c.dom.Document;
import org.w3c.dom.Element;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.File;
import javax.xml.transform.OutputKeys;

public class CreateXMLDocument {

    public static void main(String[] args) {
        try {

            // Step 1: Create a DocumentBuilderFactory and DocumentBuilder
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();

            // Step 2: Create a new Document
            Document document = builder.newDocument();

            // Step 3: Create and append root element
            Element root = document.createElement("employees");
            document.appendChild(root);

            // Step 4: Create and append employee elements
            Element employee1 = document.createElement("employee");
            employee1.setAttribute("id", "1");
            Element name1 = document.createElement("Name");
            name1.appendChild(document.createTextNode("Jimmy Buffet"));
            Element id1 = document.createElement("Employee_Id");
            id1.appendChild(document.createTextNode(String.valueOf(10342256)));
            Element salary1 = document.createElement("Salary");
            salary1.appendChild(document.createTextNode(String.valueOf(5000.00)));
            employee1.appendChild(name1);
            employee1.appendChild(id1);
            employee1.appendChild(salary1);
            root.appendChild(employee1);

            Element employee2 = document.createElement("employee");
            employee2.setAttribute("id", "2");
            Element name2 = document.createElement("name");
            name2.appendChild(document.createTextNode("Jane Smith"));
            Element position2 = document.createElement("position");
            position2.appendChild(document.createTextNode("Project Manager"));
            employee2.appendChild(name2);
            employee2.appendChild(position2);
            root.appendChild(employee2);

            // Step 5: Write the content into an XML file
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();

            transformer.setOutputProperty(OutputKeys.INDENT, "yes"); // Pretty print the XML
            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");

            DOMSource domSource = new DOMSource(document);

            // Write XML to file
            StreamResult fileResult = new StreamResult(new File("src/test/resources/Payloads/output.xml"));
            transformer.transform(domSource, fileResult);

           // Print XML to console
            StreamResult consoleResult = new StreamResult(System.out);
            transformer.transform(domSource, consoleResult);

            System.out.println("XML file created successfully!");

        } catch (ParserConfigurationException | TransformerException e) {
            e.printStackTrace();
        }
    }
}

The output of the above program is

Explanation

1. Creating a DocumentBuilder Object

It has ‘newDocumentBuilder()’ method that creates an instance of the class ‘DocumentBuilder’. This DocumentBuilder class is used to get input in the form of streams, files, URLs and SAX InputSources.

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();

2. Create a new Document

Using DocumentBuilder object created in the above step, create a new document with newDocument() function.

 Document document = builder.newDocument();

3. Creating the root element

Every XML document should possess a single root element , which is also called a parent element. We can create the root element using createElement() method and append it to the document created in the previous step.

Element root = document.createElement("employees");
document.appendChild(root);

4. Appending elements to the root element

Inside the root element, we can create any number of child elements. We append them the same way we appended the root element to the document.

To write text content inside an element, we can use createTextNode() method.

We can also create attributes for elements using createAttribute() method.

Element employee1 = document.createElement("employee");
employee1.setAttribute("id", "1");
Element name1 = document.createElement("Name");
name1.appendChild(document.createTextNode("Jimmy Buffet"));
Element id1 = document.createElement("Employee_Id");
id1.appendChild(document.createTextNode(String.valueOf(10342256)));
Element salary1 = document.createElement("Salary");
salary1.appendChild(document.createTextNode(String.valueOf(5000.00)));
employee1.appendChild(name1);
employee1.appendChild(id1);
employee1.appendChild(salary1);
root.appendChild(employee1);

Element employee2 = document.createElement("employee");
employee2.setAttribute("id", "2");
Element name2 = document.createElement("name");
name2.appendChild(document.createTextNode("Jane Smith"));
Element position2 = document.createElement("position");
position2.appendChild(document.createTextNode("Project Manager"));
employee2.appendChild(name2);
employee2.appendChild(position2);
root.appendChild(employee2);

5. Writing the content into XML file

After building the elements inside the document with their corresponding attributes, we must write this content into an XML file. We do this by creating a Transformer object, which transforms our source document into StreamResult. It then stores the result in the specified file path with the given name.

TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();

transformer.setOutputProperty(OutputKeys.INDENT, "yes"); // Pretty print the XML
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");

DOMSource domSource = new DOMSource(document);

 // Write XML to file
 StreamResult fileResult = new StreamResult(new File("src/test/resources/Payloads/output.xml"));
transformer.transform(domSource, fileResult);

6. Printing the output on the console

We can test our XML file by printing it on the console. This is an optional step.

StreamResult consoleResult = new StreamResult(System.out);
transformer.transform(domSource, consoleResult);

Summary:

1. DocumentBuilderFactory and DocumentBuilder: These are used for creating new DOM `Document` instances.
2. Document Object: Represents the XML in memory, and methods like `createElement()` and `createTextNode()` are used to build the XML structure.
3. Transformer: Converts the DOM representation to a file.
4. StreamResult: Used to specify the output file where the XML content will be written.

We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!