diff --git a/tests/manual/wasm/eventloop/CMakeLists.txt b/tests/manual/wasm/eventloop/CMakeLists.txt
index 4c754deafee..aadee6af52d 100644
--- a/tests/manual/wasm/eventloop/CMakeLists.txt
+++ b/tests/manual/wasm/eventloop/CMakeLists.txt
@@ -2,6 +2,7 @@
# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
add_subdirectory(asyncify_exec)
+add_subdirectory(eventloop_auto)
add_subdirectory(main_exec)
add_subdirectory(main_noexec)
add_subdirectory(thread_exec)
diff --git a/tests/manual/wasm/eventloop/README.md b/tests/manual/wasm/eventloop/README.md
index e5d4b923060..e1a5a1a3b71 100644
--- a/tests/manual/wasm/eventloop/README.md
+++ b/tests/manual/wasm/eventloop/README.md
@@ -12,3 +12,4 @@ Contents
main_noexec Qt main() without QApplication::exec()
dialog_exec Shows how QDialog::exec() also does not return
thread_exec Shows how to use QThread::exec()
+ eventloop_auto Event loop autotest (manually run)
diff --git a/tests/manual/wasm/eventloop/eventloop_auto/CMakeLists.txt b/tests/manual/wasm/eventloop/eventloop_auto/CMakeLists.txt
new file mode 100644
index 00000000000..4212cb832b6
--- /dev/null
+++ b/tests/manual/wasm/eventloop/eventloop_auto/CMakeLists.txt
@@ -0,0 +1,21 @@
+qt_internal_add_manual_test(eventloop_auto
+ SOURCES
+ main.cpp
+ ../../qtwasmtestlib/qtwasmtestlib.cpp
+ PUBLIC_LIBRARIES
+ Qt::Core
+)
+
+include_directories(../../qtwasmtestlib/)
+
+add_custom_command(
+ TARGET eventloop_auto POST_BUILD
+ COMMAND ${CMAKE_COMMAND} -E copy
+ ${CMAKE_CURRENT_SOURCE_DIR}/eventloop_auto.html
+ ${CMAKE_CURRENT_BINARY_DIR}/eventloop_auto.html)
+
+add_custom_command(
+ TARGET eventloop_auto POST_BUILD
+ COMMAND ${CMAKE_COMMAND} -E copy
+ ${CMAKE_CURRENT_SOURCE_DIR}/../../qtwasmtestlib/qtwasmtestlib.js
+ ${CMAKE_CURRENT_BINARY_DIR}/qtwasmtestlib.js)
diff --git a/tests/manual/wasm/eventloop/eventloop_auto/eventloop_auto.html b/tests/manual/wasm/eventloop/eventloop_auto/eventloop_auto.html
new file mode 100644
index 00000000000..7ff9d8e7f23
--- /dev/null
+++ b/tests/manual/wasm/eventloop/eventloop_auto/eventloop_auto.html
@@ -0,0 +1,10 @@
+
+
+
+
+Running event dispatcher auto test.
+
diff --git a/tests/manual/wasm/eventloop/eventloop_auto/main.cpp b/tests/manual/wasm/eventloop/eventloop_auto/main.cpp
new file mode 100644
index 00000000000..c6e8bad987e
--- /dev/null
+++ b/tests/manual/wasm/eventloop/eventloop_auto/main.cpp
@@ -0,0 +1,312 @@
+// 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
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+const int timerTimeout = 10;
+
+class WasmEventDispatcherTest: public QObject
+{
+ Q_OBJECT
+private slots:
+ void postEventMainThread();
+ void timerMainThread();
+ void timerMainThreadMultiple();
+
+#if QT_CONFIG(thread)
+ void postEventSecondaryThread();
+ void postEventSecondaryThreads();
+ void postEventToSecondaryThread();
+ void timerSecondaryThread();
+#endif
+
+#ifdef QT_HAVE_EMSCRIPTEN_ASYNCIFY
+ void postEventAsyncify();
+ void timerAsyncify();
+ void postEventAsyncifyLoop();
+#endif
+
+private:
+// Disabled test function: Asyncify wait on pthread_join is not supported,
+// see https://github.com/emscripten-core/emscripten/issues/9910
+#if QT_CONFIG(thread) && defined(QT_HAVE_EMSCRIPTEN_ASYNCIFY)
+ void threadAsyncifyWait();
+#endif
+};
+
+class EventTarget : public QObject
+{
+ Q_OBJECT
+
+public:
+ static EventTarget *create(std::function callback)
+ {
+ return new EventTarget(callback);
+ }
+
+ static QEvent *createEvent()
+ {
+ return new QEvent(QEvent::User);
+ }
+
+protected:
+ EventTarget(std::function callback)
+ : m_callback(callback) { }
+
+ bool event(QEvent *evt)
+ {
+ if (evt->type() == QEvent::User) {
+ m_callback();
+ deleteLater();
+ return true;
+ }
+ return QObject::event(evt);
+ }
+
+private:
+ std::function m_callback;
+};
+
+class CompleteTestFunctionRefGuard {
+public:
+ CompleteTestFunctionRefGuard(CompleteTestFunctionRefGuard const&) = delete;
+ CompleteTestFunctionRefGuard& operator=(CompleteTestFunctionRefGuard const&) = delete;
+
+ static CompleteTestFunctionRefGuard *create() {
+ return new CompleteTestFunctionRefGuard();
+ }
+
+ void ref() {
+ QMutexLocker lock(&mutex);
+ ++m_counter;
+ }
+
+ void deref() {
+ const bool finalDeref = [this] {
+ QMutexLocker lock(&mutex);
+ return --m_counter == 0;
+ }();
+
+ if (finalDeref)
+ QtWasmTest::completeTestFunction();
+ }
+private:
+ CompleteTestFunctionRefGuard() { };
+
+ QMutex mutex;
+ int m_counter = 0;
+};
+
+#if QT_CONFIG(thread)
+
+class TestThread : public QThread
+{
+public:
+ static QThread *create(std::function started, std::function finished)
+ {
+ TestThread *thread = new TestThread();
+ connect(thread, &QThread::started, [started]() {
+ started();
+ });
+ connect(thread, &QThread::finished, [thread, finished]() {
+ finished();
+ thread->deleteLater();
+ });
+ thread->start();
+ return thread;
+ }
+};
+
+#endif
+
+// Post event to the main thread and verify that it is processed.
+void WasmEventDispatcherTest::postEventMainThread()
+{
+ QCoreApplication::postEvent(EventTarget::create([](){
+ QtWasmTest::completeTestFunction();
+ }), EventTarget::createEvent());
+}
+
+// Create a timer on the main thread and verify that it fires
+void WasmEventDispatcherTest::timerMainThread()
+{
+ QTimer::singleShot(timerTimeout, [](){
+ QtWasmTest::completeTestFunction();
+ });
+}
+
+void WasmEventDispatcherTest::timerMainThreadMultiple()
+{
+ CompleteTestFunctionRefGuard *completeGuard = CompleteTestFunctionRefGuard::create();
+ int timers = 10;
+ for (int i = 0; i < timers; ++i) {
+ completeGuard->ref();
+ QTimer::singleShot(timerTimeout * i, [completeGuard](){
+ completeGuard->deref();
+ });
+ }
+}
+
+#if QT_CONFIG(thread)
+
+// Post event on a secondary thread and verify that it is processed.
+void WasmEventDispatcherTest::postEventSecondaryThread()
+{
+ auto started = [](){
+ QCoreApplication::postEvent(EventTarget::create([](){
+ QThread::currentThread()->quit();
+ }), EventTarget::createEvent());
+ };
+
+ auto finished = [](){
+ QtWasmTest::completeTestFunction();
+ };
+
+ TestThread::create(started, finished);
+}
+
+// Post event _to_ a secondary thread and verify that it is processed.
+void WasmEventDispatcherTest::postEventToSecondaryThread()
+{
+ auto started = [](){};
+ auto finished = [](){
+ QtWasmTest::completeTestFunction();
+ };
+
+ QThread *t = TestThread::create(started, finished);
+ EventTarget *target = EventTarget::create([](){
+ QThread::currentThread()->quit();
+ });
+ target->moveToThread(t);
+ QCoreApplication::postEvent(target, EventTarget::createEvent());
+}
+
+// Post events to many secondary threads and verify that they are processed.
+void WasmEventDispatcherTest::postEventSecondaryThreads()
+{
+ // This test completes afer all threads has finished
+ CompleteTestFunctionRefGuard *completeGuard = CompleteTestFunctionRefGuard::create();
+ completeGuard->ref(); // including this thread
+
+ auto started = [](){
+ QCoreApplication::postEvent(EventTarget::create([](){
+ QThread::currentThread()->quit();
+ }), EventTarget::createEvent());
+ };
+
+ auto finished = [completeGuard](){
+ completeGuard->deref();
+ };
+
+ // Start a nymber of threads in parallel, keeping in mind that the browser
+ // has some max number of concurrent web workers (maybe 20), and that starting
+ // a new web worker requires completing a GET network request for the worker's JS.
+ const int numThreads = 10;
+ for (int i = 0; i < numThreads; ++i) {
+ completeGuard->ref();
+ TestThread::create(started, finished);
+ }
+
+ completeGuard->deref();
+}
+
+// Create a timer a secondary thread and verify that it fires
+void WasmEventDispatcherTest::timerSecondaryThread()
+{
+ auto started = [](){
+ QTimer::singleShot(timerTimeout, [](){
+ QThread::currentThread()->quit();
+ });
+ };
+
+ auto finished = [](){
+ QtWasmTest::completeTestFunction();
+ };
+
+ TestThread::create(started, finished);
+}
+
+#endif
+
+#ifdef QT_HAVE_EMSCRIPTEN_ASYNCIFY
+
+// Post an event to the main thread and asyncify wait for it
+void WasmEventDispatcherTest::postEventAsyncify()
+{
+ QEventLoop loop;
+ QCoreApplication::postEvent(EventTarget::create([&loop](){
+ loop.quit();
+ }), EventTarget::createEvent());
+ loop.exec();
+
+ QtWasmTest::completeTestFunction();
+}
+
+// Create a timer on the main thread and asyncify wait for it
+void WasmEventDispatcherTest::timerAsyncify()
+{
+ QEventLoop loop;
+ QTimer::singleShot(timerTimeout, [&loop](){
+ loop.quit();
+ });
+ loop.exec();
+
+ QtWasmTest::completeTestFunction();
+}
+
+// Asyncify wait in a loop
+void WasmEventDispatcherTest::postEventAsyncifyLoop()
+{
+ for (int i = 0; i < 10; ++i) {
+ QEventLoop loop;
+ QCoreApplication::postEvent(EventTarget::create([&loop]() {
+ loop.quit();
+ }), EventTarget::createEvent());
+ loop.exec();
+ }
+
+ QtWasmTest::completeTestFunction();
+}
+
+#if QT_CONFIG(thread)
+// Asyncify wait for QThread::wait() / pthread_join()
+void WasmEventDispatcherTest::threadAsyncifyWait()
+{
+ const int threadCount = 15;
+
+ QVector threads;
+ threads.reserve(threadCount);
+
+ for (int i = 0; i < threadCount; ++i) {
+ QThread *thread = new QThread();
+ threads.push_back(thread);
+ thread->start();
+ }
+
+ for (int i = 0; i < threadCount; ++i) {
+ QThread *thread = threads[i];
+ thread->wait();
+ delete thread;
+ }
+
+ QtWasmTest::completeTestFunction();
+}
+#endif
+
+#endif // QT_HAVE_EMSCRIPTEN_ASYNCIFY
+
+int main(int argc, char **argv)
+{
+ auto testObject = std::make_shared();
+ QtWasmTest::initTestCase(argc, argv, testObject);
+ return 0;
+}
+
+#include "main.moc"
diff --git a/tests/manual/wasm/qtwasmtestlib/qtwasmtestlib.cpp b/tests/manual/wasm/qtwasmtestlib/qtwasmtestlib.cpp
index dd7d11c398f..c70c3902496 100644
--- a/tests/manual/wasm/qtwasmtestlib/qtwasmtestlib.cpp
+++ b/tests/manual/wasm/qtwasmtestlib/qtwasmtestlib.cpp
@@ -45,7 +45,6 @@ void verify(bool condition, std::string_view conditionString, std::string_view f
// thread-safe and call be called from any thread.
void completeTestFunction(TestResult result, std::string message)
{
-
// Report test result to JavaScript test runner, on the main thread
runOnMainThread([resultString = result == TestResult::Pass ? "PASS" : "FAIL", message](){
EM_ASM({
@@ -54,6 +53,12 @@ void completeTestFunction(TestResult result, std::string message)
});
}
+// Completes the currently running test function with a Pass result.
+void completeTestFunction()
+{
+ completeTestFunction(TestResult::Pass, std::string());
+}
+
//
// Private API for the Javascript test runnner
//
diff --git a/tests/manual/wasm/qtwasmtestlib/qtwasmtestlib.h b/tests/manual/wasm/qtwasmtestlib/qtwasmtestlib.h
index f4b0f752417..c691f44600e 100644
--- a/tests/manual/wasm/qtwasmtestlib/qtwasmtestlib.h
+++ b/tests/manual/wasm/qtwasmtestlib/qtwasmtestlib.h
@@ -20,6 +20,7 @@ std::string formatMessage(std::string_view file,
std::string_view message);
void completeTestFunction(TestResult result, std::string message);
+void completeTestFunction();
void initTestCase(QObject *testObject, std::function cleanup);
template
void initTestCase(int argc,