Testing Colleges: Java with Selenium

Showing posts with label Java with Selenium. Show all posts

Automation Frameworks

Frameworks in Test Automation:

Utilizing a framework facilitates the structured organization of code, providing clear guidelines and best practices to methodically achieve desired outcomes.

Types of Automation Frameworks:

Linear Automation Framework
Modular Driven Framework
Data-Driven Framework
Keyword-Driven Framework
Hybrid Testing Framework
Behavior-Driven Development (BDD) Framework

Let's discuss each of these in detail.

1. Linear Automation Framework

The Linear Automation Framework, often referred to as the Record & Playback approach, is characterized by its simplicity and ease of implementation. Unlike more complex frameworks, such as Data-Driven or Keyword-Driven frameworks, this approach involves the creation of test scripts within a single class or script file.

How Does It Work?

Testers record their interactions with the application under test using specialized tools. These interactions are then converted into script commands stored in a single script file. During playback, the recorded actions are executed sequentially, mimicking user interactions.

Advantages:

Quick Script Generation – Testers can create scripts quickly by recording their actions without extensive scripting knowledge.
Low Barrier to Entry – Beginners can start automating tests with minimal training.
Tool Familiarization – Helps testers become familiar with automation tools.

Disadvantages:

Limited Reusability – Scripts are linear and cannot be easily reused across multiple tests.
Hardcoded Test Data – Test data is embedded within scripts, making updates challenging.
Maintenance Challenges – As the test suite grows, maintaining scripts becomes cumbersome.

2. Modular Driven Framework

The Modular Driven Framework breaks down the application into smaller, independent parts (modules). Each module is tested separately using dedicated scripts, improving reusability and organization.

Advantages:

Enhanced Reusability – Test scripts can be reused across different scenarios.
Targeted Maintenance – Changes in an application require only specific modules to be updated.
Cost-Efficient Maintenance – Clearly separated modules simplify updates and maintenance.

Challenges:

Requires Technical Expertise – Knowledge of programming and testing concepts is needed.
Time-Consuming Setup – Compared to linear automation, this approach requires careful planning.
Hardcoded Test Data – Like the Linear Framework, test data may be embedded in scripts.

3. Data-Driven Testing Framework

This framework builds upon the Modular Driven Framework by allowing test data to be dynamically supplied from external sources, such as:

Excel files
CSV files
Databases
Text files

Instead of embedding data within scripts, test scripts retrieve data from these external files during execution.

When to Use:

When testing the same functionality multiple times with different sets of input data.

Advantages:

Separation of Test Data and Test Scripts – Updating test data does not affect scripts.
Improved Test Coverage – A single test script can be reused with multiple datasets.
Flexibility & Maintainability – Test data can be updated independently.

Disadvantages:

Increased Complexity – Setting up test data sources requires extra effort.
Requires Programming Skills – Testers must understand scripting and data handling.
Time-Consuming Setup – Requires significant planning and preparation.

4. Keyword-Driven Testing Framework

This framework uses keywords stored in an external data file to drive test execution. These keywords represent specific actions to be performed, making the framework structured and reusable.

Advantages:

No Programming Skills Required – Testers can create tests using predefined keywords.
Simplified Script Creation – Once set up, writing new tests is easier.
High Code Reusability – Keywords can be used across multiple scripts.
Tool Independence – Works with various test automation tools.
Application Independence – Test cases can be designed even before development is complete.

Disadvantages:

High Initial Setup Effort – Requires significant time and automation expertise.
Higher Initial Investment – More suited for large applications.
Complex Maintenance – Managing keywords can become challenging as the framework grows.
Longer Learning Curve – Testers must learn how to use and manage keywords effectively.

5. Hybrid Testing Framework

Hybrid Testing Framework combines features of multiple frameworks, such as Keyword-Driven and Data-Driven approaches, to enhance flexibility and scalability.

Key Components:

Driver Script – Controls test execution flow.
Configuration File – Stores settings and environment variables.
Run Manager – Determines which tests to run.
Test Cases & Scripts – Defines automation scenarios.
Object Repository – Stores UI elements for easy identification.
Test Data – Externalized data sources (Excel, CSV, Databases).
Results & Logs – Stores test execution reports.
Function Library – Collection of reusable functions.
Scheduler – Automates test execution at predefined intervals.

