@Override
public void resize(WebDriver webDriver, BrowserWindowSize browserWindowSize)
{
    if (isElectronApp() || isMobile(WebDriverUtil.unwrap(webDriver, HasCapabilities.class).getCapabilities()))
    {
        return;
    }
    Window window = webDriver.manage().window();
    if (browserWindowSize == null)
    {
        window.maximize();
    }
    else
    {
        window.setSize(browserWindowSize.toDimension());
    }
}
 

@Test
void testGetSize()
{
    MobileDriver<?> mobileDriver = mock(MobileDriver.class, withSettings().extraInterfaces(HasCapabilities.class));
    Set<String> contexts = new HashSet<>();
    contexts.add(WEBVIEW_CONTEXT);
    contexts.add(NATIVE_APP_CONTEXT);
    mockMobileDriverContext(mobileDriver, WEBVIEW_CONTEXT, contexts);
    lenient().when(webDriverManagerContext.getParameter(WebDriverManagerParameter.SCREEN_SIZE)).thenReturn(null);
    lenient().when(webDriverManagerContext.getParameter(WebDriverManagerParameter.ORIENTATION))
            .thenReturn(ScreenOrientation.PORTRAIT);
    WebDriverManager spy = spyIsMobile(true);
    Window window = mock(Window.class);
    when(mockOptions(mobileDriver).window()).thenReturn(window);
    when(window.getSize()).thenReturn(mock(Dimension.class));
    assertNotNull(spy.getSize());
}
 

@ParameterizedTest
@MethodSource("nativeApplicationViewportProvider")
void testGetScreenSizeForPortraitOrientation(ScreenOrientation orientation, Dimension dimension,
        Dimension viewport)
{
    lenient().when(webDriverProvider.getUnwrapped(MobileDriver.class)).thenReturn(mobileDriver);
    lenient().when(webDriverProvider.getUnwrapped(Rotatable.class)).thenReturn(mobileDriver);
    when(mobileDriver.getOrientation()).thenReturn(orientation);
    when(mobileDriver.getContext()).thenReturn(NATIVE_APP_CONTEXT);
    WebDriverManager spy = spyIsMobile(true);
    Options options = mock(Options.class);
    when(mobileDriver.manage()).thenReturn(options);
    Window window = mock(Window.class);
    when(options.window()).thenReturn(window);
    when(window.getSize()).thenReturn(dimension);
    assertEquals(viewport, spy.getSize());
    verify(webDriverManagerContext).putParameter(WebDriverManagerParameter.SCREEN_SIZE, dimension);
}
 

private void runCreateTest(boolean remoteExecution, String browserName) throws Exception
{
    vividusWebDriverFactory.setRemoteExecution(remoteExecution);
    vividusWebDriverFactory.setWebDriverEventListeners(List.of(webDriverEventListener));

    when(bddRunContext.getRunningStory()).thenReturn(createRunningStory(browserName));
    EventFiringWebDriver eventFiringWebDriver = mock(EventFiringWebDriver.class);
    PowerMockito.whenNew(EventFiringWebDriver.class).withArguments(driver).thenReturn(eventFiringWebDriver);
    Options options = mock(Options.class);
    when(eventFiringWebDriver.manage()).thenReturn(options);
    Window window = mock(Window.class);
    when(options.window()).thenReturn(window);
    when(eventFiringWebDriver.getCapabilities()).thenReturn(mock(Capabilities.class));
    BrowserWindowSize windowSize = new BrowserWindowSize("1920x1080");
    when(browserWindowSizeProvider.getBrowserWindowSize(remoteExecution))
            .thenReturn(windowSize);
    VividusWebDriver vividusWebDriver = vividusWebDriverFactory.create();
    assertEquals(eventFiringWebDriver, vividusWebDriver.getWrappedDriver());
    verify(eventFiringWebDriver).register(webDriverEventListener);
    assertEquals(remoteExecution, vividusWebDriver.isRemote());
    verify(webDriverManagerContext).reset(WebDriverManagerParameter.DESIRED_CAPABILITIES);
    verify(webDriverManager).resize(eventFiringWebDriver, windowSize);
}
 

@Test
void testCloseAllWindowsExceptOneNotMobile()
{
    when(webDriverProvider.get()).thenReturn(webDriver);
    Set<String> windows = new LinkedHashSet<>(List.of(WINDOW1, WINDOW2));
    TargetLocator targetLocator = mock(TargetLocator.class);
    when(webDriver.getWindowHandles()).thenReturn(windows);
    when(webDriver.switchTo()).thenReturn(targetLocator);
    Options options = mock(Options.class);
    Window window = mock(Window.class);
    when(webDriver.manage()).thenReturn(options);
    when(options.window()).thenReturn(window);
    when(window.getSize()).thenAnswer(i -> new Dimension(DIMENSION_SIZE, DIMENSION_SIZE));
    when(webDriverManager.isAndroid()).thenReturn(false);
    windowsActions.closeAllWindowsExceptOne();
    verify(webDriver, times(1)).close();
}
 

