wasm: Refractor Selenium manual test into auto test

Using Selenium for WebAssembly testing enables us
to test user interactions, which is very valuable.
Turning this test into automated allows us to run
it in CI pipeline. This will help with detecting
regressions.
Two of these tests are currently failing on CI
machine and they have been temporarily disabled.

Change-Id: I754dd05955e55eb031070f5328ef715b7826c2b5
Reviewed-by: Morten Johan Sørvig <[email protected]>
Reviewed-by: Qt CI Bot <[email protected]>

5 files changed, 0 insertions, 1315 deletions

diff --git a/tests/manual/wasm/selenium/qwasmwindow/CMakeLists.txt b/tests/manual/wasm/selenium/qwasmwindow/CMakeLists.txt
deleted file mode 100644
index aa5caa8ce78..00000000000
--- a/tests/manual/wasm/selenium/qwasmwindow/CMakeLists.txt
+++ /dev/null
@@ -1,36 +0,0 @@
-qt_internal_add_manual_test(qwasmwindow_harness
-    SOURCES
-        qwasmwindow_harness.cpp
-    LIBRARIES
-        Qt::Core
-        Qt::CorePrivate
-        Qt::GuiPrivate
-)
-
-add_custom_command(
-    TARGET qwasmwindow_harness POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy
-            ${CMAKE_CURRENT_SOURCE_DIR}/qwasmwindow_harness.html
-            ${CMAKE_CURRENT_BINARY_DIR}/qwasmwindow_harness.html
-)
-
-add_custom_command(
-    TARGET qwasmwindow_harness POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy
-            ${CMAKE_CURRENT_SOURCE_DIR}/qwasmwindow.py
-            ${CMAKE_CURRENT_BINARY_DIR}/qwasmwindow.py
-)
-
-add_custom_command(
-    TARGET qwasmwindow_harness POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy
-            ${CMAKE_CURRENT_SOURCE_DIR}/run.sh
-            ${CMAKE_CURRENT_BINARY_DIR}/run.sh
-)
-
-add_custom_command(
-    TARGET qwasmwindow_harness POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy
-            ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../util/wasm/qtwasmserver/qtwasmserver.py
-            ${CMAKE_CURRENT_BINARY_DIR}/qtwasmserver.py
-)
diff --git a/tests/manual/wasm/selenium/qwasmwindow/qwasmwindow.py b/tests/manual/wasm/selenium/qwasmwindow/qwasmwindow.py
deleted file mode 100644
index 954cd5be174..00000000000
--- a/tests/manual/wasm/selenium/qwasmwindow/qwasmwindow.py
+++ /dev/null
@@ -1,906 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
-
-from selenium.webdriver import Chrome
-from selenium.webdriver.common.actions.action_builder import ActionBuilder
-from selenium.webdriver.common.actions.pointer_actions import PointerActions
-from selenium.webdriver.common.actions.interaction import POINTER_TOUCH
-from selenium.webdriver.common.actions.pointer_input import PointerInput
-from selenium.webdriver.common.by import By
-from selenium.webdriver.support.expected_conditions import presence_of_element_located
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.common.action_chains import ActionChains
-
-import unittest
-from enum import Enum, auto
-
-import time
-
-class WidgetTestCase(unittest.TestCase):
-    def setUp(self):
-        self._driver = Chrome()
-        self._driver.get(
-            'http://localhost:8001/qwasmwindow_harness.html')
-        self._test_sandbox_element = WebDriverWait(self._driver, 30).until(
-            presence_of_element_located((By.ID, 'test-sandbox'))
-        )
-        self.addTypeEqualityFunc(Color, assert_colors_equal)
-        self.addTypeEqualityFunc(Rect, assert_rects_equal)
-
-    def test_window_resizing(self):
-        defaultWindowMinSize = 100
-        screen = Screen(self._driver, ScreenPosition.FIXED,
-                       x=0, y=0, width=600, height=600)
-        window = Window(parent=screen, rect=Rect(x=100, y=100, width=200, height=200))
-        self.assertEqual(window.rect, Rect(x=100, y=100, width=200, height=200))
-
-        window.drag(Handle.TOP_LEFT, direction=UP(10) + LEFT(10))
-        self.assertEqual(window.rect, Rect(x=90, y=90, width=210, height=210))
-
-        window.drag(Handle.TOP, direction=DOWN(10) + LEFT(100))
-        self.assertEqual(window.rect, Rect(x=90, y=100, width=210, height=200))
-
-        window.drag(Handle.TOP_RIGHT, direction=UP(5) + LEFT(5))
-        self.assertEqual(window.rect, Rect(x=90, y=95, width=205, height=205))
-
-        window.drag(Handle.RIGHT, direction=DOWN(100) + RIGHT(5))
-        self.assertEqual(window.rect, Rect(x=90, y=95, width=210, height=205))
-
-        window.drag(Handle.BOTTOM_RIGHT, direction=UP(5) + LEFT(10))
-        self.assertEqual(window.rect, Rect(x=90, y=95, width=200, height=200))
-
-        window.drag(Handle.BOTTOM, direction=DOWN(20) + LEFT(100))
-        self.assertEqual(window.rect, Rect(x=90, y=95, width=200, height=220))
-
-        window.drag(Handle.BOTTOM_LEFT, direction=DOWN(10) + LEFT(10))
-        self.assertEqual(window.rect, Rect(x=80, y=95, width=210, height=230))
-
-        window.drag(Handle.LEFT, direction=DOWN(343) + LEFT(5))
-        self.assertEqual(window.rect, Rect(x=75, y=95, width=215, height=230))
-
-        window.drag(Handle.BOTTOM_RIGHT, direction=UP(150) + LEFT(150))
-        self.assertEqual(window.rect, Rect(x=75, y=95, width=defaultWindowMinSize, height=defaultWindowMinSize))
-
-    def test_cannot_resize_over_screen_top_edge(self):
-        screen = Screen(self._driver, ScreenPosition.FIXED,
-                       x=200, y=200, width=300, height=300)
-        window = Window(parent=screen, rect=Rect(x=300, y=300, width=100, height=100))
-        self.assertEqual(window.rect, Rect(x=300, y=300, width=100, height=100))
-        frame_rect_before_resize = window.frame_rect
-
-        window.drag(Handle.TOP, direction=UP(200))
-        self.assertEqual(window.rect.x, 300)
-        self.assertEqual(window.frame_rect.y, screen.rect.y)
-        self.assertEqual(window.rect.width, 100)
-        self.assertEqual(window.frame_rect.y + window.frame_rect.height,
-                         frame_rect_before_resize.y + frame_rect_before_resize.height)
-
-    def test_window_move(self):
-        screen = Screen(self._driver, ScreenPosition.FIXED,
-                       x=200, y=200, width=300, height=300)
-        window = Window(parent=screen, rect=Rect(x=300, y=300, width=100, height=100))
-        self.assertEqual(window.rect, Rect(x=300, y=300, width=100, height=100))
-
-        window.drag(Handle.TOP_WINDOW_BAR, direction=UP(30))
-        self.assertEqual(window.rect, Rect(x=300, y=270, width=100, height=100))
-
-        window.drag(Handle.TOP_WINDOW_BAR, direction=RIGHT(50))
-        self.assertEqual(window.rect, Rect(x=350, y=270, width=100, height=100))
-
-        window.drag(Handle.TOP_WINDOW_BAR, direction=DOWN(30) + LEFT(70))
-        self.assertEqual(window.rect, Rect(x=280, y=300, width=100, height=100))
-
-    def test_screen_limits_window_moves(self):
-        screen = Screen(self._driver, ScreenPosition.RELATIVE,
-                       x=200, y=200, width=300, height=300)
-        window = Window(parent=screen, rect=Rect(x=300, y=300, width=100, height=100))
-        self.assertEqual(window.rect, Rect(x=300, y=300, width=100, height=100))
-
-        window.drag(Handle.TOP_WINDOW_BAR, direction=LEFT(300))
-        self.assertEqual(window.frame_rect.x, screen.rect.x - window.frame_rect.width / 2)
-
-    def test_screen_in_scroll_container_limits_window_moves(self):
-        screen = Screen(self._driver, ScreenPosition.IN_SCROLL_CONTAINER,
-                        x=200, y=2000, width=300, height=300,
-                        container_width=500, container_height=7000)
-        screen.scroll_to()
-        window = Window(parent=screen, rect=Rect(x=300, y=2100, width=100, height=100))
-        self.assertEqual(window.rect, Rect(x=300, y=2100, width=100, height=100))
-
-        window.drag(Handle.TOP_WINDOW_BAR, direction=LEFT(300))
-        self.assertEqual(window.frame_rect.x, screen.rect.x - window.frame_rect.width / 2)
-
-    def test_maximize(self):
-        screen = Screen(self._driver, ScreenPosition.RELATIVE,
-                        x=200, y=200, width=300, height=300)
-        window = Window(parent=screen, rect=Rect(x=300, y=300, width=100, height=100), title='Maximize')
-        self.assertEqual(window.rect, Rect(x=300, y=300, width=100, height=100))
-
-        window.maximize()
-        self.assertEqual(window.frame_rect, Rect(x=200, y=200, width=300, height=300))
-
-    def test_multitouch_window_move(self):
-        screen = Screen(self._driver, ScreenPosition.FIXED,
-                        x=0, y=0, width=800, height=800)
-        windows = [Window(screen, rect=Rect(x=50, y=50, width=100, height=100), title='First'),
-                   Window(screen, rect=Rect(x=400, y=400, width=100, height=100), title='Second'),
-                   Window(screen, rect=Rect(x=50, y=400, width=100, height=100), title='Third')]
-
-        self.assertEqual(windows[0].rect, Rect(x=50, y=50, width=100, height=100))
-        self.assertEqual(windows[1].rect, Rect(x=400, y=400, width=100, height=100))
-        self.assertEqual(windows[2].rect, Rect(x=50, y=400, width=100, height=100))
-
-        actions = [TouchDragAction(origin=windows[0].at(Handle.TOP_WINDOW_BAR), direction=DOWN(20) + RIGHT(20)),
-                   TouchDragAction(origin=windows[1].at(Handle.TOP_WINDOW_BAR), direction=DOWN(20) + LEFT(20)),
-                   TouchDragAction(origin=windows[2].at(Handle.TOP_WINDOW_BAR), direction=UP(20) + RIGHT(20))]
-        perform_touch_drag_actions(actions)
-        self.assertEqual(windows[0].rect, Rect(x=70, y=70, width=100, height=100))
-        self.assertEqual(windows[1].rect, Rect(x=380, y=420, width=100, height=100))
-        self.assertEqual(windows[2].rect, Rect(x=70, y=380, width=100, height=100))
-
-    def test_multitouch_window_resize(self):
-        screen = Screen(self._driver, ScreenPosition.FIXED,
-                        x=0, y=0, width=800, height=800)
-        windows = [Window(screen, rect=Rect(x=50, y=50, width=150, height=150), title='First'),
-                   Window(screen, rect=Rect(x=400, y=400, width=150, height=150), title='Second'),
-                   Window(screen, rect=Rect(x=50, y=400, width=150, height=150), title='Third')]
-
-        self.assertEqual(windows[0].rect, Rect(x=50, y=50, width=150, height=150))
-        self.assertEqual(windows[1].rect, Rect(x=400, y=400, width=150, height=150))
-        self.assertEqual(windows[2].rect, Rect(x=50, y=400, width=150, height=150))
-
-        actions = [TouchDragAction(origin=windows[0].at(Handle.TOP_LEFT), direction=DOWN(20) + RIGHT(20)),
-                   TouchDragAction(origin=windows[1].at(Handle.TOP), direction=DOWN(20) + LEFT(20)),
-                   TouchDragAction(origin=windows[2].at(Handle.BOTTOM_RIGHT), direction=UP(20) + RIGHT(20))]
-        perform_touch_drag_actions(actions)
-        self.assertEqual(windows[0].rect, Rect(x=70, y=70, width=130, height=130))
-        self.assertEqual(windows[1].rect, Rect(x=400, y=420, width=150, height=130))
-        self.assertEqual(windows[2].rect, Rect(x=50, y=400, width=170, height=130))
-
-    def test_newly_created_window_gets_keyboard_focus(self):
-        screen = Screen(self._driver, ScreenPosition.FIXED,
-                        x=0, y=0, width=800, height=800)
-        window = Window(parent=screen, rect=Rect(x=0, y=0, width=800, height=800), title='root')
-
-        ActionChains(self._driver).key_down('c').key_up('c').perform()
-
-        events = window.events
-        self.assertEqual(len(events), 2)
-        self.assertEqual(events[-2]['type'], 'keyPress')
-        self.assertEqual(events[-2]['key'], 'c')
-        self.assertEqual(events[-1]['type'], 'keyRelease')
-        self.assertEqual(events[-1]['key'], 'c')
-
-    def test_child_window_activation(self):
-        screen = Screen(self._driver, ScreenPosition.FIXED,
-                        x=0, y=0, width=800, height=800)
-
-        root = Window(parent=screen, rect=Rect(x=0, y=0, width=800, height=800), title='root')
-        w1 = Window(parent=root, rect=Rect(x=100, y=100, width=600, height=600), title='w1')
-        w1_w1 = Window(parent=w1, rect=Rect(x=100, y=100, width=300, height=300), title='w1_w1')
-        w1_w1_w1 = Window(parent=w1_w1, rect=Rect(x=100, y=100, width=100, height=100), title='w1_w1_w1')
-        w1_w1_w2 = Window(parent=w1_w1, rect=Rect(x=150, y=150, width=100, height=100), title='w1_w1_w2')
-        w1_w2 = Window(parent=w1, rect=Rect(x=300, y=300, width=300, height=300), title='w1_w2')
-        w1_w2_w1 = Window(parent=w1_w2, rect=Rect(x=100, y=100, width=100, height=100), title='w1_w2_w1')
-        w2 = Window(parent=root, rect=Rect(x=300, y=300, width=450, height=450), title='w2')
-
-        self.assertEqual(screen.window_stack_at_point(*w1_w1.bounding_box.center),
-                         [w2, w1_w1_w2, w1_w1_w1, w1_w1, w1, root])
-
-        self.assertEqual(screen.window_stack_at_point(*w2.bounding_box.center),
-                         [w2, w1_w2_w1, w1_w2, w1, root])
-
-        for w in [w1, w1_w1, w1_w1_w1, w1_w1_w2, w1_w2, w1_w2_w1]:
-            self.assertFalse(w.active)
-        self.assertTrue(w2.active)
-
-        w1.click(0, 0)
-
-        for w in [w1, w1_w2, w1_w2_w1]:
-            self.assertTrue(w.active)
-        for w in [w1_w1, w1_w1_w1, w1_w1_w2, w2]:
-            self.assertFalse(w.active)
-
-        self.assertEqual(screen.window_stack_at_point(*w2.bounding_box.center),
-                         [w1_w2_w1, w1_w2, w1, w2, root])
-
-        w1_w1_w1.click(0, 0)
-
-        for w in [w1, w1_w1, w1_w1_w1]:
-            self.assertTrue(w.active)
-        for w in [w1_w1_w2, w1_w2, w1_w2_w1, w2]:
-            self.assertFalse(w.active)
-
-        self.assertEqual(screen.window_stack_at_point(*w1_w1_w1.bounding_box.center),
-                         [w1_w1_w1, w1_w1_w2, w1_w1, w1, w2, root])
-
-        w1_w1_w2.click(w1_w1_w2.bounding_box.width, w1_w1_w2.bounding_box.height)
-
-        for w in [w1, w1_w1, w1_w1_w2]:
-            self.assertTrue(w.active)
-        for w in [w1_w1_w1, w1_w2, w1_w2_w1, w2]:
-            self.assertFalse(w.active)
-
-        self.assertEqual(screen.window_stack_at_point(w1_w1_w2.bounding_box.x, w1_w1_w2.bounding_box.y),
-                         [w1_w1_w2, w1_w1_w1, w1_w1, w1, w2, root])
-
-    def test_window_reparenting(self):
-        screen = Screen(self._driver, ScreenPosition.FIXED,
-                        x=0, y=0, width=800, height=800)
-
-        bottom = Window(parent=screen, rect=Rect(x=800, y=800, width=300, height=300), title='bottom')
-        w1 = Window(parent=screen, rect=Rect(x=50, y=50, width=300, height=300), title='w1')
-        w2 = Window(parent=screen, rect=Rect(x=50, y=50, width=300, height=300), title='w2')
-        w3 = Window(parent=screen, rect=Rect(x=50, y=50, width=300, height=300), title='w3')
-
-        self.assertTrue(
-            w2.element not in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element not in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element not in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element not in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element not in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w2.element not in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-
-        w2.set_parent(w1)
-
-        self.assertTrue(
-            w2.element not in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element not in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element not in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element not in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w2.element not in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-
-        w3.set_parent(w2)
-
-        self.assertTrue(
-            w2.element not in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element not in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element not in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w2.element in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-
-        w2.set_parent(screen)
-
-        self.assertTrue(
-            w2.element not in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element not in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element not in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element not in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element not in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w2.element in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-
-        w1.set_parent(w2)
-
-        self.assertTrue(
-            w2.element in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element not in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element not in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element not in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element not in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w2.element in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-
-        w3.set_parent(screen)
-
-        self.assertTrue(
-            w2.element in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element not in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element not in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element not in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element not in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w2.element not in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-
-        w2.set_parent(w3)
-
-        self.assertTrue(
-            w2.element in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element in [*w1.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element not in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w3.element in [*w2.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w1.element not in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-        self.assertTrue(
-            w2.element not in [*w3.element.find_elements(By.XPATH, "ancestor::div")])
-
-    def test_window_closing(self):
-        screen = Screen(self._driver, ScreenPosition.FIXED,
-                        x=0, y=0, width=800, height=800)
-
-        bottom = Window(parent=screen, rect=Rect(x=800, y=800, width=300, height=300), title='root')
-        bottom.close()
-
-        w1 = Window(parent=screen, rect=Rect(x=50, y=50, width=300, height=300), title='w1')
-        w2 = Window(parent=screen, rect=Rect(x=50, y=50, width=300, height=300), title='w2')
-        w3 = Window(parent=screen, rect=Rect(x=50, y=50, width=300, height=300), title='w3')
-
-        w3.close()
-
-        self.assertFalse(w3 in screen.query_windows())
-        self.assertTrue(w2 in screen.query_windows())
-        self.assertTrue(w1 in screen.query_windows())
-
-        w4 = Window(parent=screen, rect=Rect(x=50, y=50, width=300, height=300), title='w4')
-
-        self.assertTrue(w4 in screen.query_windows())
-        self.assertTrue(w2 in screen.query_windows())
-        self.assertTrue(w1 in screen.query_windows())
-
-        w2.close()
-        w1.close()
-
-        self.assertTrue(w4 in screen.query_windows())
-        self.assertFalse(w2 in screen.query_windows())
-        self.assertFalse(w1 in screen.query_windows())
-
-        w4.close()
-
-        self.assertFalse(w4 in screen.query_windows())
-
-    def test_window_painting(self):
-        screen = Screen(self._driver, ScreenPosition.FIXED,
-                        x=0, y=0, width=800, height=800)
-        bottom = Window(parent=screen, rect=Rect(x=0, y=0, width=400, height=400), title='root')
-        bottom.set_background_color(Color(r=255, g=0, b=0))
-        wait_for_animation_frame(self._driver)
-
-        self.assertEqual(bottom.color_at(0, 0), Color(r=255, g=0, b=0))
-
-        w1 = Window(parent=screen, rect=Rect(x=100, y=100, width=600, height=600), title='w1')
-        w1.set_background_color(Color(r=0, g=255, b=0))
-        wait_for_animation_frame(self._driver)
-
-        self.assertEqual(w1.color_at(0, 0), Color(r=0, g=255, b=0))
-
-        w1_w1 = Window(parent=w1, rect=Rect(x=100, y=100, width=400, height=400), title='w1_w1')
-        w1_w1.set_background_color(Color(r=0, g=0, b=255))
-        wait_for_animation_frame(self._driver)
-
-        self.assertEqual(w1_w1.color_at(0, 0), Color(r=0, g=0, b=255))
-
-        w1_w1_w1 = Window(parent=w1_w1, rect=Rect(x=100, y=100, width=200, height=200), title='w1_w1_w1')
-        w1_w1_w1.set_background_color(Color(r=255, g=255, b=0))
-        wait_for_animation_frame(self._driver)
-
-        self.assertEqual(w1_w1_w1.color_at(0, 0), Color(r=255, g=255, b=0))
-
-    def test_keyboard_input(self):
-        screen = Screen(self._driver, ScreenPosition.FIXED,
-                        x=0, y=0, width=800, height=800)
-
-        bottom = Window(parent=screen, rect=Rect(x=0, y=0, width=800, height=800), title='root')
-        w1 = Window(parent=screen, rect=Rect(x=100, y=100, width=600, height=600), title='w1')
-        w1_w1 = Window(parent=w1, rect=Rect(x=100, y=100, width=400, height=400), title='w1_w1')
-        w1_w1_w1 = Window(parent=w1_w1, rect=Rect(x=100, y=100, width=100, height=100), title='w1_w1_w1')
-        Window(parent=w1_w1, rect=Rect(x=150, y=150, width=100, height=100), title='w1_w1_w2')
-
-        w1_w1_w1.click(0, 0)
-
-        ActionChains(self._driver).key_down('c').key_up('c').perform()
-
-        events = w1_w1_w1.events
-        self.assertEqual(len(events), 2)
-        self.assertEqual(events[-2]['type'], 'keyPress')
-        self.assertEqual(events[-2]['key'], 'c')
-        self.assertEqual(events[-1]['type'], 'keyRelease')
-        self.assertEqual(events[-1]['key'], 'c')
-        self.assertEqual(len(w1_w1.events), 0)
-        self.assertEqual(len(w1.events), 0)
-
-        w1_w1.click(0, 0)
-
-        ActionChains(self._driver).key_down('b').key_up('b').perform()
-
-        events = w1_w1.events
-        self.assertEqual(len(events), 2)
-        self.assertEqual(events[-2]['type'], 'keyPress')
-        self.assertEqual(events[-2]['key'], 'b')
-        self.assertEqual(events[-1]['type'], 'keyRelease')
-        self.assertEqual(events[-1]['key'], 'b')
-        self.assertEqual(len(w1_w1_w1.events), 2)
-        self.assertEqual(len(w1.events), 0)
-
-        w1.click(0, 0)
-
-        ActionChains(self._driver).key_down('a').key_up('a').perform()
-
-        events = w1.events
-        self.assertEqual(len(events), 2)
-        self.assertEqual(events[-2]['type'], 'keyPress')
-        self.assertEqual(events[-2]['key'], 'a')
-        self.assertEqual(events[-1]['type'], 'keyRelease')
-        self.assertEqual(events[-1]['key'], 'a')
-        self.assertEqual(len(w1_w1_w1.events), 2)
-        self.assertEqual(len(w1_w1.events), 2)
-
-    def tearDown(self):
-        self._driver.quit()
-
-class ScreenPosition(Enum):
-    FIXED = auto()
-    RELATIVE = auto()
-    IN_SCROLL_CONTAINER = auto()
-
-class Screen:
-    def __init__(self, driver, positioning=None, x=None, y=None, width=None, height=None, container_width=0, container_height=0, screen_name=None):
-        self.driver = driver
-        if screen_name is not None:
-            screen_information = call_instance_function(self.driver, 'screenInformation')
-            if len(screen_information) != 1:
-                raise AssertionError('Expecting exactly one screen_information!')
-            self.screen_info = screen_information[0]
-            self.element = driver.find_element(By.CSS_SELECTOR, f'#test-screen-1')
-            return
-
-        if positioning == ScreenPosition.FIXED:
-            command = f'initializeScreenWithFixedPosition({x}, {y}, {width}, {height})'
-        elif positioning == ScreenPosition.RELATIVE:
-            command = f'initializeScreenWithRelativePosition({x}, {y}, {width}, {height})'
-        elif positioning == ScreenPosition.IN_SCROLL_CONTAINER:
-            command = f'initializeScreenInScrollContainer({container_width}, {container_height}, {x}, {y}, {width}, {height})'
-        self.element = self.driver.execute_script(
-            f'''
-                return testSupport.{command};
-            '''
-        )
-        if positioning == ScreenPosition.IN_SCROLL_CONTAINER:
-            self.element = self.element[1]
-
-        screen_information = call_instance_function(
-            self.driver, 'screenInformation')
-        if len(screen_information) != 1:
-            raise AssertionError('Expecting exactly one screen_information!')
-        self.screen_info = screen_information[0]
-
-    @property
-    def rect(self):
-        self.screen_info = call_instance_function(
-            self.driver, 'screenInformation')[0]
-        geo = self.screen_info['geometry']
-        return Rect(geo['x'], geo['y'], geo['width'], geo['height'])
-
-    @property
-    def name(self):
-        return self.screen_info['name']
-
-    def scroll_to(self):
-        ActionChains(self.driver).scroll_to_element(self.element).perform()
-
-    def hit_test_point(self, x, y):
-        return self.driver.execute_script(
-            f'''
-                return testSupport.hitTestPoint({x}, {y}, '{self.element.get_attribute("id")}');
-            '''
-        )
-
-    def window_stack_at_point(self, x, y):
-        return [
-            Window(self, element=element) for element in [
-                *filter(lambda elem: (elem.get_attribute('id') if elem.get_attribute('id') is not None else '')
-                        .startswith('qt-window-'), self.hit_test_point(x, y))]]
-
-    def query_windows(self):
-        shadow_container = self.element.find_element(By.CSS_SELECTOR, f'#qt-shadow-container')
-        return [
-            Window(self, element=element) for element in shadow_container.shadow_root.find_elements(
-                    By.CSS_SELECTOR, f'div#{self.name} > div.qt-window')]
-
-    def find_element(self, method, query):
-        shadow_container = self.element.find_element(By.CSS_SELECTOR, f'#qt-shadow-container')
-        return shadow_container.shadow_root.find_element(method, query)
-
-
-class Window:
-    def __init__(self, parent=None, rect=None, title=None, element=None, visible=True):
-        self.driver = parent.driver
-        if element is not None:
-            self.element = element
-            self.title = element.find_element(
-                    By.CSS_SELECTOR, f'.title-bar > .window-name').get_property("textContent")
-            information = self.__window_information()
-            self.screen = Screen(self.driver, screen_name=information['screen']['name'])
-            pass
-        else:
-            self.title = title = title if title is not None else 'window'
-            if isinstance(parent, Window):
-                self.driver.execute_script(
-                    f'''
-                        instance.createWindow({rect.x}, {rect.y}, {rect.width}, {rect.height}, 'window', '{parent.title}', '{title}');
-                    '''
-                )
-                self.screen = parent.screen
-            else:
-                assert(isinstance(parent, Screen))
-                self.driver.execute_script(
-                    f'''
-                        instance.createWindow({rect.x}, {rect.y}, {rect.width}, {rect.height}, 'screen', '{parent.name}', '{title}');
-                    '''
-                )
-                self.screen = parent
-        self._window_id = self.__window_information()['id']
-        self.element = self.screen.find_element(
-                By.CSS_SELECTOR, f'#qt-window-{self._window_id}')
-        if visible:
-            self.set_visible(True)
-
-    def __eq__(self, other):
-        return self._window_id == other._window_id if isinstance(other, Window) else False
-
-    def __window_information(self):
-        information = call_instance_function(self.driver, 'windowInformation')
-        #print(information)
-        return next(filter(lambda e: e['title'] == self.title, information))        
-
-    @property
-    def rect(self):
-        geo = self.__window_information()["geometry"]
-        return Rect(geo['x'], geo['y'], geo['width'], geo['height'])
-
-    @property
-    def frame_rect(self):
-        geo = self.__window_information()["frameGeometry"]
-        return Rect(geo['x'], geo['y'], geo['width'], geo['height'])
-
-    @property
-    def events(self):
-        events = self.driver.execute_script(
-            f'''
-                return testSupport.events();
-            '''
-        )
-        return [*filter(lambda e: e['windowTitle'] == self.title, events)]
-
-    def set_visible(self, visible):
-        info = self.__window_information()
-        self.driver.execute_script(
-            f'''instance.setWindowVisible({info['id']}, {'true' if visible else 'false'});''')
-
-    def drag(self, handle, direction):
-        ActionChains(self.driver)                                                        \
-            .move_to_element_with_offset(self.element, *self.at(handle)['offset'])       \
-            .click_and_hold()                                                            \
-            .move_by_offset(*translate_direction_to_offset(direction))                   \
-            .release().perform()
-
-    def maximize(self):
-        maximize_button = self.element.find_element(
-            By.CSS_SELECTOR, f'.title-bar :nth-child(6)')
-        maximize_button.click()
-
-    def at(self, handle):
-        """ Returns (window, offset) for given handle on window"""
-        width = self.frame_rect.width
-        height = self.frame_rect.height
-
-        if handle == Handle.TOP_LEFT:
-            offset = (-width/2, -height/2)
-        elif handle == Handle.TOP:
-            offset = (0, -height/2)
-        elif handle == Handle.TOP_RIGHT:
-            offset = (width/2, -height/2)
-        elif handle == Handle.LEFT:
-            offset = (-width/2, 0)
-        elif handle == Handle.RIGHT:
-            offset = (width/2, 0)
-        elif handle == Handle.BOTTOM_LEFT:
-            offset = (-width/2, height/2)
-        elif handle == Handle.BOTTOM:
-            offset = (0, height/2)
-        elif handle == Handle.BOTTOM_RIGHT:
-            offset = (width/2, height/2)
-        elif handle == Handle.TOP_WINDOW_BAR:
-            frame_top = self.frame_rect.y
-            client_area_top = self.rect.y
-            top_frame_bar_width = client_area_top - frame_top
-            offset = (0, -height/2 + top_frame_bar_width/2)
-        return {'window': self, 'offset': offset}
-
-    @property
-    def bounding_box(self):
-        raw = self.driver.execute_script("""
-            return arguments[0].getBoundingClientRect();
-            """, self.element)
-        return Rect(raw['x'], raw['y'], raw['width'], raw['height'])
-
-    @property
-    def active(self):
-        return not self.inactive
-        # self.assertFalse('inactive' in window_element.get_attribute(
-        #     'class').split(' '), window_element.get_attribute('id'))
-
-    @property
-    def inactive(self):
-        window_chain = [
-            *self.element.find_elements(By.XPATH, "ancestor::div"), self.element]
-        return next(filter(lambda elem: 'qt-window' in elem.get_attribute('class').split(' ') and
-                           'inactive' in elem.get_attribute(
-                               'class').split(' '),
-                           window_chain
-                           ), None) is not None
-
-    def click(self, x, y):
-        rect = self.bounding_box
-
-        SELENIUM_IMPRECISION_COMPENSATION = 2
-        ActionChains(self.driver).move_to_element(
-            self.element).move_by_offset(-rect.width / 2 + x + SELENIUM_IMPRECISION_COMPENSATION,
-                                         -rect.height / 2 + y + SELENIUM_IMPRECISION_COMPENSATION).click().perform()
-
-    def set_parent(self, parent):
-        if isinstance(parent, Screen):
-            # TODO won't work with screen that is not parent.screen
-            self.screen = parent
-            self.driver.execute_script(
-                f'''
-                    instance.setWindowParent('{self.title}', 'none');
-                '''
-            )
-        else:
-            assert(isinstance(parent, Window))
-            self.screen = parent.screen
-            self.driver.execute_script(
-                f'''
-                    instance.setWindowParent('{self.title}', '{parent.title}');
-                '''
-            )
-
-    def close(self):
-        self.driver.execute_script(
-            f'''
-                instance.closeWindow('{self.title}');
-            '''
-        )
-
-    def color_at(self, x, y):
-        raw = self.driver.execute_script(
-            f'''
-                return arguments[0].querySelector('canvas')
-                    .getContext('2d').getImageData({x}, {y}, 1, 1).data;
-            ''', self.element)
-        return Color(r=raw[0], g=raw[1], b=raw[2])
-
-    def set_background_color(self, color):
-        return self.driver.execute_script(
-            f'''
-                return instance.setWindowBackgroundColor('{self.title}', {color.r}, {color.g}, {color.b});
-            '''
-        )
-
-
-class TouchDragAction:
-    def __init__(self, origin, direction):
-        self.origin = origin
-        self.direction = direction
-        self.step = 2
-
-
-def perform_touch_drag_actions(actions):
-    driver = actions[0].origin['window'].driver
-    touch_action_builder = ActionBuilder(driver)
-    pointers = [PointerActions(source=touch_action_builder.add_pointer_input(
-        POINTER_TOUCH, f'touch_input_{i}')) for i in range(len(actions))]
-
-    for action, pointer in zip(actions, pointers):
-        pointer.move_to(
-            action.origin['window'].element, *action.origin['offset'])
-        pointer.pointer_down(width=10, height=10, pressure=1)
-    moves = [translate_direction_to_offset(a.direction) for a in actions]
-
-    def movement_finished():
-        for move in moves:
-            if move != (0, 0):
-                return False
-        return True
-
-    def sign(num):
-        if num > 0:
-            return 1
-        elif num < 0:
-            return -1
-        return 0
-
-    while not movement_finished():
-        for i in range(len(actions)):
-            pointer = pointers[i]
-            move = moves[i]
-            step = actions[i].step
-
-            current_move = (
-                min(abs(move[0]), step) * sign(move[0]), min(abs(move[1]), step) * sign(move[1]))
-            moves[i] = (move[0] - current_move[0], move[1] - current_move[1])
-            pointer.move_by(current_move[0],
-                            current_move[1], width=10, height=10)
-    for pointer in pointers:
-        pointer.pointer_up()
-
-    touch_action_builder.perform()
-
-
-class TouchDragAction:
-    def __init__(self, origin, direction):
-        self.origin = origin
-        self.direction = direction
-        self.step = 2
-
-
-def perform_touch_drag_actions(actions):
-    driver = actions[0].origin['window'].driver
-    touch_action_builder = ActionBuilder(driver)
-    pointers = [PointerActions(source=touch_action_builder.add_pointer_input(
-        POINTER_TOUCH, f'touch_input_{i}')) for i in range(len(actions))]
-
-    for action, pointer in zip(actions, pointers):
-        pointer.move_to(
-            action.origin['window'].element, *action.origin['offset'])
-        pointer.pointer_down(width=10, height=10, pressure=1)
-
-    moves = [translate_direction_to_offset(a.direction) for a in actions]
-
-    def movement_finished():
-        for move in moves:
-            if move != (0, 0):
-                return False
-        return True
-
-    def sign(num):
-        if num > 0:
-            return 1
-        elif num < 0:
-            return -1
-        return 0
-
-    while not movement_finished():
-        for i in range(len(actions)):
-            pointer = pointers[i]
-            move = moves[i]
-            step = actions[i].step
-
-            current_move = (
-                min(abs(move[0]), step) * sign(move[0]), min(abs(move[1]), step) * sign(move[1]))
-            moves[i] = (move[0] - current_move[0], move[1] - current_move[1])
-            pointer.move_by(current_move[0],
-                            current_move[1], width=10, height=10)
-
-    for pointer in pointers:
-        pointer.pointer_up()
-
-    touch_action_builder.perform()
-
-
-def translate_direction_to_offset(direction):
-    return (direction.val[1] - direction.val[3], direction.val[2] - direction.val[0])
-
-
-def call_instance_function(driver, name):
-    return driver.execute_script(
-        f'''let result;
-            window.{name}Callback = data => result = data;
-            instance.{name}();
-            return eval(result);''')
-
-def wait_for_animation_frame(driver):
-    driver.execute_script(
-        '''
-            window.requestAnimationFrame(() => {
-                const sync = document.createElement('div');
-                sync.id = 'test-sync';
-                document.body.appendChild(sync);
-            });
-        '''
-    )
-    WebDriverWait(driver, 1).until(
-        presence_of_element_located((By.ID, 'test-sync'))
-    )
-    driver.execute_script(
-        '''
-            document.body.removeChild(document.body.querySelector('#test-sync'));
-        '''
-    )
-
-class Direction:
-    def __init__(self):
-        self.val = (0, 0, 0, 0)
-
-    def __init__(self, north, east, south, west):
-        self.val = (north, east, south, west)
-
-    def __add__(self, other):
-        return Direction(self.val[0] + other.val[0],
-                         self.val[1] + other.val[1],
-                         self.val[2] + other.val[2],
-                         self.val[3] + other.val[3])
-
-
-class UP(Direction):
-    def __init__(self, step=1):
-        self.val = (step, 0, 0, 0)
-
-
-class RIGHT(Direction):
-    def __init__(self, step=1):
-        self.val = (0, step, 0, 0)
-
-
-class DOWN(Direction):
-    def __init__(self, step=1):
-        self.val = (0, 0, step, 0)
-
-
-class LEFT(Direction):
-    def __init__(self, step=1):
-        self.val = (0, 0, 0, step)
-
-
-class Handle(Enum):
-    TOP_LEFT = auto()
-    TOP = auto()
-    TOP_RIGHT = auto()
-    LEFT = auto()
-    RIGHT = auto()
-    BOTTOM_LEFT = auto()
-    BOTTOM = auto()
-    BOTTOM_RIGHT = auto()
-    TOP_WINDOW_BAR = auto()
-
-class Color:
-    def __init__(self, r, g, b):
-        self.r = r
-        self.g = g
-        self.b = b
-
-class Rect:
-    def __init__(self, x, y, width, height) -> None:
-        self.x = x
-        self.y = y
-        self.width = width
-        self.height = height
-
-    def __str__(self):
-        return f'(x: {self.x}, y: {self.y}, width: {self.width}, height: {self.height})'
-
-    @property
-    def center(self):
-        return self.x + self.width / 2, self.y + self.height / 2,
-
-def assert_colors_equal(color1, color2, msg=None):
-    if color1.r != color2.r or color1.g != color2.g or color1.b != color2.b:
-        raise AssertionError(f'Colors not equal: \n{color1} \nvs \n{color2}')
-
-def assert_rects_equal(geo1, geo2, msg=None):
-    if geo1.x != geo2.x or geo1.y != geo2.y or geo1.width != geo2.width or geo1.height != geo2.height:
-        raise AssertionError(f'Rectangles not equal: \n{geo1} \nvs \n{geo2}')
-
-unittest.main()
diff --git a/tests/manual/wasm/selenium/qwasmwindow/qwasmwindow_harness.cpp b/tests/manual/wasm/selenium/qwasmwindow/qwasmwindow_harness.cpp
deleted file mode 100644
index b1624822930..00000000000
--- a/tests/manual/wasm/selenium/qwasmwindow/qwasmwindow_harness.cpp
+++ /dev/null
@@ -1,270 +0,0 @@
-// Copyright (C) 2022 The Qt Company Ltd.
-// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
-
-#include <QtCore/QEvent>
-
-#include <QtGui/qevent.h>
-#include <QtCore/qobject.h>
-#include <QtCore/qregularexpression.h>
-#include <QtGui/qpainter.h>
-#include <QtGui/qrasterwindow.h>
-#include <QtGui/qscreen.h>
-#include <QtGui/qwindow.h>
-#include <QtGui/qguiapplication.h>
-
-#include <emscripten.h>
-#include <emscripten/bind.h>
-#include <emscripten/val.h>
-
-#include <memory>
-#include <sstream>
-#include <vector>
-
-class TestWindow : public QRasterWindow
-{
-    Q_OBJECT
-
-public:
-    void setBackgroundColor(int r, int g, int b)
-    {
-        m_backgroundColor = QColor::fromRgb(r, g, b);
-        update();
-    }
-
-private:
-    void closeEvent(QCloseEvent *ev) override
-    {
-        Q_UNUSED(ev);
-        delete this;
-    }
-
-    void keyPressEvent(QKeyEvent *event) final
-    {
-        auto data = emscripten::val::object();
-        data.set("type", emscripten::val("keyPress"));
-        data.set("windowId", emscripten::val(winId()));
-        data.set("windowTitle", emscripten::val(title().toStdString()));
-        data.set("key", emscripten::val(event->text().toStdString()));
-        emscripten::val::global("window")["testSupport"].call<void>("reportEvent", std::move(data));
-    }
-
-    void keyReleaseEvent(QKeyEvent *event) final
-    {
-        auto data = emscripten::val::object();
-        data.set("type", emscripten::val("keyRelease"));
-        data.set("windowId", emscripten::val(winId()));
-        data.set("windowTitle", emscripten::val(title().toStdString()));
-        data.set("key", emscripten::val(event->text().toStdString()));
-        emscripten::val::global("window")["testSupport"].call<void>("reportEvent", std::move(data));
-    }
-
-    void paintEvent(QPaintEvent *e) final
-    {
-        QPainter painter(this);
-        painter.fillRect(e->rect(), m_backgroundColor);
-    }
-
-    QColor m_backgroundColor = Qt::white;
-};
-
-namespace {
-TestWindow *findWindowByTitle(const std::string &title)
-{
-    auto windows = qGuiApp->allWindows();
-    auto window_it = std::find_if(windows.begin(), windows.end(), [&title](QWindow *window) {
-        return window->title() == QString::fromLatin1(title);
-    });
-    return window_it == windows.end() ? nullptr : static_cast<TestWindow *>(*window_it);
-}
-} // namespace
-
-using namespace emscripten;
-
-std::string toJSArray(const std::vector<std::string> &elements)
-{
-    std::ostringstream out;
-    out << "[";
-    bool comma = false;
-    for (const auto &element : elements) {
-        out << (comma ? "," : "");
-        out << element;
-        comma = true;
-    }
-    out << "]";
-    return out.str();
-}
-
-std::string toJSString(const QString &qstring)
-{
-    Q_ASSERT_X(([qstring]() {
-                   static QRegularExpression unescapedQuoteRegex(R"re((?:^|[^\\])')re");
-                   return qstring.indexOf(unescapedQuoteRegex) == -1;
-               })(),
-               Q_FUNC_INFO, "Unescaped single quotes found");
-    return "'" + qstring.toStdString() + "'";
-}
-
-std::string rectToJSObject(const QRect &rect)
-{
-    std::ostringstream out;
-    out << "{"
-        << "  x: " << std::to_string(rect.x()) << ","
-        << "  y: " << std::to_string(rect.y()) << ","
-        << "  width: " << std::to_string(rect.width()) << ","
-        << "  height: " << std::to_string(rect.height()) << "}";
-    return out.str();
-}
-
-std::string screenToJSObject(const QScreen &screen)
-{
-    std::ostringstream out;
-    out << "{"
-        << "  name: " << toJSString(screen.name()) << ","
-        << "  geometry: " << rectToJSObject(screen.geometry()) << "}";
-    return out.str();
-}
-
-std::string windowToJSObject(const QWindow &window)
-{
-    std::ostringstream out;
-    out << "{"
-        << "  id: " << std::to_string(window.winId()) << ","
-        << "  geometry: " << rectToJSObject(window.geometry()) << ","
-        << "  frameGeometry: " << rectToJSObject(window.frameGeometry()) << ","
-        << "  screen: " << screenToJSObject(*window.screen()) << ","
-        << "  title: '" << window.title().toStdString() << "' }";
-    return out.str();
-}
-
-void windowInformation()
-{
-    auto windows = qGuiApp->allWindows();
-
-    std::vector<std::string> windowsAsJsObjects;
-    windowsAsJsObjects.reserve(windows.size());
-    std::transform(windows.begin(), windows.end(), std::back_inserter(windowsAsJsObjects),
-                   [](const QWindow *window) { return windowToJSObject(*window); });
-
-    emscripten::val::global("window").call<void>("windowInformationCallback",
-                                                 emscripten::val(toJSArray(windowsAsJsObjects)));
-}
-
-void screenInformation()
-{
-    auto screens = qGuiApp->screens();
-
-    std::vector<std::string> screensAsJsObjects;
-    screensAsJsObjects.reserve(screens.size());
-    std::transform(screens.begin(), screens.end(), std::back_inserter(screensAsJsObjects),
-                   [](const QScreen *screen) { return screenToJSObject(*screen); });
-    emscripten::val::global("window").call<void>("screenInformationCallback",
-                                                 emscripten::val(toJSArray(screensAsJsObjects)));
-}
-
-void createWindow(int x, int y, int w, int h, std::string parentType, std::string parentId,
-                  std::string title)
-{
-    QScreen *parentScreen = nullptr;
-    QWindow *parentWindow = nullptr;
-    if (parentType == "screen") {
-        auto screens = qGuiApp->screens();
-        auto screen_it = std::find_if(screens.begin(), screens.end(), [&parentId](QScreen *screen) {
-            return screen->name() == QString::fromLatin1(parentId);
-        });
-        if (screen_it == screens.end()) {
-            qWarning() << "No such screen: " << parentId;
-            return;
-        }
-        parentScreen = *screen_it;
-    } else if (parentType == "window") {
-        auto windows = qGuiApp->allWindows();
-        auto window_it = std::find_if(windows.begin(), windows.end(), [&parentId](QWindow *window) {
-            return window->title() == QString::fromLatin1(parentId);
-        });
-        if (window_it == windows.end()) {
-            qWarning() << "No such window: " << parentId;
-            return;
-        }
-        parentWindow = *window_it;
-        parentScreen = parentWindow->screen();
-    } else {
-        qWarning() << "Wrong parent type " << parentType;
-        return;
-    }
-
-    auto *window = new TestWindow;
-
-    window->setFlag(Qt::WindowTitleHint);
-    window->setFlag(Qt::WindowMaximizeButtonHint);
-    window->setTitle(QString::fromLatin1(title));
-    window->setGeometry(x, y, w, h);
-    window->setScreen(parentScreen);
-    window->setParent(parentWindow);
-}
-
-void setWindowBackgroundColor(std::string title, int r, int g, int b)
-{
-    auto *window = findWindowByTitle(title);
-    if (!window) {
-        qWarning() << "No such window: " << title;
-        return;
-    }
-    window->setBackgroundColor(r, g, b);
-}
-
-void setWindowVisible(int windowId, bool visible) {
-    auto windows = qGuiApp->allWindows();
-    auto window_it = std::find_if(windows.begin(), windows.end(), [windowId](QWindow *window) {
-        return window->winId() == WId(windowId);
-    });
-    if (window_it == windows.end()) {
-        qWarning() << "No such window: " << windowId;
-        return;
-    }
-
-    (*window_it)->setVisible(visible);
-}
-
-void setWindowParent(std::string windowTitle, std::string parentTitle)
-{
-    QWindow *window = findWindowByTitle(windowTitle);
-    if (!window) {
-        qWarning() << "Window could not be found " << parentTitle;
-        return;
-    }
-    QWindow *parent = nullptr;
-    if (parentTitle != "none") {
-        if ((parent = findWindowByTitle(parentTitle)) == nullptr) {
-            qWarning() << "Parent window could not be found " << parentTitle;
-            return;
-        }
-    }
-    window->setParent(parent);
-}
-
-bool closeWindow(std::string title)
-{
-    QWindow *window = findWindowByTitle(title);
-    return window ? window->close() : false;
-}
-
-EMSCRIPTEN_BINDINGS(qwasmwindow)
-{
-    emscripten::function("screenInformation", &screenInformation);
-    emscripten::function("windowInformation", &windowInformation);
-    emscripten::function("createWindow", &createWindow);
-    emscripten::function("setWindowVisible", &setWindowVisible);
-    emscripten::function("setWindowParent", &setWindowParent);
-    emscripten::function("closeWindow", &closeWindow);
-    emscripten::function("setWindowBackgroundColor", &setWindowBackgroundColor);
-}
-
-int main(int argc, char **argv)
-{
-    QGuiApplication app(argc, argv);
-
-    app.exec();
-    return 0;
-}
-
-#include "qwasmwindow_harness.moc"
diff --git a/tests/manual/wasm/selenium/qwasmwindow/qwasmwindow_harness.html b/tests/manual/wasm/selenium/qwasmwindow/qwasmwindow_harness.html
deleted file mode 100644
index 3e63e52e04b..00000000000
--- a/tests/manual/wasm/selenium/qwasmwindow/qwasmwindow_harness.html
+++ /dev/null
@@ -1,80 +0,0 @@
-<!doctype html>
-
-<head>
-    <script type="text/javascript" src="qwasmwindow_harness.js"></script>
-    <script>
-        (async () => {
-            const instance = await qwasmwindow_harness_entry({});
-            window.instance = instance;
-
-            const testSandbox = document.createElement('div');
-            testSandbox.id = 'test-sandbox';
-            let nextScreenId = 1;
-            document.body.appendChild(testSandbox);
-
-            const eventList = [];
-
-            const makeSizedDiv = (left, top, width, height) => {
-                const screenDiv = document.createElement('div');
-
-                screenDiv.style.left = `${left}px`;
-                screenDiv.style.top = `${top}px`;
-                screenDiv.style.width = `${width}px`;
-                screenDiv.style.height = `${height}px`;
-                screenDiv.style.backgroundColor = 'lightblue';
-                screenDiv.id = `test-screen-${nextScreenId++}`;
-
-                return screenDiv;
-            };
-
-            window.testSupport = {
-                initializeScreenWithFixedPosition: (left, top, width, height) => {
-                    const screenDiv = makeSizedDiv(left, top, width, height);
-                    testSandbox.appendChild(screenDiv);
-
-                    screenDiv.style.position = 'fixed';
-                    instance.qtAddContainerElement(screenDiv);
-
-                    return screenDiv;
-                },
-                initializeScreenWithRelativePosition: (left, top, width, height) => {
-                    const screenDiv = makeSizedDiv(left, top, width, height);
-                    testSandbox.appendChild(screenDiv);
-
-                    screenDiv.style.position = 'relative';
-                    instance.qtAddContainerElement(screenDiv);
-
-                    return screenDiv;
-                },
-                initializeScreenInScrollContainer:
-                    (scrollWidth, scrollHeight, left, top, width, height) => {
-                        const scrollContainer = document.createElement('div');
-                        scrollContainer.style.height = `${scrollHeight}px`;
-                        scrollContainer.style.width = `${scrollWidth}px`;
-                        testSandbox.appendChild(scrollContainer);
-
-                        const screenDiv = makeSizedDiv(left, top, width, height);
-                        scrollContainer.appendChild(screenDiv);
-                        screenDiv.style.position = 'relative';
-
-                        instance.qtAddContainerElement(screenDiv);
-
-                        return [scrollContainer, screenDiv];
-                    },
-                reportEvent: event => {
-                    eventList.push(event);
-                },
-                events: () => eventList,
-                hitTestPoint: (x, y, screenId) => {
-                    return document
-                        .querySelector(`#${screenId}`)
-                        .querySelector('#qt-shadow-container')
-                        .shadowRoot.elementsFromPoint(x, y);
-                }
-            };
-        })();
-    </script>
-</head>
-
-<body>
-</body>
diff --git a/tests/manual/wasm/selenium/qwasmwindow/run.sh b/tests/manual/wasm/selenium/qwasmwindow/run.sh
deleted file mode 100755
index f6271d6131a..00000000000
--- a/tests/manual/wasm/selenium/qwasmwindow/run.sh
+++ /dev/null
@@ -1,23 +0,0 @@
-#! /bin/bash
-
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
-
-set -m
-
-function removeServer()
-{
-    [ -z "$cleanupPid" ] || kill $cleanupPid
-}
-
-trap removeServer EXIT
-
-script_dir=`dirname ${BASH_SOURCE[0]}`
-cd "$script_dir"
-python3 qtwasmserver.py -p 8001 > /dev/null 2>&1 &
-cleanupPid=$!
-
-python3 qwasmwindow.py $@
-
-echo 'Press any key to continue...' >&2
-read -n 1