1 /* 2 * Copyright (c) 2025 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 <iostream> 17 #include <gtest/gtest.h> 18 #include <gmock/gmock.h> 19 #include <vector> 20 #include "audio_utils.h" 21 #include "audio_errors.h" 22 #include "common/hdi_adapter_info.h" 23 #include "util/id_handler.h" 24 #include "util/audio_running_lock.h" 25 #include "util/ring_buffer_handler.h" 26 #include "util/callback_wrapper.h" 27 #include "util/kv_pair.h" 28 29 using namespace testing::ext; 30 31 namespace OHOS { 32 namespace AudioStandard { 33 class UtilUnitTest : 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.name : Test IdHandler API 43 * @tc.number : IdHandlerUnitTest_001 44 * @tc.desc : Test IdHandler action 45 */ 46 HWTEST_F(UtilUnitTest, IdHandlerUnitTest_001, TestSize.Level1) 47 { 48 IdHandler &idHandler = IdHandler::GetInstance(); 49 uint32_t id = idHandler.GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY, HDI_ID_INFO_DEFAULT); 50 EXPECT_NE(id, HDI_INVALID_ID); 51 52 id = idHandler.GetRenderIdByDeviceClass(""); 53 EXPECT_EQ(id, HDI_INVALID_ID); 54 55 id = idHandler.GetCaptureIdByDeviceClass("", SOURCE_TYPE_MIC); 56 EXPECT_EQ(id, HDI_INVALID_ID); 57 58 idHandler.IncInfoIdUseCount(id); 59 idHandler.DecInfoIdUseCount(id); 60 61 auto ret = idHandler.CheckId(id, HDI_ID_BASE_RENDER); 62 EXPECT_EQ(ret, false); 63 64 uint32_t base = idHandler.ParseBase(0); 65 EXPECT_EQ(base, 0); 66 67 uint32_t type = idHandler.ParseType(0); 68 EXPECT_EQ(type, 0); 69 70 std::string info = idHandler.ParseInfo(HDI_INVALID_ID); 71 EXPECT_EQ(info, ""); 72 } 73 74 /** 75 * @tc.name : Test IdHandler API 76 * @tc.number : IdHandlerUnitTest_002 77 * @tc.desc : Test IdHandler action 78 */ 79 HWTEST_F(UtilUnitTest, IdHandlerUnitTest_002, TestSize.Level1) 80 { 81 IdHandler &idHandler = IdHandler::GetInstance(); 82 uint32_t id = idHandler.GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_BLUETOOTH, HDI_ID_INFO_HEARING_AID); 83 EXPECT_NE(id, HDI_INVALID_ID); 84 85 uint32_t hearingAidId = idHandler.GetRenderIdByDeviceClass("hearing_aid"); 86 EXPECT_EQ(hearingAidId, id); 87 } 88 89 /** 90 * @tc.name : Test AudioRunningLock API 91 * @tc.number : AudioRunningLockUnitTest_001 92 * @tc.desc : Test AudioRunningLock action 93 */ 94 HWTEST_F(UtilUnitTest, AudioRunningLockUnitTest_001, TestSize.Level1) 95 { 96 #ifdef FEATURE_POWER_MANAGER 97 std::shared_ptr<AudioRunningLock> runningLock = std::make_shared<AudioRunningLock>("test"); 98 ASSERT_NE(runningLock, nullptr); 99 100 auto ret = runningLock->Lock(-1); // -1: test 101 EXPECT_EQ(ret, SUCCESS); 102 103 runningLock->UnLock(); 104 vector<int32_t> vec = { 0 }; 105 runningLock->UpdateAppsUid(vec.begin(), vec.end()); 106 #endif 107 } 108 109 /** 110 * @tc.name : Test AudioRunningLock API 111 * @tc.number : AudioRunningLockUnitTest_002 112 * @tc.desc : Test AudioRunningLock action 113 */ 114 HWTEST_F(UtilUnitTest, AudioRunningLockUnitTest_002, TestSize.Level1) 115 { 116 #ifdef FEATURE_POWER_MANAGER 117 std::shared_ptr<AudioRunningLock> runningLock = std::make_shared<AudioRunningLock>("test"); 118 ASSERT_NE(runningLock, nullptr); 119 120 auto ret = runningLock->UpdateAppsUidToPowerMgr(); 121 EXPECT_EQ(ret, SUCCESS); 122 123 vector<int32_t> vec = { 0 }; 124 runningLock->UpdateAppsUid(vec.begin(), vec.end()); 125 126 ret = runningLock->UpdateAppsUidToPowerMgr(); 127 EXPECT_EQ(ret, SUCCESS); 128 #endif 129 } 130 131 /** 132 * @tc.name : Test AudioRunningLock API 133 * @tc.number : AudioRunningLockUnitTest_003 134 * @tc.desc : Test AudioRunningLock action 135 */ 136 HWTEST_F(UtilUnitTest, AudioRunningLockUnitTest_003, TestSize.Level1) 137 { 138 #ifdef FEATURE_POWER_MANAGER 139 std::shared_ptr<AudioRunningLock> runningLock = std::make_shared<AudioRunningLock>("test"); 140 ASSERT_NE(runningLock, nullptr); 141 142 runningLock->isLocked_ = true; 143 144 auto ret = runningLock->UpdateAppsUidToPowerMgr(); 145 EXPECT_EQ(ret, SUCCESS); 146 147 vector<int32_t> vec = { 0 }; 148 runningLock->UpdateAppsUid(vec.begin(), vec.end()); 149 150 ret = runningLock->UpdateAppsUidToPowerMgr(); 151 EXPECT_EQ(ret, SUCCESS); 152 #endif 153 } 154 155 /** 156 * @tc.name : Test RingBufferHandler API 157 * @tc.number : RingBufferHandlerUnitTest_001 158 * @tc.desc : Test RingBufferHandler action 159 */ 160 HWTEST_F(UtilUnitTest, RingBufferHandlerUnitTest_001, TestSize.Level1) 161 { 162 std::shared_ptr<RingBufferHandler> handler = std::make_shared<RingBufferHandler>(); 163 ASSERT_NE(handler, nullptr); 164 165 handler->Init(10, 10, 10, 10, 10); // 10: test 166 167 vector<uint8_t> bufferWrite = { 0 }; 168 auto ret = handler->WriteDataToRingBuffer(bufferWrite.data(), bufferWrite.size()); 169 EXPECT_NE(ret, SUCCESS); 170 171 vector<uint8_t> bufferRead = { 0 }; 172 bufferRead.resize(bufferWrite.size()); 173 ret = handler->ReadDataFromRingBuffer(bufferRead.data(), bufferRead.size()); 174 EXPECT_NE(ret, SUCCESS); 175 176 handler->AddWriteIndex(); 177 handler->AddReadIndex(); 178 } 179 180 /** 181 * @tc.name : Test CallbackWrapper API 182 * @tc.number : CallbackWrapperUnitTest_001 183 * @tc.desc : Test SinkCallbackWrapper action 184 */ 185 HWTEST_F(UtilUnitTest, CallbackWrapperUnitTest_001, TestSize.Level1) 186 { 187 SinkCallbackWrapper sinkCbWrapper; 188 189 std::shared_ptr<IAudioSinkCallback> sinkCb = nullptr; 190 sinkCbWrapper.RegistCallback(HDI_CB_RENDER_STATE, sinkCb); 191 IAudioSinkCallback *sinkRawCb = nullptr; 192 sinkCbWrapper.RegistCallback(HDI_CB_RENDER_STATE, sinkRawCb); __anon208b37780102(uint32_t renderId) 193 std::function<std::shared_ptr<IAudioSinkCallback>(uint32_t)> cbGenerator = [](uint32_t renderId) { 194 return nullptr; 195 }; 196 sinkCbWrapper.RegistCallbackGenerator(HDI_CB_RENDER_STATE, cbGenerator); 197 sinkCb = sinkCbWrapper.GetCallback(HDI_CB_RENDER_STATE, HDI_INVALID_ID); 198 EXPECT_EQ(sinkCb, nullptr); 199 sinkRawCb = sinkCbWrapper.GetRawCallback(HDI_CB_RENDER_STATE); 200 EXPECT_EQ(sinkRawCb, nullptr); 201 202 sinkCbWrapper.OnRenderSinkParamChange("", NONE, "", ""); 203 sinkCbWrapper.OnRenderSinkStateChange(0, false); 204 } 205 206 /** 207 * @tc.name : Test CallbackWrapper API 208 * @tc.number : CallbackWrapperUnitTest_002 209 * @tc.desc : Test SourceCallbackWrapper action 210 */ 211 HWTEST_F(UtilUnitTest, CallbackWrapperUnitTest_002, TestSize.Level1) 212 { 213 SourceCallbackWrapper sourceCbWrapper; 214 215 std::shared_ptr<IAudioSourceCallback> sourceCb = nullptr; 216 sourceCbWrapper.RegistCallback(HDI_CB_CAPTURE_STATE, sourceCb); 217 IAudioSourceCallback *sourceRawCb = nullptr; 218 sourceCbWrapper.RegistCallback(HDI_CB_CAPTURE_STATE, sourceRawCb); __anon208b37780202(uint32_t captureId) 219 std::function<std::shared_ptr<IAudioSourceCallback>(uint32_t)> cbGenerator = [](uint32_t captureId) { 220 return nullptr; 221 }; 222 sourceCbWrapper.RegistCallbackGenerator(HDI_CB_CAPTURE_STATE, cbGenerator); 223 sourceCb = sourceCbWrapper.GetCallback(HDI_CB_CAPTURE_STATE, HDI_INVALID_ID); 224 EXPECT_EQ(sourceCb, nullptr); 225 sourceRawCb = sourceCbWrapper.GetRawCallback(HDI_CB_CAPTURE_STATE); 226 EXPECT_EQ(sourceRawCb, nullptr); 227 228 sourceCbWrapper.OnCaptureSourceParamChange("", NONE, "", ""); 229 sourceCbWrapper.OnCaptureState(false); 230 sourceCbWrapper.OnWakeupClose(); 231 } 232 233 /** 234 * @tc.name : Test KvPair API 235 * @tc.number : KvPairUnitTest_001 236 * @tc.desc : Test KvPair action 237 */ 238 HWTEST_F(UtilUnitTest, KvPairUnitTest_001, TestSize.Level1) 239 { 240 KvPair<std::string> kv; 241 kv.Set<uint32_t>("test", 1); 242 uint32_t value = 0; 243 auto ret = kv.Get<uint32_t>("test", value); 244 EXPECT_EQ(ret, SUCCESS); 245 EXPECT_EQ(value, 1); 246 kv.Erase("test"); 247 ret = kv.Get<uint32_t>("test_1", value); 248 EXPECT_NE(ret, SUCCESS); 249 } 250 251 } // namespace AudioStandard 252 } // namespace OHOS 253