Browser Window Management is an important Selenium WebDriver concept used to control the size, position, and display state of the browser during automated testing. Selenium provides dedicated WebDriver commands for maximizing, minimizing, resizing, repositioning, and opening the browser in fullscreen mode.
Browser window management is especially useful when testing responsive web applications because screen resolution can affect how web pages and UI elements are rendered. Selenium provides APIs for getting and setting browser window dimensions and position, as well as maximizing, minimizing, and entering fullscreen mode.
Browser Window Management means controlling the browser window programmatically through Selenium WebDriver instead of manually changing the browser's size or position.
Using Selenium, we can control:
Different browser sizes can produce different layouts on a web application. A responsive website may display a desktop navigation menu at a large resolution and a mobile or compact navigation menu at a smaller resolution.
Browser Window Management helps testers create controlled and repeatable browser conditions.
In Selenium Java, browser window operations are accessed through:
driver.manage().window()The commonly used methods are:
| Method | Purpose |
|---|---|
maximize() |
Maximizes the browser window. |
minimize() |
Minimizes the current browser window. |
fullscreen() |
Displays the browser in fullscreen mode. |
getSize() |
Gets the current browser window dimensions. |
setSize() |
Sets the browser window dimensions. |
getPosition() |
Gets the current browser window position. |
setPosition() |
Moves the browser window to a specified position. |
The maximize() method enlarges the current browser window. On most operating systems, the window fills the available screen area without covering the operating system's own menus and toolbars.
driver.manage().window().maximize();
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class MaximizeBrowser {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://www.google.com");
driver.quit();
}
}
Maximizing the browser is common in desktop-oriented Selenium automation because it provides a larger working area for the application.
Selenium 4 introduced support for minimizing the current browsing window through the minimize() method. The exact behavior can depend on the operating system's window manager.
driver.manage().window().minimize();
WebDriver driver = new ChromeDriver();
driver.get("https://www.google.com");
driver.manage().window().minimize();
Minimizing the browser is less common in normal UI automation because the browser normally needs to remain available for interaction.
The fullscreen() method places the browser into fullscreen mode. Selenium documentation describes this as filling the entire screen, similar to pressing F11 in most browsers.
driver.manage().window().fullscreen();
WebDriver driver = new ChromeDriver();
driver.get("https://www.google.com");
driver.manage().window().fullscreen();
| maximize() | fullscreen() |
|---|---|
| Maximizes the browser window. | Fills the entire screen. |
| Normally keeps browser and operating-system UI available. | Behaves similarly to fullscreen/F11 mode. |
| Commonly used for normal Selenium automation. | Useful when fullscreen behavior needs to be tested. |
| Uses the operating system's maximize behavior. | Uses the browser's fullscreen behavior. |
The getSize() method retrieves the current browser window dimensions.
Dimension size = driver.manage().window().getSize();
System.out.println("Width: " + size.getWidth());
System.out.println("Height: " + size.getHeight());
The Selenium Java API represents the window dimensions using the Dimension class. Selenium's documentation demonstrates retrieving width and height individually or storing the complete dimension object.
The Selenium Dimension class represents the width and height of a browser window.
Dimension size = driver.manage().window().getSize();
int width = size.getWidth();
int height = size.getHeight();
System.out.println("Browser Width: " + width);
System.out.println("Browser Height: " + height);
The setSize() method allows you to specify the width and height of the browser window.
driver.manage().window().setSize(
new Dimension(1024, 768)
);
Selenium documents setSize() as the operation for restoring the window and setting its size.
import org.openqa.selenium.Dimension;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class BrowserSizeExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().window().setSize(
new Dimension(1024, 768)
);
driver.get("https://www.google.com");
driver.quit();
}
}
One of the most useful applications of setSize() is testing how a website behaves at different browser dimensions.
driver.manage().window().setSize(
new Dimension(1920, 1080)
);
driver.manage().window().setSize(
new Dimension(1366, 768)
);
driver.manage().window().setSize(
new Dimension(1024, 768)
);
Browser window size and webpage viewport size are related but are not necessarily identical.
The getPosition() method retrieves the current position of the browser window.
Point position = driver.manage().window().getPosition();
int x = position.getX();
int y = position.getY();
System.out.println("X Position: " + x);
System.out.println("Y Position: " + y);
Selenium describes the window position as the coordinates of the top-left point of the browser window.
The Selenium Point class represents the X and Y coordinates of the browser window.
Point position = driver.manage().window().getPosition();
System.out.println("X: " + position.getX());
System.out.println("Y: " + position.getY());
The setPosition() method moves the browser window to a specified position on the screen.
driver.manage().window().setPosition(
new Point(0, 0)
);
Selenium provides this operation for moving the window to a chosen position.
import org.openqa.selenium.Point;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class BrowserPositionExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().window().setPosition(
new Point(100, 100)
);
driver.get("https://www.google.com");
driver.quit();
}
}
The browser position can be understood using two coordinates:
Screen
+------------------------------------------------+
| |
| X = 100 |
| ↓ |
| +---------------------------+ |
| | | |
| | Browser Window | |
| | | |
| +---------------------------+ |
| |
+------------------------------------------------+
Y = 100
For example, the browser can be moved to X = 200 and Y = 150.
driver.manage().window().setPosition(
new Point(200, 150)
);
You can retrieve the browser's dimensions and coordinates together.
Dimension size = driver.manage().window().getSize();
Point position = driver.manage().window().getPosition();
System.out.println("Width: " + size.getWidth());
System.out.println("Height: " + size.getHeight());
System.out.println("X: " + position.getX());
System.out.println("Y: " + position.getY());
import org.openqa.selenium.Dimension;
import org.openqa.selenium.Point;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class WindowManagement {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
try {
driver.get("https://www.google.com");
driver.manage().window().maximize();
Dimension size =
driver.manage().window().getSize();
System.out.println(
"Width: " + size.getWidth()
);
System.out.println(
"Height: " + size.getHeight()
);
Point position =
driver.manage().window().getPosition();
System.out.println(
"X: " + position.getX()
);
System.out.println(
"Y: " + position.getY()
);
driver.manage().window().setSize(
new Dimension(1024, 768)
);
driver.manage().window().setPosition(
new Point(100, 100)
);
} finally {
driver.quit();
}
}
}
Start Test
↓
Create WebDriver
↓
Launch Browser
↓
Open Application
↓
Manage Browser Window
↓
+-----------------------------+
| Maximize |
| Minimize |
| Fullscreen |
| Set Size |
| Get Size |
| Set Position |
| Get Position |
+-----------------------------+
↓
Perform Test Actions
↓
Validate Results
↓
Close Browser
A common Selenium automation pattern is to configure the browser window before interacting with application elements.
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
This gives the test a predictable initial browser state.
Responsive websites change their layout according to the available screen dimensions. Browser window management can therefore be used to test different responsive states.
driver.manage().window().setSize(
new Dimension(1366, 768)
);
driver.get("https://example.com");
A second test can use a smaller dimension:
driver.manage().window().setSize(
new Dimension(768, 1024)
);
driver.get("https://example.com");
A large browser size can be used to test desktop-oriented layouts.
driver.manage().window().setSize(
new Dimension(1920, 1080)
);
driver.get("https://example.com");
Possible elements to validate include:
A smaller browser dimension can help identify responsive layout problems.
driver.manage().window().setSize(
new Dimension(768, 1024)
);
driver.get("https://example.com");
Window management can be combined with a login automation workflow.
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com/login");
driver.findElement(By.id("username"))
.sendKeys("testuser");
driver.findElement(By.id("password"))
.sendKeys("password");
driver.findElement(By.id("login"))
.click();
Browser dimensions can affect screenshots. Setting a fixed size before taking a screenshot can make screenshots more consistent.
driver.manage().window().setSize(
new Dimension(1366, 768)
);
driver.get("https://example.com");
File screenshot =
((TakesScreenshot) driver)
.getScreenshotAs(OutputType.FILE);
Visual testing often requires consistent rendering conditions. If the same test is executed at different browser dimensions, responsive layouts may produce different visual results.
For this reason, a framework may standardize browser dimensions before visual validation.
In headless execution there may not be a visible browser window, but browser dimensions can still affect page rendering and responsive behavior.
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless=new");
options.addArguments("--window-size=1366,768");
WebDriver driver = new ChromeDriver(options);
driver.get("https://example.com");
Some browser startup configuration can be supplied through ChromeOptions.
ChromeOptions options = new ChromeOptions();
options.addArguments("--start-maximized");
WebDriver driver = new ChromeDriver(options);
Window management can also be performed after the driver is created:
driver.manage().window().maximize();
WebDriver driver = new FirefoxDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
WebDriver driver = new EdgeDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
The same WebDriver window-management concepts can be used with different supported browsers.
| Browser | Example Driver | Window Management |
|---|---|---|
| Chrome | ChromeDriver |
driver.manage().window().maximize(); |
| Firefox | FirefoxDriver |
driver.manage().window().maximize(); |
| Edge | EdgeDriver |
driver.manage().window().maximize(); |
Browser window management should not be confused with handling multiple browser windows or tabs.
Window management controls properties such as size and position. Multiple-window handling determines which browser window or tab Selenium is currently controlling.
WebDriver identifies each browser window or tab using a unique window handle. Selenium does not make a functional distinction between a window and a tab for this purpose.
String currentWindow =
driver.getWindowHandle();
System.out.println(
"Current Window: " + currentWindow
);
Set windowHandles =
driver.getWindowHandles();
System.out.println(
"Total Windows: " + windowHandles.size()
);
When multiple windows or tabs are available, Selenium can switch between them using their window handles.
for (String handle : driver.getWindowHandles()) {
driver.switchTo().window(handle);
}
Selenium's official documentation recommends retrieving window handles and switching to the desired browsing context before interacting with it.
Selenium 4 provides switchTo().newWindow() for creating and focusing a new tab or window.
driver.switchTo().newWindow(
WindowType.TAB
);
To create a new browser window:
driver.switchTo().newWindow(
WindowType.WINDOW
);
| Browser Window Management | Multiple Window Handling |
|---|---|
| Controls window size. | Controls which window or tab Selenium is using. |
| Controls window position. | Uses window handles. |
| Supports maximize/minimize/fullscreen. | Supports switching between windows. |
Uses driver.manage().window(). |
Uses driver.switchTo().window(). |
Browser windows and frames are different concepts. A frame or iframe is embedded inside a webpage, while a browser window or tab is a separate browsing context.
driver.switchTo().frame("frameName");Window management should therefore not be confused with frame switching.
Window configuration can be placed inside a TestNG setup method so that every test begins with a consistent browser state.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class WindowTest {
WebDriver driver;
@BeforeMethod
public void setup() {
driver = new ChromeDriver();
driver.manage().window().maximize();
}
@Test
public void testHomePage() {
driver.get("https://example.com");
}
}
Using @BeforeMethod is useful when every test should start with the same browser configuration.
@BeforeMethod
public void setup() {
driver = new ChromeDriver();
driver.manage().window().maximize();
}
In a Page Object Model framework, browser initialization and window configuration are generally kept in a base test or driver-management layer rather than inside individual page classes.
public class BaseTest {
protected WebDriver driver;
public void setup() {
driver = new ChromeDriver();
driver.manage().window().maximize();
}
}
A reusable base class can standardize browser startup across multiple test classes.
public class BaseTest {
protected WebDriver driver;
public void initializeBrowser() {
driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
}
}
Browser dimensions can be stored as configuration values when a framework needs to run tests at predefined resolutions.
browser.width=1366
browser.height=768
The values can then be used with Selenium:
int width = 1366;
int height = 768;
driver.manage().window().setSize(
new Dimension(width, height)
);
Responsive navigation can change depending on the available browser width.
A desktop layout might display:
Home | Products | Services | About | ContactA smaller layout might display a hamburger menu instead.
Selenium can test both states by changing the browser window dimensions.
driver.manage().window().setSize(
new Dimension(1366, 768)
);
driver.get("https://example.com");
// Validate desktop navigation
driver.manage().window().setSize(
new Dimension(768, 1024)
);
driver.get("https://example.com");
// Validate responsive navigation
Changing browser dimensions can affect element visibility because responsive CSS may change the layout.
driver.manage().window().setSize(
new Dimension(1366, 768)
);
WebElement menu =
driver.findElement(By.id("mainMenu"));
System.out.println(
menu.isDisplayed()
);
Window configuration can be combined with assertions to validate responsive UI behavior.
driver.manage().window().setSize(
new Dimension(1366, 768)
);
driver.get("https://example.com");
WebElement header =
driver.findElement(By.id("header"));
Assert.assertTrue(
header.isDisplayed()
);
This can happen when the current browsing window has been closed or is no longer available.
Unsupported or unsuitable dimensions can cause problems depending on the browser and execution environment.
An element may disappear or move because changing the browser size triggered a different responsive layout.
Operating systems, display settings, browser UI, remote environments, and browser configurations can influence the final rendering.
maximize() with fullscreen().
maximize() for normal desktop-style automation when appropriate.setSize() when a specific browser dimension is required.getSize() when the test needs to inspect the current dimensions.getPosition() when browser coordinates are relevant.
Launch Browser
↓
Create WebDriver Session
↓
Configure Browser Window
↓
Maximize / Set Specific Size
↓
Open Application
↓
Validate Layout
↓
Interact With Elements
↓
Capture Screenshot
↓
Validate Result
↓
Close Browser
import org.openqa.selenium.Dimension;
import org.openqa.selenium.Point;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class CompleteWindowManagement {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
try {
driver.manage().window().maximize();
driver.get("https://www.google.com");
Dimension initialSize =
driver.manage().window().getSize();
System.out.println(
"Initial Width: " +
initialSize.getWidth()
);
System.out.println(
"Initial Height: " +
initialSize.getHeight()
);
Point initialPosition =
driver.manage().window().getPosition();
System.out.println(
"Initial X: " +
initialPosition.getX()
);
System.out.println(
"Initial Y: " +
initialPosition.getY()
);
driver.manage().window().setSize(
new Dimension(1024, 768)
);
driver.manage().window().setPosition(
new Point(100, 100)
);
Dimension finalSize =
driver.manage().window().getSize();
System.out.println(
"Final Width: " +
finalSize.getWidth()
);
System.out.println(
"Final Height: " +
finalSize.getHeight()
);
Point finalPosition =
driver.manage().window().getPosition();
System.out.println(
"Final X: " +
finalPosition.getX()
);
System.out.println(
"Final Y: " +
finalPosition.getY()
);
} finally {
driver.quit();
}
}
}
A useful Selenium practice project is a Responsive Website Window Tester. The objective is to open a website at different browser dimensions and verify that important UI components are available in each layout.
import org.openqa.selenium.By;
import org.openqa.selenium.Dimension;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class ResponsiveWindowTest {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
try {
driver.manage().window().setSize(
new Dimension(1366, 768)
);
driver.get("https://example.com");
boolean desktopMenu =
driver.findElement(
By.id("desktopMenu")
).isDisplayed();
System.out.println(
"Desktop Menu: " + desktopMenu
);
driver.manage().window().setSize(
new Dimension(768, 1024)
);
driver.get("https://example.com");
boolean mobileMenu =
driver.findElement(
By.id("mobileMenu")
).isDisplayed();
System.out.println(
"Responsive Menu: " + mobileMenu
);
} finally {
driver.quit();
}
}
}
Browser window management is part of the browser-control layer of Selenium WebDriver.
Test Case
↓
TestNG / JUnit
↓
Page Object / Framework
↓
WebDriver
↓
Window Management API
↓
Browser Driver
↓
Browser
↓
Web Application
The WebDriver window-management API provides methods for retrieving and setting window dimensions and position and for maximizing, minimizing, and entering fullscreen mode.
Selenium 4 supports window operations including maximize, minimize, fullscreen, size, and position management. The Selenium documentation specifically notes that minimizing the window is supported in Selenium 4 and later.
Modern Selenium versions can use Selenium Manager to assist with browser-driver management. Browser window management itself is performed through the WebDriver window API after the browser session is created.
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
Use the maximize() method.
driver.manage().window().maximize();
Use the minimize() method.
driver.manage().window().minimize();
Use the fullscreen() method.
driver.manage().window().fullscreen();
Use setSize() with the Selenium Dimension class.
driver.manage().window().setSize(
new Dimension(1024, 768)
);
Use getSize().
Dimension size =
driver.manage().window().getSize();
Use getPosition().
Point position =
driver.manage().window().getPosition();
Use setPosition().
driver.manage().window().setPosition(
new Point(100, 100)
);
maximize() enlarges the browser window, while fullscreen() fills the entire screen similar to fullscreen/F11 behavior.
Dimension represents the width and height of a browser window.
Point represents the X and Y coordinates of a browser window.
Because responsive web applications can change their layout, navigation, visibility, and element arrangement according to the available screen dimensions.
Browser window management controls properties such as size, position, maximize, minimize, and fullscreen. Window handling controls which browser window or tab Selenium is currently interacting with using window handles.
| Task | Selenium Java Code |
|---|---|
| Maximize | driver.manage().window().maximize(); |
| Minimize | driver.manage().window().minimize(); |
| Fullscreen | driver.manage().window().fullscreen(); |
| Get Size | driver.manage().window().getSize(); |
| Set Size | driver.manage().window().setSize(new Dimension(1024, 768)); |
| Get Position | driver.manage().window().getPosition(); |
| Set Position | driver.manage().window().setPosition(new Point(100, 100)); |
| Get Current Handle | driver.getWindowHandle(); |
| Get All Handles | driver.getWindowHandles(); |
WebDriver driver = new ChromeDriver();
↓
driver.manage().window()
↓
+-----------------------+
| |
↓ ↓
maximize() fullscreen()
|
↓
setSize()
|
↓
getSize()
|
↓
setPosition()
|
↓
getPosition()
|
↓
Perform Test
|
↓
Validate Result
|
↓
driver.quit()
After completing this topic, learners should be able to:
For structured Selenium Automation Testing training with Java, hands-on automation practice, Selenium WebDriver, TestNG, Page Object Model, cross-browser testing, automation frameworks, and real-time projects, you can explore the JustAcademy Selenium Automation Testing Course.
JustAcademy Selenium Automation Testing Course
For course demo registration:
Register for Selenium Course Demo
Browser Window Management is an important Selenium WebDriver topic used to control the size, position, and display state of a browser during automated testing. Selenium provides methods such as maximize(), minimize(), fullscreen(), getSize(), setSize(), getPosition(), and setPosition() for browser window control.
Browser Window Management is particularly useful for responsive web testing, consistent screenshots, controlled test environments, visual validation, and testing different screen resolutions. It should also be clearly distinguished from multiple-window handling, where Selenium uses window handles to switch between tabs or windows.
Important Browser Window Management Code:
driver.manage().window().maximize();
driver.manage().window().minimize();
driver.manage().window().fullscreen();
Dimension size =
driver.manage().window().getSize();
driver.manage().window().setSize(
new Dimension(1024, 768)
);
Point position =
driver.manage().window().getPosition();
driver.manage().window().setPosition(
new Point(100, 100)
);
Official Selenium Documentation: Selenium WebDriver Browser Windows