Advantages:

Best of Multiple Frameworks – Combines strengths of Keyword-Driven and Data-Driven frameworks.
High Flexibility & Reusability – Adaptable to different testing needs.
Faster Execution – Optimized test execution time.
Scalability – Supports multi-platform and cross-browser testing.

Disadvantages:

Requires Strong Technical Expertise – Developers must understand multiple frameworks.
Higher Initial Effort – Requires significant setup time and investment.

6. Behavior-Driven Development (BDD) Framework

BDD enables teams to create test cases in plain, human-readable language (e.g., English). This improves collaboration between testers, developers, and business analysts.

Given-When-Then Approach:

BDD follows a structured format:

Given – Defines initial conditions.
When – Describes user actions.
Then – Specifies expected outcomes.

Example Feature File (Cucumber - Gherkin Format): gherkin

Feature: BDD implementation using Cucumber

Scenario: Login to Gmail using Cucumber plugin

Given User is navigating to the Gmail login page

When User enters username as "Username" and password as "Password"

Then User is successfully navigated to the Gmail mailbox

Advantages:

Improved Test Coverage – Ensures all user stories are tested.
Readable Scenarios – Uses natural language for easy understanding.
Test Automation Friendly – Works with Cucumber, SpecFlow, and JBehave.
Code Reusability – Steps can be reused across test cases.
CI/CD Integration – Easily fits into Continuous Integration pipelines.

Disadvantages:

Requires Collaboration – Close coordination between developers and testers is needed.
Risk of Misuse – If not used correctly, BDD can turn into an inefficient testing approach.

Conclusion:

Selecting the right automation framework depends on project requirements, team expertise, and long-term maintainability. Linear and Modular frameworks are best for small projects, while Data-Driven, Keyword-Driven, Hybrid, and BDD frameworks are ideal for large-scale automation efforts.

File Upload Using Selenium WebDriver

Exploring Different Approaches for File Upload with Selenium WebDriver:

........Incomplete.......

File uploads are a common functionality on web applications, and automating this process is crucial for efficient testing with Selenium WebDriver. In this blog post, we will explore three different methods to upload files using Selenium WebDriver: 'SendKeys', the 'Robot' class, and 'AutoIT'.

Using SendKeys:

The most straightforward approach for uploading a file in Selenium WebDriver is to use the 'SendKeys' method. This method is applicable only if the HTML input element has the attribute type="file". This attribute is specific to file upload functionality, and using Selenium's sendKeys method allows for the automatic selection of the desired file for this type of input field.

Syntax:

WebElement fileInput = driver.findElement(By.id("idvlaue"));
fileInput.sendKeys("path/to/your/file.txt");

Pros:

Directly interacts with the file input element.
Simple and concise code for file uploads.
No external dependencies are required.

Cons:

Limited to scenarios where the file input element is present.

Using Robot Class:

The Robot class in Java can be used to simulate keyboard and mouse actions. In the context of the uploads, the Robot class can be used to navigate the file selection dialogue.

Example Program:

import java.awt.AWTException;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.datatransfer.StringSelection;
import java.awt.event.KeyEvent;
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;
public class Dummy2 {
public static void main(String[] args) throws AWTException {
ChromeOptions co = new ChromeOptions();
co.addArguments("-remote-allow-origins");
WebDriver driver = new ChromeDriver();
driver.get("https://testingcolleges.blogspot.com/2024/01/file-upload-demo-page.html");
WebElement fileUploadBtn = driver.findElement(By.className("file-label-2"));
fileUploadBtn.click();
Robot rbt = new Robot();
rbt.delay(2000); // just like thread.sleep
//these below 2 lines used to copy the path
StringSelection ss = new StringSelection("C:\\Users\\Dollar\\Desktop\\Dummy.txt");
// copy the above path in clipboard
Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss, null);
//Toolkit.getDefaultToolkit().getSystemClipboard().setContents("path", null);
//perform Ctrl+V operation to pass the copied path
rbt.keyPress(KeyEvent.VK_CONTROL);
rbt.keyPress(KeyEvent.VK_V);
rbt.keyRelease(KeyEvent.VK_CONTROL);
rbt.keyRelease(KeyEvent.VK_V);
//Enter press
rbt.keyPress(KeyEvent.VK_ENTER);
rbt.keyRelease(KeyEvent.VK_ENTER);
}
}

