Skip to content

Commit

Permalink
[tests] Added tests for SRTO_PACINGMODE
Browse files Browse the repository at this point in the history
  • Loading branch information
@maxsharabayko
maxsharabayko committed Sep 14, 2020
1 parent 63f8858 commit 1ea8908
Showing 1 changed file with 293 additions and 24 deletions.
317 changes: 293 additions & 24 deletions test/test_socket_options.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -33,13 +33,48 @@ class TestSocketOptions
// cleanup any pending stuff, but no exceptions allowed
}

public:
void StartListener()
{
// Specify address of the listener
sockaddr* psa = (sockaddr*)&m_sa;
ASSERT_NE(srt_bind(m_listen_sock, psa, sizeof m_sa), SRT_ERROR);

srt_listen(m_listen_sock, 1);
}

SRTSOCKET EstablishConnection()
{
auto accept_async = [](SRTSOCKET listen_sock) {
sockaddr_in client_address;
int length = sizeof(sockaddr_in);
const SRTSOCKET accepted_socket = srt_accept(listen_sock, (sockaddr*)&client_address, &length);
return accepted_socket;
};
auto accept_res = async(launch::async, accept_async, m_listen_sock);

sockaddr* psa = (sockaddr*)&m_sa;
const int connect_res = srt_connect(m_caller_sock, psa, sizeof m_sa);
EXPECT_EQ(connect_res, SRT_SUCCESS);

const SRTSOCKET accepted_sock = accept_res.get();
EXPECT_NE(accepted_sock, SRT_INVALID_SOCK);

return accepted_sock;
}

protected:
// SetUp() is run immediately before a test starts.
void SetUp()
{
ASSERT_GE(srt_startup(), 0);
const int yes = 1;

memset(&m_sa, 0, sizeof m_sa);
m_sa.sin_family = AF_INET;
m_sa.sin_port = htons(5200);
ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &m_sa.sin_addr), 1);

m_caller_sock = srt_create_socket();
ASSERT_NE(m_caller_sock, SRT_INVALID_SOCK);
ASSERT_EQ(srt_setsockopt(m_caller_sock, 0, SRTO_RCVSYN, &yes, sizeof yes), SRT_SUCCESS); // for async connect
Expand All @@ -63,6 +98,7 @@ class TestSocketOptions
protected:
// put in any custom data members that you need

sockaddr_in m_sa;
SRTSOCKET m_caller_sock = SRT_INVALID_SOCK;
SRTSOCKET m_listen_sock = SRT_INVALID_SOCK;

Expand All @@ -78,30 +114,8 @@ TEST_F(TestSocketOptions, LossMaxTTL)
const int loss_max_ttl = 5;
ASSERT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_LOSSMAXTTL, &loss_max_ttl, sizeof loss_max_ttl), SRT_SUCCESS);

// Specify address
sockaddr_in sa;
memset(&sa, 0, sizeof sa);
sa.sin_family = AF_INET;
sa.sin_port = htons(5200);
ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
sockaddr* psa = (sockaddr*)&sa;
ASSERT_NE(srt_bind(m_listen_sock, psa, sizeof sa), SRT_ERROR);

srt_listen(m_listen_sock, 1);

auto accept_async = [](SRTSOCKET listen_sock) {
sockaddr_in client_address;
int length = sizeof(sockaddr_in);
const SRTSOCKET accepted_socket = srt_accept(listen_sock, (sockaddr*)&client_address, &length);
return accepted_socket;
};
auto accept_res = async(launch::async, accept_async, m_listen_sock);

const int connect_res = srt_connect(m_caller_sock, psa, sizeof sa);
EXPECT_EQ(connect_res, SRT_SUCCESS);

const SRTSOCKET accepted_sock = accept_res.get();
ASSERT_NE(accepted_sock, SRT_INVALID_SOCK);
StartListener();
const SRTSOCKET accepted_sock = EstablishConnection();

int opt_val = 0;
int opt_len = 0;
Expand All @@ -120,4 +134,259 @@ TEST_F(TestSocketOptions, LossMaxTTL)
ASSERT_NE(srt_close(accepted_sock), SRT_ERROR);
}

// Try to set/get SRTO_PACINGMODE with wrong optlen
TEST_F(TestSocketOptions, PacingModeGetSetWrongLen)
{
SRT_PACING_CONFIG cfg;
int optlen = (int) (sizeof cfg) - 1;
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_ERROR);

cfg.mode = SRT_PACING_DEFMAXBW;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg - 1), SRT_ERROR);
}

// Check the default SRTO_PACINGMODE is SRT_PACING_DEFMAXBW
TEST_F(TestSocketOptions, PacingModeDefault)
{
SRT_PACING_CONFIG cfg;
int optlen = (int) (sizeof cfg);
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(optlen, (int) (sizeof cfg));
EXPECT_EQ(cfg.mode, SRT_PACING_DEFMAXBW);
EXPECT_EQ(cfg.bw, 1000000000/8);
EXPECT_EQ(cfg.bw_overhead, -1);
}

