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.
  */
 
+#include <functional>
 #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"
@@ skipping 93 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());
   }
 
+  void TestMemberIsPositive(const RTCStatsMemberInterface& member) {
+    TestMemberSign(member, "positive", [](int sign) { return sign == 1; });

[hta-webrtc, 2016/12/20 15:19:18]

This seems like a huge amount of machinery for saying

EXPECT_TRUE(member.is_defined())
EXPECT_TRUE(member.<suitable_cast>.value() > 0)

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

Not quite, I have to do MarkMemberTested and EXPECT_BLAH with messages for nice
failure messages, but it can be almost that simple with a template to avoid the
switch! Fixed.

+  }
+
+  void TestMemberIsNonNegative(const RTCStatsMemberInterface& member) {
+    TestMemberSign(member, "non-negative", [](int sign) { return sign >= 0; });
+  }
+
   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 TestMemberSign(const RTCStatsMemberInterface& member,
+                      const char* sign_requirement,
+                      std::function<bool(int)> sign_check) {
+    EXPECT_TRUE(member.is_defined()) <<
+        stats_->type() << "." << member.name() << "[" << stats_->id() <<
+        "] was undefined.";
+    if (!member.is_defined()) {
+      MarkMemberTested(member, false);
+      return;
+    }
+    rtc::Optional<int> sign;
+    switch (member.type()) {
+      case RTCStatsMemberInterface::kInt32:
+        sign = rtc::Optional<int>(Sign(
+            **static_cast<const RTCStatsMember<int32_t>*>(&member)));
+        break;
+      case RTCStatsMemberInterface::kUint32:
+        sign = rtc::Optional<int>(Sign(
+            **static_cast<const RTCStatsMember<uint32_t>*>(&member)));
+        break;
+      case RTCStatsMemberInterface::kInt64:
+        sign = rtc::Optional<int>(Sign(
+            **static_cast<const RTCStatsMember<int64_t>*>(&member)));
+        break;
+      case RTCStatsMemberInterface::kUint64:
+        sign = rtc::Optional<int>(Sign(
+            **static_cast<const RTCStatsMember<uint64_t>*>(&member)));
+        break;
+      case RTCStatsMemberInterface::kDouble:
+        sign = rtc::Optional<int>(Sign(
+            **static_cast<const RTCStatsMember<double>*>(&member)));
+        break;
+      default:
+        break;
+    }
+    if (!sign) {
+      EXPECT_TRUE(false) <<
+          stats_->type() << "." << member.name() << "[" << stats_->id() <<
+          "] is not " << sign_requirement << " because it is not a numeric " <<
+          "value (" << member.ValueToString() << ").";
+      MarkMemberTested(member, false);
+      return;
+    }
+    bool passed_sign_check = sign_check(*sign);
+    EXPECT_TRUE(passed_sign_check) <<
+        stats_->type() << "." << member.name() << "[" << stats_->id() <<
+        "] is not " << sign_requirement << " (" << member.ValueToString() <<
+        ").";
+    MarkMemberTested(member, passed_sign_check);
+  }
+
+  template<typename T>
+  int Sign(T value) {
+    return (value > T(0)) - (value < T(0));
+  }
+
   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()) {
@@ skipping 120 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(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(data_channel.messages_sent);
+    verifier.TestMemberIsNonNegative(data_channel.bytes_sent);
+    verifier.TestMemberIsNonNegative(data_channel.messages_received);
+    verifier.TestMemberIsNonNegative(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.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(candidate_pair.bytes_sent);
+    verifier.TestMemberIsNonNegative(candidate_pair.bytes_received);
     verifier.TestMemberIsUndefined(candidate_pair.total_round_trip_time);
-    verifier.TestMemberIsDefined(candidate_pair.current_round_trip_time);
+    verifier.TestMemberIsNonNegative(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(candidate_pair.requests_received);
+    verifier.TestMemberIsNonNegative(candidate_pair.requests_sent);
+    verifier.TestMemberIsNonNegative(candidate_pair.responses_received);
+    verifier.TestMemberIsNonNegative(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(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(candidate.port);
     verifier.TestMemberIsDefined(candidate.protocol);
     verifier.TestMemberIsDefined(candidate.candidate_type);
-    verifier.TestMemberIsDefined(candidate.priority);
+    verifier.TestMemberIsNonNegative(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(media_stream_track.frame_width);
+      verifier.TestMemberIsNonNegative(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(peer_connection.data_channels_opened);
+    verifier.TestMemberIsNonNegative(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(stream.fir_count);
+      verifier->TestMemberIsNonNegative(stream.pli_count);
+      verifier->TestMemberIsNonNegative(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(inbound_stream.packets_received);
+    verifier.TestMemberIsNonNegative(inbound_stream.bytes_received);
+    verifier.TestMemberIsNonNegative(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(inbound_stream.jitter);
     }
-    verifier.TestMemberIsDefined(inbound_stream.fraction_lost);
+    verifier.TestMemberIsNonNegative(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(outbound_stream.packets_sent);
+    verifier.TestMemberIsNonNegative(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(transport.bytes_sent);
+    verifier.TestMemberIsNonNegative(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