// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <gtest/gtest.h>
#include <iniparser.h>
#include <stdio.h>
#include <syslog.h>
#include <map>
extern "C" {
#include "cras_alsa_ucm.h"
#include "cras_types.h"
#include "cras_util.h"
#include "utlist.h"
#include "cras_util.h"
// Include C file to test static functions.
#include "cras_alsa_ucm.c"
}
namespace {
static int snd_use_case_mgr_open_return;
static snd_use_case_mgr_t *snd_use_case_mgr_open_mgr_ptr;
static unsigned snd_use_case_mgr_open_called;
static unsigned snd_use_case_mgr_close_called;
static unsigned snd_use_case_get_called;
static std::vector<std::string> snd_use_case_get_id;
static int snd_use_case_set_return;
static std::map<std::string, std::string> snd_use_case_get_value;
static unsigned snd_use_case_set_called;
static std::vector<std::pair<std::string, std::string> > snd_use_case_set_param;
static std::map<std::string, const char **> fake_list;
static std::map<std::string, unsigned> fake_list_size;
static unsigned snd_use_case_free_list_called;
static std::vector<std::string> list_devices_callback_names;
static std::vector<void*> list_devices_callback_args;
static struct cras_use_case_mgr cras_ucm_mgr;
static const char *avail_verbs[] = { "HiFi", "Comment for Verb1" };
static void ResetStubData() {
snd_use_case_mgr_open_called = 0;
snd_use_case_mgr_open_return = 0;
snd_use_case_mgr_close_called = 0;
snd_use_case_set_return = 0;
snd_use_case_get_called = 0;
snd_use_case_set_called = 0;
snd_use_case_set_param.clear();
snd_use_case_free_list_called = 0;
snd_use_case_get_id.clear();
snd_use_case_get_value.clear();
fake_list.clear();
fake_list_size.clear();
fake_list["_verbs"] = avail_verbs;
fake_list_size["_verbs"] = 2;
list_devices_callback_names.clear();
list_devices_callback_args.clear();
snd_use_case_mgr_open_mgr_ptr = reinterpret_cast<snd_use_case_mgr_t*>(0x55);
cras_ucm_mgr.use_case = CRAS_STREAM_TYPE_DEFAULT;
}
static void list_devices_callback(const char* section_name, void *arg) {
list_devices_callback_names.push_back(std::string(section_name));
list_devices_callback_args.push_back(arg);
}
static void SetSectionDeviceData() {
static const char *sections[] = { "Speaker", "Comment for Dev1",
"IntMic", "Comment for Dev2",
"Headphone", "Comment for Dev3",
"ExtMic", "Comment for Dev4",
"HDMI", "Comment for Dev5"};
fake_list["_devices/HiFi"] = sections;
fake_list_size["_devices/HiFi"] = 10;
std::string id_1 = "=PlaybackPCM/Speaker/HiFi";
std::string id_2 = "=CapturePCM/IntMic/HiFi";
std::string id_3 = "=PlaybackPCM/Headphone/HiFi";
std::string id_4 = "=CapturePCM/ExtMic/HiFi";
std::string id_5 = "=PlaybackPCM/HDMI/HiFi";
std::string value_1 = "test_card:0";
std::string value_2 = "test_card:0";
std::string value_3 = "test_card:0";
std::string value_4 = "test_card:0";
std::string value_5 = "test_card:1";
snd_use_case_get_value[id_1] = value_1;
snd_use_case_get_value[id_2] = value_2;
snd_use_case_get_value[id_3] = value_3;
snd_use_case_get_value[id_4] = value_4;
snd_use_case_get_value[id_5] = value_5;
}
TEST(AlsaUcm, CreateFailInvalidCard) {
ResetStubData();
EXPECT_EQ(NULL, ucm_create(NULL));
EXPECT_EQ(0, snd_use_case_mgr_open_called);
}
TEST(AlsaUcm, CreateFailCardNotFound) {
ResetStubData();
snd_use_case_mgr_open_return = -1;
EXPECT_EQ(NULL, ucm_create("foo"));
EXPECT_EQ(1, snd_use_case_mgr_open_called);
}
TEST(AlsaUcm, CreateFailNoHiFi) {
ResetStubData();
snd_use_case_set_return = -1;
EXPECT_EQ(NULL, ucm_create("foo"));
EXPECT_EQ(1, snd_use_case_mgr_open_called);
EXPECT_EQ(1, snd_use_case_set_called);
EXPECT_EQ(1, snd_use_case_mgr_close_called);
}
TEST(AlsaUcm, CreateSuccess) {
struct cras_use_case_mgr *mgr;
ResetStubData();
mgr = ucm_create("foo");
EXPECT_NE(static_cast<snd_use_case_mgr_t*>(NULL), mgr->mgr);
EXPECT_EQ(1, snd_use_case_mgr_open_called);
EXPECT_EQ(1, snd_use_case_set_called);
EXPECT_EQ(0, snd_use_case_mgr_close_called);
ucm_destroy(mgr);
EXPECT_EQ(1, snd_use_case_mgr_close_called);
}
TEST(AlsaUcm, CheckEnabledEmptyList) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
ResetStubData();
fake_list["_enadevs"] = NULL;
fake_list_size["_enadevs"] = 0;
EXPECT_EQ(0, ucm_set_enabled(mgr, "Dev1", 0));
EXPECT_EQ(0, snd_use_case_set_called);
EXPECT_EQ(0, ucm_set_enabled(mgr, "Dev1", 1));
EXPECT_EQ(1, snd_use_case_set_called);
EXPECT_EQ(0, snd_use_case_free_list_called);
}
TEST(AlsaUcm, CheckEnabledAlready) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
const char *enabled[] = { "Dev2", "Dev1" };
ResetStubData();
fake_list["_enadevs"] = enabled;
fake_list_size["_enadevs"] = 2;
EXPECT_EQ(0, ucm_set_enabled(mgr, "Dev1", 1));
EXPECT_EQ(0, snd_use_case_set_called);
EXPECT_EQ(0, ucm_set_enabled(mgr, "Dev1", 0));
EXPECT_EQ(1, snd_use_case_set_called);
EXPECT_EQ(2, snd_use_case_free_list_called);
}
TEST(AlsaUcm, GetEdidForDev) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
std::string id = "=EDIDFile/Dev1/HiFi";
std::string value = "EdidFileName";
const char *file_name;
ResetStubData();
snd_use_case_get_value[id] = value;
file_name = ucm_get_edid_file_for_dev(mgr, "Dev1");
ASSERT_TRUE(file_name);
EXPECT_EQ(0, strcmp(file_name, value.c_str()));
free((void*)file_name);
ASSERT_EQ(1, snd_use_case_get_called);
EXPECT_EQ(snd_use_case_get_id[0], id);
}
TEST(AlsaUcm, GetCapControlForDev) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
char *cap_control;
std::string id = "=CaptureControl/Dev1/HiFi";
std::string value = "MIC";
ResetStubData();
snd_use_case_get_value[id] = value;
cap_control = ucm_get_cap_control(mgr, "Dev1");
ASSERT_TRUE(cap_control);
EXPECT_EQ(0, strcmp(cap_control, value.c_str()));
free(cap_control);
ASSERT_EQ(1, snd_use_case_get_called);
EXPECT_EQ(snd_use_case_get_id[0], id);
}
TEST(AlsaUcm, GetOverrideType) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
const char *override_type_name;
std::string id = "=OverrideNodeType/Dev1/HiFi";
std::string value = "HDMI";
ResetStubData();
snd_use_case_get_value[id] = value;
override_type_name = ucm_get_override_type_name(mgr, "Dev1");
ASSERT_TRUE(override_type_name);
EXPECT_EQ(0, strcmp(override_type_name, value.c_str()));
free((void*)override_type_name);
ASSERT_EQ(1, snd_use_case_get_called);
EXPECT_EQ(snd_use_case_get_id[0], id);
}
TEST(AlsaUcm, GetSectionsForVar) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
struct section_name *section_names, *c;
ResetStubData();
const char *sections[] = { "Sec1", "Comment for Sec1",
"Sec2", "Comment for Sec2",
"Sec3", "Comment for Sec3"};
fake_list["Identifier"] = sections;
fake_list_size["Identifier"] = 6;
std::string id_1 = "=Var/Sec1/HiFi";
std::string id_2 = "=Var/Sec2/HiFi";
std::string id_3 = "=Var/Sec3/HiFi";
std::string value_1 = "Value1";
std::string value_2 = "Value2";
std::string value_3 = "Value2";
snd_use_case_get_value[id_1] = value_1;
snd_use_case_get_value[id_2] = value_2;
snd_use_case_get_value[id_3] = value_3;
section_names = ucm_get_sections_for_var(mgr, "Var", "Value2", "Identifier",
CRAS_STREAM_OUTPUT);
ASSERT_TRUE(section_names);
EXPECT_EQ(0, strcmp(section_names->name, "Sec2"));
EXPECT_EQ(0, strcmp(section_names->next->name, "Sec3"));
ASSERT_EQ(3, snd_use_case_get_called);
EXPECT_EQ(snd_use_case_get_id[0], id_1);
EXPECT_EQ(snd_use_case_get_id[1], id_2);
EXPECT_EQ(snd_use_case_get_id[2], id_3);
DL_FOREACH(section_names, c) {
DL_DELETE(section_names, c);
free((void*)c->name);
free(c);
}
}
TEST(AlsaUcm, GetDevForJack) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
const char *dev_name;
const char *devices[] = { "Dev1", "Comment for Dev1", "Dev2",
"Comment for Dev2" };
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = 4;
std::string id_1 = "=JackName/Dev1/HiFi";
std::string id_2 = "=JackName/Dev2/HiFi";
std::string value_1 = "Value1";
std::string value_2 = "Value2";
snd_use_case_get_value[id_1] = value_1;
snd_use_case_get_value[id_2] = value_2;
dev_name = ucm_get_dev_for_jack(mgr, value_2.c_str(), CRAS_STREAM_OUTPUT);
ASSERT_TRUE(dev_name);
EXPECT_EQ(0, strcmp(dev_name, "Dev2"));
free((void*)dev_name);
ASSERT_EQ(2, snd_use_case_get_called);
EXPECT_EQ(snd_use_case_get_id[0], id_1);
EXPECT_EQ(snd_use_case_get_id[1], id_2);
}
TEST(AlsaUcm, GetDevForHeadphoneJack) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
const char *dev_name;
const char *devices[] = { "Mic", "Comment for Dev1", "Headphone",
"Comment for Dev2" };
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = 4;
std::string id_1 = "=JackName/Mic/HiFi";
std::string id_2 = "=JackName/Headphone/HiFi";
std::string value = "JackValue";
snd_use_case_get_value[id_1] = value;
snd_use_case_get_value[id_2] = value;
/* Looking for jack with matched value with output direction, Headphone will
* be found even though Mic section has the matched value too. */
dev_name = ucm_get_dev_for_jack(mgr, value.c_str(), CRAS_STREAM_OUTPUT);
ASSERT_TRUE(dev_name);
EXPECT_EQ(0, strcmp(dev_name, "Headphone"));
free((void*)dev_name);
}
TEST(AlsaUcm, GetDevForMicJack) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
const char *dev_name;
const char *devices[] = { "Headphone", "Comment for Dev1", "Mic",
"Comment for Dev2" };
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = 4;
std::string id_1 = "=JackName/Headphone/HiFi";
std::string id_2 = "=JackName/Mic/HiFi";
std::string value = "JackValue";
snd_use_case_get_value[id_1] = value;
snd_use_case_get_value[id_2] = value;
/* Looking for jack with matched value with input direction, Mic will be found
* even though Headphone section has the matched value too. */
dev_name = ucm_get_dev_for_jack(mgr, value.c_str(), CRAS_STREAM_INPUT);
ASSERT_TRUE(dev_name);
EXPECT_EQ(0, strcmp(dev_name, "Mic"));
free((void*)dev_name);
}
TEST(AlsaUcm, GetDevForMixer) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
const char *dev_name_out, *dev_name_in;
const char *devices[] = { "Dev1", "Comment for Dev1", "Dev2",
"Comment for Dev2" };
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = 4;
std::string id_1 = "=MixerName/Dev1/HiFi";
std::string id_2 = "=MixerName/Dev2/HiFi";
std::string value_1 = "Value1";
std::string value_2 = "Value2";
snd_use_case_get_value[id_1] = value_1;
snd_use_case_get_value[id_2] = value_2;
dev_name_out = ucm_get_dev_for_mixer(
mgr, value_1.c_str(), CRAS_STREAM_OUTPUT);
dev_name_in = ucm_get_dev_for_mixer(mgr, value_2.c_str(), CRAS_STREAM_INPUT);
ASSERT_TRUE(dev_name_out);
EXPECT_EQ(0, strcmp(dev_name_out, "Dev1"));
free((void*)dev_name_out);
ASSERT_TRUE(dev_name_in);
EXPECT_EQ(0, strcmp(dev_name_in, "Dev2"));
free((void*)dev_name_in);
}
TEST(AlsaUcm, GetDeviceNameForDevice) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
const char *input_dev_name, *output_dev_name;
const char *devices[] = { "Dev1", "Comment for Dev1", "Dev2",
"Comment for Dev2" };
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = 4;
std::string id_1 = "=CapturePCM/Dev1/HiFi";
std::string id_2 = "=PlaybackPCM/Dev2/HiFi";
std::string value_1 = "DeviceName1";
std::string value_2 = "DeviceName2";
snd_use_case_get_value[id_1] = value_1;
snd_use_case_get_value[id_2] = value_2;
input_dev_name = ucm_get_device_name_for_dev(mgr, "Dev1", CRAS_STREAM_INPUT);
output_dev_name = ucm_get_device_name_for_dev(mgr, "Dev2", CRAS_STREAM_OUTPUT);
ASSERT_TRUE(input_dev_name);
ASSERT_TRUE(output_dev_name);
EXPECT_EQ(0, strcmp(input_dev_name, value_1.c_str()));
EXPECT_EQ(0, strcmp(output_dev_name, value_2.c_str()));
ASSERT_EQ(2, snd_use_case_get_called);
EXPECT_EQ(snd_use_case_get_id[0], id_1);
EXPECT_EQ(snd_use_case_get_id[1], id_2);
}
TEST(AlsaUcm, GetDeviceRateForDevice) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
int input_dev_rate, output_dev_rate;
const char *devices[] = { "Dev1", "Comment for Dev1", "Dev2",
"Comment for Dev2" };
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = 4;
std::string id_1 = "=CaptureRate/Dev1/HiFi";
std::string id_2 = "=PlaybackRate/Dev2/HiFi";
std::string value_1 = "44100";
std::string value_2 = "48000";
snd_use_case_get_value[id_1] = value_1;
snd_use_case_get_value[id_2] = value_2;
input_dev_rate = ucm_get_sample_rate_for_dev(mgr, "Dev1", CRAS_STREAM_INPUT);
output_dev_rate = ucm_get_sample_rate_for_dev(mgr, "Dev2",
CRAS_STREAM_OUTPUT);
EXPECT_EQ(44100, input_dev_rate);
EXPECT_EQ(48000, output_dev_rate);
ASSERT_EQ(2, snd_use_case_get_called);
EXPECT_EQ(snd_use_case_get_id[0], id_1);
EXPECT_EQ(snd_use_case_get_id[1], id_2);
}
TEST(AlsaUcm, GetCaptureChannelMapForDevice) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
int8_t channel_layout[CRAS_CH_MAX];
int rc;
ResetStubData();
std::string id_1 = "=CaptureChannelMap/Dev1/HiFi";
std::string value_1 = "-1 -1 0 1 -1 -1 -1 -1 -1 -1 -1";
snd_use_case_get_value[id_1] = value_1;
rc = ucm_get_capture_chmap_for_dev(mgr, "Dev1", channel_layout);
EXPECT_EQ(0, rc);
ASSERT_EQ(1, snd_use_case_get_called);
EXPECT_EQ(snd_use_case_get_id[0], id_1);
EXPECT_EQ(channel_layout[0], -1);
EXPECT_EQ(channel_layout[1], -1);
EXPECT_EQ(channel_layout[2], 0);
EXPECT_EQ(channel_layout[3], 1);
EXPECT_EQ(channel_layout[4], -1);
EXPECT_EQ(channel_layout[5], -1);
EXPECT_EQ(channel_layout[6], -1);
EXPECT_EQ(channel_layout[7], -1);
EXPECT_EQ(channel_layout[8], -1);
EXPECT_EQ(channel_layout[9], -1);
EXPECT_EQ(channel_layout[10], -1);
}
TEST(AlsaUcm, GetHotwordModels) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
const char *models;
const char *modifiers[] = { "Mod1",
"Comment1",
"Hotword Model en",
"Comment2",
"Hotword Model jp",
"Comment3",
"Mod2",
"Comment4",
"Hotword Model de",
"Comment5" };
ResetStubData();
fake_list["_modifiers/HiFi"] = modifiers;
fake_list_size["_modifiers/HiFi"] = 10;
models = ucm_get_hotword_models(mgr);
ASSERT_TRUE(models);
EXPECT_EQ(0, strcmp(models, "en,jp,de"));
}
TEST(AlsaUcm, SetHotwordModel) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
const char *modifiers[] = { "Hotword Model en",
"Comment1",
"Hotword Model jp",
"Comment2",
"Hotword Model de",
"Comment3" };
const char *enabled_mods[] = { "Hotword Model en" };
ResetStubData();
fake_list["_modifiers/HiFi"] = modifiers;
fake_list_size["_modifiers/HiFi"] = 6;
EXPECT_EQ(-EINVAL, ucm_set_hotword_model(mgr, "zh"));
EXPECT_EQ(0, snd_use_case_set_called);
fake_list["_enamods"] = enabled_mods;
fake_list_size["_enamods"] = 1;
ucm_set_hotword_model(mgr, "jp");
EXPECT_EQ(2, snd_use_case_set_called);
EXPECT_EQ(snd_use_case_set_param[0],
std::make_pair(std::string("_dismod"), std::string("Hotword Model en")));
EXPECT_EQ(snd_use_case_set_param[1],
std::make_pair(std::string("_enamod"), std::string("Hotword Model jp")));
}
TEST(AlsaUcm, SwapModeExists) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
int rc;
const char *modifiers_1[] = { "Speaker Swap Mode",
"Comment for Speaker Swap Mode",
"Microphone Swap Mode",
"Comment for Microphone Swap Mode" };
const char *modifiers_2[] = { "Speaker Some Mode",
"Comment for Speaker Some Mode",
"Microphone Some Mode",
"Comment for Microphone Some Mode" };
ResetStubData();
fake_list["_modifiers/HiFi"] = modifiers_1;
fake_list_size["_modifiers/HiFi"] = 4;
rc = ucm_swap_mode_exists(mgr);
EXPECT_EQ(1, rc);
fake_list["_modifiers/HiFi"] = modifiers_2;
fake_list_size["_modifiers/HiFi"] = 4;
rc = ucm_swap_mode_exists(mgr);
EXPECT_EQ(0, rc);
}
TEST(AlsaUcm, EnableSwapMode) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
int rc;
const char *modifiers[] = { "Speaker Swap Mode",
"Comment for Speaker Swap Mode",
"Microphone Swap Mode",
"Comment for Microphone Swap Mode" };
const char *modifiers_enabled[] = {"Speaker Swap Mode"};
ResetStubData();
fake_list["_modifiers/HiFi"] = modifiers;
fake_list_size["_modifiers/HiFi"] = 4;
fake_list["_enamods"] = modifiers_enabled;
fake_list_size["_enamods"] = 1;
snd_use_case_set_return = 0;
rc = ucm_enable_swap_mode(mgr, "Headphone", 1);
EXPECT_EQ(-EPERM, rc);
EXPECT_EQ(0, snd_use_case_set_called);
rc = ucm_enable_swap_mode(mgr, "Speaker", 1);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, snd_use_case_set_called);
rc = ucm_enable_swap_mode(mgr, "Microphone", 1);
EXPECT_EQ(0, rc);
EXPECT_EQ(1, snd_use_case_set_called);
}
TEST(AlsaUcm, DisableSwapMode) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
int rc;
const char *modifiers[] = { "Speaker Swap Mode",
"Comment for Speaker Swap Mode",
"Microphone Swap Mode",
"Comment for Microphone Swap Mode" };
const char *modifiers_enabled[] = {"Speaker Swap Mode"};
ResetStubData();
fake_list["_modifiers/HiFi"] = modifiers;
fake_list_size["_modifiers/HiFi"] = 4;
fake_list["_enamods"] = modifiers_enabled;
fake_list_size["_enamods"] = 1;
snd_use_case_set_return = 0;
rc = ucm_enable_swap_mode(mgr, "Headphone", 0);
EXPECT_EQ(-EPERM, rc);
EXPECT_EQ(0, snd_use_case_set_called);
rc = ucm_enable_swap_mode(mgr, "Microphone", 0);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, snd_use_case_set_called);
rc = ucm_enable_swap_mode(mgr, "Speaker", 0);
EXPECT_EQ(0, rc);
EXPECT_EQ(1, snd_use_case_set_called);
}
TEST(AlsaFlag, GetFlag) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
char *flag_value;
std::string id = "=FlagName//HiFi";
std::string value = "1";
ResetStubData();
snd_use_case_get_value[id] = value;
flag_value = ucm_get_flag(mgr, "FlagName");
ASSERT_TRUE(flag_value);
EXPECT_EQ(0, strcmp(flag_value, value.c_str()));
free(flag_value);
ASSERT_EQ(1, snd_use_case_get_called);
EXPECT_EQ(snd_use_case_get_id[0], id);
}
TEST(AlsaUcm, ModifierEnabled) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
int enabled;
ResetStubData();
const char *mods[] = { "Mod1", "Mod2" };
fake_list["_enamods"] = mods;
fake_list_size["_enamods"] = 2;
enabled = modifier_enabled(mgr, "Mod1");
EXPECT_EQ(1, enabled);
enabled = modifier_enabled(mgr, "Mod2");
EXPECT_EQ(1, enabled);
enabled = modifier_enabled(mgr, "Mod3");
EXPECT_EQ(0, enabled);
}
TEST(AlsaUcm, SetModifierEnabled) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
ResetStubData();
ucm_set_modifier_enabled(mgr, "Mod1", 1);
EXPECT_EQ(snd_use_case_set_param[0],
std::make_pair(std::string("_enamod"), std::string("Mod1")));
EXPECT_EQ(1, snd_use_case_set_called);
ucm_set_modifier_enabled(mgr, "Mod1", 0);
EXPECT_EQ(snd_use_case_set_param[1],
std::make_pair(std::string("_dismod"), std::string("Mod1")));
EXPECT_EQ(2, snd_use_case_set_called);
}
TEST(AlsaUcm, EndWithSuffix) {
EXPECT_EQ(1, ucm_str_ends_with_suffix("Foo bar", "bar"));
EXPECT_EQ(1, ucm_str_ends_with_suffix("bar", "bar"));
EXPECT_EQ(0, ucm_str_ends_with_suffix("Foo car", "bar"));
}
TEST(AlsaUcm, SectionExistsWithName) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
const char *sections[] = { "Sec1", "Comment for Sec1", "Sec2",
"Comment for Sec2" };
ResetStubData();
fake_list["Identifier"] = sections;
fake_list_size["Identifier"] = 4;
EXPECT_EQ(1, ucm_section_exists_with_name(mgr, "Sec1", "Identifier"));
EXPECT_EQ(1, ucm_section_exists_with_name(mgr, "Sec2", "Identifier"));
EXPECT_EQ(0, ucm_section_exists_with_name(mgr, "Sec3", "Identifier"));
}
TEST(AlsaUcm, SectionExistsWithSuffix) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
ResetStubData();
const char *sections[] = { "Sec1 Suffix1", "Comment for Sec1",
"Sec2 Suffix2", "Comment for Sec2" };
fake_list["Identifier"] = sections;
fake_list_size["Identifier"] = 4;
EXPECT_EQ(1, ucm_section_exists_with_suffix(mgr, "Suffix1", "Identifier"));
EXPECT_EQ(1, ucm_section_exists_with_suffix(mgr, "Suffix2", "Identifier"));
EXPECT_EQ(0, ucm_section_exists_with_suffix(mgr, "Suffix3", "Identifier"));
}
TEST(AlsaUcm, DisableSoftwareVolume) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
unsigned int disable_software_volume;
std::string id = "=DisableSoftwareVolume//HiFi";
std::string value = "1";
ResetStubData();
snd_use_case_get_value[id] = value;
disable_software_volume = ucm_get_disable_software_volume(mgr);
ASSERT_TRUE(disable_software_volume);
ASSERT_EQ(1, snd_use_case_get_called);
EXPECT_EQ(snd_use_case_get_id[0], id);
}
TEST(AlsaUcm, GetCoupledMixersForDevice) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
struct mixer_name *mixer_names_1, *mixer_names_2, *c;
const char *devices[] = { "Dev1", "Comment for Dev1", "Dev2",
"Comment for Dev2" };
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = 4;
std::string id_1 = "=CoupledMixers/Dev1/HiFi";
std::string value_1 = "Mixer Name1,Mixer Name2,Mixer Name3";
std::string id_2 = "=CoupledMixers/Dev2/HiFi";
std::string value_2 = "";
snd_use_case_get_value[id_1] = value_1;
snd_use_case_get_value[id_2] = value_2;
mixer_names_1 = ucm_get_coupled_mixer_names(mgr, "Dev1");
mixer_names_2 = ucm_get_coupled_mixer_names(mgr, "Dev2");
ASSERT_TRUE(mixer_names_1);
EXPECT_EQ(0, strcmp(mixer_names_1->name, "Mixer Name1"));
EXPECT_EQ(0, strcmp(mixer_names_1->next->name, "Mixer Name2"));
EXPECT_EQ(0, strcmp(mixer_names_1->next->next->name, "Mixer Name3"));
EXPECT_EQ(NULL, mixer_names_1->next->next->next);
EXPECT_EQ(NULL, mixer_names_2);
DL_FOREACH(mixer_names_1, c) {
DL_DELETE(mixer_names_1, c);
free((void*)c->name);
free(c);
}
}
TEST(AlsaUcm, FreeMixerNames) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
struct mixer_name *mixer_names_1;
const char *devices[] = { "Dev1", "Comment for Dev1"};
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = 2;
std::string id_1 = "=CoupledMixers/Dev1/HiFi";
std::string value_1 = "Mixer Name1,Mixer Name2,Mixer Name3";
snd_use_case_get_value[id_1] = value_1;
mixer_names_1 = ucm_get_coupled_mixer_names(mgr, "Dev1");
ASSERT_TRUE(mixer_names_1);
EXPECT_EQ(0, strcmp(mixer_names_1->name, "Mixer Name1"));
EXPECT_EQ(0, strcmp(mixer_names_1->next->name, "Mixer Name2"));
EXPECT_EQ(0, strcmp(mixer_names_1->next->next->name, "Mixer Name3"));
EXPECT_EQ(NULL, mixer_names_1->next->next->next);
/* No way to actually check if memory is freed. */
mixer_name_free(mixer_names_1);
}
TEST(AlsaUcm, MaxSoftwareGain) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
long max_software_gain;
int ret;
std::string id = "=MaxSoftwareGain/Internal Mic/HiFi";
std::string value = "2000";
ResetStubData();
/* Value can be found in UCM. */
snd_use_case_get_value[id] = value;
ret = ucm_get_max_software_gain(mgr, "Internal Mic", &max_software_gain);
EXPECT_EQ(0, ret);
EXPECT_EQ(2000, max_software_gain);
ResetStubData();
/* Value can not be found in UCM. */
ret = ucm_get_max_software_gain(mgr, "Internal Mic", &max_software_gain);
ASSERT_TRUE(ret);
}
TEST(AlsaUcm, DefaultNodeGain) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
long default_node_gain;
int ret;
std::string id = "=DefaultNodeGain/Internal Mic/HiFi";
std::string value = "-2000";
ResetStubData();
/* Value can be found in UCM. */
snd_use_case_get_value[id] = value;
ret = ucm_get_default_node_gain(mgr, "Internal Mic", &default_node_gain);
EXPECT_EQ(0, ret);
EXPECT_EQ(-2000, default_node_gain);
ResetStubData();
/* Value can not be found in UCM. */
ret = ucm_get_default_node_gain(mgr, "Internal Mic", &default_node_gain);
ASSERT_TRUE(ret);
}
TEST(AlsaUcm, UseFullySpecifiedUCMConfig) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
int fully_specified_flag;
std::string id = "=FullySpecifiedUCM//HiFi";
ResetStubData();
/* Flag is not set */
fully_specified_flag = ucm_has_fully_specified_ucm_flag(mgr);
ASSERT_FALSE(fully_specified_flag);
/* Flag is set to "1". */
snd_use_case_get_value[id] = std::string("1");
fully_specified_flag = ucm_has_fully_specified_ucm_flag(mgr);
ASSERT_TRUE(fully_specified_flag);
/* Flag is set to "0". */
snd_use_case_get_value[id] = std::string("0");
fully_specified_flag = ucm_has_fully_specified_ucm_flag(mgr);
ASSERT_FALSE(fully_specified_flag);
}
TEST(AlsaUcm, EnableHtimestampFlag) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
unsigned int enable_htimestamp_flag;
std::string id = "=EnableHtimestamp//HiFi";
ResetStubData();
/* Flag is not set */
enable_htimestamp_flag = ucm_get_enable_htimestamp_flag(mgr);
ASSERT_FALSE(enable_htimestamp_flag);
/* Flag is set to "1". */
snd_use_case_get_value[id] = std::string("1");
enable_htimestamp_flag = ucm_get_enable_htimestamp_flag(mgr);
ASSERT_TRUE(enable_htimestamp_flag);
/* Flag is set to "0". */
snd_use_case_get_value[id] = std::string("0");
enable_htimestamp_flag = ucm_get_enable_htimestamp_flag(mgr);
ASSERT_FALSE(enable_htimestamp_flag);
}
TEST(AlsaUcm, GetMixerNameForDevice) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
const char *mixer_name_1, *mixer_name_2;
const char *devices[] = { "Dev1", "Comment for Dev1", "Dev2",
"Comment for Dev2" };
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = 4;
std::string id_1 = "=MixerName/Dev1/HiFi";
std::string id_2 = "=MixerName/Dev2/HiFi";
std::string value_1 = "MixerName1";
std::string value_2 = "MixerName2";
snd_use_case_get_value[id_1] = value_1;
snd_use_case_get_value[id_2] = value_2;
mixer_name_1 = ucm_get_mixer_name_for_dev(mgr, "Dev1");
mixer_name_2 = ucm_get_mixer_name_for_dev(mgr, "Dev2");
EXPECT_EQ(0, strcmp(mixer_name_1, value_1.c_str()));
EXPECT_EQ(0, strcmp(mixer_name_2, value_2.c_str()));
}
TEST(AlsaUcm, GetMainVolumeMixerName) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
struct mixer_name *mixer_names_1, *mixer_names_2, *c;
ResetStubData();
std::string id = "=MainVolumeNames//HiFi";
std::string value_1 = "Mixer Name1,Mixer Name2,Mixer Name3";
snd_use_case_get_value[id] = value_1;
mixer_names_1 = ucm_get_main_volume_names(mgr);
ResetStubData();
/* Can not find MainVolumeNames */
mixer_names_2 = ucm_get_main_volume_names(mgr);
ASSERT_TRUE(mixer_names_1);
EXPECT_EQ(0, strcmp(mixer_names_1->name, "Mixer Name1"));
EXPECT_EQ(0, strcmp(mixer_names_1->next->name, "Mixer Name2"));
EXPECT_EQ(0, strcmp(mixer_names_1->next->next->name, "Mixer Name3"));
EXPECT_EQ(NULL, mixer_names_1->next->next->next);
DL_FOREACH(mixer_names_1, c) {
DL_DELETE(mixer_names_1, c);
free((void*)c->name);
free(c);
}
EXPECT_EQ(NULL, mixer_names_2);
}
TEST(AlsaUcm, ListSectionsByDeviceNameOutput) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
void* callback_arg = reinterpret_cast<void*>(0x56);
int listed = 0;
ResetStubData();
SetSectionDeviceData();
listed = ucm_list_section_devices_by_device_name(
mgr, CRAS_STREAM_OUTPUT, "test_card:0", list_devices_callback,
callback_arg);
EXPECT_EQ(2, listed);
EXPECT_EQ(2, list_devices_callback_names.size());
EXPECT_EQ(2, list_devices_callback_args.size());
EXPECT_EQ(
0, strcmp(list_devices_callback_names[0].c_str(), "Speaker"));
EXPECT_EQ(callback_arg, list_devices_callback_args[0]);
EXPECT_EQ(
0, strcmp(list_devices_callback_names[1].c_str(), "Headphone"));
EXPECT_EQ(callback_arg, list_devices_callback_args[1]);
}
TEST(AlsaUcm, ListSectionsByDeviceNameInput) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
void* callback_arg = reinterpret_cast<void*>(0x56);
int listed = 0;
ResetStubData();
SetSectionDeviceData();
listed = ucm_list_section_devices_by_device_name(
mgr, CRAS_STREAM_INPUT, "test_card:0", list_devices_callback,
callback_arg);
EXPECT_EQ(2, listed);
EXPECT_EQ(2, list_devices_callback_names.size());
EXPECT_EQ(2, list_devices_callback_args.size());
EXPECT_EQ(
0, strcmp(list_devices_callback_names[0].c_str(), "IntMic"));
EXPECT_EQ(callback_arg, list_devices_callback_args[0]);
EXPECT_EQ(
0, strcmp(list_devices_callback_names[1].c_str(), "ExtMic"));
EXPECT_EQ(callback_arg, list_devices_callback_args[1]);
}
TEST(AlsaUcm, GetJackNameForDevice) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
const char *jack_name_1, *jack_name_2;
const char *devices[] = { "Dev1", "Comment for Dev1", "Dev2",
"Comment for Dev2" };
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = 4;
std::string id_1 = "=JackName/Dev1/HiFi";
std::string value_1 = "JackName1";
snd_use_case_get_value[id_1] = value_1;
jack_name_1 = ucm_get_jack_name_for_dev(mgr, "Dev1");
jack_name_2 = ucm_get_jack_name_for_dev(mgr, "Dev2");
EXPECT_EQ(0, strcmp(jack_name_1, value_1.c_str()));
EXPECT_EQ(NULL, jack_name_2);
}
TEST(AlsaUcm, GetJackTypeForDevice) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
const char *jack_type_1, *jack_type_2, *jack_type_3, *jack_type_4;
const char *devices[] = { "Dev1", "Comment for Dev1",
"Dev2", "Comment for Dev2",
"Dev3", "Comment for Dev3",
"Dev4", "Comment for Dev4"};
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = 8;
std::string id_1 = "=JackType/Dev1/HiFi";
std::string value_1 = "hctl";
std::string id_2 = "=JackType/Dev2/HiFi";
std::string value_2 = "gpio";
std::string id_3 = "=JackType/Dev3/HiFi";
std::string value_3 = "something";
snd_use_case_get_value[id_1] = value_1;
snd_use_case_get_value[id_2] = value_2;
snd_use_case_get_value[id_3] = value_3;
jack_type_1 = ucm_get_jack_type_for_dev(mgr, "Dev1");
jack_type_2 = ucm_get_jack_type_for_dev(mgr, "Dev2");
jack_type_3 = ucm_get_jack_type_for_dev(mgr, "Dev3");
jack_type_4 = ucm_get_jack_type_for_dev(mgr, "Dev4");
/* Only "hctl" and "gpio" are valid types. */
EXPECT_EQ(0, strcmp(jack_type_1, value_1.c_str()));
EXPECT_EQ(0, strcmp(jack_type_2, value_2.c_str()));
EXPECT_EQ(NULL, jack_type_3);
EXPECT_EQ(NULL, jack_type_4);
}
TEST(AlsaUcm, GetPeriodFramesForDevice) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
int dma_period_1, dma_period_2, dma_period_3;
const char *devices[] = { "Dev1", "Comment for Dev1",
"Dev2", "Comment for Dev2",
"Dev3", "Comment for Dev3" };
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = 6;
std::string id_1 = "=DmaPeriodMicrosecs/Dev1/HiFi";
std::string value_1 = "1000";
std::string id_2 = "=DmaPeriodMicrosecs/Dev2/HiFi";
std::string value_2 = "-10";
snd_use_case_get_value[id_1] = value_1;
snd_use_case_get_value[id_2] = value_2;
dma_period_1 = ucm_get_dma_period_for_dev(mgr, "Dev1");
dma_period_2 = ucm_get_dma_period_for_dev(mgr, "Dev2");
dma_period_3 = ucm_get_dma_period_for_dev(mgr, "Dev3");
/* Only "hctl" and "gpio" are valid types. */
EXPECT_EQ(1000, dma_period_1);
EXPECT_EQ(0, dma_period_2);
EXPECT_EQ(0, dma_period_3);
}
TEST(AlsaUcm, UcmSection) {
struct ucm_section *section_list = NULL;
struct ucm_section *section;
struct mixer_name *controls = NULL;
struct mixer_name *m_name;
int dev_idx = 0;
size_t i;
enum CRAS_STREAM_DIRECTION dir = CRAS_STREAM_OUTPUT;
static const char *name = "Headphone";
static const char *jack_name = "my-card-name Headset Jack";
static const char *jack_type = "gpio";
static const char *mixer_name = "Control1";
static const char *coupled_names[] = {
"Coupled1",
"Coupled2"
};
section = ucm_section_create(NULL, 0, CRAS_STREAM_OUTPUT, NULL, NULL);
EXPECT_EQ(reinterpret_cast<struct ucm_section*>(NULL), section);
section = ucm_section_create(name, dev_idx, dir, jack_name, jack_type);
EXPECT_NE(reinterpret_cast<struct ucm_section*>(NULL), section);
EXPECT_NE(name, section->name);
EXPECT_EQ(0, strcmp(name, section->name));
EXPECT_EQ(dev_idx, section->dev_idx);
EXPECT_EQ(dir, section->dir);
EXPECT_NE(jack_name, section->jack_name);
EXPECT_NE(jack_type, section->jack_type);
EXPECT_EQ(section->prev, section);
EXPECT_EQ(reinterpret_cast<const char *>(NULL), section->mixer_name);
EXPECT_EQ(reinterpret_cast<struct mixer_name*>(NULL), section->coupled);
EXPECT_EQ(-EINVAL, ucm_section_set_mixer_name(section, NULL));
EXPECT_EQ(-EINVAL, ucm_section_set_mixer_name(NULL, mixer_name));
EXPECT_EQ(0, ucm_section_set_mixer_name(section, mixer_name));
EXPECT_NE(section->mixer_name, mixer_name);
EXPECT_EQ(0, strcmp(section->mixer_name, mixer_name));
EXPECT_EQ(-EINVAL, ucm_section_add_coupled(
section, NULL, MIXER_NAME_VOLUME));
EXPECT_EQ(-EINVAL, ucm_section_add_coupled(
NULL, coupled_names[0], MIXER_NAME_VOLUME));
EXPECT_EQ(0, ucm_section_add_coupled(
section, coupled_names[0], MIXER_NAME_VOLUME));
EXPECT_EQ(-EINVAL, ucm_section_concat_coupled(section, NULL));
EXPECT_EQ(-EINVAL, ucm_section_concat_coupled(
NULL, reinterpret_cast<struct mixer_name*>(0x1111)));
controls = NULL;
for (i = 1; i < ARRAY_SIZE(coupled_names); i++) {
controls = mixer_name_add(controls, coupled_names[i],
CRAS_STREAM_OUTPUT, MIXER_NAME_VOLUME);
}
/* Add controls to the list of coupled controls for this section. */
EXPECT_EQ(0, ucm_section_concat_coupled(section, controls));
i = 0;
DL_FOREACH(section->coupled, m_name) {
EXPECT_NE(m_name->name, coupled_names[i]);
EXPECT_EQ(0, strcmp(m_name->name, coupled_names[i]));
i++;
}
EXPECT_EQ(i, ARRAY_SIZE(coupled_names));
DL_APPEND(section_list, section);
ucm_section_free_list(section_list);
}
TEST(AlsaUcm, GetSections) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
struct ucm_section* sections;
struct ucm_section* section;
struct mixer_name* m_name;
int section_count = 0;
int i = 0;
const char *devices[] = { "Headphone", "The headphones jack.",
"Speaker", "The speakers.",
"Mic", "Microphone jack.",
"Internal Mic", "Internal Microphones",
"HDMI", "HDMI output" };
const char* ids[] = {
"=PlaybackPCM/Headphone/HiFi",
"=JackName/Headphone/HiFi",
"=JackType/Headphone/HiFi",
"=JackSwitch/Headphone/HiFi",
"=CoupledMixers/Headphone/HiFi",
"=PlaybackPCM/Speaker/HiFi",
"=CoupledMixers/Speaker/HiFi",
"=CapturePCM/Mic/HiFi",
"=JackName/Mic/HiFi",
"=JackType/Mic/HiFi",
"=JackSwitch/Mic/HiFi",
"=MixerName/Mic/HiFi",
"=CapturePCM/Internal Mic/HiFi",
"=CoupledMixers/Internal Mic/HiFi",
"=JackSwitch/Internal Mic/HiFi",
"=PlaybackPCM/HDMI/HiFi",
"=MixerName/HDMI/HiFi",
NULL
};
const char* values[] = {
"hw:my-sound-card,0",
"my-sound-card Headset Jack",
"gpio",
"2",
"HP-L,HP-R",
"hw:my-sound-card,0",
"SPK-L,SPK-R",
"hw:my-sound-card,0",
"my-sound-card Headset Jack",
"gpio",
"0",
"CAPTURE",
"hw:my-sound-card,0",
"MIC-L,MIC-R",
"-10",
"hw:my-sound-card,2",
"HDMI",
};
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = ARRAY_SIZE(devices);
while (ids[i]) {
snd_use_case_get_value[ids[i]] = values[i];
i++;
}
sections = ucm_get_sections(mgr);
ASSERT_NE(sections, (struct ucm_section*)NULL);
DL_FOREACH(sections, section) {
section_count++;
}
EXPECT_EQ(section_count, ARRAY_SIZE(devices) / 2);
// Headphone
section = sections;
EXPECT_EQ(0, strcmp(section->name, "Headphone"));
EXPECT_EQ(0, section->dev_idx);
EXPECT_EQ(CRAS_STREAM_OUTPUT, section->dir);
EXPECT_EQ(0, strcmp(section->jack_name, values[1]));
EXPECT_EQ(0, strcmp(section->jack_type, values[2]));
EXPECT_EQ(NULL, section->mixer_name);
ASSERT_NE((struct mixer_name*)NULL, section->coupled);
m_name = section->coupled;
EXPECT_EQ(0, strcmp(m_name->name, "HP-L"));
m_name = m_name->next;
EXPECT_EQ(0, strcmp(m_name->name, "HP-R"));
EXPECT_EQ(NULL, m_name->next);
EXPECT_EQ(2, section->jack_switch);
// Speaker
section = section->next;
EXPECT_EQ(0, strcmp(section->name, "Speaker"));
EXPECT_EQ(0, section->dev_idx);
EXPECT_EQ(CRAS_STREAM_OUTPUT, section->dir);
EXPECT_EQ(NULL, section->jack_name);
EXPECT_EQ(NULL, section->jack_type);
EXPECT_EQ(-1, section->jack_switch);
EXPECT_EQ(NULL, section->mixer_name);
ASSERT_NE((struct mixer_name*)NULL, section->coupled);
m_name = section->coupled;
EXPECT_EQ(0, strcmp(m_name->name, "SPK-L"));
m_name = m_name->next;
EXPECT_EQ(0, strcmp(m_name->name, "SPK-R"));
EXPECT_EQ(NULL, m_name->next);
// Mic
section = section->next;
EXPECT_EQ(0, strcmp(section->name, "Mic"));
EXPECT_EQ(0, section->dev_idx);
EXPECT_EQ(CRAS_STREAM_INPUT, section->dir);
EXPECT_EQ(0, strcmp(section->jack_name, values[1]));
EXPECT_EQ(0, strcmp(section->jack_type, values[2]));
EXPECT_EQ(0, section->jack_switch);
ASSERT_NE((const char *)NULL, section->mixer_name);
EXPECT_EQ(0, strcmp(section->mixer_name, "CAPTURE"));
EXPECT_EQ(NULL, section->coupled);
// Internal Mic
section = section->next;
EXPECT_EQ(0, strcmp(section->name, "Internal Mic"));
EXPECT_EQ(0, section->dev_idx);
EXPECT_EQ(CRAS_STREAM_INPUT, section->dir);
EXPECT_EQ(NULL, section->jack_name);
EXPECT_EQ(NULL, section->jack_type);
EXPECT_EQ(-1, section->jack_switch);
EXPECT_EQ(NULL, section->mixer_name);
ASSERT_NE((struct mixer_name*)NULL, section->coupled);
m_name = section->coupled;
EXPECT_EQ(0, strcmp(m_name->name, "MIC-L"));
m_name = m_name->next;
EXPECT_EQ(0, strcmp(m_name->name, "MIC-R"));
// HDMI
section = section->next;
EXPECT_EQ(0, strcmp(section->name, "HDMI"));
EXPECT_EQ(2, section->dev_idx);
EXPECT_EQ(CRAS_STREAM_OUTPUT, section->dir);
EXPECT_EQ(NULL, section->jack_name);
EXPECT_EQ(NULL, section->jack_type);
EXPECT_EQ(-1, section->jack_switch);
ASSERT_NE((const char *)NULL, section->mixer_name);
EXPECT_EQ(0, strcmp(section->mixer_name, "HDMI"));
EXPECT_EQ(NULL, section->next);
ucm_section_free_list(sections);
}
TEST(AlsaUcm, GetSectionsMissingPCM) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
struct ucm_section* sections;
int i = 0;
const char *devices[] = { "Headphone", "The headphones jack." };
const char* ids[] = {
"=JackName/Headphone/HiFi",
"=CoupledMixers/Headphone/HiFi",
NULL
};
const char* values[] = {
"my-sound-card Headset Jack",
"HP-L,HP-R",
};
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = ARRAY_SIZE(devices);
while (ids[i]) {
snd_use_case_get_value[ids[i]] = values[i];
i++;
}
sections = ucm_get_sections(mgr);
EXPECT_EQ(NULL, sections);
}
TEST(AlsaUcm, GetSectionsBadPCM) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
struct ucm_section* sections;
int i = 0;
const char *devices[] = { "Headphone", "The headphones jack." };
const char* ids[] = {
"=PlaybackPCM/Headphone/HiFi",
"=JackName/Headphone/HiFi",
"=CoupledMixers/Headphone/HiFi",
NULL
};
const char* values[] = {
"hw:my-sound-card:0",
"my-sound-card Headset Jack",
"HP-L,HP-R",
};
ResetStubData();
fake_list["_devices/HiFi"] = devices;
fake_list_size["_devices/HiFi"] = ARRAY_SIZE(devices);
while (ids[i]) {
snd_use_case_get_value[ids[i]] = values[i];
i++;
}
sections = ucm_get_sections(mgr);
EXPECT_EQ(NULL, sections);
}
TEST(AlsaUcm, CheckUseCaseVerbs) {
struct cras_use_case_mgr *mgr = &cras_ucm_mgr;
/* Verifies the mapping between stream types and verbs are correct. */
mgr->use_case = CRAS_STREAM_TYPE_DEFAULT;
EXPECT_EQ(0, strcmp("HiFi", uc_verb(mgr)));
mgr->use_case = CRAS_STREAM_TYPE_MULTIMEDIA;
EXPECT_EQ(0, strcmp("Multimedia", uc_verb(mgr)));
mgr->use_case = CRAS_STREAM_TYPE_VOICE_COMMUNICATION;
EXPECT_EQ(0, strcmp("Voice Call", uc_verb(mgr)));
mgr->use_case = CRAS_STREAM_TYPE_SPEECH_RECOGNITION;
EXPECT_EQ(0, strcmp("Speech", uc_verb(mgr)));
mgr->use_case = CRAS_STREAM_TYPE_PRO_AUDIO;
EXPECT_EQ(0, strcmp("Pro Audio", uc_verb(mgr)));
}
TEST(AlsaUcm, GetAvailUseCases) {
struct cras_use_case_mgr *mgr;
const char *verbs[] = { "HiFi", "Comment for Verb1",
"Voice Call", "Comment for Verb2",
"Speech", "Comment for Verb3" };
ResetStubData();
fake_list["_verbs"] = verbs;
fake_list_size["_verbs"] = 6;
mgr = ucm_create("foo");
EXPECT_EQ(0x0D, mgr->avail_use_cases);
ucm_destroy(mgr);
}
TEST(AlsaUcm, SetUseCase) {
struct cras_use_case_mgr *mgr;
const char *verbs[] = { "HiFi", "Comment for Verb1",
"Voice Call", "Comment for Verb2",
"Speech", "Comment for Verb3" };
int rc;
ResetStubData();
fake_list["_verbs"] = verbs;
fake_list_size["_verbs"] = 6;
mgr = ucm_create("foo");
EXPECT_EQ(snd_use_case_set_param[0],
std::make_pair(std::string("_verb"), std::string("HiFi")));
rc = ucm_set_use_case(mgr, CRAS_STREAM_TYPE_VOICE_COMMUNICATION);
EXPECT_EQ(0, rc);
EXPECT_EQ(mgr->use_case, CRAS_STREAM_TYPE_VOICE_COMMUNICATION);
EXPECT_EQ(snd_use_case_set_param[1],
std::make_pair(std::string("_verb"), std::string("Voice Call")));
/* Request unavailable use case will fail. */
rc = ucm_set_use_case(mgr, CRAS_STREAM_TYPE_PRO_AUDIO);
EXPECT_EQ(-1, rc);
/* cras_use_case_mgr's use case should not be changed. */
EXPECT_EQ(mgr->use_case, CRAS_STREAM_TYPE_VOICE_COMMUNICATION);
/* And snd_use_case_set not being called. */
EXPECT_EQ(2, snd_use_case_set_param.size());
ucm_destroy(mgr);
}
/* Stubs */
extern "C" {
int snd_use_case_mgr_open(snd_use_case_mgr_t** uc_mgr, const char* card_name) {
snd_use_case_mgr_open_called++;
*uc_mgr = snd_use_case_mgr_open_mgr_ptr;
return snd_use_case_mgr_open_return;
}
int snd_use_case_mgr_close(snd_use_case_mgr_t *uc_mgr) {
snd_use_case_mgr_close_called++;
return 0;
}
int snd_use_case_get(snd_use_case_mgr_t* uc_mgr,
const char *identifier,
const char **value) {
snd_use_case_get_called++;
snd_use_case_get_id.push_back(std::string(identifier));
if (snd_use_case_get_value.find(identifier) == snd_use_case_get_value.end()) {
*value = NULL;
return -1;
}
*value = strdup(snd_use_case_get_value[identifier].c_str());
return 0;
}
int snd_use_case_set(snd_use_case_mgr_t* uc_mgr,
const char *identifier,
const char *value) {
snd_use_case_set_called++;
snd_use_case_set_param.push_back(
std::make_pair(std::string(identifier), std::string(value)));
return snd_use_case_set_return;
}
int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr,
const char *identifier,
const char **list[]) {
*list = fake_list[identifier];
return fake_list_size[identifier];
}
int snd_use_case_free_list(const char *list[], int items) {
snd_use_case_free_list_called++;
return 0;
}
} /* extern "C" */
} // namespace
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
openlog(NULL, LOG_PERROR, LOG_USER);
return RUN_ALL_TESTS();
}