// Check with SRT_PACING_UNSET the actual mode is automatically detected
TEST_F(TestSocketOptions, PacingModeUnset)
{
SRT_PACING_CONFIG cfg;
int optlen = (int) (sizeof cfg);
cfg.mode = SRT_PACING_UNSET;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_SUCCESS);

EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_DEFMAXBW);
EXPECT_EQ(cfg.bw, 1000000000/8);
EXPECT_EQ(cfg.bw_overhead, -1);

int64_t optval = 0;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_MAXBW, &optval, sizeof optval), SRT_SUCCESS);

EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_ESTINPUTBW);
EXPECT_EQ(cfg.bw_overhead, 25);

optval = 1000;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_INPUTBW, &optval, sizeof optval), SRT_SUCCESS);
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_INPUTBW);
EXPECT_EQ(cfg.bw, optval);
EXPECT_EQ(cfg.bw_overhead, 25);
}

// Check that setting SRT_PACING_DEFMAXBW results in proper mode
TEST_F(TestSocketOptions, PacingModeDEFMAXBW)
{
SRT_PACING_CONFIG cfg;
int optlen = (int) (sizeof cfg);

cfg.mode = SRT_PACING_DEFMAXBW;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_SUCCESS);

EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_DEFMAXBW);
EXPECT_EQ(cfg.bw, 1000000000/8);
EXPECT_EQ(cfg.bw_overhead, -1);
}

// Check that setting and getting SRT_PACING_MAXBW
TEST_F(TestSocketOptions, PacingModeMAXBW)
{
const int64_t bw = 50000000;
SRT_PACING_CONFIG cfg;
int optlen = (int) (sizeof cfg);

cfg.mode = SRT_PACING_MAXBW;
cfg.bw = 0;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_ERROR) << "BW has to be a positive number";
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_DEFMAXBW);
EXPECT_EQ(cfg.bw, 1000000000/8);
EXPECT_EQ(cfg.bw_overhead, -1);

cfg.mode = SRT_PACING_MAXBW;
cfg.bw = -1;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_ERROR) << "BW has to be a positive number";
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_DEFMAXBW);
EXPECT_EQ(cfg.bw, 1000000000/8);
EXPECT_EQ(cfg.bw_overhead, -1);

cfg.mode = SRT_PACING_MAXBW;
cfg.bw = bw;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_SUCCESS);
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_MAXBW);
EXPECT_EQ(cfg.bw, bw);
EXPECT_EQ(cfg.bw_overhead, -1);
}

// Check that setting SRT_PACING_INPUTBW results in proper mode
TEST_F(TestSocketOptions, PacingModeINPUTBW)
{
const int64_t bw = 50000000;
SRT_PACING_CONFIG cfg;
int optlen = (int) (sizeof cfg);

cfg.mode = SRT_PACING_INPUTBW;
cfg.bw = 0;
cfg.bw_overhead = 25;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_ERROR) << "BW has to be a positive number";
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode,SRT_PACING_DEFMAXBW);
EXPECT_EQ(cfg.bw, 1000000000/8);
EXPECT_EQ(cfg.bw_overhead, -1);

cfg.mode = SRT_PACING_INPUTBW;
cfg.bw = -1;
cfg.bw_overhead = 25;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_ERROR) << "BW has to be a positive number";
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_DEFMAXBW);
EXPECT_EQ(cfg.bw, 1000000000/8);
EXPECT_EQ(cfg.bw_overhead, -1);

cfg.mode = SRT_PACING_INPUTBW;
cfg.bw = bw;
cfg.bw_overhead = 25;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_SUCCESS);
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_INPUTBW);
EXPECT_EQ(cfg.bw, bw);
EXPECT_EQ(cfg.bw_overhead, 25);
}

// Check that setting SRT_PACING_ESTINPUTBW results in proper mode
TEST_F(TestSocketOptions, PacingModeESTINPUTBW)
{
const int64_t bw = 50000000;
SRT_PACING_CONFIG cfg;
int optlen = (int) (sizeof cfg);

cfg.mode = SRT_PACING_ESTINPUTBW;
cfg.bw = -1;
cfg.bw_overhead = 0;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_ERROR) << "BW overhead has to be a positive number";
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_DEFMAXBW);
EXPECT_EQ(cfg.bw, 1000000000/8);
EXPECT_EQ(cfg.bw_overhead, -1);

cfg.mode = SRT_PACING_ESTINPUTBW;
cfg.bw = -1;
cfg.bw_overhead = 25;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_SUCCESS) << "negative BW has to be ignored";
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_ESTINPUTBW);
EXPECT_EQ(cfg.bw, 0);
EXPECT_EQ(cfg.bw_overhead, 25);