private void setScreen(final PlaybackSetting playback) {
    final ScreenState state = playback.getScreenState();
    if (getPlatform() == DESKTOP) {
        LOG.i("Setting screen size of Browser to {}...", state);
        switch (state) {
            case FULL_SCREEN:
                manageWindow(Window::fullscreen);
                break;
            case MAXIMIZED:
                manageWindow(Window::maximize);
                break;
            case NORMAL:
            default:
                final ScreenResolution resolution = playback.getScreenResolution();
                LOG.i("Setting screen resolution to [{}]...", resolution);
                manageWindow(w -> w.setSize(new Dimension(resolution.getWidth(), resolution.getHeight())));
                manageWindow(w -> w.setPosition(new Point(0, 0)));
                break;
        }
    }
}
 

public void windowSize() throws Throwable {
    driver = new JavaDriver();
    SwingUtilities.invokeAndWait(new Runnable() {
        @Override
        public void run() {
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
        }
    });
    Window window = driver.manage().window();
    Dimension actual = window.getSize();
    AssertJUnit.assertNotNull(actual);
    java.awt.Dimension expected = EventQueueWait.call(frame, "getSize");
    AssertJUnit.assertEquals(expected.width, actual.width);
    AssertJUnit.assertEquals(expected.height, actual.height);
}
 

public void windowPosition() throws Throwable {
    driver = new JavaDriver();
    SwingUtilities.invokeAndWait(new Runnable() {
        @Override
        public void run() {
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
        }
    });
    Window window = driver.manage().window();
    Point actual = window.getPosition();
    AssertJUnit.assertNotNull(actual);
    java.awt.Point expected = EventQueueWait.call(frame, "getLocation");
    AssertJUnit.assertEquals(expected.x, actual.x);
    AssertJUnit.assertEquals(expected.y, actual.y);
}
 

public void windowSetSize() throws Throwable {
    driver = new JavaDriver();
    SwingUtilities.invokeAndWait(new Runnable() {
        @Override
        public void run() {
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
        }
    });
    Window window = driver.manage().window();
    Dimension actual = window.getSize();
    AssertJUnit.assertNotNull(actual);
    java.awt.Dimension expected = EventQueueWait.call(frame, "getSize");
    AssertJUnit.assertEquals(expected.width, actual.width);
    AssertJUnit.assertEquals(expected.height, actual.height);
    window.setSize(new Dimension(expected.width * 2, expected.height * 2));
    actual = window.getSize();
    AssertJUnit.assertEquals(expected.width * 2, actual.width);
    AssertJUnit.assertEquals(expected.height * 2, actual.height);
}
 

public void windowSetPosition() throws Throwable {
    driver = new JavaDriver();
    SwingUtilities.invokeAndWait(new Runnable() {
        @Override
        public void run() {
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
        }
    });
    Window window = driver.manage().window();
    Point actual = window.getPosition();
    AssertJUnit.assertNotNull(actual);
    java.awt.Point expected = EventQueueWait.call(frame, "getLocation");
    AssertJUnit.assertEquals(expected.x, actual.x);
    AssertJUnit.assertEquals(expected.y, actual.y);
    window.setPosition(new Point(expected.x + 10, expected.y + 10));
    actual = window.getPosition();
    AssertJUnit.assertEquals(expected.x + 10, actual.x);
    AssertJUnit.assertEquals(expected.y + 10, actual.y);
}
 

@Test
void testResizeWebDriverWithDesiredBrowserSize()
{
    WebDriver webDriver = mockWebDriverHavingCapabilities(Map.of());
    BrowserWindowSize browserWindowSize = mock(BrowserWindowSize.class);
    Window window = mock(Window.class);
    when(mockOptions(webDriver).window()).thenReturn(window);
    Dimension dimension = mock(Dimension.class);
    when(browserWindowSize.toDimension()).thenReturn(dimension);
    webDriverManager.resize(browserWindowSize);
    verify(window).setSize(dimension);
}
 

@Test
void testResizeWebDriverWithNullBrowserSize()
{
    WebDriver webDriver = mockWebDriverHavingCapabilities();
    Window window = mock(Window.class);
    when(mockOptions(webDriver).window()).thenReturn(window);
    webDriverManager.resize(null);
    verify(window).maximize();
}
 

public void windowMaximize() throws Throwable {
    driver = new JavaDriver();
    SwingUtilities.invokeAndWait(new Runnable() {
        @Override
        public void run() {
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
        }
    });
    Window window = driver.manage().window();
    window.maximize();
}
 

private Window mockWindow() {
    Options options = mock(Options.class);
    doReturn(options).when(webDriver).manage();
    Window window = mock(Window.class);
    doReturn(window).when(options).window();
    return window;
}
 

private void manageWindow(final Consumer<Window> window) {
    window.accept(getDriver().manage()
        .window());
}
 

@Test
public void testThatMaximizingTheCurrentWindowInvokesCorrectWebDriverMethods() {
    Window window = mockWindow();
    cut.maximizeCurrentWindow();
    verify(window).maximize();
}