OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
50 0x00, 0x64, 0x00, 0x00}; | 50 0x00, 0x64, 0x00, 0x00}; |
51 constexpr uint8_t kTooSmallPacket[] = { | 51 constexpr uint8_t kTooSmallPacket[] = { |
52 kVersionBits | Nack::kFeedbackMessageType, Nack::kPacketType, 0, 2, | 52 kVersionBits | Nack::kFeedbackMessageType, Nack::kPacketType, 0, 2, |
53 0x12, 0x34, 0x56, 0x78, | 53 0x12, 0x34, 0x56, 0x78, |
54 0x23, 0x45, 0x67, 0x89}; | 54 0x23, 0x45, 0x67, 0x89}; |
55 // clang-format on | 55 // clang-format on |
56 } // namespace | 56 } // namespace |
57 | 57 |
58 TEST(RtcpPacketNackTest, Create) { | 58 TEST(RtcpPacketNackTest, Create) { |
59 Nack nack; | 59 Nack nack; |
60 nack.SetSenderSsrc(kSenderSsrc); | 60 nack.From(kSenderSsrc); |
61 nack.SetMediaSsrc(kRemoteSsrc); | 61 nack.To(kRemoteSsrc); |
62 nack.SetPacketIds(kList, kListLength); | 62 nack.WithList(kList, kListLength); |
63 | 63 |
64 rtc::Buffer packet = nack.Build(); | 64 rtc::Buffer packet = nack.Build(); |
65 | 65 |
66 EXPECT_THAT(make_tuple(packet.data(), packet.size()), | 66 EXPECT_THAT(make_tuple(packet.data(), packet.size()), |
67 ElementsAreArray(kPacket)); | 67 ElementsAreArray(kPacket)); |
68 } | 68 } |
69 | 69 |
70 TEST(RtcpPacketNackTest, Parse) { | 70 TEST(RtcpPacketNackTest, Parse) { |
71 Nack parsed; | 71 Nack parsed; |
72 EXPECT_TRUE(test::ParseSinglePacket(kPacket, &parsed)); | 72 EXPECT_TRUE(test::ParseSinglePacket(kPacket, &parsed)); |
73 const Nack& const_parsed = parsed; | 73 const Nack& const_parsed = parsed; |
74 | 74 |
75 EXPECT_EQ(kSenderSsrc, const_parsed.sender_ssrc()); | 75 EXPECT_EQ(kSenderSsrc, const_parsed.sender_ssrc()); |
76 EXPECT_EQ(kRemoteSsrc, const_parsed.media_ssrc()); | 76 EXPECT_EQ(kRemoteSsrc, const_parsed.media_ssrc()); |
77 EXPECT_THAT(const_parsed.packet_ids(), ElementsAreArray(kList)); | 77 EXPECT_THAT(const_parsed.packet_ids(), ElementsAreArray(kList)); |
78 } | 78 } |
79 | 79 |
80 TEST(RtcpPacketNackTest, CreateWrap) { | 80 TEST(RtcpPacketNackTest, CreateWrap) { |
81 Nack nack; | 81 Nack nack; |
82 nack.SetSenderSsrc(kSenderSsrc); | 82 nack.From(kSenderSsrc); |
83 nack.SetMediaSsrc(kRemoteSsrc); | 83 nack.To(kRemoteSsrc); |
84 nack.SetPacketIds(kWrapList, kWrapListLength); | 84 nack.WithList(kWrapList, kWrapListLength); |
85 | 85 |
86 rtc::Buffer packet = nack.Build(); | 86 rtc::Buffer packet = nack.Build(); |
87 | 87 |
88 EXPECT_THAT(make_tuple(packet.data(), packet.size()), | 88 EXPECT_THAT(make_tuple(packet.data(), packet.size()), |
89 ElementsAreArray(kWrapPacket)); | 89 ElementsAreArray(kWrapPacket)); |
90 } | 90 } |
91 | 91 |
92 TEST(RtcpPacketNackTest, ParseWrap) { | 92 TEST(RtcpPacketNackTest, ParseWrap) { |
93 Nack parsed; | 93 Nack parsed; |
94 EXPECT_TRUE(test::ParseSinglePacket(kWrapPacket, &parsed)); | 94 EXPECT_TRUE(test::ParseSinglePacket(kWrapPacket, &parsed)); |
95 | 95 |
96 EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc()); | 96 EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc()); |
97 EXPECT_EQ(kRemoteSsrc, parsed.media_ssrc()); | 97 EXPECT_EQ(kRemoteSsrc, parsed.media_ssrc()); |
98 EXPECT_THAT(parsed.packet_ids(), ElementsAreArray(kWrapList)); | 98 EXPECT_THAT(parsed.packet_ids(), ElementsAreArray(kWrapList)); |
99 } | 99 } |
100 | 100 |
101 TEST(RtcpPacketNackTest, BadOrder) { | 101 TEST(RtcpPacketNackTest, BadOrder) { |
102 // Does not guarantee optimal packing, but should guarantee correctness. | 102 // Does not guarantee optimal packing, but should guarantee correctness. |
103 const uint16_t kUnorderedList[] = {1, 25, 13, 12, 9, 27, 29}; | 103 const uint16_t kUnorderedList[] = {1, 25, 13, 12, 9, 27, 29}; |
104 const size_t kUnorderedListLength = | 104 const size_t kUnorderedListLength = |
105 sizeof(kUnorderedList) / sizeof(kUnorderedList[0]); | 105 sizeof(kUnorderedList) / sizeof(kUnorderedList[0]); |
106 Nack nack; | 106 Nack nack; |
107 nack.SetSenderSsrc(kSenderSsrc); | 107 nack.From(kSenderSsrc); |
108 nack.SetMediaSsrc(kRemoteSsrc); | 108 nack.To(kRemoteSsrc); |
109 nack.SetPacketIds(kUnorderedList, kUnorderedListLength); | 109 nack.WithList(kUnorderedList, kUnorderedListLength); |
110 | 110 |
111 rtc::Buffer packet = nack.Build(); | 111 rtc::Buffer packet = nack.Build(); |
112 | 112 |
113 Nack parsed; | 113 Nack parsed; |
114 EXPECT_TRUE(test::ParseSinglePacket(packet, &parsed)); | 114 EXPECT_TRUE(test::ParseSinglePacket(packet, &parsed)); |
115 | 115 |
116 EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc()); | 116 EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc()); |
117 EXPECT_EQ(kRemoteSsrc, parsed.media_ssrc()); | 117 EXPECT_EQ(kRemoteSsrc, parsed.media_ssrc()); |
118 EXPECT_THAT(parsed.packet_ids(), UnorderedElementsAreArray(kUnorderedList)); | 118 EXPECT_THAT(parsed.packet_ids(), UnorderedElementsAreArray(kUnorderedList)); |
119 } | 119 } |
120 | 120 |
121 TEST(RtcpPacketNackTest, CreateFragmented) { | 121 TEST(RtcpPacketNackTest, CreateFragmented) { |
122 Nack nack; | 122 Nack nack; |
123 const uint16_t kList[] = {1, 100, 200, 300, 400}; | 123 const uint16_t kList[] = {1, 100, 200, 300, 400}; |
124 const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]); | 124 const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]); |
125 nack.SetSenderSsrc(kSenderSsrc); | 125 nack.From(kSenderSsrc); |
126 nack.SetMediaSsrc(kRemoteSsrc); | 126 nack.To(kRemoteSsrc); |
127 nack.SetPacketIds(kList, kListLength); | 127 nack.WithList(kList, kListLength); |
128 | 128 |
129 class MockPacketReadyCallback : public rtcp::RtcpPacket::PacketReadyCallback { | 129 class MockPacketReadyCallback : public rtcp::RtcpPacket::PacketReadyCallback { |
130 public: | 130 public: |
131 MOCK_METHOD2(OnPacketReady, void(uint8_t*, size_t)); | 131 MOCK_METHOD2(OnPacketReady, void(uint8_t*, size_t)); |
132 } verifier; | 132 } verifier; |
133 | 133 |
134 class NackVerifier { | 134 class NackVerifier { |
135 public: | 135 public: |
136 explicit NackVerifier(std::vector<uint16_t> ids) : ids_(ids) {} | 136 explicit NackVerifier(std::vector<uint16_t> ids) : ids_(ids) {} |
137 void operator()(uint8_t* data, size_t length) { | 137 void operator()(uint8_t* data, size_t length) { |
(...skipping 11 matching lines...) Expand all Loading... |
149 .WillOnce(Invoke(packet2)); | 149 .WillOnce(Invoke(packet2)); |
150 const size_t kBufferSize = 12 + (3 * 4); // Fits common header + 3 nack items | 150 const size_t kBufferSize = 12 + (3 * 4); // Fits common header + 3 nack items |
151 uint8_t buffer[kBufferSize]; | 151 uint8_t buffer[kBufferSize]; |
152 EXPECT_TRUE(nack.BuildExternalBuffer(buffer, kBufferSize, &verifier)); | 152 EXPECT_TRUE(nack.BuildExternalBuffer(buffer, kBufferSize, &verifier)); |
153 } | 153 } |
154 | 154 |
155 TEST(RtcpPacketNackTest, CreateFailsWithTooSmallBuffer) { | 155 TEST(RtcpPacketNackTest, CreateFailsWithTooSmallBuffer) { |
156 const uint16_t kList[] = {1}; | 156 const uint16_t kList[] = {1}; |
157 const size_t kMinNackBlockSize = 16; | 157 const size_t kMinNackBlockSize = 16; |
158 Nack nack; | 158 Nack nack; |
159 nack.SetSenderSsrc(kSenderSsrc); | 159 nack.From(kSenderSsrc); |
160 nack.SetMediaSsrc(kRemoteSsrc); | 160 nack.To(kRemoteSsrc); |
161 nack.SetPacketIds(kList, 1); | 161 nack.WithList(kList, 1); |
162 class Verifier : public rtcp::RtcpPacket::PacketReadyCallback { | 162 class Verifier : public rtcp::RtcpPacket::PacketReadyCallback { |
163 public: | 163 public: |
164 void OnPacketReady(uint8_t* data, size_t length) override { | 164 void OnPacketReady(uint8_t* data, size_t length) override { |
165 ADD_FAILURE() << "Buffer should be too small."; | 165 ADD_FAILURE() << "Buffer should be too small."; |
166 } | 166 } |
167 } verifier; | 167 } verifier; |
168 uint8_t buffer[kMinNackBlockSize - 1]; | 168 uint8_t buffer[kMinNackBlockSize - 1]; |
169 EXPECT_FALSE( | 169 EXPECT_FALSE( |
170 nack.BuildExternalBuffer(buffer, kMinNackBlockSize - 1, &verifier)); | 170 nack.BuildExternalBuffer(buffer, kMinNackBlockSize - 1, &verifier)); |
171 } | 171 } |
172 | 172 |
173 TEST(RtcpPacketNackTest, ParseFailsWithTooSmallBuffer) { | 173 TEST(RtcpPacketNackTest, ParseFailsWithTooSmallBuffer) { |
174 Nack parsed; | 174 Nack parsed; |
175 EXPECT_FALSE(test::ParseSinglePacket(kTooSmallPacket, &parsed)); | 175 EXPECT_FALSE(test::ParseSinglePacket(kTooSmallPacket, &parsed)); |
176 } | 176 } |
177 | 177 |
178 } // namespace webrtc | 178 } // namespace webrtc |
OLD | NEW |