path: root/testcase/audio/audio_haltests.cpp

/*
 * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * Contact: Seungbae Shin <seungbae.shin@samsung.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <string.h>
#include <unistd.h>
#include <iostream>
#include <array>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <gtest/gtest.h>

#include <audio_hal_interface.h>
#include <system_info.h>

using namespace std;

typedef enum audio_sample_format {
	AUDIO_SAMPLE_U8,
	AUDIO_SAMPLE_ALAW,
	AUDIO_SAMPLE_ULAW,
	AUDIO_SAMPLE_S16LE,
	AUDIO_SAMPLE_S16BE,
	AUDIO_SAMPLE_FLOAT32LE,
	AUDIO_SAMPLE_FLOAT32BE,
	AUDIO_SAMPLE_S32LE,
	AUDIO_SAMPLE_S32BE,
	AUDIO_SAMPLE_S24LE,
	AUDIO_SAMPLE_S24BE,
	AUDIO_SAMPLE_S24_32LE,
	AUDIO_SAMPLE_S24_32BE,
	AUDIO_SAMPLE_MAX,
	AUDIO_SAMPLE_INVALID = -1
} audio_sample_format_t;

typedef struct {
	audio_sample_format_t format;
	uint32_t rate;
	uint8_t channels;
} audio_pcm_sample_spec_t;


/*
 * TestSuite Class
 */
class AudioHalTest : public testing::Test
{
	public:
		virtual void SetUp();
		virtual void TearDown();

	protected:
		void SetRouteToSpeaker();
		int32_t WritePcmFromFile(pcm_handle pcm_h, audio_pcm_sample_spec_t *spec);
		uint32_t BytesToFrames(uint32_t bytes, audio_pcm_sample_spec_t *spec);
		uint32_t FramesToBytes(uint32_t frames, audio_pcm_sample_spec_t *spec);
		static void HalMessageCallback(const char *name, int value, void *user_data);

		audio_hal_interface *m_h;
		const string default_card = "sprdphone";
		const string default_device = "0";

	private:
};

void AudioHalTest::SetUp()
{
	m_h = nullptr;

	int32_t ret = audio_hal_interface_init(&m_h);
	if (ret != AUDIO_HAL_SUCCESS)
		cout << "audio hal init failed : " << ret << endl;
}

void AudioHalTest::TearDown()
{
	if (m_h == nullptr)
		return;

	int32_t ret = audio_hal_interface_deinit(m_h);
	if (ret != AUDIO_HAL_SUCCESS)
		cout << "audio hal deinit failed : " << ret << endl;

	m_h = nullptr;
}

void AudioHalTest::SetRouteToSpeaker()
{
	hal_route_info info;
	int32_t num_of_devices = 1;

	memset(&info, 0, sizeof(hal_route_info));

	info.role = "media";
	info.device_infos = (hal_device_info*)malloc(sizeof(hal_device_info) * num_of_devices);
	if (info.device_infos == nullptr) {
		cout << "malloc error!!! : " << errno << endl;
		return;
	}
	info.device_infos[0].direction = DIRECTION_OUT;
	info.device_infos[0].type = "builtin-speaker";
	info.device_infos[0].id = 100;
	info.num_of_devices = num_of_devices;

	int32_t ret = audio_hal_interface_update_route(m_h, &info);

	cout << "update route : " << ret << endl;

	free(info.device_infos);
}

