Skip to content

Commit 7acef83

Browse files
Sujay Patelfacebook-github-bot
Sujay Patel
authored and
facebook-github-bot
committed
Implemented Conversion Functions for MoQTestParamaters and TrackNamespace
Summary: Implemented the conversion functions convertTrackNamespaceToMoqTestParam and convertMoqTestParamToTrackNamespace along with their tests. Reviewed By: sharmafb Differential Revision: D75258781 fbshipit-source-id: 546a4d4056d21edbd8bd2f8500196a4df6f1097f
1 parent 407230c commit 7acef83

File tree

3 files changed

+235
-20
lines changed

3 files changed

+235
-20
lines changed

‎moxygen/moqtest/Utils.cpp

Lines changed: 85 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,9 @@
44

55
namespace moxygen {
66

7+
const int kNumParams = 16;
8+
const std::string kField0 = "moq-test-00";
9+
710
folly::Expected<folly::Unit, std::runtime_error> validateMoQTestParameters(
811
MoQTestParameters* track) {
912
// Check if Forwarding Preference is valid (0-3) (Tuple Field 1)
@@ -57,4 +60,86 @@ folly::Expected<folly::Unit, std::runtime_error> validateMoQTestParameters(
5760
return folly::Unit();
5861
}
5962

63+
folly::Expected<moxygen::TrackNamespace, std::runtime_error>
64+
convertMoqTestParamToTrackNamespace(MoQTestParameters* params) {
65+
if (!validateMoQTestParameters(params)) {
66+
return folly::makeUnexpected(
67+
std::runtime_error("MoQTestParameters are invalid"));
68+
}
69+
70+
TrackNamespace trackNamespace({
71+
kField0,
72+
std::to_string(static_cast<int>(params->forwardingPreference)),
73+
std::to_string(params->startGroup),
74+
std::to_string(params->startObject),
75+
std::to_string(params->lastGroupInTrack),
76+
std::to_string(params->lastObjectInTrack),
77+
std::to_string(params->objectsPerGroup),
78+
std::to_string(params->sizeOfObjectZero),
79+
std::to_string(params->sizeOfObjectGreaterThanZero),
80+
std::to_string(params->objectFrequency),
81+
std::to_string(params->groupIncrement),
82+
std::to_string(params->objectIncrement),
83+
std::to_string(static_cast<int>(params->sendEndOfGroupMarkers)),
84+
std::to_string(static_cast<int>(params->testIntegerExtension)),
85+
std::to_string(static_cast<int>(params->testVariableExtension)),
86+
std::to_string(params->publisherDeliveryTimeout),
87+
});
88+
return trackNamespace;
89+
}
90+
91+
folly::Expected<moxygen::MoQTestParameters, std::runtime_error>
92+
convertTrackNamespaceToMoqTestParam(TrackNamespace* track) {
93+
// Check if TrackNamespace is of length 16
94+
if ((track->trackNamespace).size() != kNumParams) {
95+
return folly::makeUnexpected(
96+
std::runtime_error("TrackNamespace is not of length 16"));
97+
}
98+
// Check if TrackNamespace is correct protocol (Tuple Field 0)
99+
if ((track->trackNamespace)[0] != kField0) {
100+
return folly::makeUnexpected(
101+
std::runtime_error("Tuple element 0 is not moq-test-00"));
102+
}
103+
104+
// Create Empty MoQTestParameters
105+
MoQTestParameters params = MoQTestParameters();
106+
107+
// Assign values to appropriate positions in params
108+
try {
109+
params.forwardingPreference =
110+
ForwardingPreference(std::stoi((track->trackNamespace)[1]));
111+
params.startGroup = std::stoull((track->trackNamespace)[2]);
112+
params.startObject = std::stoull((track->trackNamespace)[3]);
113+
params.lastGroupInTrack = std::stoull((track->trackNamespace)[4]);
114+
params.lastObjectInTrack = std::stoull((track->trackNamespace)[5]);
115+
params.objectsPerGroup = std::stoull((track->trackNamespace)[6]);
116+
params.sizeOfObjectZero = std::stoull((track->trackNamespace)[7]);
117+
params.sizeOfObjectGreaterThanZero =
118+
std::stoull((track->trackNamespace)[8]);
119+
params.objectFrequency = std::stoull((track->trackNamespace)[9]);
120+
params.groupIncrement = std::stoull((track->trackNamespace)[10]);
121+
params.objectIncrement = std::stoull((track->trackNamespace)[11]);
122+
params.sendEndOfGroupMarkers =
123+
static_cast<bool>(std::stoi((track->trackNamespace)[12]));
124+
params.testIntegerExtension =
125+
static_cast<bool>(std::stoi((track->trackNamespace)[13]));
126+
params.testVariableExtension =
127+
static_cast<bool>(std::stoi((track->trackNamespace)[14]));
128+
params.publisherDeliveryTimeout = std::stoull((track->trackNamespace)[15]);
129+
} catch (const std::exception& e) {
130+
return folly::makeUnexpected(std::runtime_error(
131+
"Error Converting TrackNamespace String value to Digit: " +
132+
std::string(e.what())));
133+
}
134+
135+
// Check if the new params is Valid
136+
auto res = validateMoQTestParameters(&params);
137+
if (res.hasError()) {
138+
return folly::makeUnexpected(
139+
std::runtime_error("MoQTestParameters was created, but is invalid."));
140+
}
141+
142+
return params;
143+
}
144+
60145
} // namespace moxygen

‎moxygen/moqtest/Utils.h

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,11 +5,18 @@
55
*/
66

77
#include <folly/Expected.h>
8+
#include "moxygen/MoQFramer.h"
89
#include "moxygen/moqtest/Types.h"
910

1011
namespace moxygen {
1112

1213
folly::Expected<folly::Unit, std::runtime_error> validateMoQTestParameters(
1314
MoQTestParameters* track);
1415

16+
folly::Expected<moxygen::TrackNamespace, std::runtime_error>
17+
convertMoqTestParamToTrackNamespace(MoQTestParameters* params);
18+
19+
folly::Expected<moxygen::MoQTestParameters, std::runtime_error>
20+
convertTrackNamespaceToMoqTestParam(TrackNamespace* track);
21+
1522
} // namespace moxygen

‎moxygen/test/MoQTrackTest.cpp

Lines changed: 143 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -8,58 +8,181 @@ namespace {
88

99
class MoQTrackTest : public testing::Test {
1010
public:
11-
protected:
12-
MoQTrackTest() {}
11+
void CreatDefaultTrackNamespace() {
12+
track_.trackNamespace = {
13+
"moq-test-00",
14+
"0",
15+
"0",
16+
"0",
17+
"10",
18+
"1",
19+
"1",
20+
"1",
21+
"1",
22+
"1",
23+
"1",
24+
"1",
25+
"0",
26+
"0",
27+
"0",
28+
"0"};
29+
}
1330

14-
moxygen::MoQTestParameters track_;
31+
void CreateDefaultMoQTestParameters() {
32+
params_.forwardingPreference = moxygen::ForwardingPreference(0);
33+
params_.startGroup = 0;
34+
params_.startObject = 0;
35+
params_.lastGroupInTrack = 10;
36+
params_.lastObjectInTrack = 1;
37+
params_.objectsPerGroup = 1;
38+
params_.sizeOfObjectZero = 1;
39+
params_.sizeOfObjectGreaterThanZero = 1;
40+
params_.objectFrequency = 1;
41+
params_.groupIncrement = 1;
42+
params_.objectIncrement = 1;
43+
params_.sendEndOfGroupMarkers = false;
44+
params_.testIntegerExtension = false;
45+
params_.testVariableExtension = false;
46+
params_.publisherDeliveryTimeout = 0;
47+
}
48+
49+
moxygen::MoQTestParameters params_;
50+
moxygen::TrackNamespace track_;
1551
};
1652

1753
} // namespace
1854

55+
// MoQTestParameters Validation Function Tests
1956
TEST_F(MoQTrackTest, testValidateTrackNamespaceAsDefault) {
20-
EXPECT_NO_THROW(moxygen::validateMoQTestParameters(&track_));
57+
EXPECT_NO_THROW(moxygen::validateMoQTestParameters(&params_));
2158
}
2259

2360
TEST_F(MoQTrackTest, testInvalidForwardPreference) {
24-
track_.forwardingPreference = moxygen::ForwardingPreference(4);
25-
auto validateResult = moxygen::validateMoQTestParameters(&track_);
61+
params_.forwardingPreference = moxygen::ForwardingPreference(4);
62+
auto validateResult = moxygen::validateMoQTestParameters(&params_);
2663
EXPECT_TRUE(validateResult.hasError());
2764
}
2865

2966
TEST_F(MoQTrackTest, testStartGroupGreaterThanLastGroup) {
30-
track_.startGroup = 4;
31-
track_.lastGroupInTrack = 3;
32-
auto validateResult = moxygen::validateMoQTestParameters(&track_);
67+
params_.startGroup = 4;
68+
params_.lastGroupInTrack = 3;
69+
auto validateResult = moxygen::validateMoQTestParameters(&params_);
3370
EXPECT_TRUE(validateResult.hasError());
3471
}
3572

3673
TEST_F(MoQTrackTest, testStartObjectGreaterThanLastObject) {
37-
track_.startObject = 4;
38-
track_.lastObjectInTrack = 3;
39-
auto validateResult = moxygen::validateMoQTestParameters(&track_);
74+
params_.startObject = 4;
75+
params_.lastObjectInTrack = 3;
76+
auto validateResult = moxygen::validateMoQTestParameters(&params_);
4077
EXPECT_TRUE(validateResult.hasError());
4178
}
4279

4380
TEST_F(MoQTrackTest, testLastGroupGreaterThanAllowedMaximum) {
44-
track_.lastGroupInTrack = static_cast<uint64_t>(pow(2, 62));
45-
auto validateResult = moxygen::validateMoQTestParameters(&track_);
81+
params_.lastGroupInTrack = static_cast<uint64_t>(pow(2, 62));
82+
auto validateResult = moxygen::validateMoQTestParameters(&params_);
4683
EXPECT_TRUE(validateResult.hasError());
4784
}
4885

4986
TEST_F(MoQTrackTest, testLastObjectGreaterThanAllowedMaximum) {
50-
track_.lastObjectInTrack = 10000;
51-
auto validateResult = moxygen::validateMoQTestParameters(&track_);
87+
params_.lastObjectInTrack = 10000;
88+
auto validateResult = moxygen::validateMoQTestParameters(&params_);
5289
EXPECT_TRUE(validateResult.hasError());
5390
}
5491

5592
TEST_F(MoQTrackTest, testGroupIncrementAsZero) {
56-
track_.groupIncrement = 0;
57-
auto validateResult = moxygen::validateMoQTestParameters(&track_);
93+
params_.groupIncrement = 0;
94+
auto validateResult = moxygen::validateMoQTestParameters(&params_);
5895
EXPECT_TRUE(validateResult.hasError());
5996
}
6097

6198
TEST_F(MoQTrackTest, testObjectIncrementAsZero) {
62-
track_.objectIncrement = 0;
63-
auto validateResult = moxygen::validateMoQTestParameters(&track_);
99+
params_.objectIncrement = 0;
100+
auto validateResult = moxygen::validateMoQTestParameters(&params_);
64101
EXPECT_TRUE(validateResult.hasError());
65102
}
103+
104+
// Convert TrackNamespace to MoQTestParameters Tests
105+
TEST_F(MoQTrackTest, testConvertTrackNamespaceToMoQTestParameters) {
106+
CreatDefaultTrackNamespace();
107+
auto params = moxygen::convertTrackNamespaceToMoqTestParam(&track_);
108+
ASSERT_FALSE(params.hasError());
109+
EXPECT_EQ(
110+
params.value().forwardingPreference, moxygen::ForwardingPreference(0));
111+
EXPECT_EQ(params.value().startGroup, 0);
112+
EXPECT_EQ(params.value().startObject, 0);
113+
EXPECT_EQ(params.value().lastGroupInTrack, 10);
114+
EXPECT_EQ(params.value().lastObjectInTrack, 1);
115+
EXPECT_EQ(params.value().objectsPerGroup, 1);
116+
EXPECT_EQ(params.value().sizeOfObjectZero, 1);
117+
EXPECT_EQ(params.value().sizeOfObjectGreaterThanZero, 1);
118+
EXPECT_EQ(params.value().objectFrequency, 1);
119+
EXPECT_EQ(params.value().groupIncrement, 1);
120+
EXPECT_EQ(params.value().objectIncrement, 1);
121+
EXPECT_EQ(params.value().sendEndOfGroupMarkers, false);
122+
EXPECT_EQ(params.value().testIntegerExtension, false);
123+
EXPECT_EQ(params.value().testVariableExtension, false);
124+
EXPECT_EQ(params.value().publisherDeliveryTimeout, 0);
125+
}
126+
127+
TEST_F(
128+
MoQTrackTest,
129+
testConvertTrackNamespaceToMoQTestParametersWithInvalidProtocol) {
130+
CreatDefaultTrackNamespace();
131+
track_.trackNamespace[0] = "moq-test-01";
132+
auto params = moxygen::convertTrackNamespaceToMoqTestParam(&track_);
133+
EXPECT_TRUE(params.hasError());
134+
}
135+
136+
TEST_F(MoQTrackTest, testConversionGivenTrackNamespaceWithInvalidLength) {
137+
CreatDefaultTrackNamespace();
138+
track_.trackNamespace.resize(15);
139+
auto params = moxygen::convertTrackNamespaceToMoqTestParam(&track_);
140+
EXPECT_TRUE(params.hasError());
141+
}
142+
143+
TEST_F(MoQTrackTest, testConversionWithInvalidEndParams) {
144+
CreatDefaultTrackNamespace();
145+
track_.trackNamespace[1] = "4";
146+
auto params = moxygen::convertTrackNamespaceToMoqTestParam(&track_);
147+
EXPECT_TRUE(params.hasError());
148+
}
149+
150+
TEST_F(MoQTrackTest, testConversionWithTrackNamespaceHavingNonDigitValues) {
151+
CreatDefaultTrackNamespace();
152+
track_.trackNamespace[1] = "a";
153+
auto params = moxygen::convertTrackNamespaceToMoqTestParam(&track_);
154+
EXPECT_TRUE(params.hasError());
155+
}
156+
157+
// Test Conversion of MoQTestParameters to TrackNamespace
158+
TEST_F(MoQTrackTest, testConvertMoQTestParametersToTrackNamespace) {
159+
CreateDefaultMoQTestParameters();
160+
auto track = moxygen::convertMoqTestParamToTrackNamespace(&params_);
161+
ASSERT_FALSE(track.hasError());
162+
EXPECT_EQ(track.value().trackNamespace.size(), 16);
163+
EXPECT_EQ(track.value().trackNamespace[0], "moq-test-00");
164+
EXPECT_EQ(track.value().trackNamespace[1], "0");
165+
EXPECT_EQ(track.value().trackNamespace[2], "0");
166+
EXPECT_EQ(track.value().trackNamespace[3], "0");
167+
EXPECT_EQ(track.value().trackNamespace[4], "10");
168+
EXPECT_EQ(track.value().trackNamespace[5], "1");
169+
EXPECT_EQ(track.value().trackNamespace[6], "1");
170+
EXPECT_EQ(track.value().trackNamespace[7], "1");
171+
EXPECT_EQ(track.value().trackNamespace[8], "1");
172+
EXPECT_EQ(track.value().trackNamespace[9], "1");
173+
EXPECT_EQ(track.value().trackNamespace[10], "1");
174+
EXPECT_EQ(track.value().trackNamespace[11], "1");
175+
EXPECT_EQ(track.value().trackNamespace[12], "0");
176+
EXPECT_EQ(track.value().trackNamespace[13], "0");
177+
EXPECT_EQ(track.value().trackNamespace[14], "0");
178+
EXPECT_EQ(track.value().trackNamespace[15], "0");
179+
}
180+
181+
TEST_F(
182+
MoQTrackTest,
183+
testConvertMoQTestParametersToTrackNamespaceWithInvalidParams) {
184+
CreateDefaultMoQTestParameters();
185+
params_.lastObjectInTrack = 2;
186+
auto track = moxygen::convertMoqTestParamToTrackNamespace(&params_);
187+
EXPECT_TRUE(track.hasError());
188+
}

0 commit comments

Comments
 (0)