Home | History | Annotate | Download | only in tests 
      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