Improve rtcstats_integrationtest.cc by sanity checking values.

webrtc/api/rtcstats_integrationtest.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 103 matching lines @@
   }
 
   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.";
+        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() << ").";
+        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;
+    }

[hta-webrtc, 2017/01/02 11:31:59]

I'm not happy with the fact that this repeats code from TestMemberIsDefined, but
you need to do the "return" here, which makes it complex to just call
TestMemberIsDefined. I'll let it pass.

+    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);
@@ skipping 144 matching lines @@
     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.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.TestMemberIsDefined(data_channel.messages_sent);
-    verifier.TestMemberIsDefined(data_channel.bytes_sent);
-    verifier.TestMemberIsDefined(data_channel.messages_received);
-    verifier.TestMemberIsDefined(data_channel.bytes_received);
+    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);

[hbos, 2016/12/21 10:41:14]

Here and in other places: I'm doing the check even for unsigned values which
can't fail by definition, but I'm thinking it doesn't hurt for clarity.
Otherwise the unsigned should just be TestMemberIsDefined.

     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.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.TestMemberIsNonNegative<uint64_t>(candidate_pair.bytes_sent);
+    verifier.TestMemberIsNonNegative<uint64_t>(candidate_pair.bytes_received);
     verifier.TestMemberIsUndefined(candidate_pair.total_round_trip_time);
-    verifier.TestMemberIsDefined(candidate_pair.current_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.TestMemberIsDefined(candidate_pair.requests_received);
-    verifier.TestMemberIsDefined(candidate_pair.requests_sent);
-    verifier.TestMemberIsDefined(candidate_pair.responses_received);
-    verifier.TestMemberIsDefined(candidate_pair.responses_sent);
+    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.TestMemberIsDefined(candidate_pair.consent_requests_sent);
+    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.TestMemberIsDefined(candidate.ip);
-    verifier.TestMemberIsDefined(candidate.port);
+    verifier.TestMemberIsNonNegative<int32_t>(candidate.port);
     verifier.TestMemberIsDefined(candidate.protocol);
     verifier.TestMemberIsDefined(candidate.candidate_type);
-    verifier.TestMemberIsDefined(candidate.priority);
+    verifier.TestMemberIsNonNegative<int32_t>(candidate.priority);
     verifier.TestMemberIsUndefined(candidate.url);
     return verifier.ExpectAllMembersSuccessfullyTested();
   }
 
   bool VerifyRTCLocalIceCandidateStats(
       const RTCLocalIceCandidateStats& local_candidate) {
     return VerifyRTCIceCandidateStats(local_candidate);
   }
 
   bool VerifyRTCRemoteIceCandidateStats(
@@ skipping 14 matching lines @@
       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.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);
       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);
@@ skipping 21 matching lines @@
       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);
+    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->TestMemberIsUndefined(stream.media_track_id);
     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->TestMemberIsDefined(stream.fir_count);
-      verifier->TestMemberIsDefined(stream.pli_count);
-      verifier->TestMemberIsDefined(stream.nack_count);
+      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.TestMemberIsDefined(inbound_stream.packets_received);
-    verifier.TestMemberIsDefined(inbound_stream.bytes_received);
-    verifier.TestMemberIsDefined(inbound_stream.packets_lost);
+    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.TestMemberIsDefined(inbound_stream.jitter);
+      verifier.TestMemberIsNonNegative<double>(inbound_stream.jitter);
     }
-    verifier.TestMemberIsDefined(inbound_stream.fraction_lost);
+    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);
     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.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);
     return verifier.ExpectAllMembersSuccessfullyTested();
   }
 
   bool VerifyRTCTransportStats(
       const RTCTransportStats& transport) {
     RTCStatsVerifier verifier(report_, &transport);
-    verifier.TestMemberIsDefined(transport.bytes_sent);
-    verifier.TestMemberIsDefined(transport.bytes_received);
+    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.active_connection);
     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();
@@ skipping 26 matching lines @@
   // 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());
 }
 
 }  // namespace
 
 }  // namespace webrtc