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 "audio_utils.h"
20 #include "common/hdi_adapter_info.h"
21 #include "manager/hdi_adapter_manager.h"
22
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace AudioStandard {
27 class FastAudioRenderSinkUnitTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
31 virtual void SetUp();
32 virtual void TearDown();
33
34 protected:
35 static uint32_t id_;
36 static std::shared_ptr<IAudioRenderSink> sink_;
37 static IAudioSinkAttr attr_;
38 };
39
40 uint32_t FastAudioRenderSinkUnitTest::id_ = HDI_INVALID_ID;
41 std::shared_ptr<IAudioRenderSink> FastAudioRenderSinkUnitTest::sink_ = nullptr;
42 IAudioSinkAttr FastAudioRenderSinkUnitTest::attr_ = {};
43
SetUpTestCase()44 void FastAudioRenderSinkUnitTest::SetUpTestCase()
45 {
46 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
47 id_ = manager.GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_FAST, HDI_ID_INFO_DIRECT, true);
48 }
49
TearDownTestCase()50 void FastAudioRenderSinkUnitTest::TearDownTestCase()
51 {
52 HdiAdapterManager::GetInstance().ReleaseId(id_);
53 }
54
SetUp()55 void FastAudioRenderSinkUnitTest::SetUp()
56 {
57 sink_ = HdiAdapterManager::GetInstance().GetRenderSink(id_, true);
58 if (sink_ == nullptr) {
59 return;
60 }
61 }
62
TearDown()63 void FastAudioRenderSinkUnitTest::TearDown()
64 {
65 sink_ = nullptr;
66 }
67
68 /**
69 * @tc.name : Test FastSink API
70 * @tc.number : FastSinkUnitTest_001
71 * @tc.desc : Test fast sink create
72 */
73 HWTEST_F(FastAudioRenderSinkUnitTest, FastSinkUnitTest_001, TestSize.Level1)
74 {
75 EXPECT_TRUE(sink_);
76 }
77
78 /**
79 * @tc.name : Test FastSink API
80 * @tc.number : FastSinkUnitTest_002
81 * @tc.desc : Test fast sink deinit
82 */
83 HWTEST_F(FastAudioRenderSinkUnitTest, FastSinkUnitTest_002, TestSize.Level1)
84 {
85 EXPECT_TRUE(sink_);
86 if (sink_->IsInited()) {
87 sink_->DeInit();
88 }
89 EXPECT_FALSE(sink_->IsInited());
90 }
91
92 /**
93 * @tc.name : Test FastSink API
94 * @tc.number : FastSinkUnitTest_003
95 * @tc.desc : Test fast sink start, stop, resume, pause, flush, reset
96 */
97 HWTEST_F(FastAudioRenderSinkUnitTest, FastSinkUnitTest_003, TestSize.Level1)
98 {
99 EXPECT_TRUE(sink_);
100 int32_t ret = sink_->Start();
101 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
102 ret = sink_->Stop();
103 EXPECT_EQ(ret, SUCCESS);
104 ret = sink_->Resume();
105 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
106 ret = sink_->Pause();
107 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
108 ret = sink_->Flush();
109 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
110 ret = sink_->Reset();
111 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
112 ret = sink_->Stop();
113 EXPECT_EQ(ret, SUCCESS);
114 }
115
116 /**
117 * @tc.name : Test FastSink API
118 * @tc.number : FastSinkUnitTest_004
119 * @tc.desc : Test fast sink set/get volume
120 */
121 HWTEST_F(FastAudioRenderSinkUnitTest, FastSinkUnitTest_004, TestSize.Level1)
122 {
123 EXPECT_TRUE(sink_);
124 int32_t ret = sink_->SetVolume(0.0f, 0.0f);
125 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
126 ret = sink_->SetVolume(0.0f, 1.0f);
127 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
128 ret = sink_->SetVolume(1.0f, 0.0f);
129 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
130 ret = sink_->SetVolume(1.0f, 1.0f);
131 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
132 float left;
133 float right;
134 ret = sink_->GetVolume(left, right);
135 EXPECT_EQ(ret, SUCCESS);
136 }
137
138 /**
139 * @tc.name : Test FastSink API
140 * @tc.number : FastSinkUnitTest_005
141 * @tc.desc : Test fast sink set audio scene
142 */
143 HWTEST_F(FastAudioRenderSinkUnitTest, FastSinkUnitTest_005, TestSize.Level1)
144 {
145 EXPECT_TRUE(sink_);
146 std::vector<DeviceType> deviceTypes = { DEVICE_TYPE_SPEAKER };
147 int32_t ret = sink_->SetAudioScene(AUDIO_SCENE_DEFAULT, deviceTypes);
148 EXPECT_EQ(ret, SUCCESS);
149 }
150
151 /**
152 * @tc.name : Test FastSink API
153 * @tc.number : FastSinkUnitTest_006
154 * @tc.desc : Test fast sink update active device
155 */
156 HWTEST_F(FastAudioRenderSinkUnitTest, FastSinkUnitTest_006, TestSize.Level1)
157 {
158 EXPECT_TRUE(sink_);
159 std::vector<DeviceType> deviceTypes = { DEVICE_TYPE_SPEAKER };
160 int32_t ret = sink_->UpdateActiveDevice(deviceTypes);
161 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
162 }
163
164 /**
165 * @tc.name : Test FastSink API
166 * @tc.number : FastSinkUnitTest_007
167 * @tc.desc : Test fast sink update apps uid
168 */
169 HWTEST_F(FastAudioRenderSinkUnitTest, FastSinkUnitTest_007, TestSize.Level1)
170 {
171 EXPECT_TRUE(sink_);
172 vector<int32_t> appsUid;
173 int32_t ret = sink_->UpdateAppsUid(appsUid);
174 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
175 }
176
177 } // namespace AudioStandard
178 } // namespace OHOS
179