1 // Copyright (c) 2012 The Chromium OS Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include <gtest/gtest.h> 6 #include <iniparser.h> 7 #include <map> 8 #include <stdio.h> 9 #include <syslog.h> 10 #include <sys/param.h> 11 12 extern "C" { 13 #include "cras_alsa_card.h" 14 #include "cras_alsa_io.h" 15 #include "cras_alsa_mixer.h" 16 #include "cras_alsa_ucm.h" 17 #include "cras_types.h" 18 #include "cras_util.h" 19 #include "utlist.h" 20 } 21 22 namespace { 23 24 static size_t cras_alsa_mixer_create_called; 25 static struct cras_alsa_mixer *cras_alsa_mixer_create_return; 26 static size_t cras_alsa_mixer_destroy_called; 27 static size_t cras_alsa_iodev_create_called; 28 static struct cras_iodev **cras_alsa_iodev_create_return; 29 static struct cras_iodev *cras_alsa_iodev_create_default_return[] = { 30 reinterpret_cast<struct cras_iodev *>(2), 31 reinterpret_cast<struct cras_iodev *>(3), 32 reinterpret_cast<struct cras_iodev *>(4), 33 reinterpret_cast<struct cras_iodev *>(5), 34 }; 35 static size_t cras_alsa_iodev_create_return_size; 36 static size_t cras_alsa_iodev_legacy_complete_init_called; 37 static size_t cras_alsa_iodev_ucm_add_nodes_and_jacks_called; 38 static size_t cras_alsa_iodev_ucm_complete_init_called; 39 static size_t cras_alsa_iodev_destroy_called; 40 static struct cras_iodev *cras_alsa_iodev_destroy_arg; 41 static size_t cras_alsa_iodev_index_called; 42 static std::map<struct cras_iodev *, unsigned int> cras_alsa_iodev_index_return; 43 static int alsa_iodev_has_hctl_jacks_return; 44 static size_t snd_ctl_open_called; 45 static size_t snd_ctl_open_return; 46 static size_t snd_ctl_close_called; 47 static size_t snd_ctl_close_return; 48 static size_t snd_ctl_pcm_next_device_called; 49 static bool snd_ctl_pcm_next_device_return_error; 50 static int *snd_ctl_pcm_next_device_set_devs; 51 static size_t snd_ctl_pcm_next_device_set_devs_size; 52 static size_t snd_ctl_pcm_next_device_set_devs_index; 53 static size_t snd_ctl_pcm_info_called; 54 static int *snd_ctl_pcm_info_rets; 55 static size_t snd_ctl_pcm_info_rets_size; 56 static size_t snd_ctl_pcm_info_rets_index; 57 static size_t snd_ctl_card_info_called; 58 static int snd_ctl_card_info_ret; 59 static size_t snd_hctl_open_called; 60 static int snd_hctl_open_return_value; 61 static int snd_hctl_close_called; 62 static size_t snd_hctl_nonblock_called; 63 static snd_hctl_t *snd_hctl_open_pointer_val; 64 static size_t snd_hctl_load_called; 65 static int snd_hctl_load_return_value; 66 static struct pollfd *snd_hctl_poll_descriptors_fds; 67 static size_t snd_hctl_poll_descriptors_num_fds; 68 static size_t snd_hctl_poll_descriptors_called; 69 static size_t cras_system_add_select_fd_called; 70 static std::vector<int> cras_system_add_select_fd_values; 71 static size_t cras_system_rm_select_fd_called; 72 static std::vector<int> cras_system_rm_select_fd_values; 73 static size_t snd_hctl_handle_events_called; 74 static size_t iniparser_freedict_called; 75 static size_t iniparser_load_called; 76 static struct cras_device_blacklist *fake_blacklist; 77 static int cras_device_blacklist_check_retval; 78 static unsigned ucm_create_called; 79 static unsigned ucm_destroy_called; 80 static size_t ucm_get_dev_for_mixer_called; 81 static size_t ucm_get_flag_called; 82 static char ucm_get_flag_name[64]; 83 static char* device_config_dir; 84 static const char* cras_card_config_dir; 85 static struct mixer_name *ucm_get_coupled_mixer_names_return_value; 86 static struct mixer_name *coupled_output_names_value; 87 static int ucm_has_fully_specified_ucm_flag_return_value; 88 static int ucm_get_sections_called; 89 static struct ucm_section *ucm_get_sections_return_value; 90 static size_t cras_alsa_mixer_add_controls_in_section_called; 91 static int cras_alsa_mixer_add_controls_in_section_return_value; 92 93 static void ResetStubData() { 94 cras_alsa_mixer_create_called = 0; 95 cras_alsa_mixer_create_return = reinterpret_cast<struct cras_alsa_mixer *>(1); 96 cras_alsa_mixer_destroy_called = 0; 97 cras_alsa_iodev_destroy_arg = NULL; 98 cras_alsa_iodev_create_called = 0; 99 cras_alsa_iodev_create_return = cras_alsa_iodev_create_default_return; 100 cras_alsa_iodev_create_return_size = 101 ARRAY_SIZE(cras_alsa_iodev_create_default_return); 102 cras_alsa_iodev_legacy_complete_init_called = 0; 103 cras_alsa_iodev_ucm_add_nodes_and_jacks_called = 0; 104 cras_alsa_iodev_ucm_complete_init_called = 0; 105 cras_alsa_iodev_destroy_called = 0; 106 cras_alsa_iodev_index_called = 0; 107 cras_alsa_iodev_index_return.clear(); 108 alsa_iodev_has_hctl_jacks_return = 1; 109 snd_ctl_open_called = 0; 110 snd_ctl_open_return = 0; 111 snd_ctl_close_called = 0; 112 snd_ctl_close_return = 0; 113 snd_ctl_pcm_next_device_called = 0; 114 snd_ctl_pcm_next_device_return_error = false; 115 snd_ctl_pcm_next_device_set_devs_size = 0; 116 snd_ctl_pcm_next_device_set_devs_index = 0; 117 snd_ctl_pcm_info_called = 0; 118 snd_ctl_pcm_info_rets_size = 0; 119 snd_ctl_pcm_info_rets_index = 0; 120 snd_ctl_card_info_called = 0; 121 snd_ctl_card_info_ret = 0; 122 snd_hctl_open_called = 0; 123 snd_hctl_open_return_value = 0; 124 snd_hctl_open_pointer_val = reinterpret_cast<snd_hctl_t *>(0x4323); 125 snd_hctl_load_called = 0; 126 snd_hctl_load_return_value = 0; 127 snd_hctl_close_called = 0; 128 snd_hctl_nonblock_called = 0; 129 snd_hctl_poll_descriptors_num_fds = 0; 130 snd_hctl_poll_descriptors_called = 0; 131 snd_hctl_handle_events_called = 0; 132 snd_hctl_poll_descriptors_num_fds = 0; 133 snd_hctl_poll_descriptors_called = 0; 134 cras_system_add_select_fd_called = 0; 135 cras_system_add_select_fd_values.clear(); 136 cras_system_rm_select_fd_called = 0; 137 cras_system_rm_select_fd_values.clear(); 138 iniparser_freedict_called = 0; 139 iniparser_load_called = 0; 140 fake_blacklist = reinterpret_cast<struct cras_device_blacklist *>(3); 141 cras_device_blacklist_check_retval = 0; 142 ucm_create_called = 0; 143 ucm_destroy_called = 0; 144 ucm_get_dev_for_mixer_called = 0; 145 ucm_get_flag_called = 0; 146 memset(ucm_get_flag_name, 0, sizeof(ucm_get_flag_name)); 147 device_config_dir = reinterpret_cast<char *>(3); 148 cras_card_config_dir = NULL; 149 ucm_get_coupled_mixer_names_return_value = NULL; 150 mixer_name_free(coupled_output_names_value); 151 coupled_output_names_value = NULL; 152 ucm_has_fully_specified_ucm_flag_return_value = 0; 153 ucm_get_sections_called = 0; 154 ucm_get_sections_return_value = NULL; 155 cras_alsa_mixer_add_controls_in_section_called = 0; 156 cras_alsa_mixer_add_controls_in_section_return_value = 0; 157 } 158 159 TEST(AlsaCard, CreateFailInvalidCard) { 160 struct cras_alsa_card *c; 161 cras_alsa_card_info card_info; 162 163 ResetStubData(); 164 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 165 card_info.card_index = 55; 166 c = cras_alsa_card_create(&card_info, device_config_dir, 167 fake_blacklist, NULL); 168 EXPECT_EQ(static_cast<struct cras_alsa_card *>(NULL), c); 169 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 170 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 171 } 172 173 TEST(AlsaCard, CreateFailMixerInit) { 174 struct cras_alsa_card *c; 175 cras_alsa_card_info card_info; 176 177 ResetStubData(); 178 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 179 card_info.card_index = 0; 180 cras_alsa_mixer_create_return = static_cast<struct cras_alsa_mixer *>(NULL); 181 c = cras_alsa_card_create(&card_info, device_config_dir, 182 fake_blacklist, NULL); 183 EXPECT_EQ(static_cast<struct cras_alsa_card *>(NULL), c); 184 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 185 EXPECT_EQ(1, cras_alsa_mixer_create_called); 186 EXPECT_EQ(0, cras_alsa_mixer_destroy_called); 187 } 188 189 TEST(AlsaCard, CreateFailCtlOpen) { 190 struct cras_alsa_card *c; 191 cras_alsa_card_info card_info; 192 193 ResetStubData(); 194 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 195 card_info.card_index = 0; 196 snd_ctl_open_return = -1; 197 c = cras_alsa_card_create(&card_info, device_config_dir, 198 fake_blacklist, NULL); 199 EXPECT_EQ(static_cast<struct cras_alsa_card *>(NULL), c); 200 EXPECT_EQ(1, snd_ctl_open_called); 201 EXPECT_EQ(0, snd_ctl_close_called); 202 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 203 EXPECT_EQ(0, cras_alsa_mixer_create_called); 204 } 205 206 TEST(AlsaCard, CreateFailHctlOpen) { 207 struct cras_alsa_card *c; 208 cras_alsa_card_info card_info; 209 210 ResetStubData(); 211 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 212 card_info.card_index = 0; 213 snd_hctl_open_pointer_val = NULL; 214 snd_hctl_open_return_value = -1; 215 216 c = cras_alsa_card_create(&card_info, device_config_dir, 217 fake_blacklist, NULL); 218 EXPECT_NE(static_cast<struct cras_alsa_card *>(NULL), c); 219 EXPECT_EQ(1, snd_ctl_open_called); 220 EXPECT_EQ(1, snd_ctl_close_called); 221 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 222 EXPECT_EQ(1, snd_hctl_open_called); 223 EXPECT_EQ(0, snd_hctl_nonblock_called); 224 EXPECT_EQ(0, snd_hctl_load_called); 225 EXPECT_EQ(1, cras_alsa_mixer_create_called); 226 } 227 228 TEST(AlsaCard, CreateFailHctlLoad) { 229 struct cras_alsa_card *c; 230 cras_alsa_card_info card_info; 231 232 ResetStubData(); 233 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 234 card_info.card_index = 0; 235 snd_hctl_load_return_value = -1; 236 237 c = cras_alsa_card_create(&card_info, device_config_dir, 238 fake_blacklist, NULL); 239 EXPECT_EQ(static_cast<struct cras_alsa_card *>(NULL), c); 240 EXPECT_EQ(1, snd_ctl_open_called); 241 EXPECT_EQ(1, snd_ctl_close_called); 242 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 243 EXPECT_EQ(1, snd_hctl_open_called); 244 EXPECT_EQ(1, snd_hctl_nonblock_called); 245 EXPECT_EQ(1, snd_hctl_load_called); 246 EXPECT_EQ(0, cras_alsa_mixer_create_called); 247 } 248 249 TEST(AlsaCard, AddSelectForHctlNoDevices) { 250 struct pollfd poll_fds[] = { 251 {3, 0, 0}, 252 }; 253 254 struct cras_alsa_card *c; 255 cras_alsa_card_info card_info; 256 257 ResetStubData(); 258 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 259 card_info.card_index = 0; 260 snd_hctl_poll_descriptors_fds = poll_fds; 261 snd_hctl_poll_descriptors_num_fds = ARRAY_SIZE(poll_fds); 262 263 c = cras_alsa_card_create(&card_info, device_config_dir, 264 fake_blacklist, NULL); 265 EXPECT_NE(static_cast<struct cras_alsa_card *>(NULL), c); 266 EXPECT_EQ(1, snd_ctl_open_called); 267 EXPECT_EQ(1, snd_ctl_close_called); 268 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 269 EXPECT_EQ(1, snd_hctl_open_called); 270 EXPECT_EQ(1, snd_hctl_nonblock_called); 271 EXPECT_EQ(1, snd_hctl_load_called); 272 EXPECT_EQ(1, cras_alsa_mixer_create_called); 273 EXPECT_EQ(0, cras_system_add_select_fd_called); 274 cras_alsa_card_destroy(c); 275 EXPECT_EQ(0, cras_system_rm_select_fd_called); 276 } 277 278 TEST(AlsaCard, AddSelectForHctlWithDevices) { 279 struct pollfd poll_fds[] = { 280 {3, 0, 0}, 281 }; 282 int dev_nums[] = {0}; 283 int info_rets[] = {0, -1}; 284 285 struct cras_alsa_card *c; 286 cras_alsa_card_info card_info; 287 288 ResetStubData(); 289 snd_ctl_pcm_next_device_set_devs_size = ARRAY_SIZE(dev_nums); 290 snd_ctl_pcm_next_device_set_devs = dev_nums; 291 snd_ctl_pcm_info_rets_size = ARRAY_SIZE(info_rets); 292 snd_ctl_pcm_info_rets = info_rets; 293 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 294 card_info.card_index = 0; 295 snd_hctl_poll_descriptors_fds = poll_fds; 296 snd_hctl_poll_descriptors_num_fds = ARRAY_SIZE(poll_fds); 297 298 c = cras_alsa_card_create(&card_info, device_config_dir, 299 fake_blacklist, NULL); 300 EXPECT_NE(static_cast<struct cras_alsa_card *>(NULL), c); 301 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 302 EXPECT_EQ(2, snd_ctl_pcm_next_device_called); 303 EXPECT_EQ(1, cras_alsa_iodev_create_called); 304 EXPECT_EQ(0, cras_alsa_iodev_index_called); 305 EXPECT_EQ(1, snd_ctl_card_info_called); 306 EXPECT_EQ(1, ucm_create_called); 307 EXPECT_EQ(1, ucm_get_dev_for_mixer_called); 308 EXPECT_EQ(1, ucm_get_flag_called); 309 EXPECT_EQ(0, strcmp(ucm_get_flag_name, "ExtraMainVolume")); 310 EXPECT_EQ(cras_card_config_dir, device_config_dir); 311 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 312 EXPECT_EQ(1, snd_hctl_open_called); 313 EXPECT_EQ(1, snd_hctl_nonblock_called); 314 EXPECT_EQ(1, snd_hctl_load_called); 315 EXPECT_EQ(1, cras_alsa_mixer_create_called); 316 ASSERT_EQ(1, cras_system_add_select_fd_called); 317 EXPECT_EQ(3, cras_system_add_select_fd_values[0]); 318 cras_alsa_card_destroy(c); 319 EXPECT_EQ(ARRAY_SIZE(poll_fds), cras_system_rm_select_fd_called); 320 } 321 322 TEST(AlsaCard, CreateFailCtlCardInfo) { 323 struct cras_alsa_card *c; 324 cras_alsa_card_info card_info; 325 326 ResetStubData(); 327 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 328 card_info.card_index = 0; 329 snd_ctl_card_info_ret = -1; 330 c = cras_alsa_card_create(&card_info, device_config_dir, 331 fake_blacklist, NULL); 332 EXPECT_EQ(static_cast<struct cras_alsa_card *>(NULL), c); 333 EXPECT_EQ(1, snd_ctl_open_called); 334 EXPECT_EQ(1, snd_ctl_close_called); 335 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 336 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 337 } 338 339 TEST(AlsaCard, CreateNoDevices) { 340 struct cras_alsa_card *c; 341 cras_alsa_card_info card_info; 342 343 ResetStubData(); 344 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 345 card_info.card_index = 1; 346 c = cras_alsa_card_create(&card_info, device_config_dir, 347 fake_blacklist, NULL); 348 EXPECT_NE(static_cast<struct cras_alsa_card *>(NULL), c); 349 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 350 EXPECT_EQ(1, snd_ctl_pcm_next_device_called); 351 EXPECT_EQ(0, cras_alsa_iodev_create_called); 352 EXPECT_EQ(0, cras_alsa_iodev_legacy_complete_init_called); 353 EXPECT_EQ(1, cras_alsa_card_get_index(c)); 354 EXPECT_EQ(0, ucm_get_sections_called); 355 EXPECT_EQ(0, cras_alsa_mixer_add_controls_in_section_called); 356 357 cras_alsa_card_destroy(c); 358 EXPECT_EQ(0, cras_alsa_iodev_destroy_called); 359 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 360 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 361 } 362 363 TEST(AlsaCard, CreateOneOutputNextDevError) { 364 struct cras_alsa_card *c; 365 cras_alsa_card_info card_info; 366 367 ResetStubData(); 368 snd_ctl_pcm_next_device_return_error = true; 369 card_info.card_type = ALSA_CARD_TYPE_USB; 370 card_info.card_index = 0; 371 c = cras_alsa_card_create(&card_info, device_config_dir, 372 fake_blacklist, NULL); 373 EXPECT_EQ(static_cast<struct cras_alsa_card *>(NULL), c); 374 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 375 EXPECT_EQ(snd_ctl_open_called, snd_ctl_close_called); 376 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 377 } 378 379 TEST(AlsaCard, CreateOneOutput) { 380 struct cras_alsa_card *c; 381 int dev_nums[] = {0}; 382 int info_rets[] = {0, -1}; 383 cras_alsa_card_info card_info; 384 385 ResetStubData(); 386 snd_ctl_pcm_next_device_set_devs_size = ARRAY_SIZE(dev_nums); 387 snd_ctl_pcm_next_device_set_devs = dev_nums; 388 snd_ctl_pcm_info_rets_size = ARRAY_SIZE(info_rets); 389 snd_ctl_pcm_info_rets = info_rets; 390 card_info.card_type = ALSA_CARD_TYPE_USB; 391 card_info.card_index = 0; 392 c = cras_alsa_card_create(&card_info, device_config_dir, 393 fake_blacklist, NULL); 394 EXPECT_NE(static_cast<struct cras_alsa_card *>(NULL), c); 395 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 396 EXPECT_EQ(2, snd_ctl_pcm_next_device_called); 397 EXPECT_EQ(1, cras_alsa_iodev_create_called); 398 EXPECT_EQ(1, cras_alsa_iodev_legacy_complete_init_called); 399 EXPECT_EQ(0, cras_alsa_iodev_index_called); 400 EXPECT_EQ(1, snd_ctl_card_info_called); 401 EXPECT_EQ(1, ucm_create_called); 402 EXPECT_EQ(1, ucm_get_dev_for_mixer_called); 403 EXPECT_EQ(1, ucm_get_flag_called); 404 EXPECT_EQ(0, strcmp(ucm_get_flag_name, "ExtraMainVolume")); 405 EXPECT_EQ(cras_card_config_dir, device_config_dir); 406 EXPECT_EQ(0, ucm_get_sections_called); 407 EXPECT_EQ(0, cras_alsa_mixer_add_controls_in_section_called); 408 409 cras_alsa_card_destroy(c); 410 EXPECT_EQ(1, ucm_destroy_called); 411 EXPECT_EQ(1, cras_alsa_iodev_destroy_called); 412 EXPECT_EQ(cras_alsa_iodev_create_return[0], cras_alsa_iodev_destroy_arg); 413 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 414 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 415 } 416 417 TEST(AlsaCard, CreateOneOutputBlacklisted) { 418 struct cras_alsa_card *c; 419 int dev_nums[] = {0}; 420 int info_rets[] = {0, -1}; 421 cras_alsa_card_info card_info; 422 423 ResetStubData(); 424 snd_ctl_pcm_next_device_set_devs_size = ARRAY_SIZE(dev_nums); 425 snd_ctl_pcm_next_device_set_devs = dev_nums; 426 snd_ctl_pcm_info_rets_size = ARRAY_SIZE(info_rets); 427 snd_ctl_pcm_info_rets = info_rets; 428 alsa_iodev_has_hctl_jacks_return = 0; 429 cras_device_blacklist_check_retval = 1; 430 card_info.card_type = ALSA_CARD_TYPE_USB; 431 card_info.card_index = 0; 432 c = cras_alsa_card_create(&card_info, device_config_dir, 433 fake_blacklist, NULL); 434 EXPECT_NE(static_cast<struct cras_alsa_card *>(NULL), c); 435 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 436 EXPECT_EQ(2, snd_ctl_pcm_next_device_called); 437 EXPECT_EQ(1, snd_ctl_card_info_called); 438 EXPECT_EQ(0, cras_alsa_iodev_create_called); 439 EXPECT_EQ(0, cras_alsa_iodev_legacy_complete_init_called); 440 EXPECT_EQ(cras_card_config_dir, device_config_dir); 441 442 cras_alsa_card_destroy(c); 443 EXPECT_EQ(0, cras_alsa_iodev_destroy_called); 444 EXPECT_EQ(NULL, cras_alsa_iodev_destroy_arg); 445 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 446 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 447 } 448 449 TEST(AlsaCard, CreateTwoOutputs) { 450 struct cras_alsa_card *c; 451 int dev_nums[] = {0, 3}; 452 int info_rets[] = {0, -1, 0}; 453 cras_alsa_card_info card_info; 454 455 ResetStubData(); 456 snd_ctl_pcm_next_device_set_devs_size = ARRAY_SIZE(dev_nums); 457 snd_ctl_pcm_next_device_set_devs = dev_nums; 458 snd_ctl_pcm_info_rets_size = ARRAY_SIZE(info_rets); 459 snd_ctl_pcm_info_rets = info_rets; 460 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 461 card_info.card_index = 0; 462 c = cras_alsa_card_create(&card_info, device_config_dir, 463 fake_blacklist, NULL); 464 EXPECT_NE(static_cast<struct cras_alsa_card *>(NULL), c); 465 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 466 EXPECT_EQ(3, snd_ctl_pcm_next_device_called); 467 EXPECT_EQ(2, cras_alsa_iodev_create_called); 468 EXPECT_EQ(2, cras_alsa_iodev_legacy_complete_init_called); 469 EXPECT_EQ(1, cras_alsa_iodev_index_called); 470 EXPECT_EQ(1, snd_ctl_card_info_called); 471 EXPECT_EQ(cras_card_config_dir, device_config_dir); 472 EXPECT_EQ(0, ucm_get_sections_called); 473 EXPECT_EQ(0, cras_alsa_mixer_add_controls_in_section_called); 474 475 cras_alsa_card_destroy(c); 476 EXPECT_EQ(2, cras_alsa_iodev_destroy_called); 477 EXPECT_EQ(cras_alsa_iodev_create_return[1], cras_alsa_iodev_destroy_arg); 478 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 479 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 480 } 481 482 TEST(AlsaCard, CreateTwoDuplicateDeviceIndex) { 483 struct cras_alsa_card *c; 484 int dev_nums[] = {0, 0}; 485 int info_rets[] = {0, -1, 0}; 486 cras_alsa_card_info card_info; 487 488 ResetStubData(); 489 snd_ctl_pcm_next_device_set_devs_size = ARRAY_SIZE(dev_nums); 490 snd_ctl_pcm_next_device_set_devs = dev_nums; 491 snd_ctl_pcm_info_rets_size = ARRAY_SIZE(info_rets); 492 snd_ctl_pcm_info_rets = info_rets; 493 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 494 card_info.card_index = 0; 495 c = cras_alsa_card_create(&card_info, device_config_dir, 496 fake_blacklist, NULL); 497 EXPECT_NE(static_cast<struct cras_alsa_card *>(NULL), c); 498 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 499 EXPECT_EQ(3, snd_ctl_pcm_next_device_called); 500 EXPECT_EQ(1, cras_alsa_iodev_create_called); 501 EXPECT_EQ(2, cras_alsa_iodev_legacy_complete_init_called); 502 EXPECT_EQ(1, cras_alsa_iodev_index_called); 503 EXPECT_EQ(1, snd_ctl_card_info_called); 504 EXPECT_EQ(cras_card_config_dir, device_config_dir); 505 EXPECT_EQ(0, ucm_get_sections_called); 506 EXPECT_EQ(0, cras_alsa_mixer_add_controls_in_section_called); 507 508 cras_alsa_card_destroy(c); 509 EXPECT_EQ(1, cras_alsa_iodev_destroy_called); 510 EXPECT_EQ(cras_alsa_iodev_create_return[0], cras_alsa_iodev_destroy_arg); 511 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 512 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 513 } 514 515 TEST(AlsaCard, CreateOneInput) { 516 struct cras_alsa_card *c; 517 int dev_nums[] = {0}; 518 int info_rets[] = {-1, 0}; 519 cras_alsa_card_info card_info; 520 521 ResetStubData(); 522 snd_ctl_pcm_next_device_set_devs_size = ARRAY_SIZE(dev_nums); 523 snd_ctl_pcm_next_device_set_devs = dev_nums; 524 snd_ctl_pcm_info_rets_size = ARRAY_SIZE(info_rets); 525 snd_ctl_pcm_info_rets = info_rets; 526 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 527 card_info.card_index = 0; 528 c = cras_alsa_card_create(&card_info, device_config_dir, 529 fake_blacklist, NULL); 530 EXPECT_NE(static_cast<struct cras_alsa_card *>(NULL), c); 531 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 532 EXPECT_EQ(2, snd_ctl_pcm_next_device_called); 533 EXPECT_EQ(1, cras_alsa_iodev_create_called); 534 EXPECT_EQ(1, cras_alsa_iodev_legacy_complete_init_called); 535 EXPECT_EQ(0, cras_alsa_iodev_index_called); 536 EXPECT_EQ(cras_card_config_dir, device_config_dir); 537 EXPECT_EQ(0, ucm_get_sections_called); 538 EXPECT_EQ(0, cras_alsa_mixer_add_controls_in_section_called); 539 540 cras_alsa_card_destroy(c); 541 EXPECT_EQ(1, cras_alsa_iodev_destroy_called); 542 EXPECT_EQ(cras_alsa_iodev_create_return[0], cras_alsa_iodev_destroy_arg); 543 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 544 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 545 } 546 547 TEST(AlsaCard, CreateOneInputAndOneOutput) { 548 struct cras_alsa_card *c; 549 int dev_nums[] = {0}; 550 int info_rets[] = {0, 0}; 551 cras_alsa_card_info card_info; 552 553 ResetStubData(); 554 snd_ctl_pcm_next_device_set_devs_size = ARRAY_SIZE(dev_nums); 555 snd_ctl_pcm_next_device_set_devs = dev_nums; 556 snd_ctl_pcm_info_rets_size = ARRAY_SIZE(info_rets); 557 snd_ctl_pcm_info_rets = info_rets; 558 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 559 card_info.card_index = 0; 560 c = cras_alsa_card_create(&card_info, device_config_dir, 561 fake_blacklist, NULL); 562 EXPECT_NE(static_cast<struct cras_alsa_card *>(NULL), c); 563 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 564 EXPECT_EQ(2, snd_ctl_pcm_next_device_called); 565 EXPECT_EQ(2, cras_alsa_iodev_create_called); 566 EXPECT_EQ(2, cras_alsa_iodev_legacy_complete_init_called); 567 EXPECT_EQ(0, cras_alsa_iodev_index_called); 568 EXPECT_EQ(cras_card_config_dir, device_config_dir); 569 EXPECT_EQ(0, ucm_get_sections_called); 570 EXPECT_EQ(0, cras_alsa_mixer_add_controls_in_section_called); 571 572 cras_alsa_card_destroy(c); 573 EXPECT_EQ(2, cras_alsa_iodev_destroy_called); 574 EXPECT_EQ(cras_alsa_iodev_create_return[1], cras_alsa_iodev_destroy_arg); 575 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 576 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 577 } 578 579 TEST(AlsaCard, CreateOneInputAndOneOutputTwoDevices) { 580 struct cras_alsa_card *c; 581 int dev_nums[] = {0, 3}; 582 int info_rets[] = {0, -1, -1, 0}; 583 cras_alsa_card_info card_info; 584 585 ResetStubData(); 586 snd_ctl_pcm_next_device_set_devs_size = ARRAY_SIZE(dev_nums); 587 snd_ctl_pcm_next_device_set_devs = dev_nums; 588 snd_ctl_pcm_info_rets_size = ARRAY_SIZE(info_rets); 589 snd_ctl_pcm_info_rets = info_rets; 590 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 591 card_info.card_index = 0; 592 c = cras_alsa_card_create(&card_info, device_config_dir, 593 fake_blacklist, NULL); 594 EXPECT_NE(static_cast<struct cras_alsa_card *>(NULL), c); 595 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 596 EXPECT_EQ(3, snd_ctl_pcm_next_device_called); 597 EXPECT_EQ(2, cras_alsa_iodev_create_called); 598 EXPECT_EQ(2, cras_alsa_iodev_legacy_complete_init_called); 599 EXPECT_EQ(0, cras_alsa_iodev_index_called); 600 EXPECT_EQ(cras_card_config_dir, device_config_dir); 601 EXPECT_EQ(0, ucm_get_sections_called); 602 EXPECT_EQ(0, cras_alsa_mixer_add_controls_in_section_called); 603 604 cras_alsa_card_destroy(c); 605 EXPECT_EQ(2, cras_alsa_iodev_destroy_called); 606 EXPECT_EQ(cras_alsa_iodev_create_return[1], cras_alsa_iodev_destroy_arg); 607 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 608 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 609 } 610 611 TEST(AlsaCard, CreateOneOutputWithCoupledMixers) { 612 struct cras_alsa_card *c; 613 int dev_nums[] = {0}; 614 int info_rets[] = {0, -1}; 615 struct mixer_name *mixer_name_1, *mixer_name_2; 616 /* Use strdup because cras_alsa_card_create will delete it. */ 617 const char *name1 = strdup("MixerName1"), *name2 = strdup("MixerName2"); 618 619 cras_alsa_card_info card_info; 620 621 ResetStubData(); 622 snd_ctl_pcm_next_device_set_devs_size = ARRAY_SIZE(dev_nums); 623 snd_ctl_pcm_next_device_set_devs = dev_nums; 624 snd_ctl_pcm_info_rets_size = ARRAY_SIZE(info_rets); 625 snd_ctl_pcm_info_rets = info_rets; 626 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 627 card_info.card_index = 0; 628 629 /* Creates a list of mixer names as return value of 630 * ucm_get_coupled_mixer_names. */ 631 mixer_name_1 = (struct mixer_name*)malloc(sizeof(*mixer_name_1)); 632 mixer_name_2 = (struct mixer_name*)malloc(sizeof(*mixer_name_2)); 633 mixer_name_1->name = name1; 634 mixer_name_2->name = name2; 635 DL_APPEND(ucm_get_coupled_mixer_names_return_value, mixer_name_1); 636 DL_APPEND(ucm_get_coupled_mixer_names_return_value, mixer_name_2); 637 638 c = cras_alsa_card_create(&card_info, device_config_dir, 639 fake_blacklist, NULL); 640 641 EXPECT_NE(static_cast<struct cras_alsa_card *>(NULL), c); 642 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 643 EXPECT_EQ(2, snd_ctl_pcm_next_device_called); 644 EXPECT_EQ(1, cras_alsa_iodev_create_called); 645 EXPECT_EQ(1, cras_alsa_iodev_legacy_complete_init_called); 646 EXPECT_EQ(0, cras_alsa_iodev_index_called); 647 EXPECT_EQ(1, snd_ctl_card_info_called); 648 EXPECT_EQ(1, ucm_create_called); 649 EXPECT_EQ(1, ucm_get_dev_for_mixer_called); 650 EXPECT_EQ(1, ucm_get_flag_called); 651 EXPECT_EQ(0, strcmp(ucm_get_flag_name, "ExtraMainVolume")); 652 EXPECT_EQ(cras_card_config_dir, device_config_dir); 653 EXPECT_EQ(0, ucm_get_sections_called); 654 EXPECT_EQ(0, cras_alsa_mixer_add_controls_in_section_called); 655 656 /* Checks cras_alsa_card_create can handle the list and pass the names to 657 * cras_alsa_mixer_create. */ 658 struct mixer_name *m_name = coupled_output_names_value; 659 EXPECT_EQ(0, m_name ? strcmp(m_name->name, "MixerName1") : 1); 660 if (m_name) 661 m_name = m_name->next; 662 EXPECT_EQ(0, m_name ? strcmp(m_name->name, "MixerName2") : 1); 663 664 cras_alsa_card_destroy(c); 665 EXPECT_EQ(1, ucm_destroy_called); 666 EXPECT_EQ(1, cras_alsa_iodev_destroy_called); 667 EXPECT_EQ(cras_alsa_iodev_create_return[0], cras_alsa_iodev_destroy_arg); 668 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 669 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 670 671 mixer_name_free(coupled_output_names_value); 672 coupled_output_names_value = NULL; 673 } 674 675 TEST(AlsaCard, CreateFullyUCMNoSections) { 676 struct cras_alsa_card *c; 677 cras_alsa_card_info card_info; 678 679 ResetStubData(); 680 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 681 card_info.card_index = 0; 682 ucm_has_fully_specified_ucm_flag_return_value = 1; 683 ucm_get_sections_return_value = NULL; 684 c = cras_alsa_card_create(&card_info, device_config_dir, 685 fake_blacklist, NULL); 686 EXPECT_EQ(static_cast<struct cras_alsa_card *>(NULL), c); 687 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 688 EXPECT_EQ(0, cras_alsa_iodev_create_called); 689 EXPECT_EQ(0, cras_alsa_iodev_ucm_complete_init_called); 690 EXPECT_EQ(1, snd_ctl_card_info_called); 691 EXPECT_EQ(1, ucm_get_sections_called); 692 EXPECT_EQ(0, cras_alsa_mixer_add_controls_in_section_called); 693 694 cras_alsa_card_destroy(c); 695 EXPECT_EQ(1, ucm_destroy_called); 696 EXPECT_EQ(0, cras_alsa_iodev_destroy_called); 697 EXPECT_EQ(NULL, cras_alsa_iodev_destroy_arg); 698 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 699 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 700 } 701 702 struct ucm_section *GenerateUcmSections (void) { 703 struct ucm_section *sections = NULL; 704 struct ucm_section *section; 705 706 section = ucm_section_create("Headphone", 0, CRAS_STREAM_OUTPUT, 707 "my-sound-card Headset Jack", "gpio"); 708 ucm_section_add_coupled(section, "HP-L", MIXER_NAME_VOLUME); 709 ucm_section_add_coupled(section, "HP-R", MIXER_NAME_VOLUME); 710 DL_APPEND(sections, section); 711 712 section = ucm_section_create("Speaker", 0, CRAS_STREAM_OUTPUT, 713 NULL, NULL); 714 ucm_section_add_coupled(section, "SPK-L", MIXER_NAME_VOLUME); 715 ucm_section_add_coupled(section, "SPK-R", MIXER_NAME_VOLUME); 716 DL_APPEND(sections, section); 717 718 section = ucm_section_create("Mic", 0, CRAS_STREAM_INPUT, 719 "my-sound-card Headset Jack", "gpio"); 720 ucm_section_set_mixer_name(section, "CAPTURE"); 721 722 section = ucm_section_create("Internal Mic", 0, CRAS_STREAM_INPUT, 723 NULL, NULL); 724 ucm_section_add_coupled(section, "INT-MIC-L", MIXER_NAME_VOLUME); 725 ucm_section_add_coupled(section, "INT-MIC-R", MIXER_NAME_VOLUME); 726 DL_APPEND(sections, section); 727 728 section = ucm_section_create("Mic", 1, CRAS_STREAM_INPUT, 729 "my-sound-card Headset Jack", "gpio"); 730 ucm_section_add_coupled(section, "MIC-L", MIXER_NAME_VOLUME); 731 ucm_section_add_coupled(section, "MIC-R", MIXER_NAME_VOLUME); 732 DL_APPEND(sections, section); 733 734 section = ucm_section_create("HDMI", 2, CRAS_STREAM_OUTPUT, 735 NULL, NULL); 736 ucm_section_set_mixer_name(section, "HDMI"); 737 DL_APPEND(sections, section); 738 739 return sections; 740 } 741 742 TEST(AlsaCard, CreateFullyUCMFailureOnControls) { 743 struct cras_alsa_card *c; 744 cras_alsa_card_info card_info; 745 746 ResetStubData(); 747 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 748 card_info.card_index = 0; 749 ucm_has_fully_specified_ucm_flag_return_value = 1; 750 ucm_get_sections_return_value = GenerateUcmSections(); 751 ASSERT_NE(ucm_get_sections_return_value, (struct ucm_section *)NULL); 752 753 cras_alsa_mixer_add_controls_in_section_return_value = -EINVAL; 754 755 c = cras_alsa_card_create(&card_info, device_config_dir, 756 fake_blacklist, NULL); 757 758 EXPECT_EQ(static_cast<struct cras_alsa_card *>(NULL), c); 759 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 760 EXPECT_EQ(1, snd_ctl_card_info_called); 761 EXPECT_EQ(1, ucm_get_sections_called); 762 EXPECT_EQ(1, cras_alsa_mixer_add_controls_in_section_called); 763 EXPECT_EQ(0, cras_alsa_iodev_create_called); 764 EXPECT_EQ(0, cras_alsa_iodev_ucm_complete_init_called); 765 766 cras_alsa_card_destroy(c); 767 EXPECT_EQ(1, ucm_destroy_called); 768 EXPECT_EQ(0, cras_alsa_iodev_destroy_called); 769 EXPECT_EQ(NULL, cras_alsa_iodev_destroy_arg); 770 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 771 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 772 } 773 774 TEST(AlsaCard, CreateFullyUCMFourDevicesFiveSections) { 775 struct cras_alsa_card *c; 776 cras_alsa_card_info card_info; 777 int info_rets[] = {0, 0, 0, 0, 0, -1}; 778 779 ResetStubData(); 780 card_info.card_type = ALSA_CARD_TYPE_INTERNAL; 781 card_info.card_index = 0; 782 snd_ctl_pcm_info_rets_size = ARRAY_SIZE(info_rets); 783 snd_ctl_pcm_info_rets = info_rets; 784 ucm_has_fully_specified_ucm_flag_return_value = 1; 785 ucm_get_sections_return_value = GenerateUcmSections(); 786 cras_alsa_iodev_index_return[cras_alsa_iodev_create_return[0]] = 0; 787 cras_alsa_iodev_index_return[cras_alsa_iodev_create_return[1]] = 0; 788 cras_alsa_iodev_index_return[cras_alsa_iodev_create_return[2]] = 1; 789 cras_alsa_iodev_index_return[cras_alsa_iodev_create_return[3]] = 2; 790 ASSERT_NE(ucm_get_sections_return_value, (struct ucm_section *)NULL); 791 792 c = cras_alsa_card_create(&card_info, device_config_dir, 793 fake_blacklist, NULL); 794 795 EXPECT_NE(static_cast<struct cras_alsa_card *>(NULL), c); 796 EXPECT_EQ(snd_ctl_close_called, snd_ctl_open_called); 797 EXPECT_EQ(1, snd_ctl_card_info_called); 798 EXPECT_EQ(1, ucm_get_sections_called); 799 EXPECT_EQ(5, snd_ctl_pcm_info_called); 800 EXPECT_EQ(5, cras_alsa_mixer_add_controls_in_section_called); 801 EXPECT_EQ(4, cras_alsa_iodev_create_called); 802 EXPECT_EQ(5, cras_alsa_iodev_ucm_add_nodes_and_jacks_called); 803 EXPECT_EQ(4, cras_alsa_iodev_ucm_complete_init_called); 804 805 cras_alsa_card_destroy(c); 806 EXPECT_EQ(1, ucm_destroy_called); 807 EXPECT_EQ(4, cras_alsa_iodev_destroy_called); 808 EXPECT_EQ(cras_alsa_iodev_create_return[3], cras_alsa_iodev_destroy_arg); 809 EXPECT_EQ(cras_alsa_mixer_create_called, cras_alsa_mixer_destroy_called); 810 EXPECT_EQ(iniparser_load_called, iniparser_freedict_called); 811 } 812 813 814 /* Stubs */ 815 816 extern "C" { 817 struct cras_alsa_mixer *cras_alsa_mixer_create(const char *card_name) { 818 cras_alsa_mixer_create_called++; 819 return cras_alsa_mixer_create_return; 820 } 821 822 int cras_alsa_mixer_add_controls_by_name_matching( 823 struct cras_alsa_mixer* cmix, 824 struct mixer_name *extra_controls, 825 struct mixer_name *coupled_controls) { 826 /* Duplicate coupled_output_names to verify in the end of unittest 827 * because names will get freed later in cras_alsa_card_create. */ 828 struct mixer_name *control; 829 DL_FOREACH(coupled_controls, control) { 830 coupled_output_names_value = 831 mixer_name_add(coupled_output_names_value, 832 control->name, 833 CRAS_STREAM_OUTPUT, 834 control->type); 835 } 836 return 0; 837 } 838 839 void cras_alsa_mixer_destroy(struct cras_alsa_mixer *cras_mixer) { 840 cras_alsa_mixer_destroy_called++; 841 } 842 843 struct cras_iodev *alsa_iodev_create(size_t card_index, 844 const char *card_name, 845 size_t device_index, 846 const char *dev_name, 847 const char *dev_id, 848 enum CRAS_ALSA_CARD_TYPE card_type, 849 int is_first, 850 struct cras_alsa_mixer *mixer, 851 const struct cras_card_config *config, 852 struct cras_use_case_mgr *ucm, 853 snd_hctl_t *hctl, 854 enum CRAS_STREAM_DIRECTION direction, 855 size_t usb_vid, 856 size_t usb_pid, 857 char *usb_serial_number) { 858 struct cras_iodev *result = NULL; 859 if (cras_alsa_iodev_create_called < cras_alsa_iodev_create_return_size) 860 result = cras_alsa_iodev_create_return[cras_alsa_iodev_create_called]; 861 cras_alsa_iodev_create_called++; 862 return result; 863 } 864 void alsa_iodev_destroy(struct cras_iodev *iodev) { 865 cras_alsa_iodev_destroy_called++; 866 cras_alsa_iodev_destroy_arg = iodev; 867 } 868 int alsa_iodev_legacy_complete_init(struct cras_iodev *iodev) { 869 cras_alsa_iodev_legacy_complete_init_called++; 870 return 0; 871 } 872 int alsa_iodev_ucm_add_nodes_and_jacks(struct cras_iodev *iodev, 873 struct ucm_section *section) { 874 cras_alsa_iodev_ucm_add_nodes_and_jacks_called++; 875 return 0; 876 } 877 void alsa_iodev_ucm_complete_init(struct cras_iodev *iodev) { 878 cras_alsa_iodev_ucm_complete_init_called++; 879 } 880 unsigned alsa_iodev_index(struct cras_iodev *iodev) { 881 std::map<struct cras_iodev *, unsigned int>::iterator i; 882 cras_alsa_iodev_index_called++; 883 i = cras_alsa_iodev_index_return.find(iodev); 884 if (i != cras_alsa_iodev_index_return.end()) 885 return i->second; 886 return 0; 887 } 888 int alsa_iodev_has_hctl_jacks(struct cras_iodev *iodev) { 889 return alsa_iodev_has_hctl_jacks_return; 890 } 891 892 size_t snd_pcm_info_sizeof() { 893 return 10; 894 } 895 size_t snd_ctl_card_info_sizeof() { 896 return 10; 897 } 898 int snd_ctl_open(snd_ctl_t **handle, const char *name, int card) { 899 snd_ctl_open_called++; 900 if (snd_ctl_open_return == 0) 901 *handle = reinterpret_cast<snd_ctl_t*>(0xff); 902 else 903 *handle = NULL; 904 return snd_ctl_open_return; 905 } 906 int snd_ctl_close(snd_ctl_t *handle) { 907 snd_ctl_close_called++; 908 return snd_ctl_close_return; 909 } 910 int snd_ctl_pcm_next_device(snd_ctl_t *ctl, int *device) { 911 if (snd_ctl_pcm_next_device_return_error) { 912 *device = 10; 913 return -1; 914 } 915 snd_ctl_pcm_next_device_called++; 916 if (snd_ctl_pcm_next_device_set_devs_index >= 917 snd_ctl_pcm_next_device_set_devs_size) { 918 *device = -1; 919 return 0; 920 } 921 *device = 922 snd_ctl_pcm_next_device_set_devs[snd_ctl_pcm_next_device_set_devs_index]; 923 snd_ctl_pcm_next_device_set_devs_index++; 924 return 0; 925 } 926 void snd_pcm_info_set_device(snd_pcm_info_t *obj, unsigned int val) { 927 } 928 void snd_pcm_info_set_subdevice(snd_pcm_info_t *obj, unsigned int val) { 929 } 930 void snd_pcm_info_set_stream(snd_pcm_info_t *obj, snd_pcm_stream_t val) { 931 } 932 int snd_ctl_pcm_info(snd_ctl_t *ctl, snd_pcm_info_t *info) { 933 int ret; 934 snd_ctl_pcm_info_called++; 935 if (snd_ctl_pcm_info_rets_index >= 936 snd_ctl_pcm_info_rets_size) { 937 return -1; 938 } 939 ret = snd_ctl_pcm_info_rets[snd_ctl_pcm_info_rets_index]; 940 snd_ctl_pcm_info_rets_index++; 941 return ret; 942 } 943 int snd_ctl_card_info(snd_ctl_t *ctl, snd_ctl_card_info_t *info) { 944 snd_ctl_card_info_called++; 945 return snd_ctl_card_info_ret; 946 } 947 const char *snd_ctl_card_info_get_name(const snd_ctl_card_info_t *obj) { 948 return "TestName"; 949 } 950 const char *snd_ctl_card_info_get_id(const snd_ctl_card_info_t *obj) { 951 return "TestId"; 952 } 953 int snd_hctl_open(snd_hctl_t **hctlp, const char *name, int mode) { 954 *hctlp = snd_hctl_open_pointer_val; 955 snd_hctl_open_called++; 956 return snd_hctl_open_return_value; 957 } 958 int snd_hctl_nonblock(snd_hctl_t *hctl, int nonblock) { 959 snd_hctl_nonblock_called++; 960 return 0; 961 } 962 int snd_hctl_load(snd_hctl_t *hctl) { 963 snd_hctl_load_called++; 964 return snd_hctl_load_return_value; 965 } 966 int snd_hctl_close(snd_hctl_t *hctl) { 967 snd_hctl_close_called++; 968 return 0; 969 } 970 int snd_hctl_poll_descriptors_count(snd_hctl_t *hctl) { 971 return snd_hctl_poll_descriptors_num_fds; 972 } 973 int snd_hctl_poll_descriptors(snd_hctl_t *hctl, 974 struct pollfd *pfds, 975 unsigned int space) { 976 unsigned int num = MIN(space, snd_hctl_poll_descriptors_num_fds); 977 memcpy(pfds, snd_hctl_poll_descriptors_fds, num * sizeof(*pfds)); 978 snd_hctl_poll_descriptors_called++; 979 return num; 980 } 981 int snd_hctl_handle_events(snd_hctl_t *hctl) { 982 snd_hctl_handle_events_called++; 983 return 0; 984 } 985 986 int cras_system_add_select_fd(int fd, 987 void (*callback)(void *data), 988 void *callback_data) 989 { 990 cras_system_add_select_fd_called++; 991 cras_system_add_select_fd_values.push_back(fd); 992 return 0; 993 } 994 void cras_system_rm_select_fd(int fd) 995 { 996 cras_system_rm_select_fd_called++; 997 cras_system_rm_select_fd_values.push_back(fd); 998 } 999 1000 struct cras_card_config *cras_card_config_create(const char *config_path, 1001 const char *card_name) 1002 { 1003 cras_card_config_dir = config_path; 1004 return NULL; 1005 } 1006 1007 void cras_card_config_destroy(struct cras_card_config *card_config) 1008 { 1009 } 1010 1011 struct cras_volume_curve *cras_card_config_get_volume_curve_for_control( 1012 const struct cras_card_config *card_config, 1013 const char *control_name) 1014 { 1015 return NULL; 1016 } 1017 1018 int cras_device_blacklist_check( 1019 struct cras_device_blacklist *blacklist, 1020 unsigned vendor_id, 1021 unsigned product_id, 1022 unsigned device_index) { 1023 EXPECT_EQ(fake_blacklist, blacklist); 1024 1025 return cras_device_blacklist_check_retval; 1026 } 1027 1028 struct cras_use_case_mgr *ucm_create(const char* name) { 1029 ucm_create_called++; 1030 return reinterpret_cast<struct cras_use_case_mgr *>(0x44); 1031 } 1032 1033 void ucm_destroy(struct cras_use_case_mgr *mgr) { 1034 ucm_destroy_called++; 1035 } 1036 1037 char *ucm_get_dev_for_mixer(struct cras_use_case_mgr *mgr, const char *mixer, 1038 enum CRAS_STREAM_DIRECTION dir) 1039 { 1040 ucm_get_dev_for_mixer_called++; 1041 return strdup("device"); 1042 } 1043 1044 char *ucm_get_flag(struct cras_use_case_mgr *mgr, const char *flag_name) { 1045 ucm_get_flag_called++; 1046 strncpy(ucm_get_flag_name, flag_name, sizeof(ucm_get_flag_name)); 1047 return NULL; 1048 } 1049 1050 struct mixer_name *ucm_get_coupled_mixer_names( 1051 struct cras_use_case_mgr *mgr, const char *dev) 1052 { 1053 return ucm_get_coupled_mixer_names_return_value; 1054 } 1055 1056 int ucm_has_fully_specified_ucm_flag(struct cras_use_case_mgr *mgr) 1057 { 1058 return ucm_has_fully_specified_ucm_flag_return_value; 1059 } 1060 1061 struct ucm_section *ucm_get_sections(struct cras_use_case_mgr *mgr) 1062 { 1063 ucm_get_sections_called++; 1064 return ucm_get_sections_return_value; 1065 } 1066 1067 int cras_alsa_mixer_add_controls_in_section( 1068 struct cras_alsa_mixer *cmix, 1069 struct ucm_section *section) 1070 { 1071 cras_alsa_mixer_add_controls_in_section_called++; 1072 return cras_alsa_mixer_add_controls_in_section_return_value; 1073 } 1074 1075 void ucm_free_mixer_names(struct mixer_name *names) 1076 { 1077 struct mixer_name *m; 1078 DL_FOREACH(names, m) { 1079 DL_DELETE(names, m); 1080 free((void*)m->name); 1081 free(m); 1082 } 1083 } 1084 1085 } /* extern "C" */ 1086 1087 } // namespace 1088 1089 int main(int argc, char **argv) { 1090 ::testing::InitGoogleTest(&argc, argv); 1091 openlog(NULL, LOG_PERROR, LOG_USER); 1092 return RUN_ALL_TESTS(); 1093 } 1094