Pros:

Works across different browsers.
Can handle scenarios with hidden file input fields.

Cons:

Requires handling keyboard events, which may be error-prone.
Platform-dependent and may need adjustments for different operating systems.

Using AutoIT:

AutoIT is a scripting language designed for automating the Windows GUI and general scripting tasks. It can be integrated with Selenium WebDriver to handle file Uploads.

Pros:

Powerful for handling complex file upload scenarios.
Works seamlessly across different browsers and operating systems.

Cons:

Requires installing AutoIT and writing an external script.
Add an external dependency to your automation project.

Conclusion:

Each method for file upload with Selenium WebDriver has its advantages and limitations. The choice of method depends on the specific requirements of your application and the level of control and compatibility needed. While SendKeys is suitable for simple scenarios, the Robot class and AutoIT offer more flexibility and control, making them valuable tools for handling complex file upload functionalities.

Browser Window Sizes and Positions

maximize(): The maximize() method is used to maximize the browser window. This is often done to ensure that the web page is displayed in its full size on the screen. Here's an example of how you can use the 'maximize' method in selenium with Java:

public class Maximize {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
}
}

How to Minimize the Browser Window in Selenium?

Selenium's Java has no built-in method to minimize the browser window. However, Selenium's Python does have a minimize function.

getSize(): The getSize() method is used to get the height and width of a WebElement/BrowserWindow. The getSize() method returns an object of type 'Dimension', and you can use its 'getHeight' and 'getWidth' methods to obtain the height and width, respectively.

Example 1: To get the height and width of a web element.

import org.openqa.selenium.By;
import org.openqa.selenium.Dimension;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
public class GetElementSize {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
WebElement element = driver.findElement(By.id("value"));
Dimension size = element.getSize();
System.out.println("Height: " + size.getHeight());
System.out.println("Width: " + size.getWidth());
}
}

Example 2: To get the height and width of a Browser Window.

import org.openqa.selenium.Dimension;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class GetBrowserWindowSize {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
Dimension windowSize = driver.manage().window().getSize();
System.out.println("Window Height: " + windowSize.getHeight());
System.out.println("Window Width: " + windowSize.getWidth());
}
}

Note: In the above example instead of creating the Dimension class object we can also directly give the methods:

driver.manage().window().getSize().getHeight();

driver.manage().window().getSize().getWidth();

Resize the Browser window:

To resize the Browser window. 'manage().window().setSize()' is a predefined method of the Selenium 'WebDriver' class.

Syntax 1:

Dimension newSize = new Dimension(800, 600); //(width, height)
driver.manage().window().setSize(newSize);

Syntax 2:

driver.manage().window.setSize(new Dimension(800, 600));

Example:

import org.openqa.selenium.Dimension;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class ResizeWindow {
public static void main(String[] args) {
System.setProperty("webdriver.chrome.driver", "path/chromedriver.exe");
WebDriver driver = new ChromeDriver();
driver.get("http://example.com/");
Dimension newSize = new Dimension(800, 600);
driver.manage().window().setSize(newSize);
}
}

Note: In Eclipse, you may have recommend two import statements for the 'Dimension' class: 'import java.awt.Dimension;' and 'import org.openqa.selenium.Dimension;'. You should only select 'import org.openqa.selenium.Dimension;'.

getPosition():

getPosition() method gets the position of the current window, relative to the upper left corner of the screen. The method takes no arguments and returns a Point object, which contains the X and Y coordinates of the window.

Syntax:(With Point object)

// Get the position of the current window
Point p = driver.manage().window().getPosition();
// Print the X and Y coordinates of the window
System.out.println("X Coordinate: " + p.getX());
System.out.println("Y Coordinate: " + p.getY());

