| // 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 <stdio.h> |
| #include <string.h> |
| |
| extern "C" { |
| #include "cras_alert.h" |
| #include "cras_board_config.h" |
| #include "cras_shm.h" |
| #include "cras_system_state.h" |
| #include "cras_types.h" |
| } |
| |
| namespace { |
| static struct cras_alsa_card* kFakeAlsaCard; |
| size_t cras_alsa_card_create_called; |
| size_t cras_alsa_card_destroy_called; |
| static size_t add_stub_called; |
| static size_t rm_stub_called; |
| static size_t add_task_stub_called; |
| static size_t callback_stub_called; |
| static void* select_data_value; |
| static void* task_data_value; |
| static size_t add_callback_called; |
| static cras_alert_cb add_callback_cb; |
| static void* add_callback_arg; |
| static size_t rm_callback_called; |
| static cras_alert_cb rm_callback_cb; |
| static void* rm_callback_arg; |
| static size_t alert_pending_called; |
| static char* device_config_dir; |
| static const char* cras_alsa_card_config_dir; |
| static size_t cras_observer_notify_output_volume_called; |
| static size_t cras_observer_notify_output_mute_called; |
| static size_t cras_observer_notify_capture_mute_called; |
| static size_t cras_observer_notify_suspend_changed_called; |
| static size_t cras_observer_notify_num_active_streams_called; |
| static size_t cras_observer_notify_input_streams_with_permission_called; |
| static size_t cras_iodev_list_reset_for_noise_cancellation_called; |
| static struct cras_board_config fake_board_config; |
| static size_t cras_alert_process_all_pending_alerts_called; |
| |
| static void ResetStubData() { |
| cras_alsa_card_create_called = 0; |
| cras_alsa_card_destroy_called = 0; |
| kFakeAlsaCard = reinterpret_cast<struct cras_alsa_card*>(0x33); |
| add_stub_called = 0; |
| rm_stub_called = 0; |
| add_task_stub_called = 0; |
| callback_stub_called = 0; |
| add_callback_called = 0; |
| rm_callback_called = 0; |
| alert_pending_called = 0; |
| device_config_dir = NULL; |
| cras_alsa_card_config_dir = NULL; |
| cras_observer_notify_output_volume_called = 0; |
| cras_observer_notify_output_mute_called = 0; |
| cras_observer_notify_capture_mute_called = 0; |
| cras_observer_notify_suspend_changed_called = 0; |
| cras_observer_notify_num_active_streams_called = 0; |
| cras_observer_notify_input_streams_with_permission_called = 0; |
| cras_alert_process_all_pending_alerts_called = 0; |
| cras_iodev_list_reset_for_noise_cancellation_called = 0; |
| memset(&fake_board_config, 0, sizeof(fake_board_config)); |
| } |
| |
| static int add_stub(int fd, |
| void (*cb)(void* data, int revents), |
| void* callback_data, |
| int events, |
| void* select_data) { |
| add_stub_called++; |
| select_data_value = select_data; |
| return 0; |
| } |
| |
| static void rm_stub(int fd, void* select_data) { |
| rm_stub_called++; |
| select_data_value = select_data; |
| } |
| |
| static int add_task_stub(void (*cb)(void* data), |
| void* callback_data, |
| void* task_data) { |
| add_task_stub_called++; |
| task_data_value = task_data; |
| return 0; |
| } |
| |
| static void callback_stub(void* data, int revents) { |
| callback_stub_called++; |
| } |
| |
| static void task_stub(void* data) { |
| callback_stub_called++; |
| } |
| |
| static void do_sys_init() { |
| char* shm_name; |
| ASSERT_GT(asprintf(&shm_name, "/cras-%d", getpid()), 0); |
| int rw_shm_fd; |
| int ro_shm_fd; |
| struct cras_server_state* exp_state = |
| (struct cras_server_state*)cras_shm_setup(shm_name, sizeof(*exp_state), |
| &rw_shm_fd, &ro_shm_fd); |
| if (!exp_state) |
| exit(-1); |
| cras_system_state_init(device_config_dir, shm_name, rw_shm_fd, ro_shm_fd, |
| exp_state, sizeof(*exp_state)); |
| free(shm_name); |
| } |
| |
| TEST(SystemStateSuite, DefaultVolume) { |
| do_sys_init(); |
| EXPECT_EQ(100, cras_system_get_volume()); |
| EXPECT_EQ(0, cras_system_get_mute()); |
| EXPECT_EQ(0, cras_system_get_capture_mute()); |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemStateSuite, SetVolume) { |
| do_sys_init(); |
| cras_system_set_volume(0); |
| EXPECT_EQ(0, cras_system_get_volume()); |
| cras_system_set_volume(50); |
| EXPECT_EQ(50, cras_system_get_volume()); |
| cras_system_set_volume(CRAS_MAX_SYSTEM_VOLUME); |
| EXPECT_EQ(CRAS_MAX_SYSTEM_VOLUME, cras_system_get_volume()); |
| cras_system_set_volume(CRAS_MAX_SYSTEM_VOLUME + 1); |
| EXPECT_EQ(CRAS_MAX_SYSTEM_VOLUME, cras_system_get_volume()); |
| cras_system_state_deinit(); |
| EXPECT_EQ(4, cras_observer_notify_output_volume_called); |
| } |
| |
| TEST(SystemStateSuite, SetMinMaxVolume) { |
| do_sys_init(); |
| cras_system_set_volume_limits(-10000, -600); |
| EXPECT_EQ(-10000, cras_system_get_min_volume()); |
| EXPECT_EQ(-600, cras_system_get_max_volume()); |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemStateSuite, SetUserMute) { |
| ResetStubData(); |
| do_sys_init(); |
| |
| EXPECT_EQ(0, cras_system_get_mute()); |
| |
| cras_system_set_user_mute(0); |
| EXPECT_EQ(0, cras_system_get_mute()); |
| EXPECT_EQ(0, cras_observer_notify_output_mute_called); |
| |
| cras_system_set_user_mute(1); |
| EXPECT_EQ(1, cras_system_get_mute()); |
| EXPECT_EQ(1, cras_observer_notify_output_mute_called); |
| |
| cras_system_set_user_mute(22); |
| EXPECT_EQ(1, cras_system_get_mute()); |
| EXPECT_EQ(1, cras_observer_notify_output_mute_called); |
| |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemStateSuite, SetMute) { |
| ResetStubData(); |
| do_sys_init(); |
| |
| EXPECT_EQ(0, cras_system_get_mute()); |
| |
| cras_system_set_mute(0); |
| EXPECT_EQ(0, cras_system_get_mute()); |
| EXPECT_EQ(0, cras_observer_notify_output_mute_called); |
| |
| cras_system_set_mute(1); |
| EXPECT_EQ(1, cras_system_get_mute()); |
| EXPECT_EQ(1, cras_observer_notify_output_mute_called); |
| |
| cras_system_set_mute(22); |
| EXPECT_EQ(1, cras_system_get_mute()); |
| EXPECT_EQ(1, cras_observer_notify_output_mute_called); |
| |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemStateSuite, SetSystemMuteThenSwitchUserMute) { |
| ResetStubData(); |
| do_sys_init(); |
| |
| EXPECT_EQ(0, cras_system_get_mute()); |
| |
| // Set system mute. |
| cras_system_set_mute(1); |
| |
| // Switching user mute will not notify observer. |
| EXPECT_EQ(1, cras_observer_notify_output_mute_called); |
| cras_system_set_user_mute(1); |
| EXPECT_EQ(1, cras_observer_notify_output_mute_called); |
| cras_system_set_user_mute(0); |
| EXPECT_EQ(1, cras_observer_notify_output_mute_called); |
| |
| // Unset system mute. |
| cras_system_set_mute(0); |
| EXPECT_EQ(2, cras_observer_notify_output_mute_called); |
| |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemStateSuite, SetUserMuteThenSwitchSystemMute) { |
| ResetStubData(); |
| do_sys_init(); |
| |
| EXPECT_EQ(0, cras_system_get_mute()); |
| |
| // Set user mute. |
| cras_system_set_user_mute(1); |
| |
| // Switching system mute will not notify observer. |
| EXPECT_EQ(1, cras_observer_notify_output_mute_called); |
| cras_system_set_mute(1); |
| EXPECT_EQ(1, cras_observer_notify_output_mute_called); |
| cras_system_set_mute(0); |
| EXPECT_EQ(1, cras_observer_notify_output_mute_called); |
| |
| // Unset user mute. |
| cras_system_set_user_mute(0); |
| EXPECT_EQ(2, cras_observer_notify_output_mute_called); |
| |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemStateSuite, CaptureMuteChangedCallbackMultiple) { |
| do_sys_init(); |
| ResetStubData(); |
| |
| cras_system_set_capture_mute(1); |
| EXPECT_EQ(1, cras_system_get_capture_mute()); |
| EXPECT_EQ(1, cras_observer_notify_capture_mute_called); |
| cras_system_set_capture_mute(0); |
| EXPECT_EQ(0, cras_system_get_capture_mute()); |
| EXPECT_EQ(2, cras_observer_notify_capture_mute_called); |
| |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemStateSuite, MuteLocked) { |
| do_sys_init(); |
| ResetStubData(); |
| |
| cras_system_set_mute(1); |
| EXPECT_EQ(1, cras_system_get_mute()); |
| EXPECT_EQ(0, cras_system_get_mute_locked()); |
| EXPECT_EQ(1, cras_observer_notify_output_mute_called); |
| |
| cras_system_set_mute_locked(1); |
| cras_system_set_mute(0); |
| EXPECT_EQ(1, cras_system_get_mute()); |
| EXPECT_EQ(1, cras_system_get_mute_locked()); |
| EXPECT_EQ(1, cras_observer_notify_output_mute_called); |
| |
| cras_system_set_capture_mute(1); |
| EXPECT_EQ(1, cras_system_get_capture_mute()); |
| EXPECT_EQ(0, cras_system_get_capture_mute_locked()); |
| EXPECT_EQ(1, cras_observer_notify_capture_mute_called); |
| |
| cras_system_set_capture_mute_locked(1); |
| cras_system_set_capture_mute(0); |
| EXPECT_EQ(1, cras_system_get_capture_mute()); |
| EXPECT_EQ(1, cras_system_get_capture_mute_locked()); |
| cras_system_state_deinit(); |
| EXPECT_EQ(2, cras_observer_notify_capture_mute_called); |
| } |
| |
| TEST(SystemStateSuite, Suspend) { |
| do_sys_init(); |
| ResetStubData(); |
| |
| cras_system_set_suspended(1); |
| EXPECT_EQ(1, cras_observer_notify_suspend_changed_called); |
| EXPECT_EQ(1, cras_alert_process_all_pending_alerts_called); |
| EXPECT_EQ(1, cras_system_get_suspended()); |
| |
| cras_system_set_suspended(0); |
| EXPECT_EQ(2, cras_observer_notify_suspend_changed_called); |
| EXPECT_EQ(0, cras_system_get_suspended()); |
| |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemStateSuite, AddCardFailCreate) { |
| ResetStubData(); |
| kFakeAlsaCard = NULL; |
| cras_alsa_card_info info; |
| |
| info.card_type = ALSA_CARD_TYPE_INTERNAL; |
| info.card_index = 0; |
| do_sys_init(); |
| EXPECT_EQ(-ENOMEM, cras_system_add_alsa_card(&info)); |
| EXPECT_EQ(1, cras_alsa_card_create_called); |
| EXPECT_EQ(cras_alsa_card_config_dir, device_config_dir); |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemStateSuite, AddCard) { |
| ResetStubData(); |
| cras_alsa_card_info info; |
| |
| info.card_type = ALSA_CARD_TYPE_INTERNAL; |
| info.card_index = 0; |
| do_sys_init(); |
| EXPECT_EQ(0, cras_system_add_alsa_card(&info)); |
| EXPECT_EQ(1, cras_alsa_card_create_called); |
| EXPECT_EQ(cras_alsa_card_config_dir, device_config_dir); |
| // Adding the same card again should fail. |
| ResetStubData(); |
| EXPECT_NE(0, cras_system_add_alsa_card(&info)); |
| EXPECT_EQ(0, cras_alsa_card_create_called); |
| // Removing card should destroy it. |
| cras_system_remove_alsa_card(0); |
| EXPECT_EQ(1, cras_alsa_card_destroy_called); |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemSettingsRegisterSelectDescriptor, AddSelectFd) { |
| void* stub_data = reinterpret_cast<void*>(44); |
| void* select_data = reinterpret_cast<void*>(33); |
| int rc; |
| |
| ResetStubData(); |
| do_sys_init(); |
| rc = cras_system_add_select_fd(7, callback_stub, stub_data, POLLIN); |
| EXPECT_NE(0, rc); |
| EXPECT_EQ(0, add_stub_called); |
| EXPECT_EQ(0, rm_stub_called); |
| rc = cras_system_set_select_handler(add_stub, rm_stub, select_data); |
| EXPECT_EQ(0, rc); |
| EXPECT_EQ(0, add_stub_called); |
| EXPECT_EQ(0, rm_stub_called); |
| rc = cras_system_set_select_handler(add_stub, rm_stub, select_data); |
| EXPECT_EQ(-EEXIST, rc); |
| EXPECT_EQ(0, add_stub_called); |
| EXPECT_EQ(0, rm_stub_called); |
| rc = cras_system_add_select_fd(7, callback_stub, stub_data, POLLIN); |
| EXPECT_EQ(0, rc); |
| EXPECT_EQ(1, add_stub_called); |
| EXPECT_EQ(select_data, select_data_value); |
| cras_system_rm_select_fd(7); |
| EXPECT_EQ(1, rm_stub_called); |
| EXPECT_EQ(0, callback_stub_called); |
| EXPECT_EQ(select_data, select_data_value); |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemSettingsAddTask, AddTask) { |
| void* stub_data = reinterpret_cast<void*>(44); |
| void* task_data = reinterpret_cast<void*>(33); |
| int rc; |
| |
| do_sys_init(); |
| rc = cras_system_add_task(task_stub, stub_data); |
| EXPECT_NE(0, rc); |
| EXPECT_EQ(0, add_task_stub_called); |
| rc = cras_system_set_add_task_handler(add_task_stub, task_data); |
| EXPECT_EQ(0, rc); |
| EXPECT_EQ(0, add_task_stub_called); |
| rc = cras_system_add_task(task_stub, stub_data); |
| EXPECT_EQ(0, rc); |
| EXPECT_EQ(1, add_task_stub_called); |
| EXPECT_EQ(task_data, task_data_value); |
| |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemSettingsStreamCount, StreamCount) { |
| ResetStubData(); |
| do_sys_init(); |
| |
| EXPECT_EQ(0, cras_system_state_get_active_streams()); |
| cras_system_state_stream_added(CRAS_STREAM_OUTPUT, CRAS_CLIENT_TYPE_CHROME); |
| EXPECT_EQ(1, cras_system_state_get_active_streams()); |
| struct cras_timespec ts1; |
| cras_system_state_get_last_stream_active_time(&ts1); |
| cras_system_state_stream_removed(CRAS_STREAM_OUTPUT, CRAS_CLIENT_TYPE_CHROME); |
| EXPECT_EQ(0, cras_system_state_get_active_streams()); |
| struct cras_timespec ts2; |
| cras_system_state_get_last_stream_active_time(&ts2); |
| EXPECT_NE(0, memcmp(&ts1, &ts2, sizeof(ts1))); |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemSettingsStreamCount, StreamCountByDirection) { |
| ResetStubData(); |
| do_sys_init(); |
| |
| EXPECT_EQ(0, cras_system_state_get_active_streams()); |
| cras_system_state_stream_added(CRAS_STREAM_OUTPUT, CRAS_CLIENT_TYPE_CHROME); |
| cras_system_state_stream_added(CRAS_STREAM_INPUT, CRAS_CLIENT_TYPE_CHROME); |
| cras_system_state_stream_added(CRAS_STREAM_POST_MIX_PRE_DSP, |
| CRAS_CLIENT_TYPE_CHROME); |
| EXPECT_EQ(1, cras_observer_notify_input_streams_with_permission_called); |
| EXPECT_EQ( |
| 1, cras_system_state_get_active_streams_by_direction(CRAS_STREAM_OUTPUT)); |
| EXPECT_EQ( |
| 1, cras_system_state_get_active_streams_by_direction(CRAS_STREAM_INPUT)); |
| EXPECT_EQ(1, cras_system_state_get_active_streams_by_direction( |
| CRAS_STREAM_POST_MIX_PRE_DSP)); |
| EXPECT_EQ(3, cras_system_state_get_active_streams()); |
| EXPECT_EQ(3, cras_observer_notify_num_active_streams_called); |
| cras_system_state_stream_removed(CRAS_STREAM_OUTPUT, CRAS_CLIENT_TYPE_CHROME); |
| cras_system_state_stream_removed(CRAS_STREAM_INPUT, CRAS_CLIENT_TYPE_CHROME); |
| cras_system_state_stream_removed(CRAS_STREAM_POST_MIX_PRE_DSP, |
| CRAS_CLIENT_TYPE_CHROME); |
| EXPECT_EQ(2, cras_observer_notify_input_streams_with_permission_called); |
| EXPECT_EQ( |
| 0, cras_system_state_get_active_streams_by_direction(CRAS_STREAM_OUTPUT)); |
| EXPECT_EQ( |
| 0, cras_system_state_get_active_streams_by_direction(CRAS_STREAM_INPUT)); |
| EXPECT_EQ(0, cras_system_state_get_active_streams_by_direction( |
| CRAS_STREAM_POST_MIX_PRE_DSP)); |
| EXPECT_EQ(0, cras_system_state_get_active_streams()); |
| EXPECT_EQ(6, cras_observer_notify_num_active_streams_called); |
| |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemStateSuite, IgnoreUCMSuffix) { |
| fake_board_config.ucm_ignore_suffix = strdup("TEST1,TEST2,TEST3"); |
| do_sys_init(); |
| |
| EXPECT_EQ(1, cras_system_check_ignore_ucm_suffix("TEST1")); |
| EXPECT_EQ(1, cras_system_check_ignore_ucm_suffix("TEST2")); |
| EXPECT_EQ(1, cras_system_check_ignore_ucm_suffix("TEST3")); |
| EXPECT_EQ(0, cras_system_check_ignore_ucm_suffix("TEST4")); |
| cras_system_state_deinit(); |
| } |
| |
| TEST(SystemStateSuite, SetNoiseCancellationEnabled) { |
| ResetStubData(); |
| do_sys_init(); |
| |
| EXPECT_EQ(0, cras_system_get_noise_cancellation_enabled()); |
| |
| cras_system_set_noise_cancellation_enabled(0); |
| EXPECT_EQ(0, cras_system_get_noise_cancellation_enabled()); |
| EXPECT_EQ(0, cras_iodev_list_reset_for_noise_cancellation_called); |
| |
| cras_system_set_noise_cancellation_enabled(1); |
| EXPECT_EQ(1, cras_system_get_noise_cancellation_enabled()); |
| EXPECT_EQ(1, cras_iodev_list_reset_for_noise_cancellation_called); |
| |
| cras_system_set_noise_cancellation_enabled(1); |
| EXPECT_EQ(1, cras_system_get_noise_cancellation_enabled()); |
| // cras_iodev_list_reset_for_noise_cancellation shouldn't be called if state |
| // is already enabled/disabled. |
| EXPECT_EQ(1, cras_iodev_list_reset_for_noise_cancellation_called); |
| |
| cras_system_set_noise_cancellation_enabled(0); |
| EXPECT_EQ(0, cras_system_get_noise_cancellation_enabled()); |
| EXPECT_EQ(2, cras_iodev_list_reset_for_noise_cancellation_called); |
| |
| cras_system_state_deinit(); |
| } |
| |
| extern "C" { |
| |
| struct cras_alsa_card* cras_alsa_card_create( |
| struct cras_alsa_card_info* info, |
| const char* device_config_dir, |
| struct cras_device_blocklist* blocklist) { |
| cras_alsa_card_create_called++; |
| cras_alsa_card_config_dir = device_config_dir; |
| return kFakeAlsaCard; |
| } |
| |
| void cras_alsa_card_destroy(struct cras_alsa_card* alsa_card) { |
| cras_alsa_card_destroy_called++; |
| } |
| |
| size_t cras_alsa_card_get_index(const struct cras_alsa_card* alsa_card) { |
| return 0; |
| } |
| |
| struct cras_device_blocklist* cras_device_blocklist_create( |
| const char* config_path) { |
| return NULL; |
| } |
| |
| void cras_device_blocklist_destroy(struct cras_device_blocklist* blocklist) {} |
| |
| struct cras_alert* cras_alert_create(cras_alert_prepare prepare, |
| unsigned int flags) { |
| return NULL; |
| } |
| |
| void cras_alert_destroy(struct cras_alert* alert) {} |
| |
| int cras_alert_add_callback(struct cras_alert* alert, |
| cras_alert_cb cb, |
| void* arg) { |
| add_callback_called++; |
| add_callback_cb = cb; |
| add_callback_arg = arg; |
| return 0; |
| } |
| |
| int cras_alert_rm_callback(struct cras_alert* alert, |
| cras_alert_cb cb, |
| void* arg) { |
| rm_callback_called++; |
| rm_callback_cb = cb; |
| rm_callback_arg = arg; |
| return 0; |
| } |
| |
| void cras_alert_pending(struct cras_alert* alert) { |
| alert_pending_called++; |
| } |
| |
| cras_tm* cras_tm_init() { |
| return static_cast<cras_tm*>(malloc(sizeof(unsigned int))); |
| } |
| |
| void cras_tm_deinit(cras_tm* tm) { |
| free(tm); |
| } |
| |
| void cras_observer_notify_output_volume(int32_t volume) { |
| cras_observer_notify_output_volume_called++; |
| } |
| |
| void cras_observer_notify_output_mute(int muted, |
| int user_muted, |
| int mute_locked) { |
| cras_observer_notify_output_mute_called++; |
| } |
| |
| void cras_observer_notify_capture_mute(int muted, int mute_locked) { |
| cras_observer_notify_capture_mute_called++; |
| } |
| |
| void cras_observer_notify_suspend_changed(int suspended) { |
| cras_observer_notify_suspend_changed_called++; |
| } |
| |
| void cras_observer_notify_num_active_streams(enum CRAS_STREAM_DIRECTION dir, |
| uint32_t num_active_streams) { |
| cras_observer_notify_num_active_streams_called++; |
| } |
| |
| void cras_observer_notify_input_streams_with_permission( |
| uint32_t num_input_streams[CRAS_NUM_CLIENT_TYPE]) { |
| cras_observer_notify_input_streams_with_permission_called++; |
| } |
| |
| void cras_board_config_get(const char* config_path, |
| struct cras_board_config* board_config) { |
| *board_config = fake_board_config; |
| } |
| |
| void cras_alert_process_all_pending_alerts() { |
| cras_alert_process_all_pending_alerts_called++; |
| } |
| |
| void cras_iodev_list_reset_for_noise_cancellation() { |
| cras_iodev_list_reset_for_noise_cancellation_called++; |
| } |
| |
| } // extern "C" |
| } // namespace |
| |
| int main(int argc, char** argv) { |
| ::testing::InitGoogleTest(&argc, argv); |
| return RUN_ALL_TESTS(); |
| } |
