[1.0.1][ut] add receiver test cases

Change-Id: Ieda6affd9d372d62921f018e9a6578f0759e0ead

diff --git a/packaging/capi-media-transporter.spec b/packaging/capi-media-transporter.spec
index 2a4a4fe..9150950 100644 (file)
--- 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:    1.0.0
+Version:    1.0.1
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/unittest/CMakeLists.txt b/unittest/CMakeLists.txt
index 424b7b8..1b0882d 100644 (file)
--- a/unittest/CMakeLists.txt
+++ b/unittest/CMakeLists.txt
@@ -46,9 +46,11 @@ INCLUDE_DIRECTORIES(
 
 SET(UT_SRC
   ut_rist_sender.cpp
+  ut_rist_receiver.cpp
   ut_rtsp_sender.cpp
   ut_rtsp_sender_to_server.cpp
   ut_srt_sender.cpp
+  ut_srt_receiver.cpp
   ut_main.cpp
 )
 

diff --git a/unittest/ut_base.hpp b/unittest/ut_base.hpp
index e955570..32320f5 100644 (file)
--- a/unittest/ut_base.hpp
+++ b/unittest/ut_base.hpp
@@ -15,16 +15,13 @@
  */
 
 #include <chrono>
-#include <iostream>
-#include <memory>
-#include <string>
 #include <thread>
-#include <malloc.h>
+#include <mutex>
+#include <condition_variable>
 #include <dlog.h>
 #include <glib.h>
-
-#include "gtest/gtest.h"
 #include <mtpr.h>
+#include "gtest/gtest.h"
 
 #undef LOG_TAG
 #define LOG_TAG "MTPR_UT"

diff --git a/unittest/ut_rist_receiver.cpp b/unittest/ut_rist_receiver.cpp
new file mode 100644 (file)
index 0000000..b3e1939
--- /dev/null
+++ b/unittest/ut_rist_receiver.cpp
@@ -0,0 +1,431 @@
+/*
+ * 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 "ut_base.hpp"
+
+static GMainLoop* mainloop;
+static std::mutex dataLock;
+static std::condition_variable dataCV;
+static bool packetReceived;
+
+static void* _run_rist_sender(void* ptr) {
+       mtpr_h mtpr;
+       unsigned int src_id = 0;
+       mtpr_create(MTPR_CONNECTION_TYPE_RIST_SENDER, &mtpr);
+       mtpr_set_receiver_address(mtpr, "127.0.0.1:5004");
+       mtpr_add_media_source(mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &src_id);
+       mtpr_start(mtpr);
+
+       mainloop = g_main_loop_new(NULL, FALSE);
+
+       LOGD("rist sender ready");
+       g_main_loop_run(mainloop);
+
+       LOGD("rist sender terminated");
+       g_main_loop_unref(mainloop);
+
+       mtpr_stop(mtpr);
+       mtpr_destroy(mtpr);
+
+       return NULL;
+}
+
+static void dataPacketCb(mtpr_h mtpr, mtpr_media_type_e type,
+                                               unsigned int id, media_packet_h packet, void *user_data) {
+       LOGD("callback is invoked. type: %d, id: %d", type, id);
+       std::unique_lock<std::mutex> lock(dataLock);
+
+       packetReceived = true;
+
+       lock.unlock();
+       dataCV.notify_all();
+}
+
+static void waitDataPacket() {
+       std::unique_lock<std::mutex> lock(dataLock);
+       LOGD("start] wait video data");
+       if (dataCV.wait_for(lock, std::chrono::seconds(1),
+                       []{ return packetReceived; })) {
+           LOGD("finish waiting for packet received");
+       } else {
+           LOGW("1s timed out for packet receiving");
+       }
+       LOGD("stop] wait video data");
+       lock.unlock();
+}
+
+class MediaTransporterTestRistReceiverWithSender : public MediaTransporterTestBase {
+public:
+       MediaTransporterTestRistReceiverWithSender() = default;
+       ~MediaTransporterTestRistReceiverWithSender() = default;
+
+       void SetUp() override {
+               LOGD("Enter");
+               start_rist_sender();
+               packetReceived = false;
+
+               int ret = mtpr_create(MTPR_CONNECTION_TYPE_RIST_RECEIVER, &_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");
+               stop_rist_sender();
+
+               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";
+
+       void start_rist_sender() {
+               _ristSender = g_thread_try_new("rist_sender", _run_rist_sender, NULL, NULL);
+               std::this_thread::sleep_for(std::chrono::seconds(1));
+       }
+
+       void stop_rist_sender() {
+               if (mainloop)
+                       g_main_loop_quit(mainloop);
+               if (_ristSender)
+                       g_thread_join(_ristSender);
+       }
+
+       GThread* _ristSender {nullptr};
+};
+
+class MediaTransporterTestRistReceiver : public MediaTransporterTestBase {
+public:
+       MediaTransporterTestRistReceiver() = default;
+       ~MediaTransporterTestRistReceiver() = default;
+
+       void SetUp() override {
+               LOGD("Enter");
+
+               int ret = mtpr_create(MTPR_CONNECTION_TYPE_RIST_RECEIVER, &_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";
+};
+
+// MediaTransporterTestRistReceiver
+
+TEST_F(MediaTransporterTestRistReceiver, set_address_p)
+{
+       int ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistReceiver, 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(MediaTransporterTestRistReceiver, set_address_n2)
+{
+       int ret = mtpr_set_sender_address(_mtpr, _receiverPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRistReceiver, 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(MediaTransporterTestRistReceiver, 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(MediaTransporterTestRistReceiver, get_address_n2)
+{
+       char *address = NULL;
+
+       int ret = mtpr_get_receiver_address(_mtpr, &address);
+       ASSERT_EQ(ret, MTPR_ERROR_NO_DATA);
+}
+
+TEST_F(MediaTransporterTestRistReceiver, 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(MediaTransporterTestRistReceiver, 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_RECEIVER);
+}
+
+TEST_F(MediaTransporterTestRistReceiver, 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(MediaTransporterTestRistReceiver, start_p)
+{
+       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_NONE);
+}
+
+TEST_F(MediaTransporterTestRistReceiver, start_n1)
+{
+       int ret = MTPR_ERROR_NONE;
+
+       ret = mtpr_start(_mtpr);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRistReceiver, start_n2)
+{
+       int ret = MTPR_ERROR_NONE;
+
+       ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_start(NULL);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistReceiver, stop_p)
+{
+       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_NONE);
+
+       ret = mtpr_stop(_mtpr);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistReceiver, stop_n1)
+{
+       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_NONE);
+
+       ret = mtpr_stop(NULL);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistReceiver, stop_n2)
+{
+       int ret = mtpr_stop(_mtpr);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_STATE);
+}
+
+TEST_F(MediaTransporterTestRistReceiver, 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(MediaTransporterTestRistReceiver, get_state_p2)
+{
+       int ret = MTPR_ERROR_NONE;
+       mtpr_state_e state = MTPR_STATE_IDLE;
+
+       ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       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(MediaTransporterTestRistReceiver, get_state_p3)
+{
+       int ret = MTPR_ERROR_NONE;
+       mtpr_state_e state = MTPR_STATE_IDLE;
+
+       ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       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(MediaTransporterTestRistReceiver, 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(MediaTransporterTestRistReceiver, 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(MediaTransporterTestRistReceiver, get_connection_param_n)
+{
+       int ret = MTPR_ERROR_NONE;
+       char* 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);
+}
+
+// MediaTransporterTestRistReceiverWithSender
+
+TEST_F(MediaTransporterTestRistReceiverWithSender, start_p)
+{
+       int ret = MTPR_ERROR_NONE;
+
+       ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_set_video_packet_cb(_mtpr, dataPacketCb, _mtpr);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_start(_mtpr);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       waitDataPacket();
+       ASSERT_TRUE(packetReceived);
+}

diff --git a/unittest/ut_srt_receiver.cpp b/unittest/ut_srt_receiver.cpp
new file mode 100644 (file)
index 0000000..1d3bbf3
--- /dev/null
+++ b/unittest/ut_srt_receiver.cpp
@@ -0,0 +1,595 @@
+/*
+ * 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 "ut_base.hpp"
+
+static GMainLoop* mainloop;
+static std::mutex dataLock;
+static std::condition_variable dataCV;
+static bool packetReceived;
+
+static void* _run_srt_sender(void* ptr) {
+       mtpr_h mtpr;
+       unsigned int src_id = 0;
+       mtpr_create(MTPR_CONNECTION_TYPE_SRT_SENDER, &mtpr);
+       mtpr_set_sender_address(mtpr, "srt://:8888");
+       mtpr_add_media_source(mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &src_id);
+       mtpr_start(mtpr);
+
+       mainloop = g_main_loop_new(NULL, FALSE);
+
+       LOGD("srt sender ready");
+       g_main_loop_run(mainloop);
+
+       LOGD("srt sender terminated");
+       g_main_loop_unref(mainloop);
+
+       mtpr_stop(mtpr);
+       mtpr_destroy(mtpr);
+
+       return NULL;
+}
+
+static void dataPacketCb(mtpr_h mtpr, mtpr_media_type_e type,
+                                               unsigned int id, media_packet_h packet, void *user_data) {
+       LOGD("callback is invoked. type: %d, id: %d", type, id);
+       std::unique_lock<std::mutex> lock(dataLock);
+
+       packetReceived = true;
+
+       lock.unlock();
+       dataCV.notify_all();
+}
+
+static void waitDataPacket() {
+       std::unique_lock<std::mutex> lock(dataLock);
+       LOGD("start] wait video data");
+       if (dataCV.wait_for(lock, std::chrono::seconds(1),
+                       []{ return packetReceived; })) {
+           LOGD("finish waiting for packet received");
+       } else {
+           LOGW("1s timed out for packet receiving");
+       }
+       LOGD("stop] wait video data");
+       lock.unlock();
+}
+
+class MediaTransporterTestSrtReceiverWithSender : public MediaTransporterTestBase {
+public:
+       MediaTransporterTestSrtReceiverWithSender() = default;
+       ~MediaTransporterTestSrtReceiverWithSender() = default;
+
+       void SetUp() override {
+               LOGD("Enter");
+               start_srt_sender();
+               packetReceived = false;
+
+               int ret = mtpr_create(MTPR_CONNECTION_TYPE_SRT_RECEIVER, &_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");
+               stop_srt_sender();
+
+               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 = "srt://127.0.0.1:8888";
+
+       void start_srt_sender() {
+               _srtSender = g_thread_try_new("srt_sender", _run_srt_sender, NULL, NULL);
+               std::this_thread::sleep_for(std::chrono::seconds(1));
+       }
+
+       void stop_srt_sender() {
+               if (mainloop)
+                       g_main_loop_quit(mainloop);
+               if (_srtSender)
+                       g_thread_join(_srtSender);
+       }
+
+       GThread* _srtSender {nullptr};
+};
+
+class MediaTransporterTestSrtReceiver : public MediaTransporterTestBase {
+public:
+       MediaTransporterTestSrtReceiver() = default;
+       ~MediaTransporterTestSrtReceiver() = default;
+
+       void SetUp() override {
+               LOGD("Enter");
+
+               int ret = mtpr_create(MTPR_CONNECTION_TYPE_SRT_RECEIVER, &_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 = "srt://127.0.0.1:8888";
+};
+
+// MediaTransporterTestSrtReceiver
+
+TEST_F(MediaTransporterTestSrtReceiver, set_address_p)
+{
+       int ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, 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(MediaTransporterTestSrtReceiver, set_address_n2)
+{
+       int ret = mtpr_set_receiver_address(_mtpr, _senderPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, 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(MediaTransporterTestSrtReceiver, 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(MediaTransporterTestSrtReceiver, get_address_n2)
+{
+       char *address = NULL;
+
+       int ret = mtpr_get_sender_address(_mtpr, &address);
+       ASSERT_EQ(ret, MTPR_ERROR_NO_DATA);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, 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(MediaTransporterTestSrtReceiver, 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_SRT_RECEIVER);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, 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(MediaTransporterTestSrtReceiver, start_p)
+{
+       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_NONE);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, start_n1)
+{
+       int ret = MTPR_ERROR_NONE;
+
+       ret = mtpr_start(_mtpr);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, start_n2)
+{
+       int ret = MTPR_ERROR_NONE;
+
+       ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_start(NULL);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, stop_p)
+{
+       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_NONE);
+
+       ret = mtpr_stop(_mtpr);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, stop_n1)
+{
+       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_NONE);
+
+       ret = mtpr_stop(NULL);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, stop_n2)
+{
+       int ret = mtpr_stop(_mtpr);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_STATE);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, 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(MediaTransporterTestSrtReceiver, get_state_p2)
+{
+       int ret = MTPR_ERROR_NONE;
+       mtpr_state_e state = MTPR_STATE_IDLE;
+
+       ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       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(MediaTransporterTestSrtReceiver, get_state_p3)
+{
+       int ret = MTPR_ERROR_NONE;
+       mtpr_state_e state = MTPR_STATE_IDLE;
+
+       ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       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(MediaTransporterTestSrtReceiver, 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(MediaTransporterTestSrtReceiver, set_connection_param_mode_p)
+{
+       int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, "2");
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, set_connection_param_mode_n1)
+{
+       int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, "4");
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, set_connection_param_mode_n2)
+{
+       int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, "test");
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, 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(MediaTransporterTestSrtReceiver, 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(MediaTransporterTestSrtReceiver, 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(MediaTransporterTestSrtReceiver, 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(MediaTransporterTestSrtReceiver, 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(MediaTransporterTestSrtReceiver, set_connection_param_passphrase_n)
+{
+       int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, "testpwd");
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, set_connection_param_pbkeylen_p)
+{
+       int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, "16");
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, set_connection_param_pbkeylen_n1)
+{
+       int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, "20");
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, set_connection_param_pbkeylen_n2)
+{
+       int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, "16test");
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, set_connection_param_pbkeylen_n3)
+{
+       int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, "test");
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, 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(MediaTransporterTestSrtReceiver, set_connection_param_n1)
+{
+       int ret = MTPR_ERROR_NONE;
+
+       ret = mtpr_set_connection_param(NULL, MTPR_CONNECTION_PARAM_SRT_MODE, "2");
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+       ret = mtpr_set_connection_param(_mtpr, NULL, "2");
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, 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_RIST_MIN_RTCP_INTERVAL, "50");
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, get_connection_param_p1)
+{
+       int ret = MTPR_ERROR_NONE;
+       char* value = NULL;
+
+       ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, "2");
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, &value);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       ASSERT_STREQ(value, "2");
+       g_free(value);
+
+       ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_STREAMID, "testid");
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_STREAMID, &value);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       ASSERT_STREQ(value, "testid");
+       g_free(value);
+
+       ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, "testpassphrase");
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, &value);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       ASSERT_STREQ(value, "testpassphrase");
+       g_free(value);
+
+       ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, "24");
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, &value);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       ASSERT_STREQ(value, "24");
+       g_free(value);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, get_connection_param_p2)
+{
+       int ret = MTPR_ERROR_NONE;
+       char* value = NULL;
+
+       ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, &value);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       ASSERT_TRUE(value);
+       g_free(value);
+
+       ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, &value);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       ASSERT_TRUE(value);
+       g_free(value);
+}
+
+TEST_F(MediaTransporterTestSrtReceiver, get_connection_param_n1)
+{
+       int ret = MTPR_ERROR_NONE;
+       char* 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(MediaTransporterTestSrtReceiver, get_connection_param_n2)
+{
+       int ret = MTPR_ERROR_NONE;
+       char* value = NULL;
+
+       ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_STREAMID, &value);
+       ASSERT_EQ(ret, MTPR_ERROR_NO_DATA);
+
+       ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, &value);
+       ASSERT_EQ(ret, MTPR_ERROR_NO_DATA);
+}
+
+// MediaTransporterTestSrtReceiverWithSender
+
+TEST_F(MediaTransporterTestSrtReceiverWithSender, start_p)
+{
+       int ret = MTPR_ERROR_NONE;
+
+       ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_set_video_packet_cb(_mtpr, dataPacketCb, _mtpr);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_start(_mtpr);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       waitDataPacket();
+       ASSERT_TRUE(packetReceived);
+}