int32_t AudioHalTest::WritePcmFromFile(pcm_handle pcm_h, audio_pcm_sample_spec_t *spec)
{
	int32_t ret = AUDIO_HAL_SUCCESS;
	char buffer[65536];

	const char res_path[] = "/usr/share/testcase/res/audio/dtmf_16le_44100_2ch.raw";

	int fd = open(res_path, O_RDONLY);
	cout << res_path << ", fd opened : " << fd << endl;

	cout << "start to play dtmf sounds for 5 sec. " << endl;

	while (fd != -1) {

		uint32_t avail_frames = 0;
		ret = audio_hal_interface_pcm_available(m_h, pcm_h, &avail_frames);

		if (avail_frames == 0) {
			usleep(20000); // 20ms
			continue;
		}

		int bytes_read = read(fd, buffer, FramesToBytes(avail_frames, spec));
		//cout << "avail frames : " << avail_frames << ", read_n : " << bytes_read << endl;

		ret = audio_hal_interface_pcm_write(m_h, pcm_h, buffer, BytesToFrames(bytes_read, spec));
		if (ret == AUDIO_HAL_ERROR)
			break;

		if (bytes_read < static_cast<int>(FramesToBytes(avail_frames, spec))) {
			cout << "EOS!!!" << endl;
			break;
		}
	}

	cout << "Done!!!" << endl;

	if (fd != -1)
		close(fd);

	return ret;
}

uint32_t AudioHalTest::BytesToFrames(uint32_t bytes, audio_pcm_sample_spec_t *spec)
{
	if (spec->format == AUDIO_SAMPLE_S16LE)
		return bytes / spec->channels / 2;
	else
		return 0; // not supported yet.

}

uint32_t AudioHalTest::FramesToBytes(uint32_t frames, audio_pcm_sample_spec_t *spec)
{
	if (spec->format == AUDIO_SAMPLE_S16LE)
		return frames * spec->channels * 2;
	else
		return 0; // not supported yet.
}

void AudioHalTest::HalMessageCallback(const char *name, int value, void *user_data)
{
	cout << name << "," << value << "," << user_data << endl;
}

/**
 * @testcase		InitP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, Initialize audio HAL handle
 * @apicovered		audio_init, audio_deinit
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST(AudioHalPreTest, InitP)
{
	audio_hal_interface *h = nullptr;

	int32_t ret = audio_hal_interface_init(&h);
	ASSERT_EQ(ret, AUDIO_HAL_SUCCESS);
	ASSERT_NE(h, nullptr);

	ret = audio_hal_interface_deinit(h);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);
}

/**
 * @testcase		InitN
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Negative, Initialize audio HAL handle
 * @apicovered		audio_init
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST(AudioHalPreTest, InitN)
{
	int32_t ret = audio_hal_interface_init(nullptr);
	ASSERT_EQ(ret, AUDIO_HAL_ERROR);
}

/**
 * @testcase		DeinitP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, Deinitialize audio HAL handle
 * @apicovered		audio_init, audio_deinit
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST(AudioHalPreTest, DeinitP)
{
	audio_hal_interface *h = nullptr;

	int32_t ret = audio_hal_interface_init(&h);
	ASSERT_EQ(ret, AUDIO_HAL_SUCCESS);
	ASSERT_NE(h, nullptr);

	ret = audio_hal_interface_deinit(h);
	ASSERT_EQ(ret, AUDIO_HAL_SUCCESS);
}

/**
 * @testcase		GetVolumeLevelMaxP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, Get maximum volume level of each volume types
 * @apicovered		audio_get_volume_level_max
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, GetVolumeLevelMaxP)
{
	uint32_t level_max;
	const array<string, 8> vol_types = { "system", "notification", "alarm", "ringtone",
										"media", "call", "voip", "voice" };

	for (const auto& i : vol_types) {
		int32_t ret = audio_hal_interface_get_volume_level_max(m_h, i.c_str(), DIRECTION_OUT, &level_max);
		cout << i << " : " << level_max << endl;
		EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);
	}
}

/**
 * @testcase		GetVolumeLevelMaxN
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Negative, Get maximum volume level of each volume types
 * @apicovered		audio_get_volume_level_max
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, GetVolumeLevelMaxN)
{
	int32_t ret = audio_hal_interface_get_volume_level_max(m_h, "media", DIRECTION_OUT, nullptr);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);
}

/**
 * @testcase		GetVolumeLevelP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, Get volume level of each volume types
 * @apicovered		audio_get_volume_level
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, GetVolumeLevelP)
{
	uint32_t level;
	const array<string, 8> vol_types = { "system", "notification", "alarm", "ringtone",
										"media", "call", "voip", "voice" };

	for (const auto& i : vol_types) {
		int32_t ret = audio_hal_interface_get_volume_level(m_h, i.c_str(), DIRECTION_OUT, &level);
		cout << i << " : " << level << endl;
		EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);
	}
}

/**
 * @testcase		GetVolumeLevelN
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Negative, Get volume level of each volume types
 * @apicovered		audio_get_volume_level
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, GetVolumeLevelN)
{
	int32_t ret = audio_hal_interface_get_volume_level(m_h, "media", DIRECTION_OUT, nullptr);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);
}

/**
 * @testcase		SetVolumeLevelP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, Set volume level of each volume types
 * @apicovered		audio_set_volume_level
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, SetVolumeLevelP)
{
	/* FIXME : need to revise */
	int32_t ret = audio_hal_interface_set_volume_level(m_h, "media", DIRECTION_OUT, 15);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);

	ret = audio_hal_interface_set_volume_level(m_h, "media", DIRECTION_OUT, 7);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);
}


