qt 6.5.1 original

tests/auto/wasm/CMakeLists.txt

@@ -0,0 +1,42 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+#####################################################################
+## tst_wasm Test:
+#####################################################################
+
+qt_internal_add_test(tst_localfileapi
+    SOURCES
+        tst_localfileapi.cpp
+    DEFINES
+        QT_NO_FOREACH
+    LIBRARIES
+        Qt::GuiPrivate
+        Qt::Core
+        Qt::Gui
+        Qt::Widgets
+)
+
+qt_internal_add_test(tst_qwasmwindowstack
+    SOURCES
+        tst_qwasmwindowstack.cpp
+    DEFINES
+        QT_NO_FOREACH
+    LIBRARIES
+        Qt::GuiPrivate
+    PUBLIC_LIBRARIES
+        Qt::Core
+        Qt::Gui
+        Qt::Widgets
+)
+
+qt_internal_add_test(tst_qwasmkeytranslator
+    SOURCES
+        tst_qwasmkeytranslator.cpp
+    DEFINES
+        QT_NO_FOREACH
+    LIBRARIES
+        Qt::GuiPrivate
+    PUBLIC_LIBRARIES
+        Qt::Core
+)

tests/auto/wasm/tst_localfileapi.cpp

@@ -0,0 +1,221 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// Copyright (C) 2016 Intel Corporation.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include <QtGui/private/qlocalfileapi_p.h>
+#include <QTest>
+#include <emscripten/val.h>
+
+class tst_LocalFileApi : public QObject
+{
+    Q_OBJECT
+
+private:
+    emscripten::val makeAccept(std::vector<emscripten::val> types) {
+        auto accept = emscripten::val::object();
+        accept.set("application/octet-stream",
+            emscripten::val::array(std::move(types)));
+        return accept;
+    }
+
+    emscripten::val makeType(QString description, std::vector<emscripten::val> acceptExtensions) {
+        using namespace emscripten;
+
+        auto type = val::object();
+        type.set("description", description.toStdString());
+
+        auto accept = val::object();
+        accept.set("application/octet-stream",
+            val::array(std::move(acceptExtensions)));
+        type.set("accept", makeAccept(std::move(acceptExtensions)));
+
+        return type;
+    }
+
+    emscripten::val makeOpenFileOptions(bool acceptMultiple, std::vector<emscripten::val> types) {
+        using namespace emscripten;
+
+        auto webFilter = val::object();
+        webFilter.set("types", val::array(std::move(types)));
+        if (!types.empty())
+            webFilter.set("excludeAcceptAllOption", val(true));
+        webFilter.set("multiple", val(acceptMultiple));
+
+        return webFilter;
+    }
+
+    emscripten::val makeSaveFileOptions(QString suggestedName, std::vector<emscripten::val> types) {
+        using namespace emscripten;
+
+        auto webFilter = val::object();
+        webFilter.set("suggestedName", val(suggestedName.toStdString()));
+        webFilter.set("types", val::array(std::move(types)));
+
+        return webFilter;
+    }
+
+private Q_SLOTS:
+    void fileExtensionFilterTransformation_data();
+    void fileExtensionFilterTransformation();
+    void acceptTransformation_data();
+    void acceptTransformation();
+    void typeTransformation_data();
+    void typeTransformation();
+    void openFileOptions_data();
+    void openFileOptions();
+    void saveFileOptions_data();
+    void saveFileOptions();
+};
+
+bool valDeepEquals(emscripten::val lhs, emscripten::val rhs)
+{
+    auto json = emscripten::val::global("JSON");
+    auto lhsAsJsonString = json.call<emscripten::val>("stringify", lhs);
+    auto rhsAsJsonString = json.call<emscripten::val>("stringify", rhs);
+
+    return lhsAsJsonString.equals(rhsAsJsonString);
+}
+
+void tst_LocalFileApi::fileExtensionFilterTransformation_data()
+{
+    QTest::addColumn<QString>("qtFileFilter");
+    QTest::addColumn<std::optional<std::string>>("expectedWebExtensionFilter");
+
+    QTest::newRow("PNG extension with an asterisk") << QString("*.png") << std::make_optional<std::string>(".png");
+    QTest::newRow("Long extension with an asterisk") << QString("*.someotherfile") << std::make_optional<std::string>(".someotherfile");
+    QTest::newRow(".dat with no asterisk") << QString(".dat") << std::make_optional<std::string>(".dat");
+    QTest::newRow("Multiple asterisks") << QString("*ot*.abc") << std::optional<std::string>();
+    QTest::newRow("Filename") << QString("abcd.abc") << std::optional<std::string>();
+    QTest::newRow("match all") << QString("*.*") << std::optional<std::string>();
+}
+
+void tst_LocalFileApi::fileExtensionFilterTransformation()
+{
+    QFETCH(QString, qtFileFilter);
+    QFETCH(std::optional<std::string>, expectedWebExtensionFilter);
+
+    auto result = LocalFileApi::Type::Accept::MimeType::Extension::fromQt(qtFileFilter);
+    if (expectedWebExtensionFilter) {
+        QCOMPARE_EQ(expectedWebExtensionFilter, result->asVal().as<std::string>());
+    } else {
+        QVERIFY(!result.has_value());
+    }
+}
+
+void tst_LocalFileApi::acceptTransformation_data()
+{
+    using namespace emscripten;
+
+    QTest::addColumn<QString>("qtFilterList");
+    QTest::addColumn<emscripten::val>("expectedWebType");
+
+    QTest::newRow("Multiple types") << QString("*.png *.other *.txt")
+        << makeAccept(std::vector<val> { val(".png"), val(".other"), val(".txt") });
+
+    QTest::newRow("Single type") << QString("*.png")
+        << makeAccept(std::vector<val> { val(".png") });
+
+    QTest::newRow("No filter when accepts all") << QString("*.*")
+        << val::undefined();
+
+    QTest::newRow("No filter when one filter accepts all") << QString("*.* *.jpg")
+        << val::undefined();
+
+    QTest::newRow("Weird spaces") << QString("    *.jpg     *.png *.icon  ")
+        << makeAccept(std::vector<val> { val(".jpg"), val(".png"), val(".icon") });
+}
+
+void tst_LocalFileApi::acceptTransformation()
+{
+    QFETCH(QString, qtFilterList);
+    QFETCH(emscripten::val, expectedWebType);
+
+    auto result = LocalFileApi::Type::Accept::fromQt(qtFilterList);
+    if (!expectedWebType.isUndefined()) {
+        QVERIFY(valDeepEquals(result->asVal(), expectedWebType));
+    } else {
+        QVERIFY(!result.has_value());
+    }
+}
+
+void tst_LocalFileApi::typeTransformation_data()
+{
+    using namespace emscripten;
+
+    QTest::addColumn<QString>("qtFilterList");
+    QTest::addColumn<emscripten::val>("expectedWebType");
+
+    QTest::newRow("With description") << QString("Text files (*.txt)")
+        << makeType("Text files", std::vector<val> { val(".txt") });
+
+    QTest::newRow("No description") << QString("*.jpg")
+        << makeType("", std::vector<val> { val(".jpg") });
+}
+
+void tst_LocalFileApi::typeTransformation()
+{
+    QFETCH(QString, qtFilterList);
+    QFETCH(emscripten::val, expectedWebType);
+
+    auto result = LocalFileApi::Type::fromQt(qtFilterList);
+    if (!expectedWebType.isUndefined()) {
+        QVERIFY(valDeepEquals(result->asVal(), expectedWebType));
+    } else {
+        QVERIFY(!result.has_value());
+    }
+}
+
+void tst_LocalFileApi::openFileOptions_data()
+{
+    using namespace emscripten;
+
+    QTest::addColumn<QStringList>("qtFilterList");
+    QTest::addColumn<bool>("multiple");
+    QTest::addColumn<emscripten::val>("expectedWebType");
+
+    QTest::newRow("Multiple files") << QStringList({"Text files (*.txt)", "Images (*.jpg *.png)", "*.bat"})
+        << true
+        << makeOpenFileOptions(true, { makeType("Text files", { val(".txt")}), makeType("Images", { val(".jpg"), val(".png")}), makeType("", { val(".bat")})});
+    QTest::newRow("Single file") << QStringList({"Text files (*.txt)", "Images (*.jpg *.png)", "*.bat"})
+        << false
+        << makeOpenFileOptions(false, { makeType("Text files", { val(".txt")}), makeType("Images", { val(".jpg"), val(".png")}), makeType("", { val(".bat")})});
+}
+
+void tst_LocalFileApi::openFileOptions()
+{
+    QFETCH(QStringList, qtFilterList);
+    QFETCH(bool, multiple);
+    QFETCH(emscripten::val, expectedWebType);
+
+    auto result = LocalFileApi::makeOpenFileOptions(qtFilterList, multiple);
+    QVERIFY(valDeepEquals(result, expectedWebType));
+}
+
+void tst_LocalFileApi::saveFileOptions_data()
+{
+    using namespace emscripten;
+
+    QTest::addColumn<QStringList>("qtFilterList");
+    QTest::addColumn<QString>("suggestedName");
+    QTest::addColumn<emscripten::val>("expectedWebType");
+
+    QTest::newRow("Multiple files") << QStringList({"Text files (*.txt)", "Images (*.jpg *.png)", "*.bat"})
+        << "someName1"
+        << makeSaveFileOptions("someName1", { makeType("Text files", { val(".txt")}), makeType("Images", { val(".jpg"), val(".png")}), makeType("", { val(".bat")})});
+    QTest::newRow("Single file") << QStringList({"Text files (*.txt)", "Images (*.jpg *.png)", "*.bat"})
+        << "some name 2"
+        << makeSaveFileOptions("some name 2", { makeType("Text files", { val(".txt")}), makeType("Images", { val(".jpg"), val(".png")}), makeType("", { val(".bat")})});
+}
+
+void tst_LocalFileApi::saveFileOptions()
+{
+    QFETCH(QStringList, qtFilterList);
+    QFETCH(QString, suggestedName);
+    QFETCH(emscripten::val, expectedWebType);
+
+    auto result = LocalFileApi::makeSaveFileOptions(qtFilterList, suggestedName.toStdString());
+    QVERIFY(valDeepEquals(result, expectedWebType));
+}
+
+QTEST_APPLESS_MAIN(tst_LocalFileApi)
+#include "tst_localfileapi.moc"

