1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <gtest/gtest.h>
16 #include <gmock/gmock.h>
17 #include "native_child_process.h"
18 #include "app_utils.h"
19 #include "child_process_args_manager.h"
20 #include "child_process_configs.h"
21 #include "native_child_callback.h"
22
23 extern void SetGlobalNativeChildCallbackStub(OHOS::sptr<OHOS::AbilityRuntime::NativeChildCallback> local);
24
25 namespace OHOS {
26 namespace AbilityRuntime {
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 class ChildProcessCapiTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35
36 static void OnNativeChildProcessStarted(int errCode, OHIPCRemoteProxy *remoteProxy);
37 static void OnNativeChildProcessExit(int32_t pid, int32_t signal);
38 static void OnNativeChildProcessExit1(int32_t pid, int32_t signal);
39
40 void SetUp();
41 void TearDown();
42 };
43
SetUpTestCase(void)44 void ChildProcessCapiTest::SetUpTestCase(void)
45 {}
46
TearDownTestCase(void)47 void ChildProcessCapiTest::TearDownTestCase(void)
48 {}
49
SetUp(void)50 void ChildProcessCapiTest::SetUp(void)
51 {}
52
TearDown(void)53 void ChildProcessCapiTest::TearDown(void)
54 {}
55
OnNativeChildProcessStarted(int errCode,OHIPCRemoteProxy * remoteProxy)56 void ChildProcessCapiTest::OnNativeChildProcessStarted(int errCode, OHIPCRemoteProxy *remoteProxy)
57 {
58 }
59
OnNativeChildProcessExit(int32_t pid,int32_t signal)60 void ChildProcessCapiTest::OnNativeChildProcessExit(int32_t pid, int32_t signal)
61 {
62 GTEST_LOG_(INFO) << "OnNativeChildProcessExit call";
63 }
64
OnNativeChildProcessExit1(int32_t pid,int32_t signal)65 void ChildProcessCapiTest::OnNativeChildProcessExit1(int32_t pid, int32_t signal)
66 {
67 GTEST_LOG_(INFO) << "OnNativeChildProcessExit1 call";
68 }
69
70 /**
71 * @tc.number: OH_Ability_CreateNativeChildProcess_001
72 * @tc.desc: Test API OH_Ability_CreateNativeChildProcess works
73 * @tc.type: FUNC
74 */
75 HWTEST_F(ChildProcessCapiTest, OH_Ability_CreateNativeChildProcess_001, TestSize.Level2)
76 {
77 GTEST_LOG_(INFO) << "OH_Ability_CreateNativeChildProcess_001 begin";
78 int ret = OH_Ability_CreateNativeChildProcess(nullptr, ChildProcessCapiTest::OnNativeChildProcessStarted);
79 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
80
81 ret = OH_Ability_CreateNativeChildProcess("test.so", nullptr);
82 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
83
84 ret = OH_Ability_CreateNativeChildProcess("test.so", ChildProcessCapiTest::OnNativeChildProcessStarted);
85 if (!AAFwk::AppUtils::GetInstance().IsMultiProcessModel()) {
86 EXPECT_EQ(ret, NCP_ERR_SERVICE_ERROR);
87 return;
88 } else if (!AAFwk::AppUtils::GetInstance().IsSupportNativeChildProcess()) {
89 EXPECT_EQ(ret, NCP_ERR_MULTI_PROCESS_DISABLED);
90 return;
91 }
92
93 GTEST_LOG_(INFO) << "OH_Ability_CreateNativeChildProcess return " << ret;
94 EXPECT_NE(ret, NCP_ERR_NOT_SUPPORTED);
95 }
96
97 /**
98 * @tc.number: OH_Ability_StartNativeChildProcess_001
99 * @tc.desc: Test API OH_Ability_StartNativeChildProcess_001 works
100 * @tc.type: FUNC
101 */
102 HWTEST_F(ChildProcessCapiTest, OH_Ability_StartNativeChildProcess_001, TestSize.Level2)
103 {
104 GTEST_LOG_(INFO) << "OH_Ability_StartNativeChildProcess_001 begin";
105 NativeChildProcess_Args args;
106 NativeChildProcess_Options options;
107 int32_t pid = 0;
108 auto ret = OH_Ability_StartNativeChildProcess(nullptr, args, options, &pid);
109 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
110 GTEST_LOG_(INFO) << "OH_Ability_StartNativeChildProcess_001 begin";
111 }
112
113 /**
114 * @tc.number: OH_Ability_CreateNativeChildProcessWithConfigs_001
115 * @tc.desc: Test API OH_Ability_CreateNativeChildProcessWithConfigs works
116 * @tc.type: FUNC
117 */
118 HWTEST_F(ChildProcessCapiTest, OH_Ability_CreateNativeChildProcessWithConfigs, TestSize.Level2)
119 {
120 GTEST_LOG_(INFO) << "OH_Ability_CreateNativeChildProcess_001 begin";
121 auto configs = OH_Ability_CreateChildProcessConfigs();
122 int ret = OH_Ability_CreateNativeChildProcessWithConfigs(nullptr, configs,
123 ChildProcessCapiTest::OnNativeChildProcessStarted);
124 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
125
126 ret = OH_Ability_CreateNativeChildProcessWithConfigs("test.so", configs, nullptr);
127 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
128
129 ret = OH_Ability_CreateNativeChildProcessWithConfigs("test.so", nullptr,
130 ChildProcessCapiTest::OnNativeChildProcessStarted);
131 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
132
133 ret = OH_Ability_CreateNativeChildProcessWithConfigs("test.so", configs,
134 ChildProcessCapiTest::OnNativeChildProcessStarted);
135 if (!AAFwk::AppUtils::GetInstance().IsMultiProcessModel()) {
136 EXPECT_EQ(ret, NCP_ERR_SERVICE_ERROR);
137 return;
138 } else if (!AAFwk::AppUtils::GetInstance().IsSupportNativeChildProcess()) {
139 EXPECT_EQ(ret, NCP_ERR_MULTI_PROCESS_DISABLED);
140 return;
141 }
142
143 GTEST_LOG_(INFO) << "OH_Ability_CreateNativeChildProcess return " << ret;
144 EXPECT_NE(ret, NCP_ERR_NOT_SUPPORTED);
145 }
146
147 /**
148 * @tc.number: OH_Ability_StartNativeChildProcessWithConfigs_001
149 * @tc.desc: Test API OH_Ability_StartNativeChildProcessWithConfigs_001 works
150 * @tc.type: FUNC
151 */
152 HWTEST_F(ChildProcessCapiTest, OH_Ability_StartNativeChildProcessWithConfigs_001, TestSize.Level2)
153 {
154 GTEST_LOG_(INFO) << "OH_Ability_StartNativeChildProcessWithConfigs_001 begin";
155 NativeChildProcess_Args args;
156 auto configs = OH_Ability_CreateChildProcessConfigs();
157 int32_t pid = 0;
158 auto ret = OH_Ability_StartNativeChildProcessWithConfigs(nullptr, args, configs, &pid);
159 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
160 ret = OH_Ability_StartNativeChildProcessWithConfigs("a.so:Main", args, nullptr, &pid);
161 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
162 ret = OH_Ability_DestroyChildProcessConfigs(configs);
163 EXPECT_EQ(ret, NCP_NO_ERROR);
164 ret = OH_Ability_DestroyChildProcessConfigs(nullptr);
165 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
166 GTEST_LOG_(INFO) << "OH_Ability_StartNativeChildProcess_001 begin";
167 }
168
169 /**
170 * @tc.number: OH_Ability_Ability_ChildProcessConfigs_001
171 * @tc.desc: Test API OH_Ability_Ability_ChildProcessConfigs_001 works
172 * @tc.type: FUNC
173 */
174 HWTEST_F(ChildProcessCapiTest, OH_Ability_ChildProcessConfigs_SetIsolationMode_001, TestSize.Level2)
175 {
176 GTEST_LOG_(INFO) << "OH_Ability_Ability_ChildProcessConfigs_001 begin";
177 auto configs = OH_Ability_CreateChildProcessConfigs();
178 auto ret = OH_Ability_ChildProcessConfigs_SetIsolationMode(configs, NCP_ISOLATION_MODE_ISOLATED);
179 EXPECT_EQ(ret, NCP_NO_ERROR);
180 ret = OH_Ability_ChildProcessConfigs_SetIsolationMode(nullptr, NCP_ISOLATION_MODE_ISOLATED);
181 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
182 ret = OH_Ability_DestroyChildProcessConfigs(configs);
183 EXPECT_EQ(ret, NCP_NO_ERROR);
184 GTEST_LOG_(INFO) << "OH_Ability_Ability_ChildProcessConfigs_001 begin";
185 }
186
187 /**
188 * @tc.number: OH_Ability_ChildProcessConfigs_SetProcessName_001
189 * @tc.desc: Test API OH_Ability_ChildProcessConfigs_SetProcessName_001 works
190 * @tc.type: FUNC
191 */
192 HWTEST_F(ChildProcessCapiTest, OH_Ability_ChildProcessConfigs_SetProcessName_001, TestSize.Level2)
193 {
194 GTEST_LOG_(INFO) << "OH_Ability_Ability_ChildProcessConfigs_001 begin";
195 auto configs = OH_Ability_CreateChildProcessConfigs();
196 auto ret = OH_Ability_ChildProcessConfigs_SetProcessName(configs, nullptr);
197 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
198 ret = OH_Ability_ChildProcessConfigs_SetProcessName(nullptr, "");
199 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
200 ret = OH_Ability_ChildProcessConfigs_SetProcessName(configs, "");
201 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
202 ret = OH_Ability_ChildProcessConfigs_SetProcessName(configs, "abc_123");
203 EXPECT_EQ(ret, NCP_NO_ERROR);
204 ret = OH_Ability_ChildProcessConfigs_SetProcessName(configs, "abc_123[");
205 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
206 ret = OH_Ability_DestroyChildProcessConfigs(configs);
207 EXPECT_EQ(ret, NCP_NO_ERROR);
208 GTEST_LOG_(INFO) << "OH_Ability_Ability_ChildProcessConfigs_001 begin";
209 }
210
211
212 /**
213 * @tc.number: OH_Ability_RegisterNativeChildProcessExitCallback_001
214 * @tc.desc: Test API OH_Ability_RegisterNativeChildProcessExitCallback_001 works
215 * @tc.type: FUNC
216 */
217 HWTEST_F(ChildProcessCapiTest, OH_Ability_RegisterNativeChildProcessExitCallback_001, TestSize.Level0)
218 {
219 GTEST_LOG_(INFO) << "OH_Ability_RegisterNativeChildProcessExitCallback_001 begin";
220 auto ret = OH_Ability_RegisterNativeChildProcessExitCallback(nullptr);
221 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
222 ret = OH_Ability_RegisterNativeChildProcessExitCallback(ChildProcessCapiTest::OnNativeChildProcessExit);
223 EXPECT_EQ(ret, NCP_ERR_INTERNAL);
224 ret = OH_Ability_UnregisterNativeChildProcessExitCallback(ChildProcessCapiTest::OnNativeChildProcessExit);
225 EXPECT_EQ(ret, NCP_ERR_CALLBACK_NOT_EXIST);
226 GTEST_LOG_(INFO) << "OH_Ability_RegisterNativeChildProcessExitCallback_001 end";
227 }
228
229 /**
230 * @tc.number: OH_Ability_RegisterNativeChildProcessExitCallback_002
231 * @tc.desc: Test API OH_Ability_RegisterNativeChildProcessExitCallback_002 works
232 * @tc.type: FUNC
233 */
234 HWTEST_F(ChildProcessCapiTest, OH_Ability_RegisterNativeChildProcessExitCallback_002, TestSize.Level0)
235 {
236 GTEST_LOG_(INFO) << "OH_Ability_RegisterNativeChildProcessExitCallback_002 begin";
237 auto localCallbackStub = sptr<NativeChildCallback>::MakeSptr(nullptr);
238 ::SetGlobalNativeChildCallbackStub(localCallbackStub);
239 auto ret = OH_Ability_RegisterNativeChildProcessExitCallback(ChildProcessCapiTest::OnNativeChildProcessExit);
240 EXPECT_EQ(ret, NCP_NO_ERROR);
241 ret = OH_Ability_RegisterNativeChildProcessExitCallback(ChildProcessCapiTest::OnNativeChildProcessExit);
242 EXPECT_EQ(ret, NCP_NO_ERROR);
243 int32_t pid = 111;
244 int32_t signal = 9;
245 localCallbackStub->OnNativeChildExit(pid, signal);
246 EXPECT_EQ(ret, NCP_NO_ERROR);
247 ret = OH_Ability_UnregisterNativeChildProcessExitCallback(ChildProcessCapiTest::OnNativeChildProcessExit);
248 EXPECT_EQ(ret, NCP_ERR_INTERNAL);
249 ::SetGlobalNativeChildCallbackStub(nullptr);
250 GTEST_LOG_(INFO) << "OH_Ability_RegisterNativeChildProcessExitCallback_002 end";
251 }
252
253 /**
254 * @tc.number: OH_Ability_UnregisterNativeChildProcessExitCallback_001
255 * @tc.desc: Test API OH_Ability_UnregisterNativeChildProcessExitCallback_001 works
256 * @tc.type: FUNC
257 */
258 HWTEST_F(ChildProcessCapiTest, OH_Ability_UnregisterNativeChildProcessExitCallback_001, TestSize.Level0)
259 {
260 GTEST_LOG_(INFO) << "OH_Ability_UnregisterNativeChildProcessExitCallback_001 begin";
261 auto ret = OH_Ability_UnregisterNativeChildProcessExitCallback(nullptr);
262 EXPECT_EQ(ret, NCP_ERR_INVALID_PARAM);
263 ret = OH_Ability_UnregisterNativeChildProcessExitCallback(ChildProcessCapiTest::OnNativeChildProcessExit);
264 EXPECT_EQ(ret, NCP_ERR_CALLBACK_NOT_EXIST);
265 GTEST_LOG_(INFO) << "OH_Ability_UnregisterNativeChildProcessExitCallback_001 end";
266 }
267
268 /**
269 * @tc.number: OH_Ability_UnregisterNativeChildProcessExitCallback_002
270 * @tc.desc: Test API OH_Ability_UnregisterNativeChildProcessExitCallback_002 works
271 * @tc.type: FUNC
272 */
273 HWTEST_F(ChildProcessCapiTest, OH_Ability_UnregisterNativeChildProcessExitCallback_002, TestSize.Level0)
274 {
275 GTEST_LOG_(INFO) << "OH_Ability_UnregisterNativeChildProcessExitCallback_002 begin";
276 auto localCallbackStub = sptr<NativeChildCallback>::MakeSptr(nullptr);
277 ::SetGlobalNativeChildCallbackStub(localCallbackStub);
278 auto ret = OH_Ability_RegisterNativeChildProcessExitCallback(ChildProcessCapiTest::OnNativeChildProcessExit);
279 EXPECT_EQ(ret, NCP_NO_ERROR);
280 ret = OH_Ability_UnregisterNativeChildProcessExitCallback(ChildProcessCapiTest::OnNativeChildProcessExit1);
281 EXPECT_EQ(ret, NCP_ERR_CALLBACK_NOT_EXIST);
282 ::SetGlobalNativeChildCallbackStub(nullptr);
283 GTEST_LOG_(INFO) << "OH_Ability_UnregisterNativeChildProcessExitCallback_002 end";
284 }
285
286 /**
287 * @tc.number: OH_Ability_GetCurrentChildProcessArgs_001
288 * @tc.desc: Test API OH_Ability_GetCurrentChildProcessArgs_001 works
289 * @tc.type: FUNC
290 */
291 HWTEST_F(ChildProcessCapiTest, OH_Ability_GetCurrentChildProcessArgs_001, TestSize.Level2)
292 {
293 GTEST_LOG_(INFO) << "OH_Ability_GetCurrentChildProcessArgs_001 begin";
294 EXPECT_EQ(OH_Ability_GetCurrentChildProcessArgs(), nullptr);
295 NativeChildProcess_Args args = { 0 };
296 ChildProcessArgsManager::GetInstance().SetChildProcessArgs(args);
297 EXPECT_NE(OH_Ability_GetCurrentChildProcessArgs(), nullptr);
298 GTEST_LOG_(INFO) << "OH_Ability_GetCurrentChildProcessArgs_001 end";
299 }
300 } // namespace AbilityRuntime
301 } // namespace OHOS
302