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 RemoteAudioCaptureSourceUnitTest : 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<IAudioCaptureSource> source_;
37 static IAudioSourceAttr attr_;
38 };
39
40 uint32_t RemoteAudioCaptureSourceUnitTest::id_ = HDI_INVALID_ID;
41 std::shared_ptr<IAudioCaptureSource> RemoteAudioCaptureSourceUnitTest::source_ = nullptr;
42 IAudioSourceAttr RemoteAudioCaptureSourceUnitTest::attr_ = {};
43
SetUpTestCase()44 void RemoteAudioCaptureSourceUnitTest::SetUpTestCase()
45 {
46 id_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_CAPTURE, HDI_ID_TYPE_REMOTE, "test", true);
47 }
48
TearDownTestCase()49 void RemoteAudioCaptureSourceUnitTest::TearDownTestCase()
50 {
51 HdiAdapterManager::GetInstance().ReleaseId(id_);
52 }
53
SetUp()54 void RemoteAudioCaptureSourceUnitTest::SetUp()
55 {
56 source_ = HdiAdapterManager::GetInstance().GetCaptureSource(id_, true);
57 if (source_ == nullptr) {
58 return;
59 }
60 attr_.adapterName = "test";
61 attr_.channel = 2; // 2: channel
62 source_->Init(attr_);
63 }
64
TearDown()65 void RemoteAudioCaptureSourceUnitTest::TearDown()
66 {
67 if (source_ && source_->IsInited()) {
68 source_->DeInit();
69 }
70 source_ = nullptr;
71 }
72
73 /**
74 * @tc.name : Test RemoteSource API
75 * @tc.number : RemoteSourceUnitTest_001
76 * @tc.desc : Test remote source create
77 */
78 HWTEST_F(RemoteAudioCaptureSourceUnitTest, RemoteSourceUnitTest_001, TestSize.Level1)
79 {
80 EXPECT_TRUE(source_ && source_->IsInited());
81 }
82
83 /**
84 * @tc.name : Test RemoteSource API
85 * @tc.number : RemoteSourceUnitTest_002
86 * @tc.desc : Test remote source init
87 */
88 HWTEST_F(RemoteAudioCaptureSourceUnitTest, RemoteSourceUnitTest_002, TestSize.Level1)
89 {
90 EXPECT_TRUE(source_ && source_->IsInited());
91 source_->DeInit();
92 int32_t ret = source_->Init(attr_);
93 EXPECT_EQ(ret, SUCCESS);
94 ret = source_->Init(attr_);
95 EXPECT_EQ(ret, SUCCESS);
96 EXPECT_TRUE(source_->IsInited());
97 }
98
99 /**
100 * @tc.name : Test RemoteSource API
101 * @tc.number : RemoteSourceUnitTest_003
102 * @tc.desc : Test remote source start, stop, resume, pause, flush, reset
103 */
104 HWTEST_F(RemoteAudioCaptureSourceUnitTest, RemoteSourceUnitTest_003, TestSize.Level1)
105 {
106 EXPECT_TRUE(source_);
107 int32_t ret = source_->Start();
108 EXPECT_EQ(ret, ERR_NOT_STARTED);
109 ret = source_->Stop();
110 EXPECT_EQ(ret, SUCCESS);
111 ret = source_->Resume();
112 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
113 ret = source_->Pause();
114 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
115 ret = source_->Flush();
116 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
117 ret = source_->Reset();
118 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
119 ret = source_->Stop();
120 EXPECT_EQ(ret, SUCCESS);
121 }
122
123 /**
124 * @tc.name : Test RemoteSource API
125 * @tc.number : RemoteSourceUnitTest_004
126 * @tc.desc : Test remote source capture frame
127 */
128 HWTEST_F(RemoteAudioCaptureSourceUnitTest, RemoteSourceUnitTest_004, TestSize.Level1)
129 {
130 EXPECT_TRUE(source_ && source_->IsInited());
131 char *buffer = nullptr;
132 uint64_t requestBytes = 0;
133 uint64_t replyBytes = 0;
134 int32_t ret = source_->CaptureFrame(buffer, requestBytes, replyBytes);
135 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
136 }
137
138 /**
139 * @tc.name : Test RemoteSource API
140 * @tc.number : RemoteSourceUnitTest_005
141 * @tc.desc : Test remote source set/get volume
142 */
143 HWTEST_F(RemoteAudioCaptureSourceUnitTest, RemoteSourceUnitTest_005, TestSize.Level1)
144 {
145 EXPECT_TRUE(source_ && source_->IsInited());
146 int32_t ret = source_->SetVolume(0.0f, 0.0f);
147 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
148 ret = source_->SetVolume(0.0f, 1.0f);
149 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
150 ret = source_->SetVolume(1.0f, 0.0f);
151 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
152 ret = source_->SetVolume(1.0f, 1.0f);
153 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
154 float left;
155 float right;
156 ret = source_->GetVolume(left, right);
157 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
158 }
159
160 /**
161 * @tc.name : Test RemoteSource API
162 * @tc.number : RemoteSourceUnitTest_006
163 * @tc.desc : Test remote source set/get mute
164 */
165 HWTEST_F(RemoteAudioCaptureSourceUnitTest, RemoteSourceUnitTest_006, TestSize.Level1)
166 {
167 EXPECT_TRUE(source_ && source_->IsInited());
168 int32_t ret = source_->SetMute(false);
169 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
170 bool isMute;
171 ret = source_->GetMute(isMute);
172 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
173 }
174
175 /**
176 * @tc.name : Test RemoteSource API
177 * @tc.number : RemoteSourceUnitTest_007
178 * @tc.desc : Test remote source set audio scene
179 */
180 HWTEST_F(RemoteAudioCaptureSourceUnitTest, RemoteSourceUnitTest_007, TestSize.Level1)
181 {
182 EXPECT_TRUE(source_ && source_->IsInited());
183 int32_t ret = source_->SetAudioScene(AUDIO_SCENE_DEFAULT, DEVICE_TYPE_SPEAKER);
184 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
185 }
186
187 /**
188 * @tc.name : Test RemoteSource API
189 * @tc.number : RemoteSourceUnitTest_008
190 * @tc.desc : Test remote source update active device
191 */
192 HWTEST_F(RemoteAudioCaptureSourceUnitTest, RemoteSourceUnitTest_008, TestSize.Level1)
193 {
194 EXPECT_TRUE(source_ && source_->IsInited());
195 int32_t ret = source_->UpdateActiveDevice(DEVICE_TYPE_SPEAKER);
196 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
197 }
198
199 } // namespace AudioStandard
200 } // namespace OHOS
201