zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reformat the WebRTC code base

Browse Source 
Running clang-format with chromium's style guide.

The goal is n-fold:
 * providing consistency and readability (that's what code guidelines are for)
 * preventing noise with presubmit checks and git cl format
 * building on the previous point: making it easier to automatically fix format issues
 * you name it

Please consider using git-hyper-blame to ignore this commit.

Bug: webrtc:9340
Change-Id: I694567c4cdf8cee2860958cfe82bfaf25848bb87
Reviewed-on: https://webrtc-review.googlesource.com/81185
Reviewed-by: Patrik Höglund <phoglund@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23660}
This commit is contained in:
Yves Gerey
2018-06-19 15:03:05 +02:00
parent b602123a5a
commit 665174fdbb
1569 changed files with 30495 additions and 30309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
modules/rtp_rtcp/source/rtcp_packet/app.cc
View File

@ -64,9 +64,9 @@ void App::SetSubType(uint8_t subtype) {
void App::SetData(const uint8_t* data, size_t data_length) {
RTC_DCHECK(data);
RTC_DCHECK_EQ(data_length % 4, 0) << "Data must be 32 bits aligned.";
RTC_DCHECK_LE(data_length, kMaxDataSize) << "App data size " << data_length
<< " exceed maximum of "
<< kMaxDataSize << " bytes.";
RTC_DCHECK_LE(data_length, kMaxDataSize)
<< "App data size " << data_length << " exceed maximum of "
<< kMaxDataSize << " bytes.";
data_.SetData(data, data_length);
}

2
modules/rtp_rtcp/source/rtcp_packet/common_header.h
View File

@ -21,7 +21,7 @@ class CommonHeader {
CommonHeader() {}
CommonHeader(const CommonHeader&) = default;
CommonHeader& operator =(const CommonHeader&) = default;
CommonHeader& operator=(const CommonHeader&) = default;
bool Parse(const uint8_t* buffer, size_t size_bytes);

10
modules/rtp_rtcp/source/rtcp_packet/common_header_unittest.cc
View File

@ -42,9 +42,8 @@ TEST(RtcpCommonHeaderTest, Version) {
}
TEST(RtcpCommonHeaderTest, PacketSize) {
uint8_t buffer[] = {0x80, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00};
uint8_t buffer[] = {0x80, 0x00, 0x00, 0x02, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
CommonHeader header;
EXPECT_FALSE(header.Parse(buffer, sizeof(buffer) - 1));
EXPECT_TRUE(header.Parse(buffer, sizeof(buffer)));
@ -55,9 +54,8 @@ TEST(RtcpCommonHeaderTest, PacketSize) {
TEST(RtcpCommonHeaderTest, PaddingAndPayloadSize) {
// Set v = 2, p = 1, but leave fmt, pt as 0.
uint8_t buffer[] = {0xa0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00};
uint8_t buffer[] = {0xa0, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
CommonHeader header;
// Padding bit set, but no byte for padding (can't specify padding length).
EXPECT_FALSE(header.Parse(buffer, 4));

48
modules/rtp_rtcp/source/rtcp_packet/extended_reports_unittest.cc
View File

@ -39,16 +39,13 @@ bool operator==(const RTCPVoIPMetric& metric1, const RTCPVoIPMetric& metric2) {
metric1.endSystemDelay == metric2.endSystemDelay &&
metric1.signalLevel == metric2.signalLevel &&
metric1.noiseLevel == metric2.noiseLevel &&
metric1.RERL == metric2.RERL &&
metric1.Gmin == metric2.Gmin &&
metric1.RERL == metric2.RERL && metric1.Gmin == metric2.Gmin &&
metric1.Rfactor == metric2.Rfactor &&
metric1.extRfactor == metric2.extRfactor &&
metric1.MOSLQ == metric2.MOSLQ &&
metric1.MOSCQ == metric2.MOSCQ &&
metric1.MOSLQ == metric2.MOSLQ && metric1.MOSCQ == metric2.MOSCQ &&
metric1.RXconfig == metric2.RXconfig &&
metric1.JBnominal == metric2.JBnominal &&
metric1.JBmax == metric2.JBmax &&
metric1.JBabsMax == metric2.JBabsMax;
metric1.JBmax == metric2.JBmax && metric1.JBabsMax == metric2.JBabsMax;
}
namespace rtcp {
@ -57,8 +54,7 @@ bool operator==(const Rrtr& rrtr1, const Rrtr& rrtr2) {
}
bool operator==(const ReceiveTimeInfo& time1, const ReceiveTimeInfo& time2) {
return time1.ssrc == time2.ssrc &&
time1.last_rr == time2.last_rr &&
return time1.ssrc == time2.ssrc && time1.last_rr == time2.last_rr &&
time1.delay_since_last_rr == time2.delay_since_last_rr;
}
@ -113,26 +109,26 @@ Rrtr RtcpPacketExtendedReportsTest::Rand<Rrtr>() {
template <>
RTCPVoIPMetric RtcpPacketExtendedReportsTest::Rand<RTCPVoIPMetric>() {
RTCPVoIPMetric metric;
metric.lossRate = Rand<uint8_t>();
metric.discardRate = Rand<uint8_t>();
metric.burstDensity = Rand<uint8_t>();
metric.gapDensity = Rand<uint8_t>();
metric.burstDuration = Rand<uint16_t>();
metric.gapDuration = Rand<uint16_t>();
metric.lossRate = Rand<uint8_t>();
metric.discardRate = Rand<uint8_t>();
metric.burstDensity = Rand<uint8_t>();
metric.gapDensity = Rand<uint8_t>();
metric.burstDuration = Rand<uint16_t>();
metric.gapDuration = Rand<uint16_t>();
metric.roundTripDelay = Rand<uint16_t>();
metric.endSystemDelay = Rand<uint16_t>();
metric.signalLevel = Rand<uint8_t>();
metric.noiseLevel = Rand<uint8_t>();
metric.RERL = Rand<uint8_t>();
metric.Gmin = Rand<uint8_t>();
metric.Rfactor = Rand<uint8_t>();
metric.extRfactor = Rand<uint8_t>();
metric.MOSLQ = Rand<uint8_t>();
metric.MOSCQ = Rand<uint8_t>();
metric.RXconfig = Rand<uint8_t>();
metric.JBnominal = Rand<uint16_t>();
metric.JBmax = Rand<uint16_t>();
metric.JBabsMax = Rand<uint16_t>();
metric.signalLevel = Rand<uint8_t>();
metric.noiseLevel = Rand<uint8_t>();
metric.RERL = Rand<uint8_t>();
metric.Gmin = Rand<uint8_t>();
metric.Rfactor = Rand<uint8_t>();
metric.extRfactor = Rand<uint8_t>();
metric.MOSLQ = Rand<uint8_t>();
metric.MOSCQ = Rand<uint8_t>();
metric.RXconfig = Rand<uint8_t>();
metric.JBnominal = Rand<uint16_t>();
metric.JBmax = Rand<uint16_t>();
metric.JBabsMax = Rand<uint16_t>();
return metric;
}

22
modules/rtp_rtcp/source/rtcp_packet/fir_unittest.cc
View File

@ -29,11 +29,9 @@ constexpr uint32_t kSenderSsrc = 0x12345678;
constexpr uint32_t kRemoteSsrc = 0x23456789;
constexpr uint8_t kSeqNr = 13;
// Manually created Fir packet matching constants above.
constexpr uint8_t kPacket[] = {0x84, 206, 0x00, 0x04,
0x12, 0x34, 0x56, 0x78,
0x00, 0x00, 0x00, 0x00,
0x23, 0x45, 0x67, 0x89,
0x0d, 0x00, 0x00, 0x00};
constexpr uint8_t kPacket[] = {0x84, 206, 0x00, 0x04, 0x12, 0x34, 0x56,
0x78, 0x00, 0x00, 0x00, 0x00, 0x23, 0x45,
0x67, 0x89, 0x0d, 0x00, 0x00, 0x00};
} // namespace
TEST(RtcpPacketFirTest, Parse) {
@ -77,20 +75,16 @@ TEST(RtcpPacketFirTest, TwoFciEntries) {
}
TEST(RtcpPacketFirTest, ParseFailsOnZeroFciEntries) {
constexpr uint8_t kPacketWithoutFci[] = {0x84, 206, 0x00, 0x02,
0x12, 0x34, 0x56, 0x78,
0x00, 0x00, 0x00, 0x00};
constexpr uint8_t kPacketWithoutFci[] = {0x84, 206, 0x00, 0x02, 0x12, 0x34,
0x56, 0x78, 0x00, 0x00, 0x00, 0x00};
Fir parsed;
EXPECT_FALSE(test::ParseSinglePacket(kPacketWithoutFci, &parsed));
}
TEST(RtcpPacketFirTest, ParseFailsOnFractionalFciEntries) {
constexpr uint8_t kPacketWithOneAndHalfFci[] = {0x84, 206, 0x00, 0x05,
0x12, 0x34, 0x56, 0x78,
0x00, 0x00, 0x00, 0x00,
0x23, 0x45, 0x67, 0x89,
0x0d, 0x00, 0x00, 0x00,
'h', 'a', 'l', 'f'};
constexpr uint8_t kPacketWithOneAndHalfFci[] = {
0x84, 206, 0x00, 0x05, 0x12, 0x34, 0x56, 0x78, 0x00, 0x00, 0x00, 0x00,
0x23, 0x45, 0x67, 0x89, 0x0d, 0x00, 0x00, 0x00, 'h', 'a', 'l', 'f'};
Fir parsed;
EXPECT_FALSE(test::ParseSinglePacket(kPacketWithOneAndHalfFci, &parsed));

7
modules/rtp_rtcp/source/rtcp_packet/pli_unittest.cc
View File

@ -23,9 +23,8 @@ namespace {
const uint32_t kSenderSsrc = 0x12345678;
const uint32_t kRemoteSsrc = 0x23456789;
// Manually created Pli packet matching constants above.
const uint8_t kPacket[] = {0x81, 206, 0x00, 0x02,
0x12, 0x34, 0x56, 0x78,
0x23, 0x45, 0x67, 0x89};
const uint8_t kPacket[] = {0x81, 206, 0x00, 0x02, 0x12, 0x34,
0x56, 0x78, 0x23, 0x45, 0x67, 0x89};
} // namespace
TEST(RtcpPacketPliTest, Parse) {
@ -45,7 +44,7 @@ TEST(RtcpPacketPliTest, Create) {
rtc::Buffer packet = pli.Build();
EXPECT_THAT(make_tuple(packet.data(), packet.size()),
ElementsAreArray(kPacket));
ElementsAreArray(kPacket));
}
TEST(RtcpPacketPliTest, ParseFailsOnTooSmallPacket) {

10
modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request_unittest.cc
View File

@ -23,9 +23,8 @@ namespace {
const uint32_t kSenderSsrc = 0x12345678;
const uint32_t kRemoteSsrc = 0x23456789;
// Manually created packet matching constants above.
const uint8_t kPacket[] = {0x85, 205, 0x00, 0x02,
0x12, 0x34, 0x56, 0x78,
0x23, 0x45, 0x67, 0x89};
const uint8_t kPacket[] = {0x85, 205, 0x00, 0x02, 0x12, 0x34,
0x56, 0x78, 0x23, 0x45, 0x67, 0x89};
} // namespace
TEST(RtcpPacketRapidResyncRequestTest, Parse) {
@ -56,9 +55,8 @@ TEST(RtcpPacketRapidResyncRequestTest, ParseFailsOnTooSmallPacket) {
}
TEST(RtcpPacketRapidResyncRequestTest, ParseFailsOnTooLargePacket) {
const uint8_t kTooLargePacket[] = {0x85, 205, 0x00, 0x03,
0x12, 0x34, 0x56, 0x78,
0x32, 0x21, 0x65, 0x87,
const uint8_t kTooLargePacket[] = {0x85, 205, 0x00, 0x03, 0x12, 0x34,
0x56, 0x78, 0x32, 0x21, 0x65, 0x87,
0x23, 0x45, 0x67, 0x89};
RapidResyncRequest parsed;
EXPECT_FALSE(test::ParseSinglePacket(kTooLargePacket, &parsed));

5
modules/rtp_rtcp/source/rtcp_packet/rrtr_unittest.cc
View File

@ -19,9 +19,8 @@ namespace {
const uint32_t kNtpSec = 0x12345678;
const uint32_t kNtpFrac = 0x23456789;
const uint8_t kBlock[] = {0x04, 0x00, 0x00, 0x02,
0x12, 0x34, 0x56, 0x78,
0x23, 0x45, 0x67, 0x89};
const uint8_t kBlock[] = {0x04, 0x00, 0x00, 0x02, 0x12, 0x34,
0x56, 0x78, 0x23, 0x45, 0x67, 0x89};
const size_t kBlockSizeBytes = sizeof(kBlock);
static_assert(
kBlockSizeBytes == Rrtr::kLength,

66
modules/rtp_rtcp/source/rtcp_packet/sdes_unittest.cc
View File

@ -97,11 +97,10 @@ TEST(RtcpPacketSdesTest, CreateAndParseCnameItemWithEmptyString) {
TEST(RtcpPacketSdesTest, ParseSkipsNonCNameField) {
const uint8_t kName[] = "abc";
const uint8_t kCname[] = "de";
const uint8_t kValidPacket[] = {0x81, 202, 0x00, 0x04,
0x12, 0x34, 0x56, 0x78,
kNameTag, 3, kName[0], kName[1], kName[2],
kCnameTag, 2, kCname[0], kCname[1],
kTerminatorTag, kPadding, kPadding};
const uint8_t kValidPacket[] = {
0x81, 202, 0x00, 0x04, 0x12, 0x34, 0x56,
0x78, kNameTag, 3, kName[0], kName[1], kName[2], kCnameTag,
2, kCname[0], kCname[1], kTerminatorTag, kPadding, kPadding};
// Sanity checks packet was assembled correctly.
ASSERT_EQ(0u, sizeof(kValidPacket) % 4);
ASSERT_EQ(kValidPacket[3] + 1u, sizeof(kValidPacket) / 4);
@ -118,13 +117,14 @@ TEST(RtcpPacketSdesTest, ParseSkipsChunksWithoutCName) {
const uint8_t kName[] = "ab";
const uint8_t kEmail[] = "de";
const uint8_t kCname[] = "def";
const uint8_t kPacket[] = {0x82, 202, 0x00, 0x07,
0x12, 0x34, 0x56, 0x78, // 1st chunk.
kNameTag, 3, kName[0], kName[1], kName[2],
kEmailTag, 2, kEmail[0], kEmail[1],
kTerminatorTag, kPadding, kPadding,
0x23, 0x45, 0x67, 0x89, // 2nd chunk.
kCnameTag, 3, kCname[0], kCname[1], kCname[2],
const uint8_t kPacket[] = {
0x82, 202, 0x00, 0x07, 0x12,
0x34, 0x56, 0x78, // 1st chunk.
kNameTag, 3, kName[0], kName[1], kName[2],
kEmailTag, 2, kEmail[0], kEmail[1], kTerminatorTag,
kPadding, kPadding, 0x23, 0x45, 0x67,
0x89, // 2nd chunk.
kCnameTag, 3, kCname[0], kCname[1], kCname[2],
kTerminatorTag, kPadding, kPadding};
// Sanity checks packet was assembled correctly.
ASSERT_EQ(0u, sizeof(kPacket) % 4);
@ -141,10 +141,9 @@ TEST(RtcpPacketSdesTest, ParseFailsWithoutChunkItemTerminator) {
const uint8_t kName[] = "abc";
const uint8_t kCname[] = "d";
// No place for next chunk item.
const uint8_t kInvalidPacket[] = {0x81, 202, 0x00, 0x03,
0x12, 0x34, 0x56, 0x78,
kNameTag, 3, kName[0], kName[1], kName[2],
kCnameTag, 1, kCname[0]};
const uint8_t kInvalidPacket[] = {
0x81, 202, 0x00, 0x03, 0x12, 0x34, 0x56, 0x78,
kNameTag, 3, kName[0], kName[1], kName[2], kCnameTag, 1, kCname[0]};
// Sanity checks packet was assembled correctly.
ASSERT_EQ(0u, sizeof(kInvalidPacket) % 4);
ASSERT_EQ(kInvalidPacket[3] + 1u, sizeof(kInvalidPacket) / 4);
@ -157,11 +156,9 @@ TEST(RtcpPacketSdesTest, ParseFailsWithDamagedChunkItem) {
const uint8_t kName[] = "ab";
const uint8_t kCname[] = "d";
// Next chunk item has non-terminator type, but not the size.
const uint8_t kInvalidPacket[] = {0x81, 202, 0x00, 0x03,
0x12, 0x34, 0x56, 0x78,
kNameTag, 2, kName[0], kName[1],
kCnameTag, 1, kCname[0],
kEmailTag};
const uint8_t kInvalidPacket[] = {
0x81, 202, 0x00, 0x03, 0x12, 0x34, 0x56, 0x78,
kNameTag, 2, kName[0], kName[1], kCnameTag, 1, kCname[0], kEmailTag};
// Sanity checks packet was assembled correctly.
ASSERT_EQ(0u, sizeof(kInvalidPacket) % 4);
ASSERT_EQ(kInvalidPacket[3] + 1u, sizeof(kInvalidPacket) / 4);
@ -174,10 +171,9 @@ TEST(RtcpPacketSdesTest, ParseFailsWithTooLongChunkItem) {
const uint8_t kName[] = "abc";
const uint8_t kCname[] = "d";
// Last chunk item has length that goes beyond the buffer end.
const uint8_t kInvalidPacket[] = {0x81, 202, 0x00, 0x03,
0x12, 0x34, 0x56, 0x78,
kNameTag, 3, kName[0], kName[1], kName[2],
kCnameTag, 2, kCname[0]};
const uint8_t kInvalidPacket[] = {
0x81, 202, 0x00, 0x03, 0x12, 0x34, 0x56, 0x78,
kNameTag, 3, kName[0], kName[1], kName[2], kCnameTag, 2, kCname[0]};
// Sanity checks packet was assembled correctly.
ASSERT_EQ(0u, sizeof(kInvalidPacket) % 4);
ASSERT_EQ(kInvalidPacket[3] + 1u, sizeof(kInvalidPacket) / 4);
@ -189,11 +185,10 @@ TEST(RtcpPacketSdesTest, ParseFailsWithTooLongChunkItem) {
TEST(RtcpPacketSdesTest, ParseFailsWithTwoCNames) {
const uint8_t kCname1[] = "a";
const uint8_t kCname2[] = "de";
const uint8_t kInvalidPacket[] = {0x81, 202, 0x00, 0x03,
0x12, 0x34, 0x56, 0x78,
kCnameTag, 1, kCname1[0],
kCnameTag, 2, kCname2[0], kCname2[1],
kTerminatorTag};
const uint8_t kInvalidPacket[] = {
0x81, 202, 0x00, 0x03, 0x12, 0x34, 0x56,
0x78, kCnameTag, 1, kCname1[0], kCnameTag, 2, kCname2[0],
kCname2[1], kTerminatorTag};
// Sanity checks packet was assembled correctly.
ASSERT_EQ(0u, sizeof(kInvalidPacket) % 4);
ASSERT_EQ(kInvalidPacket[3] + 1u, sizeof(kInvalidPacket) / 4);
@ -206,12 +201,11 @@ TEST(RtcpPacketSdesTest, ParseFailsWithTooLittleSpaceForNextChunk) {
const uint8_t kCname[] = "a";
const uint8_t kEmail[] = "de";
// Two chunks are promised in the header, but no place for the second chunk.
const uint8_t kInvalidPacket[] = {0x82, 202, 0x00, 0x04,
0x12, 0x34, 0x56, 0x78, // 1st chunk.
kCnameTag, 1, kCname[0],
kEmailTag, 2, kEmail[0], kEmail[1],
kTerminatorTag,
0x23, 0x45, 0x67, 0x89}; // 2nd chunk.
const uint8_t kInvalidPacket[] = {
0x82, 202, 0x00, 0x04, 0x12, 0x34, 0x56,
0x78, // 1st chunk.
kCnameTag, 1, kCname[0], kEmailTag, 2, kEmail[0], kEmail[1],
kTerminatorTag, 0x23, 0x45, 0x67, 0x89}; // 2nd chunk.
// Sanity checks packet was assembled correctly.
ASSERT_EQ(0u, sizeof(kInvalidPacket) % 4);
ASSERT_EQ(kInvalidPacket[3] + 1u, sizeof(kInvalidPacket) / 4);

11
modules/rtp_rtcp/source/rtcp_packet/sender_report_unittest.cc
View File

@ -29,13 +29,10 @@ const NtpTime kNtp(0x11121418, 0x22242628);
const uint32_t kRtpTimestamp = 0x33343536;
const uint32_t kPacketCount = 0x44454647;
const uint32_t kOctetCount = 0x55565758;
const uint8_t kPacket[] = {0x80, 200, 0x00, 0x06,
0x12, 0x34, 0x56, 0x78,
0x11, 0x12, 0x14, 0x18,
0x22, 0x24, 0x26, 0x28,
0x33, 0x34, 0x35, 0x36,
0x44, 0x45, 0x46, 0x47,
0x55, 0x56, 0x57, 0x58};
const uint8_t kPacket[] = {0x80, 200, 0x00, 0x06, 0x12, 0x34, 0x56,
0x78, 0x11, 0x12, 0x14, 0x18, 0x22, 0x24,
0x26, 0x28, 0x33, 0x34, 0x35, 0x36, 0x44,
0x45, 0x46, 0x47, 0x55, 0x56, 0x57, 0x58};
} // namespace
TEST(RtcpPacketSenderReportTest, CreateWithoutReportBlocks) {

13
modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc
View File

@ -26,11 +26,9 @@ const uint32_t kSenderSsrc = 0x12345678;
const uint32_t kRemoteSsrc = 0x23456789;
const uint32_t kBitrateBps = 312000;
const uint16_t kOverhead = 0x1fe;
const uint8_t kPacket[] = {0x84, 205, 0x00, 0x04,
0x12, 0x34, 0x56, 0x78,
0x00, 0x00, 0x00, 0x00,
0x23, 0x45, 0x67, 0x89,
0x0a, 0x61, 0x61, 0xfe};
const uint8_t kPacket[] = {0x84, 205, 0x00, 0x04, 0x12, 0x34, 0x56,
0x78, 0x00, 0x00, 0x00, 0x00, 0x23, 0x45,
0x67, 0x89, 0x0a, 0x61, 0x61, 0xfe};
} // namespace
TEST(RtcpPacketTmmbnTest, Create) {
@ -97,9 +95,8 @@ TEST(RtcpPacketTmmbnTest, ParseFailsOnTooSmallPacket) {
}
TEST(RtcpPacketTmmbnTest, ParseFailsOnUnAlignedPacket) {
const uint8_t kUnalignedPacket[] = {0x84, 205, 0x00, 0x03,
0x12, 0x34, 0x56, 0x78,
0x00, 0x00, 0x00, 0x00,
const uint8_t kUnalignedPacket[] = {0x84, 205, 0x00, 0x03, 0x12, 0x34,
0x56, 0x78, 0x00, 0x00, 0x00, 0x00,
0x23, 0x45, 0x67, 0x89};
Tmmbn tmmbn;

22
modules/rtp_rtcp/source/rtcp_packet/tmmbr_unittest.cc
View File

@ -26,11 +26,9 @@ const uint32_t kSenderSsrc = 0x12345678;
const uint32_t kRemoteSsrc = 0x23456789;
const uint32_t kBitrateBps = 312000;
const uint16_t kOverhead = 0x1fe;
const uint8_t kPacket[] = {0x83, 205, 0x00, 0x04,
0x12, 0x34, 0x56, 0x78,
0x00, 0x00, 0x00, 0x00,
0x23, 0x45, 0x67, 0x89,
0x0a, 0x61, 0x61, 0xfe};
const uint8_t kPacket[] = {0x83, 205, 0x00, 0x04, 0x12, 0x34, 0x56,
0x78, 0x00, 0x00, 0x00, 0x00, 0x23, 0x45,
0x67, 0x89, 0x0a, 0x61, 0x61, 0xfe};
} // namespace
TEST(RtcpPacketTmmbrTest, Create) {
@ -74,21 +72,17 @@ TEST(RtcpPacketTmmbrTest, CreateAndParseWithTwoEntries) {
}
TEST(RtcpPacketTmmbrTest, ParseFailsWithoutItems) {
const uint8_t kZeroItemsPacket[] = {0x83, 205, 0x00, 0x02,
0x12, 0x34, 0x56, 0x78,
0x00, 0x00, 0x00, 0x00};
const uint8_t kZeroItemsPacket[] = {0x83, 205, 0x00, 0x02, 0x12, 0x34,
0x56, 0x78, 0x00, 0x00, 0x00, 0x00};
Tmmbr tmmbr;
EXPECT_FALSE(test::ParseSinglePacket(kZeroItemsPacket, &tmmbr));
}
TEST(RtcpPacketTmmbrTest, ParseFailsOnUnAlignedPacket) {
const uint8_t kUnalignedPacket[] = {0x83, 205, 0x00, 0x05,
0x12, 0x34, 0x56, 0x78,
0x00, 0x00, 0x00, 0x00,
0x23, 0x45, 0x67, 0x89,
0x0a, 0x61, 0x61, 0xfe,
0x34, 0x56, 0x78, 0x9a};
const uint8_t kUnalignedPacket[] = {
0x83, 205, 0x00, 0x05, 0x12, 0x34, 0x56, 0x78, 0x00, 0x00, 0x00, 0x00,
0x23, 0x45, 0x67, 0x89, 0x0a, 0x61, 0x61, 0xfe, 0x34, 0x56, 0x78, 0x9a};
Tmmbr tmmbr;
EXPECT_FALSE(test::ParseSinglePacket(kUnalignedPacket, &tmmbr));

9
modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc
View File

@ -79,8 +79,8 @@ class FeedbackTester {
ASSERT_TRUE(feedback_->IsConsistent());
serialized_ = feedback_->Build();
VerifyInternal();
feedback_ = TransportFeedback::ParseFrom(serialized_.data(),
serialized_.size());
feedback_ =
TransportFeedback::ParseFrom(serialized_.data(), serialized_.size());
ASSERT_TRUE(feedback_->IsConsistent());
ASSERT_NE(nullptr, feedback_.get());
VerifyInternal();
@ -209,10 +209,7 @@ TEST(RtcpPacketTest, TransportFeedback_TwoBitVectorFull) {
TEST(RtcpPacketTest, TransportFeedback_LargeAndNegativeDeltas) {
const uint16_t kReceived[] = {1, 2, 6, 7, 8};
const int64_t kReceiveTimes[] = {
2000,
1000,
4000,
3000,
2000, 1000, 4000, 3000,
3000 + TransportFeedback::kDeltaScaleFactor * (1 << 8)};
const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
const size_t kExpectedSizeBytes =

9
modules/rtp_rtcp/source/rtcp_packet/voip_metric_unittest.cc
View File

@ -17,11 +17,10 @@ namespace rtcp {
namespace {
const uint32_t kRemoteSsrc = 0x23456789;
const uint8_t kBlock[] = {0x07, 0x00, 0x00, 0x08, 0x23, 0x45, 0x67, 0x89,
0x01, 0x02, 0x03, 0x04, 0x11, 0x12, 0x22, 0x23,
0x33, 0x34, 0x44, 0x45, 0x05, 0x06, 0x07, 0x08,
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x00, 0x55, 0x56,
0x66, 0x67, 0x77, 0x78};
const uint8_t kBlock[] = {0x07, 0x00, 0x00, 0x08, 0x23, 0x45, 0x67, 0x89, 0x01,
0x02, 0x03, 0x04, 0x11, 0x12, 0x22, 0x23, 0x33, 0x34,
0x44, 0x45, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x00, 0x55, 0x56, 0x66, 0x67, 0x77, 0x78};
const size_t kBlockSizeBytes = sizeof(kBlock);
static_assert(
kBlockSizeBytes == VoipMetric::kLength,