tests/auto/wasm/tst_qwasmkeytranslator.cpp

@@ -0,0 +1,425 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "../../../src/plugins/platforms/wasm/qwasmkeytranslator.h"
+
+#include "../../../src/plugins/platforms/wasm/qwasmevent.h"
+
+#include <QTest>
+
+#include <emscripten/val.h>
+
+namespace {
+emscripten::val makeDeadKeyJsEvent(QString code, Qt::KeyboardModifiers modifiers)
+{
+    auto jsEvent = emscripten::val::object();
+    jsEvent.set("code", emscripten::val(code.toStdString()));
+    jsEvent.set("key", emscripten::val("Dead"));
+    jsEvent.set("shiftKey", emscripten::val(modifiers.testFlag(Qt::ShiftModifier)));
+    jsEvent.set("ctrlKey", emscripten::val(false));
+    jsEvent.set("altKey", emscripten::val(false));
+    jsEvent.set("metaKey", emscripten::val(false));
+
+    return jsEvent;
+}
+
+emscripten::val makeKeyJsEvent(QString code, QString key, Qt::KeyboardModifiers modifiers)
+{
+    auto jsEvent = emscripten::val::object();
+    jsEvent.set("code", emscripten::val(code.toStdString()));
+    jsEvent.set("key", emscripten::val(key.toStdString()));
+    jsEvent.set("shiftKey", emscripten::val(modifiers.testFlag(Qt::ShiftModifier)));
+    jsEvent.set("ctrlKey", emscripten::val(modifiers.testFlag(Qt::ControlModifier)));
+    jsEvent.set("altKey", emscripten::val(modifiers.testFlag(Qt::AltModifier)));
+    jsEvent.set("metaKey", emscripten::val(modifiers.testFlag(Qt::MetaModifier)));
+
+    return jsEvent;
+}
+} // unnamed namespace
+
+class tst_QWasmKeyTranslator : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QWasmKeyTranslator() = default;
+
+private slots:
+    void init();
+
+    void modifyByDeadKey_data();
+    void modifyByDeadKey();
+    void deadKeyModifiesOnlyOneKeyPressAndUp();
+    void deadKeyIgnoresKeyUpPrecedingKeyDown();
+    void onlyKeysProducingTextAreModifiedByDeadKeys();
+};
+
+void tst_QWasmKeyTranslator::init() { }
+
+void tst_QWasmKeyTranslator::modifyByDeadKey_data()
+{
+    QTest::addColumn<QString>("deadKeyCode");
+    QTest::addColumn<Qt::KeyboardModifiers>("deadKeyModifiers");
+    QTest::addColumn<QString>("targetKeyCode");
+    QTest::addColumn<QString>("targetKey");
+    QTest::addColumn<Qt::Key>("targetQtKey");
+    QTest::addColumn<Qt::KeyboardModifiers>("modifiers");
+    QTest::addColumn<QString>("expectedModifiedKey");
+
+    QTest::newRow("à (Backquote)") << "Backquote" << Qt::KeyboardModifiers() << "KeyA"
+                                   << "a" << Qt::Key_Agrave << Qt::KeyboardModifiers() << "à";
+    QTest::newRow("À (Backquote)")
+            << "Backquote" << Qt::KeyboardModifiers() << "KeyA"
+            << "A" << Qt::Key_Agrave << Qt::KeyboardModifiers(Qt::ShiftModifier) << "À";
+    QTest::newRow("à (IntlBackslash)") << "IntlBackslash" << Qt::KeyboardModifiers() << "KeyA"
+                                       << "a" << Qt::Key_Agrave << Qt::KeyboardModifiers() << "à";
+    QTest::newRow("À (IntlBackslash)")
+            << "IntlBackslash" << Qt::KeyboardModifiers() << "KeyA"
+            << "A" << Qt::Key_Agrave << Qt::KeyboardModifiers(Qt::ShiftModifier) << "À";
+    QTest::newRow("á (Quote)") << "Quote" << Qt::KeyboardModifiers() << "KeyA"
+                               << "a" << Qt::Key_Aacute << Qt::KeyboardModifiers() << "á";
+    QTest::newRow("Á (Quote)") << "Quote" << Qt::KeyboardModifiers() << "KeyA"
+                               << "A" << Qt::Key_Aacute << Qt::KeyboardModifiers(Qt::ShiftModifier)
+                               << "Á";
+    QTest::newRow("á") << "KeyE" << Qt::KeyboardModifiers() << "KeyA"
+                       << "a" << Qt::Key_Aacute << Qt::KeyboardModifiers() << "á";
+    QTest::newRow("Á") << "KeyE" << Qt::KeyboardModifiers() << "KeyA"
+                       << "A" << Qt::Key_Aacute << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Á";
+    QTest::newRow("ä (Mac Umlaut)") << "KeyU" << Qt::KeyboardModifiers() << "KeyA"
+                                    << "a" << Qt::Key_Adiaeresis << Qt::KeyboardModifiers() << "ä";
+    QTest::newRow("Ä (Mac Umlaut)")
+            << "KeyU" << Qt::KeyboardModifiers() << "KeyA"
+            << "A" << Qt::Key_Adiaeresis << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ä";
+    QTest::newRow("ä (Shift+Quote)")
+            << "Quote" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyA"
+            << "a" << Qt::Key_Adiaeresis << Qt::KeyboardModifiers() << "ä";
+    QTest::newRow("Ä (Shift+Quote)")
+            << "Quote" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyA"
+            << "A" << Qt::Key_Adiaeresis << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ä";
+    QTest::newRow("â") << "KeyI" << Qt::KeyboardModifiers() << "KeyA"
+                       << "a" << Qt::Key_Acircumflex << Qt::KeyboardModifiers() << "â";
+    QTest::newRow("Â") << "KeyI" << Qt::KeyboardModifiers() << "KeyA"
+                       << "A" << Qt::Key_Acircumflex << Qt::KeyboardModifiers(Qt::ShiftModifier)
+                       << "Â";
+    QTest::newRow("â (^ key)") << "Digit6" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyA"
+                               << "a" << Qt::Key_Acircumflex << Qt::KeyboardModifiers() << "â";
+    QTest::newRow("Â (^ key)") << "Digit6" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyA"
+                               << "A" << Qt::Key_Acircumflex
+                               << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Â";
+    QTest::newRow("ã") << "KeyN" << Qt::KeyboardModifiers() << "KeyA"
+                       << "a" << Qt::Key_Atilde << Qt::KeyboardModifiers() << "ã";
+    QTest::newRow("Ã") << "KeyN" << Qt::KeyboardModifiers() << "KeyA"
+                       << "A" << Qt::Key_Atilde << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ã";
+
+    QTest::newRow("è (Backquote)") << "Backquote" << Qt::KeyboardModifiers() << "KeyE"
+                                   << "e" << Qt::Key_Egrave << Qt::KeyboardModifiers() << "è";
+    QTest::newRow("È (Backquote)")
+            << "Backquote" << Qt::KeyboardModifiers() << "KeyE"
+            << "E" << Qt::Key_Egrave << Qt::KeyboardModifiers(Qt::ShiftModifier) << "È";
+    QTest::newRow("è") << "IntlBackslash" << Qt::KeyboardModifiers() << "KeyE"
+                       << "e" << Qt::Key_Egrave << Qt::KeyboardModifiers() << "è";
+    QTest::newRow("È") << "IntlBackslash" << Qt::KeyboardModifiers() << "KeyE"
+                       << "E" << Qt::Key_Egrave << Qt::KeyboardModifiers(Qt::ShiftModifier) << "È";
+    QTest::newRow("é") << "KeyE" << Qt::KeyboardModifiers() << "KeyE"
+                       << "e" << Qt::Key_Eacute << Qt::KeyboardModifiers() << "é";
+    QTest::newRow("É") << "KeyE" << Qt::KeyboardModifiers() << "KeyE"
+                       << "E" << Qt::Key_Eacute << Qt::KeyboardModifiers(Qt::ShiftModifier) << "É";
+    QTest::newRow("é (Quote)") << "Quote" << Qt::KeyboardModifiers() << "KeyE"
+                               << "e" << Qt::Key_Eacute << Qt::KeyboardModifiers() << "é";
+    QTest::newRow("É (Quote)") << "Quote" << Qt::KeyboardModifiers() << "KeyE"
+                               << "E" << Qt::Key_Eacute << Qt::KeyboardModifiers(Qt::ShiftModifier)
+                               << "É";
+    QTest::newRow("ë (Mac Umlaut)") << "KeyU" << Qt::KeyboardModifiers() << "KeyE"
+                                    << "e" << Qt::Key_Ediaeresis << Qt::KeyboardModifiers() << "ë";
+    QTest::newRow("Ë (Mac Umlaut)")
+            << "KeyU" << Qt::KeyboardModifiers() << "KeyE"
+            << "E" << Qt::Key_Ediaeresis << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ë";
+    QTest::newRow("ë (Shift+Quote)")
+            << "Quote" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyE"
+            << "e" << Qt::Key_Ediaeresis << Qt::KeyboardModifiers() << "ë";
+    QTest::newRow("Ë (Shift+Quote)")
+            << "Quote" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyE"
+            << "E" << Qt::Key_Ediaeresis << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ë";
+    QTest::newRow("ê") << "KeyI" << Qt::KeyboardModifiers() << "KeyE"
+                       << "e" << Qt::Key_Ecircumflex << Qt::KeyboardModifiers() << "ê";
+    QTest::newRow("Ê") << "KeyI" << Qt::KeyboardModifiers() << "KeyE"
+                       << "E" << Qt::Key_Ecircumflex << Qt::KeyboardModifiers(Qt::ShiftModifier)
+                       << "Ê";
+    QTest::newRow("ê (^ key)") << "Digit6" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyE"
+                               << "e" << Qt::Key_Ecircumflex << Qt::KeyboardModifiers() << "ê";
+    QTest::newRow("Ê (^ key)") << "Digit6" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyE"
+                               << "E" << Qt::Key_Ecircumflex
+                               << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ê";
+
+    QTest::newRow("ì (Backquote)") << "Backquote" << Qt::KeyboardModifiers() << "KeyI"
+                                   << "i" << Qt::Key_Igrave << Qt::KeyboardModifiers() << "ì";
+    QTest::newRow("Ì (Backquote)")
+            << "Backquote" << Qt::KeyboardModifiers() << "KeyI"
+            << "I" << Qt::Key_Igrave << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ì";
+    QTest::newRow("ì") << "IntlBackslash" << Qt::KeyboardModifiers() << "KeyI"
+                       << "i" << Qt::Key_Igrave << Qt::KeyboardModifiers() << "ì";
+    QTest::newRow("Ì") << "IntlBackslash" << Qt::KeyboardModifiers() << "KeyI"
+                       << "I" << Qt::Key_Igrave << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ì";
+    QTest::newRow("í") << "KeyE" << Qt::KeyboardModifiers() << "KeyI"
+                       << "i" << Qt::Key_Iacute << Qt::KeyboardModifiers() << "í";
+    QTest::newRow("Í") << "KeyE" << Qt::KeyboardModifiers() << "KeyI"
+                       << "I" << Qt::Key_Iacute << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Í";
+    QTest::newRow("í (Quote)") << "Quote" << Qt::KeyboardModifiers() << "KeyI"
+                               << "i" << Qt::Key_Iacute << Qt::KeyboardModifiers() << "í";
+    QTest::newRow("Í (Quote)") << "Quote" << Qt::KeyboardModifiers() << "KeyI"
+                               << "I" << Qt::Key_Iacute << Qt::KeyboardModifiers(Qt::ShiftModifier)
+                               << "Í";
+    QTest::newRow("ï (Mac Umlaut)") << "KeyU" << Qt::KeyboardModifiers() << "KeyI"
+                                    << "i" << Qt::Key_Idiaeresis << Qt::KeyboardModifiers() << "ï";
+    QTest::newRow("Ï (Mac Umlaut)")
+            << "KeyU" << Qt::KeyboardModifiers() << "KeyI"
+            << "I" << Qt::Key_Idiaeresis << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ï";
+    QTest::newRow("ï (Shift+Quote)")
+            << "Quote" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyI"
+            << "i" << Qt::Key_Idiaeresis << Qt::KeyboardModifiers() << "ï";
+    QTest::newRow("Ï (Shift+Quote)")
+            << "Quote" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyI"
+            << "I" << Qt::Key_Idiaeresis << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ï";
+    QTest::newRow("î") << "KeyI" << Qt::KeyboardModifiers() << "KeyI"
+                       << "i" << Qt::Key_Icircumflex << Qt::KeyboardModifiers() << "î";
+    QTest::newRow("Î") << "KeyI" << Qt::KeyboardModifiers() << "KeyI"
+                       << "I" << Qt::Key_Icircumflex << Qt::KeyboardModifiers(Qt::ShiftModifier)
+                       << "Î";
+    QTest::newRow("î (^ key)") << "Digit6" << Qt::KeyboardModifiers() << "KeyI"
+                               << "i" << Qt::Key_Icircumflex << Qt::KeyboardModifiers() << "î";
+    QTest::newRow("Î (^ key)") << "Digit6" << Qt::KeyboardModifiers() << "KeyI"
+                               << "I" << Qt::Key_Icircumflex
+                               << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Î";
+
+    QTest::newRow("ñ") << "KeyN" << Qt::KeyboardModifiers() << "KeyN"
+                       << "n" << Qt::Key_Ntilde << Qt::KeyboardModifiers() << "ñ";
+    QTest::newRow("Ñ") << "KeyN" << Qt::KeyboardModifiers() << "KeyN"
+                       << "N" << Qt::Key_Ntilde << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ñ";
+
+    QTest::newRow("ò (Backquote)") << "Backquote" << Qt::KeyboardModifiers() << "KeyO"
+                                   << "o" << Qt::Key_Ograve << Qt::KeyboardModifiers() << "ò";
+    QTest::newRow("Ò (Backquote)")
+            << "Backquote" << Qt::KeyboardModifiers() << "KeyO"
+            << "O" << Qt::Key_Ograve << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ò";
+    QTest::newRow("ò") << "IntlBackslash" << Qt::KeyboardModifiers() << "KeyO"
+                       << "o" << Qt::Key_Ograve << Qt::KeyboardModifiers() << "ò";
+    QTest::newRow("Ò") << "IntlBackslash" << Qt::KeyboardModifiers() << "KeyO"
+                       << "O" << Qt::Key_Ograve << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ò";
+    QTest::newRow("ó") << "KeyE" << Qt::KeyboardModifiers() << "KeyO"
+                       << "o" << Qt::Key_Oacute << Qt::KeyboardModifiers() << "ó";
+    QTest::newRow("Ó") << "KeyE" << Qt::KeyboardModifiers() << "KeyO"
+                       << "O" << Qt::Key_Oacute << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ó";
+    QTest::newRow("ó (Quote)") << "Quote" << Qt::KeyboardModifiers() << "KeyO"
+                               << "o" << Qt::Key_Oacute << Qt::KeyboardModifiers() << "ó";
+    QTest::newRow("Ó  (Quote)") << "Quote" << Qt::KeyboardModifiers() << "KeyO"
+                                << "O" << Qt::Key_Oacute << Qt::KeyboardModifiers(Qt::ShiftModifier)
+                                << "Ó";
+    QTest::newRow("ö (Mac Umlaut)") << "KeyU" << Qt::KeyboardModifiers() << "KeyO"
+                                    << "o" << Qt::Key_Odiaeresis << Qt::KeyboardModifiers() << "ö";
+    QTest::newRow("Ö (Mac Umlaut)")
+            << "KeyU" << Qt::KeyboardModifiers() << "KeyO"
+            << "O" << Qt::Key_Odiaeresis << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ö";
+    QTest::newRow("ö (Shift+Quote)")
+            << "Quote" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyO"
+            << "o" << Qt::Key_Odiaeresis << Qt::KeyboardModifiers() << "ö";
+    QTest::newRow("Ö (Shift+Quote)")
+            << "Quote" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyO"
+            << "O" << Qt::Key_Odiaeresis << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ö";
+    QTest::newRow("ô") << "KeyI" << Qt::KeyboardModifiers() << "KeyO"
+                       << "o" << Qt::Key_Ocircumflex << Qt::KeyboardModifiers() << "ô";
+    QTest::newRow("Ô") << "KeyI" << Qt::KeyboardModifiers() << "KeyO"
+                       << "O" << Qt::Key_Ocircumflex << Qt::KeyboardModifiers(Qt::ShiftModifier)
+                       << "Ô";
+    QTest::newRow("ô (^ key)") << "Digit6" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyO"
+                               << "o" << Qt::Key_Ocircumflex << Qt::KeyboardModifiers() << "ô";
+    QTest::newRow("Ô (^ key)") << "Digit6" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyO"
+                               << "O" << Qt::Key_Ocircumflex
+                               << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ô";
+    QTest::newRow("õ") << "KeyN" << Qt::KeyboardModifiers() << "KeyO"
+                       << "o" << Qt::Key_Otilde << Qt::KeyboardModifiers() << "õ";
+    QTest::newRow("Õ") << "KeyN" << Qt::KeyboardModifiers() << "KeyO"
+                       << "O" << Qt::Key_Otilde << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Õ";
+
+    QTest::newRow("ù (Backquote)") << "Backquote" << Qt::KeyboardModifiers() << "KeyU"
+                                   << "u" << Qt::Key_Ugrave << Qt::KeyboardModifiers() << "ù";
+    QTest::newRow("Ù (Backquote)")
+            << "Backquote" << Qt::KeyboardModifiers() << "KeyU"
+            << "U" << Qt::Key_Ugrave << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ù";
+    QTest::newRow("ù") << "IntlBackslash" << Qt::KeyboardModifiers() << "KeyU"
+                       << "u" << Qt::Key_Ugrave << Qt::KeyboardModifiers() << "ù";
+    QTest::newRow("Ù") << "IntlBackslash" << Qt::KeyboardModifiers() << "KeyU"
+                       << "U" << Qt::Key_Ugrave << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ù";
+    QTest::newRow("ú") << "KeyE" << Qt::KeyboardModifiers() << "KeyU"
+                       << "u" << Qt::Key_Uacute << Qt::KeyboardModifiers() << "ú";
+    QTest::newRow("Ú") << "KeyE" << Qt::KeyboardModifiers() << "KeyU"
+                       << "U" << Qt::Key_Uacute << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ú";
+    QTest::newRow("ú (Quote)") << "Quote" << Qt::KeyboardModifiers() << "KeyU"
+                               << "u" << Qt::Key_Uacute << Qt::KeyboardModifiers() << "ú";
+    QTest::newRow("Ú (Quote)") << "Quote" << Qt::KeyboardModifiers() << "KeyU"
+                               << "U" << Qt::Key_Uacute << Qt::KeyboardModifiers(Qt::ShiftModifier)
+                               << "Ú";
+    QTest::newRow("ü (Mac Umlaut)") << "KeyU" << Qt::KeyboardModifiers() << "KeyU"
+                                    << "u" << Qt::Key_Udiaeresis << Qt::KeyboardModifiers() << "ü";
+    QTest::newRow("Ü (Mac Umlaut)")
+            << "KeyU" << Qt::KeyboardModifiers() << "KeyU"
+            << "U" << Qt::Key_Udiaeresis << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ü";
+    QTest::newRow("ü (Shift+Quote)")
+            << "Quote" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyU"
+            << "u" << Qt::Key_Udiaeresis << Qt::KeyboardModifiers() << "ü";
+    QTest::newRow("Ü (Shift+Quote)")
+            << "Quote" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyU"
+            << "U" << Qt::Key_Udiaeresis << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ü";
+    QTest::newRow("û") << "KeyI" << Qt::KeyboardModifiers() << "KeyU"
+                       << "û" << Qt::Key_Ucircumflex << Qt::KeyboardModifiers() << "û";
+    QTest::newRow("Û") << "KeyI" << Qt::KeyboardModifiers() << "KeyU"
+                       << "U" << Qt::Key_Ucircumflex << Qt::KeyboardModifiers(Qt::ShiftModifier)
+                       << "Û";
+    QTest::newRow("û (^ key)") << "Digit6" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyU"
+                               << "û" << Qt::Key_Ucircumflex << Qt::KeyboardModifiers() << "û";
+    QTest::newRow("Û (^ key)") << "Digit6" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyU"
+                               << "U" << Qt::Key_Ucircumflex
+                               << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Û";
+
+    QTest::newRow("ý") << "KeyE" << Qt::KeyboardModifiers() << "KeyY"
+                       << "y" << Qt::Key_Yacute << Qt::KeyboardModifiers() << "ý";
+    QTest::newRow("Ý") << "KeyE" << Qt::KeyboardModifiers() << "KeyY"
+                       << "Y" << Qt::Key_Yacute << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ý";
+    QTest::newRow("ý (Quote)") << "Quote" << Qt::KeyboardModifiers() << "KeyY"
+                               << "y" << Qt::Key_Yacute << Qt::KeyboardModifiers() << "ý";
+    QTest::newRow("Ý (Quote)") << "Quote" << Qt::KeyboardModifiers() << "KeyY"
+                               << "Y" << Qt::Key_Yacute << Qt::KeyboardModifiers(Qt::ShiftModifier)
+                               << "Ý";
+    QTest::newRow("ÿ (Mac Umlaut)") << "KeyU" << Qt::KeyboardModifiers() << "KeyY"
+                                    << "y" << Qt::Key_ydiaeresis << Qt::KeyboardModifiers() << "ÿ";
+    QTest::newRow("Ÿ (Mac Umlaut)")
+            << "KeyU" << Qt::KeyboardModifiers() << "KeyY"
+            << "Y" << Qt::Key_ydiaeresis << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ÿ";
+    QTest::newRow("ÿ (Shift+Quote)")
+            << "Quote" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyY"
+            << "y" << Qt::Key_ydiaeresis << Qt::KeyboardModifiers() << "ÿ";
+    QTest::newRow("Ÿ (Shift+Quote)")
+            << "Quote" << Qt::KeyboardModifiers(Qt::ShiftModifier) << "KeyY"
+            << "Y" << Qt::Key_ydiaeresis << Qt::KeyboardModifiers(Qt::ShiftModifier) << "Ÿ";
+}
+
+void tst_QWasmKeyTranslator::modifyByDeadKey()
+{
+    QFETCH(QString, deadKeyCode);
+    QFETCH(Qt::KeyboardModifiers, deadKeyModifiers);
+    QFETCH(QString, targetKeyCode);
+    QFETCH(QString, targetKey);
+    QFETCH(Qt::Key, targetQtKey);
+    QFETCH(Qt::KeyboardModifiers, modifiers);
+    QFETCH(QString, expectedModifiedKey);
+
+    QWasmDeadKeySupport deadKeySupport;
+
+    KeyEvent event(EventType::KeyDown, makeDeadKeyJsEvent(deadKeyCode, deadKeyModifiers));
+    QCOMPARE(event.deadKey, true);
+
+    deadKeySupport.applyDeadKeyTranslations(&event);
+
+    KeyEvent eDown(EventType::KeyDown, makeKeyJsEvent(targetKeyCode, targetKey, modifiers));
+    QCOMPARE(eDown.deadKey, false);
+    deadKeySupport.applyDeadKeyTranslations(&eDown);
+    QCOMPARE(eDown.deadKey, false);
+    QCOMPARE(eDown.text, expectedModifiedKey);
+    QCOMPARE(eDown.key, targetQtKey);
+
+    KeyEvent eUp(EventType::KeyUp, makeKeyJsEvent(targetKeyCode, targetKey, modifiers));
+    QCOMPARE(eUp.deadKey, false);
+    deadKeySupport.applyDeadKeyTranslations(&eUp);
+    QCOMPARE(eUp.text, expectedModifiedKey);
+    QCOMPARE(eUp.key, targetQtKey);
+}
+
+void tst_QWasmKeyTranslator::deadKeyModifiesOnlyOneKeyPressAndUp()
+{
+    QWasmDeadKeySupport deadKeySupport;
+    KeyEvent event(EventType::KeyDown, makeDeadKeyJsEvent("KeyU", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&event);
+
+    KeyEvent eDown(EventType::KeyDown, makeKeyJsEvent("KeyU", "u", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&eDown);
+    QCOMPARE(eDown.text, "ü");
+    QCOMPARE(eDown.key, Qt::Key_Udiaeresis);
+
+    KeyEvent eUp(EventType::KeyUp, makeKeyJsEvent("KeyU", "u", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&eUp);
+    QCOMPARE(eUp.text, "ü");
+    QCOMPARE(eUp.key, Qt::Key_Udiaeresis);
+
+    KeyEvent eDown2(EventType::KeyDown, makeKeyJsEvent("KeyU", "u", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&eDown2);
+    QCOMPARE(eDown2.text, "u");
+    QCOMPARE(eDown2.key, Qt::Key_U);
+
+    KeyEvent eUp2(EventType::KeyUp, makeKeyJsEvent("KeyU", "u", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&eUp2);
+    QCOMPARE(eUp2.text, "u");
+    QCOMPARE(eUp2.key, Qt::Key_U);
+}
+
+void tst_QWasmKeyTranslator::deadKeyIgnoresKeyUpPrecedingKeyDown()
+{
+    QWasmDeadKeySupport deadKeySupport;
+
+    KeyEvent deadKeyDownEvent(EventType::KeyDown,
+                              makeDeadKeyJsEvent("KeyU", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&deadKeyDownEvent);
+
+    KeyEvent deadKeyUpEvent(EventType::KeyUp, makeDeadKeyJsEvent("KeyU", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&deadKeyUpEvent);
+
+    KeyEvent otherKeyUpEvent(EventType::KeyUp,
+                             makeKeyJsEvent("AltLeft", "Alt", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&otherKeyUpEvent);
+
+    KeyEvent eDown(EventType::KeyDown, makeKeyJsEvent("KeyU", "u", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&eDown);
+    QCOMPARE(eDown.text, "ü");
+    QCOMPARE(eDown.key, Qt::Key_Udiaeresis);
+
+    KeyEvent yetAnotherKeyUpEvent(
+            EventType::KeyUp, makeKeyJsEvent("ControlLeft", "Control", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&yetAnotherKeyUpEvent);
+
+    KeyEvent eUp(EventType::KeyUp, makeKeyJsEvent("KeyU", "u", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&eUp);
+    QCOMPARE(eUp.text, "ü");
+    QCOMPARE(eUp.key, Qt::Key_Udiaeresis);
+}
+
+void tst_QWasmKeyTranslator::onlyKeysProducingTextAreModifiedByDeadKeys()
+{
+    QWasmDeadKeySupport deadKeySupport;
+
+    KeyEvent deadKeyDownEvent(EventType::KeyDown,
+                              makeDeadKeyJsEvent("KeyU", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&deadKeyDownEvent);
+
+    KeyEvent noTextKeyDown(EventType::KeyDown,
+                           makeKeyJsEvent("AltLeft", "Alt", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&noTextKeyDown);
+    QCOMPARE(noTextKeyDown.text, "");
+    QCOMPARE(noTextKeyDown.key, Qt::Key_Alt);
+
+    KeyEvent noTextKeyUp(EventType::KeyUp,
+                         makeKeyJsEvent("AltLeft", "Alt", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&noTextKeyUp);
+    QCOMPARE(noTextKeyDown.text, "");
+    QCOMPARE(noTextKeyDown.key, Qt::Key_Alt);
+
+    KeyEvent eDown(EventType::KeyDown, makeKeyJsEvent("KeyU", "u", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&eDown);
+    QCOMPARE(eDown.text, "ü");
+    QCOMPARE(eDown.key, Qt::Key_Udiaeresis);
+
+    KeyEvent eUp(EventType::KeyUp, makeKeyJsEvent("KeyU", "u", Qt::KeyboardModifiers()));
+    deadKeySupport.applyDeadKeyTranslations(&eUp);
+    QCOMPARE(eUp.text, "ü");
+    QCOMPARE(eUp.key, Qt::Key_Udiaeresis);
+}
+
+QTEST_MAIN(tst_QWasmKeyTranslator)
+#include "tst_qwasmkeytranslator.moc"

tests/auto/wasm/tst_qwasmwindowstack.cpp

@@ -0,0 +1,272 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "../../../src/plugins/platforms/wasm/qwasmwindowstack.h"
+#include <QtGui/QWindow>
+#include <QTest>
+#include <emscripten/val.h>
+
+class QWasmWindow
+{
+};
+
+namespace {
+std::vector<QWasmWindow *> getWindowsFrontToBack(const QWasmWindowStack *stack)
+{
+    return std::vector<QWasmWindow *>(stack->begin(), stack->end());
+}
+}
+
+class tst_QWasmWindowStack : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QWasmWindowStack()
+        : m_mockCallback(std::bind(&tst_QWasmWindowStack::onTopWindowChanged, this))
+    {
+    }
+
+private slots:
+    void init();
+
+    void insertion();
+    void raisingTheRootIsImpossible();
+    void raising();
+    void lowering();
+    void removing();
+    void removingTheRoot();
+    void clearing();
+
+private:
+    void onTopWindowChanged()
+    {
+        ++m_topLevelChangedCallCount;
+        if (m_onTopLevelChangedAction)
+            m_onTopLevelChangedAction();
+    }
+
+    void verifyTopWindowChangedCalled(int expected = 1)
+    {
+        QCOMPARE(expected, m_topLevelChangedCallCount);
+        clearCallbackCounter();
+    }
+
+    void clearCallbackCounter() { m_topLevelChangedCallCount = 0; }
+
+    QWasmWindowStack::TopWindowChangedCallbackType m_mockCallback;
+    QWasmWindowStack::TopWindowChangedCallbackType m_onTopLevelChangedAction;
+    int m_topLevelChangedCallCount = 0;
+
+    QWasmWindow m_root;
+    QWasmWindow m_window1;
+    QWasmWindow m_window2;
+    QWasmWindow m_window3;
+    QWasmWindow m_window4;
+    QWasmWindow m_window5;
+};
+
+void tst_QWasmWindowStack::init()
+{
+    m_onTopLevelChangedAction = QWasmWindowStack::TopWindowChangedCallbackType();
+    clearCallbackCounter();
+}
+
+void tst_QWasmWindowStack::insertion()
+{
+    QWasmWindowStack stack(m_mockCallback);
+
+    m_onTopLevelChangedAction = [this, &stack]() { QVERIFY(stack.topWindow() == &m_root); };
+    stack.pushWindow(&m_root);
+    verifyTopWindowChangedCalled();
+
+    m_onTopLevelChangedAction = [this, &stack]() { QVERIFY(stack.topWindow() == &m_window1); };
+    stack.pushWindow(&m_window1);
+    verifyTopWindowChangedCalled();
+
+    m_onTopLevelChangedAction = [this, &stack]() { QVERIFY(stack.topWindow() == &m_window2); };
+    stack.pushWindow(&m_window2);
+    verifyTopWindowChangedCalled();
+}
+
+void tst_QWasmWindowStack::raisingTheRootIsImpossible()
+{
+    QWasmWindowStack stack(m_mockCallback);
+
+    stack.pushWindow(&m_root);
+    stack.pushWindow(&m_window1);
+    stack.pushWindow(&m_window2);
+    stack.pushWindow(&m_window3);
+    stack.pushWindow(&m_window4);
+    stack.pushWindow(&m_window5);
+
+    clearCallbackCounter();
+
+    stack.raise(&m_root);
+    verifyTopWindowChangedCalled(0);
+
+    QCOMPARE(&m_window5, stack.topWindow());
+
+    m_onTopLevelChangedAction = [this, &stack]() { QVERIFY(stack.topWindow() == &m_window2); };
+    stack.raise(&m_window2);
+    verifyTopWindowChangedCalled();
+}
+
+void tst_QWasmWindowStack::raising()
+{
+    QWasmWindowStack stack(m_mockCallback);
+
+    stack.pushWindow(&m_root);
+    stack.pushWindow(&m_window1);
+    stack.pushWindow(&m_window2);
+    stack.pushWindow(&m_window3);
+    stack.pushWindow(&m_window4);
+    stack.pushWindow(&m_window5);
+
+    clearCallbackCounter();
+
+    QCOMPARE(&m_window5, stack.topWindow());
+
+    m_onTopLevelChangedAction = [this, &stack]() { QVERIFY(stack.topWindow() == &m_window1); };
+    stack.raise(&m_window1);
+    verifyTopWindowChangedCalled();
+    QCOMPARE(&m_window1, stack.topWindow());
+
+    stack.raise(&m_window1);
+    verifyTopWindowChangedCalled(0);
+    QCOMPARE(&m_window1, stack.topWindow());
+
+    m_onTopLevelChangedAction = [this, &stack]() { QVERIFY(stack.topWindow() == &m_window3); };
+    stack.raise(&m_window3);
+    verifyTopWindowChangedCalled();
+    QCOMPARE(&m_window3, stack.topWindow());
+}
+
+void tst_QWasmWindowStack::lowering()
+{
+    QWasmWindowStack stack(m_mockCallback);
+
+    stack.pushWindow(&m_root);
+    stack.pushWindow(&m_window1);
+    stack.pushWindow(&m_window2);
+    stack.pushWindow(&m_window3);
+    stack.pushWindow(&m_window4);
+    stack.pushWindow(&m_window5);
+    // Window order: 5 4 3 2 1 R
+
+    clearCallbackCounter();
+
+    QCOMPARE(&m_window5, stack.topWindow());
+
+    m_onTopLevelChangedAction = [this, &stack]() { QVERIFY(stack.topWindow() == &m_window4); };
+    stack.lower(&m_window5);
+    // Window order: 4 3 2 1 5 R
+    verifyTopWindowChangedCalled();
+    QCOMPARE(&m_window4, stack.topWindow());
+
+    stack.lower(&m_window3);
+    // Window order: 4 2 1 5 3 R
+    verifyTopWindowChangedCalled(0);
+    std::vector<QWasmWindow *> expectedWindowOrder = { &m_window4, &m_window2, &m_window1,
+                                                       &m_window5, &m_window3, &m_root };
+    QVERIFY(std::equal(expectedWindowOrder.begin(), expectedWindowOrder.end(),
+                       getWindowsFrontToBack(&stack).begin()));
+}
+
+void tst_QWasmWindowStack::removing()
+{
+    QWasmWindowStack stack(m_mockCallback);
+
+    stack.pushWindow(&m_root);
+    stack.pushWindow(&m_window1);
+    stack.pushWindow(&m_window2);
+    stack.pushWindow(&m_window3);
+    stack.pushWindow(&m_window4);
+    stack.pushWindow(&m_window5);
+    // Window order: 5 4 3 2 1 R
+
+    clearCallbackCounter();
+
+    QCOMPARE(&m_window5, stack.topWindow());
+
+    m_onTopLevelChangedAction = [this, &stack]() { QVERIFY(stack.topWindow() == &m_window4); };
+    stack.removeWindow(&m_window5);
+    // Window order: 4 3 2 1 R
+    verifyTopWindowChangedCalled();
+    QCOMPARE(&m_window4, stack.topWindow());
+
+    stack.removeWindow(&m_window2);
+    // Window order: 4 3 1 R
+    verifyTopWindowChangedCalled(0);
+    std::vector<QWasmWindow *> expectedWindowOrder = { &m_window4, &m_window3, &m_window1,
+                                                       &m_root };
+    QVERIFY(std::equal(expectedWindowOrder.begin(), expectedWindowOrder.end(),
+                       getWindowsFrontToBack(&stack).begin()));
+}
+
+void tst_QWasmWindowStack::removingTheRoot()
+{
+    QWasmWindowStack stack(m_mockCallback);
+
+    stack.pushWindow(&m_root);
+    stack.pushWindow(&m_window1);
+    stack.pushWindow(&m_window2);
+    stack.pushWindow(&m_window3);
+    // Window order: 3 2 1 R
+
+    clearCallbackCounter();
+
+    QCOMPARE(&m_window3, stack.topWindow());
+
+    stack.removeWindow(&m_root);
+    // Window order: 3 2 1
+    verifyTopWindowChangedCalled(0);
+    QCOMPARE(&m_window3, stack.topWindow());
+
+    m_onTopLevelChangedAction = [this, &stack]() { QVERIFY(stack.topWindow() == &m_window1); };
+    // Check that the new bottom window is not treated specially as a root
+    stack.raise(&m_window1);
+    // Window order: 1 3 2
+    verifyTopWindowChangedCalled();
+    std::vector<QWasmWindow *> expectedWindowOrder = { &m_window1, &m_window3, &m_window2 };
+    QVERIFY(std::equal(expectedWindowOrder.begin(), expectedWindowOrder.end(),
+                       getWindowsFrontToBack(&stack).begin()));
+
+    m_onTopLevelChangedAction = [this, &stack]() { QVERIFY(stack.topWindow() == &m_window3); };
+    // Check that the new bottom window is not treated specially as a root
+    stack.lower(&m_window1);
+    // Window order: 3 2 1
+    verifyTopWindowChangedCalled();
+    expectedWindowOrder = { &m_window3, &m_window2, &m_window1 };
+    QVERIFY(std::equal(expectedWindowOrder.begin(), expectedWindowOrder.end(),
+                       getWindowsFrontToBack(&stack).begin()));
+}
+
+void tst_QWasmWindowStack::clearing()
+{
+    QWasmWindowStack stack(m_mockCallback);
+
+    stack.pushWindow(&m_root);
+    stack.pushWindow(&m_window1);
+    // Window order: 1 R
+
+    clearCallbackCounter();
+
+    QCOMPARE(&m_window1, stack.topWindow());
+
+    m_onTopLevelChangedAction = [this, &stack]() { QVERIFY(stack.topWindow() == &m_root); };
+    stack.removeWindow(&m_window1);
+    // Window order: R
+    verifyTopWindowChangedCalled();
+    QCOMPARE(&m_root, stack.topWindow());
+
+    m_onTopLevelChangedAction = [&stack]() { QVERIFY(stack.topWindow() == nullptr); };
+    stack.removeWindow(&m_root);
+    // Window order: <empty>
+    verifyTopWindowChangedCalled();
+    QCOMPARE(nullptr, stack.topWindow());
+    QCOMPARE(0u, stack.size());
+}
+
+QTEST_MAIN(tst_QWasmWindowStack)
+#include "tst_qwasmwindowstack.moc"