RTCStatsCollectorTest: Remove ExpectReportContainsDataChannel.

webrtc/api/rtcstatscollector_unittest.cc

 /*
  *  Copyright 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.
  */
 
@@ skipping 521 matching lines @@
       EXPECT_EQ(*cert_stats.base64_certificate, cert_info.pems[i]);
       if (i + 1 < cert_info.fingerprints.size()) {
         EXPECT_EQ(*cert_stats.issuer_certificate_id,
                   "RTCCertificate_" + cert_info.fingerprints[i + 1]);
       } else {
         EXPECT_FALSE(cert_stats.issuer_certificate_id.is_defined());
       }
     }
   }
 
-  void ExpectReportContainsDataChannel(
-      const rtc::scoped_refptr<const RTCStatsReport>& report,
-      const DataChannel& data_channel) {
-    const RTCStats* stats = report->Get("RTCDataChannel_" +
-                                        rtc::ToString<>(data_channel.id()));
-    EXPECT_TRUE(stats);
-    const RTCDataChannelStats& data_channel_stats =
-        stats->cast_to<const RTCDataChannelStats>();
-    EXPECT_EQ(*data_channel_stats.label, data_channel.label());
-    EXPECT_EQ(*data_channel_stats.protocol, data_channel.protocol());
-    EXPECT_EQ(*data_channel_stats.datachannelid, data_channel.id());
-    EXPECT_EQ(*data_channel_stats.state,
-        DataStateToRTCDataChannelStateForTesting(data_channel.state()));
-    EXPECT_EQ(*data_channel_stats.messages_sent, data_channel.messages_sent());
-    EXPECT_EQ(*data_channel_stats.bytes_sent, data_channel.bytes_sent());
-    EXPECT_EQ(*data_channel_stats.messages_received,
-              data_channel.messages_received());
-    EXPECT_EQ(*data_channel_stats.bytes_received,
-              data_channel.bytes_received());
-  }
-
  protected:
   rtc::scoped_refptr<RTCStatsCollectorTestHelper> test_;
   rtc::scoped_refptr<RTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTest, SingleCallback) {
   rtc::scoped_refptr<const RTCStatsReport> result;
   collector_->GetStatsReport(RTCStatsObtainer::Create(&result));
   EXPECT_TRUE_WAIT(result, kGetStatsReportTimeoutMs);
 }
