From 7bfa4b4054da704ccc12cdb1a74727f53224a3e8 Mon Sep 17 00:00:00 2001 From: "jh9216.park" Date: Mon, 24 May 2021 21:47:32 -0400 Subject: [PATCH] Add TCs and dbus mock - Add DbusMock class - Add a TC for aul_terminate_pid_without_restart - Add a TC for aul_terminate_app - Add a TC for aul_is_tep_mount_dbus_done - Add a TC for aul_check_tep_mount Change-Id: I2f42a0990e31a1010685c04e8b75d14f65c3eb07 Signed-off-by: jh9216.park --- test/unit_tests/mock/dbus_mock.cc | 60 ++++++++++++ test/unit_tests/mock/dbus_mock.h | 66 +++++++++++++ test/unit_tests/test_launch.cc | 188 +++++++++++++++++++++++++++++++------- 3 files changed, 280 insertions(+), 34 deletions(-) create mode 100644 test/unit_tests/mock/dbus_mock.cc create mode 100644 test/unit_tests/mock/dbus_mock.h diff --git a/test/unit_tests/mock/dbus_mock.cc b/test/unit_tests/mock/dbus_mock.cc new file mode 100644 index 0000000..457c0f2 --- /dev/null +++ b/test/unit_tests/mock/dbus_mock.cc @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 + +#include "mock/dbus_mock.h" +#include "mock/mock_hook.h" +#include "mock/test_fixture.h" + +extern "C" GDBusConnection* g_bus_get_sync(GBusType bus_type, + GCancellable* cancellable, GError** error) { + return MOCK_HOOK_P3(DbusMock, g_bus_get_sync, bus_type, cancellable, error); +} + +extern "C" guint g_dbus_connection_signal_subscribe(GDBusConnection* arg0, + const gchar* arg1, const gchar* arg2, const gchar* arg3, const gchar* arg4, + const gchar* arg5, GDBusSignalFlags arg6, GDBusSignalCallback arg7, + gpointer arg8, GDestroyNotify arg9) { + return MOCK_HOOK_P10(DbusMock, g_dbus_connection_signal_subscribe, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); +} + +extern "C" void g_object_unref(gpointer object) { + MOCK_HOOK_P1(DbusMock, g_object_unref, object); +} + +extern "C" GDBusMessage* g_dbus_message_new_method_call(const gchar* arg0, + const gchar* arg1, const gchar* arg2, const gchar* arg3) { + return MOCK_HOOK_P4(DbusMock, g_dbus_message_new_method_call, arg0, arg1, + arg2, arg3); +} + +extern "C" void g_dbus_message_set_body(GDBusMessage* arg0, GVariant* arg1) { + return MOCK_HOOK_P2(DbusMock, g_dbus_message_set_body, arg0, arg1); +} + +extern "C" GDBusMessage* g_dbus_connection_send_message_with_reply_sync( + GDBusConnection* conn, GDBusMessage* msg, GDBusSendMessageFlags flags, + gint timeout, volatile guint32* out_serial, GCancellable* cancellable, + GError** error) { + return MOCK_HOOK_P7(DbusMock, g_dbus_connection_send_message_with_reply_sync, + conn, msg, flags, timeout, out_serial, cancellable, error); +} + +extern "C" GVariant* g_dbus_message_get_body(GDBusMessage* arg0) { + return MOCK_HOOK_P1(DbusMock, g_dbus_message_get_body, arg0); +} diff --git a/test/unit_tests/mock/dbus_mock.h b/test/unit_tests/mock/dbus_mock.h new file mode 100644 index 0000000..a0288d1 --- /dev/null +++ b/test/unit_tests/mock/dbus_mock.h @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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. + */ + +#ifndef UNIT_TESTS_MOCK_DBUS_MOCK_H_ +#define UNIT_TESTS_MOCK_DBUS_MOCK_H_ + +#include +#include +#include + +#include "mock/module_mock.h" + +class DbusMock : public virtual ModuleMock { + public: + DbusMock() { + using ::testing::_; + using ::testing::Return; + using ::testing::Invoke; + + static int dummy; + GDBusConnection* conn = (GDBusConnection*)&dummy; + GDBusMessage* msg = (GDBusMessage*)&dummy; + GDBusMessage* reply = (GDBusMessage*)&dummy; + + ON_CALL(*this, g_bus_get_sync(_, _, _)) + .WillByDefault(Return(conn)); + + ON_CALL(*this, g_dbus_message_new_method_call(_, _, _, _)) + .WillByDefault(Return(msg)); + + ON_CALL(*this, g_dbus_connection_send_message_with_reply_sync( + _, _, _, _, _, _, _)) + .WillByDefault(Return(reply)); + } + + MOCK_METHOD3(g_bus_get_sync, GDBusConnection* (GBusType, GCancellable*, + GError**)); + MOCK_METHOD10(g_dbus_connection_signal_subscribe, + guint (GDBusConnection*, const gchar*, const gchar*, const gchar*, + const gchar*, const gchar*, GDBusSignalFlags, GDBusSignalCallback, + gpointer, GDestroyNotify)); + MOCK_METHOD1(g_object_unref, void (gpointer)); + MOCK_METHOD4(g_dbus_message_new_method_call, + GDBusMessage* (const gchar*, const gchar*, const gchar*, const gchar*)); + MOCK_METHOD2(g_dbus_message_set_body, void (GDBusMessage*, GVariant*)); + MOCK_METHOD1(g_dbus_message_get_body, GVariant* (GDBusMessage*)); + MOCK_METHOD7(g_dbus_connection_send_message_with_reply_sync, + GDBusMessage* (GDBusConnection*, GDBusMessage*, GDBusSendMessageFlags, + gint, volatile guint32*, GCancellable*, GError**)); +}; + +#endif // UNIT_TESTS_MOCK_DBUS_MOCK_H_ + diff --git a/test/unit_tests/test_launch.cc b/test/unit_tests/test_launch.cc index 09d78ba..ea1cc26 100644 --- a/test/unit_tests/test_launch.cc +++ b/test/unit_tests/test_launch.cc @@ -25,10 +25,10 @@ #include #include "launch.h" -#include "mock/socket_mock.h" +#include "mock/dbus_mock.h" #include "mock/mock_hook.h" -#include "mock/test_fixture.h" #include "mock/socket_mock.h" +#include "mock/test_fixture.h" using ::testing::_; using ::testing::DoAll; @@ -39,7 +39,8 @@ using ::testing::SaveArg; namespace { -class Mocks : virtual public ::testing::NiceMock {}; +class Mocks : virtual public ::testing::NiceMock, + virtual public ::testing::NiceMock {}; } // namespace @@ -60,7 +61,8 @@ TEST_F(LaunchTest, aul_launch_app) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -87,7 +89,8 @@ TEST_F(LaunchTest, aul_launch_app_async) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -113,14 +116,16 @@ TEST_F(LaunchTest, aul_terminate_pid) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; })); EXPECT_CALL(GetMock(), recv(_, _, _, _)) .Times(1) - .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) + -> ssize_t { int ret = 0; memcpy(buf, &ret, sizeof(int)); return sizeof(int); @@ -139,14 +144,16 @@ TEST_F(LaunchTest, aul_terminate_pid_sync) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; })); EXPECT_CALL(GetMock(), recv(_, _, _, _)) .Times(1) - .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) + -> ssize_t { int ret = 0; memcpy(buf, &ret, sizeof(int)); return sizeof(int); @@ -165,14 +172,16 @@ TEST_F(LaunchTest, aul_terminate_pid_async) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; })); EXPECT_CALL(GetMock(), recv(_, _, _, _)) .Times(1) - .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) + -> ssize_t { int ret = 0; memcpy(buf, &ret, sizeof(int)); return sizeof(int); @@ -191,7 +200,8 @@ TEST_F(LaunchTest, aul_open_app) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -217,7 +227,8 @@ TEST_F(LaunchTest, aul_resume_app) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -243,14 +254,16 @@ TEST_F(LaunchTest, aul_resume_pid) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; })); EXPECT_CALL(GetMock(), recv(_, _, _, _)) .Times(1) - .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) + -> ssize_t { int ret = 0; memcpy(buf, &ret, sizeof(int)); return sizeof(int); @@ -269,14 +282,16 @@ TEST_F(LaunchTest, aul_resume_pid_async) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; })); EXPECT_CALL(GetMock(), recv(_, _, _, _)) .Times(1) - .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) + -> ssize_t { int ret = 0; memcpy(buf, &ret, sizeof(int)); return sizeof(int); @@ -295,7 +310,8 @@ TEST_F(LaunchTest, aul_pause_app) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -316,7 +332,8 @@ TEST_F(LaunchTest, aul_pause_pid) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -337,14 +354,16 @@ TEST_F(LaunchTest, aul_app_is_running) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; })); EXPECT_CALL(GetMock(), recv(_, _, _, _)) .Times(1) - .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) + -> ssize_t { int ret = 1; memcpy(buf, &ret, sizeof(int)); return sizeof(int); @@ -363,7 +382,8 @@ TEST_F(LaunchTest, aul_prepare_app_defined_loader) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -389,7 +409,8 @@ TEST_F(LaunchTest, aul_terminate_app_with_instance_id) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -415,7 +436,8 @@ TEST_F(LaunchTest, aul_terminate_instance_async) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -441,7 +463,8 @@ TEST_F(LaunchTest, aul_resume_app_by_instance_id) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -467,7 +490,8 @@ TEST_F(LaunchTest, aul_prepare_candidate_process) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -493,7 +517,8 @@ TEST_F(LaunchTest, aul_app_register_pid) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -514,14 +539,16 @@ TEST_F(LaunchTest, aul_add_loader) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; })); EXPECT_CALL(GetMock(), recv(_, _, _, _)) .Times(1) - .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) + -> ssize_t { int ret = 0; memcpy(buf, &ret, sizeof(int)); return sizeof(int); @@ -541,7 +568,8 @@ TEST_F(LaunchTest, aul_remove_loader) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -567,7 +595,8 @@ TEST_F(LaunchTest, aul_reload_appinfo) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -593,7 +622,8 @@ TEST_F(LaunchTest, aul_kill_pid) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -619,7 +649,8 @@ TEST_F(LaunchTest, aul_terminate_pid_sync_without_restart) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -645,7 +676,8 @@ TEST_F(LaunchTest, aul_terminate_bgapp_pid) { .Times(1); EXPECT_CALL(GetMock(), send(_, _, _, _)) .Times(1) - .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) -> ssize_t { + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { const app_pkt_t* header = reinterpret_cast(buf); cmd = header->cmd; return n; @@ -662,3 +694,91 @@ TEST_F(LaunchTest, aul_terminate_bgapp_pid) { EXPECT_EQ(ret, AUL_R_OK); EXPECT_EQ(cmd, APP_TERM_BGAPP_BY_PID); } + +TEST_F(LaunchTest, aul_terminate_pid_without_restart) { + int cmd = -1; + EXPECT_CALL(GetMock(), socket(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), connect(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), send(_, _, _, _)) + .Times(1) + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { + const app_pkt_t* header = reinterpret_cast(buf); + cmd = header->cmd; + return n; + })); + EXPECT_CALL(GetMock(), recv(_, _, _, _)) + .Times(1) + .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) -> ssize_t { + int ret = 0; + memcpy(buf, &ret, sizeof(int)); + return sizeof(int); + })); + + int ret = aul_terminate_pid_without_restart(100); + EXPECT_EQ(ret, AUL_R_OK); + EXPECT_EQ(cmd, APP_TERM_BY_PID_WITHOUT_RESTART); +} + +TEST_F(LaunchTest, aul_terminate_app) { + int cmd = -1; + EXPECT_CALL(GetMock(), socket(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), connect(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), send(_, _, _, _)) + .Times(1) + .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags) + -> ssize_t { + const app_pkt_t* header = reinterpret_cast(buf); + cmd = header->cmd; + return n; + })); + EXPECT_CALL(GetMock(), recv(_, _, _, _)) + .Times(1) + .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) -> ssize_t { + int ret = 0; + memcpy(buf, &ret, sizeof(int)); + return sizeof(int); + })); + + int ret = aul_terminate_app("test-app"); + EXPECT_EQ(ret, AUL_R_OK); + EXPECT_EQ(cmd, APP_TERMINATE); +} + +TEST_F(LaunchTest, aul_is_tep_mount_dbus_done) { + EXPECT_CALL(GetMock(), + g_dbus_connection_send_message_with_reply_sync(_, _, _, _, _, _, _)) + .Times(1); + + std::unique_ptr v_auto( + g_variant_new("(i)", 1), g_variant_unref); + EXPECT_CALL(GetMock(), g_dbus_message_get_body(_)) + .Times(1) + .WillOnce(Invoke([&](GDBusMessage* arg0) -> GVariant* { + return v_auto.get(); + })); + + int ret = aul_is_tep_mount_dbus_done("/tmp/test.tep"); + EXPECT_EQ(ret, 1); +} + +TEST_F(LaunchTest, aul_check_tep_mount) { + EXPECT_CALL(GetMock(), + g_dbus_connection_send_message_with_reply_sync(_, _, _, _, _, _, _)) + .Times(1); + + std::unique_ptr v_auto( + g_variant_new("(i)", 1), g_variant_unref); + EXPECT_CALL(GetMock(), g_dbus_message_get_body(_)) + .Times(1) + .WillOnce(Invoke([&](GDBusMessage* arg0) -> GVariant* { + return v_auto.get(); + })); + + int ret = aul_check_tep_mount("/tmp/test.tep"); + EXPECT_EQ(ret, AUL_R_OK); +} -- 2.7.4