Add test cases for launch.c

- Add a TC for aul_launch_app_async
- Add a TC for aul_terminate_pid_sync
- Add a TC for aul_open_app
- Add a TC for aul_resume_app
- Add a TC for aul_resume_pid
- Add a TC for aul_resume_pid_async
- Add a TC for aul_app_is_running
- Add a TC for aul_prepare_app_defined_loader
- Add a TC for aul_terminate_pid_async
- Add a TC for aul_pause_app
- Add a TC for aul_pause_pid
- Add a TC for aul_terminate_app_with_instance_id
- Add a TC for aul_terminate_instance_async
- Add a TC for aul_resume_app_by_instance_id
- Add a TC for aul_prepare_candidate_process
- Add a TC for aul_app_register_pid
- Add a TC for aul_add_loader
- Add a TC for aul_remove_loader
- Add a TC for aul_reload_appinfo
- Add a TC for aul_kill_pid
- Add a TC for aul_terminate_pid_sync_without_restart
- Add a TC for aul_terminate_bgapp_pid

Change-Id: I9edd668ea984d98f3970159849527b0cfbbe931f
Signed-off-by: jh9216.park <jh9216.park@samsung.com>

diff --git a/test/unit_tests/test_launch.cc b/test/unit_tests/test_launch.cc
index 1c84325..09d78ba 100644 (file)
--- a/test/unit_tests/test_launch.cc
+++ b/test/unit_tests/test_launch.cc
@@ -21,7 +21,10 @@
 #include <iostream>
 #include <memory>
 #include <aul.h>
+#include <aul_sock.h>
+#include <aul_cmd.h>
 
+#include "launch.h"
 #include "mock/socket_mock.h"
 #include "mock/mock_hook.h"
 #include "mock/test_fixture.h"
@@ -50,15 +53,123 @@ class LaunchTest : public TestFixture {
 
 TEST_F(LaunchTest, aul_launch_app) {
   tizen_base::Bundle b;
+  int cmd = -1;
   EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
       .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_launch_app("test_appid", b.GetHandle());
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_START);
+}
+
+TEST_F(LaunchTest, aul_launch_app_async) {
+  tizen_base::Bundle b;
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
   EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
       .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_launch_app_async("test_appid", b.GetHandle());
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_START_ASYNC);
+}
 
+TEST_F(LaunchTest, aul_terminate_pid) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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(1000);
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_TERM_BY_PID);
+}
+
+TEST_F(LaunchTest, aul_terminate_pid_sync) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
       .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_sync(1000);
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_TERM_BY_PID_SYNC);
+}
 
+TEST_F(LaunchTest, aul_terminate_pid_async) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
   EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
       .Times(1)
       .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) -> ssize_t {
@@ -67,21 +178,478 @@ TEST_F(LaunchTest, aul_launch_app) {
         return sizeof(int);
       }));
 
-  int ret = aul_launch_app("test_appid", b.GetHandle());
+  int ret = aul_terminate_pid_async(1000);
   EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_TERM_BY_PID_ASYNC);
 }
 
-TEST_F(LaunchTest, aul_terminate_pid) {
+TEST_F(LaunchTest, aul_open_app) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_open_app("test_appid");
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_OPEN);
+}
+
+TEST_F(LaunchTest, aul_resume_app) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_resume_app("test_appid");
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_RESUME);
+}
+
+TEST_F(LaunchTest, aul_resume_pid) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_resume_pid(100);
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_RESUME_BY_PID);
+}
+
+TEST_F(LaunchTest, aul_resume_pid_async) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_resume_pid_async(100);
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_RESUME_BY_PID_ASYNC);
+}
+
+TEST_F(LaunchTest, aul_pause_app) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+      .Times(0);
+
+  int ret = aul_pause_app("test_appid");
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_PAUSE);
+}
+
+TEST_F(LaunchTest, aul_pause_pid) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+      .Times(0);
+
+  int ret = aul_pause_pid(100);
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_PAUSE_BY_PID);
+}
+
+TEST_F(LaunchTest, aul_app_is_running) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        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, sizeof(int));
+        return sizeof(int);
+      }));
+
+  int ret = aul_app_is_running("test-appid");
+  EXPECT_EQ(ret, 1);
+  EXPECT_EQ(cmd, APP_IS_RUNNING);
+}
+
+TEST_F(LaunchTest, aul_prepare_app_defined_loader) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_prepare_app_defined_loader("test-loader");
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_PREPARE_APP_DEFINED_LOADER);
+}
+
+TEST_F(LaunchTest, aul_terminate_app_with_instance_id) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_with_instance_id("test-app", "inst");
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_TERMINATE);
+}
+
+TEST_F(LaunchTest, aul_terminate_instance_async) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_instance_async("inst", 100);
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_TERM_INSTANCE_ASYNC);
+}
+
+TEST_F(LaunchTest, aul_resume_app_by_instance_id) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_resume_app_by_instance_id("test-app", "inst");
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_RESUME);
+}
+
+TEST_F(LaunchTest, aul_prepare_candidate_process) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_prepare_candidate_process();
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_PREPARE_CANDIDATE_PROCESS);
+}
+
+TEST_F(LaunchTest, aul_app_register_pid) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
+      .Times(0);
+
+  int ret = aul_app_register_pid("test-app", 100);
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_REGISTER_PID);
+}
+
+TEST_F(LaunchTest, aul_add_loader) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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);
+      }));
+
   tizen_base::Bundle b;
+  int ret = aul_add_loader("/tmp/test-loader", b.GetHandle());
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_ADD_LOADER);
+}
+
+TEST_F(LaunchTest, aul_remove_loader) {
+  int cmd = -1;
   EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
       .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_remove_loader(1);
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_REMOVE_LOADER);
+}
+
+TEST_F(LaunchTest, aul_reload_appinfo) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
   EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
       .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_reload_appinfo();
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, AMD_RELOAD_APPINFO);
+}
 
+TEST_F(LaunchTest, aul_kill_pid) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_kill_pid(100);
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_KILL_BY_PID);
+}
+
+TEST_F(LaunchTest, aul_terminate_pid_sync_without_restart) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
       .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
+  EXPECT_CALL(GetMock<SocketMock>(), 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_sync_without_restart(100);
+  EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_TERM_BY_PID_SYNC_WITHOUT_RESTART);
+}
+
+TEST_F(LaunchTest, aul_terminate_bgapp_pid) {
+  int cmd = -1;
+  EXPECT_CALL(GetMock<SocketMock>(), socket(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<SocketMock>(), connect(_, _, _))
+      .Times(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* header = reinterpret_cast<const app_pkt_t*>(buf);
+        cmd = header->cmd;
+        return n;
+      }));
   EXPECT_CALL(GetMock<SocketMock>(), recv(_, _, _, _))
       .Times(1)
       .WillOnce(Invoke([](int fd, void* buf, size_t n, int flags) -> ssize_t {
@@ -90,6 +658,7 @@ TEST_F(LaunchTest, aul_terminate_pid) {
         return sizeof(int);
       }));
 
-  int ret = aul_terminate_pid(1000);
+  int ret = aul_terminate_bgapp_pid(100);
   EXPECT_EQ(ret, AUL_R_OK);
+  EXPECT_EQ(cmd, APP_TERM_BGAPP_BY_PID);
 }