Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1439)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: webrtc/api/rtcstats_integrationtest.cc

Issue 2521663002: RTCStatsIntegrationTest added. (Closed)
Patch Set: Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « webrtc/api/BUILD.gn ('k') | webrtc/api/rtcstatscollector_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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..eb09e8b455341b8c09f04f8ad8e669de1f1c2b23
--- /dev/null
+++ b/webrtc/api/rtcstats_integrationtest.cc
@@ -0,0 +1,497 @@
+/*
+ * 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 <sstream>
+#include <vector>
+
+#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/refcountedobject.h"
+#include "webrtc/base/scoped_ref_ptr.h"
+
+namespace webrtc {
+
+namespace {
+
+const int64_t kGetStatsTimeoutMs = 1000;
Taylor Brandstetter 2016/11/22 10:02:31 I'd suggest using a larger timeout such as 10 seco
hbos 2016/11/22 14:19:27 Done.
+
+class RTCStatsIntegrationTest : public testing::Test {
+ public:
+ RTCStatsIntegrationTest() {
Taylor Brandstetter 2016/11/22 10:02:31 Should this test use real network resources, or us
hbos 2016/11/22 14:19:27 Updated to use VirtualSocketServer.
+ 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:stun.l.google.com:19302";
Taylor Brandstetter 2016/11/22 10:02:32 Does this test need a STUN server? If not I'd omit
hbos 2016/11/22 14:19:27 Done. After some confusion I was able to wire it u
+ 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());
+
+ // Negotiate and wait for call to establish
+ caller_->CreateOffer(nullptr);
+ caller_->WaitForCallEstablished();
+ callee_->WaitForCallEstablished();
+ }
+
+ rtc::scoped_refptr<const RTCStatsReport> CallerGetStats() {
+ return GetStats(caller_->pc());
+ }
+
+ rtc::scoped_refptr<const RTCStatsReport> CalleeGetStats() {
+ 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();
+ }
+
+ 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 MemberTested(
Taylor Brandstetter 2016/11/22 10:02:32 nit: I'd prefer the name MarkMemberTested or somet
hbos 2016/11/22 14:19:27 Done.
+ 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() << " was undefined.";
+ MemberTested(member, member.is_defined());
+ }
+
+ void TestMemberIsUndefined(const RTCStatsMemberInterface& member) {
+ EXPECT_FALSE(member.is_defined()) <<
+ stats_->type() << "." << member.name() << " was defined (" <<
+ member.ValueToString() << ").";
+ MemberTested(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() << " was not tested.";
+ }
+ return false;
+ }
+
+ private:
+ void TestMemberIsIDReference(
+ const RTCStatsMemberInterface& member,
+ const char* expected_type,
+ bool optional) {
+ if (optional && !member.is_defined()) {
+ MemberTested(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() << ").";
+ MemberTested(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(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() == 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;
+ }
+ }
+ // TODO(hbos): Don't make an exception for |RTCDataChannelStats|, update the
+ // integration test to include data channels instead.
hbos 2016/11/21 18:40:20 Will address before landing.
+ missing_stats.erase(RTCDataChannelStats::kType);
+ 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 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.audio_level.is_defined()) {
+ // Video-only members
+ // TODO(hbos): In the integration test there are video tracks with and
+ // without |frame_width| and |frame_height| defined. Should we enforce
+ // |TestMemberIsDefined| or not? Currently optional:
hbos 2016/11/21 18:40:20 Will look into before landing.
+ verifier.MemberTested(media_stream_track.frame_width, true);
+ verifier.MemberTested(media_stream_track.frame_height, true);
+ 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
+ verifier.TestMemberIsDefined(media_stream_track.audio_level);
+ verifier.TestMemberIsDefined(media_stream_track.echo_return_loss);
+ verifier.TestMemberIsDefined(
+ media_stream_track.echo_return_loss_enhancement);
+ }
+ 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->TestMemberIsUndefined(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, GetStats) {
+ StartCall();
+
+ rtc::scoped_refptr<const RTCStatsReport> report = CallerGetStats();
Taylor Brandstetter 2016/11/22 10:02:31 Do you plan to add callee stats too?
hbos 2016/11/22 14:19:27 Sure! Done.
+ RTCStatsReportVerifier(report.get()).VerifyReport();
+}
+
+} // namespace
+
+} // namespace webrtc
« no previous file with comments | « webrtc/api/BUILD.gn ('k') | webrtc/api/rtcstatscollector_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698