@@ skipping 304 matching lines @@
         return static_cast<rtc::SSLCertificate*>(nullptr);
       }));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
   ExpectReportContainsCertificateInfo(report, *local_certinfo.get());
   ExpectReportContainsCertificateInfo(report, *remote_certinfo.get());
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
   test_->data_channels().push_back(
-      new MockDataChannel(0, DataChannelInterface::kConnecting));
+      new MockDataChannel(
+          0, "MockDataChannel0", DataChannelInterface::kConnecting, "udp",
+          1, 2, 3, 4));
+  RTCDataChannelStats expected_data_channel0("RTCDataChannel_0", 0);
+  expected_data_channel0.label = "MockDataChannel0";
+  expected_data_channel0.protocol = "udp";
+  expected_data_channel0.datachannelid = 0;
+  expected_data_channel0.state = "connecting";
+  expected_data_channel0.messages_sent = 1;
+  expected_data_channel0.bytes_sent = 2;
+  expected_data_channel0.messages_received = 3;
+  expected_data_channel0.bytes_received = 4;
+
   test_->data_channels().push_back(
-      new MockDataChannel(1, DataChannelInterface::kOpen));
+      new MockDataChannel(
+          1, "MockDataChannel1", DataChannelInterface::kOpen, "tcp",
+          5, 6, 7, 8));
+  RTCDataChannelStats expected_data_channel1("RTCDataChannel_1", 0);
+  expected_data_channel1.label = "MockDataChannel1";
+  expected_data_channel1.protocol = "tcp";
+  expected_data_channel1.datachannelid = 1;
+  expected_data_channel1.state = "open";
+  expected_data_channel1.messages_sent = 5;
+  expected_data_channel1.bytes_sent = 6;
+  expected_data_channel1.messages_received = 7;
+  expected_data_channel1.bytes_received = 8;
+
   test_->data_channels().push_back(
-      new MockDataChannel(2, DataChannelInterface::kClosing));
+      new MockDataChannel(
+          2, "MockDataChannel2", DataChannelInterface::kClosing, "udp",
+          9, 10, 11, 12));
+  RTCDataChannelStats expected_data_channel2("RTCDataChannel_2", 0);
+  expected_data_channel2.label = "MockDataChannel2";
+  expected_data_channel2.protocol = "udp";
+  expected_data_channel2.datachannelid = 2;
+  expected_data_channel2.state = "closing";
+  expected_data_channel2.messages_sent = 9;
+  expected_data_channel2.bytes_sent = 10;
+  expected_data_channel2.messages_received = 11;
+  expected_data_channel2.bytes_received = 12;
+
   test_->data_channels().push_back(
-      new MockDataChannel(3, DataChannelInterface::kClosed));
+      new MockDataChannel(
+          3, "MockDataChannel3", DataChannelInterface::kClosed, "tcp",
+          13, 14, 15, 16));
+  RTCDataChannelStats expected_data_channel3("RTCDataChannel_3", 0);
+  expected_data_channel3.label = "MockDataChannel3";
+  expected_data_channel3.protocol = "tcp";
+  expected_data_channel3.datachannelid = 3;
+  expected_data_channel3.state = "closed";
+  expected_data_channel3.messages_sent = 13;
+  expected_data_channel3.bytes_sent = 14;
+  expected_data_channel3.messages_received = 15;
+  expected_data_channel3.bytes_received = 16;
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
-  ExpectReportContainsDataChannel(report, *test_->data_channels()[0]);
-  ExpectReportContainsDataChannel(report, *test_->data_channels()[1]);
-  ExpectReportContainsDataChannel(report, *test_->data_channels()[2]);
-  ExpectReportContainsDataChannel(report, *test_->data_channels()[3]);
-
-  test_->data_channels().clear();
-  test_->data_channels().push_back(
-      new MockDataChannel(0, DataChannelInterface::kConnecting,
-                          1, 2, 3, 4));
-  test_->data_channels().push_back(
-      new MockDataChannel(1, DataChannelInterface::kOpen,
-                          5, 6, 7, 8));
-  test_->data_channels().push_back(
-      new MockDataChannel(2, DataChannelInterface::kClosing,
-                          9, 10, 11, 12));
-  test_->data_channels().push_back(
-      new MockDataChannel(3, DataChannelInterface::kClosed,
-                          13, 14, 15, 16));
-
-  collector_->ClearCachedStatsReport();
-  report = GetStatsReport();
-  ExpectReportContainsDataChannel(report, *test_->data_channels()[0]);
-  ExpectReportContainsDataChannel(report, *test_->data_channels()[1]);
-  ExpectReportContainsDataChannel(report, *test_->data_channels()[2]);
-  ExpectReportContainsDataChannel(report, *test_->data_channels()[3]);
+  ASSERT_TRUE(report->Get(expected_data_channel0.id()));
+  EXPECT_EQ(expected_data_channel0,
+            report->Get(expected_data_channel0.id())->cast_to<
+                RTCDataChannelStats>());
+  ASSERT_TRUE(report->Get(expected_data_channel1.id()));
+  EXPECT_EQ(expected_data_channel1,
+            report->Get(expected_data_channel1.id())->cast_to<
+                RTCDataChannelStats>());
+  ASSERT_TRUE(report->Get(expected_data_channel2.id()));
+  EXPECT_EQ(expected_data_channel2,
+            report->Get(expected_data_channel2.id())->cast_to<
+                RTCDataChannelStats>());
+  ASSERT_TRUE(report->Get(expected_data_channel3.id()));
+  EXPECT_EQ(expected_data_channel3,
+            report->Get(expected_data_channel3.id())->cast_to<
+                RTCDataChannelStats>());
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidateStats) {
   // Candidates in the first transport stats.
   std::unique_ptr<cricket::Candidate> a_local_host = CreateFakeCandidate(
       "1.2.3.4", 5,
       "a_local_host's protocol",
       cricket::LOCAL_PORT_TYPE,
       0);
   std::unique_ptr<cricket::Candidate> a_remote_srflx = CreateFakeCandidate(
@@ skipping 115 matching lines @@
   expected_pair.writable = true;
   expected_pair.bytes_sent = 42;
   expected_pair.bytes_received = 1234;
   expected_pair.current_round_trip_time = 1.337;
   expected_pair.requests_received = 2020;
   expected_pair.requests_sent = 2000;
   expected_pair.responses_received = 4321;
   expected_pair.responses_sent = 1000;
   expected_pair.consent_requests_sent = (2020 - 2000);
 
-  EXPECT_TRUE(report->Get(expected_pair.id()));
+  ASSERT_TRUE(report->Get(expected_pair.id()));
   EXPECT_EQ(
       expected_pair,
       report->Get(expected_pair.id())->cast_to<RTCIceCandidatePairStats>());
 
-  EXPECT_TRUE(report->Get(*expected_pair.local_candidate_id));
+  ASSERT_TRUE(report->Get(*expected_pair.local_candidate_id));
   ExpectReportContainsCandidate(report, connection_info.local_candidate, true);
-  EXPECT_TRUE(report->Get(*expected_pair.remote_candidate_id));
+  ASSERT_TRUE(report->Get(*expected_pair.remote_candidate_id));
   ExpectReportContainsCandidate(report, connection_info.remote_candidate,
                                 false);
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCPeerConnectionStats) {
   {
     rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
     RTCPeerConnectionStats expected("RTCPeerConnection",
                                     report->timestamp_us());
     expected.data_channels_opened = 0;
     expected.data_channels_closed = 0;
-    EXPECT_TRUE(report->Get("RTCPeerConnection"));
+    ASSERT_TRUE(report->Get("RTCPeerConnection"));
     EXPECT_EQ(expected,
               report->Get("RTCPeerConnection")->cast_to<
                   RTCPeerConnectionStats>());
   }
 
   rtc::scoped_refptr<DataChannel> dummy_channel_a = DataChannel::Create(
       nullptr, cricket::DCT_NONE, "DummyChannelA", InternalDataChannelInit());
   test_->pc().SignalDataChannelCreated(dummy_channel_a.get());
   rtc::scoped_refptr<DataChannel> dummy_channel_b = DataChannel::Create(
       nullptr, cricket::DCT_NONE, "DummyChannelB", InternalDataChannelInit());
   test_->pc().SignalDataChannelCreated(dummy_channel_b.get());
 
   dummy_channel_a->SignalOpened(dummy_channel_a.get());
   // Closing a channel that is not opened should not affect the counts.
   dummy_channel_b->SignalClosed(dummy_channel_b.get());
 
   {
     collector_->ClearCachedStatsReport();
     rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
     RTCPeerConnectionStats expected("RTCPeerConnection",
                                     report->timestamp_us());
     expected.data_channels_opened = 1;
     expected.data_channels_closed = 0;
-    EXPECT_TRUE(report->Get("RTCPeerConnection"));
+    ASSERT_TRUE(report->Get("RTCPeerConnection"));
     EXPECT_EQ(expected,
               report->Get("RTCPeerConnection")->cast_to<
                   RTCPeerConnectionStats>());
   }
 
   dummy_channel_b->SignalOpened(dummy_channel_b.get());
   dummy_channel_b->SignalClosed(dummy_channel_b.get());
 
   {
     collector_->ClearCachedStatsReport();
     rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
     RTCPeerConnectionStats expected("RTCPeerConnection",
                                     report->timestamp_us());
     expected.data_channels_opened = 2;
     expected.data_channels_closed = 1;
-    EXPECT_TRUE(report->Get("RTCPeerConnection"));
+    ASSERT_TRUE(report->Get("RTCPeerConnection"));
     EXPECT_EQ(expected,
               report->Get("RTCPeerConnection")->cast_to<
                   RTCPeerConnectionStats>());
   }
 }
 
 TEST_F(RTCStatsCollectorTest,
        CollectRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Audio) {
   rtc::scoped_refptr<StreamCollection> local_streams =
       StreamCollection::Create();
@@ skipping 36 matching lines @@
   remote_stream->AddTrack(remote_audio_track);
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
 
   RTCMediaStreamStats expected_local_stream(
       "RTCMediaStream_LocalStreamLabel", report->timestamp_us());
   expected_local_stream.stream_identifier = local_stream->label();
   expected_local_stream.track_ids = std::vector<std::string>();
   expected_local_stream.track_ids->push_back(
       "RTCMediaStreamTrack_LocalAudioTrackID");
-  EXPECT_TRUE(report->Get(expected_local_stream.id()));
+  ASSERT_TRUE(report->Get(expected_local_stream.id()));
   EXPECT_EQ(expected_local_stream,
             report->Get(expected_local_stream.id())->cast_to<
                 RTCMediaStreamStats>());
 
   RTCMediaStreamStats expected_remote_stream(
       "RTCMediaStream_RemoteStreamLabel", report->timestamp_us());
   expected_remote_stream.stream_identifier = remote_stream->label();
   expected_remote_stream.track_ids = std::vector<std::string>();
   expected_remote_stream.track_ids->push_back(
       "RTCMediaStreamTrack_RemoteAudioTrackID");
-  EXPECT_TRUE(report->Get(expected_remote_stream.id()));
+  ASSERT_TRUE(report->Get(expected_remote_stream.id()));
   EXPECT_EQ(expected_remote_stream,
             report->Get(expected_remote_stream.id())->cast_to<
                 RTCMediaStreamStats>());
 
   RTCMediaStreamTrackStats expected_local_audio_track(
       "RTCMediaStreamTrack_LocalAudioTrackID", report->timestamp_us());
   expected_local_audio_track.track_identifier = local_audio_track->id();
   expected_local_audio_track.remote_source = false;
   expected_local_audio_track.ended = true;
   expected_local_audio_track.detached = false;
   expected_local_audio_track.audio_level = 1.0;
   expected_local_audio_track.echo_return_loss = 42.0;
   expected_local_audio_track.echo_return_loss_enhancement = 52.0;
-  EXPECT_TRUE(report->Get(expected_local_audio_track.id()));
+  ASSERT_TRUE(report->Get(expected_local_audio_track.id()));
   EXPECT_EQ(expected_local_audio_track,
             report->Get(expected_local_audio_track.id())->cast_to<
                 RTCMediaStreamTrackStats>());
 
   RTCMediaStreamTrackStats expected_remote_audio_track(
       "RTCMediaStreamTrack_RemoteAudioTrackID", report->timestamp_us());
   expected_remote_audio_track.track_identifier = remote_audio_track->id();
   expected_remote_audio_track.remote_source = true;
   expected_remote_audio_track.ended = false;
   expected_remote_audio_track.detached = false;
   expected_remote_audio_track.audio_level = 0.0;
   expected_remote_audio_track.echo_return_loss = 13.0;
   expected_remote_audio_track.echo_return_loss_enhancement = 37.0;
-  EXPECT_TRUE(report->Get(expected_remote_audio_track.id()));
+  ASSERT_TRUE(report->Get(expected_remote_audio_track.id()));
   EXPECT_EQ(expected_remote_audio_track,
             report->Get(expected_remote_audio_track.id())->cast_to<
                 RTCMediaStreamTrackStats>());
 }
 
 TEST_F(RTCStatsCollectorTest,
        CollectRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Audio_Defaults) {
   rtc::scoped_refptr<StreamCollection> local_streams =
       StreamCollection::Create();
   EXPECT_CALL(test_->pc(), local_streams())
@@ skipping 19 matching lines @@
 
   RTCMediaStreamTrackStats expected_local_audio_track(
       "RTCMediaStreamTrack_LocalAudioTrackID", report->timestamp_us());
   expected_local_audio_track.track_identifier = local_audio_track->id();
   expected_local_audio_track.remote_source = false;
   expected_local_audio_track.ended = true;
   expected_local_audio_track.detached = false;
   expected_local_audio_track.audio_level = 1.0;
   // Should be undefined: |expected_local_audio_track.echo_return_loss| and
   // |expected_local_audio_track.echo_return_loss_enhancement|.
-  EXPECT_TRUE(report->Get(expected_local_audio_track.id()));
+  ASSERT_TRUE(report->Get(expected_local_audio_track.id()));
   EXPECT_EQ(expected_local_audio_track,
             report->Get(expected_local_audio_track.id())->cast_to<
                 RTCMediaStreamTrackStats>());
 }
 
 TEST_F(RTCStatsCollectorTest,
        CollectRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Video) {
   rtc::scoped_refptr<StreamCollection> local_streams =
       StreamCollection::Create();
   rtc::scoped_refptr<StreamCollection> remote_streams =
@@ skipping 37 matching lines @@
   remote_stream->AddTrack(remote_video_track);
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
 
   RTCMediaStreamStats expected_local_stream(
       "RTCMediaStream_LocalStreamLabel", report->timestamp_us());
   expected_local_stream.stream_identifier = local_stream->label();
   expected_local_stream.track_ids = std::vector<std::string>();
   expected_local_stream.track_ids->push_back(
       "RTCMediaStreamTrack_LocalVideoTrackID");
-  EXPECT_TRUE(report->Get(expected_local_stream.id()));
+  ASSERT_TRUE(report->Get(expected_local_stream.id()));
   EXPECT_EQ(expected_local_stream,
             report->Get(expected_local_stream.id())->cast_to<
                 RTCMediaStreamStats>());
 
   RTCMediaStreamStats expected_remote_stream(
       "RTCMediaStream_RemoteStreamLabel", report->timestamp_us());
   expected_remote_stream.stream_identifier = remote_stream->label();
   expected_remote_stream.track_ids = std::vector<std::string>();
   expected_remote_stream.track_ids->push_back(
       "RTCMediaStreamTrack_RemoteVideoTrackID");
-  EXPECT_TRUE(report->Get(expected_remote_stream.id()));
+  ASSERT_TRUE(report->Get(expected_remote_stream.id()));
   EXPECT_EQ(expected_remote_stream,
             report->Get(expected_remote_stream.id())->cast_to<
                 RTCMediaStreamStats>());
 
   RTCMediaStreamTrackStats expected_local_video_track(
       "RTCMediaStreamTrack_LocalVideoTrackID", report->timestamp_us());
   expected_local_video_track.track_identifier = local_video_track->id();
   expected_local_video_track.remote_source = false;
   expected_local_video_track.ended = false;
   expected_local_video_track.detached = false;
   expected_local_video_track.frame_width = 1234;
   expected_local_video_track.frame_height = 4321;
-  EXPECT_TRUE(report->Get(expected_local_video_track.id()));
+  ASSERT_TRUE(report->Get(expected_local_video_track.id()));
   EXPECT_EQ(expected_local_video_track,
             report->Get(expected_local_video_track.id())->cast_to<
                 RTCMediaStreamTrackStats>());
 
   RTCMediaStreamTrackStats expected_remote_video_track(
       "RTCMediaStreamTrack_RemoteVideoTrackID", report->timestamp_us());
   expected_remote_video_track.track_identifier = remote_video_track->id();
   expected_remote_video_track.remote_source = true;
   expected_remote_video_track.ended = true;
   expected_remote_video_track.detached = false;
   expected_remote_video_track.frame_width = 1234;
   expected_remote_video_track.frame_height = 4321;
-  EXPECT_TRUE(report->Get(expected_remote_video_track.id()));
+  ASSERT_TRUE(report->Get(expected_remote_video_track.id()));
   EXPECT_EQ(expected_remote_video_track,
             report->Get(expected_remote_video_track.id())->cast_to<
                 RTCMediaStreamTrackStats>());
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Audio) {
   MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
   cricket::VoiceChannel voice_channel(
       test_->worker_thread(), test_->network_thread(), test_->media_engine(),
       voice_media_channel, nullptr, "VoiceContentName", kDefaultRtcpEnabled,
@@ skipping 54 matching lines @@
   expected_audio.bytes_received = 3;
   expected_audio.packets_lost = 42;
   expected_audio.jitter = 4.5;
   expected_audio.fraction_lost = 5.5;
 
   ASSERT(report->Get(expected_audio.id()));
   const RTCInboundRTPStreamStats& audio = report->Get(
       expected_audio.id())->cast_to<RTCInboundRTPStreamStats>();
   EXPECT_EQ(audio, expected_audio);
 
-  EXPECT_TRUE(report->Get(*expected_audio.transport_id));
-  EXPECT_TRUE(report->Get(*expected_audio.codec_id));
+  ASSERT_TRUE(report->Get(*expected_audio.transport_id));
+  ASSERT_TRUE(report->Get(*expected_audio.codec_id));
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Video) {
   MockVideoMediaChannel* video_media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(
       test_->worker_thread(), test_->network_thread(), video_media_channel,
       nullptr, "VideoContentName", kDefaultRtcpEnabled, kDefaultSrtpRequired);
 
   cricket::VideoMediaInfo video_media_info;
 
@@ skipping 54 matching lines @@
   expected_video.packets_received = 2;
   expected_video.bytes_received = 3;
   expected_video.packets_lost = 42;
   expected_video.fraction_lost = 4.5;
 
   ASSERT(report->Get(expected_video.id()));
   const RTCInboundRTPStreamStats& video = report->Get(
       expected_video.id())->cast_to<RTCInboundRTPStreamStats>();
   EXPECT_EQ(video, expected_video);
 
-  EXPECT_TRUE(report->Get(*expected_video.transport_id));
-  EXPECT_TRUE(report->Get(*video.codec_id));
+  ASSERT_TRUE(report->Get(*expected_video.transport_id));
+  ASSERT_TRUE(report->Get(*video.codec_id));
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Audio) {
   MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
   cricket::VoiceChannel voice_channel(
       test_->worker_thread(), test_->network_thread(), test_->media_engine(),
       voice_media_channel, nullptr, "VoiceContentName", kDefaultRtcpEnabled,
       kDefaultSrtpRequired);
 
   cricket::VoiceMediaInfo voice_media_info;
@@ skipping 46 matching lines @@
   expected_audio.codec_id = "RTCCodec_OutboundAudio_42";
   expected_audio.packets_sent = 2;
   expected_audio.bytes_sent = 3;
   expected_audio.round_trip_time = 4.5;
 
   ASSERT(report->Get(expected_audio.id()));
   const RTCOutboundRTPStreamStats& audio = report->Get(
       expected_audio.id())->cast_to<RTCOutboundRTPStreamStats>();
   EXPECT_EQ(audio, expected_audio);
 
-  EXPECT_TRUE(report->Get(*expected_audio.transport_id));
-  EXPECT_TRUE(report->Get(*expected_audio.codec_id));
+  ASSERT_TRUE(report->Get(*expected_audio.transport_id));
+  ASSERT_TRUE(report->Get(*expected_audio.codec_id));
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Video) {
   MockVideoMediaChannel* video_media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(
       test_->worker_thread(), test_->network_thread(), video_media_channel,
       nullptr, "VideoContentName", kDefaultRtcpEnabled, kDefaultSrtpRequired);
 
   cricket::VideoMediaInfo video_media_info;
 
@@ skipping 51 matching lines @@
   expected_video.nack_count = 4;
   expected_video.packets_sent = 5;
   expected_video.bytes_sent = 6;
   expected_video.round_trip_time = 7.5;
 
   ASSERT(report->Get(expected_video.id()));
   const RTCOutboundRTPStreamStats& video = report->Get(
       expected_video.id())->cast_to<RTCOutboundRTPStreamStats>();
   EXPECT_EQ(video, expected_video);
 
-  EXPECT_TRUE(report->Get(*expected_video.transport_id));
-  EXPECT_TRUE(report->Get(*expected_video.codec_id));
+  ASSERT_TRUE(report->Get(*expected_video.transport_id));
+  ASSERT_TRUE(report->Get(*expected_video.codec_id));
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Default) {
   MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
   cricket::VoiceChannel voice_channel(
       test_->worker_thread(), test_->network_thread(), test_->media_engine(),
       voice_media_channel, nullptr, "VoiceContentName", kDefaultRtcpEnabled,
       kDefaultSrtpRequired);
   MockVideoMediaChannel* video_media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(
@@ skipping 126 matching lines @@
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
 
   RTCTransportStats expected_rtp_transport(
       "RTCTransport_transport_" +
           rtc::ToString<>(cricket::ICE_CANDIDATE_COMPONENT_RTP),
       report->timestamp_us());
   expected_rtp_transport.bytes_sent = 42;
   expected_rtp_transport.bytes_received = 1337;
   expected_rtp_transport.active_connection = false;
 
-  EXPECT_TRUE(report->Get(expected_rtp_transport.id()));
+  ASSERT_TRUE(report->Get(expected_rtp_transport.id()));
   EXPECT_EQ(
       expected_rtp_transport,
       report->Get(expected_rtp_transport.id())->cast_to<RTCTransportStats>());
 
   cricket::ConnectionInfo rtcp_connection_info;
   rtcp_connection_info.best_connection = false;
   rtcp_connection_info.local_candidate = *rtcp_local_candidate.get();
   rtcp_connection_info.remote_candidate = *rtcp_remote_candidate.get();
   rtcp_connection_info.sent_total_bytes = 1337;
   rtcp_connection_info.recv_total_bytes = 42;
@@ skipping 11 matching lines @@
   RTCTransportStats expected_rtcp_transport(
       "RTCTransport_transport_" +
           rtc::ToString<>(cricket::ICE_CANDIDATE_COMPONENT_RTCP),
       report->timestamp_us());
   expected_rtcp_transport.bytes_sent = 1337;
   expected_rtcp_transport.bytes_received = 42;
   expected_rtcp_transport.active_connection = false;
 
   expected_rtp_transport.rtcp_transport_stats_id = expected_rtcp_transport.id();
 
-  EXPECT_TRUE(report->Get(expected_rtp_transport.id()));
+  ASSERT_TRUE(report->Get(expected_rtp_transport.id()));
   EXPECT_EQ(
       expected_rtp_transport,
       report->Get(expected_rtp_transport.id())->cast_to<RTCTransportStats>());
-  EXPECT_TRUE(report->Get(expected_rtcp_transport.id()));
+  ASSERT_TRUE(report->Get(expected_rtcp_transport.id()));
   EXPECT_EQ(
       expected_rtcp_transport,
       report->Get(expected_rtcp_transport.id())->cast_to<RTCTransportStats>());
 
   // Get stats with an active connection.
   session_stats.transport_stats["transport"]
       .channel_stats[1]
       .connection_infos[0]
       .best_connection = true;
 
   collector_->ClearCachedStatsReport();
   report = GetStatsReport();
 
   expected_rtcp_transport.active_connection = true;
   expected_rtcp_transport.selected_candidate_pair_id =
       "RTCIceCandidatePair_" + rtcp_local_candidate->id() + "_" +
       rtcp_remote_candidate->id();
 
-  EXPECT_TRUE(report->Get(expected_rtp_transport.id()));
+  ASSERT_TRUE(report->Get(expected_rtp_transport.id()));
   EXPECT_EQ(
       expected_rtp_transport,
       report->Get(expected_rtp_transport.id())->cast_to<RTCTransportStats>());
-  EXPECT_TRUE(report->Get(expected_rtcp_transport.id()));
+  ASSERT_TRUE(report->Get(expected_rtcp_transport.id()));
   EXPECT_EQ(
       expected_rtcp_transport,
       report->Get(expected_rtcp_transport.id())->cast_to<RTCTransportStats>());
 
   // Get stats with certificates.
   std::unique_ptr<CertificateInfo> local_certinfo =
       CreateFakeCertificateAndInfoFromDers(
           std::vector<std::string>({ "(local) local", "(local) chain" }));
   std::unique_ptr<CertificateInfo> remote_certinfo =
       CreateFakeCertificateAndInfoFromDers(
@@ skipping 21 matching lines @@
   expected_rtp_transport.local_certificate_id =
       "RTCCertificate_" + local_certinfo->fingerprints[0];
   expected_rtp_transport.remote_certificate_id =
       "RTCCertificate_" + remote_certinfo->fingerprints[0];
 
   expected_rtcp_transport.local_certificate_id =
       *expected_rtp_transport.local_certificate_id;
   expected_rtcp_transport.remote_certificate_id =
       *expected_rtp_transport.remote_certificate_id;
 
-  EXPECT_TRUE(report->Get(expected_rtp_transport.id()));
+  ASSERT_TRUE(report->Get(expected_rtp_transport.id()));
   EXPECT_EQ(
       expected_rtp_transport,
       report->Get(expected_rtp_transport.id())->cast_to<RTCTransportStats>());
-  EXPECT_TRUE(report->Get(expected_rtcp_transport.id()));
+  ASSERT_TRUE(report->Get(expected_rtcp_transport.id()));
   EXPECT_EQ(
       expected_rtcp_transport,
       report->Get(expected_rtcp_transport.id())->cast_to<RTCTransportStats>());
 }
 
 class RTCStatsCollectorTestWithFakeCollector : public testing::Test {
  public:
   RTCStatsCollectorTestWithFakeCollector()
     : test_(new rtc::RefCountedObject<RTCStatsCollectorTestHelper>()),
       collector_(FakeRTCStatsCollector::Create(
           &test_->pc(), 50 * rtc::kNumMicrosecsPerMillisec)) {
   }
 
  protected:
   rtc::scoped_refptr<RTCStatsCollectorTestHelper> test_;
   rtc::scoped_refptr<FakeRTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
   collector_->VerifyThreadUsageAndResultsMerging();
 }
 
 }  // namespace
 
 }  // namespace webrtc