rtcp_packet_unittest.cc revision a3b8769860bdb0a45dbff6d1e0092486fa59aaa4 
1/*
2 *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
3 *
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
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 *
10 * This file includes unit tests for the RtcpPacket.
11 */
12
13#include "testing/gmock/include/gmock/gmock.h"
14#include "testing/gtest/include/gtest/gtest.h"
15
16#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
17#include "webrtc/test/rtcp_packet_parser.h"
18
19using ::testing::ElementsAre;
20
21using webrtc::rtcp::App;
22using webrtc::rtcp::Bye;
23using webrtc::rtcp::Dlrr;
24using webrtc::rtcp::Empty;
25using webrtc::rtcp::Fir;
26using webrtc::rtcp::Ij;
27using webrtc::rtcp::Nack;
28using webrtc::rtcp::Pli;
29using webrtc::rtcp::Sdes;
30using webrtc::rtcp::SenderReport;
31using webrtc::rtcp::Sli;
32using webrtc::rtcp::RawPacket;
33using webrtc::rtcp::ReceiverReport;
34using webrtc::rtcp::Remb;
35using webrtc::rtcp::ReportBlock;
36using webrtc::rtcp::Rpsi;
37using webrtc::rtcp::Rrtr;
38using webrtc::rtcp::SenderReport;
39using webrtc::rtcp::Tmmbn;
40using webrtc::rtcp::Tmmbr;
41using webrtc::rtcp::VoipMetric;
42using webrtc::rtcp::Xr;
43using webrtc::test::RtcpPacketParser;
44
45namespace webrtc {
46
47const uint32_t kSenderSsrc = 0x12345678;
48const uint32_t kRemoteSsrc = 0x23456789;
49
50TEST(RtcpPacketTest, Rr) {
51  ReceiverReport rr;
52  rr.From(kSenderSsrc);
53
54  rtc::scoped_ptr<RawPacket> packet(rr.Build());
55  RtcpPacketParser parser;
56  parser.Parse(packet->Buffer(), packet->Length());
57  EXPECT_EQ(1, parser.receiver_report()->num_packets());
58  EXPECT_EQ(kSenderSsrc, parser.receiver_report()->Ssrc());
59  EXPECT_EQ(0, parser.report_block()->num_packets());
60}
61
62TEST(RtcpPacketTest, RrWithOneReportBlock) {
63  ReportBlock rb;
64  rb.To(kRemoteSsrc);
65  rb.WithFractionLost(55);
66  rb.WithCumulativeLost(0x111111);
67  rb.WithExtHighestSeqNum(0x22222222);
68  rb.WithJitter(0x33333333);
69  rb.WithLastSr(0x44444444);
70  rb.WithDelayLastSr(0x55555555);
71
72  ReceiverReport rr;
73  rr.From(kSenderSsrc);
74  EXPECT_TRUE(rr.WithReportBlock(rb));
75
76  rtc::scoped_ptr<RawPacket> packet(rr.Build());
77  RtcpPacketParser parser;
78  parser.Parse(packet->Buffer(), packet->Length());
79  EXPECT_EQ(1, parser.receiver_report()->num_packets());
80  EXPECT_EQ(kSenderSsrc, parser.receiver_report()->Ssrc());
81  EXPECT_EQ(1, parser.report_block()->num_packets());
82  EXPECT_EQ(kRemoteSsrc, parser.report_block()->Ssrc());
83  EXPECT_EQ(55U, parser.report_block()->FractionLost());
84  EXPECT_EQ(0x111111U, parser.report_block()->CumPacketLost());
85  EXPECT_EQ(0x22222222U, parser.report_block()->ExtHighestSeqNum());
86  EXPECT_EQ(0x33333333U, parser.report_block()->Jitter());
87  EXPECT_EQ(0x44444444U, parser.report_block()->LastSr());
88  EXPECT_EQ(0x55555555U, parser.report_block()->DelayLastSr());
89}
90
91TEST(RtcpPacketTest, RrWithTwoReportBlocks) {
92  ReportBlock rb1;
93  rb1.To(kRemoteSsrc);
94  ReportBlock rb2;
95  rb2.To(kRemoteSsrc + 1);
96
97  ReceiverReport rr;
98  rr.From(kSenderSsrc);
99  EXPECT_TRUE(rr.WithReportBlock(rb1));
100  EXPECT_TRUE(rr.WithReportBlock(rb2));
101
102  rtc::scoped_ptr<RawPacket> packet(rr.Build());
103  RtcpPacketParser parser;
104  parser.Parse(packet->Buffer(), packet->Length());
105  EXPECT_EQ(1, parser.receiver_report()->num_packets());
106  EXPECT_EQ(kSenderSsrc, parser.receiver_report()->Ssrc());
107  EXPECT_EQ(2, parser.report_block()->num_packets());
108  EXPECT_EQ(1, parser.report_blocks_per_ssrc(kRemoteSsrc));
109  EXPECT_EQ(1, parser.report_blocks_per_ssrc(kRemoteSsrc + 1));
110}
111
112TEST(RtcpPacketTest, RrWithTooManyReportBlocks) {
113  ReceiverReport rr;
114  rr.From(kSenderSsrc);
115  const int kMaxReportBlocks = (1 << 5) - 1;
116  ReportBlock rb;
117  for (int i = 0; i < kMaxReportBlocks; ++i) {
118    rb.To(kRemoteSsrc + i);
119    EXPECT_TRUE(rr.WithReportBlock(rb));
120  }
121  rb.To(kRemoteSsrc + kMaxReportBlocks);
122  EXPECT_FALSE(rr.WithReportBlock(rb));
123}
124
125TEST(RtcpPacketTest, Sr) {
126  SenderReport sr;
127  sr.From(kSenderSsrc);
128  sr.WithNtpSec(0x11111111);
129  sr.WithNtpFrac(0x22222222);
130  sr.WithRtpTimestamp(0x33333333);
131  sr.WithPacketCount(0x44444444);
132  sr.WithOctetCount(0x55555555);
133
134  rtc::scoped_ptr<RawPacket> packet(sr.Build());
135  RtcpPacketParser parser;
136  parser.Parse(packet->Buffer(), packet->Length());
137
138  EXPECT_EQ(1, parser.sender_report()->num_packets());
139  EXPECT_EQ(kSenderSsrc, parser.sender_report()->Ssrc());
140  EXPECT_EQ(0x11111111U, parser.sender_report()->NtpSec());
141  EXPECT_EQ(0x22222222U, parser.sender_report()->NtpFrac());
142  EXPECT_EQ(0x33333333U, parser.sender_report()->RtpTimestamp());
143  EXPECT_EQ(0x44444444U, parser.sender_report()->PacketCount());
144  EXPECT_EQ(0x55555555U, parser.sender_report()->OctetCount());
145  EXPECT_EQ(0, parser.report_block()->num_packets());
146}
147
148TEST(RtcpPacketTest, SrWithOneReportBlock) {
149  ReportBlock rb;
150  rb.To(kRemoteSsrc);
151
152  SenderReport sr;
153  sr.From(kSenderSsrc);
154  EXPECT_TRUE(sr.WithReportBlock(rb));
155
156  rtc::scoped_ptr<RawPacket> packet(sr.Build());
157  RtcpPacketParser parser;
158  parser.Parse(packet->Buffer(), packet->Length());
159  EXPECT_EQ(1, parser.sender_report()->num_packets());
160  EXPECT_EQ(kSenderSsrc, parser.sender_report()->Ssrc());
161  EXPECT_EQ(1, parser.report_block()->num_packets());
162  EXPECT_EQ(kRemoteSsrc, parser.report_block()->Ssrc());
163}
164
165TEST(RtcpPacketTest, SrWithTwoReportBlocks) {
166  ReportBlock rb1;
167  rb1.To(kRemoteSsrc);
168  ReportBlock rb2;
169  rb2.To(kRemoteSsrc + 1);
170
171  SenderReport sr;
172  sr.From(kSenderSsrc);
173  EXPECT_TRUE(sr.WithReportBlock(rb1));
174  EXPECT_TRUE(sr.WithReportBlock(rb2));
175
176  rtc::scoped_ptr<RawPacket> packet(sr.Build());
177  RtcpPacketParser parser;
178  parser.Parse(packet->Buffer(), packet->Length());
179  EXPECT_EQ(1, parser.sender_report()->num_packets());
180  EXPECT_EQ(kSenderSsrc, parser.sender_report()->Ssrc());
181  EXPECT_EQ(2, parser.report_block()->num_packets());
182  EXPECT_EQ(1, parser.report_blocks_per_ssrc(kRemoteSsrc));
183  EXPECT_EQ(1, parser.report_blocks_per_ssrc(kRemoteSsrc + 1));
184}
185
186TEST(RtcpPacketTest, SrWithTooManyReportBlocks) {
187  SenderReport sr;
188  sr.From(kSenderSsrc);
189  const int kMaxReportBlocks = (1 << 5) - 1;
190  ReportBlock rb;
191  for (int i = 0; i < kMaxReportBlocks; ++i) {
192    rb.To(kRemoteSsrc + i);
193    EXPECT_TRUE(sr.WithReportBlock(rb));
194  }
195  rb.To(kRemoteSsrc + kMaxReportBlocks);
196  EXPECT_FALSE(sr.WithReportBlock(rb));
197}
198
199TEST(RtcpPacketTest, IjNoItem) {
200  Ij ij;
201
202  rtc::scoped_ptr<RawPacket> packet(ij.Build());
203  RtcpPacketParser parser;
204  parser.Parse(packet->Buffer(), packet->Length());
205  EXPECT_EQ(1, parser.ij()->num_packets());
206  EXPECT_EQ(0, parser.ij_item()->num_packets());
207}
208
209TEST(RtcpPacketTest, IjOneItem) {
210  Ij ij;
211  EXPECT_TRUE(ij.WithJitterItem(0x11111111));
212
213  rtc::scoped_ptr<RawPacket> packet(ij.Build());
214  RtcpPacketParser parser;
215  parser.Parse(packet->Buffer(), packet->Length());
216  EXPECT_EQ(1, parser.ij()->num_packets());
217  EXPECT_EQ(1, parser.ij_item()->num_packets());
218  EXPECT_EQ(0x11111111U, parser.ij_item()->Jitter());
219}
220
221TEST(RtcpPacketTest, IjTwoItems) {
222  Ij ij;
223  EXPECT_TRUE(ij.WithJitterItem(0x11111111));
224  EXPECT_TRUE(ij.WithJitterItem(0x22222222));
225
226  rtc::scoped_ptr<RawPacket> packet(ij.Build());
227  RtcpPacketParser parser;
228  parser.Parse(packet->Buffer(), packet->Length());
229  EXPECT_EQ(1, parser.ij()->num_packets());
230  EXPECT_EQ(2, parser.ij_item()->num_packets());
231  EXPECT_EQ(0x22222222U, parser.ij_item()->Jitter());
232}
233
234TEST(RtcpPacketTest, IjTooManyItems) {
235  Ij ij;
236  const int kMaxIjItems = (1 << 5) - 1;
237  for (int i = 0; i < kMaxIjItems; ++i) {
238    EXPECT_TRUE(ij.WithJitterItem(i));
239  }
240  EXPECT_FALSE(ij.WithJitterItem(kMaxIjItems));
241}
242
243TEST(RtcpPacketTest, AppWithNoData) {
244  App app;
245  app.WithSubType(30);
246  uint32_t name = 'n' << 24;
247  name += 'a' << 16;
248  name += 'm' << 8;
249  name += 'e';
250  app.WithName(name);
251
252  rtc::scoped_ptr<RawPacket> packet(app.Build());
253  RtcpPacketParser parser;
254  parser.Parse(packet->Buffer(), packet->Length());
255  EXPECT_EQ(1, parser.app()->num_packets());
256  EXPECT_EQ(30U, parser.app()->SubType());
257  EXPECT_EQ(name, parser.app()->Name());
258  EXPECT_EQ(0, parser.app_item()->num_packets());
259}
260
261TEST(RtcpPacketTest, App) {
262  App app;
263  app.From(kSenderSsrc);
264  app.WithSubType(30);
265  uint32_t name = 'n' << 24;
266  name += 'a' << 16;
267  name += 'm' << 8;
268  name += 'e';
269  app.WithName(name);
270  const char kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'};
271  const size_t kDataLength = sizeof(kData) / sizeof(kData[0]);
272  app.WithData((const uint8_t*)kData, kDataLength);
273
274  rtc::scoped_ptr<RawPacket> packet(app.Build());
275  RtcpPacketParser parser;
276  parser.Parse(packet->Buffer(), packet->Length());
277  EXPECT_EQ(1, parser.app()->num_packets());
278  EXPECT_EQ(30U, parser.app()->SubType());
279  EXPECT_EQ(name, parser.app()->Name());
280  EXPECT_EQ(1, parser.app_item()->num_packets());
281  EXPECT_EQ(kDataLength, parser.app_item()->DataLength());
282  EXPECT_EQ(0, strncmp(kData, (const char*)parser.app_item()->Data(),
283      parser.app_item()->DataLength()));
284}
285
286TEST(RtcpPacketTest, SdesWithOneChunk) {
287  Sdes sdes;
288  EXPECT_TRUE(sdes.WithCName(kSenderSsrc, "alice@host"));
289
290  rtc::scoped_ptr<RawPacket> packet(sdes.Build());
291  RtcpPacketParser parser;
292  parser.Parse(packet->Buffer(), packet->Length());
293  EXPECT_EQ(1, parser.sdes()->num_packets());
294  EXPECT_EQ(1, parser.sdes_chunk()->num_packets());
295  EXPECT_EQ(kSenderSsrc, parser.sdes_chunk()->Ssrc());
296  EXPECT_EQ("alice@host", parser.sdes_chunk()->Cname());
297}
298
299TEST(RtcpPacketTest, SdesWithMultipleChunks) {
300  Sdes sdes;
301  EXPECT_TRUE(sdes.WithCName(kSenderSsrc, "a"));
302  EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 1, "ab"));
303  EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 2, "abc"));
304  EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 3, "abcd"));
305  EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 4, "abcde"));
306  EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 5, "abcdef"));
307
308  rtc::scoped_ptr<RawPacket> packet(sdes.Build());
309  RtcpPacketParser parser;
310  parser.Parse(packet->Buffer(), packet->Length());
311  EXPECT_EQ(1, parser.sdes()->num_packets());
312  EXPECT_EQ(6, parser.sdes_chunk()->num_packets());
313  EXPECT_EQ(kSenderSsrc + 5, parser.sdes_chunk()->Ssrc());
314  EXPECT_EQ("abcdef", parser.sdes_chunk()->Cname());
315}
316
317TEST(RtcpPacketTest, SdesWithTooManyChunks) {
318  Sdes sdes;
319  const int kMaxChunks = (1 << 5) - 1;
320  for (int i = 0; i < kMaxChunks; ++i) {
321    uint32_t ssrc = kSenderSsrc + i;
322    std::ostringstream oss;
323    oss << "cname" << i;
324    EXPECT_TRUE(sdes.WithCName(ssrc, oss.str()));
325  }
326  EXPECT_FALSE(sdes.WithCName(kSenderSsrc + kMaxChunks, "foo"));
327}
328
329TEST(RtcpPacketTest, CnameItemWithEmptyString) {
330  Sdes sdes;
331  EXPECT_TRUE(sdes.WithCName(kSenderSsrc, ""));
332
333  rtc::scoped_ptr<RawPacket> packet(sdes.Build());
334  RtcpPacketParser parser;
335  parser.Parse(packet->Buffer(), packet->Length());
336  EXPECT_EQ(1, parser.sdes()->num_packets());
337  EXPECT_EQ(1, parser.sdes_chunk()->num_packets());
338  EXPECT_EQ(kSenderSsrc, parser.sdes_chunk()->Ssrc());
339  EXPECT_EQ("", parser.sdes_chunk()->Cname());
340}
341
342TEST(RtcpPacketTest, Pli) {
343  Pli pli;
344  pli.From(kSenderSsrc);
345  pli.To(kRemoteSsrc);
346
347  rtc::scoped_ptr<RawPacket> packet(pli.Build());
348  RtcpPacketParser parser;
349  parser.Parse(packet->Buffer(), packet->Length());
350  EXPECT_EQ(1, parser.pli()->num_packets());
351  EXPECT_EQ(kSenderSsrc, parser.pli()->Ssrc());
352  EXPECT_EQ(kRemoteSsrc, parser.pli()->MediaSsrc());
353}
354
355TEST(RtcpPacketTest, Sli) {
356  const uint16_t kFirstMb = 7777;
357  const uint16_t kNumberOfMb = 6666;
358  const uint8_t kPictureId = 60;
359  Sli sli;
360  sli.From(kSenderSsrc);
361  sli.To(kRemoteSsrc);
362  sli.WithFirstMb(kFirstMb);
363  sli.WithNumberOfMb(kNumberOfMb);
364  sli.WithPictureId(kPictureId);
365
366  rtc::scoped_ptr<RawPacket> packet(sli.Build());
367  RtcpPacketParser parser;
368  parser.Parse(packet->Buffer(), packet->Length());
369  EXPECT_EQ(1, parser.sli()->num_packets());
370  EXPECT_EQ(kSenderSsrc, parser.sli()->Ssrc());
371  EXPECT_EQ(kRemoteSsrc, parser.sli()->MediaSsrc());
372  EXPECT_EQ(1, parser.sli_item()->num_packets());
373  EXPECT_EQ(kFirstMb, parser.sli_item()->FirstMb());
374  EXPECT_EQ(kNumberOfMb, parser.sli_item()->NumberOfMb());
375  EXPECT_EQ(kPictureId, parser.sli_item()->PictureId());
376}
377
378TEST(RtcpPacketTest, Nack) {
379  Nack nack;
380  const uint16_t kList[] = {0, 1, 3, 8, 16};
381  const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]);
382  nack.From(kSenderSsrc);
383  nack.To(kRemoteSsrc);
384  nack.WithList(kList, kListLength);
385  rtc::scoped_ptr<RawPacket> packet(nack.Build());
386  RtcpPacketParser parser;
387  parser.Parse(packet->Buffer(), packet->Length());
388  EXPECT_EQ(1, parser.nack()->num_packets());
389  EXPECT_EQ(kSenderSsrc, parser.nack()->Ssrc());
390  EXPECT_EQ(kRemoteSsrc, parser.nack()->MediaSsrc());
391  EXPECT_EQ(1, parser.nack_item()->num_packets());
392  std::vector<uint16_t> seqs = parser.nack_item()->last_nack_list();
393  EXPECT_EQ(kListLength, seqs.size());
394  for (size_t i = 0; i < kListLength; ++i) {
395    EXPECT_EQ(kList[i], seqs[i]);
396  }
397}
398
399TEST(RtcpPacketTest, NackWithWrap) {
400  Nack nack;
401  const uint16_t kList[] = {65500, 65516, 65534, 65535, 0, 1, 3, 20, 100};
402  const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]);
403  nack.From(kSenderSsrc);
404  nack.To(kRemoteSsrc);
405  nack.WithList(kList, kListLength);
406  rtc::scoped_ptr<RawPacket> packet(nack.Build());
407  RtcpPacketParser parser;
408  parser.Parse(packet->Buffer(), packet->Length());
409  EXPECT_EQ(1, parser.nack()->num_packets());
410  EXPECT_EQ(kSenderSsrc, parser.nack()->Ssrc());
411  EXPECT_EQ(kRemoteSsrc, parser.nack()->MediaSsrc());
412  EXPECT_EQ(4, parser.nack_item()->num_packets());
413  std::vector<uint16_t> seqs = parser.nack_item()->last_nack_list();
414  EXPECT_EQ(kListLength, seqs.size());
415  for (size_t i = 0; i < kListLength; ++i) {
416    EXPECT_EQ(kList[i], seqs[i]);
417  }
418}
419
420TEST(RtcpPacketTest, NackFragmented) {
421  Nack nack;
422  const uint16_t kList[] = {1, 100, 200, 300, 400};
423  const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]);
424  nack.From(kSenderSsrc);
425  nack.To(kRemoteSsrc);
426  nack.WithList(kList, kListLength);
427
428  class Verifier : public rtcp::RtcpPacket::PacketReadyCallback {
429   public:
430    void OnPacketReady(uint8_t* data, size_t length) override {
431      ++packets_created_;
432      RtcpPacketParser parser;
433      parser.Parse(data, length);
434      EXPECT_EQ(1, parser.nack()->num_packets());
435      EXPECT_EQ(kSenderSsrc, parser.nack()->Ssrc());
436      EXPECT_EQ(kRemoteSsrc, parser.nack()->MediaSsrc());
437      switch (packets_created_) {
438        case 1:
439          EXPECT_THAT(parser.nack_item()->last_nack_list(),
440                      ElementsAre(1, 100, 200));
441          break;
442        case 2:
443          EXPECT_THAT(parser.nack_item()->last_nack_list(),
444                      ElementsAre(300, 400));
445          break;
446        default:
447          ADD_FAILURE() << "Unexpected packet count: " << packets_created_;
448      }
449    }
450    int packets_created_ = 0;
451  } verifier;
452  const size_t kBufferSize = 12 + (3 * 4);  // Fits common header + 3 nack items
453  uint8_t buffer[kBufferSize];
454  EXPECT_TRUE(nack.BuildExternalBuffer(buffer, kBufferSize, &verifier));
455  EXPECT_EQ(2, verifier.packets_created_);
456}
457
458TEST(RtcpPacketTest, NackWithTooSmallBuffer) {
459  const uint16_t kList[] = {1};
460  const size_t kMinNackBlockSize = 16;
461  Nack nack;
462  nack.From(kSenderSsrc);
463  nack.To(kRemoteSsrc);
464  nack.WithList(kList, 1);
465  class Verifier : public rtcp::RtcpPacket::PacketReadyCallback {
466   public:
467    void OnPacketReady(uint8_t* data, size_t length) override {
468      ADD_FAILURE() << "Buffer should be too small.";
469    }
470  } verifier;
471  uint8_t buffer[kMinNackBlockSize - 1];
472  EXPECT_FALSE(
473      nack.BuildExternalBuffer(buffer, kMinNackBlockSize - 1, &verifier));
474}
475
476TEST(RtcpPacketTest, Rpsi) {
477  Rpsi rpsi;
478  // 1000001 (7 bits = 1 byte in native string).
479  const uint64_t kPictureId = 0x41;
480  const uint16_t kNumberOfValidBytes = 1;
481  rpsi.WithPayloadType(100);
482  rpsi.WithPictureId(kPictureId);
483
484  rtc::scoped_ptr<RawPacket> packet(rpsi.Build());
485  RtcpPacketParser parser;
486  parser.Parse(packet->Buffer(), packet->Length());
487  EXPECT_EQ(100, parser.rpsi()->PayloadType());
488  EXPECT_EQ(kNumberOfValidBytes * 8, parser.rpsi()->NumberOfValidBits());
489  EXPECT_EQ(kPictureId, parser.rpsi()->PictureId());
490}
491
492TEST(RtcpPacketTest, RpsiWithTwoByteNativeString) {
493  Rpsi rpsi;
494  // |1 0000001 (7 bits = 1 byte in native string).
495  const uint64_t kPictureId = 0x81;
496  const uint16_t kNumberOfValidBytes = 2;
497  rpsi.WithPictureId(kPictureId);
498
499  rtc::scoped_ptr<RawPacket> packet(rpsi.Build());
500  RtcpPacketParser parser;
501  parser.Parse(packet->Buffer(), packet->Length());
502  EXPECT_EQ(kNumberOfValidBytes * 8, parser.rpsi()->NumberOfValidBits());
503  EXPECT_EQ(kPictureId, parser.rpsi()->PictureId());
504}
505
506TEST(RtcpPacketTest, RpsiWithThreeByteNativeString) {
507  Rpsi rpsi;
508  // 10000|00 100000|0 1000000 (7 bits = 1 byte in native string).
509  const uint64_t kPictureId = 0x102040;
510  const uint16_t kNumberOfValidBytes = 3;
511  rpsi.WithPictureId(kPictureId);
512
513  rtc::scoped_ptr<RawPacket> packet(rpsi.Build());
514  RtcpPacketParser parser;
515  parser.Parse(packet->Buffer(), packet->Length());
516  EXPECT_EQ(kNumberOfValidBytes * 8, parser.rpsi()->NumberOfValidBits());
517  EXPECT_EQ(kPictureId, parser.rpsi()->PictureId());
518}
519
520TEST(RtcpPacketTest, RpsiWithFourByteNativeString) {
521  Rpsi rpsi;
522  // 1000|001 00001|01 100001|1 1000010 (7 bits = 1 byte in native string).
523  const uint64_t kPictureId = 0x84161C2;
524  const uint16_t kNumberOfValidBytes = 4;
525  rpsi.WithPictureId(kPictureId);
526
527  rtc::scoped_ptr<RawPacket> packet(rpsi.Build());
528  RtcpPacketParser parser;
529  parser.Parse(packet->Buffer(), packet->Length());
530  EXPECT_EQ(kNumberOfValidBytes * 8, parser.rpsi()->NumberOfValidBits());
531  EXPECT_EQ(kPictureId, parser.rpsi()->PictureId());
532}
533
534TEST(RtcpPacketTest, RpsiWithMaxPictureId) {
535  Rpsi rpsi;
536  // 1 1111111| 1111111 1|111111 11|11111 111|1111 1111|111 11111|
537  // 11 111111|1 1111111 (7 bits = 1 byte in native string).
538  const uint64_t kPictureId = 0xffffffffffffffff;
539  const uint16_t kNumberOfValidBytes = 10;
540  rpsi.WithPictureId(kPictureId);
541
542  rtc::scoped_ptr<RawPacket> packet(rpsi.Build());
543  RtcpPacketParser parser;
544  parser.Parse(packet->Buffer(), packet->Length());
545  EXPECT_EQ(kNumberOfValidBytes * 8, parser.rpsi()->NumberOfValidBits());
546  EXPECT_EQ(kPictureId, parser.rpsi()->PictureId());
547}
548
549TEST(RtcpPacketTest, Fir) {
550  Fir fir;
551  fir.From(kSenderSsrc);
552  fir.To(kRemoteSsrc);
553  fir.WithCommandSeqNum(123);
554
555  rtc::scoped_ptr<RawPacket> packet(fir.Build());
556  RtcpPacketParser parser;
557  parser.Parse(packet->Buffer(), packet->Length());
558  EXPECT_EQ(1, parser.fir()->num_packets());
559  EXPECT_EQ(kSenderSsrc, parser.fir()->Ssrc());
560  EXPECT_EQ(1, parser.fir_item()->num_packets());
561  EXPECT_EQ(kRemoteSsrc, parser.fir_item()->Ssrc());
562  EXPECT_EQ(123U, parser.fir_item()->SeqNum());
563}
564
565TEST(RtcpPacketTest, AppendPacket) {
566  Fir fir;
567  ReportBlock rb;
568  ReceiverReport rr;
569  rr.From(kSenderSsrc);
570  EXPECT_TRUE(rr.WithReportBlock(rb));
571  rr.Append(&fir);
572
573  rtc::scoped_ptr<RawPacket> packet(rr.Build());
574  RtcpPacketParser parser;
575  parser.Parse(packet->Buffer(), packet->Length());
576  EXPECT_EQ(1, parser.receiver_report()->num_packets());
577  EXPECT_EQ(kSenderSsrc, parser.receiver_report()->Ssrc());
578  EXPECT_EQ(1, parser.report_block()->num_packets());
579  EXPECT_EQ(1, parser.fir()->num_packets());
580}
581
582TEST(RtcpPacketTest, AppendPacketOnEmpty) {
583  Empty empty;
584  ReceiverReport rr;
585  rr.From(kSenderSsrc);
586  empty.Append(&rr);
587
588  rtc::scoped_ptr<RawPacket> packet(empty.Build());
589  RtcpPacketParser parser;
590  parser.Parse(packet->Buffer(), packet->Length());
591  EXPECT_EQ(1, parser.receiver_report()->num_packets());
592  EXPECT_EQ(0, parser.report_block()->num_packets());
593}
594
595TEST(RtcpPacketTest, AppendPacketWithOwnAppendedPacket) {
596  Fir fir;
597  Bye bye;
598  ReportBlock rb;
599
600  ReceiverReport rr;
601  EXPECT_TRUE(rr.WithReportBlock(rb));
602  rr.Append(&fir);
603
604  SenderReport sr;
605  sr.Append(&bye);
606  sr.Append(&rr);
607
608  rtc::scoped_ptr<RawPacket> packet(sr.Build());
609  RtcpPacketParser parser;
610  parser.Parse(packet->Buffer(), packet->Length());
611  EXPECT_EQ(1, parser.sender_report()->num_packets());
612  EXPECT_EQ(1, parser.receiver_report()->num_packets());
613  EXPECT_EQ(1, parser.report_block()->num_packets());
614  EXPECT_EQ(1, parser.bye()->num_packets());
615  EXPECT_EQ(1, parser.fir()->num_packets());
616}
617
618TEST(RtcpPacketTest, Bye) {
619  Bye bye;
620  bye.From(kSenderSsrc);
621
622  rtc::scoped_ptr<RawPacket> packet(bye.Build());
623  RtcpPacketParser parser;
624  parser.Parse(packet->Buffer(), packet->Length());
625  EXPECT_EQ(1, parser.bye()->num_packets());
626  EXPECT_EQ(kSenderSsrc, parser.bye()->Ssrc());
627}
628
629TEST(RtcpPacketTest, ByeWithCsrcs) {
630  Fir fir;
631  Bye bye;
632  bye.From(kSenderSsrc);
633  EXPECT_TRUE(bye.WithCsrc(0x22222222));
634  EXPECT_TRUE(bye.WithCsrc(0x33333333));
635  bye.Append(&fir);
636
637  rtc::scoped_ptr<RawPacket> packet(bye.Build());
638  RtcpPacketParser parser;
639  parser.Parse(packet->Buffer(), packet->Length());
640  EXPECT_EQ(1, parser.bye()->num_packets());
641  EXPECT_EQ(kSenderSsrc, parser.bye()->Ssrc());
642  EXPECT_EQ(1, parser.fir()->num_packets());
643}
644
645TEST(RtcpPacketTest, ByeWithTooManyCsrcs) {
646  Bye bye;
647  bye.From(kSenderSsrc);
648  const int kMaxCsrcs = (1 << 5) - 2;  // 5 bit len, first item is sender SSRC.
649  for (int i = 0; i < kMaxCsrcs; ++i) {
650    EXPECT_TRUE(bye.WithCsrc(i));
651  }
652  EXPECT_FALSE(bye.WithCsrc(kMaxCsrcs));
653}
654
655TEST(RtcpPacketTest, BuildWithInputBuffer) {
656  Fir fir;
657  ReportBlock rb;
658  ReceiverReport rr;
659  rr.From(kSenderSsrc);
660  EXPECT_TRUE(rr.WithReportBlock(rb));
661  rr.Append(&fir);
662
663  const size_t kRrLength = 8;
664  const size_t kReportBlockLength = 24;
665  const size_t kFirLength = 20;
666
667  class Verifier : public rtcp::RtcpPacket::PacketReadyCallback {
668   public:
669    void OnPacketReady(uint8_t* data, size_t length) override {
670      RtcpPacketParser parser;
671      parser.Parse(data, length);
672      EXPECT_EQ(1, parser.receiver_report()->num_packets());
673      EXPECT_EQ(1, parser.report_block()->num_packets());
674      EXPECT_EQ(1, parser.fir()->num_packets());
675      ++packets_created_;
676    }
677
678    int packets_created_ = 0;
679  } verifier;
680  const size_t kBufferSize = kRrLength + kReportBlockLength + kFirLength;
681  uint8_t buffer[kBufferSize];
682  EXPECT_TRUE(rr.BuildExternalBuffer(buffer, kBufferSize, &verifier));
683  EXPECT_EQ(1, verifier.packets_created_);
684}
685
686TEST(RtcpPacketTest, BuildWithTooSmallBuffer) {
687  ReportBlock rb;
688  ReceiverReport rr;
689  rr.From(kSenderSsrc);
690  EXPECT_TRUE(rr.WithReportBlock(rb));
691
692  const size_t kRrLength = 8;
693  const size_t kReportBlockLength = 24;
694
695  // No packet.
696  class Verifier : public rtcp::RtcpPacket::PacketReadyCallback {
697    void OnPacketReady(uint8_t* data, size_t length) override {
698      ADD_FAILURE() << "Packet should not fit within max size.";
699    }
700  } verifier;
701  const size_t kBufferSize = kRrLength + kReportBlockLength - 1;
702  uint8_t buffer[kBufferSize];
703  EXPECT_FALSE(rr.BuildExternalBuffer(buffer, kBufferSize, &verifier));
704}
705
706TEST(RtcpPacketTest, BuildWithTooSmallBuffer_FragmentedSend) {
707  Fir fir;
708  ReportBlock rb;
709  ReceiverReport rr;
710  rr.From(kSenderSsrc);
711  EXPECT_TRUE(rr.WithReportBlock(rb));
712  rr.Append(&fir);
713
714  const size_t kRrLength = 8;
715  const size_t kReportBlockLength = 24;
716
717  class Verifier : public rtcp::RtcpPacket::PacketReadyCallback {
718   public:
719    void OnPacketReady(uint8_t* data, size_t length) override {
720      RtcpPacketParser parser;
721      parser.Parse(data, length);
722      switch (packets_created_++) {
723        case 0:
724          EXPECT_EQ(1, parser.receiver_report()->num_packets());
725          EXPECT_EQ(1, parser.report_block()->num_packets());
726          EXPECT_EQ(0, parser.fir()->num_packets());
727          break;
728        case 1:
729          EXPECT_EQ(0, parser.receiver_report()->num_packets());
730          EXPECT_EQ(0, parser.report_block()->num_packets());
731          EXPECT_EQ(1, parser.fir()->num_packets());
732          break;
733        default:
734          ADD_FAILURE() << "OnPacketReady not expected to be called "
735                        << packets_created_ << " times.";
736      }
737    }
738
739    int packets_created_ = 0;
740  } verifier;
741  const size_t kBufferSize = kRrLength + kReportBlockLength;
742  uint8_t buffer[kBufferSize];
743  EXPECT_TRUE(rr.BuildExternalBuffer(buffer, kBufferSize, &verifier));
744  EXPECT_EQ(2, verifier.packets_created_);
745}
746
747TEST(RtcpPacketTest, Remb) {
748  Remb remb;
749  remb.From(kSenderSsrc);
750  remb.AppliesTo(kRemoteSsrc);
751  remb.AppliesTo(kRemoteSsrc + 1);
752  remb.AppliesTo(kRemoteSsrc + 2);
753  remb.WithBitrateBps(261011);
754
755  rtc::scoped_ptr<RawPacket> packet(remb.Build());
756  RtcpPacketParser parser;
757  parser.Parse(packet->Buffer(), packet->Length());
758  EXPECT_EQ(1, parser.psfb_app()->num_packets());
759  EXPECT_EQ(kSenderSsrc, parser.psfb_app()->Ssrc());
760  EXPECT_EQ(1, parser.remb_item()->num_packets());
761  EXPECT_EQ(261011, parser.remb_item()->last_bitrate_bps());
762  std::vector<uint32_t> ssrcs = parser.remb_item()->last_ssrc_list();
763  EXPECT_EQ(kRemoteSsrc, ssrcs[0]);
764  EXPECT_EQ(kRemoteSsrc + 1, ssrcs[1]);
765  EXPECT_EQ(kRemoteSsrc + 2, ssrcs[2]);
766}
767
768TEST(RtcpPacketTest, Tmmbr) {
769  Tmmbr tmmbr;
770  tmmbr.From(kSenderSsrc);
771  tmmbr.To(kRemoteSsrc);
772  tmmbr.WithBitrateKbps(312);
773  tmmbr.WithOverhead(60);
774
775  rtc::scoped_ptr<RawPacket> packet(tmmbr.Build());
776  RtcpPacketParser parser;
777  parser.Parse(packet->Buffer(), packet->Length());
778  EXPECT_EQ(1, parser.tmmbr()->num_packets());
779  EXPECT_EQ(kSenderSsrc, parser.tmmbr()->Ssrc());
780  EXPECT_EQ(1, parser.tmmbr_item()->num_packets());
781  EXPECT_EQ(312U, parser.tmmbr_item()->BitrateKbps());
782  EXPECT_EQ(60U, parser.tmmbr_item()->Overhead());
783}
784
785TEST(RtcpPacketTest, TmmbnWithNoItem) {
786  Tmmbn tmmbn;
787  tmmbn.From(kSenderSsrc);
788
789  rtc::scoped_ptr<RawPacket> packet(tmmbn.Build());
790  RtcpPacketParser parser;
791  parser.Parse(packet->Buffer(), packet->Length());
792  EXPECT_EQ(1, parser.tmmbn()->num_packets());
793  EXPECT_EQ(kSenderSsrc, parser.tmmbn()->Ssrc());
794  EXPECT_EQ(0, parser.tmmbn_items()->num_packets());
795}
796
797TEST(RtcpPacketTest, TmmbnWithOneItem) {
798  Tmmbn tmmbn;
799  tmmbn.From(kSenderSsrc);
800  EXPECT_TRUE(tmmbn.WithTmmbr(kRemoteSsrc, 312, 60));
801
802  rtc::scoped_ptr<RawPacket> packet(tmmbn.Build());
803  RtcpPacketParser parser;
804  parser.Parse(packet->Buffer(), packet->Length());
805  EXPECT_EQ(1, parser.tmmbn()->num_packets());
806  EXPECT_EQ(kSenderSsrc, parser.tmmbn()->Ssrc());
807  EXPECT_EQ(1, parser.tmmbn_items()->num_packets());
808  EXPECT_EQ(kRemoteSsrc, parser.tmmbn_items()->Ssrc(0));
809  EXPECT_EQ(312U, parser.tmmbn_items()->BitrateKbps(0));
810  EXPECT_EQ(60U, parser.tmmbn_items()->Overhead(0));
811}
812
813TEST(RtcpPacketTest, TmmbnWithTwoItems) {
814  Tmmbn tmmbn;
815  tmmbn.From(kSenderSsrc);
816  EXPECT_TRUE(tmmbn.WithTmmbr(kRemoteSsrc, 312, 60));
817  EXPECT_TRUE(tmmbn.WithTmmbr(kRemoteSsrc + 1, 1288, 40));
818
819  rtc::scoped_ptr<RawPacket> packet(tmmbn.Build());
820  RtcpPacketParser parser;
821  parser.Parse(packet->Buffer(), packet->Length());
822  EXPECT_EQ(1, parser.tmmbn()->num_packets());
823  EXPECT_EQ(kSenderSsrc, parser.tmmbn()->Ssrc());
824  EXPECT_EQ(2, parser.tmmbn_items()->num_packets());
825  EXPECT_EQ(kRemoteSsrc, parser.tmmbn_items()->Ssrc(0));
826  EXPECT_EQ(312U, parser.tmmbn_items()->BitrateKbps(0));
827  EXPECT_EQ(60U, parser.tmmbn_items()->Overhead(0));
828  EXPECT_EQ(kRemoteSsrc + 1, parser.tmmbn_items()->Ssrc(1));
829  EXPECT_EQ(1288U, parser.tmmbn_items()->BitrateKbps(1));
830  EXPECT_EQ(40U, parser.tmmbn_items()->Overhead(1));
831}
832
833TEST(RtcpPacketTest, TmmbnWithTooManyItems) {
834  Tmmbn tmmbn;
835  tmmbn.From(kSenderSsrc);
836  const int kMaxTmmbrItems = 50;
837  for (int i = 0; i < kMaxTmmbrItems; ++i)
838    EXPECT_TRUE(tmmbn.WithTmmbr(kRemoteSsrc + i, 312, 60));
839
840  EXPECT_FALSE(tmmbn.WithTmmbr(kRemoteSsrc + kMaxTmmbrItems, 312, 60));
841}
842
843TEST(RtcpPacketTest, XrWithNoReportBlocks) {
844  Xr xr;
845  xr.From(kSenderSsrc);
846
847  rtc::scoped_ptr<RawPacket> packet(xr.Build());
848  RtcpPacketParser parser;
849  parser.Parse(packet->Buffer(), packet->Length());
850  EXPECT_EQ(1, parser.xr_header()->num_packets());
851  EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
852}
853
854TEST(RtcpPacketTest, XrWithRrtr) {
855  Rrtr rrtr;
856  rrtr.WithNtpSec(0x11111111);
857  rrtr.WithNtpFrac(0x22222222);
858  Xr xr;
859  xr.From(kSenderSsrc);
860  EXPECT_TRUE(xr.WithRrtr(&rrtr));
861
862  rtc::scoped_ptr<RawPacket> packet(xr.Build());
863  RtcpPacketParser parser;
864  parser.Parse(packet->Buffer(), packet->Length());
865  EXPECT_EQ(1, parser.xr_header()->num_packets());
866  EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
867  EXPECT_EQ(1, parser.rrtr()->num_packets());
868  EXPECT_EQ(0x11111111U, parser.rrtr()->NtpSec());
869  EXPECT_EQ(0x22222222U, parser.rrtr()->NtpFrac());
870}
871
872TEST(RtcpPacketTest, XrWithTwoRrtrBlocks) {
873  Rrtr rrtr1;
874  rrtr1.WithNtpSec(0x11111111);
875  rrtr1.WithNtpFrac(0x22222222);
876  Rrtr rrtr2;
877  rrtr2.WithNtpSec(0x33333333);
878  rrtr2.WithNtpFrac(0x44444444);
879  Xr xr;
880  xr.From(kSenderSsrc);
881  EXPECT_TRUE(xr.WithRrtr(&rrtr1));
882  EXPECT_TRUE(xr.WithRrtr(&rrtr2));
883
884  rtc::scoped_ptr<RawPacket> packet(xr.Build());
885  RtcpPacketParser parser;
886  parser.Parse(packet->Buffer(), packet->Length());
887  EXPECT_EQ(1, parser.xr_header()->num_packets());
888  EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
889  EXPECT_EQ(2, parser.rrtr()->num_packets());
890  EXPECT_EQ(0x33333333U, parser.rrtr()->NtpSec());
891  EXPECT_EQ(0x44444444U, parser.rrtr()->NtpFrac());
892}
893
894TEST(RtcpPacketTest, XrWithDlrrWithOneSubBlock) {
895  Dlrr dlrr;
896  EXPECT_TRUE(dlrr.WithDlrrItem(0x11111111, 0x22222222, 0x33333333));
897  Xr xr;
898  xr.From(kSenderSsrc);
899  EXPECT_TRUE(xr.WithDlrr(&dlrr));
900
901  rtc::scoped_ptr<RawPacket> packet(xr.Build());
902  RtcpPacketParser parser;
903  parser.Parse(packet->Buffer(), packet->Length());
904  EXPECT_EQ(1, parser.xr_header()->num_packets());
905  EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
906  EXPECT_EQ(1, parser.dlrr()->num_packets());
907  EXPECT_EQ(1, parser.dlrr_items()->num_packets());
908  EXPECT_EQ(0x11111111U, parser.dlrr_items()->Ssrc(0));
909  EXPECT_EQ(0x22222222U, parser.dlrr_items()->LastRr(0));
910  EXPECT_EQ(0x33333333U, parser.dlrr_items()->DelayLastRr(0));
911}
912
913TEST(RtcpPacketTest, XrWithDlrrWithTwoSubBlocks) {
914  Dlrr dlrr;
915  EXPECT_TRUE(dlrr.WithDlrrItem(0x11111111, 0x22222222, 0x33333333));
916  EXPECT_TRUE(dlrr.WithDlrrItem(0x44444444, 0x55555555, 0x66666666));
917  Xr xr;
918  xr.From(kSenderSsrc);
919  EXPECT_TRUE(xr.WithDlrr(&dlrr));
920
921  rtc::scoped_ptr<RawPacket> packet(xr.Build());
922  RtcpPacketParser parser;
923  parser.Parse(packet->Buffer(), packet->Length());
924  EXPECT_EQ(1, parser.xr_header()->num_packets());
925  EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
926  EXPECT_EQ(1, parser.dlrr()->num_packets());
927  EXPECT_EQ(2, parser.dlrr_items()->num_packets());
928  EXPECT_EQ(0x11111111U, parser.dlrr_items()->Ssrc(0));
929  EXPECT_EQ(0x22222222U, parser.dlrr_items()->LastRr(0));
930  EXPECT_EQ(0x33333333U, parser.dlrr_items()->DelayLastRr(0));
931  EXPECT_EQ(0x44444444U, parser.dlrr_items()->Ssrc(1));
932  EXPECT_EQ(0x55555555U, parser.dlrr_items()->LastRr(1));
933  EXPECT_EQ(0x66666666U, parser.dlrr_items()->DelayLastRr(1));
934}
935
936TEST(RtcpPacketTest, DlrrWithTooManySubBlocks) {
937  const int kMaxItems = 100;
938  Dlrr dlrr;
939  for (int i = 0; i < kMaxItems; ++i)
940    EXPECT_TRUE(dlrr.WithDlrrItem(i, i, i));
941  EXPECT_FALSE(dlrr.WithDlrrItem(kMaxItems, kMaxItems, kMaxItems));
942}
943
944TEST(RtcpPacketTest, XrWithTwoDlrrBlocks) {
945  Dlrr dlrr1;
946  EXPECT_TRUE(dlrr1.WithDlrrItem(0x11111111, 0x22222222, 0x33333333));
947  Dlrr dlrr2;
948  EXPECT_TRUE(dlrr2.WithDlrrItem(0x44444444, 0x55555555, 0x66666666));
949  Xr xr;
950  xr.From(kSenderSsrc);
951  EXPECT_TRUE(xr.WithDlrr(&dlrr1));
952  EXPECT_TRUE(xr.WithDlrr(&dlrr2));
953
954  rtc::scoped_ptr<RawPacket> packet(xr.Build());
955  RtcpPacketParser parser;
956  parser.Parse(packet->Buffer(), packet->Length());
957  EXPECT_EQ(1, parser.xr_header()->num_packets());
958  EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
959  EXPECT_EQ(2, parser.dlrr()->num_packets());
960  EXPECT_EQ(2, parser.dlrr_items()->num_packets());
961  EXPECT_EQ(0x11111111U, parser.dlrr_items()->Ssrc(0));
962  EXPECT_EQ(0x22222222U, parser.dlrr_items()->LastRr(0));
963  EXPECT_EQ(0x33333333U, parser.dlrr_items()->DelayLastRr(0));
964  EXPECT_EQ(0x44444444U, parser.dlrr_items()->Ssrc(1));
965  EXPECT_EQ(0x55555555U, parser.dlrr_items()->LastRr(1));
966  EXPECT_EQ(0x66666666U, parser.dlrr_items()->DelayLastRr(1));
967}
968
969TEST(RtcpPacketTest, XrWithVoipMetric) {
970  VoipMetric metric;
971  metric.To(kRemoteSsrc);
972  metric.LossRate(1);
973  metric.DiscardRate(2);
974  metric.BurstDensity(3);
975  metric.GapDensity(4);
976  metric.BurstDuration(0x1111);
977  metric.GapDuration(0x2222);
978  metric.RoundTripDelay(0x3333);
979  metric.EndSystemDelay(0x4444);
980  metric.SignalLevel(5);
981  metric.NoiseLevel(6);
982  metric.Rerl(7);
983  metric.Gmin(8);
984  metric.Rfactor(9);
985  metric.ExtRfactor(10);
986  metric.MosLq(11);
987  metric.MosCq(12);
988  metric.RxConfig(13);
989  metric.JbNominal(0x5555);
990  metric.JbMax(0x6666);
991  metric.JbAbsMax(0x7777);
992
993  Xr xr;
994  xr.From(kSenderSsrc);
995  EXPECT_TRUE(xr.WithVoipMetric(&metric));
996
997  rtc::scoped_ptr<RawPacket> packet(xr.Build());
998  RtcpPacketParser parser;
999  parser.Parse(packet->Buffer(), packet->Length());
1000  EXPECT_EQ(1, parser.xr_header()->num_packets());
1001  EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
1002  EXPECT_EQ(1, parser.voip_metric()->num_packets());
1003  EXPECT_EQ(kRemoteSsrc, parser.voip_metric()->Ssrc());
1004  EXPECT_EQ(1, parser.voip_metric()->LossRate());
1005  EXPECT_EQ(2, parser.voip_metric()->DiscardRate());
1006  EXPECT_EQ(3, parser.voip_metric()->BurstDensity());
1007  EXPECT_EQ(4, parser.voip_metric()->GapDensity());
1008  EXPECT_EQ(0x1111, parser.voip_metric()->BurstDuration());
1009  EXPECT_EQ(0x2222, parser.voip_metric()->GapDuration());
1010  EXPECT_EQ(0x3333, parser.voip_metric()->RoundTripDelay());
1011  EXPECT_EQ(0x4444, parser.voip_metric()->EndSystemDelay());
1012  EXPECT_EQ(5, parser.voip_metric()->SignalLevel());
1013  EXPECT_EQ(6, parser.voip_metric()->NoiseLevel());
1014  EXPECT_EQ(7, parser.voip_metric()->Rerl());
1015  EXPECT_EQ(8, parser.voip_metric()->Gmin());
1016  EXPECT_EQ(9, parser.voip_metric()->Rfactor());
1017  EXPECT_EQ(10, parser.voip_metric()->ExtRfactor());
1018  EXPECT_EQ(11, parser.voip_metric()->MosLq());
1019  EXPECT_EQ(12, parser.voip_metric()->MosCq());
1020  EXPECT_EQ(13, parser.voip_metric()->RxConfig());
1021  EXPECT_EQ(0x5555, parser.voip_metric()->JbNominal());
1022  EXPECT_EQ(0x6666, parser.voip_metric()->JbMax());
1023  EXPECT_EQ(0x7777, parser.voip_metric()->JbAbsMax());
1024}
1025
1026TEST(RtcpPacketTest, XrWithMultipleReportBlocks) {
1027  Rrtr rrtr;
1028  Dlrr dlrr;
1029  EXPECT_TRUE(dlrr.WithDlrrItem(1, 2, 3));
1030  VoipMetric metric;
1031  Xr xr;
1032  xr.From(kSenderSsrc);
1033  EXPECT_TRUE(xr.WithRrtr(&rrtr));
1034  EXPECT_TRUE(xr.WithDlrr(&dlrr));
1035  EXPECT_TRUE(xr.WithVoipMetric(&metric));
1036
1037  rtc::scoped_ptr<RawPacket> packet(xr.Build());
1038  RtcpPacketParser parser;
1039  parser.Parse(packet->Buffer(), packet->Length());
1040  EXPECT_EQ(1, parser.xr_header()->num_packets());
1041  EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
1042  EXPECT_EQ(1, parser.rrtr()->num_packets());
1043  EXPECT_EQ(1, parser.dlrr()->num_packets());
1044  EXPECT_EQ(1, parser.dlrr_items()->num_packets());
1045  EXPECT_EQ(1, parser.voip_metric()->num_packets());
1046}
1047
1048TEST(RtcpPacketTest, DlrrWithoutItemNotIncludedInPacket) {
1049  Rrtr rrtr;
1050  Dlrr dlrr;
1051  VoipMetric metric;
1052  Xr xr;
1053  xr.From(kSenderSsrc);
1054  EXPECT_TRUE(xr.WithRrtr(&rrtr));
1055  EXPECT_TRUE(xr.WithDlrr(&dlrr));
1056  EXPECT_TRUE(xr.WithVoipMetric(&metric));
1057
1058  rtc::scoped_ptr<RawPacket> packet(xr.Build());
1059  RtcpPacketParser parser;
1060  parser.Parse(packet->Buffer(), packet->Length());
1061  EXPECT_EQ(1, parser.xr_header()->num_packets());
1062  EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
1063  EXPECT_EQ(1, parser.rrtr()->num_packets());
1064  EXPECT_EQ(0, parser.dlrr()->num_packets());
1065  EXPECT_EQ(1, parser.voip_metric()->num_packets());
1066}
1067
1068TEST(RtcpPacketTest, XrWithTooManyBlocks) {
1069  const int kMaxBlocks = 50;
1070  Xr xr;
1071
1072  Rrtr rrtr;
1073  for (int i = 0; i < kMaxBlocks; ++i)
1074    EXPECT_TRUE(xr.WithRrtr(&rrtr));
1075  EXPECT_FALSE(xr.WithRrtr(&rrtr));
1076
1077  Dlrr dlrr;
1078  for (int i = 0; i < kMaxBlocks; ++i)
1079    EXPECT_TRUE(xr.WithDlrr(&dlrr));
1080  EXPECT_FALSE(xr.WithDlrr(&dlrr));
1081
1082  VoipMetric voip_metric;
1083  for (int i = 0; i < kMaxBlocks; ++i)
1084    EXPECT_TRUE(xr.WithVoipMetric(&voip_metric));
1085  EXPECT_FALSE(xr.WithVoipMetric(&voip_metric));
1086}
1087
1088}  // namespace webrtc
1089