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