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 OffloadAudioRenderSinkUnitTest : 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 OffloadAudioRenderSinkUnitTest::id_ = HDI_INVALID_ID;
41 std::shared_ptr<IAudioRenderSink> OffloadAudioRenderSinkUnitTest::sink_ = nullptr;
42 IAudioSinkAttr OffloadAudioRenderSinkUnitTest::attr_ = {};
43
SetUpTestCase()44 void OffloadAudioRenderSinkUnitTest::SetUpTestCase()
45 {
46 id_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_OFFLOAD, HDI_ID_INFO_DEFAULT, true);
47 }
48
TearDownTestCase()49 void OffloadAudioRenderSinkUnitTest::TearDownTestCase()
50 {
51 HdiAdapterManager::GetInstance().ReleaseId(id_);
52 }
53
SetUp()54 void OffloadAudioRenderSinkUnitTest::SetUp()
55 {
56 sink_ = HdiAdapterManager::GetInstance().GetRenderSink(id_, true);
57 if (sink_ == nullptr) {
58 return;
59 }
60 }
61
TearDown()62 void OffloadAudioRenderSinkUnitTest::TearDown()
63 {
64 sink_ = nullptr;
65 }
66
67 /**
68 * @tc.name : Test OffloadSink API
69 * @tc.number : OffloadSinkUnitTest_001
70 * @tc.desc : Test offload sink create
71 */
72 HWTEST_F(OffloadAudioRenderSinkUnitTest, OffloadSinkUnitTest_001, TestSize.Level1)
73 {
74 EXPECT_TRUE(sink_);
75 }
76
77 /**
78 * @tc.name : Test OffloadSink API
79 * @tc.number : OffloadSinkUnitTest_002
80 * @tc.desc : Test offload sink deinit
81 */
82 HWTEST_F(OffloadAudioRenderSinkUnitTest, OffloadSinkUnitTest_002, TestSize.Level1)
83 {
84 EXPECT_TRUE(sink_);
85 if (sink_->IsInited()) {
86 sink_->DeInit();
87 }
88 EXPECT_FALSE(sink_->IsInited());
89 }
90
91 /**
92 * @tc.name : Test OffloadSink API
93 * @tc.number : OffloadSinkUnitTest_003
94 * @tc.desc : Test offload sink start, stop, resume, pause, flush, reset
95 */
96 HWTEST_F(OffloadAudioRenderSinkUnitTest, OffloadSinkUnitTest_003, TestSize.Level1)
97 {
98 EXPECT_TRUE(sink_);
99 int32_t ret = sink_->Start();
100 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
101 ret = sink_->Stop();
102 EXPECT_EQ(ret, SUCCESS);
103 ret = sink_->Resume();
104 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
105 ret = sink_->Pause();
106 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
107 ret = sink_->Flush();
108 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
109 ret = sink_->Reset();
110 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
111 ret = sink_->Stop();
112 EXPECT_EQ(ret, SUCCESS);
113 }
114
115 /**
116 * @tc.name : Test OffloadSink API
117 * @tc.number : OffloadSinkUnitTest_004
118 * @tc.desc : Test offload sink set/get volume
119 */
120 HWTEST_F(OffloadAudioRenderSinkUnitTest, OffloadSinkUnitTest_004, TestSize.Level1)
121 {
122 EXPECT_TRUE(sink_);
123 int32_t ret = sink_->SetVolume(0.0f, 0.0f);
124 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
125 ret = sink_->SetVolume(0.0f, 1.0f);
126 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
127 ret = sink_->SetVolume(1.0f, 0.0f);
128 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
129 ret = sink_->SetVolume(1.0f, 1.0f);
130 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
131 float left;
132 float right;
133 ret = sink_->GetVolume(left, right);
134 EXPECT_EQ(ret, SUCCESS);
135 }
136
137 /**
138 * @tc.name : Test OffloadSink API
139 * @tc.number : OffloadSinkUnitTest_005
140 * @tc.desc : Test offload sink set audio scene
141 */
142 HWTEST_F(OffloadAudioRenderSinkUnitTest, OffloadSinkUnitTest_005, TestSize.Level1)
143 {
144 EXPECT_TRUE(sink_);
145 std::vector<DeviceType> deviceTypes = { DEVICE_TYPE_SPEAKER };
146 int32_t ret = sink_->SetAudioScene(AUDIO_SCENE_DEFAULT, deviceTypes);
147 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
148 }
149
150 /**
151 * @tc.name : Test OffloadSink API
152 * @tc.number : OffloadSinkUnitTest_006
153 * @tc.desc : Test offload sink update active device
154 */
155 HWTEST_F(OffloadAudioRenderSinkUnitTest, OffloadSinkUnitTest_006, TestSize.Level1)
156 {
157 EXPECT_TRUE(sink_);
158 std::vector<DeviceType> deviceTypes = { DEVICE_TYPE_SPEAKER };
159 int32_t ret = sink_->UpdateActiveDevice(deviceTypes);
160 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
161 }
162
163 } // namespace AudioStandard
164 } // namespace OHOS
165