1 /*
2  * Copyright (c) 2024 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 "security_collector_test.h"
17 
18 #include <thread>
19 
20 #include "directory_ex.h"
21 #include "file_ex.h"
22 #include "gmock/gmock.h"
23 #include "system_ability_definition.h"
24 
25 #include "security_guard_define.h"
26 #include "security_guard_log.h"
27 #include "security_guard_utils.h"
28 #define private public
29 #define protected public
30 #include "data_collection.h"
31 #include "collector_cfg_marshalling.h"
32 #include "accesstoken_kit.h"
33 #include "security_collector_manager_service.h"
34 #include "security_collector_run_manager.h"
35 #undef private
36 #undef protected
37 
38 using namespace testing;
39 using namespace testing::ext;
40 using namespace OHOS::Security::SecurityGuard;
41 using namespace OHOS::Security::SecurityCollector;
42 
43 namespace OHOS {
44     std::shared_ptr<Security::AccessToken::MockAccessTokenKitInterface>
45         Security::AccessToken::AccessTokenKit::instance_ = nullptr;
46     std::shared_ptr<Security::AccessToken::MockTokenIdKitInterface>
47         Security::AccessToken::TokenIdKit::instance_ = nullptr;
48     std::mutex Security::AccessToken::AccessTokenKit::mutex_ {};
49     std::mutex Security::AccessToken::TokenIdKit::mutex_ {};
50     constexpr char PERMISSION[] = "ohos.permission.securityguard.REQUEST_SECURITY_EVENT_INFO";
51 }
52 
53 namespace OHOS::Security::SecurityCollectorTest {
54 SecurityCollectorManagerService g_service(SECURITY_COLLECTOR_MANAGER_SA_ID, true);
SetUpTestCase()55 void SecurityCollectorTest::SetUpTestCase()
56 {
57 }
58 
TearDownTestCase()59 void SecurityCollectorTest::TearDownTestCase()
60 {
61     AccessToken::AccessTokenKit::DelInterface();
62     AccessToken::TokenIdKit::DelInterface();
63 }
64 
SetUp()65 void SecurityCollectorTest::SetUp()
66 {
67 }
68 
TearDown()69 void SecurityCollectorTest::TearDown()
70 {
71 }
72 
73 class MockRemoteObject final : public IRemoteObject {
74 public:
MockRemoteObject()75     MockRemoteObject() : IRemoteObject(u"")
76     {
77     }
78     MOCK_METHOD0(GetObjectRefCount, int32_t());
79     MOCK_METHOD4(SendRequest, int(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option));
80     MOCK_METHOD1(AddDeathRecipient, bool(const sptr<DeathRecipient> &recipient));
81     MOCK_METHOD1(RemoveDeathRecipient, bool(const sptr<DeathRecipient> &recipient));
82     MOCK_METHOD2(Dump, int(int fd, const std::vector<std::u16string> &args));
83 };
84 
85 HWTEST_F(SecurityCollectorTest, GetAppName01, TestSize.Level1)
86 {
87     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
88         Return(AccessToken::ATokenTypeEnum::TOKEN_HAP));
89     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetHapTokenInfo).WillOnce(
90         Return(SecurityCollector::ErrorCode::FAILED));
91     EXPECT_EQ(SecurityCollectorManagerService::GetAppName(), "");
92 }
93 
94 HWTEST_F(SecurityCollectorTest, GetAppName02, TestSize.Level1)
95 {
96     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
97         Return(AccessToken::ATokenTypeEnum::TOKEN_HAP));
98     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetHapTokenInfo).WillRepeatedly(
__anond0c616bb0102(AccessToken::AccessTokenID tokenID, AccessToken::HapTokenInfo& hapTokenInfoRes) 99         [] (AccessToken::AccessTokenID tokenID, AccessToken::HapTokenInfo& hapTokenInfoRes) {
100             hapTokenInfoRes.bundleName = "bundleName";
101             return SecurityCollector::ErrorCode::SUCCESS;
102         });
103     EXPECT_EQ(SecurityCollectorManagerService::GetAppName(), "bundleName");
104 }
105 
106 HWTEST_F(SecurityCollectorTest, GetAppName03, TestSize.Level1)
107 {
108     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
109         Return(AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
110     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetNativeTokenInfo).WillOnce(
111         Return(SecurityCollector::ErrorCode::FAILED));
112     EXPECT_EQ(SecurityCollectorManagerService::GetAppName(), "");
113 }
114 
115 HWTEST_F(SecurityCollectorTest, GetAppName04, TestSize.Level1)
116 {
117     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
118         Return(AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
119     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetNativeTokenInfo).WillOnce(
__anond0c616bb0202(AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) 120         [] (AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) {
121             nativeTokenInfoRes.processName = "processName";
122             return SecurityCollector::ErrorCode::SUCCESS;
123         });
124     EXPECT_EQ(SecurityCollectorManagerService::GetAppName(), "processName");
125 }
126 
127 HWTEST_F(SecurityCollectorTest, GetAppName05, TestSize.Level1)
128 {
129     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillRepeatedly(
130         Return(AccessToken::ATokenTypeEnum::TOKEN_INVALID));
131     EXPECT_EQ(SecurityCollectorManagerService::GetAppName(), "");
132 }
133 
134 HWTEST_F(SecurityCollectorTest, HasPermission01, TestSize.Level1)
135 {
136     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
137         Return(AccessToken::PermissionState::PERMISSION_DENIED));
138     EXPECT_EQ(SecurityCollectorManagerService::HasPermission(PERMISSION), SecurityCollector::ErrorCode::NO_PERMISSION);
139 }
140 
141 HWTEST_F(SecurityCollectorTest, HasPermission02, TestSize.Level1)
142 {
143     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
144         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
145     EXPECT_EQ(SecurityCollectorManagerService::HasPermission(PERMISSION), SecurityCollector::ErrorCode::SUCCESS);
146 }
147 
148 HWTEST_F(SecurityCollectorTest, HasPermission03, TestSize.Level1)
149 {
150     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
151         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
152     EXPECT_EQ(SecurityCollectorManagerService::HasPermission(PERMISSION), SecurityCollector::ErrorCode::SUCCESS);
153 }
154 
155 HWTEST_F(SecurityCollectorTest, Subscribe01, TestSize.Level1)
156 {
157     SecurityCollectorSubscribeInfo subscribeInfo{};
158     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
159     EXPECT_TRUE(obj != nullptr);
160     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
161         Return(AccessToken::PermissionState::PERMISSION_DENIED));
162     EXPECT_EQ(g_service.Subscribe(subscribeInfo, obj), SecurityCollector::ErrorCode::NO_PERMISSION);
163     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
164 }
165 
166 HWTEST_F(SecurityCollectorTest, Subscribe02, TestSize.Level1)
167 {
168     SecurityCollector::Event event {
169         .eventId = 2,
170         .version = "version",
171         .content = "content",
172         .extra = ""
173     };
174     SecurityCollectorSubscribeInfo subscribeInfo(event, -1, true);
175     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
176     EXPECT_TRUE(obj != nullptr);
177     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
178         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
179     EXPECT_EQ(g_service.Subscribe(subscribeInfo, obj), SecurityCollector::ErrorCode::BAD_PARAM);
180     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
181 }
182 
183 HWTEST_F(SecurityCollectorTest, Subscribe03, TestSize.Level1)
184 {
185     SecurityCollector::Event event {
186         .eventId = 2,
187         .version = "version",
188         .content = "content",
189         .extra = ""
190     };
191     SecurityCollectorSubscribeInfo subscribeInfo(event);
192     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
193     EXPECT_TRUE(obj != nullptr);
194     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
195         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
196     EXPECT_EQ(g_service.Subscribe(subscribeInfo, obj), SecurityCollector::ErrorCode::BAD_PARAM);
197     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
198 }
199 
200 HWTEST_F(SecurityCollectorTest, Unsubscribe01, TestSize.Level1)
201 {
202     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
203     EXPECT_TRUE(obj != nullptr);
204     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
205         Return(AccessToken::PermissionState::PERMISSION_DENIED));
206     EXPECT_EQ(g_service.Unsubscribe(obj), SecurityCollector::ErrorCode::NO_PERMISSION);
207     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
208 }
209 
210 HWTEST_F(SecurityCollectorTest, CollectorStart01, TestSize.Level1)
211 {
212     SecurityCollectorSubscribeInfo info{};
213     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
214     EXPECT_TRUE(obj != nullptr);
215     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
216         Return(AccessToken::PermissionState::PERMISSION_DENIED));
217     EXPECT_EQ(g_service.CollectorStart(info, obj), SecurityCollector::ErrorCode::NO_PERMISSION);
218 }
219 
220 HWTEST_F(SecurityCollectorTest, CollectorStart02, TestSize.Level1)
221 {
222     SecurityCollectorSubscribeInfo info{};
223     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
224     EXPECT_TRUE(obj != nullptr);
225     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
226         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
227     EXPECT_CALL(DataCollection::GetInstance(), GetCollectorType).WillOnce(Return(SecurityCollector::ErrorCode::FAILED));
228     EXPECT_EQ(g_service.CollectorStart(info, obj), SecurityCollector::ErrorCode::BAD_PARAM);
229 }
230 
231 HWTEST_F(SecurityCollectorTest, CollectorStart03, TestSize.Level1)
232 {
233     SecurityCollectorSubscribeInfo info{};
234     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
235     EXPECT_TRUE(obj != nullptr);
236     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
237         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
__anond0c616bb0302(int64_t eventId, int32_t& collectorType) 238     EXPECT_CALL(DataCollection::GetInstance(), GetCollectorType).WillOnce([] (int64_t eventId, int32_t& collectorType) {
239         collectorType = 0;
240         return SecurityCollector::ErrorCode::SUCCESS;
241     });
242     EXPECT_EQ(g_service.CollectorStart(info, obj), SecurityCollector::ErrorCode::BAD_PARAM);
243 }
244 
245 HWTEST_F(SecurityCollectorTest, CollectorStart04, TestSize.Level1)
246 {
247     SecurityCollectorSubscribeInfo info{};
248     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
249     EXPECT_TRUE(obj != nullptr);
250     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
251         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
__anond0c616bb0402(int64_t eventId, int32_t& collectorType) 252     EXPECT_CALL(DataCollection::GetInstance(), GetCollectorType).WillOnce([] (int64_t eventId, int32_t& collectorType) {
253         collectorType = 1;
254         return SecurityCollector::ErrorCode::SUCCESS;
255     });
256     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
257         Return(AccessToken::ATokenTypeEnum::TOKEN_HAP));
258     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetHapTokenInfo).WillOnce(
259         Return(SecurityCollector::ErrorCode::FAILED));
260     EXPECT_EQ(g_service.CollectorStart(info, obj), SecurityCollector::ErrorCode::BAD_PARAM);
261 }
262 
263 HWTEST_F(SecurityCollectorTest, CollectorStart05, TestSize.Level1)
264 {
265     SecurityCollectorSubscribeInfo info{};
266     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
267     EXPECT_TRUE(obj != nullptr);
268     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
269         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
__anond0c616bb0502(int64_t eventId, int32_t& collectorType) 270     EXPECT_CALL(DataCollection::GetInstance(), GetCollectorType).WillOnce([] (int64_t eventId, int32_t& collectorType) {
271         collectorType = 1;
272         return SecurityCollector::ErrorCode::SUCCESS;
273     });
274     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
275         Return(AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
276     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetNativeTokenInfo).WillOnce(
__anond0c616bb0602(AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) 277         [] (AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) {
278             nativeTokenInfoRes.processName = "processName";
279             return SecurityCollector::ErrorCode::SUCCESS;
280         });
281     EXPECT_CALL(SecurityCollectorRunManager::GetInstance(), StartCollector).WillOnce(Return(false));
282     EXPECT_EQ(g_service.CollectorStart(info, obj), SecurityCollector::ErrorCode::BAD_PARAM);
283 }
284 
285 HWTEST_F(SecurityCollectorTest, CollectorStart06, TestSize.Level1)
286 {
287     SecurityCollectorSubscribeInfo info{};
288     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
289     EXPECT_TRUE(obj != nullptr);
290     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
291         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
__anond0c616bb0702(int64_t eventId, int32_t& collectorType) 292     EXPECT_CALL(DataCollection::GetInstance(), GetCollectorType).WillOnce([] (int64_t eventId, int32_t& collectorType) {
293         collectorType = 1;
294         return SecurityCollector::ErrorCode::SUCCESS;
295     });
296     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
297         Return(AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
298     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetNativeTokenInfo).WillOnce(
__anond0c616bb0802(AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) 299         [] (AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) {
300             nativeTokenInfoRes.processName = "processName";
301             return SecurityCollector::ErrorCode::SUCCESS;
302         });
303     EXPECT_CALL(SecurityCollectorRunManager::GetInstance(), StartCollector).WillOnce(Return(true));
304     EXPECT_EQ(g_service.CollectorStart(info, obj), SecurityCollector::ErrorCode::SUCCESS);
305 }
306 
307 HWTEST_F(SecurityCollectorTest, CollectorStop01, TestSize.Level1)
308 {
309     SecurityCollectorSubscribeInfo info{};
310     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
311     EXPECT_TRUE(obj != nullptr);
312     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
313         Return(AccessToken::PermissionState::PERMISSION_DENIED));
314     EXPECT_EQ(g_service.CollectorStop(info, obj), SecurityCollector::ErrorCode::NO_PERMISSION);
315 }
316 
317 HWTEST_F(SecurityCollectorTest, CollectorStop02, TestSize.Level1)
318 {
319     SecurityCollectorSubscribeInfo info{};
320     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
321     EXPECT_TRUE(obj != nullptr);
322     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
323         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
324     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
325         Return(AccessToken::ATokenTypeEnum::TOKEN_HAP));
326     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetHapTokenInfo).WillOnce(
327         Return(SecurityCollector::ErrorCode::FAILED));
328     EXPECT_EQ(g_service.CollectorStop(info, obj), SecurityCollector::ErrorCode::BAD_PARAM);
329 }
330 
331 HWTEST_F(SecurityCollectorTest, CollectorStop03, TestSize.Level1)
332 {
333     SecurityCollectorSubscribeInfo info{};
334     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
335     EXPECT_TRUE(obj != nullptr);
336     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
337         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
338     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
339         Return(AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
340     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetNativeTokenInfo).WillOnce(
__anond0c616bb0902(AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) 341         [] (AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) {
342             nativeTokenInfoRes.processName = "processName";
343             return SecurityCollector::ErrorCode::SUCCESS;
344         });
345     EXPECT_CALL(SecurityCollectorRunManager::GetInstance(), StopCollector).WillOnce(Return(false));
346     EXPECT_EQ(g_service.CollectorStop(info, obj), SecurityCollector::ErrorCode::BAD_PARAM);
347 }
348 
349 HWTEST_F(SecurityCollectorTest, CollectorStop04, TestSize.Level1)
350 {
351     SecurityCollectorSubscribeInfo info{};
352     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
353     EXPECT_TRUE(obj != nullptr);
354     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
355         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
356     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
357         Return(AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
358     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetNativeTokenInfo).WillOnce(
__anond0c616bb0a02(AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) 359         [] (AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) {
360             nativeTokenInfoRes.processName = "processName";
361             return SecurityCollector::ErrorCode::SUCCESS;
362         });
363     EXPECT_CALL(SecurityCollectorRunManager::GetInstance(), StopCollector).WillOnce(Return(true));
364     EXPECT_EQ(g_service.CollectorStop(info, obj), SecurityCollector::ErrorCode::SUCCESS);
365 }
366 
367 HWTEST_F(SecurityCollectorTest, ExecuteOnNotifyByTask01, TestSize.Level1)
368 {
369     Event event{};
370     sptr<MockRemoteObject> obj = nullptr;
371     g_service.ExecuteOnNotifyByTask(obj, event);
372     EXPECT_TRUE(obj == nullptr);
373 }
374 
375 HWTEST_F(SecurityCollectorTest, ExecuteOnNotifyByTask02, TestSize.Level1)
376 {
377     Event event{};
378     event.eventId = SecurityCollector::FILE_EVENTID;
379     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
380     EXPECT_TRUE(obj != nullptr);
381     EXPECT_CALL(*obj, SendRequest)
__anond0c616bb0b02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 382         .WillOnce([](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
383             g_service.OnRemoteRequest(code, data, reply, option);
384             return SecurityCollector::ErrorCode::SUCCESS;
385         });
386     g_service.ExecuteOnNotifyByTask(obj, event);
387     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
388 }
389 
390 HWTEST_F(SecurityCollectorTest, ExecuteOnNotifyByTask03, TestSize.Level1)
391 {
392     Event event{};
393     event.eventId = SecurityCollector::PROCESS_EVENTID;
394     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
395     EXPECT_TRUE(obj != nullptr);
396     EXPECT_CALL(*obj, SendRequest)
__anond0c616bb0c02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 397         .WillOnce([](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
398             g_service.OnRemoteRequest(code, data, reply, option);
399             return SecurityCollector::ErrorCode::SUCCESS;
400         });
401     g_service.ExecuteOnNotifyByTask(obj, event);
402     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
403 }
404 
405 HWTEST_F(SecurityCollectorTest, ExecuteOnNotifyByTask04, TestSize.Level1)
406 {
407     Event event{};
408     event.eventId = SecurityCollector::NETWORK_EVENTID;
409     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
410     EXPECT_TRUE(obj != nullptr);
411     EXPECT_CALL(*obj, SendRequest)
__anond0c616bb0d02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 412         .WillOnce([](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
413             g_service.OnRemoteRequest(code, data, reply, option);
414             return SecurityCollector::ErrorCode::SUCCESS;
415         });
416     g_service.ExecuteOnNotifyByTask(obj, event);
417     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
418 }
419 
420 HWTEST_F(SecurityCollectorTest, ExecuteOnNotifyByTask05, TestSize.Level1)
421 {
422     Event event{};
423     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
424     EXPECT_TRUE(obj != nullptr);
425     EXPECT_CALL(*obj, SendRequest)
__anond0c616bb0e02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 426         .WillOnce([](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
427             g_service.OnRemoteRequest(code, data, reply, option);
428             return SecurityCollector::ErrorCode::SUCCESS;
429         });
430     g_service.ExecuteOnNotifyByTask(obj, event);
431     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
432 }
433 
434 HWTEST_F(SecurityCollectorTest, QuerySecurityEvent01, TestSize.Level1)
435 {
436     std::vector<SecurityEventRuler> rulers{};
437     std::vector<SecurityEvent> events{};
438     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
439         Return(AccessToken::PermissionState::PERMISSION_DENIED));
440     EXPECT_EQ(g_service.QuerySecurityEvent(rulers, events), SecurityCollector::ErrorCode::NO_PERMISSION);
441 }
442 
443 HWTEST_F(SecurityCollectorTest, QuerySecurityEvent02, TestSize.Level1)
444 {
445     std::vector<SecurityEventRuler> rulers{};
446     std::vector<SecurityEvent> events{};
447     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
448         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
449     EXPECT_CALL(DataCollection::GetInstance(), QuerySecurityEvent).WillOnce(Return(false));
450     EXPECT_EQ(g_service.QuerySecurityEvent(rulers, events), SecurityCollector::ErrorCode::READ_ERR);
451 }
452 
453 HWTEST_F(SecurityCollectorTest, QuerySecurityEvent03, TestSize.Level1)
454 {
455     std::vector<SecurityEventRuler> rulers{};
456     std::vector<SecurityEvent> events{};
457     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
458         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
459     EXPECT_CALL(DataCollection::GetInstance(), QuerySecurityEvent).WillOnce(Return(true));
460     EXPECT_EQ(g_service.QuerySecurityEvent(rulers, events), SecurityCollector::ErrorCode::SUCCESS);
461 }
462 
463 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithInvalidInt, TestSize.Level1)
464 {
465     MessageParcel data;
466     MessageParcel reply;
467     MessageOption option;
468 
469     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
470     data.WriteInt32(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE);
471     int32_t result =
472         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
473     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
474 }
475 
476 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithInvalidCmd, TestSize.Level1)
477 {
478     MessageParcel data;
479     MessageParcel reply;
480     MessageOption option;
481 
482     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
483     data.WriteInt32(100);
484     int32_t result = g_service.OnRemoteRequest(100, data, reply, option);
485     EXPECT_EQ(result, 305);
486 }
487 
488 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithInvalidToken, TestSize.Level1)
489 {
490     MessageParcel data;
491     MessageParcel reply;
492     MessageOption option;
493 
494     data.WriteInterfaceToken(u"InvalidToken");
495     int32_t result =
496         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
497     EXPECT_EQ(result, 305);
498 }
499 
500 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd00, TestSize.Level1)
501 {
502     MessageParcel data;
503     MessageParcel reply;
504     MessageOption option;
505     SecurityCollectorSubscribeInfo subscribeInfo{};
506     sptr<MockRemoteObject> callback = nullptr;
507 
508     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
509     int32_t result =
510         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
511     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
512 }
513 
514 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd01, TestSize.Level1)
515 {
516     MessageParcel data;
517     MessageParcel reply;
518     MessageOption option;
519     SecurityCollectorSubscribeInfo subscribeInfo{};
520     sptr<MockRemoteObject> callback = nullptr;
521 
522     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
523     data.WriteParcelable(&subscribeInfo);
524     data.WriteRemoteObject(callback);
525     int32_t result =
526         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
527     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
528 }
529 
530 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd02, TestSize.Level1)
531 {
532     MessageParcel data;
533     MessageParcel reply;
534     MessageOption option;
535     SecurityCollectorSubscribeInfo subscribeInfo{};
536     sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
537 
538     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
539     data.WriteParcelable(&subscribeInfo);
540     data.WriteRemoteObject(callback);
541     int32_t result =
542         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
543     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
544 }
545 
546 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd03, TestSize.Level1)
547 {
548     MessageParcel data;
549     MessageParcel reply;
550     MessageOption option;
551 
552     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
553     int32_t result =
554         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_UNSUBCRIBE, data, reply, option);
555     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
556 }
557 
558 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd04, TestSize.Level1)
559 {
560     MessageParcel data;
561     MessageParcel reply;
562     MessageOption option;
563     sptr<MockRemoteObject> callback = nullptr;
564 
565     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
566     data.WriteRemoteObject(callback);
567     int32_t result =
568         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_UNSUBCRIBE, data, reply, option);
569     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
570 }
571 
572 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd05, TestSize.Level1)
573 {
574     MessageParcel data;
575     MessageParcel reply;
576     MessageOption option;
577     sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
578 
579     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
580     data.WriteRemoteObject(callback);
581     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
582         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
583     int32_t result =
584         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_UNSUBCRIBE, data, reply, option);
585     EXPECT_EQ(result, SecurityCollector::ErrorCode::SUCCESS);
586 }
587 
588 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd06, TestSize.Level1)
589 {
590     MessageParcel data;
591     MessageParcel reply;
592     MessageOption option;
593     sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
594 
595     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
596     int32_t result =
597         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_START, data, reply, option);
598     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
599 }
600 
601 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd07, TestSize.Level1)
602 {
603     MessageParcel data;
604     MessageParcel reply;
605     MessageOption option;
606     SecurityCollectorSubscribeInfo subscribeInfo{};
607     sptr<MockRemoteObject> callback = nullptr;
608 
609     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
610     data.WriteParcelable(&subscribeInfo);
611     data.WriteRemoteObject(callback);
612     int32_t result =
613         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_START, data, reply, option);
614     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
615 }
616 
617 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd08, TestSize.Level1)
618 {
619     MessageParcel data;
620     MessageParcel reply;
621     MessageOption option;
622     SecurityCollectorSubscribeInfo subscribeInfo{};
623     sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
624 
625     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
626     data.WriteParcelable(&subscribeInfo);
627     data.WriteRemoteObject(callback);
628     int32_t result =
629         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_START, data, reply, option);
630     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
631 }
632 
633 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd09, TestSize.Level1)
634 {
635     MessageParcel data;
636     MessageParcel reply;
637     MessageOption option;
638 
639     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
640     int32_t result =
641         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_STOP, data, reply, option);
642     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
643 }
644 
645 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd10, TestSize.Level1)
646 {
647     MessageParcel data;
648     MessageParcel reply;
649     MessageOption option;
650     SecurityCollectorSubscribeInfo subscribeInfo{};
651     sptr<MockRemoteObject> callback = nullptr;
652 
653     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
654     data.WriteParcelable(&subscribeInfo);
655     data.WriteRemoteObject(callback);
656     int32_t result =
657         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_STOP, data, reply, option);
658     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
659 }
660 
661 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd11, TestSize.Level1)
662 {
663     MessageParcel data;
664     MessageParcel reply;
665     MessageOption option;
666     SecurityCollectorSubscribeInfo subscribeInfo{};
667     sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
668 
669     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
670     data.WriteParcelable(&subscribeInfo);
671     data.WriteRemoteObject(callback);
672     int32_t result =
673         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_STOP, data, reply, option);
674     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
675 }
676 
677 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd12, TestSize.Level1)
678 {
679     MessageParcel data;
680     MessageParcel reply;
681     MessageOption option;
682 
683     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
684     int32_t result =
685         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_QUERY, data, reply, option);
686     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
687 }
688 
689 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd13, TestSize.Level1)
690 {
691     MessageParcel data;
692     MessageParcel reply;
693     MessageOption option;
694     SecurityCollectorSubscribeInfo subscribeInfo{};
695 
696     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
697     data.WriteInt32(SecurityCollector::MAX_QUERY_EVENT_SIZE + 1);
698     int32_t result =
699         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_QUERY, data, reply, option);
700     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
701 }
702 
703 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd14, TestSize.Level1)
704 {
705     MessageParcel data;
706     MessageParcel reply;
707     MessageOption option;
708     SecurityCollector::SecurityEventRuler ruler{};
709 
710     data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
711     data.WriteInt32(1);
712     data.WriteParcelable(&ruler);
713     int32_t result =
714         g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_QUERY, data, reply, option);
715     EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
716 }
717 }