From b3f88055b507105a20d8e1ada8811bfcad76677f Mon Sep 17 00:00:00 2001 From: Eunhye Choi Date: Wed, 7 Sep 2022 20:26:43 +0900 Subject: [PATCH] [0.0.10][ut] add srt sender Change-Id: Ied5c843a3197f10f7fcf2e6c8aee35bb2720bb03 --- include/mtpr.h | 1 - packaging/capi-media-transporter.spec | 2 +- src/MediaTransporter.cpp | 19 + src/MediaTransporterParam.cpp | 12 +- src/MediaTransporterSender.cpp | 1 - src/MediaTransporterSenderRist.cpp | 9 +- src/MediaTransporterSenderRtsp.cpp | 9 +- src/MediaTransporterSenderSrt.cpp | 9 +- src/MediaTransporterSenderToServerRtsp.cpp | 11 +- unittest/{testbase.hpp => ut_base.hpp} | 19 +- unittest/ut_main.cpp | 14 +- unittest/ut_srt_sender.cpp | 558 ++++++++++++++++++++++++++--- 12 files changed, 576 insertions(+), 88 deletions(-) rename unittest/{testbase.hpp => ut_base.hpp} (61%) diff --git a/include/mtpr.h b/include/mtpr.h index 2239968..2906088 100644 --- 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 --- 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 --- 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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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); } -- 2.7.4