/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* limitations under the License.
*/
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
-#include "gtest_libmm-radio.h"
-#include "mm_error.h"
-#include "mm_radio.h"
+#include "ut_base.hpp"
using ::testing::InitGoogleTest;
using ::testing::Test;
using ::testing::TestCase;
+using ::testing::_;
+using ::testing::Return;
+using ::testing::ReturnArg;
using namespace std;
-int ret;
-MMHandleType hradio;
+class MMRadioMockTest : public MMRadioMockBaseTest {
+public:
+ void SetUp() {
+ EXPECT_CALL(*_radioMock, _mmradio_create_radio(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+ ret = mm_radio_create(&radio);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+ }
-static int _message_callback(int message, void *pParam, void *user_param)
-{
- MMMessageParamType* param = (MMMessageParamType*)pParam;
-
- cout << "incoming message :" << message << endl;
-
- switch(message)
- {
- case MM_MESSAGE_STATE_CHANGED:
- cout << "MM_MESSAGE_STATE_CHANGED: current : " << param->state.current
- << "old : " << param->state.previous << endl;
- break;
- case MM_MESSAGE_RADIO_SCAN_START:
- cout << "MM_MESSAGE_RADIO_SCAN_START" << endl;
- break;
- case MM_MESSAGE_RADIO_SCAN_INFO:
- cout << "MM_MESSAGE_RADIO_SCAN_INFO : freq : " << param->radio_scan.frequency
- << endl;
- break;
- case MM_MESSAGE_RADIO_SCAN_STOP:
- cout << "MM_MESSAGE_RADIO_SCAN_STOP" << endl;
- break;
- case MM_MESSAGE_RADIO_SCAN_FINISH:
- cout << "MM_MESSAGE_RADIO_SCAN_FINISHED" << endl;
- break;
- case MM_MESSAGE_RADIO_SEEK_START:
- cout << "MM_MESSAGE_RADIO_SEEK_START" << endl;
- break;
- case MM_MESSAGE_RADIO_SEEK_FINISH:
- cout << "MM_MESSAGE_RADIO_SEEK_FINISHED : freq : " << param->radio_scan.frequency
- << endl;
- break;
- default:
- cout << "ERROR : unknown message received!" << endl;
- break;
+ void TearDown() {
+ if (radio) {
+ EXPECT_CALL(*_radioMock, _mmradio_destroy(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+ mm_radio_destroy(radio);
+ }
}
+};
- return 0;
+TEST_F(MMRadioMockTest, mm_radio_create_test_positive) {
+ EXPECT_CALL(*_radioMock, _mmradio_destroy(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ EXPECT_CALL(*_radioMock, _mmradio_create_radio(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_destroy(radio);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+
+ ret = mm_radio_create(&radio);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
}
-class MMRadioTest : public ::testing::Test {
- protected:
- void SetUp() {
- ret = mm_radio_create(&hradio);
- ASSERT_EQ(ret, MM_ERROR_NONE) << "[FAILED] mm_radio_create";
+TEST_F(MMRadioMockTest, mm_radio_create_test_invalid_param) {
+ ret = mm_radio_create(NULL);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
- ret = mm_radio_set_message_callback(hradio, _message_callback, &hradio);
- ASSERT_EQ(ret, MM_ERROR_NONE) << "[FAILED] mm_radio_set_message_callback";
- }
+TEST_F(MMRadioMockTest, mm_radio_create_test_mock_error) {
+ EXPECT_CALL(*_radioMock, _mmradio_destroy(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
- void TearDown() {
- ret = mm_radio_destroy(hradio);
- ASSERT_EQ(ret, MM_ERROR_NONE) << "[FAILED] mm_radio_destroy";
- return;
- }
-};
+ EXPECT_CALL(*_radioMock, _mmradio_create_radio(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
-TEST_F(MMRadioTest, mmradio_create_test)
-{
- ASSERT_EQ(ret, MM_ERROR_NONE) << "[FAILED] mm_radio_create";
+ ret = mm_radio_destroy(radio);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+
+ ret = mm_radio_create(&radio);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+ radio = nullptr;
+}
+
+TEST_F(MMRadioMockTest, mm_radio_destroy_test_positive) {
+ EXPECT_CALL(*_radioMock, _mmradio_destroy(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_destroy(radio);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+ radio = nullptr;
+}
+
+TEST_F(MMRadioMockTest, mm_radio_destroy_test_invalid_handle) {
+ ret = mm_radio_destroy(NULL);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_destroy_test_mock_error) {
+ EXPECT_CALL(*_radioMock, _mmradio_destroy(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_destroy(radio);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+ radio = nullptr;
+}
+
+TEST_F(MMRadioMockTest, mm_radio_realize_test_positive) {
+ EXPECT_CALL(*_radioMock, _mmradio_realize(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ int ret = mm_radio_realize(radio);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_realize_test_invalid_handle) {
+ ret = mm_radio_realize(NULL);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_realize_test_mock_error) {
+ EXPECT_CALL(*_radioMock, _mmradio_realize(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_realize(radio);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_unrealize_test_positive) {
+ int state = (int)MM_RADIO_STATE_SCANNING;
+ EXPECT_CALL(*_radioMock, _mmradio_get_state(_, _))
+ .Times(1)
+ .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(state), ::testing::Return(MM_ERROR_NONE)));
+ EXPECT_CALL(*_radioMock, _mmradio_stop_scan(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+ EXPECT_CALL(*_radioMock, _mmradio_unrealize(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_unrealize(radio);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_unrealize_test_positive2) {
+ int state = (int)MM_RADIO_STATE_PLAYING;
+ EXPECT_CALL(*_radioMock, _mmradio_get_state(_, _))
+ .Times(1)
+ .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(state), ::testing::Return(MM_ERROR_NONE)));
+ EXPECT_CALL(*_radioMock, _mmradio_stop_scan(_))
+ .Times(0);
+ EXPECT_CALL(*_radioMock, _mmradio_unrealize(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_unrealize(radio);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_unrealize_test_invalid_handle) {
+ ret = mm_radio_unrealize(NULL);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_unrealize_test_mock_error) {
+ EXPECT_CALL(*_radioMock, _mmradio_unrealize(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_unrealize(radio);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_set_message_callback_test_positive) {
+ MMMessageCallback callback = [](int id, void* parm, void* user_param) { return 0; };
+ void *user_param = nullptr;
+
+ EXPECT_CALL(*_radioMock, _mmradio_set_message_callback(_, _, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_set_message_callback(radio, callback, user_param);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_set_message_callback_test_invalid_handle) {
+ MMMessageCallback callback = [](int id, void* parm, void* user_param) { return 0; };
+ void *user_param = nullptr;
+
+ EXPECT_CALL(*_radioMock, _mmradio_set_message_callback(_, _, _))
+ .Times(0);
+
+ ret = mm_radio_set_message_callback(nullptr, callback, user_param);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_set_message_callback_test_mock_error) {
+ MMMessageCallback callback = [](int id, void* parm, void* user_param) { return 0; };
+ void *user_param = nullptr;
+
+ EXPECT_CALL(*_radioMock, _mmradio_set_message_callback(_, _, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_set_message_callback(radio, callback, user_param);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_state_test_positive) {
+ int mock_state = (int)MM_RADIO_STATE_PLAYING;
+ MMRadioStateType state;
+
+ EXPECT_CALL(*_radioMock, _mmradio_get_state(_, _))
+ .Times(1)
+ .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(mock_state), ::testing::Return(MM_ERROR_NONE)));
+
+ ret = mm_radio_get_state(radio, &state);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+ ASSERT_EQ(state, MM_RADIO_STATE_PLAYING);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_state_test_invalid_handle) {
+ MMRadioStateType state;
+ EXPECT_CALL(*_radioMock, _mmradio_get_state(_, _))
+ .Times(0);
+
+ ret = mm_radio_get_state(nullptr, &state);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_state_test_invalid_param) {
+ EXPECT_CALL(*_radioMock, _mmradio_get_state(_, _))
+ .Times(0);
+
+ ret = mm_radio_get_state(radio, nullptr);
+ ASSERT_EQ(ret, MM_ERROR_COMMON_INVALID_ARGUMENT);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_state_test_mock_error) {
+ MMRadioStateType state;
+ EXPECT_CALL(*_radioMock, _mmradio_get_state(_, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_get_state(radio, &state);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_start_test_positive) {
+ EXPECT_CALL(*_radioMock, _mmradio_start(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_start(radio);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_start_test_invalid_handle) {
+ EXPECT_CALL(*_radioMock, _mmradio_start(_))
+ .Times(0);
+
+ ret = mm_radio_start(nullptr);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_start_test_mock_error) {
+ EXPECT_CALL(*_radioMock, _mmradio_start(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_start(radio);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_stop_test_positive) {
+ EXPECT_CALL(*_radioMock, _mmradio_stop(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_stop(radio);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_stop_test_invalid_handle) {
+ EXPECT_CALL(*_radioMock, _mmradio_stop(_))
+ .Times(0);
+
+ ret = mm_radio_stop(nullptr);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_stop_test_mock_error) {
+ EXPECT_CALL(*_radioMock, _mmradio_stop(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_stop(radio);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_seek_test_positive) {
+ MMRadioSeekDirectionType direction = MM_RADIO_SEEK_UP;
+
+ EXPECT_CALL(*_radioMock, _mmradio_seek(_, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_seek(radio, direction);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_seek_test_invalid_handle) {
+ MMRadioSeekDirectionType direction = MM_RADIO_SEEK_UP;
+
+ EXPECT_CALL(*_radioMock, _mmradio_seek(_, _))
+ .Times(0);
+
+ ret = mm_radio_seek(nullptr, direction);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_seek_test_invalid_param) {
+ MMRadioSeekDirectionType direction = (MMRadioSeekDirectionType)-1;
+
+ EXPECT_CALL(*_radioMock, _mmradio_seek(_, _))
+ .Times(0);
+
+ ret = mm_radio_seek(radio, direction);
+ ASSERT_EQ(ret, MM_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_seek_test_mock_error) {
+ MMRadioSeekDirectionType direction = MM_RADIO_SEEK_UP;
+
+ EXPECT_CALL(*_radioMock, _mmradio_seek(_, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_seek(radio, direction);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_set_frequency_test_positive) {
+ int freq = 87500;
+
+ EXPECT_CALL(*_radioMock, _mmradio_set_frequency(_, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_set_frequency(radio, freq);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_set_frequency_test_invalid_handle) {
+ int freq = 87500;
+
+ EXPECT_CALL(*_radioMock, _mmradio_set_frequency(_, _))
+ .Times(0);
+
+ ret = mm_radio_set_frequency(nullptr, freq);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_set_frequency_test_mock_error) {
+ int freq = 87500;
+
+ EXPECT_CALL(*_radioMock, _mmradio_set_frequency(_, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_set_frequency(radio, freq);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_frequency_test_positive) {
+ int mock_freq = 87500;
+ int freq = 0;
+
+ EXPECT_CALL(*_radioMock, _mmradio_get_frequency(_, _))
+ .Times(1)
+ .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(mock_freq), ::testing::Return(MM_ERROR_NONE)));
+
+ ret = mm_radio_get_frequency(radio, &freq);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+ ASSERT_EQ(freq, mock_freq);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_frequency_test_invalid_handle) {
+ int freq = 0;
+ EXPECT_CALL(*_radioMock, _mmradio_get_frequency(_, _))
+ .Times(0);
+
+ ret = mm_radio_get_frequency(nullptr, &freq);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_frequency_test_invalid_param) {
+ EXPECT_CALL(*_radioMock, _mmradio_get_frequency(_, _))
+ .Times(0);
+
+ ret = mm_radio_get_frequency(radio, nullptr);
+ ASSERT_EQ(ret, MM_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_frequency_test_mock_error) {
+ int freq = 0;
+ EXPECT_CALL(*_radioMock, _mmradio_get_frequency(_, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_get_frequency(radio, &freq);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_scan_start_test_positive) {
+ EXPECT_CALL(*_radioMock, _mmradio_start_scan(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_scan_start(radio);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_scan_start_test_invalid_handle) {
+ EXPECT_CALL(*_radioMock, _mmradio_start_scan(_))
+ .Times(0);
+
+ ret = mm_radio_scan_start(nullptr);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_scan_start_test_mock_error) {
+ EXPECT_CALL(*_radioMock, _mmradio_start_scan(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_scan_start(radio);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_scan_stop_test_positive) {
+ EXPECT_CALL(*_radioMock, _mmradio_stop_scan(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_scan_stop(radio);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_scan_stop_test_invalid_handle) {
+ EXPECT_CALL(*_radioMock, _mmradio_stop_scan(_))
+ .Times(0);
+
+ ret = mm_radio_scan_stop(nullptr);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_scan_stop_test_mock_error) {
+ EXPECT_CALL(*_radioMock, _mmradio_stop_scan(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_scan_stop(radio);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_set_mute_test_positive_mute) {
+ bool muted = true;
+
+ EXPECT_CALL(*_radioMock, _mmradio_mute(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_set_mute(radio, muted);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_set_mute_test_positive_unmute) {
+ bool muted = false;
+
+ EXPECT_CALL(*_radioMock, _mmradio_unmute(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_set_mute(radio, muted);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_set_mute_test_invalid_handle) {
+ bool muted = true;
+
+ EXPECT_CALL(*_radioMock, _mmradio_mute(_))
+ .Times(0);
+
+ ret = mm_radio_set_mute(nullptr, muted);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_set_mute_test_mock_error) {
+ bool muted = true;
+
+ EXPECT_CALL(*_radioMock, _mmradio_mute(_))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_set_mute(radio, muted);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_signal_strength_test_positive) {
+ int mock_signal_strength = 50;
+ int signal_strength = -1;
+
+ EXPECT_CALL(*_radioMock, _mmradio_get_signal_strength(_, _))
+ .Times(1)
+ .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(mock_signal_strength), ::testing::Return(MM_ERROR_NONE)));
+
+ ret = mm_radio_get_signal_strength(radio, &signal_strength);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+ ASSERT_EQ(signal_strength, mock_signal_strength);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_signal_strength_test_invalid_handle) {
+ int signal_strength = -1;
+ EXPECT_CALL(*_radioMock, _mmradio_get_signal_strength(_, _))
+ .Times(0);
+
+ ret = mm_radio_get_signal_strength(nullptr, &signal_strength);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_signal_strength_test_invalid_param) {
+ EXPECT_CALL(*_radioMock, _mmradio_get_signal_strength(_, _))
+ .Times(0);
+
+ ret = mm_radio_get_signal_strength(radio, nullptr);
+ ASSERT_EQ(ret, MM_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_signal_strength_test_mock_error) {
+ int signal_strength = -1;
+ EXPECT_CALL(*_radioMock, _mmradio_get_signal_strength(_, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_get_signal_strength(radio, &signal_strength);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_region_type_test_positive) {
+ MMRadioRegionType mock_region_type = MM_RADIO_REGION_GROUP_EUROPE;
+ MMRadioRegionType region_type = MM_RADIO_REGION_GROUP_NONE;
+
+ EXPECT_CALL(*_radioMock, _mmradio_get_region_type(_, _))
+ .Times(1)
+ .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(mock_region_type), ::testing::Return(MM_ERROR_NONE)));
+
+ ret = mm_radio_get_region_type(radio, ®ion_type);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+ ASSERT_EQ(region_type, mock_region_type);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_region_type_test_invalid_handle) {
+ MMRadioRegionType region_type = MM_RADIO_REGION_GROUP_NONE;
+ EXPECT_CALL(*_radioMock, _mmradio_get_region_type(_, _))
+ .Times(0);
+
+ ret = mm_radio_get_region_type(nullptr, ®ion_type);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_region_type_test_invalid_param) {
+ EXPECT_CALL(*_radioMock, _mmradio_get_region_type(_, _))
+ .Times(0);
+
+ ret = mm_radio_get_region_type(radio, nullptr);
+ ASSERT_EQ(ret, MM_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_region_type_test_mock_error) {
+ MMRadioRegionType region_type = MM_RADIO_REGION_GROUP_NONE;
+ EXPECT_CALL(*_radioMock, _mmradio_get_region_type(_, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_get_region_type(radio, ®ion_type);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_region_frequency_range_test_positive) {
+ unsigned int mock_min_freq = 87500;
+ unsigned int mock_max_freq = 108000;
+ unsigned int min_freq = 0;
+ unsigned int max_freq = 0;
+
+ EXPECT_CALL(*_radioMock, _mmradio_get_region_frequency_range(_, _, _))
+ .Times(1)
+ .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(mock_min_freq), ::testing::SetArgPointee<2>(mock_max_freq), ::testing::Return(MM_ERROR_NONE)));
+
+ ret = mm_radio_get_region_frequency_range(radio, &min_freq, &max_freq);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+ ASSERT_EQ(min_freq, mock_min_freq);
+ ASSERT_EQ(max_freq, mock_max_freq);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_region_frequency_range_test_invalid_handle) {
+ unsigned int min_freq = 0;
+ unsigned int max_freq = 0;
+ EXPECT_CALL(*_radioMock, _mmradio_get_region_frequency_range(_, _, _))
+ .Times(0);
+
+ ret = mm_radio_get_region_frequency_range(nullptr, &min_freq, &max_freq);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_region_frequency_range_test_invalid_param) {
+ unsigned int min_freq = 0;
+ unsigned int max_freq = 0;
+ EXPECT_CALL(*_radioMock, _mmradio_get_region_frequency_range(_, _, _))
+ .Times(0);
+
+ ret = mm_radio_get_region_frequency_range(radio, nullptr, &max_freq);
+ ASSERT_EQ(ret, MM_ERROR_INVALID_ARGUMENT);
+
+ ret = mm_radio_get_region_frequency_range(radio, &min_freq, nullptr);
+ ASSERT_EQ(ret, MM_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_region_frequency_range_test_mock_error) {
+ unsigned int min_freq = 0;
+ unsigned int max_freq = 0;
+ EXPECT_CALL(*_radioMock, _mmradio_get_region_frequency_range(_, _, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_get_region_frequency_range(radio, &min_freq, &max_freq);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_channel_spacing_test_positive) {
+ int mock_channel_spacing = 200;
+ int channel_spacing = 0;
+
+ EXPECT_CALL(*_radioMock, _mmradio_get_channel_spacing(_, _))
+ .Times(1)
+ .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(mock_channel_spacing), ::testing::Return(MM_ERROR_NONE)));
+
+ ret = mm_radio_get_channel_spacing(radio, &channel_spacing);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+ ASSERT_EQ(channel_spacing, mock_channel_spacing);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_channel_spacing_test_invalid_handle) {
+ int channel_spacing = 0;
+ EXPECT_CALL(*_radioMock, _mmradio_get_channel_spacing(_, _))
+ .Times(0);
+
+ ret = mm_radio_get_channel_spacing(nullptr, &channel_spacing);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_channel_spacing_test_invalid_param) {
+ EXPECT_CALL(*_radioMock, _mmradio_get_channel_spacing(_, _))
+ .Times(0);
+
+ ret = mm_radio_get_channel_spacing(radio, nullptr);
+ ASSERT_EQ(ret, MM_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_channel_spacing_test_mock_error) {
+ int channel_spacing = 0;
+ EXPECT_CALL(*_radioMock, _mmradio_get_channel_spacing(_, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_get_channel_spacing(radio, &channel_spacing);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_set_volume_test_positive) {
+ float volume = 0.5f;
+
+ EXPECT_CALL(*_radioMock, _mmradio_set_volume(_, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_NONE));
+
+ ret = mm_radio_set_volume(radio, volume);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_set_volume_test_invalid_handle) {
+ float volume = 0.5f;
+
+ EXPECT_CALL(*_radioMock, _mmradio_set_volume(_, _))
+ .Times(0);
+
+ ret = mm_radio_set_volume(nullptr, volume);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_set_volume_test_mock_error) {
+ float volume = 0.5f;
+
+ EXPECT_CALL(*_radioMock, _mmradio_set_volume(_, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_set_volume(radio, volume);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_volume_test_positive) {
+ float mock_volume = 0.5f;
+ float volume = 0;
+
+ EXPECT_CALL(*_radioMock, _mmradio_get_volume(_, _))
+ .Times(1)
+ .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(mock_volume), ::testing::Return(MM_ERROR_NONE)));
+
+ ret = mm_radio_get_volume(radio, &volume);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+ ASSERT_FLOAT_EQ(volume, mock_volume);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_volume_test_invalid_handle) {
+ float volume = 0;
+ EXPECT_CALL(*_radioMock, _mmradio_get_volume(_, _))
+ .Times(0);
+
+ ret = mm_radio_get_volume(nullptr, &volume);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_NOT_INITIALIZED);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_volume_test_invalid_param) {
+ EXPECT_CALL(*_radioMock, _mmradio_get_volume(_, _))
+ .Times(0);
+
+ ret = mm_radio_get_volume(radio, nullptr);
+ ASSERT_EQ(ret, MM_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(MMRadioMockTest, mm_radio_get_volume_test_mock_error) {
+ float volume = 0;
+ EXPECT_CALL(*_radioMock, _mmradio_get_volume(_, _))
+ .Times(1)
+ .WillOnce(Return(MM_ERROR_RADIO_INTERNAL));
+
+ ret = mm_radio_get_volume(radio, &volume);
+ ASSERT_EQ(ret, MM_ERROR_RADIO_INTERNAL);
}
int main(int argc, char **argv)
projects / platform / core / multimedia / libmm-radio.git / commitdiff