1 /*
2 * Copyright (c) 2022 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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include "audio_proxy_common_fun_test.h"
19 #include "audio_proxy_internal.h"
20
21 using namespace std;
22 using namespace comfun;
23 using namespace testing::ext;
24 namespace {
25 class AudioProxyAdapterTest : public testing::Test {
26 public:
27 struct AudioManager *managerFuncs = nullptr;
28 struct AudioAdapterDescriptor *descs = nullptr;
29 struct AudioAdapterDescriptor *desc = nullptr;
30 struct AudioAdapter *adapter = nullptr;
31 struct AudioRender *render = nullptr;
32 struct AudioCapture *capture = nullptr;
33 struct AudioDeviceDescriptor devDescRender = {};
34 struct AudioSampleAttributes attrsRender = {};
35 struct AudioDeviceDescriptor devDescCapture = {};
36 struct AudioSampleAttributes attrsCapture = {};
37 virtual void SetUp();
38 virtual void TearDown();
39 };
40
SetUp()41 void AudioProxyAdapterTest::SetUp()
42 {
43 managerFuncs = GetAudioManagerFuncs();
44 ASSERT_NE(managerFuncs, nullptr);
45 int32_t size = 0;
46 ASSERT_EQ(HDF_SUCCESS, managerFuncs->GetAllAdapters(managerFuncs, &descs, &size));
47 desc = &descs[0];
48 ASSERT_EQ(HDF_SUCCESS, managerFuncs->LoadAdapter(managerFuncs, desc, &adapter));
49 ASSERT_NE(adapter, nullptr);
50 ASSERT_EQ(HDF_SUCCESS, InitDevDesc(devDescRender));
51 ASSERT_EQ(HDF_SUCCESS, InitAttrs(attrsRender));
52 ASSERT_EQ(HDF_SUCCESS, adapter->CreateRender(adapter, &devDescRender, &attrsRender, &render));
53
54 ASSERT_EQ(HDF_SUCCESS, InitDevDescCapture(devDescCapture));
55 ASSERT_EQ(HDF_SUCCESS, InitAttrsCapture(attrsCapture));
56 ASSERT_EQ(HDF_SUCCESS, adapter->CreateCapture(adapter, &devDescCapture, &attrsCapture, &capture));
57 }
58
TearDown()59 void AudioProxyAdapterTest::TearDown()
60 {
61 if (adapter != nullptr) {
62 adapter->DestroyRender(adapter, render);
63 render = nullptr;
64 adapter->DestroyCapture(adapter, capture);
65 capture = nullptr;
66 }
67 if (managerFuncs != nullptr) {
68 managerFuncs->UnloadAdapter(managerFuncs, adapter);
69 adapter = nullptr;
70 managerFuncs->ReleaseAudioManagerObject(managerFuncs);
71 managerFuncs = nullptr;
72 }
73 }
74
75 HWTEST_F(AudioProxyAdapterTest, AdapterGetPortCapability_001, TestSize.Level1)
76 {
77 ASSERT_NE(adapter, nullptr);
78 const struct AudioPort *port = nullptr;
79 struct AudioPortCapability capability;
80 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, adapter->GetPortCapability(nullptr, port, &capability));
81 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, adapter->GetPortCapability(adapter, nullptr, &capability));
82 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, adapter->GetPortCapability(adapter, port, nullptr));
83 }
84
85 HWTEST_F(AudioProxyAdapterTest, AdapterGetPortCapability_002, TestSize.Level1)
86 {
87 ASSERT_NE(adapter, nullptr);
88 struct AudioPort port = {
89 .dir = PORT_OUT,
90 .portId = 0,
91 .portName = "AOP",
92 };
93 struct AudioPortCapability capability;
94 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
95 struct HdfRemoteService *proxyRemoteHandle = hwAdapter->proxyRemoteHandle;
96 hwAdapter->proxyRemoteHandle = nullptr;
97 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, adapter->GetPortCapability(adapter, &port, &capability));
98 hwAdapter->proxyRemoteHandle = proxyRemoteHandle;
99 }
100
101 HWTEST_F(AudioProxyAdapterTest, AdapterGetPortCapability_003, TestSize.Level1)
102 {
103 ASSERT_NE(adapter, nullptr);
104 struct AudioPort port = {
105 .dir = PORT_OUT,
106 .portId = 0,
107 .portName = "AOP",
108 };
109 struct AudioPortCapability capability;
110 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
111 struct AudioPortAndCapability *hwAdapterPortCapabilitys = hwAdapter->portCapabilitys;
112 hwAdapter->portCapabilitys = nullptr;
113 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, adapter->GetPortCapability(adapter, &port, &capability));
114 hwAdapter->portCapabilitys = hwAdapterPortCapabilitys;
115 }
116
117 HWTEST_F(AudioProxyAdapterTest, AdapterGetPortCapability_004, TestSize.Level1)
118 {
119 ASSERT_NE(adapter, nullptr);
120 struct AudioPort port = {
121 .dir = PORT_OUT,
122 .portId = 0,
123 .portName = "AOP",
124 };
125 struct AudioPortCapability capability;
126 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
127 int32_t portNum = hwAdapter->adapterDescriptor.portNum;
128 hwAdapter->adapterDescriptor.portNum = 0;
129 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, adapter->GetPortCapability(adapter, &port, &capability));
130 hwAdapter->adapterDescriptor.portNum = portNum;
131 }
132
133 HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_001, TestSize.Level1)
134 {
135 ASSERT_NE(adapter, nullptr);
136 struct AudioPort port = {
137 .dir = PORT_OUT,
138 .portId = 0,
139 .portName = "AOP",
140 };
141 int32_t ret = adapter->SetPassthroughMode(nullptr, &port, PORT_PASSTHROUGH_LPCM);
142 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
143 ret = adapter->SetPassthroughMode(adapter, nullptr, PORT_PASSTHROUGH_LPCM);
144 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
145 port.portName = nullptr;
146 ret = adapter->SetPassthroughMode(adapter, &port, PORT_PASSTHROUGH_LPCM);
147 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
148 }
149
150 HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_002, TestSize.Level1)
151 {
152 ASSERT_NE(adapter, nullptr);
153 struct AudioPort port;
154 port.dir = PORT_IN;
155 port.portName = nullptr;
156 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
157 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, adapter->SetPassthroughMode(adapter, &port, mode));
158 }
159
160 HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_003, TestSize.Level1)
161 {
162 ASSERT_NE(adapter, nullptr);
163 int32_t ret = adapter->InitAllPorts(adapter);
164 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
165 struct AudioPort port;
166 port.dir = PORT_OUT;
167 port.portId = 0;
168 port.portName = "AOP";
169 ret = adapter->SetPassthroughMode(adapter, &port, PORT_PASSTHROUGH_LPCM);
170 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
171 }
172
173 HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_004, TestSize.Level1)
174 {
175 ASSERT_NE(adapter, nullptr);
176 struct AudioPort port;
177 port.dir = PORT_OUT;
178 port.portId = 1;
179 port.portName = "abc";
180 int32_t ret = adapter->SetPassthroughMode(adapter, &port, PORT_PASSTHROUGH_LPCM);
181 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
182 }
183
184 HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_001, TestSize.Level1)
185 {
186 ASSERT_NE(adapter, nullptr);
187 struct AudioPort port;
188 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, adapter->GetPassthroughMode(nullptr, &port, nullptr));
189 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, adapter->GetPassthroughMode(adapter, nullptr, nullptr));
190 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, adapter->GetPassthroughMode(adapter, &port, nullptr));
191 port.portName = nullptr;
192 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, adapter->GetPassthroughMode(adapter, &port, nullptr));
193 }
194
195 HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_002, TestSize.Level1)
196 {
197 ASSERT_NE(adapter, nullptr);
198 struct AudioPort port;
199 port.dir = PORT_IN;
200 port.portId = 1;
201 port.portName = "abc";
202 AudioPortPassthroughMode mode;
203 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, adapter->GetPassthroughMode(adapter, &port, &mode));
204 }
205
206 HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_003, TestSize.Level1)
207 {
208 ASSERT_NE(adapter, nullptr);
209 struct AudioPort *port = new AudioPort;
210 port->dir = PORT_OUT;
211 port->portId = 0;
212 port->portName = "AOP";
213 AudioPortPassthroughMode mode;
214 EXPECT_EQ(AUDIO_HAL_SUCCESS, adapter->InitAllPorts(adapter));
215 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, adapter->GetPassthroughMode(adapter, port, &mode));
216 delete port;
217 port = nullptr;
218 }
219
220 HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_004, TestSize.Level1)
221 {
222 ASSERT_NE(adapter, nullptr);
223 struct AudioPort port;
224 port.dir = PORT_OUT;
225 port.portId = 1;
226 port.portName = "abc";
227 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
228 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, adapter->GetPassthroughMode(adapter, &port, &mode));
229 }
230 }
231