[0.0.10][ut] add srt sender

Change-Id: Ied5c843a3197f10f7fcf2e6c8aee35bb2720bb03

diff --git a/include/mtpr.h b/include/mtpr.h
index 2239968..2906088 100644 (file)
--- a/include/mtpr.h
+++ b/include/mtpr.h
@@ -391,7 +391,6 @@ int mtpr_destroy(mtpr_h mtpr);
  * @retval #MTPR_ERROR_NONE Successful
  * @retval #MTPR_ERROR_INVALID_PARAMETER Invalid parameter
  * @retval #MTPR_ERROR_INVALID_OPERATION Invalid operation
- * @retval #MTPR_ERROR_INVALID_STATE Invalid state
  * @retval #MTPR_ERROR_RESOURCE_FAILED Resource failed
  * @pre @a mtpr state must be set to #MTPR_STATE_IDLE.
  * @post @a mtpr state will be #MTPR_STATE_PLAYING. // FIXME

diff --git a/packaging/capi-media-transporter.spec b/packaging/capi-media-transporter.spec
index da6b952..f2b8d11 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:    0.0.9
+Version:    0.0.10
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/MediaTransporter.cpp b/src/MediaTransporter.cpp
index dfd5224..f044786 100644 (file)
--- a/src/MediaTransporter.cpp
+++ b/src/MediaTransporter.cpp
@@ -23,6 +23,8 @@ typedef struct {
 
 int mtpr_create(mtpr_connection_type_e type, mtpr_h* mtpr)
 {
+       RET_ERR_IF_NULL_ARG(mtpr);
+
        auto handle = new media_transporter_s;
        RET_VAL_IF(!handle, MTPR_ERROR_INVALID_OPERATION, "Failed to allocate handle!!!");
 
@@ -104,6 +106,7 @@ int mtpr_stop(mtpr_h mtpr)
 int mtpr_get_state(mtpr_h mtpr, mtpr_state_e *state)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(state);
 
        try {
                auto handle = static_cast<media_transporter_s*>(mtpr);
@@ -120,6 +123,7 @@ int mtpr_get_state(mtpr_h mtpr, mtpr_state_e *state)
 int mtpr_get_connection_type(mtpr_h mtpr, mtpr_connection_type_e *type)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(type);
 
        try {
                auto handle = static_cast<media_transporter_s*>(mtpr);
@@ -136,6 +140,7 @@ int mtpr_get_connection_type(mtpr_h mtpr, mtpr_connection_type_e *type)
 int mtpr_set_sender_address(mtpr_h mtpr, const char *address)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(address);
 
        try {
                auto handle = static_cast<media_transporter_s*>(mtpr);
@@ -174,6 +179,7 @@ int mtpr_get_sender_address(mtpr_h mtpr, char **address)
 int mtpr_set_receiver_address(mtpr_h mtpr, const char *address)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(address);
 
        try {
                auto handle = static_cast<media_transporter_s*>(mtpr);
@@ -212,6 +218,8 @@ int mtpr_get_receiver_address(mtpr_h mtpr, char **address)
 int mtpr_set_connection_param(mtpr_h mtpr, const char *param_name, const char *param_value)
 {
        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);
@@ -228,6 +236,7 @@ int mtpr_set_connection_param(mtpr_h mtpr, const char *param_name, const char *p
 int mtpr_set_connection_params(mtpr_h mtpr, bundle *param_list)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(param_list);
 
        try {
                auto handle = static_cast<media_transporter_s*>(mtpr);
@@ -244,6 +253,8 @@ int mtpr_set_connection_params(mtpr_h mtpr, bundle *param_list)
 int mtpr_get_connection_params(mtpr_h mtpr, bundle **param_list)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(param_list);
+
        bundle *params = NULL;
        try {
                auto handle = static_cast<media_transporter_s*>(mtpr);
@@ -328,6 +339,7 @@ int mtpr_mic_source_set_sound_stream_info(mtpr_h mtpr, unsigned int source_id, s
 int mtpr_set_error_cb(mtpr_h mtpr, mtpr_error_cb callback, void *user_data)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(callback);
 
        try {
                auto handle = static_cast<media_transporter_s*>(mtpr);
@@ -360,6 +372,7 @@ int mtpr_unset_error_cb(mtpr_h mtpr)
 int mtpr_set_track_added_cb(mtpr_h mtpr, mtpr_track_added_cb callback, void* user_data)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(callback);
 
        auto handle = static_cast<media_transporter_s*>(mtpr);
        assert(handle->base);
@@ -400,6 +413,7 @@ int mtpr_unset_track_added_cb(mtpr_h mtpr)
 int mtpr_set_no_more_track_cb(mtpr_h mtpr, mtpr_no_more_track_cb callback, void* user_data)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(callback);
 
        auto handle = static_cast<media_transporter_s*>(mtpr);
        assert(handle->base);
@@ -440,6 +454,7 @@ int mtpr_unset_no_more_track_cb(mtpr_h mtpr)
 int mtpr_set_audio_packet_cb(mtpr_h mtpr, mtpr_encoded_frame_cb callback, void* user_data)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(callback);
 
        auto handle = static_cast<media_transporter_s*>(mtpr);
        assert(handle->base);
@@ -480,6 +495,7 @@ int mtpr_unset_audio_packet_cb(mtpr_h mtpr)
 int mtpr_set_video_packet_cb(mtpr_h mtpr, mtpr_encoded_frame_cb callback, void* user_data)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(callback);
 
        auto handle = static_cast<media_transporter_s*>(mtpr);
        assert(handle->base);
@@ -520,6 +536,7 @@ int mtpr_unset_video_packet_cb(mtpr_h mtpr)
 int mtpr_set_display(mtpr_h mtpr, mtpr_display_type_e type, mtpr_display_h display)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(display);
 
        auto handle = static_cast<media_transporter_s*>(mtpr);
        assert(handle->base);
@@ -558,6 +575,7 @@ int mtpr_set_display_mode(mtpr_h mtpr, mtpr_display_mode_e mode)
 int mtpr_get_display_mode(mtpr_h mtpr, mtpr_display_mode_e *mode)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(mode);
 
        auto handle = static_cast<media_transporter_s*>(mtpr);
        RET_VAL_IF(!handle->display, MTPR_ERROR_INVALID_OPERATION, "display is not set yet!!!");
@@ -592,6 +610,7 @@ int mtpr_set_display_visible(mtpr_h mtpr, bool visible)
 int mtpr_get_display_visible(mtpr_h mtpr, bool *visible)
 {
        RET_ERR_IF_INVALID_INSTANCE(mtpr);
+       RET_ERR_IF_NULL_ARG(visible);
 
        auto handle = static_cast<media_transporter_s*>(mtpr);
        RET_VAL_IF(!handle->display, MTPR_ERROR_INVALID_OPERATION, "display is not set yet!!!");

diff --git a/src/MediaTransporterParam.cpp b/src/MediaTransporterParam.cpp
index 047fc6a..7b0b413 100644 (file)
--- a/src/MediaTransporterParam.cpp
+++ b/src/MediaTransporterParam.cpp
@@ -25,6 +25,9 @@
 using namespace tizen_media_transporter;
 using namespace tizen_media_transporter::param::srt;
 
+constexpr size_t SRT_MIN_PASSPHRASE = 10;
+constexpr size_t SRT_MAX_PASSPHRASE = 79;
+
 void param::parseSourceParam(bundle* params, param::videoInfo* vInfo, param::encodingInfo* eInfo)
 {
        int written_count = 0;
@@ -135,8 +138,9 @@ 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)
+                               throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "wrong passphrase");
                        connectionParam->passPhrase = value;
-
                } else if (key.compare(MTPR_CONNECTION_PARAM_SRT_PBKEYLEN) == 0) {
                        size_t size;
                        int val = stoi(value, &size);
@@ -161,16 +165,16 @@ void param::srt::setConnectionParamList(bundle* paramList, param::srt::connectio
        char* string_val = NULL;
 
        if (bundle_get_str(paramList, MTPR_CONNECTION_PARAM_SRT_MODE, &string_val) != BUNDLE_ERROR_KEY_NOT_AVAILABLE)
-               setConnectionParam(std::string{MTPR_CONNECTION_PARAM_SRT_MODE}, string_val, connectionParam);
+               setConnectionParam(MTPR_CONNECTION_PARAM_SRT_MODE, string_val, connectionParam);
 
        if (bundle_get_str(paramList, MTPR_CONNECTION_PARAM_SRT_STREAMID, &string_val) != BUNDLE_ERROR_KEY_NOT_AVAILABLE)
                connectionParam->streamId = string_val;
 
        if (bundle_get_str(paramList, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, &string_val) != BUNDLE_ERROR_KEY_NOT_AVAILABLE)
-               connectionParam->passPhrase = string_val;
+               setConnectionParam(MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, string_val, connectionParam);
 
        if (bundle_get_str(paramList, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, &string_val) != BUNDLE_ERROR_KEY_NOT_AVAILABLE)
-               setConnectionParam(std::string{MTPR_CONNECTION_PARAM_SRT_PBKEYLEN}, string_val, connectionParam);
+               setConnectionParam(MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, string_val, connectionParam);
 }
 
 void param::srt::getConnectionParamList(const param::srt::connectionParam& connectionParam, bundle *paramList)

diff --git a/src/MediaTransporterSender.cpp b/src/MediaTransporterSender.cpp
index 0eda02a..83fa345 100644 (file)
--- a/src/MediaTransporterSender.cpp
+++ b/src/MediaTransporterSender.cpp
@@ -55,7 +55,6 @@ IMediaSourceBin* MediaTransporterSender::getMediaSource(int id)
 
 void MediaTransporterSender::linkMediaSourceToMuxer(GstElement* mux)
 {
-
        GstPad* sinkPad = NULL;
        try {
                /* link each element */

diff --git a/src/MediaTransporterSenderRist.cpp b/src/MediaTransporterSenderRist.cpp
index 403bcf4..84da981 100644 (file)
--- a/src/MediaTransporterSenderRist.cpp
+++ b/src/MediaTransporterSenderRist.cpp
@@ -35,11 +35,14 @@ void MediaTransporterSenderRist::buildPipeline()
        GstElement* sink = NULL;
        GstElement* pay = NULL;
 
+       if (_receiverAddress.empty())
+               throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "address is empty");
+
+       if (_mediaSources.empty())
+               throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "source is empty");
+
        /* create mux to sink */
        try {
-               if (_receiverAddress.empty())
-                       throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "address is empty");
-
                mux = gst::_createElement(gst::DEFAULT_ELEMENT_TSMUX);
                g_object_set(G_OBJECT(mux), "alignment", 7, NULL);
 

diff --git a/src/MediaTransporterSenderRtsp.cpp b/src/MediaTransporterSenderRtsp.cpp
index 5e0c4ec..6ec0a26 100644 (file)
--- a/src/MediaTransporterSenderRtsp.cpp
+++ b/src/MediaTransporterSenderRtsp.cpp
@@ -44,10 +44,13 @@ void MediaTransporterSenderRtsp::buildPipeline()
        GstElement* mux = NULL;
        GstElement* pay = NULL;
 
-       try {
-               if (_senderAddress.empty())
-                       throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "address is empty");
+       if (_senderAddress.empty())
+               throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "address is empty");
+
+       if (_mediaSources.empty())
+               throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "source is empty");
 
+       try {
                /* create mux and pay */
                mux = gst::_createElement(gst::DEFAULT_ELEMENT_TSMUX);
                g_object_set(G_OBJECT(mux), "alignment", 7, NULL);

diff --git a/src/MediaTransporterSenderSrt.cpp b/src/MediaTransporterSenderSrt.cpp
index ab00a14..6b058b1 100644 (file)
--- a/src/MediaTransporterSenderSrt.cpp
+++ b/src/MediaTransporterSenderSrt.cpp
@@ -59,11 +59,14 @@ void MediaTransporterSenderSrt::buildPipeline()
        GstElement* mux = NULL;
        GstElement* sink = NULL;
 
+       if (_senderAddress.empty())
+               throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "address is empty");
+
+       if (_mediaSources.empty())
+               throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "source is empty");
+
        /* create mux to sink */
        try {
-               if (_senderAddress.empty())
-                       throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "address is empty");
-
                mux = gst::_createElement(gst::DEFAULT_ELEMENT_TSMUX);
                g_object_set(G_OBJECT(mux), "alignment", 7, NULL);
 

diff --git a/src/MediaTransporterSenderToServerRtsp.cpp b/src/MediaTransporterSenderToServerRtsp.cpp
index ff6b1da..7cf6e15 100644 (file)
--- a/src/MediaTransporterSenderToServerRtsp.cpp
+++ b/src/MediaTransporterSenderToServerRtsp.cpp
@@ -29,11 +29,14 @@ void MediaTransporterSenderToServerRtsp::buildPipeline()
        GstElement *mux = NULL;
        GstElement *sink = NULL;
 
-       /* create mux to sink */
-       try {
-               if (_receiverAddress.empty())
-                       throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "address is empty");
+       if (_receiverAddress.empty())
+               throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "address is empty");
+
+       if (_mediaSources.empty())
+               throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "source is empty");
 
+       try {
+               /* create mux to sink */
                mux = gst::_createElement(gst::DEFAULT_ELEMENT_TSMUX);
                g_object_set(G_OBJECT(mux), "alignment", 7, NULL);
 

diff --git a/unittest/testbase.hpp b/unittest/ut_base.hpp
similarity index 61%
rename from unittest/testbase.hpp
rename to unittest/ut_base.hpp
index 5e18925..e955570 100644 (file)
--- a/unittest/testbase.hpp
+++ b/unittest/ut_base.hpp
@@ -31,21 +31,12 @@
 
 class MediaTransporterTestBase : public ::testing::Test {
 public:
-    MediaTransporterTestBase() : _mtpr(nullptr) {}
+       MediaTransporterTestBase() = default;
+       ~MediaTransporterTestBase() = default;
 
-    void SetUp() override {}
-    void TearDown() override {}
-
-    mtpr_h GetHandle() { return _mtpr; }
-    const std::string& GetSRTSenderPath() { return _srtSenderPath; }
-    const std::string& GetSRTReceiverPath() { return _srtReceiverPath; }
-    const std::string& GetRTSPSenderPath() { return _rtspSenderPath; }
+       void SetUp() override {}
+       void TearDown() override {}
 
 protected:
-    mtpr_h _mtpr;
-
-private:
-    const std::string _srtSenderPath   = "srt://:8888";
-    const std::string _srtReceiverPath = "srt://127.0.0.1:8888";
-    const std::string _rtspSenderPath  = "rtsp://127.0.0.1:8554/test";
+       mtpr_h _mtpr { nullptr };
 };

diff --git a/unittest/ut_main.cpp b/unittest/ut_main.cpp
index d84a5b4..8695359 100644 (file)
--- a/unittest/ut_main.cpp
+++ b/unittest/ut_main.cpp
@@ -18,11 +18,11 @@
 
 int main(int argc, char *argv[])
 {
-    try {
-        ::testing::InitGoogleTest(&argc, argv);
-        return RUN_ALL_TESTS();
-    } catch (const std::exception &e) {
-        std::cout << "caught exception: " << e.what() << std::endl;
-        return -1;
-    }
+       try {
+               ::testing::InitGoogleTest(&argc, argv);
+               return RUN_ALL_TESTS();
+       } catch (const std::exception &e) {
+               std::cout << "caught exception: " << e.what() << std::endl;
+               return -1;
+       }
 }

diff --git a/unittest/ut_srt_sender.cpp b/unittest/ut_srt_sender.cpp
index 504680c..7f01fad 100644 (file)
--- a/unittest/ut_srt_sender.cpp
+++ b/unittest/ut_srt_sender.cpp
@@ -14,86 +14,550 @@
  * limitations under the License.
  */
 
-#include "testbase.hpp"
+#include "ut_base.hpp"
 
 class MediaTransporterSrtSenderTest : public MediaTransporterTestBase {
 public:
-    MediaTransporterSrtSenderTest() {}
+       MediaTransporterSrtSenderTest() = default;
+       ~MediaTransporterSrtSenderTest() = default;
 
-    void SetUp() override {
-        LOGD("Enter");
+       void SetUp() override {
+               LOGD("Enter");
 
-        int ret = MTPR_ERROR_NONE;
-        ret = mtpr_create(MTPR_CONNECTION_TYPE_SRT_SENDER, &_mtpr);
-        ASSERT_EQ(ret, MTPR_ERROR_NONE);
+               int ret = MTPR_ERROR_NONE;
+               ret = mtpr_create(MTPR_CONNECTION_TYPE_SRT_SENDER, &_mtpr);
+               ASSERT_EQ(ret, MTPR_ERROR_NONE);
 
-        LOGD("Leave");
-    }
+               LOGD("Leave");
+       }
 
-    void TearDown() override {
-        LOGD("Enter");
+       void TearDown() override {
+               int ret = MTPR_ERROR_NONE;
+               mtpr_state_e state = MTPR_STATE_IDLE;
+               LOGD("Enter");
 
-        if (_mtpr) {
-            int ret = mtpr_destroy(_mtpr);
-            ASSERT_EQ(ret, MTPR_ERROR_NONE);
-        }
+               if (_mtpr) {
+                       ret = mtpr_get_state(_mtpr, &state);
+                       ASSERT_EQ(ret, MTPR_ERROR_NONE);
 
-        LOGD("Leave");
-    }
+                       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 _srtSenderPath = "srt://:8888";
 };
 
-TEST_F(MediaTransporterSrtSenderTest, set_address)
+TEST_F(MediaTransporterSrtSenderTest, set_address_p)
+{
+       int ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, set_address_n1)
+{
+       int ret = MTPR_ERROR_NONE;
+
+       ret = mtpr_set_sender_address(NULL, _srtSenderPath.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(MediaTransporterSrtSenderTest, set_address_n2)
+{
+       int ret = mtpr_set_receiver_address(_mtpr, _srtSenderPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, get_address_p)
 {
-    int ret = MTPR_ERROR_NONE;
+       int ret = MTPR_ERROR_NONE;
        char *address = NULL;
 
-    ret = mtpr_set_receiver_address(GetHandle(), GetSRTSenderPath().c_str());
-    ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+       ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
 
-    ret = mtpr_set_sender_address(GetHandle(), GetSRTSenderPath().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);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, get_address_n1)
+{
+       int ret = MTPR_ERROR_NONE;
+       char *address = NULL;
+
+       ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.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(GetHandle(), &address);
-    ASSERT_EQ(ret, MTPR_ERROR_NONE);
-    ASSERT_TRUE(address);
+       ret = mtpr_get_sender_address(_mtpr, NULL);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 
-    LOGD("sender address : %s", address);
+       ret = mtpr_get_sender_address(NULL, NULL);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, get_address_n2)
+{
+       char *address = NULL;
 
-    ASSERT_STREQ(GetSRTSenderPath().c_str(), address);
+       int ret = mtpr_get_sender_address(_mtpr, &address);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
 }
 
-TEST_F(MediaTransporterSrtSenderTest, get_connection_type)
+TEST_F(MediaTransporterSrtSenderTest, get_address_n3)
 {
+       int ret = MTPR_ERROR_NONE;
+       char *address = NULL;
+
+       ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_get_receiver_address(_mtpr, &address);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, 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_SENDER);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, get_connection_type_n1)
+{
+       int ret = MTPR_ERROR_NONE;
        mtpr_connection_type_e type;
 
-    int ret = mtpr_get_connection_type(GetHandle(), &type);
-    ASSERT_EQ(ret, MTPR_ERROR_NONE);
-    ASSERT_EQ(type, MTPR_CONNECTION_TYPE_SRT_SENDER);
+       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(MediaTransporterSrtSenderTest, add_media_source_p)
+{
+       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_add_media_source(_mtpr, MTPR_SOURCE_TYPE_AUDIOTEST, NULL, &source_id);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       ASSERT_GE(source_id, 0);
 }
 
-TEST_F(MediaTransporterSrtSenderTest, add_media_source)
+TEST_F(MediaTransporterSrtSenderTest, add_media_source_n1)
 {
-    int ret = MTPR_ERROR_NONE;
+       int ret = MTPR_ERROR_NONE;
        unsigned int source_id = 0;
 
-    ret = mtpr_add_media_source(GetHandle(), MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
-    ASSERT_EQ(ret, MTPR_ERROR_NONE);
-    ASSERT_TRUE(source_id >= 0);
+       ret = mtpr_add_media_source(NULL, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 
-    ret = mtpr_add_media_source(GetHandle(), MTPR_SOURCE_TYPE_AUDIOTEST, NULL, &source_id);
-    ASSERT_EQ(ret, MTPR_ERROR_NONE);
-    ASSERT_TRUE(source_id >= 0);
+       ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_AUDIOTEST, NULL, NULL);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(MediaTransporterSrtSenderTest, remove_media_source)
+TEST_F(MediaTransporterSrtSenderTest, start_p)
 {
-    int ret = MTPR_ERROR_NONE;
+       int ret = MTPR_ERROR_NONE;
        unsigned int source_id = 0;
 
-    ret = mtpr_add_media_source(GetHandle(), MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
-    ASSERT_EQ(ret, MTPR_ERROR_NONE);
-    ASSERT_TRUE(source_id >= 0);
+       ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.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(MediaTransporterSrtSenderTest, start_n1)
+{
+       int ret = MTPR_ERROR_NONE;
+       unsigned int source_id = 0;
+
+       ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.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(MediaTransporterSrtSenderTest, 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(MediaTransporterSrtSenderTest, start_n3)
+{
+       int ret = MTPR_ERROR_NONE;
+
+       ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_start(_mtpr);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, stop_p)
+{
+       int ret = MTPR_ERROR_NONE;
+       unsigned int source_id = 0;
+
+       ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.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(MediaTransporterSrtSenderTest, stop_n1)
+{
+       int ret = MTPR_ERROR_NONE;
+       unsigned int source_id = 0;
+
+       ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.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(MediaTransporterSrtSenderTest, stop_n2)
+{
+       int ret = mtpr_stop(_mtpr);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_STATE);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, 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(MediaTransporterSrtSenderTest, 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, _srtSenderPath.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(MediaTransporterSrtSenderTest, 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, _srtSenderPath.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(MediaTransporterSrtSenderTest, 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(MediaTransporterSrtSenderTest, 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(MediaTransporterSrtSenderTest, 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(MediaTransporterSrtSenderTest, 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(MediaTransporterSrtSenderTest, set_connection_param_streamid_p)
+{
+       int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_STREAMID, "testid");
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, set_connection_param_passphrase_p)
+{
+       int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, "testpassphrase");
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, 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(MediaTransporterSrtSenderTest, 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(MediaTransporterSrtSenderTest, 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(MediaTransporterSrtSenderTest, 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(MediaTransporterSrtSenderTest, 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(MediaTransporterSrtSenderTest, set_connection_param_n)
+{
+       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);
+
+       ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, NULL);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, set_connection_params_p1)
+{
+       int ret = MTPR_ERROR_NONE;
+       bundle* params = bundle_create();
+
+       bundle_add_str(params, MTPR_CONNECTION_PARAM_SRT_MODE, "2");
+       bundle_add_str(params, MTPR_CONNECTION_PARAM_SRT_STREAMID, "testid");
+       bundle_add_str(params, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, "testpassphrase");
+       bundle_add_str(params, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, "24");
+
+       ret = mtpr_set_connection_params(_mtpr, params);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       bundle_free(params);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, set_connection_params_p2)
+{
+       int ret = MTPR_ERROR_NONE;
+       bundle* params = bundle_create();
+
+       bundle_add_str(params, MTPR_CONNECTION_PARAM_SRT_MODE, "2");
+       ret = mtpr_set_connection_params(_mtpr, params);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       bundle_add_str(params, MTPR_CONNECTION_PARAM_SRT_STREAMID, "testid");
+       ret = mtpr_set_connection_params(_mtpr, params);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       bundle_add_str(params, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, "testpassphrase");
+       ret = mtpr_set_connection_params(_mtpr, params);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       bundle_add_str(params, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, "24");
+       ret = mtpr_set_connection_params(_mtpr, params);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       bundle_free(params);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, set_connection_params_n1)
+{
+       int ret = MTPR_ERROR_NONE;
+       bundle* params = bundle_create();
+
+       bundle_add_str(params, MTPR_CONNECTION_PARAM_SRT_MODE, "7");
+
+       ret = mtpr_set_connection_params(_mtpr, params);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+       bundle_free(params);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, set_connection_params_n2)
+{
+       int ret = MTPR_ERROR_NONE;
+       bundle* params = bundle_create();
+
+       bundle_add_str(params, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, "testwd");
+
+       ret = mtpr_set_connection_params(_mtpr, params);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+       bundle_free(params);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, set_connection_params_n3)
+{
+       int ret = MTPR_ERROR_NONE;
+       bundle* params = bundle_create();
+
+       bundle_add_str(params, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, "30");
+
+       ret = mtpr_set_connection_params(_mtpr, params);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+       bundle_free(params);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, get_connection_params_p)
+{
+       int ret = MTPR_ERROR_NONE;
+       bundle* in = bundle_create();
+       bundle* out = bundle_create();
+       char* out_val = NULL;
+
+       bundle_add_str(in, MTPR_CONNECTION_PARAM_SRT_MODE, "2");
+       bundle_add_str(in, MTPR_CONNECTION_PARAM_SRT_STREAMID, "testid");
+       bundle_add_str(in, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, "testpassphrase");
+       bundle_add_str(in, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, "24");
+       int len = bundle_get_count(in);
+       ret = mtpr_set_connection_params(_mtpr, in);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_get_connection_params(_mtpr, &out);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       ASSERT_EQ(len, bundle_get_count(out));
+
+       int bundle_ret = BUNDLE_ERROR_NONE;
+       bundle_ret = bundle_get_str(out, MTPR_CONNECTION_PARAM_SRT_MODE, &out_val);
+       ASSERT_EQ(bundle_ret, BUNDLE_ERROR_NONE);
+       ASSERT_STREQ(out_val, "2");
+
+       bundle_ret = bundle_get_str(out, MTPR_CONNECTION_PARAM_SRT_STREAMID, &out_val);
+       ASSERT_EQ(bundle_ret, BUNDLE_ERROR_NONE);
+       ASSERT_STREQ(out_val, "testid");
+
+       bundle_ret = bundle_get_str(out, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, &out_val);
+       ASSERT_EQ(bundle_ret, BUNDLE_ERROR_NONE);
+       ASSERT_STREQ(out_val, "testpassphrase");
+
+       bundle_ret = bundle_get_str(out, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, &out_val);
+       ASSERT_EQ(bundle_ret, BUNDLE_ERROR_NONE);
+       ASSERT_STREQ(out_val, "24");
+
+       bundle_free(in);
+       bundle_free(out);
+}
+
+TEST_F(MediaTransporterSrtSenderTest, get_connection_params_n)
+{
+       int ret = MTPR_ERROR_NONE;
+       bundle* out = bundle_create();
+
+       ret = mtpr_get_connection_params(NULL, &out);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+       ret = mtpr_get_connection_params(_mtpr, NULL);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+       ret = mtpr_get_connection_params(NULL, NULL);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 
-    ret = mtpr_remove_media_source(GetHandle(), source_id);
-    ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       bundle_free(out);
 }