cfg.mode = SRT_PACING_ESTINPUTBW;
cfg.bw = bw;
cfg.bw_overhead = 25;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_SUCCESS);
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_ESTINPUTBW);
EXPECT_EQ(cfg.bw, 0);
EXPECT_EQ(cfg.bw_overhead, 25);
}

// Check that setting SRT_PACING_HYBRIDBW results in proper mode
TEST_F(TestSocketOptions, PacingModeHYBRIDBW)
{
const int64_t bw = 50000000;
SRT_PACING_CONFIG cfg;
int optlen = (int) (sizeof cfg);

cfg.mode = SRT_PACING_HYBRIDBW;
cfg.bw = 0;
cfg.bw_overhead = 25;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_ERROR) << "BW has to be a positive number";
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_DEFMAXBW);
EXPECT_EQ(cfg.bw, 1000000000/8);
EXPECT_EQ(cfg.bw_overhead, -1);

cfg.mode = SRT_PACING_HYBRIDBW;
cfg.bw = -1;
cfg.bw_overhead = 25;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_ERROR) << "BW has to be a positive number";
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_DEFMAXBW);
EXPECT_EQ(cfg.bw, 1000000000/8);
EXPECT_EQ(cfg.bw_overhead, -1);

cfg.mode = SRT_PACING_HYBRIDBW;
cfg.bw = bw;
cfg.bw_overhead = 25;
EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_SUCCESS);
EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
EXPECT_EQ(cfg.mode, SRT_PACING_HYBRIDBW);
EXPECT_EQ(cfg.bw, bw);
EXPECT_EQ(cfg.bw_overhead, 25);
}


// TEST_F(TestSocketOptions, PacingModeInputBW)
// {
// // SRT_PACING_UNSET, // API/ABI backward compatible mode, depending on SRTO_MAXBW, SRTO_INPUTBW and SRTO_OHEADBW
// // SRT_PACING_DEFMAXBW, // Default Max BW mode (SRTO_MAXBW, -1)
// // SRT_PACING_MAXBW, // Maximum BW is set (SRTO_MAXBW > 0)
// // SRT_PACING_INPUTBW, // Input rate and overhead are provided: MAXBW = INPUTBW * (1 + OHEADBW /100)
// // SRT_PACING_ESTINPUTBW, // Internally sampled input rate and configured overhead: MAXBW = ESTINPUTBW * (1 + OHEADBW /100)
// // SRT_PACING_HYBRIDBW // Use internally sampled and configured input rates and overhead: MAX_BW = max(INPUTBW, ESTINPUT_BW) * (1 + OHEADBW /100)
// // SRT_PACING_CONFIG cfg;

// int opt_len = (int) (sizeof cfg) - 1;
// EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_ERROR);
// opt_len = (int) (sizeof cfg);
// EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
// EXPECT_EQ(cfg.mode, SRT_PACING_DEFMAXBW);
// EXPECT_EQ(cfg.bw, 1000000000/8);
// EXPECT_EQ(cfg.bw_overhead, -1);

// cfg.mode = SRT_PACING_UNSET;
// EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, sizeof cfg), SRT_SUCCESS);

// EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), SRT_SUCCESS);
// EXPECT_EQ(cfg.mode, SRT_PACING_DEFMAXBW);
// EXPECT_EQ(cfg.bw, 1000000000/8);
// EXPECT_EQ(cfg.bw_overhead, -1);




// EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &cfg, &optlen), 0);


// SRT_PACINGMODE pacing_mode = SRT_PACING_INPUTBW;

// ASSERT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &pacing_mode, sizeof pacing_mode), SRT_ERROR);
// ASSERT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &pacing_mode, sizeof pacing_mode), SRT_SUCCESS);

// StartListener();
// const SRTSOCKET accepted_sock = EstablishConnection();

// int opt_val = 0;
// int opt_len = 0;
// ASSERT_EQ(srt_getsockopt(accepted_sock, 0, SRTO_PACINGMODE, &opt_val, &opt_len), SRT_SUCCESS);
// EXPECT_EQ(opt_val, pacing_mode) << "Wrong SRTO_PACINGMODE value on the accepted socket";
// EXPECT_EQ(opt_len, sizeof pacing_mode) << "Wrong SRTO_PACINGMODE value length on the accepted socket";

// ASSERT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PACINGMODE, &opt_val, &opt_len), SRT_SUCCESS);
// EXPECT_EQ(opt_val, pacing_mode) << "Wrong SRTO_PACINGMODE value on the listening socket";
// EXPECT_EQ(opt_len, sizeof pacing_mode) << "Wrong SRTO_PACINGMODE value length on the listening socket";

// ASSERT_NE(srt_close(accepted_sock), SRT_ERROR);
// }

0 comments on commit 1ea8908

Please sign in to comment.