gdx: Introduce extensible gdx unittests am: d42aa94714 (4c0316bc) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -460,6 +460,7 @@ cc_test {
		host_supported: true,
		srcs: [
		":TestCommonMockFunctions",
		"module_gdx_unittest.cc",
		"module_jniloop_unittest.cc",
		"module_mainloop_unittest.cc",
		],

system/gd/module_gdx_unittest.cc

0 → 100644

+341 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2023 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include "module_gdx_unittest.h"

		#include <base/callback.h>
		#include <base/functional/bind.h>
		#include <base/location.h>
		#include <base/threading/platform_thread.h>
		#include <sys/syscall.h>

		#include <string>

		#include "gtest/gtest.h"
		#include "module.h"
		#include "os/handler.h"

		using namespace bluetooth;

		namespace {
		constexpr int sync_timeout_in_ms = 3000;

		std::promise<pid_t> gdx_external_function_promise;
		std::promise<pid_t> private_impl_promise;
		std::promise<pid_t> protected_method_promise;

		} // namespace

		// Global function with C linkage
		void external_function_gdx(int /* a /, double / b /, char / c */) {
		gdx_external_function_promise.set_value(base::PlatformThread::CurrentId());
		}

		// Module private implementation that is inaccessible externally
		struct TestGdxModule::PrivateImpl : public ModuleMainloop, public ModuleJniloop {
		const int kMaxTestGdxModuleRecurseDepth = 10;

		void privateCallableMethod(int /* a /, double / b /, char / c */) {
		private_impl_promise.set_value(base::PlatformThread::CurrentId());
		}

		void repostMethodTest(int /* a /, double / b /, char / c */) {
		private_impl_promise.set_value(base::PlatformThread::CurrentId());
		}

		void privateCallableRepostOnMainMethod(
		std::shared_ptr<TestGdxModule::PrivateImpl> ptr, int a, double b, char c) {
		PostMethodOnMain(ptr, &PrivateImpl::repostMethodTest, a, b, c);
		}

		void privateCallableRepostOnJniMethod(
		std::shared_ptr<TestGdxModule::PrivateImpl> ptr, int a, double b, char c) {
		PostMethodOnJni(ptr, &PrivateImpl::repostMethodTest, a, b, c);
		}

		void privateCallableRecursiveOnMainMethod(
		std::shared_ptr<TestGdxModule::PrivateImpl> ptr, int depth, double b, char c) {
		if (depth > kMaxTestGdxModuleRecurseDepth) {
		private_impl_promise.set_value(base::PlatformThread::CurrentId());
		return;
		}
		PostMethodOnMain(ptr, &PrivateImpl::privateCallableRecursiveOnMainMethod, ptr, depth + 1, b, c);
		}

		void privateCallableRecursiveOnJniMethod(
		std::shared_ptr<TestGdxModule::PrivateImpl> ptr, int depth, double b, char c) {
		if (depth > kMaxTestGdxModuleRecurseDepth) {
		private_impl_promise.set_value(base::PlatformThread::CurrentId());
		return;
		}
		PostMethodOnJni(ptr, &PrivateImpl::privateCallableRecursiveOnJniMethod, ptr, depth + 1, b, c);
		}
		};

		// Protected module method executed on handler
		void TestGdxModule::call_on_handler_protected_method(int loop_tid, int a, int b, int c) {
		protected_method_promise = std::promise<pid_t>();
		auto future = protected_method_promise.get_future();
		CallOn(this, &TestGdxModule::protected_method, a, b, c);
		ASSERT_EQ(future.wait_for(std::chrono::seconds(3)), std::future_status::ready);
		ASSERT_EQ(future.get(), loop_tid);
		}

		// Global external function executed on main loop
		void TestGdxModule::call_on_main_external_function(int loop_tid, int a, double b, char c) {
		gdx_external_function_promise = std::promise<pid_t>();
		auto future = gdx_external_function_promise.get_future();
		PostFunctionOnMain(&external_function_gdx, a, b, c);
		ASSERT_EQ(future.wait_for(std::chrono::seconds(3)), std::future_status::ready);
		ASSERT_EQ(future.get(), loop_tid);
		}

		// Private implementation method executed on main loop
		void TestGdxModule::call_on_main(int loop_tid, int a, int b, int c) {
		private_impl_promise = std::promise<pid_t>();
		auto future = private_impl_promise.get_future();
		PostMethodOnMain(pimpl_, &TestGdxModule::PrivateImpl::privateCallableMethod, a, b, c);
		ASSERT_EQ(future.wait_for(std::chrono::seconds(3)), std::future_status::ready);
		ASSERT_EQ(future.get(), loop_tid);
		}

		// Private implementation method executed on main loop and reposted
		void TestGdxModule::call_on_main_repost(int loop_tid, int a, int b, int c) {
		private_impl_promise = std::promise<pid_t>();
		auto future = private_impl_promise.get_future();
		PostMethodOnMain(
		pimpl_, &TestGdxModule::PrivateImpl::privateCallableRepostOnMainMethod, pimpl_, a, b, c);
		ASSERT_EQ(future.wait_for(std::chrono::seconds(3)), std::future_status::ready);
		ASSERT_EQ(future.get(), loop_tid);
		}

		// Private implementation method executed on main loop recursively
		void TestGdxModule::call_on_main_recurse(int loop_tid, int depth, int b, int c) {
		private_impl_promise = std::promise<pid_t>();
		auto future = private_impl_promise.get_future();
		PostMethodOnMain(
		pimpl_,
		&TestGdxModule::PrivateImpl::privateCallableRecursiveOnMainMethod,
		pimpl_,
		depth,
		b,
		c);
		ASSERT_EQ(future.wait_for(std::chrono::seconds(3)), std::future_status::ready);
		ASSERT_EQ(future.get(), loop_tid);
		}

		// Global external function executed on main loop
		void TestGdxModule::call_on_jni_external_function(int loop_tid, int a, double b, char c) {
		gdx_external_function_promise = std::promise<pid_t>();
		auto future = gdx_external_function_promise.get_future();
		PostFunctionOnJni(&external_function_gdx, a, b, c);
		ASSERT_EQ(future.wait_for(std::chrono::seconds(3)), std::future_status::ready);
		ASSERT_EQ(future.get(), loop_tid);
		}

		// Private implementation method executed on main loop
		void TestGdxModule::call_on_jni(int loop_tid, int a, int b, int c) {
		private_impl_promise = std::promise<pid_t>();
		auto future = private_impl_promise.get_future();
		PostMethodOnJni(pimpl_, &TestGdxModule::PrivateImpl::privateCallableMethod, a, b, c);
		ASSERT_EQ(future.wait_for(std::chrono::seconds(3)), std::future_status::ready);
		ASSERT_EQ(future.get(), loop_tid);
		}

		// Private implementation method executed on main loop and reposted
		void TestGdxModule::call_on_jni_repost(int loop_tid, int a, int b, int c) {
		private_impl_promise = std::promise<pid_t>();
		auto future = private_impl_promise.get_future();
		PostMethodOnJni(
		pimpl_, &TestGdxModule::PrivateImpl::privateCallableRepostOnJniMethod, pimpl_, a, b, c);
		ASSERT_EQ(future.wait_for(std::chrono::seconds(3)), std::future_status::ready);
		ASSERT_EQ(future.get(), loop_tid);
		}

		// Private implementation method executed on main loop recursively
		void TestGdxModule::call_on_jni_recurse(int loop_tid, int depth, int b, int c) {
		private_impl_promise = std::promise<pid_t>();
		auto future = private_impl_promise.get_future();
		PostMethodOnJni(
		pimpl_,
		&TestGdxModule::PrivateImpl::privateCallableRecursiveOnJniMethod,
		pimpl_,
		depth,
		b,
		c);
		ASSERT_EQ(future.wait_for(std::chrono::seconds(3)), std::future_status::ready);
		ASSERT_EQ(future.get(), loop_tid);
		}
		void TestGdxModule::protected_method(int /* a /, int / b /, int / c */) {
		protected_method_promise.set_value(base::PlatformThread::CurrentId());
		}

		bool TestGdxModule::IsStarted() const {
		return pimpl_ != nullptr;
		}

		void TestGdxModule::Start() {
		ASSERT_FALSE(IsStarted());
		pimpl_ = std::make_shared<TestGdxModule::PrivateImpl>();
		}

		void TestGdxModule::Stop() {
		ASSERT_TRUE(IsStarted());
		pimpl_.reset();
		}

		std::string TestGdxModule::ToString() const {
		return std::string(__func__);
		}

		const bluetooth::ModuleFactory TestGdxModule::Factory =
		bluetooth::ModuleFactory([]() { return new TestGdxModule(); });

		//
		// Module GDx Testing Below
		//
		class ModuleGdxTest : public ::testing::Test {
		protected:
		void SetUp() override {
		test_framework_tid_ = base::PlatformThread::CurrentId();
		module_ = new TestGdxModule();
		main_thread_start_up();
		mainloop_tid_ = get_mainloop_tid();
		jni_thread_startup();
		jniloop_tid_ = get_jniloop_tid();
		}

		void TearDown() override {
		sync_main_handler();
		main_thread_shut_down();
		jni_thread_shutdown();
		delete module_;
		}

		void sync_main_handler() {
		std::promise promise = std::promise<void>();
		std::future future = promise.get_future();
		post_on_bt_main([&promise]() { promise.set_value(); });
		future.wait_for(std::chrono::milliseconds(sync_timeout_in_ms));
		};

		void sync_jni_handler() {
		std::promise promise = std::promise<void>();
		std::future future = promise.get_future();
		post_on_bt_jni([&promise]() { promise.set_value(); });
		future.wait_for(std::chrono::milliseconds(sync_timeout_in_ms));
		};

		static pid_t get_mainloop_tid() {
		std::promise<pid_t> pid_promise = std::promise<pid_t>();
		auto future = pid_promise.get_future();
		post_on_bt_main([&pid_promise]() { pid_promise.set_value(base::PlatformThread::CurrentId()); });
		return future.get();
		}

		static pid_t get_jniloop_tid() {
		std::promise<pid_t> pid_promise = std::promise<pid_t>();
		auto future = pid_promise.get_future();
		post_on_bt_jni([&pid_promise]() { pid_promise.set_value(base::PlatformThread::CurrentId()); });
		return future.get();
		}

		pid_t test_framework_tid_{-1};
		pid_t mainloop_tid_{-1};
		pid_t jniloop_tid_{-1};
		TestModuleRegistry module_registry_;
		TestGdxModule* module_;
		};

		class ModuleGdxWithStackTest : public ModuleGdxTest {
		protected:
		void SetUp() override {
		ModuleGdxTest::SetUp();
		module_registry_.InjectTestModule(&TestGdxModule::Factory, module_ /* pass ownership */);
		module_ = nullptr; // ownership is passed
		handler_tid_ = get_handler_tid(module_registry_.GetTestModuleHandler(&TestGdxModule::Factory));
		}

		static pid_t get_handler_tid(os::Handler* handler) {
		std::promise<pid_t> handler_tid_promise = std::promise<pid_t>();
		std::future<pid_t> future = handler_tid_promise.get_future();
		handler->Post(common::BindOnce(
		[](std::promise<pid_t> promise) { promise.set_value(base::PlatformThread::CurrentId()); },
		std::move(handler_tid_promise)));
		return future.get();
		}

		void TearDown() override {
		module_registry_.StopAll();
		ModuleGdxTest::TearDown();
		}

		TestGdxModule* Mod() {
		return module_registry_.GetModuleUnderTest<TestGdxModule>();
		}

		pid_t handler_tid_{-1};
		};

		TEST_F(ModuleGdxTest, nop) {}

		TEST_F(ModuleGdxTest, lifecycle) {
		::bluetooth::os::Thread* thread =
		new bluetooth::os::Thread("Name", bluetooth::os::Thread::Priority::REAL_TIME);
		ASSERT_FALSE(module_registry_.IsStarted<TestGdxModule>());
		module_registry_.Start<TestGdxModule>(thread);
		ASSERT_TRUE(module_registry_.IsStarted<TestGdxModule>());
		module_registry_.StopAll();
		ASSERT_FALSE(module_registry_.IsStarted<TestGdxModule>());
		delete thread;
		}

		// internal handler
		TEST_F(ModuleGdxWithStackTest, call_on_handler_protected_method) {
		Mod()->call_on_handler_protected_method(handler_tid_, 1, 2, 3);
		}

		TEST_F(ModuleGdxWithStackTest, test_call_on_main) {
		Mod()->call_on_main(mainloop_tid_, 1, 2, 3);
		}

		TEST_F(ModuleGdxWithStackTest, test_call_gdx_external_function_on_main) {
		Mod()->call_on_main_external_function(mainloop_tid_, 1, 2.3, 'c');
		}

		TEST_F(ModuleGdxWithStackTest, test_call_on_main_repost) {
		Mod()->call_on_main_repost(mainloop_tid_, 1, 2, 3);
		}

		TEST_F(ModuleGdxWithStackTest, test_call_on_main_recurse) {
		Mod()->call_on_main_recurse(mainloop_tid_, 1, 2, 3);
		}

		TEST_F(ModuleGdxWithStackTest, test_call_on_jni) {
		Mod()->call_on_jni(jniloop_tid_, 1, 2, 3);
		}

		TEST_F(ModuleGdxWithStackTest, test_call_gdx_external_function_on_jni) {
		Mod()->call_on_jni_external_function(jniloop_tid_, 1, 2.3, 'c');
		}

		TEST_F(ModuleGdxWithStackTest, test_call_on_jni_repost) {
		Mod()->call_on_jni_repost(jniloop_tid_, 1, 2, 3);
		}

		TEST_F(ModuleGdxWithStackTest, test_call_on_jni_recurse) {
		Mod()->call_on_jni_recurse(jniloop_tid_, 1, 2, 3);
		}

system/gd/module_gdx_unittest.h

0 → 100644

+64 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2023 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <base/callback.h>
		#include <base/functional/bind.h>
		#include <base/location.h>

		#include <string>

		#include "module.h"
		#include "module_jniloop.h"
		#include "module_mainloop.h"

		using namespace bluetooth;

		void external_function(int /* a /, double / b /, char / c */);

		class TestGdxModule : public Module, public ModuleMainloop, public ModuleJniloop {
		public:
		void call_on_handler_protected_method(pid_t tid, int a, int b, int c);
		void call_on_main_external_function(pid_t tid, int a, double b, char c);
		void call_on_main(pid_t tid, int a, int b, int c);
		void call_on_main_repost(pid_t tid, int a, int b, int c);
		void call_on_main_recurse(pid_t tid, int a, int b, int c);

		void call_on_jni_external_function(pid_t tid, int a, double b, char c);
		void call_on_jni(pid_t tid, int a, int b, int c);
		void call_on_jni_repost(pid_t tid, int a, int b, int c);
		void call_on_jni_recurse(pid_t tid, int a, int b, int c);

		static const bluetooth::ModuleFactory Factory;

		protected:
		void protected_method(int a, int b, int c);
		void call_on_main_internal(int a, int b, int c);
		void call_on_jni_internal(int a, int b, int c);
		bool IsStarted() const;

		void ListDependencies(bluetooth::ModuleList* /* list */) const override {}
		void Start() override;
		void Stop() override;
		std::string ToString() const override;

		private:
		struct PrivateImpl;
		std::shared_ptr<TestGdxModule::PrivateImpl> pimpl_;

		bool started_ = false;

		friend bluetooth::ModuleRegistry;
		};