1 /* mixer_test.c
2 **
3 ** Copyright 2020, The Android Open Source Project
4 **
5 ** Redistribution and use in source and binary forms, with or without
6 ** modification, are permitted provided that the following conditions are met:
7 ** * Redistributions of source code must retain the above copyright
8 ** notice, this list of conditions and the following disclaimer.
9 ** * Redistributions in binary form must reproduce the above copyright
10 ** notice, this list of conditions and the following disclaimer in the
11 ** documentation and/or other materials provided with the distribution.
12 ** * Neither the name of The Android Open Source Project nor the names of
13 ** its contributors may be used to endorse or promote products derived
14 ** from this software without specific prior written permission.
15 **
16 ** THIS SOFTWARE IS PROVIDED BY The Android Open Source Project ``AS IS'' AND
17 ** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 ** ARE DISCLAIMED. IN NO EVENT SHALL The Android Open Source Project BE LIABLE
20 ** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23 ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 ** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
26 ** DAMAGE.
27 */
28 #include "pcm_test_device.h"
29
30 #include <limits>
31 #include <string_view>
32 #include <string>
33 #include <thread>
34 #include <type_traits>
35 #include <unordered_map>
36 #include <unordered_set>
37
38 #include <gtest/gtest.h>
39
40 #include "tinyalsa/mixer.h"
41
42 namespace tinyalsa {
43 namespace testing {
44
45 #ifndef MAX_CARD_INDEX
46 #define MAX_CARD_INDEX 2
47 #endif
48
49 static constexpr unsigned int kMaxCardIndex = MAX_CARD_INDEX;
50
51 static constexpr int k100Percent = 100;
52 static constexpr int k0Percent = 0;
53
TEST(MixerTest,OpenAndClose)54 TEST(MixerTest, OpenAndClose) {
55 // assume card 0 is always probed.
56 mixer *mixer_object = mixer_open(0);
57 EXPECT_NE(mixer_object, nullptr);
58 mixer_close(mixer_object);
59 }
60
TEST(MixerTest,NullParametersCheck)61 TEST(MixerTest, NullParametersCheck) {
62 EXPECT_EQ(mixer_open(1000), nullptr);
63 mixer_close(nullptr);
64 EXPECT_EQ(mixer_add_new_ctls(nullptr), 0);
65 EXPECT_EQ(mixer_get_name(nullptr), nullptr);
66 EXPECT_EQ(mixer_get_num_ctls(nullptr), 0);
67 EXPECT_EQ(mixer_get_num_ctls_by_name(nullptr, ""), 0);
68 EXPECT_EQ(mixer_get_num_ctls_by_name(reinterpret_cast<const mixer *>(1), nullptr), 0);
69 EXPECT_EQ(mixer_get_ctl_const(nullptr, 0), nullptr);
70 EXPECT_EQ(mixer_get_ctl(nullptr, 0), nullptr);
71 EXPECT_EQ(mixer_get_ctl_by_name(nullptr, ""), nullptr);
72 EXPECT_EQ(mixer_get_ctl_by_name(reinterpret_cast<mixer *>(1), nullptr), nullptr);
73 EXPECT_EQ(mixer_get_ctl_by_name_and_index(nullptr, "", 0), nullptr);
74 EXPECT_EQ(
75 mixer_get_ctl_by_name_and_index(reinterpret_cast<mixer *>(1), nullptr, 0),
76 nullptr);
77 EXPECT_NE(mixer_subscribe_events(nullptr, 0), 0);
78 EXPECT_LT(mixer_wait_event(nullptr, 0), 0);
79 EXPECT_EQ(mixer_ctl_get_id(nullptr), std::numeric_limits<unsigned int>::max());
80 EXPECT_EQ(mixer_ctl_get_name(nullptr), nullptr);
81 EXPECT_EQ(mixer_ctl_get_type(nullptr), MIXER_CTL_TYPE_UNKNOWN);
82 EXPECT_STREQ(mixer_ctl_get_type_string(nullptr), "");
83 EXPECT_EQ(mixer_ctl_get_num_values(nullptr), 0);
84 EXPECT_EQ(mixer_ctl_get_num_enums(nullptr), 0);
85 EXPECT_EQ(mixer_ctl_get_enum_string(nullptr, 0), nullptr);
86 mixer_ctl_update(nullptr);
87 EXPECT_EQ(mixer_ctl_is_access_tlv_rw(nullptr), 0);
88 EXPECT_EQ(mixer_ctl_get_percent(nullptr, 0), -EINVAL);
89 EXPECT_EQ(mixer_ctl_set_percent(nullptr, 0, 0), -EINVAL);
90 EXPECT_EQ(mixer_ctl_get_value(nullptr, 0), -EINVAL);
91 EXPECT_EQ(mixer_ctl_get_array(nullptr, reinterpret_cast<void *>(1), 1), -EINVAL);
92 EXPECT_EQ(mixer_ctl_get_array(reinterpret_cast<mixer_ctl *>(1), nullptr, 1), -EINVAL);
93 EXPECT_EQ(
94 mixer_ctl_get_array(
95 reinterpret_cast<mixer_ctl *>(1), reinterpret_cast<void *>(1), 0), -EINVAL);
96 EXPECT_EQ(mixer_ctl_set_value(nullptr, 0, 0), -EINVAL);
97 EXPECT_EQ(mixer_ctl_set_array(nullptr, reinterpret_cast<const void *>(1), 1), -EINVAL);
98 EXPECT_EQ(mixer_ctl_set_array(reinterpret_cast<mixer_ctl *>(1), nullptr, 1), -EINVAL);
99 EXPECT_EQ(
100 mixer_ctl_set_array(
101 reinterpret_cast<mixer_ctl *>(1), reinterpret_cast<const void *>(1), 0), -EINVAL);
102 EXPECT_EQ(mixer_ctl_set_enum_by_string(nullptr, reinterpret_cast<const char *>(1)), -EINVAL);
103 EXPECT_EQ(mixer_ctl_set_enum_by_string(reinterpret_cast<mixer_ctl *>(1), nullptr), -EINVAL);
104 EXPECT_EQ(mixer_ctl_get_range_min(nullptr), -EINVAL);
105 EXPECT_EQ(mixer_ctl_get_range_max(nullptr), -EINVAL);
106 EXPECT_EQ(mixer_read_event(nullptr, reinterpret_cast<mixer_ctl_event *>(1)), -EINVAL);
107 EXPECT_EQ(mixer_read_event(reinterpret_cast<mixer *>(1), nullptr), -EINVAL);
108 EXPECT_EQ(mixer_consume_event(nullptr), -EINVAL);
109 }
110
111 class MixerTest : public ::testing::TestWithParam<unsigned int> {
112 protected:
MixerTest()113 MixerTest() : mixer_object(nullptr) {}
114 virtual ~MixerTest() = default;
115
SetUp()116 virtual void SetUp() override {
117 unsigned int card = GetParam();
118 mixer_object = mixer_open(card);
119 ASSERT_NE(mixer_object, nullptr);
120 }
121
TearDown()122 virtual void TearDown() override {
123 mixer_close(mixer_object);
124 }
125
126 mixer *mixer_object;
127 };
128
TEST_P(MixerTest,AddNewControls)129 TEST_P(MixerTest, AddNewControls) {
130 ASSERT_EQ(mixer_add_new_ctls(mixer_object), 0);
131 }
132
TEST_P(MixerTest,GetName)133 TEST_P(MixerTest, GetName) {
134 const char *name = mixer_get_name(mixer_object);
135 std::cout << name << std::endl;
136 ASSERT_STRNE(name, "");
137 }
138
TEST_P(MixerTest,GetNumberOfControls)139 TEST_P(MixerTest, GetNumberOfControls) {
140 unsigned int nums = mixer_get_num_ctls(mixer_object);
141 std::cout << nums << std::endl;
142 ASSERT_GT(nums, 0);
143 }
144
145 class MixerControlsTest : public MixerTest {
146 protected:
MixerControlsTest()147 MixerControlsTest() : number_of_controls(0), controls(nullptr) {}
148 virtual ~MixerControlsTest() = default;
149
SetUp()150 virtual void SetUp() override {
151 MixerTest::SetUp();
152
153 number_of_controls = mixer_get_num_ctls(mixer_object);
154 ASSERT_GT(number_of_controls, 0);
155
156 controls = std::make_unique<const mixer_ctl *[]>(number_of_controls);
157 ASSERT_NE(controls, nullptr);
158
159 for (unsigned int i = 0; i < number_of_controls; i++) {
160 controls[i] = mixer_get_ctl_const(mixer_object, i);
161 EXPECT_EQ(mixer_ctl_get_id(controls[i]), i);
162 EXPECT_STRNE(mixer_ctl_get_name(controls[i]), "");
163 EXPECT_NE(controls[i], nullptr);
164 }
165 }
166
TearDown()167 virtual void TearDown() override {
168 controls = nullptr;
169 MixerTest::TearDown();
170 }
171
172 unsigned int number_of_controls;
173 std::unique_ptr<const mixer_ctl *[]> controls;
174 };
175
TEST_P(MixerControlsTest,GetNumberOfControlsByName)176 TEST_P(MixerControlsTest, GetNumberOfControlsByName) {
177 for (unsigned int i = 0; i < number_of_controls; ++i) {
178 const char *name = mixer_ctl_get_name(controls[i]);
179 ASSERT_GE(mixer_get_num_ctls_by_name(mixer_object, name), 1);
180 }
181
182 std::string name{mixer_ctl_get_name(controls[0])};
183 name += "1";
184 ASSERT_EQ(mixer_get_num_ctls_by_name(mixer_object, name.c_str()), 0);
185 }
186
TEST_P(MixerControlsTest,GetControlById)187 TEST_P(MixerControlsTest, GetControlById) {
188 for (unsigned int i = 0; i < number_of_controls; ++i) {
189 ASSERT_EQ(mixer_get_ctl(mixer_object, i), controls[i]);
190 }
191
192 ASSERT_EQ(mixer_get_ctl(mixer_object, number_of_controls), nullptr);
193 }
194
TEST_P(MixerControlsTest,GetControlByName)195 TEST_P(MixerControlsTest, GetControlByName) {
196 std::unordered_set<std::string> visited_names_set;
197 for (unsigned int i = 0; i < number_of_controls; ++i) {
198 std::string name{mixer_ctl_get_name(controls[i])};
199 if (visited_names_set.find(name) == visited_names_set.end()) {
200 ASSERT_EQ(mixer_get_ctl_by_name(mixer_object, name.c_str()), controls[i]);
201 visited_names_set.insert(name);
202 }
203 }
204 }
205
TEST_P(MixerControlsTest,GetControlByNameAndIndex)206 TEST_P(MixerControlsTest, GetControlByNameAndIndex) {
207 std::unordered_map<std::string, int32_t> visited_names_and_count_map;
208 for (unsigned int i = 0; i < number_of_controls; ++i) {
209 std::string name{mixer_ctl_get_name(controls[i])};
210 if (visited_names_and_count_map.find(name) == visited_names_and_count_map.end()) {
211 visited_names_and_count_map[name] = 0;
212 }
213 ASSERT_EQ(
214 mixer_get_ctl_by_name_and_index(mixer_object,
215 name.c_str(),
216 visited_names_and_count_map[name]),
217 controls[i]);
218 visited_names_and_count_map[name] = visited_names_and_count_map[name] + 1;
219 }
220 }
221
IsValidTypeString(std::string & type)222 static inline bool IsValidTypeString(std::string& type) {
223 return type == "BOOL" || type == "INT" || type == "ENUM" || type == "BYTE" ||
224 type == "IEC958" || type == "INT64";
225 }
226
TEST_P(MixerControlsTest,GetControlTypeString)227 TEST_P(MixerControlsTest, GetControlTypeString) {
228 ASSERT_STREQ(mixer_ctl_get_type_string(nullptr), "");
229
230 for (unsigned int i = 0; i < number_of_controls; ++i) {
231 std::string type{mixer_ctl_get_type_string(controls[i])};
232 ASSERT_TRUE(IsValidTypeString(type));
233 }
234 }
235
TEST_P(MixerControlsTest,GetNumberOfValues)236 TEST_P(MixerControlsTest, GetNumberOfValues) {
237 ASSERT_EQ(mixer_ctl_get_num_values(nullptr), 0);
238 }
239
TEST_P(MixerControlsTest,GetNumberOfEnumsAndEnumString)240 TEST_P(MixerControlsTest, GetNumberOfEnumsAndEnumString) {
241 for (unsigned int i = 0; i < number_of_controls; ++i) {
242 const mixer_ctl *control = controls[i];
243 if (mixer_ctl_get_type(control) == MIXER_CTL_TYPE_ENUM) {
244 unsigned int number_of_enums = mixer_ctl_get_num_enums(control);
245 ASSERT_GT(number_of_enums, 0);
246 for (unsigned int enum_id = 0; enum_id < number_of_enums; ++enum_id) {
247 const char *enum_name = mixer_ctl_get_enum_string(
248 const_cast<mixer_ctl *>(control),
249 enum_id);
250 ASSERT_STRNE(enum_name, "");
251 }
252 }
253 }
254 }
255
TEST_P(MixerControlsTest,UpdateControl)256 TEST_P(MixerControlsTest, UpdateControl) {
257 for (unsigned int i = 0; i < number_of_controls; ++i) {
258 mixer_ctl_update(const_cast<mixer_ctl *>(controls[i]));
259 }
260 }
261
TEST_P(MixerControlsTest,GetPercent)262 TEST_P(MixerControlsTest, GetPercent) {
263 for (unsigned int i = 0; i < number_of_controls; ++i) {
264 const mixer_ctl *control = controls[i];
265 if (mixer_ctl_get_type(control) == MIXER_CTL_TYPE_INT) {
266 unsigned int number_of_values = mixer_ctl_get_num_values(controls[i]);
267 std::unique_ptr<long []> values = std::make_unique<long []>(number_of_values);
268 mixer_ctl_get_array(control, values.get(), number_of_values);
269 for (unsigned int value_id = 0; value_id < number_of_values; ++value_id) {
270 int max = mixer_ctl_get_range_max(control);
271 int min = mixer_ctl_get_range_min(control);
272 int percent = mixer_ctl_get_percent(control, value_id);
273 ASSERT_GE(percent, k0Percent);
274 ASSERT_LE(percent, k100Percent);
275 int range = max - min;
276 ASSERT_EQ(percent, (values[value_id] - min) * k100Percent / range);
277 }
278 } else {
279 ASSERT_EQ(mixer_ctl_get_percent(control, 0), -EINVAL);
280 }
281 }
282 }
283
TEST_P(MixerControlsTest,SetPercent)284 TEST_P(MixerControlsTest, SetPercent) {
285 for (unsigned int i = 0; i < number_of_controls; ++i) {
286 const mixer_ctl *control = controls[i];
287 if (mixer_ctl_get_type(control) == MIXER_CTL_TYPE_INT) {
288 unsigned int number_of_values = mixer_ctl_get_num_values(controls[i]);
289 std::unique_ptr<long []> values = std::make_unique<long []>(number_of_values);
290 mixer_ctl_get_array(control, values.get(), number_of_values);
291 for (unsigned int value_id = 0; value_id < number_of_values; ++value_id) {
292 int max = mixer_ctl_get_range_max(control);
293 int min = mixer_ctl_get_range_min(control);
294 int value = values[value_id];
295 int percent = mixer_ctl_get_percent(control, value_id);
296 if (mixer_ctl_set_percent(
297 const_cast<mixer_ctl *>(control), value_id, k100Percent) == 0) {
298 // note: some controls are able to be written, but their values might not be
299 // changed.
300 mixer_ctl_get_array(control, values.get(), number_of_values);
301 int new_value = values[value_id];
302 ASSERT_TRUE(new_value == value || new_value == max);
303 }
304 if (mixer_ctl_set_percent(
305 const_cast<mixer_ctl *>(control), value_id, k0Percent) == 0) {
306 mixer_ctl_get_array(control, values.get(), number_of_values);
307 int new_value = values[value_id];
308 ASSERT_TRUE(new_value == value || new_value == min);
309 }
310 mixer_ctl_set_percent(const_cast<mixer_ctl *>(control), value_id, percent);
311 }
312 } else {
313 ASSERT_EQ(mixer_ctl_get_percent(control, 0), -EINVAL);
314 }
315 }
316 }
317
TEST_P(MixerControlsTest,Event)318 TEST_P(MixerControlsTest, Event) {
319 ASSERT_EQ(mixer_subscribe_events(mixer_object, 1), 0);
320 const mixer_ctl *control = nullptr;
321 for (unsigned int i = 0; i < number_of_controls; ++i) {
322 std::string_view name{mixer_ctl_get_name(controls[i])};
323
324 if (name.find("Volume") != std::string_view::npos) {
325 control = controls[i];
326 }
327 }
328
329 if (control == nullptr) {
330 GTEST_SKIP() << "No volume control was found in the controls list.";
331 }
332
333 auto *local_mixer_object = mixer_object;
334 int percent = mixer_ctl_get_percent(control, 0);
335 std::thread thread([local_mixer_object, control, percent] () {
336 std::this_thread::sleep_for(std::chrono::milliseconds(50));
337 mixer_ctl_set_percent(
338 const_cast<mixer_ctl *>(control), 0,
339 percent == k100Percent ? k0Percent : k100Percent);
340 });
341
342 EXPECT_EQ(mixer_wait_event(mixer_object, 1000), 1);
343
344 EXPECT_EQ(mixer_consume_event(mixer_object), 1);
345
346 thread.join();
347 ASSERT_EQ(mixer_subscribe_events(mixer_object, 0), 0);
348
349 mixer_ctl_set_percent(const_cast<mixer_ctl *>(control), 0, percent);
350 }
351
352 INSTANTIATE_TEST_SUITE_P(
353 MixerTest,
354 MixerTest,
355 ::testing::Range<unsigned int>(
356 0,
357 kMaxCardIndex + 1
358 ));
359
360 INSTANTIATE_TEST_SUITE_P(
361 MixerControlsTest,
362 MixerControlsTest,
363 ::testing::Range<unsigned int>(
364 0,
365 kMaxCardIndex + 1
366 ));
367
368 } // namespace testing
369 } // namespace tinyalsa
370