diff --git a/services/audiomanager/managersource/src/daudio_source_dev.cpp b/services/audiomanager/managersource/src/daudio_source_dev.cpp index aa89bbf70e8fa61785db99acdb352fee9e0095c0..1d11425558620dd12023e929d9f5017d7d2fc62e 100644 --- a/services/audiomanager/managersource/src/daudio_source_dev.cpp +++ b/services/audiomanager/managersource/src/daudio_source_dev.cpp @@ -244,9 +244,7 @@ int32_t DAudioSourceDev::CloseCtrlTrans(const AudioEvent &event, bool isSpk) if ((!isSpk && (speaker_ == nullptr || !speaker_->IsOpened())) || (isSpk && (mic_ == nullptr || !mic_->IsOpened()))) { DHLOGD("No distributed audio device used, close ctrl trans."); - auto task = GenerateTask(this, &DAudioSourceDev::TaskCloseCtrlChannel, event.content, "Close Ctrl Trans", - &DAudioSourceDev::OnTaskResult); - return taskQueue_->Produce(task); + return HandleCloseCtrlTrans(event); } return DH_SUCCESS; } @@ -271,7 +269,7 @@ int32_t DAudioSourceDev::HandleCloseCtrlTrans(const AudioEvent &event) DHLOGE("Task queue is null."); return ERR_DH_AUDIO_NULLPTR; } - auto task = GenerateTask(this, &DAudioSourceDev::TaskCloseCtrlChannel, "", "Close Ctrl Trans", + auto task = GenerateTask(this, &DAudioSourceDev::TaskCloseCtrlChannel, event.content, "Close Ctrl Trans", &DAudioSourceDev::OnTaskResult); return taskQueue_->Produce(task); } @@ -466,7 +464,7 @@ int32_t DAudioSourceDev::TaskEnableDAudio(const std::string &args) json jParam = json::parse(args, nullptr, false); if (!JsonParamCheck(jParam, { KEY_DH_ID, KEY_ATTRS }) || !CheckIsNum((std::string)jParam[KEY_DH_ID])) { DHLOGE("The keys or values is invalid."); - return ERR_DH_AUDIO_NOT_SUPPORT; + return ERR_DH_AUDIO_SA_ENABLE_PARAM_INVALID; } int32_t dhId = std::stoi((std::string)jParam[KEY_DH_ID]); @@ -475,7 +473,6 @@ int32_t DAudioSourceDev::TaskEnableDAudio(const std::string &args) return EnableDSpeaker(dhId, jParam[KEY_ATTRS]); case AUDIO_DEVICE_TYPE_MIC: return EnableDMic(dhId, jParam[KEY_ATTRS]); - case AUDIO_DEVICE_TYPE_UNKNOWN: default: DHLOGE("Unknown audio device."); return ERR_DH_AUDIO_NOT_SUPPORT; @@ -530,7 +527,7 @@ int32_t DAudioSourceDev::TaskDisableDAudio(const std::string &args) } json jParam = json::parse(args, nullptr, false); if (!JsonParamCheck(jParam, { KEY_DH_ID }) || !CheckIsNum((std::string)jParam[KEY_DH_ID])) { - return ERR_DH_AUDIO_NOT_SUPPORT; + return ERR_DH_AUDIO_SA_DISABLE_PARAM_INVALID; } int32_t dhId = std::stoi((std::string)jParam[KEY_DH_ID]); switch (GetDevTypeByDHId(dhId)) { @@ -538,7 +535,6 @@ int32_t DAudioSourceDev::TaskDisableDAudio(const std::string &args) return DisableDSpeaker(dhId); case AUDIO_DEVICE_TYPE_MIC: return DisableDMic(dhId); - case AUDIO_DEVICE_TYPE_UNKNOWN: default: DHLOGE("Unknown audio device."); return ERR_DH_AUDIO_NOT_SUPPORT; @@ -893,11 +889,8 @@ int32_t DAudioSourceDev::TaskSpkMmapStop(const std::string &args) DHLOGE("Task spk mmap stop, speaker is nullptr."); return ERR_DH_AUDIO_NULLPTR; } - int32_t ret = speaker_->MmapStop(); - if (ret != DH_SUCCESS) { - DHLOGE("Task spk mmap stop fail, error code: %d.", ret); - } - return ret; + speaker_->MmapStop(); + return DH_SUCCESS; } int32_t DAudioSourceDev::TaskMicMmapStart(const std::string &args) @@ -921,11 +914,8 @@ int32_t DAudioSourceDev::TaskMicMmapStop(const std::string &args) DHLOGE("Task mic mmap stop, mic is nullptr."); return ERR_DH_AUDIO_NULLPTR; } - int32_t ret = mic_->MmapStop(); - if (ret != DH_SUCCESS) { - DHLOGE("Task mic mmap stop fail, error code: %d.", ret); - } - return ret; + mic_->MmapStop(); + return DH_SUCCESS; } void DAudioSourceDev::OnTaskResult(int32_t resultCode, const std::string &result, const std::string &funcName) diff --git a/services/audiomanager/managersource/src/dmic_dev.cpp b/services/audiomanager/managersource/src/dmic_dev.cpp index 705496af812f7902214c1443692fae3cb06e992c..484ad1f09fe726b6478c220a0f4f2c633b3411a6 100644 --- a/services/audiomanager/managersource/src/dmic_dev.cpp +++ b/services/audiomanager/managersource/src/dmic_dev.cpp @@ -405,6 +405,7 @@ int32_t DMicDev::MmapStop() if (enqueueDataThread_.joinable()) { enqueueDataThread_.join(); } + DHLOGI("Mic mmap stop end."); return DH_SUCCESS; } diff --git a/services/audiomanager/managersource/src/dspeaker_dev.cpp b/services/audiomanager/managersource/src/dspeaker_dev.cpp index ab05dbc5b4dc0823393b010cca9ff69efeeef437..082f629cde10f86811411c0f66e73319e1789c57 100644 --- a/services/audiomanager/managersource/src/dspeaker_dev.cpp +++ b/services/audiomanager/managersource/src/dspeaker_dev.cpp @@ -401,6 +401,7 @@ int32_t DSpeakerDev::MmapStop() if (enqueueDataThread_.joinable()) { enqueueDataThread_.join(); } + DHLOGI("Spk mmap stop end."); return DH_SUCCESS; } diff --git a/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp b/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp index 3c449e135d101c61e9fd50f86ab44e5827b899d4..d9ccf47d3cbca6e027ac292feb22fdb223b49fda 100644 --- a/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp +++ b/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp @@ -50,6 +50,10 @@ HWTEST_F(DAudioSinkDevTest, NotifyOpenCtrlChannel_001, TestSize.Level1) sinkDev_->taskQueue_ = std::make_shared(capacity); AudioEvent event; EXPECT_EQ(DH_SUCCESS, sinkDev_->NotifyOpenCtrlChannel(event)); + event.type = OPEN_CTRL; + sinkDev_->NotifyEvent(event); + + event.type = EVENT_UNKNOWN; sinkDev_->NotifyEvent(event); } @@ -467,6 +471,8 @@ HWTEST_F(DAudioSinkDevTest, NotifyRenderStateChange_001, TestSize.Level1) */ HWTEST_F(DAudioSinkDevTest, NotifyRenderStateChange_002, TestSize.Level1) { + sinkDev_->SleepAudioDev(); + constexpr size_t capacity = 20; sinkDev_->taskQueue_ = std::make_shared(capacity); AudioEvent event; diff --git a/services/audiomanager/test/unittest/servicesource/src/daudio_source_service_test.cpp b/services/audiomanager/test/unittest/servicesource/src/daudio_source_service_test.cpp index 4b7acc2254ca6b922c554d1ded686154d90b6d11..87b427f5a7ad7c251445f3496e61b35467b5ca80 100644 --- a/services/audiomanager/test/unittest/servicesource/src/daudio_source_service_test.cpp +++ b/services/audiomanager/test/unittest/servicesource/src/daudio_source_service_test.cpp @@ -104,7 +104,7 @@ HWTEST_F(DAudioSourceServiceTest, Dump_001, TestSize.Level1) { int32_t fd = 0; const std::vector args; - EXPECT_EQ(DH_SUCCESS, sourceSrv_->Dump(fd, args)); + sourceSrv_->Dump(fd, args); } } // DistributedHardware } // OHOS diff --git a/services/audiomanager/test/unittest/sourcedevice/BUILD.gn b/services/audiomanager/test/unittest/sourcedevice/BUILD.gn index 87165b5301f4f46c246d6a4288e0409fbf08521b..0307a28c0f74cf98403733a4a7034da8fa3ab8c5 100644 --- a/services/audiomanager/test/unittest/sourcedevice/BUILD.gn +++ b/services/audiomanager/test/unittest/sourcedevice/BUILD.gn @@ -68,6 +68,8 @@ ohos_unittest("DaudioSourceDevTest") { configs = [ ":module_private_config" ] deps = [ + "${audio_transport_path}/decodetransport:distributed_audio_decode_transport", + "${audio_transport_path}/encodetransport:distributed_audio_encode_transport", "${hdf_interfaces_path}/audioext/v1_0:libdaudioext_proxy_1.0", "${services_path}/audiomanager/servicesource:distributed_audio_source", "${services_path}/common:distributed_audio_utils", diff --git a/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp b/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp index f4f800d4bb6cbd32515ba4414aef2c9f294a1432..7b3730efdf8d14bba4434e2028928ea02522efb6 100644 --- a/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp +++ b/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp @@ -14,6 +14,10 @@ */ #include "daudio_source_dev_test.h" + +#include "audio_encode_transport.h" +#include "audio_decode_transport.h" + using namespace testing::ext; namespace OHOS { @@ -26,9 +30,9 @@ const std::string ARGS = "args"; const std::string DH_ID_MIC = "134217728"; const std::string DH_ID_SPK = "1"; const std::string DH_ID_UNKNOWN = "0"; -const int32_t taskQueueLength = 20; -const int32_t ashmemLength = 20; -const size_t capacity = 1; +const int32_t TASK_QUEUE_LEN = 20; +const int32_t ASHMEM_LEN = 20; +const size_t AUDIO_DATA_CAP = 1; const int32_t fd = 1; void DAudioSourceDevTest::SetUpTestCase(void) {} @@ -144,6 +148,24 @@ HWTEST_F(DAudioSourceDevTest, CreatTasks_002, TestSize.Level1) EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->DisableDAudio(DH_ID)); } +/** + * @tc.name: CreatTasks_003 + * @tc.desc: Verify HandleOpenDSpeaker, HandleOpenDMic and HandleOpenCtrlTrans function produce task fail. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSourceDevTest, CreatTasks_003, TestSize.Level1) +{ + size_t tempCapacity = 0; + sourceDev_->taskQueue_ = std::make_shared(tempCapacity); + AudioEvent event = AudioEvent(OPEN_SPEAKER, ""); + EXPECT_EQ(ERR_DH_AUDIO_SA_OPEN_CTRL_FAILED, sourceDev_->HandleOpenDSpeaker(event)); + + event.type = OPEN_MIC; + EXPECT_EQ(ERR_DH_AUDIO_SA_OPEN_CTRL_FAILED, sourceDev_->HandleOpenDMic(event)); + sourceDev_->taskQueue_ = nullptr; +} + /** * @tc.name: NotifyEvent_001 * @tc.desc: Verify NotifyEvent function with VOLUME_SET event, after AwakeAudioDev function. @@ -172,9 +194,9 @@ HWTEST_F(DAudioSourceDevTest, HandlePlayStatusChange_001, TestSize.Level1) AudioEvent event = AudioEvent(CHANGE_PLAY_STATUS, ""); EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandlePlayStatusChange(event)); - sourceDev_->audioCtrlMgr_ = std::make_shared(DEV_ID, sourceDev_); - sourceDev_->taskQueue_ = std::make_shared(taskQueueLength); + sourceDev_->taskQueue_ = std::make_shared(TASK_QUEUE_LEN); EXPECT_EQ(DH_SUCCESS, sourceDev_->HandlePlayStatusChange(event)); + sourceDev_->taskQueue_ = nullptr; } /** @@ -187,6 +209,49 @@ HWTEST_F(DAudioSourceDevTest, WaitForRPC_001, TestSize.Level1) { AudioEventType type = NOTIFY_OPEN_SPEAKER_RESULT; EXPECT_EQ(ERR_DH_AUDIO_SA_RPC_WAIT_TIMEOUT, sourceDev_->WaitForRPC(type)); + + type = CHANGE_PLAY_STATUS; + EXPECT_EQ(ERR_DH_AUDIO_SA_RPC_WAIT_TIMEOUT, sourceDev_->WaitForRPC(type)); + + sourceDev_->rpcResult_ = false; + type = NOTIFY_OPEN_SPEAKER_RESULT; + sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_OPEN_SPK; + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->WaitForRPC(type)); +} + +/** + * @tc.name: WaitForRPC_002 + * @tc.desc: Verify the WaitForRPC function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSourceDevTest, WaitForRPC_002, TestSize.Level1) +{ + sourceDev_->rpcResult_ = true; + + AudioEventType type = NOTIFY_OPEN_SPEAKER_RESULT; + sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_OPEN_SPK; + EXPECT_EQ(DH_SUCCESS, sourceDev_->WaitForRPC(type)); + + type = NOTIFY_CLOSE_SPEAKER_RESULT; + sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_CLOSE_SPK; + EXPECT_EQ(DH_SUCCESS, sourceDev_->WaitForRPC(type)); + + type = NOTIFY_OPEN_MIC_RESULT; + sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_OPEN_MIC; + EXPECT_EQ(DH_SUCCESS, sourceDev_->WaitForRPC(type)); + + type = NOTIFY_CLOSE_MIC_RESULT; + sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_CLOSE_MIC; + EXPECT_EQ(DH_SUCCESS, sourceDev_->WaitForRPC(type)); + + type = NOTIFY_OPEN_CTRL_RESULT; + sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_OPEN_CTRL; + EXPECT_EQ(DH_SUCCESS, sourceDev_->WaitForRPC(type)); + + type = NOTIFY_CLOSE_CTRL_RESULT; + sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_CLOSE_CTRL; + EXPECT_EQ(DH_SUCCESS, sourceDev_->WaitForRPC(type)); } /** @@ -225,11 +290,23 @@ HWTEST_F(DAudioSourceDevTest, OpenCtrlTrans_001, TestSize.Level1) { AudioEvent event; EXPECT_EQ(ERR_DH_AUDIO_SA_OPEN_CTRL_FAILED, sourceDev_->OpenCtrlTrans(event)); + + sourceDev_->audioCtrlMgr_ = std::make_shared(DEV_ID, sourceDev_); + sourceDev_->audioCtrlMgr_->isOpened_ = true; + EXPECT_EQ(DH_SUCCESS, sourceDev_->OpenCtrlTrans(event)); + + sourceDev_->audioCtrlMgr_->isOpened_ = false; + size_t tempCapacity = 0; + sourceDev_->taskQueue_ = std::make_shared(tempCapacity); + EXPECT_EQ(ERR_DH_AUDIO_SA_OPEN_CTRL_FAILED, sourceDev_->OpenCtrlTrans(event)); + sourceDev_->taskQueue_ = nullptr; + + sourceDev_->audioCtrlMgr_ = nullptr; } /** * @tc.name: CloseCtrlTrans_001 - * @tc.desc: Verify the CloseCtrlTrans function. + * @tc.desc: Verify the CloseCtrlTrans function without task queue. * @tc.type: FUNC * @tc.require: AR000H0E5F */ @@ -238,6 +315,41 @@ HWTEST_F(DAudioSourceDevTest, CloseCtrlTrans_001, TestSize.Level1) AudioEvent event; bool isSpk = false; EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk)); + + sourceDev_->audioCtrlMgr_ = std::make_shared(DEV_ID, sourceDev_); + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->CloseCtrlTrans(event, isSpk)); +} + +/** + * @tc.name: CloseCtrlTrans_002 + * @tc.desc: Verify the CloseCtrlTrans function with task queue run. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSourceDevTest, CloseCtrlTrans_002, TestSize.Level1) +{ + AudioEvent event; + sourceDev_->taskQueue_ = std::make_shared(TASK_QUEUE_LEN); + + bool isSpk = false; + sourceDev_->mic_ = nullptr; + sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); + sourceDev_->speaker_->isOpened_ = false; + EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk)); + + sourceDev_->speaker_->isOpened_ = true; + EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk)); + + isSpk = true; + sourceDev_->speaker_ = nullptr; + sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); + sourceDev_->mic_->isOpened_ = false; + EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk)); + + sourceDev_->mic_->isOpened_ = true; + EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk)); + + sourceDev_->taskQueue_ = nullptr; } /** @@ -250,6 +362,15 @@ HWTEST_F(DAudioSourceDevTest, HandleOpenCtrlTrans_001, TestSize.Level1) { AudioEvent event; EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleOpenCtrlTrans(event)); + + sourceDev_->taskQueue_ = std::make_shared(TASK_QUEUE_LEN); + EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleOpenCtrlTrans(event)); + sourceDev_->taskQueue_ = nullptr; + + size_t tempCapacity = 0; + sourceDev_->taskQueue_ = std::make_shared(tempCapacity); + EXPECT_EQ(ERR_DH_AUDIO_SA_TASKQUEUE_FULL, sourceDev_->HandleOpenCtrlTrans(event)); + sourceDev_->taskQueue_ = nullptr; } /** @@ -262,6 +383,39 @@ HWTEST_F(DAudioSourceDevTest, HandleCloseCtrlTrans_001, TestSize.Level1) { AudioEvent event; EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleCloseCtrlTrans(event)); + + sourceDev_->taskQueue_ = std::make_shared(TASK_QUEUE_LEN); + EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCloseCtrlTrans(event)); + sourceDev_->taskQueue_ = nullptr; + + size_t tempCapacity = 0; + sourceDev_->taskQueue_ = std::make_shared(tempCapacity); + EXPECT_EQ(ERR_DH_AUDIO_SA_TASKQUEUE_FULL, sourceDev_->HandleCloseCtrlTrans(event)); + sourceDev_->taskQueue_ = nullptr; +} + +/** + * @tc.name: HandleCtrlTransClosed_001 + * @tc.desc: Verify the HandleCtrlTransClosed function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSourceDevTest, HandleCtrlTransClosed_001, TestSize.Level1) +{ + AudioEvent event = AudioEvent(CTRL_CLOSED, ""); + EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event)); + + sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); + sourceDev_->speaker_->isOpened_ = false; + EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event)); + sourceDev_->speaker_->isOpened_ = true; + EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event)); + + sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); + sourceDev_->speaker_->isOpened_ = false; + EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event)); + sourceDev_->speaker_->isOpened_ = true; + EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event)); } /** @@ -274,6 +428,10 @@ HWTEST_F(DAudioSourceDevTest, HandleNotifyRPC_001, TestSize.Level1) { AudioEvent event(NOTIFY_OPEN_SPEAKER_RESULT, ""); EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->HandleNotifyRPC(event)); + + std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); + event.content = tempLongStr; + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->HandleNotifyRPC(event)); } @@ -286,7 +444,7 @@ HWTEST_F(DAudioSourceDevTest, HandleNotifyRPC_001, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, HandleNotifyRPC_002, TestSize.Level1) { AudioEvent event(NOTIFY_OPEN_SPEAKER_RESULT, "result"); - EXPECT_NE(DH_SUCCESS, sourceDev_->HandleNotifyRPC(event)); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->HandleNotifyRPC(event)); } /** @@ -298,7 +456,10 @@ HWTEST_F(DAudioSourceDevTest, HandleNotifyRPC_002, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, HandleNotifyRPC_003, TestSize.Level1) { json jParam = { { KEY_RESULT, DH_SUCCESS } }; - AudioEvent event(NOTIFY_OPEN_SPEAKER_RESULT, jParam.dump()); + AudioEvent event(CHANGE_PLAY_STATUS, jParam.dump()); + EXPECT_EQ(ERR_DH_AUDIO_NOT_FOUND_KEY, sourceDev_->HandleNotifyRPC(event)); + + event.type = NOTIFY_OPEN_SPEAKER_RESULT; EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleNotifyRPC(event)); } @@ -311,9 +472,11 @@ HWTEST_F(DAudioSourceDevTest, HandleNotifyRPC_003, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, HandleSpkMmapStart_001, TestSize.Level1) { AudioEvent event; - sourceDev_->taskQueue_ = std::make_shared(taskQueueLength); - sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleSpkMmapStart(event)); + + sourceDev_->taskQueue_ = std::make_shared(TASK_QUEUE_LEN); EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleSpkMmapStart(event)); + sourceDev_->taskQueue_ = nullptr; } /** @@ -325,9 +488,11 @@ HWTEST_F(DAudioSourceDevTest, HandleSpkMmapStart_001, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, HandleSpkMmapStop_001, TestSize.Level1) { AudioEvent event; - sourceDev_->taskQueue_ = std::make_shared(taskQueueLength); - sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleSpkMmapStop(event)); + + sourceDev_->taskQueue_ = std::make_shared(TASK_QUEUE_LEN); EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleSpkMmapStop(event)); + sourceDev_->taskQueue_ = nullptr; } /** @@ -339,9 +504,11 @@ HWTEST_F(DAudioSourceDevTest, HandleSpkMmapStop_001, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, HandleMicMmapStart_001, TestSize.Level1) { AudioEvent event; - sourceDev_->taskQueue_ = std::make_shared(taskQueueLength); - sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleMicMmapStart(event)); + + sourceDev_->taskQueue_ = std::make_shared(TASK_QUEUE_LEN); EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleMicMmapStart(event)); + sourceDev_->taskQueue_ = nullptr; } /** @@ -353,9 +520,11 @@ HWTEST_F(DAudioSourceDevTest, HandleMicMmapStart_001, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, HandleMicMmapStop_001, TestSize.Level1) { AudioEvent event; - sourceDev_->taskQueue_ = std::make_shared(taskQueueLength); - sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleMicMmapStop(event)); + + sourceDev_->taskQueue_ = std::make_shared(TASK_QUEUE_LEN); EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleMicMmapStop(event)); + sourceDev_->taskQueue_ = nullptr; } /** @@ -366,29 +535,19 @@ HWTEST_F(DAudioSourceDevTest, HandleMicMmapStop_001, TestSize.Level1) */ HWTEST_F(DAudioSourceDevTest, TaskEnableDAudio_001, TestSize.Level1) { - EXPECT_NE(DH_SUCCESS, sourceDev_->TaskEnableDAudio("")); - json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK } }; - sourceDev_->OnEnableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); - sourceDev_->OnEnableTaskResult(ERR_DH_AUDIO_NULLPTR, jParam.dump(), FUNC_NAME); - sourceDev_->OnEnableTaskResult(DH_SUCCESS, "", FUNC_NAME); + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskEnableDAudio("")); - sourceDev_->mgrCallback_ = nullptr; - sourceDev_->OnEnableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); + std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskEnableDAudio(tempLongStr)); - auto mgrCb = std::make_shared(); - EXPECT_NE(DH_SUCCESS, mgrCb->OnEnableAudioResult(DEV_ID, DH_ID_SPK, DH_SUCCESS)); -} + json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_RESULT, "test_result" } }; + EXPECT_EQ(ERR_DH_AUDIO_SA_ENABLE_PARAM_INVALID, sourceDev_->TaskEnableDAudio(jParam.dump())); -/** - * @tc.name: TaskEnableDAudio_002 - * @tc.desc: Verify the TaskEnableDAudio function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSourceDevTest, TaskEnableDAudio_002, TestSize.Level1) -{ - json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_UNKNOWN }, { KEY_ATTRS, "" } }; - EXPECT_NE(DH_SUCCESS, sourceDev_->TaskEnableDAudio(jParam.dump())); + jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, "testDhId" }, { KEY_ATTRS, "" } }; + EXPECT_EQ(ERR_DH_AUDIO_SA_ENABLE_PARAM_INVALID, sourceDev_->TaskEnableDAudio(jParam.dump())); + + jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_UNKNOWN }, { KEY_ATTRS, "" } }; + EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, sourceDev_->TaskEnableDAudio(jParam.dump())); json jParam_spk = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK }, { KEY_ATTRS, "" } }; EXPECT_NE(DH_SUCCESS, sourceDev_->TaskEnableDAudio(jParam_spk.dump())); @@ -405,35 +564,79 @@ HWTEST_F(DAudioSourceDevTest, TaskEnableDAudio_002, TestSize.Level1) */ HWTEST_F(DAudioSourceDevTest, TaskDisableDAudio_001, TestSize.Level1) { - EXPECT_NE(DH_SUCCESS, sourceDev_->TaskDisableDAudio("")); - json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK } }; - sourceDev_->OnDisableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); - sourceDev_->OnDisableTaskResult(ERR_DH_AUDIO_NULLPTR, jParam.dump(), FUNC_NAME); - sourceDev_->OnDisableTaskResult(DH_SUCCESS, "", FUNC_NAME); + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskDisableDAudio("")); + + std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskDisableDAudio(tempLongStr)); + + json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_RESULT, "test_result" } }; + EXPECT_EQ(ERR_DH_AUDIO_SA_DISABLE_PARAM_INVALID, sourceDev_->TaskDisableDAudio(jParam.dump())); + + jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, "testDhId" } }; + EXPECT_EQ(ERR_DH_AUDIO_SA_DISABLE_PARAM_INVALID, sourceDev_->TaskDisableDAudio(jParam.dump())); + + jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_UNKNOWN } }; + EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, sourceDev_->TaskDisableDAudio(jParam.dump())); + + json jParam_spk = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK } }; + EXPECT_NE(DH_SUCCESS, sourceDev_->TaskDisableDAudio(jParam_spk.dump())); + + json jParam_mic = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_MIC } }; + EXPECT_NE(DH_SUCCESS, sourceDev_->TaskDisableDAudio(jParam_mic.dump())); +} + +/** + * @tc.name: OnEnableTaskResult_001 + * @tc.desc: Verify the OnEnableTaskResult and OnEnableAudioResult function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSourceDevTest, OnEnableTaskResult_001, TestSize.Level1) +{ + sourceDev_->OnEnableTaskResult(DH_SUCCESS, "", FUNC_NAME); + + std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); + sourceDev_->OnEnableTaskResult(DH_SUCCESS, tempLongStr, FUNC_NAME); + + json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_RESULT, "test_result" } }; + sourceDev_->OnEnableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); + + jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK } }; + sourceDev_->OnEnableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); + sourceDev_->OnEnableTaskResult(ERR_DH_AUDIO_NULLPTR, jParam.dump(), FUNC_NAME); sourceDev_->mgrCallback_ = nullptr; - sourceDev_->OnDisableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); + sourceDev_->OnEnableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); auto mgrCb = std::make_shared(); - EXPECT_NE(DH_SUCCESS, mgrCb->OnDisableAudioResult(DEV_ID, DH_ID_SPK, DH_SUCCESS)); + EXPECT_NE(DH_SUCCESS, mgrCb->OnEnableAudioResult(DEV_ID, DH_ID_SPK, DH_SUCCESS)); } /** - * @tc.name: TaskDisableDAudio_002 - * @tc.desc: Verify the TaskDisableDAudio function. + * @tc.name: OnDisableTaskResult_001 + * @tc.desc: Verify the OnDisableTaskResult and OnDisableAudioResult function. * @tc.type: FUNC * @tc.require: AR000H0E5F */ -HWTEST_F(DAudioSourceDevTest, TaskDisableDAudio_002, TestSize.Level1) +HWTEST_F(DAudioSourceDevTest, OnDisableTaskResult_001, TestSize.Level1) { - json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_UNKNOWN } }; - EXPECT_NE(DH_SUCCESS, sourceDev_->TaskDisableDAudio(jParam.dump())); + sourceDev_->OnDisableTaskResult(DH_SUCCESS, "", FUNC_NAME); - json jParam_spk = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK } }; - EXPECT_NE(DH_SUCCESS, sourceDev_->TaskDisableDAudio(jParam_spk.dump())); + std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); + sourceDev_->OnDisableTaskResult(DH_SUCCESS, tempLongStr, FUNC_NAME); - json jParam_mic = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_MIC } }; - EXPECT_NE(DH_SUCCESS, sourceDev_->TaskDisableDAudio(jParam_mic.dump())); + json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_RESULT, "test_result" } }; + sourceDev_->OnDisableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); + + jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK } }; + sourceDev_->OnDisableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); + sourceDev_->OnDisableTaskResult(ERR_DH_AUDIO_NULLPTR, jParam.dump(), FUNC_NAME); + + sourceDev_->mgrCallback_ = nullptr; + sourceDev_->OnDisableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); + + auto mgrCb = std::make_shared(); + EXPECT_NE(DH_SUCCESS, mgrCb->OnDisableAudioResult(DEV_ID, DH_ID_SPK, DH_SUCCESS)); } /** @@ -445,6 +648,10 @@ HWTEST_F(DAudioSourceDevTest, TaskDisableDAudio_002, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, EnableDSpeaker_001, TestSize.Level1) { int32_t dhId = 0; + sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); + EXPECT_NE(DH_SUCCESS, sourceDev_->EnableDSpeaker(dhId, ATTRS)); + sourceDev_->speaker_ = nullptr; + EXPECT_NE(DH_SUCCESS, sourceDev_->EnableDSpeaker(dhId, ATTRS)); } @@ -457,6 +664,10 @@ HWTEST_F(DAudioSourceDevTest, EnableDSpeaker_001, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, EnableDMic_001, TestSize.Level1) { int32_t dhId = 0; + sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); + EXPECT_NE(DH_SUCCESS, sourceDev_->EnableDMic(dhId, ATTRS)); + sourceDev_->mic_ = nullptr; + EXPECT_NE(DH_SUCCESS, sourceDev_->EnableDMic(dhId, ATTRS)); } @@ -470,19 +681,10 @@ HWTEST_F(DAudioSourceDevTest, DisableDSpeaker_001, TestSize.Level1) { int32_t dhId = 0; EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->DisableDSpeaker(dhId)); -} -/** - * @tc.name: DisableDSpeaker_002 - * @tc.desc: Verify the DisableDSpeaker function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSourceDevTest, DisableDSpeaker_002, TestSize.Level1) -{ - int32_t dhId = 0; sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); EXPECT_NE(DH_SUCCESS, sourceDev_->DisableDSpeaker(dhId)); + sourceDev_->speaker_ = nullptr; } /** @@ -495,19 +697,10 @@ HWTEST_F(DAudioSourceDevTest, DisableDMic_001, TestSize.Level1) { int32_t dhId = 0; EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->DisableDMic(dhId)); -} -/** - * @tc.name: DisableDMic_002 - * @tc.desc: Verify the DisableDMic function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSourceDevTest, DisableDMic_002, TestSize.Level1) -{ - int32_t dhId = 0; sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); EXPECT_NE(DH_SUCCESS, sourceDev_->DisableDMic(dhId)); + sourceDev_->mic_ = nullptr; } /** @@ -522,10 +715,18 @@ HWTEST_F(DAudioSourceDevTest, TaskOpenDSpeaker_001, TestSize.Level1) sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskOpenDSpeaker("")); + + std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskOpenDSpeaker(tempLongStr)); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskOpenDSpeaker(ARGS)); json jParam_spk = { { KEY_DH_ID, DH_ID_SPK } }; EXPECT_EQ(ERR_DH_AUDIO_SA_RPC_WAIT_TIMEOUT, sourceDev_->TaskOpenDSpeaker(jParam_spk.dump())); + + sourceDev_->rpcResult_ = true; + sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_OPEN_SPK; + EXPECT_NE(DH_SUCCESS, sourceDev_->TaskOpenDSpeaker(jParam_spk.dump())); } /** @@ -537,6 +738,21 @@ HWTEST_F(DAudioSourceDevTest, TaskOpenDSpeaker_001, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, TaskCloseDSpeaker_001, TestSize.Level1) { EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDSpeaker(ARGS)); + + sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDSpeaker("")); + + std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDSpeaker(tempLongStr)); + + sourceDev_->speaker_->isOpened_ = true; + EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDSpeaker(ARGS)); + + sourceDev_->speaker_->isOpened_ = false; + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDSpeaker(ARGS)); + + json jParam_spk = { { KEY_DH_ID, DH_ID_SPK } }; + EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDSpeaker(jParam_spk.dump())); } /** @@ -548,10 +764,10 @@ HWTEST_F(DAudioSourceDevTest, TaskCloseDSpeaker_001, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, TaskCloseDSpeaker_002, TestSize.Level1) { sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); - EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDSpeaker("")); + sourceDev_->speaker_->speakerTrans_ = std::make_shared(DEV_ID); json jParam_spk = { { KEY_DH_ID, DH_ID_SPK } }; - EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDSpeaker(jParam_spk.dump())); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDSpeaker(jParam_spk.dump())); } /** @@ -566,6 +782,10 @@ HWTEST_F(DAudioSourceDevTest, TaskOpenDMic_001, TestSize.Level1) sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskOpenDMic("")); + + std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskOpenDMic(tempLongStr)); + EXPECT_EQ(ERR_DH_AUDIO_TRANS_ERROR, sourceDev_->TaskOpenDMic(ARGS)); json jParam_mic = { { KEY_DH_ID, DH_ID_MIC } }; @@ -581,6 +801,21 @@ HWTEST_F(DAudioSourceDevTest, TaskOpenDMic_001, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, TaskCloseDMic_001, TestSize.Level1) { EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(ARGS)); + + sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDMic("")); + + std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDMic(tempLongStr)); + + sourceDev_->mic_->isOpened_ = true; + EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(ARGS)); + + sourceDev_->mic_->isOpened_ = false; + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDMic(ARGS)); + + json jParam_mic = { { KEY_DH_ID, DH_ID_MIC } }; + EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(jParam_mic.dump())); } /** @@ -592,8 +827,7 @@ HWTEST_F(DAudioSourceDevTest, TaskCloseDMic_001, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, TaskCloseDMic_002, TestSize.Level1) { sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); - EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDMic("")); - EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDMic(ARGS)); + sourceDev_->mic_->micTrans_ = std::make_shared(DEV_ID); json jParam_mic = { { KEY_DH_ID, DH_ID_MIC } }; EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(jParam_mic.dump())); @@ -611,9 +845,18 @@ HWTEST_F(DAudioSourceDevTest, TaskOpenCtrlChannel_001, TestSize.Level1) sourceDev_->audioCtrlMgr_ = std::make_shared(DEV_ID, sourceDev_); EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskOpenCtrlChannel("")); + + std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskOpenCtrlChannel(tempLongStr)); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskOpenCtrlChannel(ARGS)); json jParam = { { KEY_DH_ID, DH_ID_SPK } }; + EXPECT_EQ(ERR_DH_AUDIO_SA_RPC_WAIT_TIMEOUT, sourceDev_->TaskOpenCtrlChannel(jParam.dump())); + + sourceDev_->rpcResult_ = true; + sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_OPEN_MIC; + jParam = { { KEY_DH_ID, DH_ID_SPK } }; EXPECT_NE(DH_SUCCESS, sourceDev_->TaskOpenCtrlChannel(jParam.dump())); } @@ -666,6 +909,9 @@ HWTEST_F(DAudioSourceDevTest, TaskSetVolume_002, TestSize.Level1) sourceDev_->audioCtrlMgr_ = std::make_shared(DEV_ID, sourceDev_); EXPECT_NE(DH_SUCCESS, sourceDev_->TaskSetVolume(ARGS)); + json jParam = { { STREAM_MUTE_STATUS, 1 } }; + EXPECT_NE(DH_SUCCESS, sourceDev_->TaskSetVolume(jParam.dump())); + sourceDev_->OnTaskResult(ERR_DH_AUDIO_NULLPTR, "", FUNC_NAME); } @@ -710,6 +956,8 @@ HWTEST_F(DAudioSourceDevTest, TaskChangeRenderState_001, TestSize.Level1) */ HWTEST_F(DAudioSourceDevTest, TaskPlayStatusChange_001, TestSize.Level1) { + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskPlayStatusChange(AUDIO_EVENT_PAUSE)); + sourceDev_->audioCtrlMgr_ = std::make_shared(DEV_ID, sourceDev_); sourceDev_->speaker_ = std::make_shared(DEV_ID, nullptr); EXPECT_NE(DH_SUCCESS, sourceDev_->TaskPlayStatusChange(AUDIO_EVENT_PAUSE)); @@ -724,8 +972,12 @@ HWTEST_F(DAudioSourceDevTest, TaskPlayStatusChange_001, TestSize.Level1) */ HWTEST_F(DAudioSourceDevTest, TaskSpkMmapStart_001, TestSize.Level1) { + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskSpkMmapStart(ARGS)); + sourceDev_->speaker_ = std::make_shared(DEV_ID, nullptr); - sourceDev_->speaker_->ashmem_ = new Ashmem(fd, ashmemLength); + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskSpkMmapStart(ARGS)); + + sourceDev_->speaker_->ashmem_ = new Ashmem(fd, ASHMEM_LEN); EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskSpkMmapStart(ARGS)); EXPECT_EQ(DH_SUCCESS, sourceDev_->speaker_->MmapStop()); } @@ -738,6 +990,8 @@ HWTEST_F(DAudioSourceDevTest, TaskSpkMmapStart_001, TestSize.Level1) */ HWTEST_F(DAudioSourceDevTest, TaskSpkMmapStop_001, TestSize.Level1) { + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskSpkMmapStop(ARGS)); + sourceDev_->speaker_ = std::make_shared(DEV_ID, nullptr); EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskSpkMmapStop(ARGS)); } @@ -750,10 +1004,14 @@ HWTEST_F(DAudioSourceDevTest, TaskSpkMmapStop_001, TestSize.Level1) */ HWTEST_F(DAudioSourceDevTest, TaskMicMmapStart_001, TestSize.Level1) { + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskMicMmapStart(ARGS)); + sourceDev_->mic_ = std::make_shared(DEV_ID, nullptr); - sourceDev_->mic_->ashmem_ = new Ashmem(fd, ashmemLength); - std::shared_ptr data = std::make_shared(capacity); - for (size_t i = 0; i < taskQueueLength; i++) { + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskMicMmapStart(ARGS)); + + sourceDev_->mic_->ashmem_ = new Ashmem(fd, ASHMEM_LEN); + std::shared_ptr data = std::make_shared(AUDIO_DATA_CAP); + for (size_t i = 0; i < TASK_QUEUE_LEN; i++) { sourceDev_->mic_->dataQueue_.push(data); } EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskMicMmapStart(ARGS)); @@ -768,6 +1026,8 @@ HWTEST_F(DAudioSourceDevTest, TaskMicMmapStart_001, TestSize.Level1) */ HWTEST_F(DAudioSourceDevTest, TaskMicMmapStop_001, TestSize.Level1) { + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskMicMmapStop(ARGS)); + sourceDev_->mic_ = std::make_shared(DEV_ID, nullptr); EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskMicMmapStop(ARGS)); }