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 "inner_api_collector_test.h"
17
18 #include "gmock/gmock.h"
19
20 #include "security_guard_define.h"
21 #include "security_guard_log.h"
22 #define private public
23 #define protected public
24 #include "acquire_data_manager_callback_service.h"
25 #include "acquire_data_manager_callback_stub.h"
26 #include "data_collect_manager_callback_service.h"
27 #include "data_collect_manager_callback_stub.h"
28 #include "data_collect_manager_idl_proxy.h"
29 #include "data_collect_manager.h"
30 #include "risk_analysis_manager_callback_service.h"
31 #include "risk_analysis_manager_callback_stub.h"
32 #include "risk_analysis_manager_callback.h"
33 #include "risk_analysis_manager_proxy.h"
34 #include "collector_manager.h"
35 #include "security_collector_manager_callback_stub.h"
36 #include "security_collector_manager_proxy.h"
37 #include "security_collector_subscribe_info.h"
38 #include "security_event.h"
39 #include "security_event_ruler.h"
40 #include "security_event_query_callback_service.h"
41 #include "security_event_query_callback_stub.h"
42 #include "security_event_query_callback.h"
43 #undef private
44 #undef protected
45
46 using namespace OHOS::Security::SecurityGuard;
47 using namespace OHOS::Security::SecurityCollector;
48
49 namespace OHOS {
50 class MockCollectorSubscriber : public ICollectorSubscriber {
51 public:
MockCollectorSubscriber(const Event & event)52 explicit MockCollectorSubscriber(const Event &event) : ICollectorSubscriber(event) {};
OnNotify(const Event & event)53 int32_t OnNotify(const Event &event) override { return 0; };
54 };
55
56 class MockRemoteObject final : public IRemoteObject {
57 public:
MockRemoteObject()58 MockRemoteObject() : IRemoteObject(u"")
59 {
60 }
GetObjectRefCount()61 int32_t GetObjectRefCount() { return 0; };
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)62 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; };
AddDeathRecipient(const sptr<DeathRecipient> & recipient)63 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)64 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
Dump(int fd,const std::vector<std::u16string> & args)65 int Dump(int fd, const std::vector<std::u16string> &args) { return 0; };
66 };
67
68 class MockAcquireDataManagerCallbackStub : public AcquireDataManagerCallbackStub {
69 public:
70 explicit MockAcquireDataManagerCallbackStub() = default;
71 ~MockAcquireDataManagerCallbackStub() override = default;
OnNotify(const std::vector<Security::SecurityCollector::Event> & events)72 int32_t OnNotify(const std::vector<Security::SecurityCollector::Event> &events) override { return 0; };
73 };
74
75 class MockRiskAnalysisManagerCallbackStub : public RiskAnalysisManagerCallbackStub {
76 public:
77 MockRiskAnalysisManagerCallbackStub() = default;
78 ~MockRiskAnalysisManagerCallbackStub() override = default;
ResponseSecurityModelResult(const std::string & devId,uint32_t modelId,std::string & result)79 int32_t ResponseSecurityModelResult(const std::string &devId, uint32_t modelId, std::string &result) override
80 {
81 return 0;
82 };
83 };
84
85 class MockSecurityCollectorManagerCallbackStub : public SecurityCollectorManagerCallbackStub {
86 public:
87 MockSecurityCollectorManagerCallbackStub() = default;
88 ~MockSecurityCollectorManagerCallbackStub() override = default;
89
OnNotify(const Event & event)90 int32_t OnNotify(const Event &event) override { return 0; };
91 };
92
93 class MockDataCollectManagerCallbackStub : public DataCollectManagerCallbackStub {
94 public:
95 MockDataCollectManagerCallbackStub() = default;
96 ~MockDataCollectManagerCallbackStub() override = default;
97
ResponseRiskData(std::string & devId,std::string & riskData,uint32_t status,const std::string & errMsg="")98 int32_t ResponseRiskData(std::string &devId, std::string &riskData, uint32_t status,
99 const std::string& errMsg = "") override { return 0; };
100 };
101
102 class MockSecurityEventQueryCallback : public SecurityEventQueryCallback {
103 public:
104 MockSecurityEventQueryCallback() = default;
105 ~MockSecurityEventQueryCallback() override = default;
OnQuery(const std::vector<SecurityEvent> & events)106 void OnQuery(const std::vector<SecurityEvent> &events) override {};
OnComplete()107 void OnComplete() override {};
OnError(const std::string & message)108 void OnError(const std::string &message) override {};
109 };
110
111 class MockSecurityEventQueryCallbackStub : public SecurityEventQueryCallbackStub {
112 public:
113 MockSecurityEventQueryCallbackStub() = default;
114 ~MockSecurityEventQueryCallbackStub() override = default;
OnQuery(const std::vector<SecurityEvent> & events)115 void OnQuery(const std::vector<SecurityEvent> &events) override {};
OnComplete()116 void OnComplete() override {};
OnError(const std::string & message)117 void OnError(const std::string &message) override {};
118 };
119
TestRequestRiskDataCallback(std::string &,std::string &,uint32_t,const std::string &)120 int32_t TestRequestRiskDataCallback(std::string &, std::string &, uint32_t, const std::string &)
121 {
122 return 0;
123 }
124
TestResultCallback(const std::string & devId,uint32_t modelId,const std::string & result)125 int32_t TestResultCallback(const std::string &devId, uint32_t modelId, const std::string &result)
126 {
127 return 0;
128 }
129 }
130
131 namespace OHOS::Security::SecurityGuardTest {
SetUpTestCase()132 void InnerApiCollectorTest::SetUpTestCase()
133 {
134 }
135
TearDownTestCase()136 void InnerApiCollectorTest::TearDownTestCase()
137 {
138 }
139
SetUp()140 void InnerApiCollectorTest::SetUp()
141 {
142 }
143
TearDown()144 void InnerApiCollectorTest::TearDown()
145 {
146 }
147
148 HWTEST_F(InnerApiCollectorTest, AcquireDataManagerTest001, testing::ext::TestSize.Level1)
149 {
150 Security::SecurityCollector::Event event;
151 auto subscriber = std::make_shared<MockCollectorSubscriber>(event);
152 int ret = DataCollectManager::GetInstance().Subscribe(subscriber);
153 EXPECT_FALSE(ret == SUCCESS);
154 ret = DataCollectManager::GetInstance().Unsubscribe(subscriber);
155 EXPECT_TRUE(ret == BAD_PARAM);
156 DataCollectManager::GetInstance().HandleDecipient();
157
158 AcquireDataManagerCallbackService service;
159 ret = service.OnNotify({event});
160 EXPECT_TRUE(ret == FAILED);
161
162 service.RegistCallBack(
__anonb4a7c8790102(const Security::SecurityCollector::Event &event) 163 [] (const Security::SecurityCollector::Event &event) {}
164 );
165 ret = service.OnNotify({event});
166 EXPECT_TRUE(ret == SUCCESS);
167 }
168
169 HWTEST_F(InnerApiCollectorTest, AcquireDataManagerCallbackStubTest001, testing::ext::TestSize.Level1)
170 {
171 MockAcquireDataManagerCallbackStub stub;
172 MessageParcel datas;
173 MessageParcel reply;
174 MessageOption option;
175 int ret = stub.OnRemoteRequest(0, datas, reply, option);
176 EXPECT_TRUE(ret == NO_PERMISSION);
177 int64_t int64 = 0;
178 std::string string = "test";
179 datas.WriteInterfaceToken(AcquireDataManagerCallbackStub::GetDescriptor());
180 ret = stub.OnRemoteRequest(0, datas, reply, option);
181 EXPECT_FALSE(ret == SUCCESS);
182 datas.WriteInterfaceToken(AcquireDataManagerCallbackStub::GetDescriptor());
183 datas.WriteInt64(int64);
184 datas.WriteString(string);
185 datas.WriteString(string);
186 datas.WriteString(string);
187 ret = stub.OnRemoteRequest(AcquireDataManagerCallbackStub::CMD_DATA_SUBSCRIBE_CALLBACK, datas, reply, option);
188 EXPECT_TRUE(ret == SUCCESS);
189 }
190
191 HWTEST_F(InnerApiCollectorTest, RiskAnalysisManagerCallbackServiceTest001, testing::ext::TestSize.Level1)
192 {
193 MockRiskAnalysisManagerCallbackStub stub;
194 MessageParcel datas;
195 MessageParcel reply;
196 MessageOption option;
197 uint32_t code = 0;
198 std::string string = "test";
199 int ret = stub.OnRemoteRequest(code, datas, reply, option);
200 EXPECT_TRUE(ret == NO_PERMISSION);
201 datas.WriteInterfaceToken(IRiskAnalysisManagerCallback::GetDescriptor());
202 ret = stub.OnRemoteRequest(code, datas, reply, option);
203 EXPECT_FALSE(ret == SUCCESS);
204 datas.WriteInterfaceToken(IRiskAnalysisManagerCallback::GetDescriptor());
205 datas.WriteUint32(0);
206 datas.WriteString(string);
207 ret = stub.OnRemoteRequest(RiskAnalysisManagerCallbackStub::CMD_SET_SECURITY_MODEL_RESULT,
208 datas, reply, option);
209 EXPECT_TRUE(ret == SUCCESS);
210 ResultCallback callback;
211 RiskAnalysisManagerCallbackService service(callback);
212 ret = service.ResponseSecurityModelResult(string, code, string);
213 EXPECT_TRUE(ret == SUCCESS);
214 service.callback_ = TestResultCallback;
215 ret = service.ResponseSecurityModelResult(string, code, string);
216 EXPECT_TRUE(ret == SUCCESS);
217 }
218
219 HWTEST_F(InnerApiCollectorTest, RiskAnalysisManagerProxyTest001, testing::ext::TestSize.Level1)
220 {
221 sptr<IRemoteObject> obj(new (std::nothrow) MockRemoteObject());
__anonb4a7c8790202(const std::string &devId, uint32_t modelId, const std::string &result) 222 ResultCallback func = [] (const std::string &devId, uint32_t modelId, const std::string &result) -> int32_t {
223 return 0;
224 };
225 sptr<RiskAnalysisManagerCallbackService> callback = new (std::nothrow) RiskAnalysisManagerCallbackService(func);
226 uint32_t uint32 = 0;
227 std::string string = "test";
228 RiskAnalysisManagerProxy proxy{obj};
229 int ret = proxy.RequestSecurityModelResult(string, uint32, string, callback);
230 EXPECT_TRUE(ret == SUCCESS);
231 ret = proxy.SetModelState(uint32, true);
232 EXPECT_TRUE(ret == SUCCESS);
233 }
234
235 HWTEST_F(InnerApiCollectorTest, CollectorManagerTest001, testing::ext::TestSize.Level1)
236 {
237 Security::SecurityCollector::Event event;
238 auto subscriber = std::make_shared<MockCollectorSubscriber>(event);
239 std::vector<SecurityEventRuler> rulers{};
240 std::vector<SecurityEvent> events{};
241 SecurityCollectorSubscribeInfo subscribeInfo{};
242 int ret = CollectorManager::GetInstance().Subscribe(subscriber);
243 EXPECT_FALSE(ret == SUCCESS);
244 ret = CollectorManager::GetInstance().Unsubscribe(subscriber);
245 EXPECT_TRUE(ret == BAD_PARAM);
246 ret = CollectorManager::GetInstance().QuerySecurityEvent(rulers, events);
247 EXPECT_FALSE(ret == SUCCESS);
248 ret = CollectorManager::GetInstance().CollectorStart(subscribeInfo);
249 EXPECT_FALSE(ret == SUCCESS);
250 ret = CollectorManager::GetInstance().CollectorStop(subscribeInfo);
251 EXPECT_FALSE(ret == SUCCESS);
252
253 CollectorManager manager;
254 sptr<Security::SecurityCollector::SecurityCollectorManagerCallbackService> callback =
255 new (std::nothrow) Security::SecurityCollector::SecurityCollectorManagerCallbackService(nullptr);
256 manager.eventListeners_[subscriber] = callback;
257 ret = manager.Subscribe(nullptr);
258 EXPECT_TRUE(ret == BAD_PARAM);
259 ret = manager.Subscribe(subscriber);
260 EXPECT_FALSE(ret == SUCCESS);
261 ret = manager.Unsubscribe(nullptr);
262 EXPECT_TRUE(ret == BAD_PARAM);
263 ret = manager.Unsubscribe(subscriber);
264 EXPECT_FALSE(ret == SUCCESS);
265 }
266
267 HWTEST_F(InnerApiCollectorTest, DataCollectManagerCallbackServiceTest001, testing::ext::TestSize.Level1)
268 {
269 MockDataCollectManagerCallbackStub stub;
270 MessageParcel datas;
271 MessageParcel reply;
272 MessageOption option;
273 uint32_t uint32 = 0;
274 std::string string = "test";
275 datas.WriteInterfaceToken(IDataCollectManagerCallback::GetDescriptor());
276 datas.WriteString(string);
277 datas.WriteUint32(uint32);
278 datas.WriteString(string);
279 int ret = stub.OnRemoteRequest(DataCollectManagerCallbackStub::CMD_SET_REQUEST_DATA, datas, reply, option);
280 EXPECT_TRUE(ret == SUCCESS);
281 ret = stub.OnRemoteRequest(0, datas, reply, option);
282 EXPECT_FALSE(ret == SUCCESS);
283 RequestRiskDataCallback callback;
284 DataCollectManagerCallbackService service(callback);
285 ret = service.ResponseRiskData(string, string, uint32, string);
286 EXPECT_TRUE(ret == NULL_OBJECT);
287 service.callback_ = TestRequestRiskDataCallback;
288 ret = service.ResponseRiskData(string, string, uint32, string);
289 EXPECT_TRUE(ret == SUCCESS);
290 }
291
292 HWTEST_F(InnerApiCollectorTest, DataCollectManagerTest001, testing::ext::TestSize.Level1)
293 {
294 DataCollectManager manager;
295 std::vector<SecurityEventRuler> rulers;
296 std::shared_ptr<MockSecurityEventQueryCallback> callback = std::make_shared<MockSecurityEventQueryCallback>();
297 int ret = manager.QuerySecurityEvent(rulers, callback);
298 EXPECT_TRUE(ret != SUCCESS);
299 }
300
301 HWTEST_F(InnerApiCollectorTest, SecurityCollectorManagerCallbackStubTest001, testing::ext::TestSize.Level1)
302 {
303 MockSecurityCollectorManagerCallbackStub stub;
304 MessageParcel datas;
305 MessageParcel reply;
306 MessageOption option;
307 uint32_t code = 0;
308 int64_t eventId = 0;
309 std::string string = "test";
310 std::vector<std::string> vec ={{"1111111111"}, "222222222"};
311 int ret = stub.OnRemoteRequest(code, datas, reply, option);
312 EXPECT_TRUE(ret == NO_PERMISSION);
313 datas.WriteInterfaceToken(ISecurityCollectorManagerCallback::GetDescriptor());
314 ret = stub.OnRemoteRequest(code, datas, reply, option);
315 EXPECT_FALSE(ret == SUCCESS);
316 datas.WriteInterfaceToken(ISecurityCollectorManagerCallback::GetDescriptor());
317 datas.WriteInt64(eventId);
318 datas.WriteString(string);
319 datas.WriteString(string);
320 datas.WriteString(string);
321 datas.WriteUint32(static_cast<uint32_t>(vec.size()));
322 for (auto iter : vec) {
323 datas.WriteString(iter);
324 }
325 ret = stub.OnRemoteRequest(SecurityCollectorManagerCallbackStub::CMD_COLLECTOR_NOTIFY, datas, reply, option);
326 EXPECT_TRUE(ret == SUCCESS);
327 }
328
329 HWTEST_F(InnerApiCollectorTest, SecurityCollectorManagerProxyTest001, testing::ext::TestSize.Level1)
330 {
331 sptr<IRemoteObject> obj(new (std::nothrow) MockRemoteObject());
332 sptr<Security::SecurityCollector::SecurityCollectorManagerCallbackService> callback =
333 new (std::nothrow) Security::SecurityCollector::SecurityCollectorManagerCallbackService(nullptr);
334 SecurityCollectorSubscribeInfo subscribeInfo{};
335 SecurityCollectorManagerProxy proxy{obj};
336 std::vector<SecurityEventRuler> rulers{};
337 std::vector<SecurityEvent> events{};
338 int ret = proxy.Subscribe(subscribeInfo, callback);
339 EXPECT_TRUE(ret == SUCCESS);
340 ret = proxy.Unsubscribe(callback);
341 EXPECT_TRUE(ret == SUCCESS);
342 ret = proxy.CollectorStart(subscribeInfo, callback);
343 EXPECT_TRUE(ret == SUCCESS);
344 ret = proxy.CollectorStop(subscribeInfo, callback);
345 EXPECT_TRUE(ret == SUCCESS);
346 ret = proxy.QuerySecurityEvent(rulers, events);
347 EXPECT_FALSE(ret == SUCCESS);
348 }
349
350 HWTEST_F(InnerApiCollectorTest, SecurityCollectorSubscribeInfoTest001, testing::ext::TestSize.Level1)
351 {
352 std::string string = "test";
353 int64_t int64 = 0;
354 SecurityCollectorSubscribeInfo info;
355 Parcel parcel;
356 bool ret = info.Marshalling(parcel);
357 EXPECT_TRUE(ret);
358 SecurityCollectorSubscribeInfo *retInfo = info.Unmarshalling(parcel);
359 EXPECT_FALSE(retInfo == nullptr);
360 ret = info.ReadFromParcel(parcel);
361 EXPECT_FALSE(ret);
362
363 parcel.WriteInt64(int64);
364 ret = info.ReadFromParcel(parcel);
365 EXPECT_FALSE(ret);
366
367 parcel.WriteInt64(int64);
368 parcel.WriteBool(true);
369 ret = info.ReadFromParcel(parcel);
370 EXPECT_FALSE(ret);
371
372 parcel.WriteInt64(int64);
373 parcel.WriteBool(true);
374 parcel.WriteInt64(int64);
375 ret = info.ReadFromParcel(parcel);
376 EXPECT_FALSE(ret);
377
378 parcel.WriteInt64(int64);
379 parcel.WriteBool(true);
380 parcel.WriteInt64(int64);
381 parcel.WriteString(string);
382 ret = info.ReadFromParcel(parcel);
383 EXPECT_FALSE(ret);
384
385 parcel.WriteInt64(int64);
386 parcel.WriteBool(true);
387 parcel.WriteInt64(int64);
388 parcel.WriteString(string);
389 parcel.WriteString(string);
390 ret = info.ReadFromParcel(parcel);
391 EXPECT_FALSE(ret);
392
393 parcel.WriteInt64(int64);
394 parcel.WriteBool(true);
395 parcel.WriteInt64(int64);
396 parcel.WriteString(string);
397 parcel.WriteString(string);
398 parcel.WriteString(string);
399 parcel.WriteString(string);
400 ret = info.ReadFromParcel(parcel);
401 EXPECT_TRUE(ret);
402
403 retInfo = info.Unmarshalling(parcel);
404 EXPECT_TRUE(retInfo == nullptr);
405 }
406
407 HWTEST_F(InnerApiCollectorTest, SecurityEventTest001, testing::ext::TestSize.Level1)
408 {
409 std::string string = "test";
410 int64_t int64 = 0;
411 SecurityEvent event;
412 Parcel parcel;
413 bool ret = event.Marshalling(parcel);
414 EXPECT_TRUE(ret);
415 SecurityEvent *retEvent = event.Unmarshalling(parcel);
416 EXPECT_FALSE(retEvent == nullptr);
417 ret = event.ReadFromParcel(parcel);
418 EXPECT_FALSE(ret);
419
420 parcel.WriteInt64(int64);
421 ret = event.ReadFromParcel(parcel);
422 EXPECT_FALSE(ret);
423
424 parcel.WriteInt64(int64);
425 parcel.WriteString(string);
426 ret = event.ReadFromParcel(parcel);
427 EXPECT_FALSE(ret);
428
429 parcel.WriteInt64(int64);
430 parcel.WriteString(string);
431 parcel.WriteString(string);
432 ret = event.ReadFromParcel(parcel);
433 EXPECT_FALSE(ret);
434
435 parcel.WriteInt64(int64);
436 parcel.WriteString(string);
437 parcel.WriteString(string);
438 parcel.WriteString(string);
439 ret = event.ReadFromParcel(parcel);
440 EXPECT_FALSE(ret);
441
442 retEvent = event.Unmarshalling(parcel);
443 EXPECT_TRUE(retEvent == nullptr);
444 }
445
446 HWTEST_F(InnerApiCollectorTest, SecurityEventRulerTest001, testing::ext::TestSize.Level1)
447 {
448 std::string string = "test";
449 int64_t int64 = 0;
450 SecurityEventRuler ruler;
451 Parcel parcel;
452 int ret = ruler.Marshalling(parcel);
453 EXPECT_TRUE(ret);
454 SecurityEventRuler *retRuler = ruler.Unmarshalling(parcel);
455 EXPECT_FALSE(retRuler == nullptr);
456 ret = ruler.ReadFromParcel(parcel);
457 EXPECT_FALSE(ret);
458
459 parcel.WriteInt64(int64);
460 ret = ruler.ReadFromParcel(parcel);
461 EXPECT_FALSE(ret);
462
463 parcel.WriteInt64(int64);
464 parcel.WriteString(string);
465 ret = ruler.ReadFromParcel(parcel);
466 EXPECT_FALSE(ret);
467
468 parcel.WriteInt64(int64);
469 parcel.WriteString(string);
470 parcel.WriteString(string);
471 ret = ruler.ReadFromParcel(parcel);
472 EXPECT_FALSE(ret);
473
474 parcel.WriteInt64(int64);
475 parcel.WriteString(string);
476 parcel.WriteString(string);
477 parcel.WriteString(string);
478 ret = ruler.ReadFromParcel(parcel);
479 EXPECT_TRUE(ret);
480
481 retRuler = ruler.Unmarshalling(parcel);
482 EXPECT_TRUE(retRuler == nullptr);
483 }
484
485 HWTEST_F(InnerApiCollectorTest, SecurityEventQueryCallbackServiceTest001, testing::ext::TestSize.Level1)
486 {
487 std::shared_ptr<MockSecurityEventQueryCallback> callback = std::make_shared<MockSecurityEventQueryCallback>();
488 SecurityEventQueryCallbackService service(nullptr);
489 std::string message = "message";
490 std::vector<SecurityEvent> events;
491 service.OnQuery(events);
492 EXPECT_EQ(events.size(), 0);
493 service.OnComplete();
494 service.OnError(message);
495 EXPECT_EQ(message, "message");
496 SecurityEventQueryCallbackService service2(callback);
497 service2.OnQuery(events);
498 EXPECT_EQ(events.size(), 0);
499 service2.OnComplete();
500 service2.OnError(message);
501 EXPECT_EQ(message, "message");
502 }
503
504 HWTEST_F(InnerApiCollectorTest, SecurityEventQueryCallbackTest001, testing::ext::TestSize.Level1)
505 {
506 MockSecurityEventQueryCallbackStub stub;
507 MessageParcel data;
508 MessageParcel reply;
509 MessageOption option;
510 int32_t ret = stub.OnRemoteRequest(0, data, reply, option);
511 EXPECT_EQ(ret, SecurityGuard::NO_PERMISSION);
512 data.WriteInterfaceToken(SecurityEventQueryCallbackStub::GetDescriptor());
513 ret = stub.OnRemoteRequest(0, data, reply, option);
514 EXPECT_FALSE(ret == SecurityGuard::SUCCESS);
515
516 data.WriteInterfaceToken(SecurityEventQueryCallbackStub::GetDescriptor());
517 ret = stub.OnRemoteRequest(SecurityEventQueryCallbackStub::CMD_ON_QUERY, data, reply, option);
518 EXPECT_EQ(ret, SecurityGuard::BAD_PARAM);
519
520 data.WriteInterfaceToken(SecurityEventQueryCallbackStub::GetDescriptor());
521 data.WriteUint32(1);
522 ret = stub.OnRemoteRequest(SecurityEventQueryCallbackStub::CMD_ON_QUERY, data, reply, option);
523 EXPECT_EQ(ret, SecurityGuard::BAD_PARAM);
524
525 data.WriteInterfaceToken(SecurityEventQueryCallbackStub::GetDescriptor());
526 data.WriteUint32(MAX_QUERY_EVENT_SIZE + 1);
527 ret = stub.OnRemoteRequest(SecurityEventQueryCallbackStub::CMD_ON_QUERY, data, reply, option);
528 EXPECT_EQ(ret, SecurityGuard::BAD_PARAM);
529
530 data.WriteInterfaceToken(SecurityEventQueryCallbackStub::GetDescriptor());
531 ret = stub.OnRemoteRequest(SecurityEventQueryCallbackStub::CMD_ON_COMPLETE, data, reply, option);
532 EXPECT_EQ(ret, SecurityGuard::SUCCESS);
533
534 data.WriteInterfaceToken(SecurityEventQueryCallbackStub::GetDescriptor());
535 stub.OnRemoteRequest(SecurityEventQueryCallbackStub::CMD_ON_ERROR, data, reply, option);
536 EXPECT_EQ(ret, SecurityGuard::SUCCESS);
537 }
538
539 }