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 "UTTest_ipc_cmd_register.h" 17 18#include <unistd.h> 19 20#include "device_manager_ipc_interface_code.h" 21#include "ipc_client_manager.h" 22#include "ipc_register_listener_req.h" 23#include "ipc_get_trustdevice_rsp.h" 24#include "ipc_get_info_by_network_rsp.h" 25#include "ipc_get_info_by_network_req.h" 26#include "ipc_get_trustdevice_req.h" 27#include "ipc_start_discovery_req.h" 28#include "ipc_stop_discovery_req.h" 29#include "ipc_publish_req.h" 30#include "ipc_unpublish_req.h" 31#include "ipc_set_useroperation_req.h" 32#include "ipc_unauthenticate_device_req.h" 33#include "ipc_authenticate_device_req.h" 34#include "ipc_get_local_device_info_rsp.h" 35#include "ipc_set_credential_req.h" 36#include "ipc_set_credential_rsp.h" 37#include "ipc_notify_event_req.h" 38#include "device_manager_notify.h" 39#include "ipc_req.h" 40#include "dm_device_info.h" 41#include "dm_constants.h" 42 43namespace OHOS { 44namespace DistributedHardware { 45void IpcCmdRegisterTest::SetUp() 46{ 47} 48 49void IpcCmdRegisterTest::TearDown() 50{ 51} 52 53void IpcCmdRegisterTest::SetUpTestCase() 54{ 55} 56 57void IpcCmdRegisterTest::TearDownTestCase() 58{ 59} 60 61namespace { 62/** 63 * @tc.name: SetRequest_001 64 * @tc.desc: 1. set cmdCode not null 65 * set MessageParcel data null 66 * set IpcReq null 67 * 2. call IpcCmdRegister OnRemoteRequest with parameter 68 * 3. check ret is ERR_DM_UNSUPPORTED_IPC_COMMAND 69 * @tc.type: FUNC 70 * @tc.require: AR000GHSJK 71 */ 72HWTEST_F(IpcCmdRegisterTest, SetRequest_001, testing::ext::TestSize.Level0) 73{ 74 // 1. set cmdCode not null 75 int32_t cmdCode = 999; 76 // set MessageParcel data null 77 MessageParcel data; 78 // set IpcReq null 79 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>(); 80 // 2. call IpcCmdRegister OnRemoteRequest with parameter 81 int ret = 0; 82 ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 83 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 84 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND); 85} 86 87/** 88 * @tc.name: SetRequest_002 89 * @tc.desc: 1. set cmdCode not null 90 * set MessageParcel data null 91 * set IpcRegisterListenerReq null 92 * 2. call IpcCmdRegister OnRemoteRequest with parameter 93 * 3. check ret is ERR_DM_IPC_WRITE_FAILED 94 * @tc.type: FUNC 95 * @tc.require: AR000GHSJK 96 */ 97HWTEST_F(IpcCmdRegisterTest, SetRequest_002, testing::ext::TestSize.Level0) 98{ 99 // 1. set cmdCode not null 100 int32_t cmdCode = REGISTER_DEVICE_MANAGER_LISTENER; 101 // set MessageParcel data null 102 MessageParcel data; 103 // set IpcRegisterListenerReq null 104 std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>(); 105 // 2. call IpcCmdRegister OnRemoteRequest with parameter 106 int ret = 0; 107 ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 108 // 3. check ret is ERR_DM_IPC_WRITE_FAILED 109 ASSERT_EQ(ret, ERR_DM_IPC_WRITE_FAILED); 110} 111 112/** 113 * @tc.name: SetRequest_003 114 * @tc.desc: 1. set cmdCode not null 115 * set MessageParcel data null 116 * set IpcRegisterListenerReq with pkgName not null 117 * 2. call IpcCmdRegister OnRemoteRequest with parameter 118 * 3. check ret is ERR_DM_IPC_WRITE_FAILED 119 * @tc.type: FUNC 120 * @tc.require: AR000GHSJK 121 */ 122HWTEST_F(IpcCmdRegisterTest, SetRequest_003, testing::ext::TestSize.Level0) 123{ 124 // 1. set cmdCode not null 125 int32_t cmdCode = REGISTER_DEVICE_MANAGER_LISTENER; 126 // set MessageParcel data null 127 MessageParcel data; 128 // set IpcRegisterListenerReq null 129 std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>(); 130 std::string pkgName = "com.ohos.test"; 131 req->SetPkgName(pkgName); 132 // 2. call IpcCmdRegister OnRemoteRequest with parameter 133 int ret = 0; 134 ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 135 // 3. check ret is ERR_DM_IPC_WRITE_FAILED 136 ASSERT_EQ(ret, ERR_DM_IPC_WRITE_FAILED); 137} 138 139/** 140 * @tc.name: SetRequest_004 141 * @tc.desc: 1. set cmdCode not null 142 * set MessageParcel data null 143 * set IpcRegisterListenerReq with listener 144 * 2. call IpcCmdRegister OnRemoteRequest with parameter 145 * 3. check ret is ERR_DM_IPC_WRITE_FAILED 146 * @tc.type: FUNC 147 * @tc.require: AR000GHSJK 148 */ 149HWTEST_F(IpcCmdRegisterTest, SetRequest_004, testing::ext::TestSize.Level0) 150{ 151 // 1. set cmdCode not null 152 int32_t cmdCode = REGISTER_DEVICE_MANAGER_LISTENER; 153 // set MessageParcel data null 154 MessageParcel data; 155 // set IpcRegisterListenerReq null 156 std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>(); 157 sptr<IRemoteObject> listener = nullptr; 158 std::string pkgName = ""; 159 req->SetPkgName(pkgName); 160 req->SetListener(listener); 161 // 2. call IpcCmdRegister OnRemoteRequest with parameter 162 int ret = 0; 163 ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 164 // 3. check ret is ERR_DM_IPC_WRITE_FAILED 165 ASSERT_EQ(ret, ERR_DM_IPC_WRITE_FAILED); 166} 167 168/** 169 * @tc.name: SetRequest_005 170 * @tc.desc: 1. set cmdCode not null 171 * set MessageParcel data null 172 * set IpcRegisterListenerReq with listener 173 * 2. call IpcCmdRegister OnRemoteRequest with parameter 174 * 3. check ret is ERR_DM_IPC_WRITE_FAILED 175 * @tc.type: FUNC 176 * @tc.require: AR000GHSJK 177 */ 178HWTEST_F(IpcCmdRegisterTest, SetRequest_005, testing::ext::TestSize.Level0) 179{ 180 // 1. set cmdCode not null 181 int32_t cmdCode = REGISTER_DEVICE_MANAGER_LISTENER; 182 // set MessageParcel data null 183 MessageParcel data; 184 // set IpcRegisterListenerReq null 185 std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>(); 186 sptr<IRemoteObject> listener = nullptr; 187 std::string pkgName = "listen not null"; 188 req->SetPkgName(pkgName); 189 req->SetListener(listener); 190 // 2. call IpcCmdRegister OnRemoteRequest with parameter 191 int ret = 0; 192 ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 193 // 3. check ret is ERR_DM_IPC_WRITE_FAILED 194 ASSERT_EQ(ret, ERR_DM_IPC_WRITE_FAILED); 195} 196 197/** 198 * @tc.name: SetRequest_006 199 * @tc.type: FUNC 200 * @tc.require: AR000GHSJK 201 */ 202HWTEST_F(IpcCmdRegisterTest, SetRequest_006, testing::ext::TestSize.Level0) 203{ 204 int32_t cmdCode = UNREGISTER_DEVICE_MANAGER_LISTENER; 205 MessageParcel data; 206 std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>(); 207 std::string pkgName = "ohos.test"; 208 req->SetPkgName(pkgName); 209 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 210 ASSERT_EQ(ret, DM_OK); 211} 212 213/** 214 * @tc.name: SetRequest_007 215 * @tc.type: FUNC 216 * @tc.require: AR000GHSJK 217 */ 218HWTEST_F(IpcCmdRegisterTest, SetRequest_007, testing::ext::TestSize.Level0) 219{ 220 int32_t cmdCode = GET_TRUST_DEVICE_LIST; 221 MessageParcel data; 222 std::shared_ptr<IpcGetTrustDeviceReq> req = std::make_shared<IpcGetTrustDeviceReq>(); 223 std::string pkgName = "ohos.test"; 224 std::string extra; 225 req->SetPkgName(pkgName); 226 req->SetExtra(extra); 227 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 228 ASSERT_EQ(ret, DM_OK); 229} 230 231/** 232 * @tc.name: SetRequest_008 233 * @tc.type: FUNC 234 * @tc.require: AR000GHSJK 235 */ 236HWTEST_F(IpcCmdRegisterTest, SetRequest_008, testing::ext::TestSize.Level0) 237{ 238 int32_t cmdCode = GET_LOCAL_DEVICE_INFO; 239 MessageParcel data; 240 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>(); 241 std::string pkgName = "ohos.test"; 242 req->SetPkgName(pkgName); 243 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 244 ASSERT_EQ(ret, DM_OK); 245} 246 247/** 248 * @tc.name: SetRequest_009 249 * @tc.type: FUNC 250 * @tc.require: AR000GHSJK 251 */ 252HWTEST_F(IpcCmdRegisterTest, SetRequest_09, testing::ext::TestSize.Level0) 253{ 254 int32_t cmdCode = GET_UDID_BY_NETWORK; 255 MessageParcel data; 256 std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>(); 257 std::string pkgName = "ohos.test"; 258 std::string netWorkId = "123"; 259 req->SetPkgName(pkgName); 260 req->SetNetWorkId(netWorkId); 261 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 262 ASSERT_EQ(ret, DM_OK); 263} 264 265/** 266 * @tc.name: SetRequest_010 267 * @tc.type: FUNC 268 * @tc.require: AR000GHSJK 269 */ 270HWTEST_F(IpcCmdRegisterTest, SetRequest_010, testing::ext::TestSize.Level0) 271{ 272 int32_t cmdCode = GET_UUID_BY_NETWORK; 273 MessageParcel data; 274 std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>(); 275 std::string pkgName = "ohos.test"; 276 std::string netWorkId = "1234"; 277 req->SetPkgName(pkgName); 278 req->SetNetWorkId(netWorkId); 279 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 280 ASSERT_EQ(ret, DM_OK); 281} 282 283/** 284 * @tc.name: SetRequest_011 285 * @tc.type: FUNC 286 * @tc.require: AR000GHSJK 287 */ 288HWTEST_F(IpcCmdRegisterTest, SetRequest_011, testing::ext::TestSize.Level0) 289{ 290 int32_t cmdCode = START_DEVICE_DISCOVER; 291 MessageParcel data; 292 std::shared_ptr<IpcStartDiscoveryReq> req = std::make_shared<IpcStartDiscoveryReq>(); 293 std::string pkgName = "ohos.test"; 294 std::string extra = "1234"; 295 DmSubscribeInfo dmSubscribeInfo; 296 req->SetPkgName(pkgName); 297 req->SetExtra(extra); 298 req->SetSubscribeInfo(dmSubscribeInfo); 299 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 300 ASSERT_EQ(ret, DM_OK); 301} 302 303/** 304 * @tc.name: SetRequest_012 305 * @tc.type: FUNC 306 * @tc.require: AR000GHSJK 307 */ 308HWTEST_F(IpcCmdRegisterTest, SetRequest_012, testing::ext::TestSize.Level0) 309{ 310 int32_t cmdCode = STOP_DEVICE_DISCOVER; 311 MessageParcel data; 312 std::shared_ptr<IpcStopDiscoveryReq> req = std::make_shared<IpcStopDiscoveryReq>(); 313 std::string pkgName = "ohos.test"; 314 uint16_t subscribeId = 12; 315 req->SetPkgName(pkgName); 316 req->SetSubscribeId(subscribeId); 317 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 318 ASSERT_EQ(ret, DM_OK); 319} 320 321/** 322 * @tc.name: SetRequest_013 323 * @tc.type: FUNC 324 * @tc.require: AR000GHSJK 325 */ 326HWTEST_F(IpcCmdRegisterTest, SetRequest_013, testing::ext::TestSize.Level0) 327{ 328 int32_t cmdCode = PUBLISH_DEVICE_DISCOVER; 329 MessageParcel data; 330 std::shared_ptr<IpcPublishReq> req = std::make_shared<IpcPublishReq>(); 331 std::string pkgName = "ohos.test"; 332 DmPublishInfo dmPublishInfo; 333 req->SetPkgName(pkgName); 334 req->SetPublishInfo(dmPublishInfo); 335 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 336 ASSERT_EQ(ret, DM_OK); 337} 338 339/** 340 * @tc.name: SetRequest_014 341 * @tc.type: FUNC 342 * @tc.require: AR000GHSJK 343 */ 344HWTEST_F(IpcCmdRegisterTest, SetRequest_014, testing::ext::TestSize.Level0) 345{ 346 int32_t cmdCode = UNPUBLISH_DEVICE_DISCOVER; 347 MessageParcel data; 348 std::shared_ptr<IpcUnPublishReq> req = std::make_shared<IpcUnPublishReq>(); 349 std::string pkgName = "ohos.test"; 350 int32_t publishId = 1; 351 req->SetPkgName(pkgName); 352 req->SetPublishId(publishId); 353 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 354 ASSERT_EQ(ret, DM_OK); 355} 356 357/** 358 * @tc.name: SetRequest_015 359 * @tc.type: FUNC 360 * @tc.require: AR000GHSJK 361 */ 362HWTEST_F(IpcCmdRegisterTest, SetRequest_015, testing::ext::TestSize.Level0) 363{ 364 int32_t cmdCode = AUTHENTICATE_DEVICE; 365 MessageParcel data; 366 std::shared_ptr<IpcAuthenticateDeviceReq> req = std::make_shared<IpcAuthenticateDeviceReq>(); 367 std::string pkgName = "ohos.test"; 368 std::string extra; 369 int32_t authType = 1; 370 DmDeviceInfo deviceInfo; 371 req->SetPkgName(pkgName); 372 req->SetAuthType(authType); 373 req->SetExtra(extra); 374 req->SetDeviceInfo(deviceInfo); 375 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 376 ASSERT_EQ(ret, DM_OK); 377} 378 379/** 380 * @tc.name: SetRequest_016 381 * @tc.type: FUNC 382 * @tc.require: AR000GHSJK 383 */ 384HWTEST_F(IpcCmdRegisterTest, SetRequest_016, testing::ext::TestSize.Level0) 385{ 386 int32_t cmdCode = NOTIFY_EVENT; 387 MessageParcel data; 388 std::shared_ptr<IpcNotifyEventReq> req = std::make_shared<IpcNotifyEventReq>(); 389 std::string pkgName = "ohos.test"; 390 int32_t eventId = 1; 391 std::string event; 392 req->SetPkgName(pkgName); 393 req->SetEventId(eventId); 394 req->SetEvent(event); 395 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 396 ASSERT_EQ(ret, DM_OK); 397} 398 399/** 400 * @tc.name: SetRequest_019 401 * @tc.type: FUNC 402 * @tc.require: AR000GHSJK 403 */ 404HWTEST_F(IpcCmdRegisterTest, SetRequest_019, testing::ext::TestSize.Level0) 405{ 406 int32_t cmdCode = SERVER_USER_AUTH_OPERATION; 407 MessageParcel data; 408 std::shared_ptr<IpcGetOperationReq> req = std::make_shared<IpcGetOperationReq>(); 409 std::string pkgName = "ohos.test"; 410 req->SetPkgName(pkgName); 411 int32_t action = 1; 412 std::string params; 413 req->SetOperation(action); 414 req->SetParams(params); 415 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 416 ASSERT_EQ(ret, DM_OK); 417} 418 419/** 420 * @tc.name: SetRequest_022 421 * @tc.type: FUNC 422 * @tc.require: AR000GHSJK 423 */ 424HWTEST_F(IpcCmdRegisterTest, SetRequest_022, testing::ext::TestSize.Level0) 425{ 426 int32_t cmdCode = REQUEST_CREDENTIAL; 427 MessageParcel data; 428 std::shared_ptr<IpcSetCredentialReq> req = std::make_shared<IpcSetCredentialReq>(); 429 std::string pkgName = "ohos.test"; 430 std::string requestJsonStr; 431 req->SetPkgName(pkgName); 432 req->SetCredentialParam(requestJsonStr); 433 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 434 ASSERT_EQ(ret, DM_OK); 435} 436 437/** 438 * @tc.name: SetRequest_023 439 * @tc.type: FUNC 440 * @tc.require: AR000GHSJK 441 */ 442HWTEST_F(IpcCmdRegisterTest, SetRequest_023, testing::ext::TestSize.Level0) 443{ 444 int32_t cmdCode = IMPORT_CREDENTIAL; 445 MessageParcel data; 446 std::shared_ptr<IpcSetCredentialReq> req = std::make_shared<IpcSetCredentialReq>(); 447 std::string pkgName = "ohos.test"; 448 std::string credentialInfo; 449 req->SetPkgName(pkgName); 450 req->SetCredentialParam(credentialInfo); 451 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 452 ASSERT_EQ(ret, DM_OK); 453} 454 455/** 456 * @tc.name: SetRequest_024 457 * @tc.type: FUNC 458 * @tc.require: AR000GHSJK 459 */ 460HWTEST_F(IpcCmdRegisterTest, SetRequest_024, testing::ext::TestSize.Level0) 461{ 462 int32_t cmdCode = DELETE_CREDENTIAL; 463 MessageParcel data; 464 std::shared_ptr<IpcSetCredentialReq> req = std::make_shared<IpcSetCredentialReq>(); 465 std::string pkgName = "ohos.test"; 466 std::string deleteInfo; 467 req->SetPkgName(pkgName); 468 req->SetCredentialParam(deleteInfo); 469 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 470 ASSERT_EQ(ret, DM_OK); 471} 472 473/** 474 * @tc.name: SetRequest_025 475 * @tc.type: FUNC 476 * @tc.require: AR000GHSJK 477 */ 478HWTEST_F(IpcCmdRegisterTest, SetRequest_025, testing::ext::TestSize.Level0) 479{ 480 int32_t cmdCode = REGISTER_CREDENTIAL_CALLBACK; 481 MessageParcel data; 482 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>(); 483 std::string pkgName = "ohos.test"; 484 req->SetPkgName(pkgName); 485 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 486 ASSERT_EQ(ret, DM_OK); 487} 488 489/** 490 * @tc.name: SetRequest_026 491 * @tc.type: FUNC 492 * @tc.require: AR000GHSJK 493 */ 494HWTEST_F(IpcCmdRegisterTest, SetRequest_026, testing::ext::TestSize.Level0) 495{ 496 int32_t cmdCode = UNREGISTER_CREDENTIAL_CALLBACK; 497 MessageParcel data; 498 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>(); 499 std::string pkgName = "ohos.test"; 500 req->SetPkgName(pkgName); 501 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data); 502 ASSERT_EQ(ret, DM_OK); 503} 504 505/** 506 * @tc.name: ReadResponse_001 507 * @tc.desc: 1. set cmdCode 9999 508 * set MessageParcel reply null 509 * 2. call IpcCmdRegister ReadResponse with parameter 510 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 511 * @tc.type: FUNC 512 * @tc.require: AR000GHSJK 513 */ 514HWTEST_F(IpcCmdRegisterTest, ReadResponse_001, testing::ext::TestSize.Level0) 515{ 516 // 1. set cmdCode not null 517 int32_t cmdCode = 9999; 518 // set MessageParcel data null 519 MessageParcel reply; 520 // set IpcRegisterListenerReq null 521 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 522 // 2. call IpcCmdRegister ReadResponse with parameter 523 int ret = 0; 524 ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 525 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 526 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND); 527} 528 529/** 530 * @tc.name: ReadResponse_002 531 * @tc.desc: 1. set cmdCode REGISTER_DEVICE_MANAGER_LISTENER 532 * set MessageParcel reply null 533 * set IpcRsp null 534 * 2. call IpcCmdRegister ReadResponse with parameter 535 * 3. check ret is DM_OK 536 * @tc.type: FUNC 537 * @tc.require: AR000GHSJK 538 */ 539HWTEST_F(IpcCmdRegisterTest, ReadResponse_002, testing::ext::TestSize.Level0) 540{ 541 // 1. set cmdCode not null 542 int32_t cmdCode = REGISTER_DEVICE_MANAGER_LISTENER; 543 // set MessageParcel data null 544 MessageParcel reply; 545 // set IpcRegisterListenerReq null 546 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 547 // 2. call IpcCmdRegister OnRemoteRequest with parameter 548 int ret = 0; 549 ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 550 // 3. check ret is DM_OK 551 ASSERT_EQ(ret, DM_OK); 552} 553 554/** 555 * @tc.name: ReadResponse_003 556 * @tc.desc: 1. set cmdCode UNREGISTER_DEVICE_MANAGER_LISTENER 557 * set MessageParcel reply null 558 * set IpcRsp null 559 * 2. call IpcCmdRegister ReadResponse with parameter 560 * 3. check ret is DM_OK 561 * @tc.type: FUNC 562 * @tc.require: AR000GHSJK 563 */ 564HWTEST_F(IpcCmdRegisterTest, ReadResponse_003, testing::ext::TestSize.Level0) 565{ 566 // 1. set cmdCode not null 567 int32_t cmdCode = UNREGISTER_DEVICE_MANAGER_LISTENER; 568 // set MessageParcel data null 569 MessageParcel reply; 570 // set IpcRegisterListenerReq null 571 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 572 // 2. call IpcCmdRegister OnRemoteRequest with parameter 573 int ret = 0; 574 ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 575 // 3. check ret is DM_OK 576 ASSERT_EQ(ret, DM_OK); 577} 578 579/** 580 * @tc.name: ReadResponse_004 581 * @tc.desc: 1. set cmdCode GET_TRUST_DEVICE_LIST 582 * set MessageParcel reply null 583 * set IpcRsp null 584 * 2. call IpcCmdRegister ReadResponse with parameter 585 * 3. check ret is DM_OK 586 * @tc.type: FUNC 587 * @tc.require: AR000GHSJK 588 */ 589HWTEST_F(IpcCmdRegisterTest, ReadResponse_004, testing::ext::TestSize.Level0) 590{ 591 // 1. set cmdCode not null 592 int32_t cmdCode = GET_TRUST_DEVICE_LIST; 593 // set MessageParcel data null 594 MessageParcel reply; 595 // set IpcRegisterListenerReq null 596 std::shared_ptr<IpcGetTrustDeviceRsp> rsp = std::make_shared<IpcGetTrustDeviceRsp>(); 597 // 2. call IpcCmdRegister OnRemoteRequest with parameter 598 int ret = 0; 599 ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 600 // 3. check ret is DM_OK 601 ASSERT_EQ(ret, DM_OK); 602} 603 604/** 605 * @tc.name: ReadResponse_006 606 * @tc.type: FUNC 607 * @tc.require: AR000GHSJK 608 */ 609HWTEST_F(IpcCmdRegisterTest, ReadResponse_006, testing::ext::TestSize.Level0) 610{ 611 int32_t cmdCode = GET_LOCAL_DEVICE_INFO; 612 MessageParcel reply; 613 std::shared_ptr<IpcGetLocalDeviceInfoRsp> rsp = std::make_shared<IpcGetLocalDeviceInfoRsp>(); 614 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 615 ASSERT_EQ(ret, DM_OK); 616} 617 618/** 619 * @tc.name: ReadResponse_007 620 * @tc.type: FUNC 621 * @tc.require: AR000GHSJK 622 */ 623HWTEST_F(IpcCmdRegisterTest, ReadResponse_007, testing::ext::TestSize.Level0) 624{ 625 int32_t cmdCode = GET_UDID_BY_NETWORK; 626 MessageParcel reply; 627 std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>(); 628 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 629 ASSERT_EQ(ret, DM_OK); 630} 631 632/** 633 * @tc.name: ReadResponse_008 634 * @tc.type: FUNC 635 * @tc.require: AR000GHSJK 636 */ 637HWTEST_F(IpcCmdRegisterTest, ReadResponse_008, testing::ext::TestSize.Level0) 638{ 639 int32_t cmdCode = GET_UUID_BY_NETWORK; 640 MessageParcel reply; 641 std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>(); 642 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 643 ASSERT_EQ(ret, DM_OK); 644} 645 646/** 647 * @tc.name: ReadResponse_009 648 * @tc.type: FUNC 649 * @tc.require: AR000GHSJK 650 */ 651HWTEST_F(IpcCmdRegisterTest, ReadResponse_009, testing::ext::TestSize.Level0) 652{ 653 int32_t cmdCode = START_DEVICE_DISCOVER; 654 MessageParcel reply; 655 std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>(); 656 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 657 ASSERT_EQ(ret, DM_OK); 658} 659 660/** 661 * @tc.name: ReadResponse_010 662 * @tc.type: FUNC 663 * @tc.require: AR000GHSJK 664 */ 665HWTEST_F(IpcCmdRegisterTest, ReadResponse_010, testing::ext::TestSize.Level0) 666{ 667 int32_t cmdCode = STOP_DEVICE_DISCOVER; 668 MessageParcel reply; 669 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 670 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 671 ASSERT_EQ(ret, DM_OK); 672} 673 674/** 675 * @tc.name: ReadResponse_011 676 * @tc.type: FUNC 677 * @tc.require: AR000GHSJK 678 */ 679HWTEST_F(IpcCmdRegisterTest, ReadResponse_011, testing::ext::TestSize.Level0) 680{ 681 int32_t cmdCode = PUBLISH_DEVICE_DISCOVER; 682 MessageParcel reply; 683 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 684 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 685 ASSERT_EQ(ret, DM_OK); 686} 687 688/** 689 * @tc.name: ReadResponse_012 690 * @tc.type: FUNC 691 * @tc.require: AR000GHSJK 692 */ 693HWTEST_F(IpcCmdRegisterTest, ReadResponse_012, testing::ext::TestSize.Level0) 694{ 695 int32_t cmdCode = UNPUBLISH_DEVICE_DISCOVER; 696 MessageParcel reply; 697 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 698 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 699 ASSERT_EQ(ret, DM_OK); 700} 701 702/** 703 * @tc.name: ReadResponse_013 704 * @tc.type: FUNC 705 * @tc.require: AR000GHSJK 706 */ 707HWTEST_F(IpcCmdRegisterTest, ReadResponse_013, testing::ext::TestSize.Level0) 708{ 709 int32_t cmdCode = AUTHENTICATE_DEVICE; 710 MessageParcel reply; 711 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 712 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 713 ASSERT_EQ(ret, DM_OK); 714} 715 716/** 717 * @tc.name: ReadResponse_014 718 * @tc.type: FUNC 719 * @tc.require: AR000GHSJK 720 */ 721HWTEST_F(IpcCmdRegisterTest, ReadResponse_014, testing::ext::TestSize.Level0) 722{ 723 int32_t cmdCode = UNAUTHENTICATE_DEVICE; 724 MessageParcel reply; 725 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 726 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 727 ASSERT_EQ(ret, DM_OK); 728} 729 730/** 731 * @tc.name: ReadResponse_016 732 * @tc.type: FUNC 733 * @tc.require: AR000GHSJK 734 */ 735HWTEST_F(IpcCmdRegisterTest, ReadResponse_016, testing::ext::TestSize.Level0) 736{ 737 int32_t cmdCode = NOTIFY_EVENT; 738 MessageParcel reply; 739 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 740 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 741 ASSERT_EQ(ret, DM_OK); 742} 743 744/** 745 * @tc.name: ReadResponse_017 746 * @tc.type: FUNC 747 * @tc.require: AR000GHSJK 748 */ 749HWTEST_F(IpcCmdRegisterTest, ReadResponse_017, testing::ext::TestSize.Level0) 750{ 751 int32_t cmdCode = SERVER_USER_AUTH_OPERATION; 752 MessageParcel reply; 753 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 754 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 755 ASSERT_EQ(ret, DM_OK); 756} 757 758/** 759 * @tc.name: ReadResponse_020 760 * @tc.type: FUNC 761 * @tc.require: AR000GHSJK 762 */ 763HWTEST_F(IpcCmdRegisterTest, ReadResponse_020, testing::ext::TestSize.Level0) 764{ 765 int32_t cmdCode = UNREGISTER_CREDENTIAL_CALLBACK; 766 MessageParcel reply; 767 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 768 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 769 ASSERT_EQ(ret, DM_OK); 770} 771 772/** 773 * @tc.name: ReadResponse_021 774 * @tc.type: FUNC 775 * @tc.require: AR000GHSJK 776 */ 777HWTEST_F(IpcCmdRegisterTest, ReadResponse_021, testing::ext::TestSize.Level0) 778{ 779 int32_t cmdCode = IMPORT_CREDENTIAL; 780 MessageParcel reply; 781 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 782 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 783 ASSERT_EQ(ret, DM_OK); 784} 785 786/** 787 * @tc.name: ReadResponse_022 788 * @tc.type: FUNC 789 * @tc.require: AR000GHSJK 790 */ 791HWTEST_F(IpcCmdRegisterTest, ReadResponse_022, testing::ext::TestSize.Level0) 792{ 793 int32_t cmdCode = DELETE_CREDENTIAL; 794 MessageParcel reply; 795 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 796 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 797 ASSERT_EQ(ret, DM_OK); 798} 799 800/** 801 * @tc.name: ReadResponse_023 802 * @tc.type: FUNC 803 * @tc.require: AR000GHSJK 804 */ 805HWTEST_F(IpcCmdRegisterTest, ReadResponse_023, testing::ext::TestSize.Level0) 806{ 807 int32_t cmdCode = REGISTER_CREDENTIAL_CALLBACK; 808 MessageParcel reply; 809 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 810 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); 811 ASSERT_EQ(ret, DM_OK); 812} 813 814/** 815 * @tc.name: OnIpcCmd_001 816 * @tc.desc: 1. set cmdCode 9999 817 * set MessageParcel reply null 818 * 2. call IpcCmdRegister OnIpcCmd with parameter 819 * 3. check ret is DEVICEMANAGER_IPC_NOT_REGISTER_FUNC 820 * @tc.type: FUNC 821 * @tc.require: AR000GHSJK 822 */ 823HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_001, testing::ext::TestSize.Level0) 824{ 825 // 1. set cmdCode not null 826 int32_t cmdCode = 9999; 827 // set MessageParcel data null 828 MessageParcel reply; 829 MessageParcel data; 830 // set IpcRegisterListenerReq null 831 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>(); 832 // 2. call IpcCmdRegister ReadResponse with parameter 833 int ret = 0; 834 ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply); 835 // 3. check ret is ERR_DM_UNSUPPORTED_IPC_COMMAND 836 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND); 837} 838 839/** 840 * @tc.name: OnIpcCmd_002 841 * @tc.desc: 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY 842 * 2. data.WriteString(pkgname) 843 * data.WriteInt32(DEVICE_STATE_ONLINE) 844 * data.WriteRawData(&dmDeviceInfo, deviceSize) 845 * 3. call IpcCmdRegister OnIpcCmd with parameter 846 * 4. check ret is DM_OK 847 * check result is DM_OK 848 * @tc.type: FUNC 849 * @tc.require: AR000GHSJK 850 */ 851HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_002, testing::ext::TestSize.Level0) 852{ 853 // 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY 854 int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY; 855 MessageParcel reply; 856 MessageParcel data; 857 // 2. data.WriteString(pkgname) 858 data.WriteString("com.ohos.test"); 859 // data.WriteInt32(DEVICE_STATE_ONLINE) 860 data.WriteInt32(DEVICE_STATE_ONLINE); 861 DmDeviceInfo dmDeviceInfo; 862 size_t deviceSize = sizeof(DmDeviceInfo); 863 // data.WriteRawData(&dmDeviceInfo, deviceSize) 864 data.WriteRawData(&dmDeviceInfo, deviceSize); 865 // 3. call IpcCmdRegister OnIpcCmd with parameter 866 int ret = 0; 867 ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply); 868 // check ret is DEVICEMANAGER_IPC_NOT_REGISTER_FUNC 869 ASSERT_EQ(ret, DM_OK); 870} 871 872/** 873 * @tc.name: OnIpcCmd_003 874 * @tc.desc: 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY 875 * 2. data.WriteString(pkgname) 876 * data.WriteInt32(DEVICE_STATE_ONLINE) 877 * data.WriteRawData(nullptr, deviceSize) 878 * 3. call IpcCmdRegister OnIpcCmd with parameter 879 * 4. check ret is DEVICEMANAGER_OK 880 * check result is DEVICE_STATE_ONLINE 881 * @tc.type: FUNC 882 * @tc.require: AR000GHSJK 883 */ 884HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_003, testing::ext::TestSize.Level0) 885{ 886 // 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY 887 int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY; 888 MessageParcel reply; 889 MessageParcel data; 890 // 2. data.WriteString(pkgname) 891 data.WriteString("com.ohos.test"); 892 // data.WriteInt32(DEVICE_STATE_ONLINE) 893 data.WriteInt32(DEVICE_STATE_ONLINE); 894 // data.WriteRawData(nullptr, deviceSize) 895 size_t deviceSize = sizeof(DmDeviceInfo); 896 data.WriteRawData(nullptr, deviceSize); 897 // 3. call IpcCmdRegister OnIpcCmd with parameter 898 int ret = 0; 899 int32_t result = 0; 900 ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply); 901 result = reply.ReadInt32(); 902 // 4. check result is DEVICE_STATE_ONLINE 903 ASSERT_EQ(result, DEVICE_STATE_ONLINE); 904 // check ret is DM_OK 905 ASSERT_EQ(ret, DM_OK); 906} 907 908/** 909 * @tc.name: OnIpcCmd_004 910 * @tc.desc: 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY 911 * 2. data.WriteString(pkgname) 912 * data.WriteInt32(DEVICE_STATE_OFFLINE) 913 * data.WriteRawData(nullptr, deviceSize) 914 * 3. call IpcCmdRegister OnIpcCmd with parameter 915 * 4. check ret is DM_OK 916 * @tc.type: FUNC 917 * @tc.require: AR000GHSJK 918 */ 919HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_004, testing::ext::TestSize.Level0) 920{ 921 // 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY 922 int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY; 923 MessageParcel reply; 924 MessageParcel data; 925 // 2. data.WriteString(pkgname) 926 data.WriteString("com.ohos.test"); 927 // data.WriteInt32(DEVICE_STATE_OFFLINE) 928 data.WriteInt32(DEVICE_STATE_OFFLINE); 929 size_t deviceSize = sizeof(DmDeviceInfo); 930 // data.WriteRawData(nullptr, deviceSize) 931 data.WriteRawData(nullptr, deviceSize); 932 // 3. call IpcCmdRegister OnIpcCmd with parameter 933 int ret = 0; 934 ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply); 935 // check ret is DM_OK 936 ASSERT_EQ(ret, DM_OK); 937} 938 939/** 940 * @tc.name: OnIpcCmd_005 941 * @tc.desc: 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY 942 * 2. data.WriteString(pkgname) 943 * data.WriteInt32(DEVICE_INFO_CHANGED) 944 * data.WriteRawData(nullptr, deviceSize) 945 * 3. call IpcCmdRegister OnIpcCmd with parameter 946 * 4. check ret is DM_OK 947 * @tc.type: FUNC 948 * @tc.require: AR000GHSJK 949 */ 950HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_005, testing::ext::TestSize.Level0) 951{ 952 // 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY 953 int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY; 954 MessageParcel reply; 955 MessageParcel data; 956 // 2. data.WriteString(pkgname) 957 data.WriteString("com.ohos.test"); 958 // data.WriteInt32(DEVICE_INFO_CHANGED) 959 data.WriteInt32(DEVICE_INFO_CHANGED); 960 size_t deviceSize = sizeof(DmDeviceInfo); 961 // data.WriteRawData(nullptr, deviceSize) 962 data.WriteRawData(nullptr, deviceSize); 963 // 3. call IpcCmdRegister OnIpcCmd with parameter 964 int ret = 0; 965 ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply); 966 // 4.check ret is DM_OK 967 ASSERT_EQ(ret, DM_OK); 968} 969 970/** 971 * @tc.name: OnIpcCmd_006 972 * @tc.type: FUNC 973 * @tc.require: AR000GHSJK 974 */ 975HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_006, testing::ext::TestSize.Level0) 976{ 977 int32_t cmdCode = SERVER_DEVICE_FOUND; 978 MessageParcel reply; 979 MessageParcel data; 980 uint16_t subscribeId = 1; 981 DmDeviceInfo deviceInfo; 982 data.WriteString("com.ohos.test"); 983 data.WriteInt16(subscribeId); 984 size_t deviceSize = sizeof(DmDeviceInfo); 985 data.WriteRawData(&deviceInfo, deviceSize); 986 int ret = 0; 987 ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply); 988 ASSERT_EQ(ret, DM_OK); 989} 990 991/** 992 * @tc.name: OnIpcCmd_007 993 * @tc.type: FUNC 994 */ 995HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_007, testing::ext::TestSize.Level0) 996{ 997 int32_t cmdCode = -1; 998 MessageParcel reply; 999 MessageParcel data; 1000 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply); 1001 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND); 1002} 1003 1004/** 1005 * @tc.name: OnIpcCmd_008 1006 * @tc.type: FUNC 1007 */ 1008HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_008, testing::ext::TestSize.Level0) 1009{ 1010 int32_t cmdCode = IPC_MSG_BUTT; 1011 MessageParcel reply; 1012 MessageParcel data; 1013 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply); 1014 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND); 1015} 1016 1017/** 1018 * @tc.name: OnIpcCmd_009 1019 * @tc.type: FUNC 1020 * @tc.require: AR000GHSJK 1021 */ 1022HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_009, testing::ext::TestSize.Level0) 1023{ 1024 int32_t cmdCode = SERVER_DISCOVER_FINISH; 1025 MessageParcel reply; 1026 MessageParcel data; 1027 uint16_t subscribeId = 1; 1028 int32_t failedReason = 0; 1029 data.WriteString("com.ohos.test"); 1030 data.WriteInt16(subscribeId); 1031 data.WriteInt32(failedReason); 1032 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply); 1033 ASSERT_EQ(ret, DM_OK); 1034} 1035 1036/** 1037 * @tc.name: OnIpcCmd_010 1038 * @tc.type: FUNC 1039 * @tc.require: AR000GHSJK 1040 */ 1041HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_010, testing::ext::TestSize.Level0) 1042{ 1043 int32_t cmdCode = SERVER_PUBLISH_FINISH; 1044 MessageParcel reply; 1045 MessageParcel data; 1046 int32_t publishId = 1; 1047 int32_t publishResult = 0; 1048 data.WriteString("com.ohos.test"); 1049 data.WriteInt32(publishId); 1050 data.WriteInt32(publishResult); 1051 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply); 1052 ASSERT_EQ(ret, DM_OK); 1053} 1054 1055/** 1056 * @tc.name: OnIpcCmd_011 1057 * @tc.type: FUNC 1058 * @tc.require: AR000GHSJK 1059 */ 1060HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_011, testing::ext::TestSize.Level0) 1061{ 1062 int32_t cmdCode = SERVER_AUTH_RESULT; 1063 MessageParcel reply; 1064 MessageParcel data; 1065 std::string pkgName = "ohos.test"; 1066 std::string deviceId = "123"; 1067 std::string token = "123456"; 1068 int32_t status = 1; 1069 int32_t reason = 0; 1070 data.WriteString(pkgName); 1071 data.WriteString(deviceId); 1072 data.WriteString(token); 1073 data.WriteInt32(status); 1074 data.WriteInt32(reason); 1075 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply); 1076 ASSERT_EQ(ret, DM_OK); 1077} 1078 1079/** 1080 * @tc.name: OnIpcCmd_013 1081 * @tc.type: FUNC 1082 * @tc.require: AR000GHSJK 1083 */ 1084HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_013, testing::ext::TestSize.Level0) 1085{ 1086 int32_t cmdCode = SERVER_DEVICE_FA_NOTIFY; 1087 MessageParcel reply; 1088 MessageParcel data; 1089 std::string pkgName = "ohos.test"; 1090 std::string paramJson = "123"; 1091 data.WriteString(pkgName); 1092 data.WriteString(paramJson); 1093 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply); 1094 ASSERT_EQ(ret, DM_OK); 1095} 1096 1097/** 1098 * @tc.name: OnIpcCmd_014 1099 * @tc.type: FUNC 1100 * @tc.require: AR000GHSJK 1101 */ 1102HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_014, testing::ext::TestSize.Level0) 1103{ 1104 int32_t cmdCode = SERVER_CREDENTIAL_RESULT; 1105 MessageParcel reply; 1106 MessageParcel data; 1107 std::string pkgName = "ohos.test"; 1108 std::string credentialResult = "123"; 1109 int32_t action = 0; 1110 data.WriteString(pkgName); 1111 data.WriteInt32(action); 1112 data.WriteString(credentialResult); 1113 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply); 1114 ASSERT_EQ(ret, DM_OK); 1115} 1116} // namespace 1117} // namespace DistributedHardware 1118} // namespace OHOS