Syntax: (We can also print the X and Y Coordinates without creating a Point object)

System.out.println("X Coordinate: " + driver.manage().window().getPosition().getX());
System.out.println("Y Coordinate: " + driver.manage().window().getPosition().getY());

Example:

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class WindowPosition {
public static void main(String[] args) {
System.setProperty("webdriver.chrome.driver", "path/chromedriver.exe");
WebDriver driver = new ChromeDriver();
driver.get("http://testingcolleges.blogspot.com/");
System.out.println("X Coordinate: " + driver.manage().window().getPosition().getX());
System.out.println("Y Coordinate: " + driver.manage().window().getPosition().getY());
}
}

Output:

X Coordinate: 10

Y Coordinate: 10

setPosition():

The setPosition() method in Selenium Webdriver sets the position of the current window relative to the top left corner of the screen. The Point class instance specifies the target position of the window.

Syntax 1:

Point p = new Point(250, 250);
driver.manage().window().setPosition(p);

Syntax 2:

driver.manage().window().setPosition(new Point(250, 250));

Example:

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.Point;
public class Position {
public static void main(String[] args) {
System.setProperty("webdriver.chrome.driver", "path/chromedriver.exe");
WebDriver driver = new ChromeDriver();
driver.get("http://testingcolleges.blogspot.com/");
Point p = new Point(250,250);
driver.manage().window().setPosition(p);
}
}

****

C# Automation, Java with Selenium, Python with Selenium

Locators

How to Inspect a web element:

On every web page, you will find various web elements, and each of these elements is made up of tags, attributes, and values.

Example: <tag attribute='values'>

Right-click any part of the page and Choose Inspect or Shortcut key F12.
Select the Element tab (by default it is selected).
Note: This inspect tab is called DOM(Document Object Model)

What is findElement?

It is the method to locate elements on the webpage.

What is By?

By is the mechanism used to locate elements within the document with the help of locator value.

What is a Locator?

It is an address that identifies web elements within documents with the help of locator value.

Locators: There are eight types of locators.

id
name
XPath
CSS Selector
Class Name
Tag Name
Link Text
Partial Link Text

1. id Locator:

If an element in your web page has an 'id' attribute, it can be identified using the value of that attribute.

Syntax (Java): driver.findElement(By.id("id_value"))

