[1.0.0][ut] add sender test cases

- major version up for 7.0 release
- add rist/rtsp sender ut
- remove rtsp server excutable
- allow null input at set connection param api

Change-Id: I0f51c4ac572db1c0b43fd7a07f4f0fe0bbb259ec

18 files changed, 1463 insertions, 130 deletions

diff --git a/include/MediaTransporterSenderRist.h b/include/MediaTransporterSenderRist.h
index 27aa32d..0aba474 100644
--- a/include/MediaTransporterSenderRist.h
+++ b/include/MediaTransporterSenderRist.h
@@ -26,9 +26,9 @@
 #include "MediaTransporterSender.h"
 #include "MediaTransporterGst.h"
 
-constexpr size_t DEFAULT_MAX_RTCP_BANDWIDTH = 0.05;
-constexpr size_t DEFAULT_MIN_RTCP_INTERVAL = 100;
-constexpr size_t DEFAULT_SEND_BUFFER = 1200;
+constexpr double DEFAULT_MAX_RTCP_BANDWIDTH = 0.05;
+constexpr unsigned int DEFAULT_MIN_RTCP_INTERVAL = 100;
+constexpr unsigned int DEFAULT_SEND_BUFFER = 1200;
 
 namespace tizen_media_transporter {
 
diff --git a/include/MediaTransporterSenderRtsp.h b/include/MediaTransporterSenderRtsp.h
index 9a1f395..54fe7fd 100644
--- a/include/MediaTransporterSenderRtsp.h
+++ b/include/MediaTransporterSenderRtsp.h
@@ -47,6 +47,7 @@ private:
 
 	std::string _senderAddress; // rtsp server ip, port + mount path
 
+	unsigned int _sourceId { 0 };
 	std::string _rtspMountPoint;
 	void* _rtspServer { nullptr };
 };