/**
 * @testcase		SetVolumeLevelN
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Negative, Set volume level of each volume types
 * @apicovered		audio_set_volume_level
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, SetVolumeLevelN)
{
	int32_t ret = audio_hal_interface_set_volume_level(m_h, "media", DIRECTION_OUT, 10000);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);
}


/**
 * @testcase		GetVolumeValueP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, Get volume value of each volume types with given volume level
 * @apicovered		audio_get_volume_value
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, GetVolumeValueP)
{
	double value;

	int32_t ret = audio_hal_interface_get_volume_value(m_h, "media", nullptr, DIRECTION_OUT, 15, &value);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);

	cout << "media vol value : " << value << endl;
}

/**
 * @testcase		GetVolumeValueN
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Negative, Get volume value of each volume types with given volume level
 * @apicovered		audio_get_volume_value
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, GetVolumeValueN)
{
	int32_t ret = audio_hal_interface_get_volume_value(m_h, "media", nullptr, DIRECTION_OUT, 15, nullptr);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);
}

/**
 * @testcase		GetVolumeMuteP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, Get volume mute of each volume types.
 * @apicovered		audio_get_volume_mute
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, GetVolumeMuteP)
{
	uint32_t mute;

	int32_t ret = audio_hal_interface_get_volume_mute(m_h, "media", DIRECTION_OUT, &mute);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);

	cout << "mute : " << mute << endl;
}

/**
 * @testcase		GetVolumeMuteN
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Negative, Get volume mute of each volume types.
 * @apicovered		audio_get_volume_mute
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, GetVolumeMuteN)
{
	int32_t ret = audio_hal_interface_get_volume_mute(m_h, "media", DIRECTION_OUT, nullptr);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);
}

/**
 * @testcase		SetVolumeMuteP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, Set volume mute of each volume types.
 * @apicovered		audio_set_volume_mute
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, SetVolumeMuteP)
{
	int32_t ret = audio_hal_interface_set_volume_mute(m_h, "media", DIRECTION_OUT, 1);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);

	ret = audio_hal_interface_set_volume_mute(m_h, "media", DIRECTION_OUT, 0);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);
}

#if 0 // can't test because mute is not implemented yet...
TEST_F(AudioHalTest, SetVolumeMuteN)
{
	int32_t ret = audio_hal_interface_set_volume_mute(m_h, "media", DIRECTION_OUT, 10000);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);
}
#endif

/**
 * @testcase		UpdateRouteP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, Update route
 * @apicovered		audio_update_route
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, UpdateRouteP)
{
	hal_route_info info;
	int32_t num_of_devices = 1;

	memset(&info, 0, sizeof(hal_route_info));

	info.role = "media";
	info.device_infos = (hal_device_info*)malloc(sizeof(hal_device_info) * num_of_devices);
	ASSERT_NE(info.device_infos, nullptr);
	info.device_infos[0].direction = DIRECTION_OUT;
	info.device_infos[0].type = "builtin-speaker";
	info.device_infos[0].id = 100;
	info.num_of_devices = num_of_devices;

	int32_t ret = audio_hal_interface_update_route(m_h, &info);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);

	free(info.device_infos);
}


/**
 * @testcase		UpdateRouteN
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Negative, Update route
 * @apicovered		audio_update_route
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, UpdateRouteN)
{
	int32_t ret = audio_hal_interface_update_route(m_h, nullptr);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);

	hal_route_info info;
	memset(&info, 0, sizeof(hal_route_info));
	info.role = nullptr;
	ret = audio_hal_interface_update_route(m_h, &info);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);
}

/**
 * @testcase		UpdateRouteOptionP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, Update route option
 * @apicovered		audio_update_route_option
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, UpdateRouteOptionP)
{
	hal_route_option option;

	int32_t ret = audio_hal_interface_update_route_option(m_h, &option);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);
}


/**
 * @testcase		UpdateRouteOptionN
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Negative, Update route option
 * @apicovered		audio_update_route_option
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, UpdateRouteOptionN)
{
	int32_t ret = audio_hal_interface_update_route_option(m_h, nullptr);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);
}

/**
 * @testcase		NotifyStreamConnectionChangedP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, Notify stream connection changed
 * @apicovered		audio_notify_stream_connection_changed
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, NotifyStreamConnectionChangedP)
{
	hal_stream_connection_info info;

	memset(&info, 0, sizeof(hal_stream_connection_info));
	info.role = "media";
	info.direction = DIRECTION_OUT;
	info.idx = 100;
	info.is_connected = true;

	int32_t ret = audio_hal_interface_notify_stream_connection_changed(m_h, &info);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);
}

/**
 * @testcase		NotifyStreamConnectionChangedN
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Negative, Notify stream connection changed
 * @apicovered		audio_notify_stream_connection_changed
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, NotifyStreamConnectionChangedN)
{
	// check for nullptr ptr
	int32_t ret = audio_hal_interface_notify_stream_connection_changed(m_h, nullptr);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);

	// check for invalid role
	hal_stream_connection_info info;
	memset(&info, 0, sizeof(hal_stream_connection_info));
	info.role = nullptr;
	info.direction = DIRECTION_OUT;
	info.idx = 100;
	info.is_connected = true;

	ret = audio_hal_interface_notify_stream_connection_changed(m_h, &info);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);
}

/**
 * @testcase		MessageCallbackP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, add/remove message callback
 * @apicovered		audio_add_message_cb, audio_remove_message_cb
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, MessageCallbackP)
{
	int32_t ret = audio_hal_interface_add_message_callback(m_h, HalMessageCallback, nullptr);
	ASSERT_EQ(ret, AUDIO_HAL_SUCCESS);

	ret = audio_hal_interface_remove_message_callback(m_h, HalMessageCallback);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);
}

/**
 * @testcase		MessageCallbackN
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Negative, add/remove message callback
 * @apicovered		audio_add_message_cb, audio_remove_message_cb
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, MessageCallbackN)
{
	int32_t ret = audio_hal_interface_add_message_callback(m_h, nullptr, nullptr);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);

	ret = audio_hal_interface_remove_message_callback(m_h, nullptr);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);
}


/**
 * @testcase		PcmGetFdP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, get fd from the pcm handle
 * @apicovered		audio_pcm_get_fd, audio_pcm_open, audio_pcm_close
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, PcmGetFdP)
{
	pcm_handle pcm_h = nullptr;

	audio_pcm_sample_spec_t sample_spec;
	sample_spec.format = AUDIO_SAMPLE_S16LE;
	sample_spec.rate = 44100;
	sample_spec.channels = 2;

	SetRouteToSpeaker();

	int32_t ret = audio_hal_interface_pcm_open(m_h, default_card.c_str(), default_device.c_str(), DIRECTION_OUT, &sample_spec,
											BytesToFrames(6400, &sample_spec), 5, &pcm_h);
	ASSERT_EQ(ret, AUDIO_HAL_SUCCESS);

	int pcm_fd = 0;
	ret = audio_hal_interface_pcm_get_fd(m_h, pcm_h, &pcm_fd);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);
	cout << "pcm fd : " << pcm_fd << endl;

	ret = audio_hal_interface_pcm_close(m_h, pcm_h);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);
}

/**
 * @testcase		PcmGetFdN
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Negative, get fd from the pcm handle
 * @apicovered		audio_pcm_get_fd, audio_pcm_open, audio_pcm_close
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, PcmGetFdN)
{
	// check for pcm handle
	int pcm_fd = 0;
	int32_t ret = audio_hal_interface_pcm_get_fd(m_h, nullptr, &pcm_fd);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);

	// check for fd
	pcm_handle pcm_h = nullptr;

	audio_pcm_sample_spec_t sample_spec;
	sample_spec.format = AUDIO_SAMPLE_S16LE;
	sample_spec.rate = 44100;
	sample_spec.channels = 2;

	SetRouteToSpeaker();

	ret = audio_hal_interface_pcm_open(m_h, default_card.c_str(), default_device.c_str(), DIRECTION_OUT, &sample_spec,
									BytesToFrames(6400, &sample_spec), 5, &pcm_h);
	ASSERT_EQ(ret, AUDIO_HAL_SUCCESS);

	ret = audio_hal_interface_pcm_get_fd(m_h, pcm_h, nullptr);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);

	ret = audio_hal_interface_pcm_close(m_h, pcm_h);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);
}

/**
 * @testcase		PcmOpenWriteCloseP
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Positive, open pcm handle, start pcm handle, write pcm buffers, stop pcm handle and close pcm_handle
 * @apicovered		audio_pcm_open, audio_pcm_start, audio_pcm_avail, audio_pcm_write, audio_pcm_stop, audio_pcm_close
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, PcmOpenWriteCloseP)
{
	pcm_handle pcm_h = nullptr;

	audio_pcm_sample_spec_t sample_spec;
	sample_spec.format = AUDIO_SAMPLE_S16LE;
	sample_spec.rate = 44100;
	sample_spec.channels = 2;

	SetRouteToSpeaker();

	int32_t ret = audio_hal_interface_pcm_open(m_h, default_card.c_str(), default_device.c_str(), DIRECTION_OUT, &sample_spec,
											BytesToFrames(6400, &sample_spec), 5, &pcm_h);
	ASSERT_EQ(ret, AUDIO_HAL_SUCCESS);

	ret = audio_hal_interface_pcm_start(m_h, pcm_h);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);

	ret = WritePcmFromFile(pcm_h, &sample_spec);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);

	ret = audio_hal_interface_pcm_stop(m_h, pcm_h);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);

	ret = audio_hal_interface_pcm_close(m_h, pcm_h);
	EXPECT_EQ(ret, AUDIO_HAL_SUCCESS);
}

/**
 * @testcase		PcmRecoverN
 * @sizen_tizen		4.0
 * @author			SR(seungbae.shin)
 * @reviewer		SR(sc11.lee)
 * @type			auto
 * @description		Negative, pcm recovery
 * @apicovered		audio_pcm_recover
 * @passcase		XXX
 * @failcase		YYY
 * @precondition	None
 * @postcondition	None
 */
TEST_F(AudioHalTest, PcmRecoverN)
{
	int32_t ret = audio_hal_interface_pcm_recover(m_h, nullptr, 0);
	EXPECT_EQ(ret, AUDIO_HAL_ERROR);
}

/* // ToDo :
int32_t audio_hal_interface_pcm_read(audio_hal_interface *h, pcm_handle pcm_h, void *buffer, uint32_t frames);
*/

/* This is not used */
#if 0
int32_t audio_hal_interface_pcm_get_params(audio_hal_interface *h, pcm_handle pcm_h, uint32_t direction, void **sample_spec,
										uint32_t *period_size, uint32_t *periods);
int32_t audio_hal_interface_pcm_set_params(audio_hal_interface *h, pcm_handle pcm_h, uint32_t direction, void *sample_spec,
										uint32_t period_size, uint32_t periods);
#endif

int main(int argc, char **argv)
{
	testing::InitGoogleTest(&argc, argv);

	return RUN_ALL_TESTS();
}