Syntax (C#): driver.FindElement(By.Id("id_value"))

Syntax (Python): driver.find_element(By.ID, "id_value")

2. name Locator:

If an element in your web page has a 'name' attribute, it can be identified using the value of that attribute.

Syntax (Java): driver.findElement(By.name("name_value"))

Syntax (C#): driver.FindElement(By.Name("name_value"))

Syntax (Python): driver.find_element(By.NAME, "name_value")

3. XPath Locator:

XPath is an XML path used for navigation through the HTML structure of the page.

There are two types of XPath

1. Absolute XPath

2. Relative XPath

To learn more about XPath Click Here.

Syntax (Java): driver.findElement(By.xpath("//xpath"))

Syntax (C#): driver.FindElement(By.XPath("//xpath"))

Syntax (Python): driver.find_element(By.XPATH, "//xpath")

Note: we can copy XPath directly from the DOM, Right-Click on the particular element field(on - DOM) then Select copy in and click on Copy XPath.

4. CSS Selector Locator:

CSS is used to create style rules for web pages and can be used to identify any web element.

To learn how to write CSS Selector Click Here.

Syntax (Java): driver.findElement(By.cssSelector("value"))

Syntax (C#): driver.FindElement(By.CssSelector("value"))

Syntax (Python): driver.find_element(By.CSS_SELECTOR, "value")

5. Class Name Locator:

If an element in your web page has a 'class' attribute, it can be identified using the value of that attribute.

Syntax (Java): driver.findElement(By.className("class_value"))

Syntax (C#): driver.FindElement(By.ClassName("class_value"))

Syntax (Python): driver.find_element(By.CLASS_NAME, "class_value")

6. Tag Name Locator:

This Locator is mainly used to get the list of web elements with the particular tag name. We will use this locator very rarely, because here we will assign the values based on the tag, not an attribute.

Syntax (Java): driver.findElements(By.tagName("a"))

Syntax (C#): driver.FindElements(By.TagName("a"))

Syntax (Python): driver.find_elements(By.TAG_NAME, "a")

7. Link Text Locator:

Text (Visible Text) used in Hyperlinks can also locate elements.

Syntax (Java): driver.findElement(By.linkText("text"))

Syntax (C#): driver.FindElement(By.LinkText("text"))

Syntax (Python): driver.find_element(By.LINK_TEXT, "text")

8. Partial Link Locator:

A part of the text(Visible Text) in the Hyperlink can also identify an element.

Syntax (Java): driver.findElement(By.partialLinkText("text"))

Syntax (C#): driver.FindElement(By.PartialLinkText("text"))

Syntax (Python): driver.find_element(By.PARTIAL_LINK_TEXT, "text")

Java with Selenium

Waits/Synchronization using Selenium with Java

Introduction:

One of the biggest challenges in Selenium automation is dealing with dynamic web elements. If elements take time to load, interaction with them too soon can result in errors like NoSuchElementException.

To handle this, Selenium provides different types of waits: Implicit Wait, Explicit Wait, and Fluent Wait. These waits help synchronize test execution with the web page's behaviour, making tests more stable and reliable.

Understanding Selenium Waits with a Real-Life Analogy

Imagine you're at a traffic signal:

🚦Implict Wait - You decide to wait for a fixed time before crossing, regardless of whether the signal changes.

🚦Explicit Wait - You wait until the light turns green before crossing.

🚦Fluent Wait - You keep checking the light every few seconds, and as soon as it turns green, you cross.

Just like in real life, choosing the right waiting strategy in Selenium depends on the situation!

1. Implicit Wait

Implicit Wait sets a default waiting time for all elements before throwing an exception. It applies globally to every element in the scripts.

✅ When to Use:

When elements load in a predictable time frame.
When you want a simple, global wait mechanism.

🚨Limitations:

Can cause unnecessary delays if elements appear earlier.
Doesn't handle dynamic elements effectively.

Implementation in Selenium

Before Selenium 4:

Syntax:

driver.manage().timeouts().implicitlyWait(TimeOut, TimeUnit.SECONDS);

Example:

driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);

After Selenium 4:

Syntax/Example:

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

2. Explicit Wait

Explicit Wait waits for a specific condition to be met before proceeding with execution. Unlike implicit Wait, it applies only to a particular element.

✅ When to Use:

When elements load dynamically at different times.
When waiting for a specific condition (e.g., visibility clickability, presence).

🚨 Limitations:

Requires additional code to define wait conditions.

Common Wait Conditions in Explicit Wait

Selenium provides various built-in wait conditions via ExpectedConditions Class:

Condition	Description	Example
visibilityOfElementLocated	Waits until the element is visible	wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("username")));
elementToBeClickable	Waits until the element is clickable	wait.until(ExpectedConditions.elementToBeClickable(By.id("submit")));
presenceOfElementLocated	Waits until the element is present in the DOM	wait.until(ExpectedConditions.presenceOfElementLocated(By.id("login")));
textToBePresentInElement	Waits until a specific text appears in an element	wait.until(ExpectedConditions.textToBePresentInElement(By.id("status"), "Success"));
alertIsPresent	Waits for an alert to appear	wait.until(ExpectedConditions.alertIsPresent());

Implementation in Selenium

Before Selenium 4:

Syntax:

WebDriverWait wait = new WebDriverWait(driver, 10);

wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("//*[@id="123"]")));

After Selenium 4:

Syntax:

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));

wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("//*[@id="123"]")));

Example:

wait.until(ExpectedConditons.elementToBeClickable(By.id("submitButton")));

3. Fluent Wait

Fluent Wait gives more control over waiting. It allows setting:

✔ A maximum timeout (how long to wait)

✔ A polling frequency (how often Selenium checks for the element)

✔ Exception handling (ignoring specific exceptions)

✅ When to Use:

