--- /dev/null
+/*
+ * Copyright (c) 2022 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 <aul.h>
+#include <aul_app_group.h>
+#include <aul_cmd.h>
+#include <aul_sock.h>
+#include <gtest/gtest.h>
+#include <stdlib.h>
+
+#include <bundle_cpp.h>
+
+#include <iostream>
+#include <memory>
+
+#include "mock/mock_hook.h"
+#include "mock/socket_mock.h"
+#include "mock/test_fixture.h"
+#include "src/launch.h"
+
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::Return;
+using ::testing::SetArgPointee;
+using ::testing::Invoke;
+using ::testing::SaveArg;
+
+namespace {
+
+constexpr const char kBelowAppId[] = "org.tizen.below";
+constexpr const char kAboveAppId[] = "org.tizen.above";
+constexpr const char kInstanceId[] = "hello@org.tizen.hello";
+constexpr const char kPkgId[] = "org.tizen.hello";
+constexpr const char kAppId[] = "org.tizen.hello";
+constexpr const int kWid = 128;
+constexpr const int kFgFlag = 1;
+constexpr const int kStatus = STATUS_VISIBLE;
+
+class Mocks : virtual public ::testing::NiceMock<SocketMock> {};
+
+} // namespace
+
+class AppGroupTest : public TestFixture {
+ public:
+ AppGroupTest() : TestFixture(std::make_unique<::Mocks>()) {}
+
+ virtual void SetUp() {
+ if (!aul_is_initialized())
+ aul_launch_init(nullptr, nullptr);
+ }
+
+ virtual void TearDown() {
+ if (aul_is_initialized())
+ aul_launch_fini();
+ }
+
+ tizen_base::Bundle MakeAppGroupInfoBundle() {
+ return {
+ { AUL_K_INSTANCE_ID, kInstanceId },
+ { AUL_K_PID, std::to_string(getpid()) },
+ { AUL_K_APPID, kAppId },
+ { AUL_K_PKGID, kPkgId },
+ { AUL_K_WID, std::to_string(kWid) },
+ { AUL_K_FG_FLAG, std::to_string(kFgFlag) },
+ { AUL_K_STATUS, std::to_string(kStatus) }
+ };
+ }
+
+ std::shared_ptr<app_pkt_t> MakePacket(const std::vector<int>& pids) {
+ app_pkt_t* pkt =
+ static_cast<app_pkt_t*>(
+ calloc(1, sizeof(app_pkt_t) + pids.size() * sizeof(int)));
+ if (pkt == nullptr)
+ return nullptr;
+
+ pkt->opt = AUL_SOCK_NONE;
+ pkt->cmd = APP_GET_INFO_OK;
+ pkt->len = pids.size() * sizeof(int);
+ memcpy(pkt->data, pids.data(), pids.size() * sizeof(int));
+ return std::shared_ptr<app_pkt_t>(pkt, free);
+
+ }
+
+ std::shared_ptr<app_pkt_t> MakePacket(tizen_base::Bundle b) {
+ auto raw = b.ToRaw();
+ app_pkt_t* pkt =
+ static_cast<app_pkt_t*>(calloc(1, sizeof(app_pkt_t) + raw.second));
+ if (pkt == nullptr)
+ return nullptr;
+
+ pkt->opt = AUL_SOCK_BUNDLE;
+ pkt->cmd = APP_GET_INFO_OK;
+ pkt->len = raw.second;
+ memcpy(pkt->data, raw.first.get(), raw.second);
+
+ return std::shared_ptr<app_pkt_t>(pkt, free);
+ }
+
+ bool touched_ = false;
+};
+
+TEST_F(AppGroupTest, aul_app_group_get_window_P) {
+ int cmd = -1;
+ int opt = -1;
+ bundle* kb = nullptr;
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ kb = bundle_decode(pkt->data, pkt->len);
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ int ret = kWid;
+ memcpy(buf, &ret, sizeof(int));
+ return n;
+ }));
+
+ int ret = aul_app_group_get_window(getpid());
+ EXPECT_NE(kb, nullptr);
+ tizen_base::Bundle b(kb, false, true);
+
+ EXPECT_EQ(ret, kWid);
+ EXPECT_EQ(cmd, APP_GROUP_GET_WINDOW);
+ EXPECT_EQ(opt, AUL_SOCK_BUNDLE);
+ EXPECT_EQ(b.GetString(AUL_K_PID), std::to_string(getpid()));
+}
+
+TEST_F(AppGroupTest, aul_app_group_get_window_N) {
+ int ret = aul_app_group_get_window(-1);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_set_window_P) {
+ int cmd = -1;
+ int opt = -1;
+ bundle* kb = nullptr;
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ kb = bundle_decode(pkt->data, pkt->len);
+ return n;
+ }));
+
+ int ret = aul_app_group_set_window(kWid);
+ EXPECT_NE(kb, nullptr);
+ tizen_base::Bundle b(kb, false, true);
+
+ EXPECT_EQ(ret, AUL_R_OK);
+ EXPECT_EQ(cmd, APP_GROUP_SET_WINDOW);
+ EXPECT_EQ(opt, (AUL_SOCK_NOREPLY | AUL_SOCK_BUNDLE));
+ EXPECT_EQ(b.GetString(AUL_K_WID), std::to_string(kWid));
+}
+
+TEST_F(AppGroupTest, aul_app_group_set_window_N) {
+ int ret = aul_app_group_set_window(-1);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_get_leader_pids_P) {
+ int cmd = -1;
+ int opt = -1;
+ std::vector<int> pids { 101, 103 };
+ auto pkt = MakePacket(pids);
+ EXPECT_NE(pkt, nullptr);
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(2)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt.get(), n);
+ return n;
+ }))
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt->data, n);
+ return n;
+ }));
+
+ int cnt = -1;
+ int* leader_pids = nullptr;
+ aul_app_group_get_leader_pids(&cnt, &leader_pids);
+ EXPECT_NE(leader_pids, nullptr);
+ auto leader_pids_auto = std::unique_ptr<int, decltype(std::free)*>(
+ leader_pids, std::free);
+
+ EXPECT_EQ(cmd, APP_GROUP_GET_LEADER_PIDS);
+ EXPECT_EQ(opt, AUL_SOCK_ASYNC);
+ EXPECT_EQ(cnt, 2);
+ EXPECT_EQ(leader_pids[0], pids[0]);
+ EXPECT_EQ(leader_pids[1], pids[1]);
+}
+
+TEST_F(AppGroupTest, aul_app_group_get_group_pids_P) {
+ int cmd = -1;
+ int opt = -1;
+ bundle* kb = nullptr;
+ std::vector<int> pids { 201, 203, 205 };
+ auto pkt = MakePacket(pids);
+ EXPECT_NE(pkt, nullptr);
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ kb = bundle_decode(pkt->data, pkt->len);
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(2)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt.get(), n);
+ return n;
+ }))
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt->data, n);
+ return n;
+ }));
+
+ int cnt = -1;
+ int* group_pids = nullptr;
+ aul_app_group_get_group_pids(getpid(), &cnt, &group_pids);
+ EXPECT_NE(group_pids, nullptr);
+ auto group_pids_auto = std::unique_ptr<int, decltype(std::free)*>(
+ group_pids, std::free);
+
+ EXPECT_NE(kb, nullptr);
+ tizen_base::Bundle b(kb, false, true);
+
+ EXPECT_EQ(cmd, APP_GROUP_GET_GROUP_PIDS);
+ EXPECT_EQ(opt, (AUL_SOCK_BUNDLE | AUL_SOCK_ASYNC));
+ EXPECT_EQ(b.GetString(AUL_K_LEADER_PID), std::to_string(getpid()));
+ EXPECT_EQ(cnt, 3);
+ EXPECT_EQ(group_pids[0], pids[0]);
+ EXPECT_EQ(group_pids[1], pids[1]);
+ EXPECT_EQ(group_pids[2], pids[2]);
+}
+
+TEST_F(AppGroupTest, aul_app_group_get_leader_pid_P) {
+ int cmd = -1;
+ int opt = -1;
+ bundle* kb = nullptr;
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ kb = bundle_decode(pkt->data, pkt->len);
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ int ret = 301;
+ memcpy(buf, &ret, n);
+ return n;
+ }));
+
+ int leader_pid = aul_app_group_get_leader_pid(getpid());
+ EXPECT_NE(kb, nullptr);
+ tizen_base::Bundle b(kb, false, true);
+
+ EXPECT_EQ(leader_pid, 301);
+ EXPECT_EQ(cmd, APP_GROUP_GET_LEADER_PID);
+ EXPECT_EQ(opt, AUL_SOCK_BUNDLE);
+ EXPECT_EQ(b.GetString(AUL_K_PID), std::to_string(getpid()));
+}
+
+TEST_F(AppGroupTest, aul_app_group_get_leader_pid_N) {
+ int ret = aul_app_group_get_leader_pid(-1);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_clear_top_P) {
+ int cmd = -1;
+ int opt = -1;
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ int ret = AUL_R_OK;
+ memcpy(buf, &ret, n);
+ return n;
+ }));
+
+ int ret = aul_app_group_clear_top();
+ EXPECT_EQ(ret, AUL_R_OK);
+ EXPECT_EQ(cmd, APP_GROUP_CLEAR_TOP);
+ EXPECT_EQ(opt, AUL_SOCK_NONE);
+}
+
+TEST_F(AppGroupTest, aul_app_group_is_top_P) {
+ std::vector<int> pids { 201, 203, getpid() };
+ auto pkt = MakePacket(pids);
+ EXPECT_NE(pkt, nullptr);
+
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(3)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ int ret = 201;
+ memcpy(buf, &ret, n);
+ return n;
+ }))
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt.get(), n);
+ return n;
+ }))
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt->data, n);
+ return n;
+ }));
+
+ int ret = aul_app_group_is_top();
+ EXPECT_EQ(ret, 1);
+}
+
+TEST_F(AppGroupTest, aul_app_group_get_fg_flag_P) {
+ int cmd = -1;
+ int opt = -1;
+ bundle* kb = nullptr;
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ kb = bundle_decode(pkt->data, pkt->len);
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ int ret = 1;
+ memcpy(buf, &ret, n);
+ return n;
+ }));
+
+ int fg_flag = aul_app_group_get_fg_flag(getpid());
+ EXPECT_NE(kb, nullptr);
+ tizen_base::Bundle b(kb, false, true);
+
+ EXPECT_EQ(fg_flag, 1);
+ EXPECT_EQ(cmd, APP_GROUP_GET_FG);
+ EXPECT_EQ(opt, AUL_SOCK_BUNDLE);
+ EXPECT_EQ(b.GetString(AUL_K_PID), std::to_string(getpid()));
+}
+
+TEST_F(AppGroupTest, aul_app_group_get_fg_flag_N) {
+ int ret = aul_app_group_get_fg_flag(-1);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_lower_P) {
+ int cmd = -1;
+ int opt = -1;
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ int ret = 1;
+ memcpy(buf, &ret, n);
+ return n;
+ }));
+
+ int exit = 0;
+ aul_app_group_lower(&exit);
+ EXPECT_EQ(exit, 1);
+ EXPECT_EQ(cmd, APP_GROUP_LOWER);
+ EXPECT_EQ(opt, AUL_SOCK_NONE);
+}
+
+TEST_F(AppGroupTest, aul_app_group_get_idle_pids_P) {
+ int cmd = -1;
+ int opt = -1;
+ std::vector<int> pids { 501, 503, 505 };
+ auto pkt = MakePacket(pids);
+ EXPECT_NE(pkt, nullptr);
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(2)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt.get(), n);
+ return n;
+ }))
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt->data, n);
+ return n;
+ }));
+
+ int cnt = -1;
+ int* idle_pids = nullptr;
+ aul_app_group_get_idle_pids(&cnt, &idle_pids);
+ EXPECT_NE(idle_pids, nullptr);
+ auto idle_pids_auto = std::unique_ptr<int, decltype(std::free)*>(
+ idle_pids, std::free);
+
+ EXPECT_EQ(cmd, APP_GROUP_GET_IDLE_PIDS);
+ EXPECT_EQ(opt, AUL_SOCK_ASYNC);
+ EXPECT_EQ(cnt, 3);
+ EXPECT_EQ(idle_pids[0], pids[0]);
+ EXPECT_EQ(idle_pids[1], pids[1]);
+ EXPECT_EQ(idle_pids[2], pids[2]);
+}
+
+TEST_F(AppGroupTest, aul_app_group_activate_below_P) {
+ int cmd = -1;
+ int opt = -1;
+ bundle* kb = nullptr;
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ kb = bundle_decode(pkt->data, pkt->len);
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ int ret = AUL_R_OK;
+ memcpy(buf, &ret, n);
+ return n;
+ }));
+
+ int ret = aul_app_group_activate_below(kBelowAppId);
+ EXPECT_NE(kb, nullptr);
+ tizen_base::Bundle b(kb, false, true);
+
+ EXPECT_EQ(ret, AUL_R_OK);
+ EXPECT_EQ(cmd, APP_GROUP_ACTIVATE_BELOW);
+ EXPECT_EQ(opt, AUL_SOCK_BUNDLE);
+ EXPECT_EQ(b.GetString(AUL_K_APPID), kBelowAppId);
+}
+
+TEST_F(AppGroupTest, aul_app_group_activate_below_N) {
+ int ret = aul_app_group_activate_below(nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_activate_above_P) {
+ int cmd = -1;
+ int opt = -1;
+ bundle* kb = nullptr;
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ kb = bundle_decode(pkt->data, pkt->len);
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ int ret = AUL_R_OK;
+ memcpy(buf, &ret, n);
+ return n;
+ }));
+
+ int ret = aul_app_group_activate_above(kAboveAppId);
+ EXPECT_NE(kb, nullptr);
+ tizen_base::Bundle b(kb, false, true);
+
+ EXPECT_EQ(ret, AUL_R_OK);
+ EXPECT_EQ(cmd, APP_GROUP_ACTIVATE_ABOVE);
+ EXPECT_EQ(opt, AUL_SOCK_BUNDLE);
+ EXPECT_EQ(b.GetString(AUL_K_APPID), kAboveAppId);
+}
+
+TEST_F(AppGroupTest, aul_app_group_activate_above_N) {
+ int ret = aul_app_group_activate_above(nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_set_window_v2_P) {
+ int cmd = -1;
+ int opt = -1;
+ bundle* kb = nullptr;
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ kb = bundle_decode(pkt->data, pkt->len);
+ return n;
+ }));
+
+ int ret = aul_app_group_set_window_v2(kInstanceId, kWid);
+ EXPECT_NE(kb, nullptr);
+ tizen_base::Bundle b(kb, false, true);
+
+ EXPECT_EQ(ret, AUL_R_OK);
+ EXPECT_EQ(cmd, APP_GROUP_SET_WINDOW_V2);
+ EXPECT_EQ(opt, (AUL_SOCK_BUNDLE | AUL_SOCK_NOREPLY));
+ EXPECT_EQ(b.GetString(AUL_K_INSTANCE_ID), kInstanceId);
+ EXPECT_EQ(b.GetString(AUL_K_WID), std::to_string(kWid));
+}
+
+TEST_F(AppGroupTest, aul_app_group_set_window_v2_N) {
+ int ret = aul_app_group_set_window_v2(kInstanceId, -1);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+
+ ret = aul_app_group_set_window_v2(nullptr, 128);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_lower_v2_P) {
+ int cmd = -1;
+ int opt = -1;
+ bundle* kb = nullptr;
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ kb = bundle_decode(pkt->data, pkt->len);
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ int ret = 1;
+ memcpy(buf, &ret, n);
+ return n;
+ }));
+
+ bool exit = false;
+ int ret = aul_app_group_lower_v2(kInstanceId, &exit);
+ EXPECT_NE(kb, nullptr);
+ tizen_base::Bundle b(kb, false, true);
+
+ EXPECT_EQ(ret, AUL_R_OK);
+ EXPECT_EQ(exit, true);
+ EXPECT_EQ(cmd, APP_GROUP_LOWER_V2);
+ EXPECT_EQ(opt, AUL_SOCK_BUNDLE);
+ EXPECT_EQ(b.GetString(AUL_K_INSTANCE_ID), kInstanceId);
+}
+
+TEST_F(AppGroupTest, aul_app_group_lower_v2_N) {
+ int ret = aul_app_group_lower_v2(kInstanceId, nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+
+ bool exit;
+ ret = aul_app_group_lower_v2(nullptr, &exit);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_foreach_leader_ids_P) {
+ int cmd = -1;
+ int opt = -1;
+ std::vector<std::string> ids = { kInstanceId };
+ tizen_base::Bundle b;
+ b.Add(AUL_K_LEADER_IDS, ids);
+ auto pkt = MakePacket(std::move(b));
+ EXPECT_NE(pkt, nullptr);
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(2)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt.get(), n);
+ return n;
+ }))
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt->data, n);
+ return n;
+ }));
+
+ touched_ = false;
+ int ret = aul_app_group_foreach_leader_ids(
+ [](const char* appid, void* user_data) {
+ if (strcmp(appid, kInstanceId) == 0) {
+ auto* test = static_cast<AppGroupTest*>(user_data);
+ test->touched_ = true;
+ }
+ }, this);
+
+ EXPECT_EQ(ret, AUL_R_OK);
+ EXPECT_EQ(cmd, APP_GROUP_GET_LEADER_IDS);
+ EXPECT_EQ(opt, AUL_SOCK_ASYNC);
+ EXPECT_EQ(touched_, true);
+}
+
+TEST_F(AppGroupTest, aul_app_group_foreach_leader_ids_N) {
+ int ret = aul_app_group_foreach_leader_ids(nullptr, nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_foreach_group_info_P) {
+ int cmd = -1;
+ int opt = -1;
+ bundle* kb = nullptr;
+ auto pkt = MakePacket(MakeAppGroupInfoBundle());
+ EXPECT_NE(pkt, nullptr);
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ kb = bundle_decode(pkt->data, pkt->len);
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(3)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ int count = 1;
+ memcpy(buf, &count, n);
+ return n;
+ }))
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt.get(), n);
+ return n;
+ }))
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt->data, n);
+ return n;
+ }));
+
+ touched_ = false;
+ int ret = aul_app_group_foreach_group_info(kInstanceId,
+ [](aul_app_group_info_h info, void* user_data) {
+ const char* id = nullptr;
+ aul_app_group_info_get_id(info, &id);
+
+ pid_t pid = -1;
+ aul_app_group_info_get_pid(info, &pid);
+
+ const char* appid = nullptr;
+ aul_app_group_info_get_appid(info, &appid);
+
+ const char* pkgid = nullptr;
+ aul_app_group_info_get_pkgid(info, &pkgid);
+
+ int wid = -1;
+ aul_app_group_info_get_window(info, &wid);
+
+ bool fg_flag = false;
+ aul_app_group_info_get_fg_flag(info, &fg_flag);
+
+ int status = -1;
+ aul_app_group_info_get_status(info, &status);
+
+ if (id && strcmp(id, kInstanceId) == 0 &&
+ pid == getpid() &&
+ appid && strcmp(appid, kAppId) == 0 &&
+ pkgid && strcmp(pkgid, kPkgId) == 0 &&
+ wid == kWid &&
+ fg_flag == true &&
+ status == STATUS_VISIBLE) {
+ auto* test = static_cast<AppGroupTest*>(user_data);
+ test->touched_ = true;
+ }
+ }, this);
+ EXPECT_NE(kb, nullptr);
+ tizen_base::Bundle b(kb, false, true);
+
+ EXPECT_EQ(ret, AUL_R_OK);
+ EXPECT_EQ(cmd, APP_GROUP_GET_GROUP_INFO);
+ EXPECT_EQ(opt, (AUL_SOCK_BUNDLE | AUL_SOCK_ASYNC));
+ EXPECT_EQ(touched_, true);
+ EXPECT_EQ(b.GetString(AUL_K_LEADER_ID), kInstanceId);
+}
+
+TEST_F(AppGroupTest, aul_app_group_foreach_group_info_N) {
+ int ret = aul_app_group_foreach_group_info(kInstanceId, nullptr, nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+
+ ret = aul_app_group_foreach_group_info(nullptr,
+ [](aul_app_group_info_h info, void* user_data) {
+ }, nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_foreach_idle_info_P) {
+ int cmd = -1;
+ int opt = -1;
+ auto pkt = MakePacket(MakeAppGroupInfoBundle());
+ EXPECT_NE(pkt, nullptr);
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ return n;
+ }));
+ EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+ .Times(3)
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ int count = 1;
+ memcpy(buf, &count, n);
+ return n;
+ }))
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt.get(), n);
+ return n;
+ }))
+ .WillOnce(Invoke([&](int fd, void* buf, size_t n, int flags) -> ssize_t {
+ memcpy(buf, pkt->data, n);
+ return n;
+ }));
+
+ touched_ = false;
+ int ret = aul_app_group_foreach_idle_info(
+ [](aul_app_group_info_h info, void* user_data) {
+ const char* id = nullptr;
+ aul_app_group_info_get_id(info, &id);
+ if (id && strcmp(id, kInstanceId) == 0) {
+ auto* test = static_cast<AppGroupTest*>(user_data);
+ test->touched_ = true;
+ }
+ }, this);
+ EXPECT_EQ(ret, AUL_R_OK);
+ EXPECT_EQ(cmd, APP_GROUP_GET_IDLE_INFO);
+ EXPECT_EQ(opt, AUL_SOCK_ASYNC);
+ EXPECT_EQ(touched_, true);
+}
+
+TEST_F(AppGroupTest, aul_app_group_foreach_idle_info_N) {
+ int ret = aul_app_group_foreach_idle_info(nullptr, nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_info_get_id_N) {
+ int ret = aul_app_group_info_get_id(nullptr, nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_info_get_pid_N) {
+ int ret = aul_app_group_info_get_pid(nullptr, nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_info_get_appid_N) {
+ int ret = aul_app_group_info_get_appid(nullptr, nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_info_get_pkgid_N) {
+ int ret = aul_app_group_info_get_pkgid(nullptr, nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_info_get_window_N) {
+ int ret = aul_app_group_info_get_window(nullptr, nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_info_get_fg_flag_N) {
+ int ret = aul_app_group_info_get_fg_flag(nullptr, nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_info_get_status_N) {
+ int ret = aul_app_group_info_get_status(nullptr, nullptr);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_add_P) {
+ int cmd = -1;
+ int opt = -1;
+ bundle* kb = nullptr;
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ kb = bundle_decode(pkt->data, pkt->len);
+ return n;
+ }));
+
+ int ret = aul_app_group_add(kWid);
+ EXPECT_NE(kb, nullptr);
+ tizen_base::Bundle b(kb, false, true);
+
+ EXPECT_EQ(ret, AUL_R_OK);
+ EXPECT_EQ(cmd, APP_GROUP_ADD);
+ EXPECT_EQ(opt, (AUL_SOCK_BUNDLE | AUL_SOCK_NOREPLY));
+ EXPECT_EQ(b.GetString(AUL_K_WID), std::to_string(kWid));
+}
+
+TEST_F(AppGroupTest, aul_app_group_add_N) {
+ int ret = aul_app_group_add(-1);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
+
+TEST_F(AppGroupTest, aul_app_group_remove_P) {
+ int cmd = -1;
+ int opt = -1;
+ bundle* kb = nullptr;
+
+ EXPECT_CALL(GetMock<SocketMock>(), send(_, _, _, _))
+ .Times(1)
+ .WillOnce(Invoke([&](int fd, const void* buf, size_t n, int flags)
+ -> ssize_t {
+ const app_pkt_t* pkt = reinterpret_cast<const app_pkt_t*>(buf);
+ cmd = pkt->cmd;
+ opt = pkt->opt;
+ kb = bundle_decode(pkt->data, pkt->len);
+ return n;
+ }));
+
+ int ret = aul_app_group_remove(kWid);
+ EXPECT_NE(kb, nullptr);
+ tizen_base::Bundle b(kb, false, true);
+
+ EXPECT_EQ(ret, AUL_R_OK);
+ EXPECT_EQ(cmd, APP_GROUP_REMOVE);
+ EXPECT_EQ(opt, (AUL_SOCK_BUNDLE | AUL_SOCK_NOREPLY));
+ EXPECT_EQ(b.GetString(AUL_K_WID), std::to_string(kWid));
+}
+
+TEST_F(AppGroupTest, aul_app_group_remove_N) {
+ int ret = aul_app_group_remove(-1);
+ EXPECT_EQ(ret, AUL_R_EINVAL);
+}
projects / platform / core / appfw / aul-1.git / commitdiff