RTCStatsIntegrationTest added.

webrtc/api/rtcstats_integrationtest.cc

Index: webrtc/api/rtcstats_integrationtest.cc
diff --git a/webrtc/api/rtcstats_integrationtest.cc b/webrtc/api/rtcstats_integrationtest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a74d19f07a70adab47aad1250f3bfe6e2604e2a3
--- /dev/null
+++ b/webrtc/api/rtcstats_integrationtest.cc
@@ -0,0 +1,537 @@
+/*
+ *  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.
+ */
+
+#include <set>
+#include <vector>
+
+#include "webrtc/api/datachannelinterface.h"
+#include "webrtc/api/peerconnectioninterface.h"
+#include "webrtc/api/stats/rtcstats_objects.h"
+#include "webrtc/api/stats/rtcstatsreport.h"
+#include "webrtc/api/test/peerconnectiontestwrapper.h"
+#include "webrtc/api/test/rtcstatsobtainer.h"
+#include "webrtc/base/checks.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/refcountedobject.h"
+#include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/base/virtualsocketserver.h"
+
+namespace webrtc {
+
+namespace {
+
+const int64_t kGetStatsTimeoutMs = 10000;
+
+class RTCStatsIntegrationTest : public testing::Test {
+ public:
+  RTCStatsIntegrationTest()
+      : physical_socket_server_(),
+        virtual_socket_server_(&physical_socket_server_),
+        network_thread_(&virtual_socket_server_),
+        worker_thread_() {
+    RTC_CHECK(network_thread_.Start());
+    RTC_CHECK(worker_thread_.Start());
+
+    caller_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>(
+        "caller", &network_thread_, &worker_thread_);
+    callee_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>(
+        "callee", &network_thread_, &worker_thread_);
+  }
+
+  void StartCall() {
+    // Create PeerConnections and "connect" sigslots
+    PeerConnectionInterface::RTCConfiguration config;
+    PeerConnectionInterface::IceServer ice_server;
+    ice_server.uri = "stun:1.1.1.1:3478";
+    config.servers.push_back(ice_server);
+    EXPECT_TRUE(caller_->CreatePc(nullptr, config));
+    EXPECT_TRUE(callee_->CreatePc(nullptr, config));
+    PeerConnectionTestWrapper::Connect(caller_.get(), callee_.get());
+
+    // Get user media for audio and video
+    caller_->GetAndAddUserMedia(true, FakeConstraints(),
+                                true, FakeConstraints());
+    callee_->GetAndAddUserMedia(true, FakeConstraints(),
+                                true, FakeConstraints());
+
+    // Create data channels
+    DataChannelInit init;
+    caller_->CreateDataChannel("data", init);
+    callee_->CreateDataChannel("data", init);
+
+    // Negotiate and wait for call to establish
+    caller_->CreateOffer(nullptr);
+    caller_->WaitForCallEstablished();
+    callee_->WaitForCallEstablished();
+  }
+
+  rtc::scoped_refptr<const RTCStatsReport> GetStatsFromCaller() {
+    return GetStats(caller_->pc());
+  }
+
+  rtc::scoped_refptr<const RTCStatsReport> GetStatsFromCallee() {
+    return GetStats(callee_->pc());
+  }
+
+ protected:
+  static rtc::scoped_refptr<const RTCStatsReport> GetStats(
+      PeerConnectionInterface* pc) {
+    rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer =
+        RTCStatsObtainer::Create();
+    pc->GetStats(stats_obtainer);
+    EXPECT_TRUE_WAIT(stats_obtainer->report(), kGetStatsTimeoutMs);
+    return stats_obtainer->report();
+  }
+
+  // These objects use each other and must be constructed/destroyed in this
+  // order. Relationship:
+  // |physical_socket_server_| <- |virtual_socket_server_| <- |network_thread_|
+  rtc::PhysicalSocketServer physical_socket_server_;
+  rtc::VirtualSocketServer virtual_socket_server_;
+  rtc::Thread network_thread_;
+  rtc::Thread worker_thread_;
+  rtc::scoped_refptr<PeerConnectionTestWrapper> caller_;
+  rtc::scoped_refptr<PeerConnectionTestWrapper> callee_;
+};
+
+class RTCStatsVerifier {
+ public:
+  RTCStatsVerifier(const RTCStatsReport* report, const RTCStats* stats)
+      : report_(report), stats_(stats), all_tests_successful_(true) {
+    RTC_CHECK(report_);
+    RTC_CHECK(stats_);
+    for (const RTCStatsMemberInterface* member : stats_->Members()) {
+      untested_members_.insert(member);
+    }
+  }
+
+  void MarkMemberTested(
+      const RTCStatsMemberInterface& member, bool test_successful) {
+    untested_members_.erase(&member);
+    all_tests_successful_ &= test_successful;
+  }
+
+  void TestMemberIsDefined(const RTCStatsMemberInterface& member) {
+    EXPECT_TRUE(member.is_defined()) <<
+      stats_->type() << "." << member.name() << "[" << stats_->id() <<
+      "] was undefined.";
+    MarkMemberTested(member, member.is_defined());
+  }
+
+  void TestMemberIsUndefined(const RTCStatsMemberInterface& member) {
+    EXPECT_FALSE(member.is_defined()) <<
+      stats_->type() << "." << member.name() << "[" << stats_->id() <<
+      "] was defined (" << member.ValueToString() << ").";
+    MarkMemberTested(member, !member.is_defined());
+  }
+
+  void TestMemberIsIDReference(
+      const RTCStatsMemberInterface& member,
+      const char* expected_type) {
+    TestMemberIsIDReference(member, expected_type, false);
+  }
+
+  void TestMemberIsOptionalIDReference(
+      const RTCStatsMemberInterface& member,
+      const char* expected_type) {
+    TestMemberIsIDReference(member, expected_type, true);
+  }
+
+  bool ExpectAllMembersSuccessfullyTested() {
+    if (untested_members_.empty())
+      return all_tests_successful_;
+    for (const RTCStatsMemberInterface* member : untested_members_) {
+      EXPECT_TRUE(false) <<
+          stats_->type() << "." << member->name() << "[" << stats_->id() <<
+          "] was not tested.";
+    }
+    return false;
+  }
+
+ private:
+  void TestMemberIsIDReference(
+      const RTCStatsMemberInterface& member,
+      const char* expected_type,
+      bool optional) {
+    if (optional && !member.is_defined()) {
+      MarkMemberTested(member, true);
+      return;
+    }
+    bool valid_reference = false;
+    if (member.is_defined()) {
+      if (member.type() == RTCStatsMemberInterface::kString) {
+        // A single ID.
+        const RTCStatsMember<std::string>& id =
+            member.cast_to<RTCStatsMember<std::string>>();
+        const RTCStats* referenced_stats = report_->Get(*id);
+        valid_reference =
+            referenced_stats && referenced_stats->type() == expected_type;
+      } else if (member.type() == RTCStatsMemberInterface::kSequenceString) {
+        // A vector of IDs.
+        valid_reference = true;
+        const RTCStatsMember<std::vector<std::string>>& ids =
+            member.cast_to<RTCStatsMember<std::vector<std::string>>>();
+        for (const std::string id : *ids) {
+          const RTCStats* referenced_stats = report_->Get(id);
+          if (!referenced_stats || referenced_stats->type() != expected_type) {
+            valid_reference = false;
+            break;
+          }
+        }
+      }
+    }
+    EXPECT_TRUE(valid_reference) <<
+      stats_->type() << "." << member.name() << " is not a reference to an " <<
+      "existing dictionary of type " << expected_type << " (" <<
+      member.ValueToString() << ").";
+    MarkMemberTested(member, valid_reference);
+  }
+
+  rtc::scoped_refptr<const RTCStatsReport> report_;
+  const RTCStats* stats_;
+  std::set<const RTCStatsMemberInterface*> untested_members_;
+  bool all_tests_successful_;
+};
+
+class RTCStatsReportVerifier {
+ public:
+  static std::set<const char*> StatsTypes() {
+    std::set<const char*> stats_types;
+    stats_types.insert(RTCCertificateStats::kType);
+    stats_types.insert(RTCCodecStats::kType);
+    stats_types.insert(RTCDataChannelStats::kType);
+    stats_types.insert(RTCIceCandidatePairStats::kType);
+    stats_types.insert(RTCLocalIceCandidateStats::kType);
+    stats_types.insert(RTCRemoteIceCandidateStats::kType);
+    stats_types.insert(RTCMediaStreamStats::kType);
+    stats_types.insert(RTCMediaStreamTrackStats::kType);
+    stats_types.insert(RTCPeerConnectionStats::kType);
+    stats_types.insert(RTCInboundRTPStreamStats::kType);
+    stats_types.insert(RTCOutboundRTPStreamStats::kType);
+    stats_types.insert(RTCTransportStats::kType);
+    return stats_types;
+  }
+
+  explicit RTCStatsReportVerifier(const RTCStatsReport* report)
+      : report_(report) {
+  }
+
+  void VerifyReport() {
+    std::set<const char*> missing_stats = StatsTypes();
+    bool verify_successful = true;
+    for (const RTCStats& stats : *report_) {
+      missing_stats.erase(stats.type());
+      if (stats.type() == RTCCertificateStats::kType) {
+        verify_successful &= VerifyRTCCertificateStats(
+            stats.cast_to<RTCCertificateStats>());
+      } else if (stats.type() == RTCCodecStats::kType) {
+        verify_successful &= VerifyRTCCodecStats(
+            stats.cast_to<RTCCodecStats>());
+      } else if (stats.type() == RTCDataChannelStats::kType) {
+        verify_successful &= VerifyRTCDataChannelStats(
+            stats.cast_to<RTCDataChannelStats>());
+      } else if (stats.type() == RTCIceCandidatePairStats::kType) {
+        verify_successful &= VerifyRTCIceCandidatePairStats(
+            stats.cast_to<RTCIceCandidatePairStats>());
+      } else if (stats.type() == RTCLocalIceCandidateStats::kType) {
+        verify_successful &= VerifyRTCLocalIceCandidateStats(
+            stats.cast_to<RTCLocalIceCandidateStats>());
+      } else if (stats.type() == RTCRemoteIceCandidateStats::kType) {
+        verify_successful &= VerifyRTCRemoteIceCandidateStats(
+            stats.cast_to<RTCRemoteIceCandidateStats>());
+      } else if (stats.type() == RTCMediaStreamStats::kType) {
+        verify_successful &= VerifyRTCMediaStreamStats(
+            stats.cast_to<RTCMediaStreamStats>());
+      } else if (stats.type() == RTCMediaStreamTrackStats::kType) {
+        verify_successful &= VerifyRTCMediaStreamTrackStats(
+            stats.cast_to<RTCMediaStreamTrackStats>());
+      } else if (stats.type() == RTCPeerConnectionStats::kType) {
+        verify_successful &= VerifyRTCPeerConnectionStats(
+            stats.cast_to<RTCPeerConnectionStats>());
+      } else if (stats.type() == RTCInboundRTPStreamStats::kType) {
+        verify_successful &= VerifyRTCInboundRTPStreamStats(
+            stats.cast_to<RTCInboundRTPStreamStats>());
+      } else if (stats.type() == RTCOutboundRTPStreamStats::kType) {
+        verify_successful &= VerifyRTCOutboundRTPStreamStats(
+            stats.cast_to<RTCOutboundRTPStreamStats>());
+      } else if (stats.type() == RTCTransportStats::kType) {
+        verify_successful &= VerifyRTCTransportStats(
+            stats.cast_to<RTCTransportStats>());
+      } else {
+        EXPECT_TRUE(false) << "Unrecognized stats type: " << stats.type();
+        verify_successful = false;
+      }
+    }
+    if (!missing_stats.empty()) {
+      verify_successful = false;
+      for (const char* missing : missing_stats) {
+        EXPECT_TRUE(false) << "Missing expected stats type: " << missing;
+      }
+    }
+    EXPECT_TRUE(verify_successful) <<
+        "One or more problems with the stats. This is the report:\n" <<
+        report_->ToString();
+  }
+
+  bool VerifyRTCCertificateStats(
+      const RTCCertificateStats& certificate) {
+    RTCStatsVerifier verifier(report_, &certificate);
+    verifier.TestMemberIsDefined(certificate.fingerprint);
+    verifier.TestMemberIsDefined(certificate.fingerprint_algorithm);
+    verifier.TestMemberIsDefined(certificate.base64_certificate);
+    verifier.TestMemberIsOptionalIDReference(
+        certificate.issuer_certificate_id, RTCCertificateStats::kType);
+    return verifier.ExpectAllMembersSuccessfullyTested();
+  }
+
+  bool VerifyRTCCodecStats(
+      const RTCCodecStats& codec) {
+    RTCStatsVerifier verifier(report_, &codec);
+    verifier.TestMemberIsDefined(codec.payload_type);
+    verifier.TestMemberIsDefined(codec.codec);
+    verifier.TestMemberIsDefined(codec.clock_rate);
+    verifier.TestMemberIsUndefined(codec.channels);
+    verifier.TestMemberIsUndefined(codec.parameters);
+    verifier.TestMemberIsUndefined(codec.implementation);
+    return verifier.ExpectAllMembersSuccessfullyTested();
+  }
+
+  bool VerifyRTCDataChannelStats(
+      const RTCDataChannelStats& data_channel) {
+    RTCStatsVerifier verifier(report_, &data_channel);
+    verifier.TestMemberIsDefined(data_channel.label);
+    verifier.TestMemberIsDefined(data_channel.protocol);
+    verifier.TestMemberIsDefined(data_channel.datachannelid);
+    verifier.TestMemberIsDefined(data_channel.state);
+    verifier.TestMemberIsDefined(data_channel.messages_sent);
+    verifier.TestMemberIsDefined(data_channel.bytes_sent);
+    verifier.TestMemberIsDefined(data_channel.messages_received);
+    verifier.TestMemberIsDefined(data_channel.bytes_received);
+    return verifier.ExpectAllMembersSuccessfullyTested();
+  }
+
+  bool VerifyRTCIceCandidatePairStats(
+      const RTCIceCandidatePairStats& candidate_pair) {
+    RTCStatsVerifier verifier(report_, &candidate_pair);
+    verifier.TestMemberIsUndefined(candidate_pair.transport_id);
+    verifier.TestMemberIsIDReference(
+        candidate_pair.local_candidate_id, RTCLocalIceCandidateStats::kType);
+    verifier.TestMemberIsIDReference(
+        candidate_pair.remote_candidate_id, RTCRemoteIceCandidateStats::kType);
+    verifier.TestMemberIsUndefined(candidate_pair.state);
+    verifier.TestMemberIsUndefined(candidate_pair.priority);
+    verifier.TestMemberIsUndefined(candidate_pair.nominated);
+    verifier.TestMemberIsDefined(candidate_pair.writable);
+    verifier.TestMemberIsUndefined(candidate_pair.readable);
+    verifier.TestMemberIsDefined(candidate_pair.bytes_sent);
+    verifier.TestMemberIsDefined(candidate_pair.bytes_received);
+    verifier.TestMemberIsUndefined(candidate_pair.total_rtt);
+    verifier.TestMemberIsDefined(candidate_pair.current_rtt);
+    verifier.TestMemberIsUndefined(candidate_pair.available_outgoing_bitrate);
+    verifier.TestMemberIsUndefined(candidate_pair.available_incoming_bitrate);
+    verifier.TestMemberIsUndefined(candidate_pair.requests_received);
+    verifier.TestMemberIsDefined(candidate_pair.requests_sent);
+    verifier.TestMemberIsDefined(candidate_pair.responses_received);
+    verifier.TestMemberIsDefined(candidate_pair.responses_sent);
+    verifier.TestMemberIsUndefined(candidate_pair.retransmissions_received);
+    verifier.TestMemberIsUndefined(candidate_pair.retransmissions_sent);
+    verifier.TestMemberIsUndefined(candidate_pair.consent_requests_received);
+    verifier.TestMemberIsUndefined(candidate_pair.consent_requests_sent);
+    verifier.TestMemberIsUndefined(candidate_pair.consent_responses_received);
+    verifier.TestMemberIsUndefined(candidate_pair.consent_responses_sent);
+    return verifier.ExpectAllMembersSuccessfullyTested();
+  }
+
+  bool VerifyRTCIceCandidateStats(
+      const RTCIceCandidateStats& candidate) {
+    RTCStatsVerifier verifier(report_, &candidate);
+    verifier.TestMemberIsDefined(candidate.ip);
+    verifier.TestMemberIsDefined(candidate.port);
+    verifier.TestMemberIsDefined(candidate.protocol);
+    verifier.TestMemberIsDefined(candidate.candidate_type);
+    verifier.TestMemberIsDefined(candidate.priority);
+    verifier.TestMemberIsUndefined(candidate.url);
+    return verifier.ExpectAllMembersSuccessfullyTested();
+  }
+
+  bool VerifyRTCLocalIceCandidateStats(
+      const RTCLocalIceCandidateStats& local_candidate) {
+    return VerifyRTCIceCandidateStats(local_candidate);
+  }
+
+  bool VerifyRTCRemoteIceCandidateStats(
+      const RTCRemoteIceCandidateStats& remote_candidate) {
+    return VerifyRTCIceCandidateStats(remote_candidate);
+  }
+
+  bool VerifyRTCMediaStreamStats(
+      const RTCMediaStreamStats& media_stream) {
+    RTCStatsVerifier verifier(report_, &media_stream);
+    verifier.TestMemberIsDefined(media_stream.stream_identifier);
+    verifier.TestMemberIsIDReference(
+        media_stream.track_ids, RTCMediaStreamTrackStats::kType);
+    return verifier.ExpectAllMembersSuccessfullyTested();
+  }
+
+  bool VerifyRTCMediaStreamTrackStats(
+      const RTCMediaStreamTrackStats& media_stream_track) {
+    RTCStatsVerifier verifier(report_, &media_stream_track);
+    verifier.TestMemberIsDefined(media_stream_track.track_identifier);
+    verifier.TestMemberIsDefined(media_stream_track.remote_source);
+    verifier.TestMemberIsDefined(media_stream_track.ended);
+    verifier.TestMemberIsDefined(media_stream_track.detached);
+    verifier.TestMemberIsUndefined(media_stream_track.ssrc_ids);
+    // Video or audio media stream track?
+    if (media_stream_track.frame_width.is_defined()) {
+      // Video-only members
+      verifier.TestMemberIsDefined(media_stream_track.frame_width);
+      verifier.TestMemberIsDefined(media_stream_track.frame_height);
+      verifier.TestMemberIsUndefined(media_stream_track.frames_per_second);
+      verifier.TestMemberIsUndefined(media_stream_track.frames_sent);
+      verifier.TestMemberIsUndefined(media_stream_track.frames_received);
+      verifier.TestMemberIsUndefined(media_stream_track.frames_decoded);
+      verifier.TestMemberIsUndefined(media_stream_track.frames_dropped);
+      verifier.TestMemberIsUndefined(media_stream_track.frames_corrupted);
+      verifier.TestMemberIsUndefined(media_stream_track.partial_frames_lost);
+      verifier.TestMemberIsUndefined(media_stream_track.full_frames_lost);
+      // Audio-only members should be undefined
+      verifier.TestMemberIsUndefined(media_stream_track.audio_level);
+      verifier.TestMemberIsUndefined(media_stream_track.echo_return_loss);
+      verifier.TestMemberIsUndefined(
+          media_stream_track.echo_return_loss_enhancement);
+    } else {
+      // Video-only members should be undefined
+      verifier.TestMemberIsUndefined(media_stream_track.frame_width);
+      verifier.TestMemberIsUndefined(media_stream_track.frame_height);
+      verifier.TestMemberIsUndefined(media_stream_track.frames_per_second);
+      verifier.TestMemberIsUndefined(media_stream_track.frames_sent);
+      verifier.TestMemberIsUndefined(media_stream_track.frames_received);
+      verifier.TestMemberIsUndefined(media_stream_track.frames_decoded);
+      verifier.TestMemberIsUndefined(media_stream_track.frames_dropped);
+      verifier.TestMemberIsUndefined(media_stream_track.frames_corrupted);
+      verifier.TestMemberIsUndefined(media_stream_track.partial_frames_lost);
+      verifier.TestMemberIsUndefined(media_stream_track.full_frames_lost);
+      // Audio-only members
+      // TODO(hbos): Why are the audio track missing |audio_level|,
+      // |echo_return_loss| and |echo_return_loss_enhancement|? Is this a real
+      // problem or does it have to do with testing and not using real devices?
+      // crbug.com/627816
+      verifier.MarkMemberTested(media_stream_track.audio_level, true);
+      verifier.MarkMemberTested(media_stream_track.echo_return_loss, true);
+      verifier.MarkMemberTested(
+          media_stream_track.echo_return_loss_enhancement, true);
+    }
+    return verifier.ExpectAllMembersSuccessfullyTested();
+  }
+
+  bool VerifyRTCPeerConnectionStats(
+      const RTCPeerConnectionStats& peer_connection) {
+    RTCStatsVerifier verifier(report_, &peer_connection);
+    verifier.TestMemberIsDefined(peer_connection.data_channels_opened);
+    verifier.TestMemberIsDefined(peer_connection.data_channels_closed);
+    return verifier.ExpectAllMembersSuccessfullyTested();
+  }
+
+  void VerifyRTCRTPStreamStats(
+      const RTCRTPStreamStats& stream, RTCStatsVerifier* verifier) {
+    verifier->TestMemberIsDefined(stream.ssrc);
+    verifier->TestMemberIsUndefined(stream.associate_stats_id);
+    verifier->TestMemberIsDefined(stream.is_remote);
+    verifier->TestMemberIsDefined(stream.media_type);
+    verifier->TestMemberIsUndefined(stream.media_track_id);
+    verifier->TestMemberIsIDReference(
+        stream.transport_id, RTCTransportStats::kType);
+    verifier->TestMemberIsDefined(stream.codec_id);
+    if (stream.media_type.is_defined() && *stream.media_type == "video") {
+      verifier->TestMemberIsDefined(stream.fir_count);
+      verifier->TestMemberIsDefined(stream.pli_count);
+      verifier->TestMemberIsDefined(stream.nack_count);
+    } else {
+      verifier->TestMemberIsUndefined(stream.fir_count);
+      verifier->TestMemberIsUndefined(stream.pli_count);
+      verifier->TestMemberIsUndefined(stream.nack_count);
+    }
+    verifier->TestMemberIsUndefined(stream.sli_count);
+  }
+
+  bool VerifyRTCInboundRTPStreamStats(
+      const RTCInboundRTPStreamStats& inbound_stream) {
+    RTCStatsVerifier verifier(report_, &inbound_stream);
+    VerifyRTCRTPStreamStats(inbound_stream, &verifier);
+    verifier.TestMemberIsDefined(inbound_stream.packets_received);
+    verifier.TestMemberIsDefined(inbound_stream.bytes_received);
+    verifier.TestMemberIsUndefined(inbound_stream.packets_lost);
+    if (inbound_stream.media_type.is_defined() &&
+        *inbound_stream.media_type == "video") {
+      verifier.TestMemberIsUndefined(inbound_stream.jitter);
+    } else {
+      verifier.TestMemberIsDefined(inbound_stream.jitter);
+    }
+    verifier.TestMemberIsDefined(inbound_stream.fraction_lost);
+    verifier.TestMemberIsUndefined(inbound_stream.packets_discarded);
+    verifier.TestMemberIsUndefined(inbound_stream.packets_repaired);
+    verifier.TestMemberIsUndefined(inbound_stream.burst_packets_lost);
+    verifier.TestMemberIsUndefined(inbound_stream.burst_packets_discarded);
+    verifier.TestMemberIsUndefined(inbound_stream.burst_loss_count);
+    verifier.TestMemberIsUndefined(inbound_stream.burst_discard_count);
+    verifier.TestMemberIsUndefined(inbound_stream.burst_loss_rate);
+    verifier.TestMemberIsUndefined(inbound_stream.burst_discard_rate);
+    verifier.TestMemberIsUndefined(inbound_stream.gap_loss_rate);
+    verifier.TestMemberIsUndefined(inbound_stream.gap_discard_rate);
+    return verifier.ExpectAllMembersSuccessfullyTested();
+  }
+
+  bool VerifyRTCOutboundRTPStreamStats(
+      const RTCOutboundRTPStreamStats& outbound_stream) {
+    RTCStatsVerifier verifier(report_, &outbound_stream);
+    VerifyRTCRTPStreamStats(outbound_stream, &verifier);
+    verifier.TestMemberIsDefined(outbound_stream.packets_sent);
+    verifier.TestMemberIsDefined(outbound_stream.bytes_sent);
+    verifier.TestMemberIsUndefined(outbound_stream.target_bitrate);
+    verifier.TestMemberIsDefined(outbound_stream.round_trip_time);
+    return verifier.ExpectAllMembersSuccessfullyTested();
+  }
+
+  bool VerifyRTCTransportStats(
+      const RTCTransportStats& transport) {
+    RTCStatsVerifier verifier(report_, &transport);
+    verifier.TestMemberIsDefined(transport.bytes_sent);
+    verifier.TestMemberIsDefined(transport.bytes_received);
+    verifier.TestMemberIsOptionalIDReference(
+        transport.rtcp_transport_stats_id, RTCTransportStats::kType);
+    verifier.TestMemberIsDefined(transport.active_connection);
+    verifier.TestMemberIsDefined(transport.selected_candidate_pair_id);
+    verifier.TestMemberIsDefined(transport.local_certificate_id);
+    verifier.TestMemberIsDefined(transport.remote_certificate_id);
+    return verifier.ExpectAllMembersSuccessfullyTested();
+  }
+
+ private:
+  rtc::scoped_refptr<const RTCStatsReport> report_;
+};
+
+TEST_F(RTCStatsIntegrationTest, GetStatsFromCaller) {
+  StartCall();
+
+  rtc::scoped_refptr<const RTCStatsReport> report = GetStatsFromCaller();
+  RTCStatsReportVerifier(report.get()).VerifyReport();
+}
+
+TEST_F(RTCStatsIntegrationTest, GetStatsFromCallee) {
+  StartCall();
+
+  rtc::scoped_refptr<const RTCStatsReport> report = GetStatsFromCallee();
+  RTCStatsReportVerifier(report.get()).VerifyReport();
+}
+
+}  // namespace
+
+}  // namespace webrtc