Index: webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc |
diff --git a/webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc b/webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..60fecd14514ae0544199b302f5869d30ba5f2375 |
--- /dev/null |
+++ b/webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc |
@@ -0,0 +1,151 @@ |
+/* |
+ * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. |
+ * |
+ * Use of this source code is governed by a BSD-style license |
+ * that can be found in the LICENSE file in the root of the source |
+ * tree. An additional intellectual property rights grant can be found |
+ * in the file PATENTS. All contributing project authors may |
+ * be found in the AUTHORS file in the root of the source tree. |
+ */ |
+ |
+#include <string.h> |
+ |
+#include <memory> |
+#include <utility> |
+ |
+#include "testing/gtest/include/gtest/gtest.h" |
+#include "webrtc/base/basictypes.h" |
+#include "webrtc/base/checks.h" |
+#include "webrtc/base/random.h" |
+#include "webrtc/base/scoped_ref_ptr.h" |
+#include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" |
+#include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" |
+#include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h" |
+#include "webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h" |
+ |
+namespace webrtc { |
+ |
+namespace { |
+constexpr uint32_t kMediaSsrc = 1254983; |
+constexpr uint16_t kMediaStartSeqNum = 825; |
+constexpr size_t kMediaPacketLength = 1234; |
+ |
+constexpr size_t kUlpfecHeaderSizeLBitClear = 14; |
+constexpr size_t kUlpfecHeaderSizeLBitSet = 18; |
+constexpr size_t kUlpfecPacketMaskOffset = 12; |
+} // namespace |
+ |
+using Packet = ::webrtc::ForwardErrorCorrection::Packet; |
danilchap
2016/09/01 16:28:48
Using is recommended to put at the top part of the
brandtr
2016/09/02 08:29:13
Done.
|
+using PacketList = ::webrtc::ForwardErrorCorrection::PacketList; |
+using ReceivedFecPacket = ::webrtc::ForwardErrorCorrection::ReceivedFecPacket; |
+ |
+class UlpfecHeaderReaderWriterTest : public ::testing::Test { |
+ protected: |
+ UlpfecHeaderReaderWriterTest() : random_(0xabcdef123456) {} |
+ |
+ // Randomly generate packet mask of specified size. |
+ void GeneratePacketMask(size_t packet_mask_size); |
+ |
+ std::unique_ptr<Packet> WriteHeader(size_t packet_mask_size); |
+ std::unique_ptr<ReceivedFecPacket> ReadHeader(const Packet& packet_to_write); |
+ |
+ void VerifyHeaders(size_t expected_fec_header_size, |
+ size_t expected_packet_mask_size, |
+ const Packet& packet_to_write, |
+ const ReceivedFecPacket& packet_to_read); |
+ |
+ UlpfecHeaderReader reader_; |
+ UlpfecHeaderWriter writer_; |
+ |
+ Random random_; |
+ uint8_t packet_mask_[kUlpfecMaxPacketMaskSize]; |
+}; |
+ |
+void UlpfecHeaderReaderWriterTest::GeneratePacketMask(size_t packet_mask_size) { |
+ RTC_DCHECK_LE(packet_mask_size, kUlpfecMaxPacketMaskSize); |
+ memset(packet_mask_, 0u, sizeof(packet_mask_)); |
+ for (size_t i = 0; i < packet_mask_size; ++i) { |
+ packet_mask_[i] = random_.Rand<uint8_t>(); |
+ } |
+} |
+ |
+std::unique_ptr<Packet> UlpfecHeaderReaderWriterTest::WriteHeader( |
+ size_t packet_mask_size) { |
+ std::unique_ptr<Packet> packet_to_write(new Packet()); |
+ packet_to_write->length = kMediaPacketLength; |
+ for (size_t i = 0; i < packet_to_write->length; ++i) { |
+ packet_to_write->data[i] = random_.Rand<uint8_t>(); |
+ } |
+ constexpr uint16_t kSeqNumBase = kMediaStartSeqNum; |
+ writer_.FinalizeFecHeader(kSeqNumBase, packet_mask_, packet_mask_size, |
+ packet_to_write.get()); |
+ return packet_to_write; |
+} |
+ |
+std::unique_ptr<ReceivedFecPacket> UlpfecHeaderReaderWriterTest::ReadHeader( |
+ const Packet& packet_to_write) { |
+ std::unique_ptr<ReceivedFecPacket> packet_to_read(new ReceivedFecPacket()); |
+ packet_to_read->ssrc = kMediaSsrc; |
+ packet_to_read->protected_ssrc = kMediaSsrc; |
+ packet_to_read->pkt = rtc::scoped_refptr<Packet>(new Packet()); |
+ memcpy(packet_to_read->pkt->data, packet_to_write.data, |
+ packet_to_write.length); |
+ packet_to_read->pkt->length = packet_to_write.length; |
+ EXPECT_TRUE(reader_.ReadFecHeader(packet_to_read.get())); |
+ return packet_to_read; |
+} |
+ |
+void UlpfecHeaderReaderWriterTest::VerifyHeaders( |
+ size_t expected_fec_header_size, |
+ size_t expected_packet_mask_size, |
+ const Packet& packet_to_write, |
+ const ReceivedFecPacket& packet_to_read) { |
+ EXPECT_EQ(kMediaSsrc, packet_to_read.ssrc); |
+ EXPECT_EQ(expected_fec_header_size, packet_to_read.fec_header_size); |
+ EXPECT_EQ(kMediaSsrc, packet_to_read.protected_ssrc); |
+ EXPECT_EQ(kMediaStartSeqNum, packet_to_read.seq_num_base); |
+ EXPECT_EQ(kUlpfecPacketMaskOffset, packet_to_read.packet_mask_offset); |
+ ASSERT_EQ(expected_packet_mask_size, packet_to_read.packet_mask_size); |
+ EXPECT_EQ(packet_to_write.length - expected_fec_header_size, |
+ packet_to_read.protection_length); |
+ EXPECT_EQ(0, |
+ memcmp(packet_mask_, |
+ &packet_to_read.pkt->data[packet_to_read.packet_mask_offset], |
+ packet_to_read.packet_mask_size)); |
+ // Verify that the call to ReadFecHeader did not tamper with the payload. |
+ EXPECT_EQ(0, memcmp(&packet_to_write.data[expected_fec_header_size], |
+ &packet_to_read.pkt->data[expected_fec_header_size], |
+ packet_to_write.length - expected_fec_header_size)); |
+} |
+ |
+TEST_F(UlpfecHeaderReaderWriterTest, CalculateSmallHeaderSize) { |
+ GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear); |
+ EXPECT_EQ(kUlpfecHeaderSizeLBitClear, |
+ writer_.FecHeaderSize(writer_.MinPacketMaskSize( |
+ packet_mask_, kUlpfecPacketMaskSizeLBitClear))); |
+} |
+ |
+TEST_F(UlpfecHeaderReaderWriterTest, CalculateLargeHeaderSize) { |
+ GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet); |
+ EXPECT_EQ(kUlpfecHeaderSizeLBitSet, |
+ writer_.FecHeaderSize(writer_.MinPacketMaskSize( |
+ packet_mask_, kUlpfecPacketMaskSizeLBitSet))); |
+} |
+ |
+TEST_F(UlpfecHeaderReaderWriterTest, WriteAndReadSmallHeader) { |
+ GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear); |
+ auto packet_to_write = WriteHeader(kUlpfecPacketMaskSizeLBitClear); |
+ auto packet_to_read = ReadHeader(*packet_to_write); |
+ VerifyHeaders(kUlpfecHeaderSizeLBitClear, kUlpfecPacketMaskSizeLBitClear, |
+ *packet_to_write, *packet_to_read); |
+} |
+ |
+TEST_F(UlpfecHeaderReaderWriterTest, WriteAndReadLargeHeader) { |
+ GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet); |
+ auto packet_to_write = WriteHeader(kUlpfecPacketMaskSizeLBitSet); |
+ auto packet_to_read = ReadHeader(*packet_to_write); |
+ VerifyHeaders(kUlpfecHeaderSizeLBitSet, kUlpfecPacketMaskSizeLBitSet, |
+ *packet_to_write, *packet_to_read); |
+} |
+ |
+} // namespace webrtc |