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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: webrtc/api/rtcstats_integrationtest.cc

Issue 2514883002: Create //webrtc/api:libjingle_peerconnection_api + refactorings. (Closed)
Patch Set: Rebase Created 3 years, 11 months 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/remoteaudiosource.cc ('k') | webrtc/api/rtcstatscollector.h » ('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
deleted file mode 100644
index 6d14c46e6c45839721588b92750679f7eead24ac..0000000000000000000000000000000000000000
--- a/webrtc/api/rtcstats_integrationtest.cc
+++ /dev/null
@@ -1,632 +0,0 @@
-/*
- * 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());
- }
-
- template<typename T>
- void TestMemberIsPositive(const RTCStatsMemberInterface& member) {
- EXPECT_TRUE(member.is_defined()) <<
- stats_->type() << "." << member.name() << "[" << stats_->id() <<
- "] was undefined.";
- if (!member.is_defined()) {
- MarkMemberTested(member, false);
- return;
- }
- bool is_positive = *member.cast_to<RTCStatsMember<T>>() > T(0);
- EXPECT_TRUE(is_positive) <<
- stats_->type() << "." << member.name() << "[" << stats_->id() <<
- "] was not positive (" << member.ValueToString() << ").";
- MarkMemberTested(member, is_positive);
- }
-
- template<typename T>
- void TestMemberIsNonNegative(const RTCStatsMemberInterface& member) {
- EXPECT_TRUE(member.is_defined()) <<
- stats_->type() << "." << member.name() << "[" << stats_->id() <<
- "] was undefined.";
- if (!member.is_defined()) {
- MarkMemberTested(member, false);
- return;
- }
- bool is_non_negative = *member.cast_to<RTCStatsMember<T>>() >= T(0);
- EXPECT_TRUE(is_non_negative) <<
- stats_->type() << "." << member.name() << "[" << stats_->id() <<
- "] was not non-negative (" << member.ValueToString() << ").";
- MarkMemberTested(member, is_non_negative);
- }
-
- 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.TestMemberIsPositive<uint32_t>(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.TestMemberIsNonNegative<uint32_t>(data_channel.messages_sent);
- verifier.TestMemberIsNonNegative<uint64_t>(data_channel.bytes_sent);
- verifier.TestMemberIsNonNegative<uint32_t>(data_channel.messages_received);
- verifier.TestMemberIsNonNegative<uint64_t>(data_channel.bytes_received);
- return verifier.ExpectAllMembersSuccessfullyTested();
- }
-
- bool VerifyRTCIceCandidatePairStats(
- const RTCIceCandidatePairStats& candidate_pair) {
- RTCStatsVerifier verifier(report_, &candidate_pair);
- verifier.TestMemberIsIDReference(
- candidate_pair.transport_id, RTCTransportStats::kType);
- verifier.TestMemberIsIDReference(
- candidate_pair.local_candidate_id, RTCLocalIceCandidateStats::kType);
- verifier.TestMemberIsIDReference(
- candidate_pair.remote_candidate_id, RTCRemoteIceCandidateStats::kType);
- verifier.TestMemberIsDefined(candidate_pair.state);
- verifier.TestMemberIsNonNegative<uint64_t>(candidate_pair.priority);
- verifier.TestMemberIsUndefined(candidate_pair.nominated);
- verifier.TestMemberIsDefined(candidate_pair.writable);
- verifier.TestMemberIsUndefined(candidate_pair.readable);
- verifier.TestMemberIsNonNegative<uint64_t>(candidate_pair.bytes_sent);
- verifier.TestMemberIsNonNegative<uint64_t>(candidate_pair.bytes_received);
- verifier.TestMemberIsUndefined(candidate_pair.total_round_trip_time);
- verifier.TestMemberIsNonNegative<double>(
- candidate_pair.current_round_trip_time);
- verifier.TestMemberIsUndefined(candidate_pair.available_outgoing_bitrate);
- verifier.TestMemberIsUndefined(candidate_pair.available_incoming_bitrate);
- verifier.TestMemberIsNonNegative<uint64_t>(
- candidate_pair.requests_received);
- verifier.TestMemberIsNonNegative<uint64_t>(candidate_pair.requests_sent);
- verifier.TestMemberIsNonNegative<uint64_t>(
- candidate_pair.responses_received);
- verifier.TestMemberIsNonNegative<uint64_t>(candidate_pair.responses_sent);
- verifier.TestMemberIsUndefined(candidate_pair.retransmissions_received);
- verifier.TestMemberIsUndefined(candidate_pair.retransmissions_sent);
- verifier.TestMemberIsUndefined(candidate_pair.consent_requests_received);
- verifier.TestMemberIsNonNegative<uint64_t>(
- 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.TestMemberIsIDReference(
- candidate.transport_id, RTCTransportStats::kType);
- verifier.TestMemberIsDefined(candidate.is_remote);
- verifier.TestMemberIsDefined(candidate.ip);
- verifier.TestMemberIsNonNegative<int32_t>(candidate.port);
- verifier.TestMemberIsDefined(candidate.protocol);
- verifier.TestMemberIsDefined(candidate.candidate_type);
- verifier.TestMemberIsNonNegative<int32_t>(candidate.priority);
- verifier.TestMemberIsUndefined(candidate.url);
- verifier.TestMemberIsDefined(candidate.deleted);
- 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.TestMemberIsDefined(media_stream_track.kind);
- // Video or audio media stream track?
- if (*media_stream_track.kind == RTCMediaStreamTrackKind::kVideo) {
- // Video-only members
- verifier.TestMemberIsNonNegative<uint32_t>(
- media_stream_track.frame_width);
- verifier.TestMemberIsNonNegative<uint32_t>(
- media_stream_track.frame_height);
- verifier.TestMemberIsUndefined(media_stream_track.frames_per_second);
- if (*media_stream_track.remote_source) {
- verifier.TestMemberIsUndefined(media_stream_track.frames_sent);
- verifier.TestMemberIsNonNegative<uint32_t>(
- media_stream_track.frames_received);
- verifier.TestMemberIsNonNegative<uint32_t>(
- media_stream_track.frames_decoded);
- } else {
- verifier.TestMemberIsNonNegative<uint32_t>(
- 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 {
- RTC_DCHECK_EQ(*media_stream_track.kind,
- RTCMediaStreamTrackKind::kAudio);
- // 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.TestMemberIsNonNegative<double>(media_stream_track.audio_level);
- // TODO(hbos): |echo_return_loss| and |echo_return_loss_enhancement| are
- // flaky on msan bot (sometimes defined, sometimes undefined). Should the
- // test run until available or is there a way to have it always be
- // defined? crbug.com/627816
- 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.TestMemberIsNonNegative<uint32_t>(
- peer_connection.data_channels_opened);
- verifier.TestMemberIsNonNegative<uint32_t>(
- 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->TestMemberIsIDReference(
- stream.media_track_id, RTCMediaStreamTrackStats::kType);
- verifier->TestMemberIsIDReference(
- stream.transport_id, RTCTransportStats::kType);
- verifier->TestMemberIsIDReference(stream.codec_id, RTCCodecStats::kType);
- if (stream.media_type.is_defined() && *stream.media_type == "video") {
- verifier->TestMemberIsNonNegative<uint32_t>(stream.fir_count);
- verifier->TestMemberIsNonNegative<uint32_t>(stream.pli_count);
- verifier->TestMemberIsNonNegative<uint32_t>(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.TestMemberIsUndefined(inbound_stream.qp_sum);
- verifier.TestMemberIsNonNegative<uint32_t>(inbound_stream.packets_received);
- verifier.TestMemberIsNonNegative<uint64_t>(inbound_stream.bytes_received);
- verifier.TestMemberIsNonNegative<uint32_t>(inbound_stream.packets_lost);
- if (inbound_stream.media_type.is_defined() &&
- *inbound_stream.media_type == "video") {
- verifier.TestMemberIsUndefined(inbound_stream.jitter);
- } else {
- verifier.TestMemberIsNonNegative<double>(inbound_stream.jitter);
- }
- verifier.TestMemberIsNonNegative<double>(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);
- if (inbound_stream.media_type.is_defined() &&
- *inbound_stream.media_type == "video") {
- verifier.TestMemberIsDefined(inbound_stream.frames_decoded);
- } else {
- verifier.TestMemberIsUndefined(inbound_stream.frames_decoded);
- }
- return verifier.ExpectAllMembersSuccessfullyTested();
- }
-
- bool VerifyRTCOutboundRTPStreamStats(
- const RTCOutboundRTPStreamStats& outbound_stream) {
- RTCStatsVerifier verifier(report_, &outbound_stream);
- VerifyRTCRTPStreamStats(outbound_stream, &verifier);
- if (outbound_stream.media_type.is_defined() &&
- *outbound_stream.media_type == "video") {
- verifier.TestMemberIsNonNegative<uint64_t>(outbound_stream.qp_sum);
- } else {
- verifier.TestMemberIsUndefined(outbound_stream.qp_sum);
- }
- verifier.TestMemberIsNonNegative<uint32_t>(outbound_stream.packets_sent);
- verifier.TestMemberIsNonNegative<uint64_t>(outbound_stream.bytes_sent);
- verifier.TestMemberIsUndefined(outbound_stream.target_bitrate);
- // TODO(hbos): Defined in video but not audio case. Why? crbug.com/669877
- verifier.MarkMemberTested(outbound_stream.round_trip_time, true);
- if (outbound_stream.media_type.is_defined() &&
- *outbound_stream.media_type == "video") {
- verifier.TestMemberIsDefined(outbound_stream.frames_encoded);
- } else {
- verifier.TestMemberIsUndefined(outbound_stream.frames_encoded);
- }
- return verifier.ExpectAllMembersSuccessfullyTested();
- }
-
- bool VerifyRTCTransportStats(
- const RTCTransportStats& transport) {
- RTCStatsVerifier verifier(report_, &transport);
- verifier.TestMemberIsNonNegative<uint64_t>(transport.bytes_sent);
- verifier.TestMemberIsNonNegative<uint64_t>(transport.bytes_received);
- verifier.TestMemberIsOptionalIDReference(
- transport.rtcp_transport_stats_id, RTCTransportStats::kType);
- verifier.TestMemberIsDefined(transport.dtls_state);
- verifier.TestMemberIsIDReference(
- transport.selected_candidate_pair_id, RTCIceCandidatePairStats::kType);
- verifier.TestMemberIsIDReference(
- transport.local_certificate_id, RTCCertificateStats::kType);
- verifier.TestMemberIsIDReference(
- transport.remote_certificate_id, RTCCertificateStats::kType);
- return verifier.ExpectAllMembersSuccessfullyTested();
- }
-
- private:
- rtc::scoped_refptr<const RTCStatsReport> report_;
-};
-
-#ifdef HAVE_SCTP
-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();
-}
-
-TEST_F(RTCStatsIntegrationTest, GetsStatsWhileDestroyingPeerConnections) {
- StartCall();
-
- rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer =
- RTCStatsObtainer::Create();
- caller_->pc()->GetStats(stats_obtainer);
- // This will destroy the peer connection.
- caller_ = nullptr;
- // Any pending stats requests should have completed in the act of destroying
- // the peer connection.
- EXPECT_TRUE(stats_obtainer->report());
-}
-#endif // HAVE_SCTP
-
-} // namespace
-
-} // namespace webrtc
« no previous file with comments | « webrtc/api/remoteaudiosource.cc ('k') | webrtc/api/rtcstatscollector.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698