When elements load at unpredictable intervals.
When elements appear after AJAX calls or animations.

🚨 Limitations:

Requires more setup compared to other waits.

Key Features of Fluent Wait

Timeout: Defines the maximum wait time before throwing an exception.
Polling Frequency: Sets how often Selenium checks for the element.
Ignoring Exceptions: Allows ignoring specific exceptions (e.g., NoSuchElementException) while waiting.

Implementation in Selenium

Before Selenium 4:

Syntax:

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

.withTimeout(40, TimeUnit.SECONDS)

.pollingEvery(5, TimeUnit.SECONDS)

.ignoring(NoSuchElementException.class);

After Selenium 4:

Syntax:

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

.withTimeout(Duration.ofSeconds(40))

.pollingEvery(Duration.ofSeconds(5))

.ignoring(NoSuchElementException.class);

Example:

WebElement element = wait.until(driver -> driver.findElement(By.id("dynamicElement")));

Comparison Table: Implicit vs. Explicit vs. Fluent Wait

Wait Type	Scope	Best Use Case	Polling?	Exception Handling?	Custom Conditions?
Implicit Wait	Global	Static waits for all elements	No	No	No
Explicit Wait	Specific element	When waiting for specific conditions	No	No	Yes
Fluent Wait	Specific element	Handling dynamic/unpredictable elements	Yes	Yes	Yes

Best Practices for Using Selenium Waits

✔ Use Explicit wait instead of Implicit Wait when dealing with dynamic elements.

✔ Avoid mixing Implict and Explicit Waits -- It can lead to unpredictable behavior.

✔ use Fluent Wait when element appear at varying intervals.

✔ Keep wait times as short as possible to avoid increasing test execution time.

Conclusion

Understanding how to use waits effectively in Selenium can significantly improve test stability and reliability. Try experimenting with different wait type in your test automation projects to see how they impact execution time.

- Next Page: Take Screen Shot

Java with Selenium, JavaScript Executor

Using JavaScript Executor in Selenium with Java - part 4

To Clear the History Of the Browser:
Syntax: JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("history.clear()");

- Next Page: JavaScript FindElements

Java with Selenium, JavaScript Executor

Using JavaScript Executor in Selenium with Java - part 3

1. Web Page Scroll to a particular element:

Syntax: JavascriptExecutor js = (JavascriptExecutor) driver;

WebElement ele = driver.findElement(By.id("123"));

js.executeScript("arguments[0].scrollIntoView(true);", ele);

Example:

class JavaScript

{

public static void main(String[] args)

{

WebDriver driver = new ChromeDriver();

JavascriptExecutor js = (JavascriptExecutor) driver;

driver.get("https://testingcolleges.blogspot.com/p/testingform.html");

WebElement src = driver.findElement(By.linkText("Blogger"));

js.executeScript("arguments[0].scrollIntoView(true);", src);

}

2. Scroll to the Top:

Syntax: JavascriptExecutor js = (JavascriptExecutor) driver;

js.executeScript("window.scrollTo(document..body.scrollHeight , 0);");

Example:

class JavaScript

{

public static void main(String[] args)

{

System.setProperty("webdriver.chrome.driver" , "path");

WebDriver driver = new ChromeDriver();

JavascriptExecutor js = (JavascriptExecutor) driver;

driver.get("https://testingcolleges.blogspot.com/p/testingform.html");

js.executeScript("window.scrollTo(document.body.scrollHeight , 0);");

}

3. Scroll to the Down:

Syntax: JavascriptExecutor js = (JavascriptExecutor) driver;

js.executeScript("window.scrollTo(0 , document..body.scrollHeight );");

Example:

class JavaScript

{

public static void main(String[] args)

{

System.setProperty("webdriver.chrome.driver" , "path");

WebDriver driver = new ChromeDriver();

JavascriptExecutor js = (JavascriptExecutor) driver;

driver.get("https://testingcolleges.blogspot.com/p/testingform.html");

js.executeScript("window.scrollTo(0 , document.body.scrollHeight);");

}

- Next Page: JavaScript Part 4

Popular Posts