1 /*
2 * Copyright (c) 2022-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
16 #include <gtest/gtest.h>
17
18 #include "mock_ability_debug_response_stub.h"
19 #include "mock_ams_mgr_scheduler.h"
20 #include "mock_app_debug_listener_stub.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace AppExecFwk {
27 namespace {
28 const std::string STRING_BUNDLE_NAME = "bundleName";
29 const std::string EMPTY_BUNDLE_NAME = "";
30 } // namespace
31
32 class AmsMgrStubTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp() override;
37 void TearDown() override;
38
39 sptr<MockAppDebugListenerStub> listener_;
40 sptr<MockAbilityDebugResponseStub> response_;
41 sptr<MockAmsMgrScheduler> mockAmsMgrScheduler_;
42
43 void WriteInterfaceToken(MessageParcel& data);
44 };
45
SetUpTestCase(void)46 void AmsMgrStubTest::SetUpTestCase(void)
47 {}
48
TearDownTestCase(void)49 void AmsMgrStubTest::TearDownTestCase(void)
50 {}
51
SetUp()52 void AmsMgrStubTest::SetUp()
53 {
54 GTEST_LOG_(INFO) << "AmsMgrStubTest::SetUp()";
55
56 listener_ = new MockAppDebugListenerStub();
57 response_ = new MockAbilityDebugResponseStub();
58 mockAmsMgrScheduler_ = new MockAmsMgrScheduler();
59 }
60
TearDown()61 void AmsMgrStubTest::TearDown()
62 {}
63
WriteInterfaceToken(MessageParcel & data)64 void AmsMgrStubTest::WriteInterfaceToken(MessageParcel& data)
65 {
66 GTEST_LOG_(INFO) << "AmsMgrStubTest::WriteInterfaceToken()";
67
68 data.WriteInterfaceToken(AmsMgrStub::GetDescriptor());
69 }
70
71 /**
72 * @tc.name: HandleRegisterAppDebugListener_0100
73 * @tc.desc: Handle register app debug listener.
74 * @tc.type: FUNC
75 */
76 HWTEST_F(AmsMgrStubTest, HandleRegisterAppDebugListener_0100, TestSize.Level1)
77 {
78 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
79 EXPECT_CALL(*mockAmsMgrScheduler_, RegisterAppDebugListener(_)).Times(1);
80 MessageParcel data;
81 MessageParcel reply;
82 MessageOption option(MessageOption::TF_ASYNC);
83 WriteInterfaceToken(data);
84 EXPECT_NE(listener_, nullptr);
85 data.WriteRemoteObject(listener_);
86
87 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
88 static_cast<uint32_t>(IAmsMgr::Message::REGISTER_APP_DEBUG_LISTENER), data, reply, option);
89 EXPECT_EQ(result, NO_ERROR);
90 }
91
92 /**
93 * @tc.name: HandleRegisterAppDebugListener_0200
94 * @tc.desc: Handle register app debug listener, check nullptr listener.
95 * @tc.type: FUNC
96 */
97 HWTEST_F(AmsMgrStubTest, HandleRegisterAppDebugListener_0200, TestSize.Level1)
98 {
99 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
100 EXPECT_CALL(*mockAmsMgrScheduler_, RegisterAppDebugListener(_)).Times(0);
101 MessageParcel data;
102 MessageParcel reply;
103 MessageOption option(MessageOption::TF_ASYNC);
104 listener_ = nullptr;
105 WriteInterfaceToken(data);
106 data.WriteRemoteObject(listener_);
107
108 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
109 static_cast<uint32_t>(IAmsMgr::Message::REGISTER_APP_DEBUG_LISTENER), data, reply, option);
110 EXPECT_EQ(result, ERR_INVALID_VALUE);
111 }
112 /**
113 * @tc.name: HandleUnregisterAppDebugListener_0100
114 * @tc.desc: Handle unregister app debug listener.
115 * @tc.type: FUNC
116 */
117 HWTEST_F(AmsMgrStubTest, HandleUnregisterAppDebugListener_0100, TestSize.Level1)
118 {
119 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
120 EXPECT_CALL(*mockAmsMgrScheduler_, UnregisterAppDebugListener(_)).Times(1);
121 MessageParcel data;
122 MessageParcel reply;
123 MessageOption option(MessageOption::TF_ASYNC);
124 WriteInterfaceToken(data);
125 EXPECT_NE(listener_, nullptr);
126 data.WriteRemoteObject(listener_);
127
128 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
129 static_cast<uint32_t>(IAmsMgr::Message::UNREGISTER_APP_DEBUG_LISTENER), data, reply, option);
130 EXPECT_EQ(result, NO_ERROR);
131 }
132
133 /**
134 * @tc.name: HandleUnregisterAppDebugListener_0200
135 * @tc.desc: Handle unregister app debug listener, check nullptr listener.
136 * @tc.type: FUNC
137 */
138 HWTEST_F(AmsMgrStubTest, HandleUnregisterAppDebugListener_0200, TestSize.Level1)
139 {
140 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
141 EXPECT_CALL(*mockAmsMgrScheduler_, UnregisterAppDebugListener(_)).Times(0);
142 MessageParcel data;
143 MessageParcel reply;
144 MessageOption option(MessageOption::TF_ASYNC);
145 listener_ = nullptr;
146 WriteInterfaceToken(data);
147 data.WriteRemoteObject(listener_);
148
149 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
150 static_cast<uint32_t>(IAmsMgr::Message::UNREGISTER_APP_DEBUG_LISTENER), data, reply, option);
151 EXPECT_EQ(result, ERR_INVALID_VALUE);
152 }
153
154 /**
155 * @tc.name: HandleAttachAppDebug_0100
156 * @tc.desc: Handle attach app, begin debug mode.
157 * @tc.type: FUNC
158 */
159 HWTEST_F(AmsMgrStubTest, HandleAttachAppDebug_0100, TestSize.Level1)
160 {
161 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
162 EXPECT_CALL(*mockAmsMgrScheduler_, AttachAppDebug(_, _)).Times(1);
163 MessageParcel data;
164 MessageParcel reply;
165 MessageOption option(MessageOption::TF_ASYNC);
166 WriteInterfaceToken(data);
167 data.WriteString(STRING_BUNDLE_NAME);
168
169 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
170 static_cast<uint32_t>(IAmsMgr::Message::ATTACH_APP_DEBUG), data, reply, option);
171 EXPECT_EQ(result, NO_ERROR);
172 }
173
174 /**
175 * @tc.name: HandleAttachAppDebug_0200
176 * @tc.desc: Handle attach app, begin debug mode, check empty bunle name.
177 * @tc.type: FUNC
178 */
179 HWTEST_F(AmsMgrStubTest, HandleAttachAppDebug_0200, TestSize.Level1)
180 {
181 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
182 EXPECT_CALL(*mockAmsMgrScheduler_, AttachAppDebug(_, _)).Times(0);
183 MessageParcel data;
184 MessageParcel reply;
185 MessageOption option(MessageOption::TF_ASYNC);
186 WriteInterfaceToken(data);
187 data.WriteString(EMPTY_BUNDLE_NAME);
188
189 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
190 static_cast<uint32_t>(IAmsMgr::Message::ATTACH_APP_DEBUG), data, reply, option);
191 EXPECT_EQ(result, ERR_INVALID_VALUE);
192 }
193
194 /**
195 * @tc.name: HandleDetachAppDebug_0100
196 * @tc.desc: Handle detach app, end debug mode.
197 * @tc.type: FUNC
198 */
199 HWTEST_F(AmsMgrStubTest, HandleDetachAppDebug_0100, TestSize.Level1)
200 {
201 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
202 EXPECT_CALL(*mockAmsMgrScheduler_, DetachAppDebug(_)).Times(1);
203 MessageParcel data;
204 MessageParcel reply;
205 MessageOption option(MessageOption::TF_ASYNC);
206 WriteInterfaceToken(data);
207 data.WriteString(STRING_BUNDLE_NAME);
208
209 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
210 static_cast<uint32_t>(IAmsMgr::Message::DETACH_APP_DEBUG), data, reply, option);
211 EXPECT_EQ(result, NO_ERROR);
212 }
213
214 /**
215 * @tc.name: HandleDetachAppDebug_0200
216 * @tc.desc: Handle detach app, check empty bundle name.
217 * @tc.type: FUNC
218 */
219 HWTEST_F(AmsMgrStubTest, HandleDetachAppDebug_0200, TestSize.Level1)
220 {
221 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
222 EXPECT_CALL(*mockAmsMgrScheduler_, DetachAppDebug(_)).Times(0);
223 MessageParcel data;
224 MessageParcel reply;
225 MessageOption option(MessageOption::TF_ASYNC);
226 WriteInterfaceToken(data);
227 data.WriteString(EMPTY_BUNDLE_NAME);
228
229 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
230 static_cast<uint32_t>(IAmsMgr::Message::DETACH_APP_DEBUG), data, reply, option);
231 EXPECT_EQ(result, ERR_INVALID_VALUE);
232 }
233
234 /**
235 * @tc.name: HandleRegisterAbilityDebugResponse_0100
236 * @tc.desc: Handle register ability debug response.
237 * @tc.type: FUNC
238 */
239 HWTEST_F(AmsMgrStubTest, HandleRegisterAbilityDebugResponse_0100, TestSize.Level1)
240 {
241 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
242 MessageParcel data;
243 MessageParcel reply;
244 MessageOption option(MessageOption::TF_ASYNC);
245 WriteInterfaceToken(data);
246 EXPECT_NE(response_, nullptr);
247 data.WriteRemoteObject(response_);
248
249 EXPECT_CALL(*mockAmsMgrScheduler_, RegisterAbilityDebugResponse(_)).Times(1);
250 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
251 static_cast<uint32_t>(IAmsMgr::Message::REGISTER_ABILITY_DEBUG_RESPONSE), data, reply, option);
252 EXPECT_EQ(result, NO_ERROR);
253 }
254
255 /**
256 * @tc.name: HandleRegisterAbilityDebugResponse_0200
257 * @tc.desc: Handle register ability debug response, check nullptr response.
258 * @tc.type: FUNC
259 */
260 HWTEST_F(AmsMgrStubTest, HandleRegisterAbilityDebugResponse_0200, TestSize.Level1)
261 {
262 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
263 MessageParcel data;
264 MessageParcel reply;
265 MessageOption option(MessageOption::TF_ASYNC);
266 response_ = nullptr;
267 WriteInterfaceToken(data);
268 data.WriteRemoteObject(response_);
269
270 EXPECT_CALL(*mockAmsMgrScheduler_, RegisterAbilityDebugResponse(_)).Times(0);
271 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
272 static_cast<uint32_t>(IAmsMgr::Message::REGISTER_ABILITY_DEBUG_RESPONSE), data, reply, option);
273 EXPECT_EQ(result, ERR_INVALID_VALUE);
274 }
275
276 /**
277 * @tc.name: NotifyAppMgrRecordExitReason_0100
278 * @tc.desc: NotifyAppMgrRecordExitReason.
279 * @tc.type: FUNC
280 */
281 HWTEST_F(AmsMgrStubTest, NotifyAppMgrRecordExitReason_0100, TestSize.Level1)
282 {
283 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
284 MessageParcel data;
285 MessageParcel reply;
286 MessageOption option(MessageOption::TF_SYNC);
287 WriteInterfaceToken(data);
288
289 int32_t reason = 0;
290 int32_t pid = 1;
291 std::string exitMsg = "JsError";
292 data.WriteInt32(reason);
293 data.WriteInt32(pid);
294 data.WriteString16(Str8ToStr16(exitMsg));
295
296 EXPECT_CALL(*mockAmsMgrScheduler_, NotifyAppMgrRecordExitReason(_, _, _))
297 .Times(1)
298 .WillOnce(Return(NO_ERROR));
299 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
300 static_cast<uint32_t>(IAmsMgr::Message::NOTIFY_APP_MGR_RECORD_EXIT_REASON), data, reply, option);
301 EXPECT_EQ(result, NO_ERROR);
302 }
303 } // namespace AppExecFwk
304 } // namespace OHOS
305