[gjs/wip/3v1n0/toggle-queue-tests: 1/2] tests: Add unit tests for ToggleQueue and ObjectInstance usage of it
- From: Marco Trevisan <marcotrevi src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gjs/wip/3v1n0/toggle-queue-tests: 1/2] tests: Add unit tests for ToggleQueue and ObjectInstance usage of it
- Date: Sun, 16 May 2021 14:01:24 +0000 (UTC)
commit c59c48aaf9c73b263ca19c2322cced2f1c64c546
Author: Marco Trevisan (Treviño) <mail 3v1n0 net>
Date: Sat May 1 22:31:19 2021 +0200
tests: Add unit tests for ToggleQueue and ObjectInstance usage of it
Instead of relying only on (at times unpredictible) JS tests for toggle
queue handling and Objects memory management, add unit tests in which we
manually handle an ObjectInstance and we simulate toggle events on it.
gi/object.h | 6 +
gi/toggle.h | 6 +
installed-tests/js/libgjstesttools/meson.build | 3 +
meson.build | 36 +-
test/gjs-test-toggle-queue.cpp | 689 +++++++++++++++++++++++++
test/gjs-test-utils.h | 10 +-
test/gjs-tests-internal.cpp | 26 +
test/gjs-tests.cpp | 12 +-
test/meson.build | 37 +-
9 files changed, 797 insertions(+), 28 deletions(-)
---
diff --git a/gi/object.h b/gi/object.h
index abe2655b..2de24c4c 100644
--- a/gi/object.h
+++ b/gi/object.h
@@ -41,6 +41,11 @@ class CallArgs;
namespace js {
class SystemAllocPolicy;
}
+namespace Gjs {
+namespace Test {
+struct ObjectInstance;
+}
+} // namespace Gjs
class ObjectInstance;
class ObjectPrototype;
@@ -294,6 +299,7 @@ class ObjectInstance : public GIWrapperInstance<ObjectBase, ObjectPrototype,
GObject>;
friend class GIWrapperBase<ObjectBase, ObjectPrototype, ObjectInstance>;
friend class ObjectBase; // for add_property, prop_getter, etc.
+ friend struct Gjs::Test::ObjectInstance;
// GIWrapperInstance::m_ptr may be null in ObjectInstance.
diff --git a/gi/toggle.h b/gi/toggle.h
index 17f22c06..293f4195 100644
--- a/gi/toggle.h
+++ b/gi/toggle.h
@@ -17,6 +17,11 @@
#include <utility> // for pair
class ObjectInstance;
+namespace Gjs {
+namespace Test {
+struct ToggleQueue;
+}
+} // namespace Gjs
/* Thread-safe queue for enqueueing toggle-up or toggle-down events on GObjects
* from any thread. For more information, see object.cpp, comments near
@@ -31,6 +36,7 @@ public:
using Handler = void (*)(ObjectInstance*, Direction);
private:
+ friend Gjs::Test::ToggleQueue;
struct Item {
Item() {}
Item(ObjectInstance* o, Direction d) : object(o), direction(d) {}
diff --git a/installed-tests/js/libgjstesttools/meson.build b/installed-tests/js/libgjstesttools/meson.build
index 036d7076..2e57483a 100644
--- a/installed-tests/js/libgjstesttools/meson.build
+++ b/installed-tests/js/libgjstesttools/meson.build
@@ -17,3 +17,6 @@ gjstest_tools_gir = gnome.generate_gir(libgjstesttools,
install: get_option('installed_tests'), install_dir_gir: false,
install_dir_typelib: installed_tests_execdir)
gjstest_tools_typelib = gjstest_tools_gir[1]
+libgjstesttools_dep = declare_dependency(
+ link_with: libgjstesttools,
+ include_directories: include_directories('.'))
diff --git a/meson.build b/meson.build
index 8d11ec84..2f1a03c7 100644
--- a/meson.build
+++ b/meson.build
@@ -496,12 +496,20 @@ if host_machine.system() == 'windows'
libgjs_cpp_args += ['-DWIN32', '-DXP_WIN']
endif
+base_build_dep = declare_dependency(
+ compile_args: libgjs_cpp_args,
+ dependencies: libgjs_dependencies)
+
libgjs_jsapi = static_library(meson.project_name() + '-jsapi',
libgjs_jsapi_sources, probes_header, probes_objfile,
- cpp_args: libgjs_cpp_args,
- dependencies: libgjs_dependencies,
+ dependencies: base_build_dep,
install: false)
+libgjs_internal = static_library(meson.project_name() + '-internal',
+ libgjs_sources, probes_header, probes_objfile,
+ dependencies: base_build_dep,
+ link_with: libgjs_jsapi)
+
link_args = []
symbol_map = files('libgjs.map')
symbol_list = files('libgjs.symbols')
@@ -513,12 +521,10 @@ link_args += cxx.get_supported_link_arguments([
])
libgjs = shared_library(meson.project_name(),
- libgjs_sources, libgjs_private_sources, module_resource_srcs,
- probes_header, probes_objfile,
- cpp_args: libgjs_cpp_args,
+ sources: [ libgjs_private_sources, module_resource_srcs ],
link_args: link_args, link_depends: [symbol_map, symbol_list],
- link_with: libgjs_jsapi,
- dependencies: libgjs_dependencies,
+ link_whole: libgjs_internal,
+ dependencies: base_build_dep,
version: '0.0.0', soversion: '0',
gnu_symbol_visibility: 'hidden',
install: true)
@@ -527,7 +533,7 @@ install_headers(gjs_public_headers, subdir: api_name / 'gjs')
# Allow using libgjs as a subproject
libgjs_dep = declare_dependency(link_with: [libgjs, libgjs_jsapi],
- dependencies: libgjs_dependencies, include_directories: top_include)
+ dependencies: base_build_dep, include_directories: top_include)
### Build GjsPrivate introspection library #####################################
@@ -543,7 +549,6 @@ gjs_private_typelib = gjs_private_gir[1]
gjs_console_srcs = ['gjs/console.cpp']
gjs_console = executable('gjs-console', gjs_console_srcs,
- cpp_args: libgjs_cpp_args,
dependencies: libgjs_dep, install: true)
meson.add_install_script('build/symlink-gjs.py', get_option('bindir'))
@@ -585,6 +590,7 @@ libgjs_test_tools_builddir = js_tests_builddir / 'libgjstesttools'
tests_environment.set('TOP_BUILDDIR', meson.build_root())
tests_environment.set('GJS_USE_UNINSTALLED_FILES', '1')
tests_environment.set('GJS_PATH', '')
+tests_environment.set('GJS_DEBUG_OUTPUT', 'stderr')
tests_environment.prepend('GI_TYPELIB_PATH', meson.current_build_dir(),
js_tests_builddir, libgjs_test_tools_builddir)
tests_environment.prepend('LD_LIBRARY_PATH', meson.current_build_dir(),
@@ -624,18 +630,18 @@ endif
### Tests and test setups ######################################################
-# Note: The test program in test/ needs to be ported
-# to Windows before we can build it on Windows.
-if host_machine.system() != 'windows'
- subdir('test')
-endif
-
if not get_option('skip_gtk_tests')
have_gtk4 = dependency('gtk4', required: false).found()
endif
subdir('installed-tests')
+# Note: The test program in test/ needs to be ported
+# to Windows before we can build it on Windows.
+if host_machine.system() != 'windows'
+ subdir('test')
+endif
+
valgrind_environment = environment()
valgrind_environment.set('G_SLICE', 'always-malloc,debug-blocks')
valgrind_environment.set('G_DEBUG',
diff --git a/test/gjs-test-toggle-queue.cpp b/test/gjs-test-toggle-queue.cpp
new file mode 100644
index 00000000..9c9818c0
--- /dev/null
+++ b/test/gjs-test-toggle-queue.cpp
@@ -0,0 +1,689 @@
+/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
+// SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
+// SPDX-FileCopyrightText: 2021 Canonical, Ltd.
+// SPDX-FileContributor: Marco Trevisan <marco trevisan canonical com>
+
+#include <config.h>
+
+#include <algorithm> // for copy
+#include <atomic>
+#include <chrono>
+#include <deque>
+#include <memory>
+#include <thread>
+#include <tuple> // for tie
+#include <utility> // for pair
+
+#include <girepository.h>
+#include <glib-object.h>
+#include <glib.h>
+
+#include <js/GCAPI.h> // for JS_GC
+#include <js/TypeDecls.h>
+
+#include "gi/object.h"
+#include "gi/toggle.h"
+#include "gjs/context.h"
+#include "gjs/jsapi-util.h"
+#include "installed-tests/js/libgjstesttools/gjs-test-tools.h"
+#include "test/gjs-test-utils.h"
+
+namespace Gjs {
+namespace Test {
+
+static GMutex s_gc_lock;
+static GCond s_gc_finished;
+static std::atomic_int s_gc_counter;
+static std::deque<std::pair<::ObjectInstance*, ::ToggleQueue::Direction>>
+ s_toggle_history;
+
+struct ObjectInstance : ::ObjectInstance {
+ using ::ObjectInstance::ensure_uses_toggle_ref;
+ using ::ObjectInstance::new_for_gobject;
+ using ::ObjectInstance::wrapper_is_rooted;
+};
+
+struct ToggleQueue {
+ static decltype(::ToggleQueue::get_default()) get_default() {
+ return ::ToggleQueue::get_default();
+ }
+ static void reset_queue() {
+ auto tq = get_default();
+ tq->m_shutdown = false;
+ g_clear_handle_id(&tq->m_idle_id, g_source_remove);
+ tq->q.clear();
+ }
+ static decltype(::ToggleQueue::q) queue() { return get_default()->q; }
+ static ::ToggleQueue::Handler handler() {
+ return get_default()->m_toggle_handler;
+ }
+};
+
+namespace TQ {
+
+static void on_gc(JSContext*, JSGCStatus status, JS::GCReason, void*) {
+ if (status != JSGC_END)
+ return;
+
+ g_mutex_lock(&s_gc_lock);
+ s_gc_counter.fetch_add(1);
+ g_cond_broadcast(&s_gc_finished);
+ g_mutex_unlock(&s_gc_lock);
+}
+
+static void setup(GjsUnitTestFixture* fx, const void*) {
+ g_irepository_prepend_search_path(g_getenv("TOP_BUILDDIR"));
+ gjs_test_tools_init();
+ gjs_unit_test_fixture_setup(fx, nullptr);
+ JS_SetGCCallback(fx->cx, on_gc, fx);
+
+ GjsAutoError error;
+ int code;
+
+ const char* gi_initializer = "imports.gi;";
+ g_assert_true(gjs_context_eval(fx->gjs_context, gi_initializer, -1,
+ "<gjs-test-toggle>", &code, error.out()));
+ g_assert_no_error(error);
+}
+
+static void wait_for_gc(GjsUnitTestFixture* fx) {
+ int count = s_gc_counter.load();
+
+ JS_GC(fx->cx);
+
+ g_mutex_lock(&s_gc_lock);
+ while (count == s_gc_counter.load()) {
+ g_cond_wait(&s_gc_finished, &s_gc_lock);
+ }
+ g_mutex_unlock(&s_gc_lock);
+}
+
+static void teardown(GjsUnitTestFixture* fx, const void*) {
+ for (auto pair : s_toggle_history)
+ ToggleQueue::get_default()->cancel(pair.first);
+
+ s_toggle_history.clear();
+ gjs_unit_test_fixture_teardown(fx, nullptr);
+
+ g_assert_true(ToggleQueue::queue().empty());
+ ToggleQueue::reset_queue();
+ gjs_test_tools_reset();
+}
+
+} // namespace TQ
+
+static ::ObjectInstance* new_test_gobject(GjsUnitTestFixture* fx) {
+ GjsAutoUnref<GObject> gobject(
+ G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr)));
+ auto* object = ObjectInstance::new_for_gobject(fx->cx, gobject);
+ static_cast<ObjectInstance*>(object)->ensure_uses_toggle_ref(fx->cx);
+ return object;
+}
+
+static void wait_for(int interval) {
+ GjsAutoPointer<GMainLoop, GMainLoop, g_main_loop_unref> loop(
+ g_main_loop_new(nullptr, false));
+ g_timeout_add_full(
+ G_PRIORITY_LOW, interval,
+ [](void* data) {
+ g_main_loop_quit(static_cast<GMainLoop*>(data));
+ return G_SOURCE_REMOVE;
+ },
+ loop, nullptr);
+ g_main_loop_run(loop);
+}
+
+static void toggles_handler(::ObjectInstance* object,
+ ::ToggleQueue::Direction direction) {
+ s_toggle_history.emplace_back(object, direction);
+}
+
+static void test_toggle_queue_unlock_empty(GjsUnitTestFixture*, const void*) {
+ assert_equal(ToggleQueue::get_default()->cancel(nullptr), false, false);
+}
+
+static void test_toggle_queue_unlock_same_thread(GjsUnitTestFixture*,
+ const void*) {
+ auto tq = ToggleQueue::get_default();
+ assert_equal(tq->cancel(nullptr), false, false);
+ assert_equal(ToggleQueue::get_default()->cancel(nullptr), false, false);
+}
+
+static void test_toggle_blocks_other_thread(GjsUnitTestFixture*, const void*) {
+ struct LockedQueue {
+ decltype(ToggleQueue::get_default()) tq = ToggleQueue::get_default();
+ };
+
+ auto locked_queue = std::make_unique<LockedQueue>();
+ assert_equal(locked_queue->tq->cancel(nullptr), false, false);
+
+ std::atomic_bool other_thread_running(false);
+ std::atomic_bool accessed_from_other_thread(false);
+ auto th = std::thread([&accessed_from_other_thread, &other_thread_running] {
+ other_thread_running.store(true);
+ auto locked_queue = std::make_unique<LockedQueue>();
+ accessed_from_other_thread.store(true);
+ assert_equal(ToggleQueue::get_default()->cancel(nullptr), false, false);
+ other_thread_running = false;
+ });
+
+ while (!other_thread_running.load())
+ g_assert_false(accessed_from_other_thread.load());
+
+ std::this_thread::sleep_for(std::chrono::milliseconds(100));
+ g_assert_true(other_thread_running);
+ g_assert_false(accessed_from_other_thread);
+
+ auto other_queue = std::make_unique<LockedQueue>();
+ assert_equal(other_queue->tq->cancel(nullptr), false, false);
+
+ other_queue.reset();
+ std::this_thread::sleep_for(std::chrono::milliseconds(100));
+ g_assert_true(other_thread_running);
+ g_assert_false(accessed_from_other_thread);
+
+ // Ok, now other thread may get the lock...
+ locked_queue.reset();
+ while (!accessed_from_other_thread.load()) {
+ }
+ g_assert_true(accessed_from_other_thread);
+
+ // Can enter again from main thread!
+ th.join();
+ g_assert_false(other_thread_running);
+ assert_equal(ToggleQueue::get_default()->cancel(nullptr), false, false);
+}
+
+static void test_toggle_queue_empty(GjsUnitTestFixture*, const void*) {
+ auto tq = ToggleQueue::get_default();
+ tq->handle_all_toggles(toggles_handler);
+ g_assert_true(s_toggle_history.empty());
+}
+
+static void test_toggle_queue_empty_cancel(GjsUnitTestFixture*, const void*) {
+ auto tq = ToggleQueue::get_default();
+ bool toggle_down_queued, toggle_up_queued;
+ std::tie(toggle_down_queued, toggle_up_queued) = tq->cancel(nullptr);
+ g_assert_false(toggle_down_queued);
+ g_assert_false(toggle_up_queued);
+}
+
+static void test_toggle_queue_enqueue_one(GjsUnitTestFixture* fx, const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto tq = ToggleQueue::get_default();
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+
+ tq->handle_all_toggles(toggles_handler);
+ assert_equal(s_toggle_history.size(), 1LU);
+ assert_equal(s_toggle_history.front(), instance,
+ ::ToggleQueue::Direction::UP);
+}
+
+static void test_toggle_queue_enqueue_one_cancel(GjsUnitTestFixture* fx,
+ const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto tq = ToggleQueue::get_default();
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+
+ bool toggle_down_queued, toggle_up_queued;
+ std::tie(toggle_down_queued, toggle_up_queued) = tq->cancel(instance);
+ g_assert_false(toggle_down_queued);
+ g_assert_true(toggle_up_queued);
+
+ tq->handle_all_toggles(toggles_handler);
+ g_assert_true(s_toggle_history.empty());
+}
+
+static void test_toggle_queue_enqueue_many_equal(GjsUnitTestFixture* fx,
+ const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto tq = ToggleQueue::get_default();
+ tq->enqueue(instance, ::ToggleQueue::Direction::DOWN, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::DOWN, toggles_handler);
+
+ tq->handle_all_toggles(toggles_handler);
+ assert_equal(s_toggle_history.size(), 0LU);
+
+ bool toggle_down_queued, toggle_up_queued;
+ std::tie(toggle_down_queued, toggle_up_queued) = tq->cancel(instance);
+ g_assert_false(toggle_down_queued);
+ g_assert_false(toggle_up_queued);
+}
+
+static void test_toggle_queue_enqueue_many_equal_cancel(GjsUnitTestFixture* fx,
+ const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto tq = ToggleQueue::get_default();
+ tq->enqueue(instance, ::ToggleQueue::Direction::DOWN, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::DOWN, toggles_handler);
+
+ bool toggle_down_queued, toggle_up_queued;
+ std::tie(toggle_down_queued, toggle_up_queued) = tq->cancel(instance);
+ g_assert_false(toggle_down_queued);
+ g_assert_false(toggle_up_queued);
+}
+
+static void test_toggle_queue_enqueue_more_up(GjsUnitTestFixture* fx,
+ const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto tq = ToggleQueue::get_default();
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::DOWN, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::DOWN, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+
+ tq->handle_all_toggles(toggles_handler);
+ assert_equal(s_toggle_history.size(), 2LU);
+ assert_equal(s_toggle_history.at(0), instance,
+ ::ToggleQueue::Direction::UP);
+ assert_equal(s_toggle_history.at(1), instance,
+ ::ToggleQueue::Direction::UP);
+
+ bool toggle_down_queued, toggle_up_queued;
+ std::tie(toggle_down_queued, toggle_up_queued) = tq->cancel(instance);
+ g_assert_false(toggle_down_queued);
+ g_assert_false(toggle_up_queued);
+}
+
+static void test_toggle_queue_enqueue_only_up(GjsUnitTestFixture* fx,
+ const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto tq = ToggleQueue::get_default();
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+
+ tq->handle_all_toggles(toggles_handler);
+ assert_equal(s_toggle_history.size(), 4LU);
+ assert_equal(s_toggle_history.at(0), instance,
+ ::ToggleQueue::Direction::UP);
+ assert_equal(s_toggle_history.at(1), instance,
+ ::ToggleQueue::Direction::UP);
+ assert_equal(s_toggle_history.at(2), instance,
+ ::ToggleQueue::Direction::UP);
+ assert_equal(s_toggle_history.at(3), instance,
+ ::ToggleQueue::Direction::UP);
+
+ bool toggle_down_queued, toggle_up_queued;
+ std::tie(toggle_down_queued, toggle_up_queued) = tq->cancel(instance);
+ g_assert_false(toggle_down_queued);
+ g_assert_false(toggle_up_queued);
+}
+
+static void test_toggle_queue_handle_more_up(GjsUnitTestFixture* fx,
+ const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto tq = ToggleQueue::get_default();
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::DOWN, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::DOWN, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+
+ wait_for(50);
+
+ assert_equal(s_toggle_history.size(), 2LU);
+ assert_equal(s_toggle_history.at(0), instance,
+ ::ToggleQueue::Direction::UP);
+ assert_equal(s_toggle_history.at(1), instance,
+ ::ToggleQueue::Direction::UP);
+
+ bool toggle_down_queued, toggle_up_queued;
+ std::tie(toggle_down_queued, toggle_up_queued) = tq->cancel(instance);
+ g_assert_false(toggle_down_queued);
+ g_assert_false(toggle_up_queued);
+}
+
+static void test_toggle_queue_handle_only_up(GjsUnitTestFixture* fx,
+ const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto tq = ToggleQueue::get_default();
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+
+ wait_for(50);
+
+ assert_equal(s_toggle_history.size(), 4LU);
+ assert_equal(s_toggle_history.at(0), instance,
+ ::ToggleQueue::Direction::UP);
+ assert_equal(s_toggle_history.at(1), instance,
+ ::ToggleQueue::Direction::UP);
+ assert_equal(s_toggle_history.at(2), instance,
+ ::ToggleQueue::Direction::UP);
+ assert_equal(s_toggle_history.at(3), instance,
+ ::ToggleQueue::Direction::UP);
+
+ bool toggle_down_queued, toggle_up_queued;
+ std::tie(toggle_down_queued, toggle_up_queued) = tq->cancel(instance);
+ g_assert_false(toggle_down_queued);
+ g_assert_false(toggle_up_queued);
+}
+
+static void test_toggle_queue_enqueue_only_up_cancel(GjsUnitTestFixture* fx,
+ const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto tq = ToggleQueue::get_default();
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+ tq->enqueue(instance, ::ToggleQueue::Direction::UP, toggles_handler);
+
+ bool toggle_down_queued, toggle_up_queued;
+ std::tie(toggle_down_queued, toggle_up_queued) = tq->cancel(instance);
+ g_assert_false(toggle_down_queued);
+ g_assert_true(toggle_up_queued);
+
+ tq->handle_all_toggles(toggles_handler);
+ g_assert_true(s_toggle_history.empty());
+}
+
+static void test_toggle_queue_object_from_main_thread(GjsUnitTestFixture* fx,
+ const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto tq = ToggleQueue::get_default();
+
+ GjsAutoUnref<GObject> reffed(instance->ptr(), GjsAutoTakeOwnership());
+
+ bool toggle_down_queued, toggle_up_queued;
+ std::tie(toggle_down_queued, toggle_up_queued) = tq->cancel(instance);
+ g_assert_false(toggle_down_queued);
+ g_assert_false(toggle_up_queued);
+
+ tq->handle_all_toggles(toggles_handler);
+ g_assert_true(s_toggle_history.empty());
+}
+
+static void test_toggle_queue_object_from_main_thread_already_enqueued(
+ GjsUnitTestFixture* fx, const void*) {
+ auto* instance = new_test_gobject(fx);
+ GjsAutoUnref<GObject> reffed;
+ GjsAutoError error;
+
+ reffed = instance->ptr();
+ gjs_test_tools_ref_other_thread(reffed, error.out());
+ g_assert_no_error(error);
+
+ assert_equal(ToggleQueue::queue().size(), 1LU);
+ assert_equal(ToggleQueue::queue().at(0).object, instance);
+ assert_equal(ToggleQueue::queue().at(0).direction,
+ ::ToggleQueue::Direction::UP);
+
+ auto tq = ToggleQueue::get_default();
+ bool toggle_down_queued, toggle_up_queued;
+ std::tie(toggle_down_queued, toggle_up_queued) = tq->cancel(instance);
+ g_assert_false(toggle_down_queued);
+ g_assert_true(toggle_up_queued);
+
+ tq->handle_all_toggles(toggles_handler);
+ g_assert_true(s_toggle_history.empty());
+}
+
+static void test_toggle_queue_object_from_main_thread_unref_already_enqueued(
+ GjsUnitTestFixture* fx, const void*) {
+ auto* instance = new_test_gobject(fx);
+ GjsAutoUnref<GObject> reffed;
+ GjsAutoError error;
+
+ reffed = instance->ptr();
+ gjs_test_tools_ref_other_thread(reffed, error.out());
+ g_assert_no_error(error);
+ assert_equal(ToggleQueue::queue().size(), 1LU);
+ assert_equal(ToggleQueue::queue().at(0).direction,
+ ::ToggleQueue::Direction::UP);
+
+ reffed.reset();
+ g_assert_true(ToggleQueue::queue().empty());
+
+ auto tq = ToggleQueue::get_default();
+ bool toggle_down_queued, toggle_up_queued;
+ std::tie(toggle_down_queued, toggle_up_queued) = tq->cancel(instance);
+ g_assert_false(toggle_down_queued);
+ g_assert_false(toggle_up_queued);
+
+ tq->handle_all_toggles(toggles_handler);
+ g_assert_true(s_toggle_history.empty());
+}
+
+static void test_toggle_queue_object_from_other_thread_ref_unref(
+ GjsUnitTestFixture* fx, const void*) {
+ auto* instance = new_test_gobject(fx);
+
+ GjsAutoError error;
+ gjs_test_tools_ref_other_thread(instance->ptr(), error.out());
+ g_assert_no_error(error);
+ assert_equal(ToggleQueue::queue().size(), 1LU);
+ assert_equal(ToggleQueue::queue().at(0).direction,
+ ::ToggleQueue::Direction::UP);
+
+ gjs_test_tools_unref_other_thread(instance->ptr(), error.out());
+ g_assert_no_error(error);
+ g_assert_true(ToggleQueue::queue().empty());
+
+ auto tq = ToggleQueue::get_default();
+ bool toggle_down_queued, toggle_up_queued;
+ std::tie(toggle_down_queued, toggle_up_queued) = tq->cancel(instance);
+ g_assert_false(toggle_down_queued);
+ g_assert_false(toggle_up_queued);
+
+ tq->handle_all_toggles(toggles_handler);
+ g_assert_true(s_toggle_history.empty());
+}
+
+static void test_toggle_queue_object_handle_up(GjsUnitTestFixture* fx,
+ const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto* instance_test = reinterpret_cast<ObjectInstance*>(instance);
+
+ GjsAutoError error;
+ gjs_test_tools_ref_other_thread(instance->ptr(), error.out());
+ g_assert_no_error(error);
+ GjsAutoUnref<GObject> reffed(instance->ptr());
+ assert_equal(ToggleQueue::queue().size(), 1LU);
+ assert_equal(ToggleQueue::queue().at(0).direction,
+ ::ToggleQueue::Direction::UP);
+
+ wait_for(50);
+ g_assert_true(instance_test->wrapper_is_rooted());
+ ToggleQueue::get_default()->handle_all_toggles(toggles_handler);
+ g_assert_true(s_toggle_history.empty());
+}
+
+static void test_toggle_queue_object_handle_up_down(GjsUnitTestFixture* fx,
+ const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto* instance_test = reinterpret_cast<ObjectInstance*>(instance);
+
+ GjsAutoError error;
+ gjs_test_tools_ref_other_thread(instance->ptr(), error.out());
+ g_assert_no_error(error);
+ assert_equal(ToggleQueue::queue().size(), 1LU);
+ assert_equal(ToggleQueue::queue().at(0).direction,
+ ::ToggleQueue::Direction::UP);
+
+ gjs_test_tools_unref_other_thread(instance->ptr(), error.out());
+ g_assert_no_error(error);
+ g_assert_true(ToggleQueue::queue().empty());
+
+ wait_for(50);
+ g_assert_false(instance_test->wrapper_is_rooted());
+ ToggleQueue::get_default()->handle_all_toggles(toggles_handler);
+ g_assert_true(s_toggle_history.empty());
+}
+
+static void test_toggle_queue_object_handle_up_down_delayed(
+ GjsUnitTestFixture* fx, const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto* instance_test = reinterpret_cast<ObjectInstance*>(instance);
+
+ GjsAutoError error;
+ gjs_test_tools_ref_other_thread(instance->ptr(), error.out());
+ g_assert_no_error(error);
+ assert_equal(ToggleQueue::queue().size(), 1LU);
+ assert_equal(ToggleQueue::queue().at(0).direction,
+ ::ToggleQueue::Direction::UP);
+
+ wait_for(50);
+ g_assert_true(instance_test->wrapper_is_rooted());
+ ToggleQueue::get_default()->handle_all_toggles(toggles_handler);
+ g_assert_true(s_toggle_history.empty());
+
+ gjs_test_tools_unref_other_thread(instance->ptr(), error.out());
+ g_assert_no_error(error);
+ assert_equal(ToggleQueue::queue().size(), 1LU);
+ assert_equal(ToggleQueue::queue().at(0).direction,
+ ::ToggleQueue::Direction::DOWN);
+
+ wait_for(50);
+ g_assert_false(instance_test->wrapper_is_rooted());
+ ToggleQueue::get_default()->handle_all_toggles(toggles_handler);
+ g_assert_true(s_toggle_history.empty());
+}
+
+static void test_toggle_queue_object_handle_up_down_on_gc(
+ GjsUnitTestFixture* fx, const void*) {
+ auto* instance = new_test_gobject(fx);
+
+ GjsAutoError error;
+ gjs_test_tools_ref_other_thread(instance->ptr(), error.out());
+ g_assert_no_error(error);
+ assert_equal(ToggleQueue::queue().size(), 1LU);
+ assert_equal(ToggleQueue::queue().at(0).direction,
+ ::ToggleQueue::Direction::UP);
+
+ gjs_test_tools_unref_other_thread(instance->ptr(), error.out());
+ g_assert_no_error(error);
+ g_assert_true(ToggleQueue::queue().empty());
+
+ GWeakRef weak_ref;
+ g_weak_ref_init(&weak_ref, instance->ptr());
+
+ TQ::wait_for_gc(fx);
+ g_assert_null(g_weak_ref_get(&weak_ref));
+
+ ToggleQueue::get_default()->handle_all_toggles(toggles_handler);
+ g_assert_true(s_toggle_history.empty());
+}
+
+static void test_toggle_queue_object_handle_many_up(GjsUnitTestFixture* fx,
+ const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto* instance_test = reinterpret_cast<ObjectInstance*>(instance);
+
+ GjsAutoError error;
+ gjs_test_tools_ref_other_thread(instance->ptr(), error.out());
+ g_assert_no_error(error);
+ GjsAutoUnref<GObject> reffed(instance->ptr());
+ // Simulating the case where late threads are causing this...
+ ToggleQueue::get_default()->enqueue(instance, ::ToggleQueue::Direction::UP,
+ ToggleQueue().handler());
+
+ assert_equal(ToggleQueue::queue().size(), 2LU);
+ assert_equal(ToggleQueue::queue().at(0).direction,
+ ::ToggleQueue::Direction::UP);
+ assert_equal(ToggleQueue::queue().at(1).direction,
+ ::ToggleQueue::Direction::UP);
+
+ wait_for(50);
+ g_assert_true(instance_test->wrapper_is_rooted());
+ ToggleQueue::get_default()->handle_all_toggles(toggles_handler);
+ g_assert_true(s_toggle_history.empty());
+}
+
+static void test_toggle_queue_object_handle_many_up_and_down(
+ GjsUnitTestFixture* fx, const void*) {
+ auto* instance = new_test_gobject(fx);
+ auto* instance_test = reinterpret_cast<ObjectInstance*>(instance);
+
+ // This is something similar to what is happening on #297
+ GjsAutoError error;
+ gjs_test_tools_ref_other_thread(instance->ptr(), error.out());
+ g_assert_no_error(error);
+ ToggleQueue::get_default()->enqueue(instance, ::ToggleQueue::Direction::UP,
+ ToggleQueue().handler());
+ gjs_test_tools_unref_other_thread(instance->ptr(), error.out());
+ g_assert_no_error(error);
+ ToggleQueue::get_default()->enqueue(
+ instance, ::ToggleQueue::Direction::DOWN, ToggleQueue().handler());
+
+ g_assert_true(ToggleQueue::queue().empty());
+
+ wait_for(50);
+ g_assert_false(instance_test->wrapper_is_rooted());
+ g_assert_true(ToggleQueue::queue().empty());
+
+ GWeakRef weak_ref;
+ g_assert_true(G_IS_OBJECT(instance->ptr()));
+ g_weak_ref_init(&weak_ref, instance->ptr());
+
+ TQ::wait_for_gc(fx);
+ g_assert_null(g_weak_ref_get(&weak_ref));
+ g_assert_true(ToggleQueue::queue().empty());
+}
+
+void add_tests_for_toggle_queue() {
+ using namespace TQ;
+#define ADD_TOGGLE_QUEUE_TEST(path, f) \
+ g_test_add("/toggle-queue/" path, GjsUnitTestFixture, nullptr, setup, f, \
+ teardown);
+
+ ADD_TOGGLE_QUEUE_TEST("spin-lock/unlock-empty",
+ test_toggle_queue_unlock_empty);
+ ADD_TOGGLE_QUEUE_TEST("spin-lock/unlock-same-thread",
+ test_toggle_queue_unlock_same_thread);
+ ADD_TOGGLE_QUEUE_TEST("spin-lock/blocks-other-thread",
+ test_toggle_blocks_other_thread);
+
+ ADD_TOGGLE_QUEUE_TEST("empty", test_toggle_queue_empty);
+ ADD_TOGGLE_QUEUE_TEST("empty_cancel", test_toggle_queue_empty_cancel);
+ ADD_TOGGLE_QUEUE_TEST("enqueue_one", test_toggle_queue_enqueue_one);
+ ADD_TOGGLE_QUEUE_TEST("enqueue_one_cancel",
+ test_toggle_queue_enqueue_one_cancel);
+ ADD_TOGGLE_QUEUE_TEST("enqueue_many_equal",
+ test_toggle_queue_enqueue_many_equal);
+ ADD_TOGGLE_QUEUE_TEST("enqueue_many_equal_cancel",
+ test_toggle_queue_enqueue_many_equal_cancel);
+ ADD_TOGGLE_QUEUE_TEST("enqueue_more_up", test_toggle_queue_enqueue_more_up);
+ ADD_TOGGLE_QUEUE_TEST("enqueue_only_up", test_toggle_queue_enqueue_only_up);
+ ADD_TOGGLE_QUEUE_TEST("enqueue_only_up_cancel",
+ test_toggle_queue_enqueue_only_up_cancel);
+ ADD_TOGGLE_QUEUE_TEST("handle_more_up", test_toggle_queue_handle_more_up);
+ ADD_TOGGLE_QUEUE_TEST("handle_only_up", test_toggle_queue_handle_only_up);
+
+ ADD_TOGGLE_QUEUE_TEST("object/not-enqueued_main_thread",
+ test_toggle_queue_object_from_main_thread);
+ ADD_TOGGLE_QUEUE_TEST(
+ "object/already_enqueued_main_thread",
+ test_toggle_queue_object_from_main_thread_already_enqueued);
+ ADD_TOGGLE_QUEUE_TEST(
+ "object/already_enqueued_unref_main_thread",
+ test_toggle_queue_object_from_main_thread_unref_already_enqueued);
+ ADD_TOGGLE_QUEUE_TEST("object/ref_unref_other_thread",
+ test_toggle_queue_object_from_other_thread_ref_unref);
+ ADD_TOGGLE_QUEUE_TEST("object/handle_up",
+ test_toggle_queue_object_handle_up);
+ ADD_TOGGLE_QUEUE_TEST("object/handle_up_down",
+ test_toggle_queue_object_handle_up_down);
+ ADD_TOGGLE_QUEUE_TEST("object/handle_up_down_delayed",
+ test_toggle_queue_object_handle_up_down_delayed);
+ ADD_TOGGLE_QUEUE_TEST("object/handle_up_down_on_gc",
+ test_toggle_queue_object_handle_up_down_on_gc);
+ ADD_TOGGLE_QUEUE_TEST("object/handle_many_up",
+ test_toggle_queue_object_handle_many_up);
+ ADD_TOGGLE_QUEUE_TEST("object/handle_many_up_and_down",
+ test_toggle_queue_object_handle_many_up_and_down);
+
+#undef ADD_TOGGLE_QUEUE_TEST
+}
+
+} // namespace Test
+} // namespace Gjs
diff --git a/test/gjs-test-utils.h b/test/gjs-test-utils.h
index 5ec140db..2fe5356a 100644
--- a/test/gjs-test-utils.h
+++ b/test/gjs-test-utils.h
@@ -42,9 +42,11 @@ void gjs_test_add_tests_for_jsapi_utils();
namespace Gjs {
namespace Test {
+void add_tests_for_toggle_queue();
+
template <typename T>
constexpr void assert_equal(T a, T b) {
- if constexpr (std::is_integral_v<T>) {
+ if constexpr (std::is_integral_v<T> || std::is_enum_v<T>) {
if constexpr (std::is_unsigned_v<T>)
g_assert_cmpuint(a, ==, b);
else
@@ -63,6 +65,12 @@ constexpr void assert_equal(T a, T b) {
}
}
+template <typename T, typename U>
+constexpr void assert_equal(std::pair<T, U> const& pair, T first, U second) {
+ assert_equal(pair.first, first);
+ assert_equal(pair.second, second);
+}
+
} // namespace Test
} // namespace Gjs
diff --git a/test/gjs-tests-internal.cpp b/test/gjs-tests-internal.cpp
new file mode 100644
index 00000000..3346935d
--- /dev/null
+++ b/test/gjs-tests-internal.cpp
@@ -0,0 +1,26 @@
+/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
+// SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
+// SPDX-FileCopyrightText: 2021 Canonical, Ltd.
+// SPDX-FileContributor: Marco Trevisan <marco trevisan canonical com>
+
+#include <config.h>
+#include <glib.h>
+
+#include "test/gjs-test-utils.h"
+
+int main(int argc, char** argv) {
+ /* Avoid interference in the tests from stray environment variable */
+ g_unsetenv("GJS_ENABLE_PROFILER");
+ g_unsetenv("GJS_TRACE_FD");
+
+ g_test_init(&argc, &argv, nullptr);
+
+ gjs_test_add_tests_for_rooting();
+ gjs_test_add_tests_for_parse_call_args();
+ gjs_test_add_tests_for_jsapi_utils();
+ Gjs::Test::add_tests_for_toggle_queue();
+
+ g_test_run();
+
+ return 0;
+}
diff --git a/test/gjs-tests.cpp b/test/gjs-tests.cpp
index 8eda4e27..e3c95858 100644
--- a/test/gjs-tests.cpp
+++ b/test/gjs-tests.cpp
@@ -45,10 +45,10 @@ void g_assertion_message(const char*, const char*, int, const char*,
#define VALID_UTF8_STRING "\303\211\303\226 foobar \343\203\237"
+namespace Gjs {
+namespace Test {
static unsigned cpp_random_seed = 0;
-using namespace Gjs::Test; // NOLINT(build/namespaces)
-
template <typename T>
T get_random_number() {
std::mt19937_64 gen(cpp_random_seed);
@@ -847,10 +847,15 @@ static void gjstest_test_func_gjs_context_argv_array() {
g_assert_false(ok);
}
+} // namespace Test
+} // namespace Gjs
+
int
main(int argc,
char **argv)
{
+ using namespace Gjs::Test;
+
/* Avoid interference in the tests from stray environment variable */
g_unsetenv("GJS_ENABLE_PROFILER");
g_unsetenv("GJS_TRACE_FD");
@@ -955,9 +960,6 @@ main(int argc,
#undef ADD_JSAPI_UTIL_TEST
gjs_test_add_tests_for_coverage ();
- gjs_test_add_tests_for_parse_call_args();
- gjs_test_add_tests_for_rooting();
- gjs_test_add_tests_for_jsapi_utils();
g_test_run();
diff --git a/test/meson.build b/test/meson.build
index 83c63067..0e35979f 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -7,21 +7,44 @@ mock_js_resources_files = gnome.compile_resources('mock-js-resources',
'mock-js-resources.gresource.xml', c_name: 'mock_js_resources',
source_dir: '..')
+libgjs_tests_common = static_library('libgjs-tests-common',
+ sources: [
+ 'gjs-test-utils.cpp', 'gjs-test-utils.h',
+ 'gjs-test-common.cpp', 'gjs-test-common.h',
+ ],
+ cpp_args: libgjs_cpp_args,
+ include_directories: top_include, dependencies: libgjs_dependencies,
+)
+
gjs_tests_sources = [
'gjs-tests.cpp',
- 'gjs-test-common.cpp', 'gjs-test-common.h',
- 'gjs-test-utils.cpp', 'gjs-test-utils.h',
- 'gjs-test-call-args.cpp',
'gjs-test-coverage.cpp',
- 'gjs-test-rooting.cpp',
- 'gjs-test-jsapi-utils.cpp',
'gjs-test-no-introspection-object.cpp', 'gjs-test-no-introspection-object.h',
]
gjs_tests = executable('gjs-tests', gjs_tests_sources, mock_js_resources_files,
- cpp_args: ['-DGJS_COMPILATION'] + directory_defines,
- include_directories: top_include, dependencies: libgjs_dep)
+ include_directories: top_include, dependencies: libgjs_dep,
+ link_with: libgjs_tests_common)
test('API tests', gjs_tests, args: ['--tap', '--keep-going', '--verbose'],
depends: gjs_private_typelib, env: tests_environment, protocol: 'tap',
suite: 'C', timeout: 60)
+
+gjs_tests_internal = executable('gjs-tests-internal',
+ sources: [
+ 'gjs-tests-internal.cpp',
+ 'gjs-test-call-args.cpp',
+ 'gjs-test-rooting.cpp',
+ 'gjs-test-jsapi-utils.cpp',
+ 'gjs-test-toggle-queue.cpp',
+ module_resource_srcs,
+ ],
+ include_directories: top_include,
+ cpp_args: libgjs_cpp_args,
+ dependencies: [libgjs_dependencies, libgjstesttools_dep],
+ link_with: [libgjs_tests_common, libgjs_internal])
+
+test('Internal API tests', gjs_tests_internal,
+ args: ['--tap', '--keep-going', '--verbose'],
+ env: tests_environment, protocol: 'tap',
+ suite: ['C', 'thread-safe'])
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
