Introduction:

In web application testing, dynamic web elements that change their attributes or locations during runtime can pose challenges. However, with the right techniques and strategies, we can effectively handle these dynamic elements using Selenium in Java. In this blog post, we will explore various techniques and provide code snippets to handle dynamic web elements successfully.

Understanding Dynamic Web Elements:

Dynamic web elements refer to elements on a webpage that change their attributes or locations dynamically. This can occur due to dynamic content loading, AJAX calls, page refreshes, or changes in the DOM structure. Examples of dynamic elements include dropdowns, menus, pop-ups, modals, or elements that load asynchronously.

Techniques for Handling Dynamic Web Elements:

1. Implicit and Explicit Waits:

Both implicit and explicit waits are essential for handling dynamic web elements. Implicit waits allow the driver to wait for a specified amount of time for an element to be present on the page. Explicit waits enable you to wait for specific conditions to be met before proceeding. Here's an example of using explicit wait with ExpectedConditions in Selenium:

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

WebDriverWait wait = new WebDriverWait(driver, 10);
WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(By.cssSelector("[data-testid='dynamic-element']")));

2. Dynamic XPath or CSS Selectors:

XPath and CSS selectors are powerful techniques for locating elements. When dealing with dynamic elements, you can utilize dynamic values within XPath or CSS selectors to locate the element. Here's an example using XPath with a dynamic attribute value:

WebElement element = driver.findElement(By.xpath("//input[contains(@class, 'dynamic-input-')]"));

3. Relational Locators:

Dynamic elements are often located relative to other stable elements on the page. By identifying the stable parent or sibling elements, you can navigate to the dynamic element using XPath or CSS selectors. Here's an example using XPath with a relational locator:

WebElement parentElement = driver.findElement(By.id("parent-element"));

WebElement dynamicElement = parentElement.findElement(By.xpath(".//span[contains(@class, 'dynamic-span')]"));

4. Refreshing the DOM:

In some cases, dynamic elements may not be immediately available in the DOM. You can try refreshing the DOM by reloading the page or waiting for a specific event to trigger the appearance of the dynamic element. Here's an example of refreshing the page to handle dynamic content:

driver.navigate().refresh();

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

5. JavaScript Execution:

JavaScript can be used to interact with dynamic elements directly. By executing JavaScript commands using Selenium, you can manipulate the DOM or trigger events on dynamic elements. Here's an example of executing JavaScript code to handle a dynamic element:

JavascriptExecutor js = (JavascriptExecutor) driver;

WebElement element = (WebElement) js.executeScript("return document.getElementById('dynamic-element')");

Conclusion:

Handling dynamic web elements is crucial for successful web application testing using Selenium in Java. By applying the techniques discussed above and utilizing the provided code snippets, you can effectively handle dynamic elements that change their attributes or locations during runtime. It is important to adapt these techniques to your specific application and regularly update your automation strategy as the dynamic elements evolve. With these approaches and a proactive approach, you can create robust and reliable automated tests, even in the presence of dynamic web elements.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public class UsingMaximizeFunction {

	public static void main(String[] args) {

		WebDriverManager.chromedriver().setup();
		WebDriver driver = new ChromeDriver();

		// Maximize current window
		driver.manage().window().maximize();

		// Navigate to a website
		driver.get("https://www.myautomationlab.com/");

		// Close the browser
		driver.quit();

	}

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public class UsingFullScreenFunction {

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

		WebDriverManager.chromedriver().setup();
		WebDriver driver = new ChromeDriver();

		// Navigate to a website
		driver.get("https://www.myautomationlab.com/");

		// Maximize current window using "fullscreen" function
		driver.manage().window().fullscreen();

		Thread.sleep(3000);

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

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public class UsingWindowSize {

	public static void main(String[] args) {

		WebDriverManager.chromedriver().setup();
		WebDriver driver = new ChromeDriver();

		// Maximize current window by setting windows size
		Dimension dim = new Dimension(1280, 860);
		driver.manage().window().setSize(dim);

		// Navigate to a website
		driver.get("https://www.myautomationlab.com/");

		// Close the browser
		driver.quit();

	}

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public class UsingChromeOptionsWindowSize {

	public static void main(String[] args) {

		// Maximize current window using ChromeOptions "window-size"
		ChromeOptions chromeOptions = new ChromeOptions();
		chromeOptions.addArguments("window-size=1280,860");

		WebDriverManager.chromedriver().setup();
		WebDriver driver = new ChromeDriver(chromeOptions);

		// Navigate to a website
		driver.get("https://www.myautomationlab.com/");

		// Close the browser
		driver.quit();

	}

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public class UsingChromeOptionsStartFullscreen {

	public static void main(String[] args) {

		// Maximize current window using ChromeOptions "--start-fullscreen"
		ChromeOptions chromeOptions = new ChromeOptions();
		chromeOptions.addArguments("--start-fullscreen");

		WebDriverManager.chromedriver().setup();
		WebDriver driver = new ChromeDriver(chromeOptions);

		// Navigate to a website
		driver.get("https://www.myautomationlab.com/");

		// Close the browser
		driver.quit();

	}

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

public class UsingChromeOptionsStartMaximized {

	public static void main(String[] args) {

		ChromeOptions chromeOptions = new ChromeOptions();

		if (System.getProperty("os.name").startsWith("Windows")) {

			// To maximize window in Windows system use "--start-maximized"
			chromeOptions.addArguments("--start-maximized");
		} else {

			// To maximize window in Mac & linux system use "--kiosk"
			chromeOptions.addArguments("--kiosk");
		}

		WebDriverManager.chromedriver().setup();
		WebDriver driver = new ChromeDriver(chromeOptions);

		// Navigate to a website
		driver.get("https://www.myautomationlab.com/");

		// Close the browser
		driver.quit();

	}

}

The Source Code for above topic is available on GitHub Repository, You can get it from this URL:- 

https://github.com/patilshubham033/InterviewQuestions/tree/master/src/test/java/com/interviewquestions/maximizewindow

Hello learners,  

In this post, we'll learn about some basic concepts related to Main method in Java. But before that lets understand what is main method, its importance, how it interacts with JVM etc. 

1. What is main method in Java?

Main method is the entry point for every Java program. When you execute certain class that time Java compiler first search for main method for that class, after finding the main method it starts it's execution. Below is the figure for illustrating meaning of every word in declaration of  main method.

In the above figure public is  a Access Modifier that means the main method is called by JVM from any class, package, subclass etc. static is a Keyword that means we don't need to create objects of main method it can be directly called with the help of class. Void is a return type that means main method does not return any value. main is a method name. And lastly main method can accept one argument of type String Array.

2. What happens to Java program if main method is not present.

It will give byte code verification error as "Main method not found in class".  Now, this will be a error and not exception since the program has not started its execution yet. Prior to JDK7 main method declaration was not mandatory but after JDK7 it is mandatory to define method for execution of program.

3. Can we overload main method in Java?

Yes, we can surely do this. We can declare multiple methods with the name as main but the parameters will be different. Let's say we have declare four different main method with different parameters as String array, Single String, Single Integer and with two Integer. And calling the other mains from first main method. Now, since the data type of parameters are different in every case so the main method execution is happening properly.

Code: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package javaProgramsforInterview;

public class JavaPrograms {
	public static void main(String[] args) {

		System.out.println("Main Method-1");
		main("my automation lab");
		main(50);
		main(20, 40);
	}

	public static void main(String args) {

		System.out.println("Main Method-2");
	}

	public static void main(int a) {

		System.out.println("Main Method-3");
	}

	public static void main(int a, int b) {

		System.out.println("Main Method-4");
	}
}

Output:

1
2
3
4

Main Method-1
Main Method-2
Main Method-3
Main Method-4

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

package javaProgramsforInterview;

public class ClassA {

	public static void main(String[] args) {

		System.out.println("This is Java Class A");
		ClassB.main(args);
	}

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

package javaProgramsforInterview;

public class ClassB {

	public static void main(String[] args) {

		System.out.println("This is Java Class B");

	}

}

1
2

This is Java Class A
This is Java Class B

Approch 1

First will convert String to Characters by using toCharArray function. After that will store that CharArray to Set it will automatically remove all duplicates. And then will use StringBuilder function to reconstruct that String.

Code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package javaProgramsforInterview;
 
import java.util.LinkedHashSet;
import java.util.Set;
 
public class RemovingDuplicates1 {
 
	public static void main(String[] args) {
		String string = "samplestringfortest";
 
		char[] chars = string.toCharArray();
		Set<Character> charSet = new LinkedHashSet<Character>();
		for (char c : chars) {
			charSet.add(c);
		}
 
		StringBuilder sb = new StringBuilder();
		for (Character character : charSet) {
			sb.append(character);
		}
		System.out.println(sb.toString());
	}
}

Output:

sampletringfo

Code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package javaProgramsforInterview;
 
public class RemovingDuplicates2 {. 
 
	public static void main(String[] args) {
		String string = "samplestringfortest";
		char[] chars = string.toCharArray();
		StringBuilder sb1 = new StringBuilder();
 
		for (int i = 0; i < chars.length; i++) {
			boolean flag = true;
			for (int j = 0; j < i; j++) {
				if (chars[j] == chars[i]) {
					flag = false;
					break;
				}
			}
			if (flag) {
				sb1.append(chars[i]);
			}
		}
		System.out.println(sb1.toString());
	}
}

Output:

sampletringfo