1 /* 2 * Copyright (C) 2024-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 <gtest/gtest.h> 17 #include "cJSON.h" 18 #include "cs_call.h" 19 #include "common_type.h" 20 #include "telephony_errors.h" 21 #include "call_manager_base.h" 22 #include "distributed_data_controller.h" 23 #include "distributed_device_observer.h" 24 #include "distributed_communication_manager.h" 25 #include "call_manager_disconnected_details.h" 26 #include "distributed_data_sink_controller.h" 27 #include "distributed_sink_switch_controller.h" 28 29 namespace OHOS { 30 namespace Telephony { 31 using namespace testing::ext; 32 33 class DistributedCommunicationManagerTest : public testing::Test { 34 public: SetUpTestCase()35 static void SetUpTestCase() {} TearDownTestCase()36 static void TearDownTestCase() {} SetUp()37 virtual void SetUp() {} TearDown()38 virtual void TearDown() {} 39 }; 40 41 /** 42 * @tc.number Telephony_DcManagerTest_001 43 * @tc.name test normal branch 44 * @tc.desc normal branch test 45 */ 46 HWTEST_F(DistributedCommunicationManagerTest, Telephony_DcManagerTest_001, Function | MediumTest | Level1) 47 { 48 int32_t direction = 1; 49 DialParaInfo mDialParaInfo; 50 DisconnectedDetails details; 51 sptr<CallBase> csCall = nullptr; 52 std::string devId = "UnitTestDeviceId"; 53 auto dcManager = DelayedSingleton<DistributedCommunicationManager>::GetInstance(); 54 std::shared_ptr<IDistributedDeviceCallback> deviceListener = std::make_shared<DistributedDeviceCallback>(); 55 56 ASSERT_NO_THROW(dcManager->NewCallCreated(csCall)); 57 58 auto deviceObserver = dcManager->GetDistributedDeviceObserver(); 59 ASSERT_TRUE(deviceObserver == nullptr); 60 61 ASSERT_NO_THROW(dcManager->Init()); 62 csCall = new CSCall(mDialParaInfo); 63 64 int32_t ret = dcManager->RegDevCallbackWrapper(deviceListener); 65 ASSERT_TRUE(ret == TELEPHONY_ERROR); 66 67 ret = dcManager->UnRegDevCallbackWrapper(); 68 ASSERT_TRUE(ret == TELEPHONY_ERROR); 69 70 ret = dcManager->SwitchDevWrapper(devId, direction); 71 ASSERT_TRUE(ret == TELEPHONY_ERROR); 72 73 ASSERT_NO_THROW(dcManager->InitExtWrapper()); 74 ASSERT_NO_THROW(dcManager->InitExtWrapper()); // extWrapperHandler_ != nullptr case 75 ASSERT_NO_THROW(dcManager->SetMuted(true)); 76 ASSERT_NO_THROW(dcManager->MuteRinger()); 77 ASSERT_NO_THROW(dcManager->ProcessCallInfo(csCall, DistributedDataType::LOCATION)); 78 ASSERT_NO_THROW(dcManager->NewCallCreated(csCall)); 79 ASSERT_NO_THROW(dcManager->CallDestroyed(details)); 80 ASSERT_NO_THROW(dcManager->DeInitExtWrapper()); 81 ASSERT_NO_THROW(dcManager->dataController_ = std::make_shared<DistributedDataSinkController>()); 82 ASSERT_NO_THROW(dcManager->SetMuted(true)); 83 ASSERT_NO_THROW(dcManager->MuteRinger()); 84 ASSERT_NO_THROW(dcManager->ProcessCallInfo(csCall, DistributedDataType::LOCATION)); 85 csCall->SetCallType(CallType::TYPE_CS); 86 dcManager->role_ = DistributedRole::SINK; 87 ASSERT_NO_THROW(dcManager->NewCallCreated(csCall)); 88 dcManager->peerDevices_.push_back("device"); 89 ASSERT_NO_THROW(dcManager->NewCallCreated(csCall)); 90 ASSERT_NO_THROW(dcManager->CallDestroyed(details)); 91 ASSERT_NO_THROW(dcManager->peerDevices_.clear()); 92 } 93 94 /** 95 * @tc.number Telephony_DcManager_DeviceOnline_001 96 * @tc.name test dc device online 97 * @tc.desc Function test 98 */ 99 HWTEST_F(DistributedCommunicationManagerTest, Telephony_DcManager_DeviceOnline_001, Function | MediumTest | Level1) 100 { 101 int32_t devRole = 0; // sink 102 std::string devId = "UnitTestDeviceId"; 103 std::string devName = "UnitTestDeviceName"; 104 AudioDeviceType deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PHONE; 105 106 auto dcManager = DelayedSingleton<DistributedCommunicationManager>::GetInstance(); 107 dcManager->devObserver_ = nullptr; 108 ASSERT_NO_THROW(dcManager->OnDeviceOnline(devId, devName, deviceType, devRole)); 109 ASSERT_FALSE(dcManager->IsConnected()); 110 111 ASSERT_NO_THROW(dcManager->Init()); 112 113 ASSERT_NO_THROW(dcManager->OnDeviceOnline(devId, devName, deviceType, devRole)); 114 ASSERT_TRUE(dcManager->IsConnected()); 115 ASSERT_TRUE(dcManager->IsSinkRole()); 116 117 devRole = 1; // source 118 deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PAD; 119 dcManager->dataController_ = nullptr; 120 ASSERT_NO_THROW(dcManager->OnDeviceOnline(devId, devName, deviceType, devRole)); 121 ASSERT_FALSE(dcManager->IsSinkRole()); 122 } 123 124 /** 125 * @tc.number Telephony_DcManager_DeviceOffline_001 126 * @tc.name test dc device offline 127 * @tc.desc Function test 128 */ 129 HWTEST_F(DistributedCommunicationManagerTest, Telephony_DcManager_DeviceOffline_001, Function | MediumTest | Level1) 130 { 131 int32_t devRole = 0; 132 std::string devId = "UnitTestDeviceId"; 133 std::string devName = "UnitTestDeviceName"; 134 AudioDeviceType deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PHONE; 135 136 auto dcManager = DelayedSingleton<DistributedCommunicationManager>::GetInstance(); 137 ASSERT_NO_THROW(dcManager->OnDeviceOffline(devId, devName, deviceType, devRole)); 138 ASSERT_NO_THROW(dcManager->IsConnected()); 139 140 ASSERT_NO_THROW(dcManager->Init()); 141 ASSERT_NO_THROW(dcManager->OnDeviceOnline(devId, devName, deviceType, devRole)); 142 ASSERT_TRUE(dcManager->IsConnected()); 143 144 ASSERT_NO_THROW(dcManager->OnDeviceOffline(devId, devName, deviceType, devRole)); 145 ASSERT_FALSE(dcManager->IsConnected()); 146 147 dcManager->devObserver_ = nullptr; 148 ASSERT_NO_THROW(dcManager->OnDeviceOffline(devId, devName, deviceType, devRole)); 149 150 dcManager->devObserver_ = std::make_shared<DistributedDeviceObserver>(); 151 dcManager->peerDevices_.push_back("hello"); 152 ASSERT_NO_THROW(dcManager->OnDeviceOffline(devId, devName, deviceType, devRole)); 153 dcManager->peerDevices_.clear(); 154 } 155 156 /** 157 * @tc.number Telephony_DcManager_SwitchDevice_001 158 * @tc.name test switch device 159 * @tc.desc Function test 160 */ 161 HWTEST_F(DistributedCommunicationManagerTest, Telephony_DcManager_SwitchDevice_001, Function | MediumTest | Level1) 162 { 163 int32_t devRole = 1; 164 std::string devId = "UnitTestDeviceId"; 165 std::string devName = "UnitTestDeviceName"; 166 AudioDeviceType deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PAD; 167 auto dcManager = DelayedSingleton<DistributedCommunicationManager>::GetInstance(); 168 ASSERT_NO_THROW(dcManager->SwitchToSourceDevice()); 169 ASSERT_NO_THROW(dcManager->Init()); 170 ASSERT_NO_THROW(dcManager->OnDeviceOnline(devId, devName, deviceType, devRole)); 171 ASSERT_TRUE(dcManager->SwitchToSourceDevice()); 172 dcManager->devSwitchController_->isAudioOnSink_ = true; 173 ASSERT_NO_THROW(dcManager->SwitchToSourceDevice()); 174 dcManager->devSwitchController_->isAudioOnSink_ = false; 175 } 176 177 /** 178 * @tc.number Telephony_DcManager_SwitchToSinkDevice 179 * @tc.name test switch to sink device 180 * @tc.desc Function test 181 */ 182 HWTEST_F(DistributedCommunicationManagerTest, Telephony_DcManager_SwitchToSinkDevice, Function | MediumTest | Level1) 183 { 184 AudioDevice device; 185 std::string deviceId = "{ \"devId\": \"101\" }"; 186 std::string deviceName = "deviceName"; 187 device.deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PAD; 188 auto dcManager = DelayedSingleton<DistributedCommunicationManager>::GetInstance(); 189 ASSERT_FALSE(dcManager->SwitchToSinkDevice(device)); // deviceId is empty 190 ASSERT_EQ(memcpy_s(device.address, kMaxAddressLen + 1, deviceId.c_str(), deviceId.size()), EOK); 191 ASSERT_EQ(memcpy_s(device.deviceName, kMaxDeviceNameLen + 1, deviceName.c_str(), deviceName.size()), EOK); 192 ASSERT_FALSE(dcManager->SwitchToSinkDevice(device)); // not dc device 193 dcManager->peerDevices_.push_back("101"); 194 ASSERT_FALSE(dcManager->SwitchToSinkDevice(device)); 195 dcManager->devSwitchController_ = nullptr; 196 ASSERT_FALSE(dcManager->SwitchToSinkDevice(device)); 197 dcManager->devSwitchController_ = std::make_shared<DistributedSinkSwitchController>(); 198 dcManager->devSwitchController_->isAudioOnSink_ = true; 199 ASSERT_TRUE(dcManager->SwitchToSinkDevice(device)); 200 dcManager->devSwitchController_->isAudioOnSink_ = false; 201 dcManager->peerDevices_.clear(); 202 deviceId = "not Json string"; 203 ASSERT_EQ(memcpy_s(device.address, kMaxAddressLen + 1, deviceId.c_str(), deviceId.size()), EOK); 204 ASSERT_EQ(dcManager->ParseDevIdFromAudioDevice(device), ""); 205 } 206 } // namespace Telephony 207 } // namespace OHOS 208