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 "audio_microphone_descriptor_unit_test.h"
17 #include "audio_microphone_descriptor.h"
18
19 using namespace testing::ext;
20
21 namespace OHOS {
22 namespace AudioStandard {
23
24 static AudioGlobalConfigManager audioGlobalConfigManager_ = AudioGlobalConfigManager::GetAudioGlobalConfigManager();
SetUpTestCase(void)25 void AudioMicrophoneDescriptorUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)26 void AudioMicrophoneDescriptorUnitTest::TearDownTestCase(void) {}
SetUp(void)27 void AudioMicrophoneDescriptorUnitTest::SetUp(void) {}
TearDown(void)28 void AudioMicrophoneDescriptorUnitTest::TearDown(void) {}
29
30 /**
31 * @tc.name : Test SetMicrophoneMutePersistent.
32 * @tc.number: SetMicrophoneMutePersistent_001
33 * @tc.desc : Test AudioPolicyService interfaces.
34 */
35 HWTEST_F(AudioMicrophoneDescriptorUnitTest, SetMicrophoneMutePersistent_001, TestSize.Level4)
36 {
37 std::shared_ptr<AudioMicrophoneDescriptor> descriptor = std::make_shared<AudioMicrophoneDescriptor>();
38
39 bool isMute = false;
40 descriptor->isMicrophoneMutePersistent_ = false;
41 descriptor->isMicrophoneMuteTemporary_ = false;
42 int32_t ret = descriptor->SetMicrophoneMutePersistent(isMute);
43
44 EXPECT_NE(ret, SUCCESS);
45 }
46
47 /**
48 * @tc.name : Test SetMicrophoneMutePersistent success when all dependencies succeed
49 * @tc.number: SetMicrophoneMutePersistent_002
50 * @tc.desc : Verify SetMicrophoneMutePersistent returns SUCCESS when both proxy and persist succeed
51 */
52 HWTEST_F(AudioMicrophoneDescriptorUnitTest, SetMicrophoneMutePersistent_002, TestSize.Level4)
53 {
54 std::shared_ptr<AudioMicrophoneDescriptor> descriptor = std::make_shared<AudioMicrophoneDescriptor>();
55
56 bool isMute = true;
57 descriptor->isMicrophoneMutePersistent_ = false;
58 descriptor->isMicrophoneMuteTemporary_ = false;
59 int32_t ret = descriptor->SetMicrophoneMutePersistent(isMute);
60 EXPECT_NE(ret, SUCCESS);
61 }
62
63 /**
64 * @tc.name : Test SetMicrophoneMute failure path.
65 * @tc.number: SetMicrophoneMute_001
66 * @tc.desc : Test AudioPolicyService interfaces with failing dependency.
67 */
68 HWTEST_F(AudioMicrophoneDescriptorUnitTest, SetMicrophoneMute_001, TestSize.Level4)
69 {
70 std::shared_ptr<AudioMicrophoneDescriptor> descriptor = std::make_shared<AudioMicrophoneDescriptor>();
71
72 bool isMute = true;
73 descriptor->isMicrophoneMutePersistent_ = false;
74 int32_t ret = descriptor->SetMicrophoneMute(isMute);
75
76 EXPECT_EQ(ret, SUCCESS);
77 }
78
79
80 /**
81 * @tc.name : Test InitPersistentMicrophoneMuteState failure path.
82 * @tc.number: InitPersistentMicrophoneMuteState_001
83 * @tc.desc : Test AudioPolicyService interfaces with failing dependency while getting persistent mute state.
84 */
85 HWTEST_F(AudioMicrophoneDescriptorUnitTest, InitPersistentMicrophoneMuteState_001, TestSize.Level4)
86 {
87 std::shared_ptr<AudioMicrophoneDescriptor> descriptor = std::make_shared<AudioMicrophoneDescriptor>();
88
89 bool isMute = false;
90 int32_t ret = descriptor->InitPersistentMicrophoneMuteState(isMute);
91
92 EXPECT_EQ(ret, ERROR);
93 }
94
95 /**
96 * @tc.name : Test GetMicrophoneMuteTemporary and GetMicrophoneMutePersistent.
97 * @tc.number: GetMicrophoneMuteState_001
98 * @tc.desc : Verify getter methods return correct values.
99 */
100 HWTEST_F(AudioMicrophoneDescriptorUnitTest, GetMicrophoneMuteState_001, TestSize.Level4)
101 {
102 std::shared_ptr<AudioMicrophoneDescriptor> descriptor = std::make_shared<AudioMicrophoneDescriptor>();
103
104 descriptor->isMicrophoneMuteTemporary_ = true;
105 descriptor->isMicrophoneMutePersistent_ = false;
106
107 EXPECT_TRUE(descriptor->GetMicrophoneMuteTemporary());
108 EXPECT_FALSE(descriptor->GetMicrophoneMutePersistent());
109
110 descriptor->isMicrophoneMuteTemporary_ = false;
111 descriptor->isMicrophoneMutePersistent_ = true;
112
113 EXPECT_FALSE(descriptor->GetMicrophoneMuteTemporary());
114 EXPECT_TRUE(descriptor->GetMicrophoneMutePersistent());
115 }
116
117 /**
118 * @tc.name : Test AddAudioCapturerMicrophoneDescriptor with DEVICE_TYPE_NONE.
119 * @tc.number: AddAudioCapturerMicrophoneDescriptor_001
120 * @tc.desc : Verify that an invalid microphone descriptor is added when devType is DEVICE_TYPE_NONE.
121 */
122 HWTEST_F(AudioMicrophoneDescriptorUnitTest, AddAudioCapturerMicrophoneDescriptor_001, TestSize.Level4)
123 {
124 std::shared_ptr<AudioMicrophoneDescriptor> descriptor = std::make_shared<AudioMicrophoneDescriptor>();
125
126 DeviceType devType = DeviceType::DEVICE_TYPE_NONE;
127 int32_t sessionId = 0;
128
129 descriptor->AddAudioCapturerMicrophoneDescriptor(sessionId, devType);
130 auto& descriptorMap = descriptor->audioCaptureMicrophoneDescriptor_;
131 auto it = descriptorMap.find(sessionId);
132 ASSERT_NE(it, descriptorMap.end());
133
134 auto desc = it->second;
135 EXPECT_EQ(desc->deviceType_, DEVICE_TYPE_INVALID);
136 }
137
138 /**
139 * @tc.name : Test AddAudioCapturerMicrophoneDescriptor with matching device type.
140 * @tc.number: AddAudioCapturerMicrophoneDescriptor_002
141 * @tc.desc : Verify that the correct microphone descriptor is added when a matching device is found.
142 */
143 HWTEST_F(AudioMicrophoneDescriptorUnitTest, AddAudioCapturerMicrophoneDescriptor_002, TestSize.Level4)
144 {
145 std::shared_ptr<AudioMicrophoneDescriptor> descriptor = std::make_shared<AudioMicrophoneDescriptor>();
146
147 sptr<MicrophoneDescriptor> mockMic = new MicrophoneDescriptor(1, DEVICE_TYPE_MIC);
148 descriptor->connectedMicrophones_.clear();
149 descriptor->connectedMicrophones_.push_back(mockMic);
150
151 int32_t testSessionId = 1002;
152 DeviceType devType = DEVICE_TYPE_MIC;
153
154 descriptor->AddAudioCapturerMicrophoneDescriptor(testSessionId, devType);
155
156 auto& descriptorMap =descriptor->audioCaptureMicrophoneDescriptor_;
157 auto it = descriptorMap.find(testSessionId);
158 ASSERT_NE(it, descriptorMap.end());
159 EXPECT_EQ(it->second, mockMic);
160 }
161
162 /**
163 * @tc.name : Test AddAudioCapturerMicrophoneDescriptor with no matching device.
164 * @tc.number: AddAudioCapturerMicrophoneDescriptor_003
165 * @tc.desc : Verify that no descriptor is added when no connected microphone matches the device type.
166 */
167 HWTEST_F(AudioMicrophoneDescriptorUnitTest, AddAudioCapturerMicrophoneDescriptor_003, TestSize.Level4)
168 {
169 std::shared_ptr<AudioMicrophoneDescriptor> descriptor = std::make_shared<AudioMicrophoneDescriptor>();
170
171 sptr<MicrophoneDescriptor> mockMic = new MicrophoneDescriptor(1, DEVICE_TYPE_MIC);
172 descriptor->connectedMicrophones_.clear();
173 descriptor->connectedMicrophones_.push_back(mockMic);
174
175 int32_t testSessionId = 1003;
176 DeviceType devType = DEVICE_TYPE_USB_HEADSET;
177
178 descriptor->AddAudioCapturerMicrophoneDescriptor(testSessionId, devType);
179
180 auto& descriptorMap = descriptor->audioCaptureMicrophoneDescriptor_;
181 auto it = descriptorMap.find(testSessionId);
182 EXPECT_EQ(it, descriptorMap.end());
183 }
184
185 /**
186 * @tc.name : Test RemoveAudioCapturerMicrophoneDescriptor with matching UIDs.
187 * @tc.number: RemoveAudioCapturerMicrophoneDescriptor_001
188 * @tc.desc : Verify that microphone descriptors are removed only when clientUID or createrUID matches the input UID.
189 */
190 HWTEST_F(AudioMicrophoneDescriptorUnitTest, RemoveAudioCapturerMicrophoneDescriptor_001, TestSize.Level4)
191 {
192 std::shared_ptr<AudioMicrophoneDescriptor> descriptor = std::make_shared<AudioMicrophoneDescriptor>();
193
194 const int32_t kSessionId = 8001;
195
196 descriptor->AddAudioCapturerMicrophoneDescriptor(kSessionId, AudioStandard::DEVICE_TYPE_MIC);
197 descriptor->RemoveAudioCapturerMicrophoneDescriptorBySessionID(kSessionId);
198
199 auto& map = descriptor->audioCaptureMicrophoneDescriptor_;
200 EXPECT_EQ(map.find(kSessionId), map.end());
201 }
202
203 /**
204 * @tc.name : Test GetAudioCapturerMicrophoneDescriptors with existing sessionId.
205 * @tc.number: GetAudioCapturerMicrophoneDescriptors_001
206 * @tc.desc : Verify that the microphone descriptor is returned when sessionId exists.
207 */
208 HWTEST_F(AudioMicrophoneDescriptorUnitTest, GetAudioCapturerMicrophoneDescriptors_001, TestSize.Level4)
209 {
210 std::shared_ptr<AudioMicrophoneDescriptor> descriptor = std::make_shared<AudioMicrophoneDescriptor>();
211
212 int32_t sessionId = 12345;
213 sptr<MicrophoneDescriptor> expectedDesc = new MicrophoneDescriptor(1, DEVICE_TYPE_EARPIECE);
214 descriptor->audioCaptureMicrophoneDescriptor_[sessionId] = expectedDesc;
215
216 std::vector<sptr<MicrophoneDescriptor>> result = descriptor->GetAudioCapturerMicrophoneDescriptors(sessionId);
217
218 EXPECT_EQ(result.size(), 1);
219 EXPECT_EQ(result[0]->deviceType_, expectedDesc->deviceType_);
220 }
221
222 /**
223 * @tc.name : Test GetAudioCapturerMicrophoneDescriptors with non-existing sessionId.
224 * @tc.number: GetAudioCapturerMicrophoneDescriptors_002
225 * @tc.desc : Verify that an empty list is returned when sessionId does not exist.
226 */
227 HWTEST_F(AudioMicrophoneDescriptorUnitTest, GetAudioCapturerMicrophoneDescriptors_002, TestSize.Level4)
228 {
229 std::shared_ptr<AudioMicrophoneDescriptor> descriptor = std::make_shared<AudioMicrophoneDescriptor>();
230
231 int32_t sessionId = 99999;
232
233 std::vector<sptr<MicrophoneDescriptor>> result = descriptor->GetAudioCapturerMicrophoneDescriptors(sessionId);
234
235 EXPECT_TRUE(result.empty());
236 }
237
238 /**
239 * @tc.name : Test RemoveAudioCapturerMicrophoneDescriptor_NoMatch
240 * @tc.number: RemoveAudioCapturerMicrophoneDescriptor_002
241 * @tc.desc : Test that no descriptor is removed when no capturer matches the UID
242 */
243 HWTEST_F(AudioMicrophoneDescriptorUnitTest, RemoveAudioCapturerMicrophoneDescriptor_002, TestSize.Level4)
244 {
245 std::shared_ptr<AudioMicrophoneDescriptor> descriptor = std::make_shared<AudioMicrophoneDescriptor>();
246 std::shared_ptr<AudioCapturerChangeInfo> info = std::make_shared<AudioCapturerChangeInfo>();
247 info->clientUID = 1;
248 info->createrUID = 1;
249 info->sessionId = 1;
250 descriptor->audioCaptureMicrophoneDescriptor_[1] = new OHOS::AudioStandard::MicrophoneDescriptor();
251 AudioStreamCollector::GetAudioStreamCollector().audioCapturerChangeInfos_.push_back(info);
252 int32_t uid = 1;
253 descriptor->RemoveAudioCapturerMicrophoneDescriptor(uid);
254 uid = 2;
255 descriptor->RemoveAudioCapturerMicrophoneDescriptor(uid);
256 info->createrUID = 2;
257 descriptor->RemoveAudioCapturerMicrophoneDescriptor(uid);
258 uid = 1;
259 descriptor->RemoveAudioCapturerMicrophoneDescriptor(uid);
260 EXPECT_TRUE(descriptor->audioCaptureMicrophoneDescriptor_.empty());
261 }
262 }
263 }