diff --git a/include/mtpr.h b/include/mtpr.h
index e4c9f95..7db3583 100644
--- a/include/mtpr.h
+++ b/include/mtpr.h
@@ -138,6 +138,7 @@ typedef enum {
  * @brief Definition for password parameter of SRT.
  * @details The password for the encrypted transmission of SRT.\n
  *          The number of characters must be 10 to 79.
+ *          NULL input is allowed to clear the password.
  * @since_tizen 7.0
  * @remarks This is write only parameter.
  * @see mtpr_set_connection_param()
diff --git a/packaging/capi-media-transporter.spec b/packaging/capi-media-transporter.spec
index 4c2e145..2a4a4fe 100644
--- a/packaging/capi-media-transporter.spec
+++ b/packaging/capi-media-transporter.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-transporter
 Summary:    A Media Transporter library in Tizen Native API
-Version:    0.0.13
+Version:    1.0.0
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0
@@ -93,7 +93,6 @@ rm -rf %{buildroot}
 mkdir -p %{buildroot}%{_bindir}
 mkdir -p %{buildroot}%{_hal_datadir}
 cp test/mtpr_test %{buildroot}%{_bindir}
-cp test/mtpr_rtsp_test %{buildroot}%{_bindir}
 
 %make_install
 mkdir -p %{buildroot}%{_hal_sysconfdir}/multimedia
@@ -123,7 +122,6 @@ find . -name '*.gcno' -exec cp --parents '{}' "$gcno_obj_dir" ';'
 %files tool
 %defattr(-,root,root,-)
 %{_bindir}/mtpr_test
-%{_bindir}/mtpr_rtsp_test
 %if 0%{?gtests:1}
 %{_bindir}/mtpr_ut
 %endif
diff --git a/src/MediaTransporter.cpp b/src/MediaTransporter.cpp
index e4d8fa6..c51c228 100644
--- a/src/MediaTransporter.cpp
+++ b/src/MediaTransporter.cpp
@@ -219,12 +219,13 @@ int mtpr_set_connection_param(mtpr_h mtpr, const char *param_name, const char *p
 {
 	RET_ERR_IF_INVALID_INSTANCE(mtpr);
 	RET_ERR_IF_NULL_ARG(param_name);
-	RET_ERR_IF_NULL_ARG(param_value);
 
 	try {
 		auto handle = static_cast<media_transporter_s*>(mtpr);
 		assert(handle->base);
-		handle->base->setConnection(param_name, param_value);
+
+		/* param value could be null depends on the param spec. */
+		handle->base->setConnection(param_name, param_value ? param_value : "");
 	} catch (const MediaTransporterException& e) {
 		LOG_ERROR("Failed to set connection param!!! : %s", e.what());
 		return e.error();
diff --git a/src/MediaTransporterBase.cpp b/src/MediaTransporterBase.cpp
index f483cb4..7bba9bb 100644
--- a/src/MediaTransporterBase.cpp
+++ b/src/MediaTransporterBase.cpp
@@ -131,8 +131,10 @@ void MediaTransporterBase::start()
 void MediaTransporterBase::stopInternal()
 {
 	try {
-		stopPipeline();
-		_state = MTPR_STATE_IDLE;
+		if (_state != MTPR_STATE_IDLE) {
+			stopPipeline();
+			_state = MTPR_STATE_IDLE;
+		}
 	} catch (const MediaTransporterException& e) {
 		LOG_ERROR("%s", e.what());
 		throw;
diff --git a/src/MediaTransporterParam.cpp b/src/MediaTransporterParam.cpp
index 2bc908b..36133cc 100644
--- a/src/MediaTransporterParam.cpp
+++ b/src/MediaTransporterParam.cpp
@@ -138,7 +138,7 @@ void param::srt::setConnectionParam(std::string key, std::string value, param::s
 			connectionParam->streamId = value;
 
 		} else if (key.compare(MTPR_CONNECTION_PARAM_SRT_PASSPHRASE) == 0) {
-			if (value.length() < SRT_MIN_PASSPHRASE || value.length() > SRT_MAX_PASSPHRASE)
+			if (!value.empty() && (value.length() < SRT_MIN_PASSPHRASE || value.length() > SRT_MAX_PASSPHRASE))
 				throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "wrong passphrase");
 			connectionParam->passPhrase = value;
 		} else if (key.compare(MTPR_CONNECTION_PARAM_SRT_PBKEYLEN) == 0) {
diff --git a/src/MediaTransporterReceiverSrt.cpp b/src/MediaTransporterReceiverSrt.cpp
index 72f911d..09cecf0 100644
--- a/src/MediaTransporterReceiverSrt.cpp
+++ b/src/MediaTransporterReceiverSrt.cpp
@@ -138,9 +138,9 @@ void MediaTransporterReceiverSrt::stopPipeline()
 							MediaTransporterIni::get().general().timeout);
 }
 
-void MediaTransporterReceiverSrt::setConnection(std::string name, std::string string_val)
+void MediaTransporterReceiverSrt::setConnection(std::string name, std::string val)
 {
-	setConnectionParam(name, string_val, &_connectionParam);
+	setConnectionParam(name, val, &_connectionParam);
 }
 
 std::string MediaTransporterReceiverSrt::getConnection(std::string name)
diff --git a/src/MediaTransporterSenderRist.cpp b/src/MediaTransporterSenderRist.cpp
index 3a7da10..ebc0e76 100644
--- a/src/MediaTransporterSenderRist.cpp
+++ b/src/MediaTransporterSenderRist.cpp
@@ -22,9 +22,9 @@
 #include "MediaTransporterUtil.h"
 #include "MediaTransporterParseIni.h"
 
-constexpr size_t MIN_RTCP_BANDWIDTH_PARAM = 0;
-constexpr size_t MAX_RTCP_BANDWIDTH_PARAM = 0.05;
-constexpr size_t MAX_RTCP_INTERVAL_PARAM = 100;
+constexpr double MIN_RTCP_BANDWIDTH_PARAM = 0;
+constexpr double MAX_RTCP_BANDWIDTH_PARAM = 0.05;
+constexpr unsigned int MAX_RTCP_INTERVAL_PARAM = 100;
 
 using namespace tizen_media_transporter;
 
@@ -105,41 +105,41 @@ void MediaTransporterSenderRist::stopPipeline()
 							MediaTransporterIni::get().general().timeout);
 }
 
-void MediaTransporterSenderRist::setConnection(std::string name, std::string string_val)
+void MediaTransporterSenderRist::setConnection(std::string name, std::string val)
 {
-	SECURE_LOG_INFO("%s : %s", name.c_str(), string_val.c_str());
+	SECURE_LOG_INFO("%s : %s", name.c_str(), val.c_str());
 
 	try {
 		if (name == MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS) {
-			_connectionParam.bondingAddress = string_val; /* FIXME : need to consider with _receiverAddress */
+			_connectionParam.bondingAddress = val; /* FIXME : need to consider with _receiverAddress */
 
 		} else if (name == MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH) {
 			size_t size;
-			double val = stod(string_val, &size);
-			if ((string_val.size() != size) ||
-				(val < MIN_RTCP_BANDWIDTH_PARAM) || (val > MAX_RTCP_BANDWIDTH_PARAM)) {
-				LOG_ERROR("invalid rtcp bandwidth value %s", string_val.c_str());
+			double maxRtcpBandwidth = stod(val, &size);
+			if ((val.size() != size) ||
+				(maxRtcpBandwidth < MIN_RTCP_BANDWIDTH_PARAM) || (maxRtcpBandwidth > MAX_RTCP_BANDWIDTH_PARAM)) {
+				LOG_ERROR("invalid rtcp bandwidth value %s", val.c_str());
 				throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid rtcp bandwidth value");
 			}
-			_connectionParam.maxRtcpBandwidth = val;
+			_connectionParam.maxRtcpBandwidth = maxRtcpBandwidth;
 
 		} else if (name == MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL) {
 			size_t size;
-			unsigned int val = stoul(string_val, &size);
-			if ((string_val.size() != size) || (val > MAX_RTCP_INTERVAL_PARAM)) {
-				LOG_ERROR("invalid rtcp interval value %s", string_val.c_str());
+			unsigned int minRtcpInterval = stoul(val, &size);
+			if ((val.size() != size) || (minRtcpInterval > MAX_RTCP_INTERVAL_PARAM)) {
+				LOG_ERROR("invalid rtcp interval value %s", val.c_str());
 				throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid rtcp interval value");
 			}
-			_connectionParam.minRtcpInterval = val;
+			_connectionParam.minRtcpInterval = minRtcpInterval;
 
 		} else if (name == MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER) {
 			size_t size;
-			unsigned int val = stoul(string_val, &size);
-			if (string_val.size() != size) {
-				LOG_ERROR("invalid sender buffer value %s", string_val.c_str());
+			unsigned int senderBuffer = stoul(val, &size);
+			if (val.size() != size) {
+				LOG_ERROR("invalid sender buffer value %s", val.c_str());
 				throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid sender buffer value");
 			}
-			_connectionParam.senderBuffer = val;
+			_connectionParam.senderBuffer = senderBuffer;
 
 		} else {
 			LOG_ERROR("invalid param name %s", name.c_str());
diff --git a/src/MediaTransporterSenderRtsp.cpp b/src/MediaTransporterSenderRtsp.cpp
index 66f5e66..9573912 100644
--- a/src/MediaTransporterSenderRtsp.cpp
+++ b/src/MediaTransporterSenderRtsp.cpp
@@ -238,7 +238,7 @@ void MediaTransporterSenderRtsp::startRtspServer()
 		g_signal_connect(GST_RTSP_MEDIA_FACTORY(factoryMtpr), "media-constructed", G_CALLBACK(__mediaConstructedCb), NULL);
 		g_signal_connect(GST_RTSP_MEDIA_FACTORY(factoryMtpr), "media-configure", G_CALLBACK(__mediaConfigureCb), NULL);
 
-		if (gst_rtsp_server_attach(server, NULL) == 0) {
+		if ((_sourceId = gst_rtsp_server_attach(server, NULL)) == 0) {
 			LOG_ERROR("failed to attach server to default context");
 			throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "failed to attach server");
 		}
@@ -261,17 +261,24 @@ void MediaTransporterSenderRtsp::startRtspServer()
 
 void MediaTransporterSenderRtsp::stopRtspServer()
 {
-	guint ref_cnt = 0;
-	GstRTSPMountPoints* mounts = NULL;
-	GstRTSPServer* server = static_cast<GstRTSPServer*>(_rtspServer);
 
-	mounts = gst_rtsp_server_get_mount_points(server);
+	if (!_rtspServer) {
+		LOG_ERROR("there is no running server");
+		throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "there is no running server");
+	}
+
+	GstRTSPServer* server = static_cast<GstRTSPServer*>(_rtspServer);
+	GstRTSPMountPoints* mounts = gst_rtsp_server_get_mount_points(server);
 	gst_rtsp_mount_points_remove_factory(mounts, _rtspMountPoint.c_str());
 	g_object_unref(mounts);
 
 	gst_rtsp_server_client_filter(server, __clientFilter, NULL);
 
-	ref_cnt = GST_OBJECT_REFCOUNT_VALUE(server);
+	if (_sourceId > 0)
+		g_source_remove(_sourceId);
+	_sourceId = 0;
+
+	guint ref_cnt = GST_OBJECT_REFCOUNT_VALUE(server);
 	for (guint i = 0; i < ref_cnt; i++)
 		gst_object_unref(server);
 
diff --git a/src/MediaTransporterSenderSrt.cpp b/src/MediaTransporterSenderSrt.cpp
index 59a38fe..193a45b 100644
--- a/src/MediaTransporterSenderSrt.cpp
+++ b/src/MediaTransporterSenderSrt.cpp
@@ -138,9 +138,9 @@ void MediaTransporterSenderSrt::stopPipeline()
 								MediaTransporterIni::get().general().timeout);
 }
 
-void MediaTransporterSenderSrt::setConnection(std::string name, std::string string_val)
+void MediaTransporterSenderSrt::setConnection(std::string name, std::string val)
 {
-	setConnectionParam(name, string_val, &_connectionParam);
+	setConnectionParam(name, val, &_connectionParam);
 }
 
 std::string MediaTransporterSenderSrt::getConnection(std::string name)
diff --git a/src/MediaTransporterSenderToServerRtsp.cpp b/src/MediaTransporterSenderToServerRtsp.cpp
index b2903e7..14ea01b 100644
--- a/src/MediaTransporterSenderToServerRtsp.cpp
+++ b/src/MediaTransporterSenderToServerRtsp.cpp
@@ -59,9 +59,6 @@ void MediaTransporterSenderToServerRtsp::buildPipeline()
 			throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "failed to gst_element_link()");
 		}
 
-		LOG_ERROR("pp %s, ref %d",
-			GST_ELEMENT_NAME(_gst.pipeline), GST_OBJECT_REFCOUNT_VALUE(_gst.pipeline));
-
 		linkMediaSourceToMuxer(mux);
 
 		_rtspSink = sink;
diff --git a/test/mtpr_rtsp_test.c b/test/mtpr_rtsp_test.c
deleted file mode 100644
index 3e54417..0000000
--- a/test/mtpr_rtsp_test.c
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
-* Copyright (c) 2022 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.
-* 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 <gst/gst.h>
-#include <gst/rtsp-server/rtsp-server.h>
-
-#ifdef PACKAGE
-#undef PACKAGE
-#endif
-#define PACKAGE "mtpr_rtsp_test"
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-#define LOG_TAG "MTPR_TEST"
-
-#define DEFAULT_RTSP_PORT "8554"
-
-int main(int argc, char *argv[])
-{
-	GMainLoop *loop;
-	GstRTSPServer *server;
-	GstRTSPMountPoints *mounts;
-	GstRTSPMediaFactory *factory;
-
-	if (argc < 2) {
-		g_print("Enter launch cmd : \"( decodebin name=depay0 ! videoconvert ! tizenwlsink )\"\n");
-		return 1;
-	}
-
-	gst_init(NULL, NULL);
-	loop = g_main_loop_new(NULL, FALSE);
-
-	server = gst_rtsp_server_new();
-	g_object_set(server, "service", DEFAULT_RTSP_PORT, NULL);
-
-	mounts = gst_rtsp_server_get_mount_points(server);
-
-	factory = gst_rtsp_media_factory_new();
-	gst_rtsp_media_factory_set_transport_mode(factory, GST_RTSP_TRANSPORT_MODE_RECORD);
-	gst_rtsp_media_factory_set_launch(factory, argv[1]);
-
-	gst_rtsp_mount_points_add_factory(mounts, "/test", factory);
-	g_object_unref(mounts);
-
-	gst_rtsp_server_attach(server, NULL);
-
-	g_print("stream ready at rtsp://127.0.0.1:%s/test\n", DEFAULT_RTSP_PORT);
-	g_main_loop_run(loop);
-
-	return 0;
-}
diff --git a/unittest/CMakeLists.txt b/unittest/CMakeLists.txt
index 8a314c3..424b7b8 100644
--- a/unittest/CMakeLists.txt
+++ b/unittest/CMakeLists.txt
@@ -45,6 +45,9 @@ INCLUDE_DIRECTORIES(
 )
 
 SET(UT_SRC
+  ut_rist_sender.cpp
+  ut_rtsp_sender.cpp
+  ut_rtsp_sender_to_server.cpp
   ut_srt_sender.cpp
   ut_main.cpp
 )
diff --git a/unittest/ut_rist_sender.cpp b/unittest/ut_rist_sender.cpp
new file mode 100644
index 0000000..5145d4e
--- /dev/null
+++ b/unittest/ut_rist_sender.cpp
@@ -0,0 +1,566 @@
+/*
+ * Copyright (c) 2022 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.
+ * 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 "ut_base.hpp"
+
+class MediaTransporterTestRistSender : public MediaTransporterTestBase {
+public:
+	MediaTransporterTestRistSender() = default;
+	~MediaTransporterTestRistSender() = default;
+
+	void SetUp() override {
+		LOGD("Enter");
+
+		int ret = mtpr_create(MTPR_CONNECTION_TYPE_RIST_SENDER, &_mtpr);
+		ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+		LOGD("Leave");
+	}
+
+	void TearDown() override {
+		int ret = MTPR_ERROR_NONE;
+		mtpr_state_e state = MTPR_STATE_IDLE;
+		LOGD("Enter");
+
+		if (_mtpr) {
+			ret = mtpr_get_state(_mtpr, &state);
+			ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+			if (state != MTPR_STATE_IDLE) {
+				ret = mtpr_stop(_mtpr);
+				ASSERT_EQ(ret, MTPR_ERROR_NONE);
+			}
+			ret = mtpr_destroy(_mtpr);
+			ASSERT_EQ(ret, MTPR_ERROR_NONE);
+		}
+		LOGD("Leave");
+	}
+
+protected:
+	const std::string _receiverPath = "127.0.0.1:5004";
+};
+
+TEST_F(MediaTransporterTestRistSender, set_address_p)
+{
+	int ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_address_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+
+	ret = mtpr_set_receiver_address(NULL, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_set_receiver_address(_mtpr, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_set_receiver_address(NULL, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_address_n2)
+{
+	int ret = mtpr_set_sender_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_address_p)
+{
+	int ret = MTPR_ERROR_NONE;
+	char *address = NULL;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_receiver_address(_mtpr, &address);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_TRUE(address);
+	ASSERT_STREQ(_receiverPath.c_str(), address);
+
+	free(address);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_address_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+	char *address = NULL;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_receiver_address(NULL, &address);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_receiver_address(_mtpr, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_receiver_address(NULL, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_address_n2)
+{
+	char *address = NULL;
+
+	int ret = mtpr_get_receiver_address(_mtpr, &address);
+	ASSERT_EQ(ret, MTPR_ERROR_NO_DATA);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_address_n3)
+{
+	int ret = MTPR_ERROR_NONE;
+	char *address = NULL;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_sender_address(_mtpr, &address);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_connection_type_p)
+{
+	mtpr_connection_type_e type;
+
+	int ret = mtpr_get_connection_type(_mtpr, &type);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_EQ(type, MTPR_CONNECTION_TYPE_RIST_SENDER);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_connection_type_n)
+{
+	int ret = MTPR_ERROR_NONE;
+	mtpr_connection_type_e type;
+
+	ret = mtpr_get_connection_type(NULL, &type);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_connection_type(_mtpr, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_connection_type(NULL, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, start_p)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, start_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, start_n2)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRistSender, start_n3)
+{
+	int ret = MTPR_ERROR_NONE;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRistSender, stop_p)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_stop(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, stop_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_stop(NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, stop_n2)
+{
+	int ret = mtpr_stop(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_STATE);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_state_p1)
+{
+	mtpr_state_e state = MTPR_STATE_IDLE;
+
+	int ret = mtpr_get_state(_mtpr, &state);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_EQ(state, MTPR_STATE_IDLE);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_state_p2)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+	mtpr_state_e state = MTPR_STATE_IDLE;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_state(_mtpr, &state);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_EQ(state, MTPR_STATE_PLAYING);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_state_p3)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+	mtpr_state_e state = MTPR_STATE_IDLE;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_stop(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_state(_mtpr, &state);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_EQ(state, MTPR_STATE_IDLE);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_state_n)
+{
+	int ret = MTPR_ERROR_NONE;
+	mtpr_state_e state = MTPR_STATE_IDLE;
+
+	ret = mtpr_get_state(NULL, &state);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_state(_mtpr, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_state(NULL, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_address_p1)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS, "0.0.0.0");
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_address_p2)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+/* FIXME: check with invalid addr format */
+TEST_F(MediaTransporterTestRistSender, DISABLED_set_connection_param_address_n)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_p1)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0");
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_p2)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0.05");
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_n1)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0.051");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_n2)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "test");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_n3)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0.051test");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_n4)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "-1");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_n5)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_p1)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "0");
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_p2)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "100");
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_n1)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "101");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_n2)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "test");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_n3)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "10test");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_n4)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "-1");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_n5)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_sender_buffer_p1)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "0");
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_sender_buffer_p2)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "4294967295");
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_sender_buffer_n1)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "11test");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_sender_buffer_n2)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "test");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_sender_buffer_n3)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+
+	ret = mtpr_set_connection_param(NULL, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "1000");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_set_connection_param(_mtpr, NULL, "1000");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_n2)
+{
+	int ret = MTPR_ERROR_NONE;
+
+	ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, "2");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_STREAMID, "testid");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_connection_param_p1)
+{
+	int ret = MTPR_ERROR_NONE;
+	gchar* value = NULL;
+
+	ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS, "127.0.0.1");
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_STREQ(value, "127.0.0.1");
+	g_free(value);
+
+	ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0.03");
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	double ret_val = strtod(value, NULL);
+	ASSERT_EQ(ret_val, (double)0.03);
+	g_free(value);
+
+	ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "99");
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_STREQ(value, "99");
+	g_free(value);
+
+	ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "1300");
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_STREQ(value, "1300");
+	g_free(value);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_connection_param_p2)
+{
+	int ret = MTPR_ERROR_NONE;
+	gchar* value = NULL;
+
+	ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_TRUE(value);
+	g_free(value);
+
+	ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_TRUE(value);
+	g_free(value);
+
+	ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_TRUE(value);
+	g_free(value);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_connection_param_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+	gchar* value = NULL;
+
+	ret = mtpr_get_connection_param(NULL, MTPR_CONNECTION_PARAM_SRT_MODE, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_connection_param(_mtpr, NULL, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_connection_param_n2)
+{
+	int ret = MTPR_ERROR_NONE;
+	gchar* value = NULL;
+
+	ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_NO_DATA);
+}
diff --git a/unittest/ut_rtsp_sender.cpp b/unittest/ut_rtsp_sender.cpp
new file mode 100644
index 0000000..774eb95
--- /dev/null
+++ b/unittest/ut_rtsp_sender.cpp
@@ -0,0 +1,347 @@
+/*
+ * Copyright (c) 2022 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.
+ * 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 "ut_base.hpp"
+
+class MediaTransporterTestRtspSender : public MediaTransporterTestBase {
+public:
+	MediaTransporterTestRtspSender() = default;
+	~MediaTransporterTestRtspSender() = default;
+
+	void SetUp() override {
+		LOGD("Enter");
+
+		int ret = mtpr_create(MTPR_CONNECTION_TYPE_RTSP_SENDER, &_mtpr);
+		ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+		LOGD("Leave");
+	}
+
+	void TearDown() override {
+		int ret = MTPR_ERROR_NONE;
+		mtpr_state_e state = MTPR_STATE_IDLE;
+		LOGD("Enter");
+
+		if (_mtpr) {
+			ret = mtpr_get_state(_mtpr, &state);
+			ASSERT_EQ(ret, MTPR_ERROR_NONE);
+			if (state != MTPR_STATE_IDLE) {
+				ret = mtpr_stop(_mtpr);
+				ASSERT_EQ(ret, MTPR_ERROR_NONE);
+			}
+			ret = mtpr_destroy(_mtpr);
+			ASSERT_EQ(ret, MTPR_ERROR_NONE);
+		}
+		LOGD("Leave");
+	}
+
+protected:
+	const std::string _senderPath = "rtsp://127.0.0.1:8554/test";
+};
+
+TEST_F(MediaTransporterTestRtspSender, set_address_p)
+{
+	int ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRtspSender, set_address_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+
+	ret = mtpr_set_sender_address(NULL, _senderPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_set_sender_address(_mtpr, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_set_sender_address(NULL, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, set_address_n2)
+{
+	int ret = mtpr_set_receiver_address(_mtpr, _senderPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_address_p)
+{
+	int ret = MTPR_ERROR_NONE;
+	char *address = NULL;
+
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_sender_address(_mtpr, &address);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_TRUE(address);
+	ASSERT_STREQ(_senderPath.c_str(), address);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_address_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+	char *address = NULL;
+
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_sender_address(NULL, &address);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_sender_address(_mtpr, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_sender_address(NULL, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_address_n2)
+{
+	char *address = NULL;
+
+	int ret = mtpr_get_sender_address(_mtpr, &address);
+	ASSERT_EQ(ret, MTPR_ERROR_NO_DATA);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_address_n3)
+{
+	int ret = MTPR_ERROR_NONE;
+	char *address = NULL;
+
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_receiver_address(_mtpr, &address);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_connection_type_p)
+{
+	mtpr_connection_type_e type;
+
+	int ret = mtpr_get_connection_type(_mtpr, &type);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_EQ(type, MTPR_CONNECTION_TYPE_RTSP_SENDER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_connection_type_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+	mtpr_connection_type_e type;
+
+	ret = mtpr_get_connection_type(NULL, &type);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_connection_type(_mtpr, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_connection_type(NULL, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, start_p)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRtspSender, start_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, start_n2)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSender, start_n3)
+{
+	int ret = MTPR_ERROR_NONE;
+
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSender, stop_p)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_stop(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRtspSender, stop_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_stop(NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, stop_n2)
+{
+	int ret = mtpr_stop(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_STATE);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_state_p1)
+{
+	mtpr_state_e state = MTPR_STATE_IDLE;
+
+	int ret = mtpr_get_state(_mtpr, &state);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_EQ(state, MTPR_STATE_IDLE);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_state_p2)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+	mtpr_state_e state = MTPR_STATE_IDLE;
+
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_state(_mtpr, &state);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_EQ(state, MTPR_STATE_PLAYING);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_state_p3)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+	mtpr_state_e state = MTPR_STATE_IDLE;
+
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_stop(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_state(_mtpr, &state);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_EQ(state, MTPR_STATE_IDLE);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_state_n)
+{
+	int ret = MTPR_ERROR_NONE;
+	mtpr_state_e state = MTPR_STATE_IDLE;
+
+	ret = mtpr_get_state(NULL, &state);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_state(_mtpr, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_state(NULL, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, set_connection_param_n)
+{
+	int ret = MTPR_ERROR_NONE;
+
+	ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, "2");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+
+	ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0.02");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_connection_param_n)
+{
+	int ret = MTPR_ERROR_NONE;
+	gchar* value = NULL;
+
+	ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+
+	ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
diff --git a/unittest/ut_rtsp_sender_to_server.cpp b/unittest/ut_rtsp_sender_to_server.cpp
new file mode 100644
index 0000000..e79fee7
--- /dev/null
+++ b/unittest/ut_rtsp_sender_to_server.cpp
@@ -0,0 +1,444 @@
+/*
+ * Copyright (c) 2022 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.
+ * 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 <gst/gst.h>
+#include <gst/rtsp-server/rtsp-server.h>
+
+#include "ut_base.hpp"
+
+static GMainLoop* _mainloop;
+static void* _run_rtsp_server(void* ptr) {
+	GstRTSPServer* server;
+	GstRTSPMountPoints* mounts;
+	GstRTSPMediaFactory* factory;
+
+	gst_init(NULL, NULL);
+	_mainloop = g_main_loop_new(NULL, FALSE);
+
+	server = gst_rtsp_server_new();
+	g_object_set(server, "service", "8554", NULL);
+
+	mounts = gst_rtsp_server_get_mount_points(server);
+
+	factory = gst_rtsp_media_factory_new();
+	gst_rtsp_media_factory_set_transport_mode(factory, GST_RTSP_TRANSPORT_MODE_RECORD);
+	gst_rtsp_media_factory_set_launch(factory, "decodebin name=depay0 ! videoconvert ! tizenwlsink");
+
+	gst_rtsp_mount_points_add_factory(mounts, "/test", factory);
+	g_object_unref(mounts);
+
+	gst_rtsp_server_attach(server, NULL);
+
+	LOGD("server ready");
+	g_main_loop_run(_mainloop);
+
+	LOGD("server terminated");
+	g_main_loop_unref(_mainloop);
+
+	return NULL;
+}
+
+class MediaTransporterTestRtspSenderToServerRun : public MediaTransporterTestBase {
+public:
+	MediaTransporterTestRtspSenderToServerRun() = default;
+	~MediaTransporterTestRtspSenderToServerRun() = default;
+
+	void SetUp() override {
+		LOGD("Enter");
+
+		start_rtsp_server();
+
+		int ret = mtpr_create(MTPR_CONNECTION_TYPE_RTSP_SENDER_TO_SERVER, &_mtpr);
+		ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+		LOGD("Leave");
+	}
+
+	void TearDown() override {
+		int ret = MTPR_ERROR_NONE;
+		mtpr_state_e state = MTPR_STATE_IDLE;
+		LOGD("Enter");
+
+		if (_mtpr) {
+			ret = mtpr_get_state(_mtpr, &state);
+			ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+			if (state != MTPR_STATE_IDLE) {
+				ret = mtpr_stop(_mtpr);
+				ASSERT_EQ(ret, MTPR_ERROR_NONE);
+			}
+			ret = mtpr_destroy(_mtpr);
+			ASSERT_EQ(ret, MTPR_ERROR_NONE);
+		}
+
+		stop_rtsp_server();
+		LOGD("Leave");
+	}
+
+protected:
+	const std::string _receiverPath = "rtsp://127.0.0.1:8554/test";
+
+	void start_rtsp_server() {
+		_rtspServer = g_thread_try_new("rtsp_server", _run_rtsp_server, NULL, NULL);
+		std::this_thread::sleep_for(std::chrono::milliseconds(100));
+	}
+
+	void stop_rtsp_server() {
+		if (_mainloop)
+			g_main_loop_quit(_mainloop);
+		if (_rtspServer)
+			g_thread_join(_rtspServer);
+	}
+
+	GThread* _rtspServer {nullptr};
+};
+
+class MediaTransporterTestRtspSenderToServer : public MediaTransporterTestBase {
+public:
+	MediaTransporterTestRtspSenderToServer() = default;
+	~MediaTransporterTestRtspSenderToServer() = default;
+
+	void SetUp() override {
+		LOGD("Enter");
+
+		int ret = mtpr_create(MTPR_CONNECTION_TYPE_RTSP_SENDER_TO_SERVER, &_mtpr);
+		ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+		LOGD("Leave");
+	}
+
+	void TearDown() override {
+		int ret = MTPR_ERROR_NONE;
+		mtpr_state_e state = MTPR_STATE_IDLE;
+		LOGD("Enter");
+
+		if (_mtpr) {
+			ret = mtpr_get_state(_mtpr, &state);
+			ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+			if (state != MTPR_STATE_IDLE) {
+				ret = mtpr_stop(_mtpr);
+				ASSERT_EQ(ret, MTPR_ERROR_NONE);
+			}
+			ret = mtpr_destroy(_mtpr);
+			ASSERT_EQ(ret, MTPR_ERROR_NONE);
+		}
+		LOGD("Leave");
+	}
+
+protected:
+	const std::string _receiverPath = "rtsp://127.0.0.1:8554/test";
+};
+
+// MediaTransporterTestRtspSenderToServer
+
+TEST_F(MediaTransporterTestRtspSenderToServer, set_address_p)
+{
+	int ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, set_address_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+
+	ret = mtpr_set_receiver_address(NULL, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_set_receiver_address(_mtpr, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_set_receiver_address(NULL, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, set_address_n2)
+{
+	int ret = mtpr_set_sender_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_address_p)
+{
+	int ret = MTPR_ERROR_NONE;
+	char *address = NULL;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_receiver_address(_mtpr, &address);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_TRUE(address);
+	ASSERT_STREQ(_receiverPath.c_str(), address);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_address_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+	char *address = NULL;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_receiver_address(NULL, &address);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_receiver_address(_mtpr, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_receiver_address(NULL, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_address_n2)
+{
+	char *address = NULL;
+
+	int ret = mtpr_get_receiver_address(_mtpr, &address);
+	ASSERT_EQ(ret, MTPR_ERROR_NO_DATA);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_address_n3)
+{
+	int ret = MTPR_ERROR_NONE;
+	char *address = NULL;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_sender_address(_mtpr, &address);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_connection_type_p)
+{
+	mtpr_connection_type_e type;
+
+	int ret = mtpr_get_connection_type(_mtpr, &type);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_EQ(type, MTPR_CONNECTION_TYPE_RTSP_SENDER_TO_SERVER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_connection_type_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+	mtpr_connection_type_e type;
+
+	ret = mtpr_get_connection_type(NULL, &type);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_connection_type(_mtpr, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_connection_type(NULL, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, start_n1)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, start_n2)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, start_n3)
+{
+	int ret = MTPR_ERROR_NONE;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+
+TEST_F(MediaTransporterTestRtspSenderToServer, stop_n)
+{
+	int ret = mtpr_stop(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_STATE);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_state_p)
+{
+	mtpr_state_e state = MTPR_STATE_IDLE;
+
+	int ret = mtpr_get_state(_mtpr, &state);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_EQ(state, MTPR_STATE_IDLE);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_state_n)
+{
+	int ret = MTPR_ERROR_NONE;
+	mtpr_state_e state = MTPR_STATE_IDLE;
+
+	ret = mtpr_get_state(NULL, &state);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_state(_mtpr, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+	ret = mtpr_get_state(NULL, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, set_connection_param_n)
+{
+	int ret = MTPR_ERROR_NONE;
+
+	ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, "2");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+
+	ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0.02");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_connection_param_n)
+{
+	int ret = MTPR_ERROR_NONE;
+	gchar* value = NULL;
+
+	ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+
+	ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, &value);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+// MediaTransporterTestRtspSenderToServerRun
+
+TEST_F(MediaTransporterTestRtspSenderToServerRun, start_p)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServerRun, stop_p)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_stop(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServerRun, stop_n)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_stop(NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServerRun, get_state_p1)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+	mtpr_state_e state = MTPR_STATE_IDLE;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_state(_mtpr, &state);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_EQ(state, MTPR_STATE_PLAYING);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServerRun, get_state_p2)
+{
+	int ret = MTPR_ERROR_NONE;
+	unsigned int source_id = 0;
+	mtpr_state_e state = MTPR_STATE_IDLE;
+
+	ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_GE(source_id, 0);
+
+	ret = mtpr_start(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_stop(_mtpr);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+	ret = mtpr_get_state(_mtpr, &state);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+	ASSERT_EQ(state, MTPR_STATE_IDLE);
+}
diff --git a/unittest/ut_srt_sender.cpp b/unittest/ut_srt_sender.cpp
index 24b0dcc..fa02e66 100644
--- a/unittest/ut_srt_sender.cpp
+++ b/unittest/ut_srt_sender.cpp
@@ -50,12 +50,12 @@ public:
 	}
 
 protected:
-	const std::string _srtSenderPath = "srt://:8888";
+	const std::string _senderPath = "srt://:8888";
 };
 
 TEST_F(MediaTransporterTestSrtSender, set_address_p)
 {
-	int ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+	int ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 }
 
@@ -63,7 +63,7 @@ TEST_F(MediaTransporterTestSrtSender, set_address_n1)
 {
 	int ret = MTPR_ERROR_NONE;
 
-	ret = mtpr_set_sender_address(NULL, _srtSenderPath.c_str());
+	ret = mtpr_set_sender_address(NULL, _senderPath.c_str());
 	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 
 	ret = mtpr_set_sender_address(_mtpr, NULL);
@@ -75,7 +75,7 @@ TEST_F(MediaTransporterTestSrtSender, set_address_n1)
 
 TEST_F(MediaTransporterTestSrtSender, set_address_n2)
 {
-	int ret = mtpr_set_receiver_address(_mtpr, _srtSenderPath.c_str());
+	int ret = mtpr_set_receiver_address(_mtpr, _senderPath.c_str());
 	ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
 }
 
@@ -84,13 +84,13 @@ TEST_F(MediaTransporterTestSrtSender, get_address_p)
 	int ret = MTPR_ERROR_NONE;
 	char *address = NULL;
 
-	ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 
 	ret = mtpr_get_sender_address(_mtpr, &address);
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 	ASSERT_TRUE(address);
-	ASSERT_STREQ(_srtSenderPath.c_str(), address);
+	ASSERT_STREQ(_senderPath.c_str(), address);
 }
 
 TEST_F(MediaTransporterTestSrtSender, get_address_n1)
@@ -98,7 +98,7 @@ TEST_F(MediaTransporterTestSrtSender, get_address_n1)
 	int ret = MTPR_ERROR_NONE;
 	char *address = NULL;
 
-	ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 
 	ret = mtpr_get_sender_address(NULL, &address);
@@ -124,7 +124,7 @@ TEST_F(MediaTransporterTestSrtSender, get_address_n3)
 	int ret = MTPR_ERROR_NONE;
 	char *address = NULL;
 
-	ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 
 	ret = mtpr_get_receiver_address(_mtpr, &address);
@@ -140,7 +140,7 @@ TEST_F(MediaTransporterTestSrtSender, get_connection_type_p)
 	ASSERT_EQ(type, MTPR_CONNECTION_TYPE_SRT_SENDER);
 }
 
-TEST_F(MediaTransporterTestSrtSender, get_connection_type_n1)
+TEST_F(MediaTransporterTestSrtSender, get_connection_type_n)
 {
 	int ret = MTPR_ERROR_NONE;
 	mtpr_connection_type_e type;
@@ -186,14 +186,13 @@ TEST_F(MediaTransporterTestSrtSender, start_p)
 	int ret = MTPR_ERROR_NONE;
 	unsigned int source_id = 0;
 
-	ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 
 	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 	ASSERT_GE(source_id, 0);
 
-
 	ret = mtpr_start(_mtpr);
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 }
@@ -203,7 +202,7 @@ TEST_F(MediaTransporterTestSrtSender, start_n1)
 	int ret = MTPR_ERROR_NONE;
 	unsigned int source_id = 0;
 
-	ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 
 	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
@@ -231,7 +230,7 @@ TEST_F(MediaTransporterTestSrtSender, start_n3)
 {
 	int ret = MTPR_ERROR_NONE;
 
-	ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 
 	ret = mtpr_start(_mtpr);
@@ -243,7 +242,7 @@ TEST_F(MediaTransporterTestSrtSender, stop_p)
 	int ret = MTPR_ERROR_NONE;
 	unsigned int source_id = 0;
 
-	ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 
 	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
@@ -262,7 +261,7 @@ TEST_F(MediaTransporterTestSrtSender, stop_n1)
 	int ret = MTPR_ERROR_NONE;
 	unsigned int source_id = 0;
 
-	ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 
 	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
@@ -297,7 +296,7 @@ TEST_F(MediaTransporterTestSrtSender, get_state_p2)
 	unsigned int source_id = 0;
 	mtpr_state_e state = MTPR_STATE_IDLE;
 
-	ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 
 	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
@@ -318,7 +317,7 @@ TEST_F(MediaTransporterTestSrtSender, get_state_p3)
 	unsigned int source_id = 0;
 	mtpr_state_e state = MTPR_STATE_IDLE;
 
-	ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+	ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 
 	ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
@@ -369,18 +368,36 @@ TEST_F(MediaTransporterTestSrtSender, set_connection_param_mode_n2)
 	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(MediaTransporterTestSrtSender, set_connection_param_streamid_p)
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_mode_n3)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_streamid_p1)
 {
 	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_STREAMID, "testid");
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 }
 
-TEST_F(MediaTransporterTestSrtSender, set_connection_param_passphrase_p)
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_streamid_p2)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_STREAMID, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_passphrase_p1)
 {
 	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, "testpassphrase");
 	ASSERT_EQ(ret, MTPR_ERROR_NONE);
 }
 
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_passphrase_p2)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
 TEST_F(MediaTransporterTestSrtSender, set_connection_param_passphrase_n)
 {
 	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, "testpwd");
@@ -411,7 +428,13 @@ TEST_F(MediaTransporterTestSrtSender, set_connection_param_pbkeylen_n3)
 	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(MediaTransporterTestSrtSender, set_connection_param_n)
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_pbkeylen_n4)
+{
+	int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, NULL);
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_n1)
 {
 	int ret = MTPR_ERROR_NONE;
 
@@ -420,12 +443,20 @@ TEST_F(MediaTransporterTestSrtSender, set_connection_param_n)
 
 	ret = mtpr_set_connection_param(_mtpr, NULL, "2");
 	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_n2)
+{
+	int ret = MTPR_ERROR_NONE;
+
+	ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "1000");
+	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 
-	ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, NULL);
+	ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "50");
 	ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(MediaTransporterTestSrtSender, get_connection_param_p)
+TEST_F(MediaTransporterTestSrtSender, get_connection_param_p1)
 {
 	int ret = MTPR_ERROR_NONE;
 	gchar* value = NULL;