RTCStatsCollectorTest: Remove ExpectReportContainsCandidate.

webrtc/api/rtcstatscollector_unittest.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 476 matching lines @@
     rtc::scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
     collector_->GetStatsReport(callback);
     EXPECT_TRUE_WAIT(callback->report(), kGetStatsReportTimeoutMs);
     int64_t after = rtc::TimeUTCMicros();
     for (const RTCStats& stats : *callback->report()) {
       EXPECT_LE(stats.timestamp_us(), after);
     }
     return callback->report();
   }
 
-  const RTCIceCandidateStats* ExpectReportContainsCandidate(
-      const rtc::scoped_refptr<const RTCStatsReport>& report,
-      const cricket::Candidate& candidate,
-      bool is_local) {
-    const RTCStats* stats = report->Get("RTCIceCandidate_" + candidate.id());
-    EXPECT_TRUE(stats);
-    const RTCIceCandidateStats* candidate_stats;
-    if (is_local)
-        candidate_stats = &stats->cast_to<RTCLocalIceCandidateStats>();
-    else
-        candidate_stats = &stats->cast_to<RTCRemoteIceCandidateStats>();
-    EXPECT_EQ(*candidate_stats->ip, candidate.address().ipaddr().ToString());
-    EXPECT_EQ(*candidate_stats->port,
-              static_cast<int32_t>(candidate.address().port()));
-    EXPECT_EQ(*candidate_stats->protocol, candidate.protocol());
-    EXPECT_EQ(*candidate_stats->candidate_type,
-              CandidateTypeToRTCIceCandidateTypeForTesting(candidate.type()));
-    EXPECT_EQ(*candidate_stats->priority,
-              static_cast<int32_t>(candidate.priority()));
-    // TODO(hbos): Define candidate_stats->url. crbug.com/632723
-    EXPECT_FALSE(candidate_stats->url.is_defined());
-    return candidate_stats;
-  }
-
   void ExpectReportContainsCertificateInfo(
       const rtc::scoped_refptr<const RTCStatsReport>& report,
       const CertificateInfo& cert_info) {
     for (size_t i = 0; i < cert_info.fingerprints.size(); ++i) {
       const RTCStats* stats = report->Get(
           "RTCCertificate_" + cert_info.fingerprints[i]);
       ASSERT_TRUE(stats);
       const RTCCertificateStats& cert_stats =
           stats->cast_to<const RTCCertificateStats>();
       EXPECT_EQ(*cert_stats.fingerprint, cert_info.fingerprints[i]);
@@ skipping 451 matching lines @@
   session_stats.transport_stats["b"].channel_stats.push_back(
       b_transport_channel_stats);
 
   // Mock the session to return the desired candidates.
   EXPECT_CALL(test_->session(), GetStats(_)).WillRepeatedly(Invoke(
       [&session_stats](const ChannelNamePairs&) {
         return std::unique_ptr<SessionStats>(new SessionStats(session_stats));
       }));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
-  ExpectReportContainsCandidate(report, *a_local_host.get(), true);
-  ExpectReportContainsCandidate(report, *a_remote_srflx.get(), false);
-  ExpectReportContainsCandidate(report, *a_local_prflx.get(), true);
-  ExpectReportContainsCandidate(report, *a_remote_relay.get(), false);
-  ExpectReportContainsCandidate(report, *b_local.get(), true);
-  ExpectReportContainsCandidate(report, *b_remote.get(), false);
+
+  RTCLocalIceCandidateStats expected_a_local_host(
+      "RTCIceCandidate_" + a_local_host->id(), report->timestamp_us());
+  expected_a_local_host.ip = "1.2.3.4";
+  expected_a_local_host.port = 5;
+  expected_a_local_host.protocol = "a_local_host's protocol";
+  expected_a_local_host.candidate_type = "host";
+  expected_a_local_host.priority = 0;
+  EXPECT_TRUE(report->Get(expected_a_local_host.id()));
+  EXPECT_EQ(expected_a_local_host,
+            report->Get(expected_a_local_host.id())->cast_to<
+                RTCLocalIceCandidateStats>());

[Taylor Brandstetter, 2016/12/20 19:56:43]

nit: It may make sense to create the "expected stats" objects in the same place
as the fake candidates (at the top of the test), so that when reading the test
code it's easier to see how the fake candidate is expected to map to the
candidate stats. Same goes for the other CLs (like data channel stats).

[hbos, 2016/12/21 09:42:07]

Done.

+
+  RTCRemoteIceCandidateStats expected_a_remote_srflx(
+      "RTCIceCandidate_" + a_remote_srflx->id(), report->timestamp_us());
+  expected_a_remote_srflx.ip = "6.7.8.9";
+  expected_a_remote_srflx.port = 10;
+  expected_a_remote_srflx.protocol = "remote_srflx's protocol";
+  expected_a_remote_srflx.candidate_type = "srflx";
+  expected_a_remote_srflx.priority = 1;
+  EXPECT_TRUE(report->Get(expected_a_remote_srflx.id()));
+  EXPECT_EQ(expected_a_remote_srflx,
+            report->Get(expected_a_remote_srflx.id())->cast_to<
+                RTCRemoteIceCandidateStats>());
+
+  RTCLocalIceCandidateStats expected_a_local_prflx(
+      "RTCIceCandidate_" + a_local_prflx->id(), report->timestamp_us());
+  expected_a_local_prflx.ip = "11.12.13.14";
+  expected_a_local_prflx.port = 15;
+  expected_a_local_prflx.protocol = "a_local_prflx's protocol";
+  expected_a_local_prflx.candidate_type = "prflx";
+  expected_a_local_prflx.priority = 2;
+  EXPECT_TRUE(report->Get(expected_a_local_prflx.id()));
+  EXPECT_EQ(expected_a_local_prflx,
+            report->Get(expected_a_local_prflx.id())->cast_to<
+                RTCLocalIceCandidateStats>());
+
+  RTCRemoteIceCandidateStats expected_a_remote_relay(
+      "RTCIceCandidate_" + a_remote_relay->id(), report->timestamp_us());
+  expected_a_remote_relay.ip = "16.17.18.19";
+  expected_a_remote_relay.port = 20;
+  expected_a_remote_relay.protocol = "a_remote_relay's protocol";
+  expected_a_remote_relay.candidate_type = "relay";
+  expected_a_remote_relay.priority = 3;
+  EXPECT_TRUE(report->Get(expected_a_remote_relay.id()));
+  EXPECT_EQ(expected_a_remote_relay,
+            report->Get(expected_a_remote_relay.id())->cast_to<
+                RTCRemoteIceCandidateStats>());
+
+  RTCLocalIceCandidateStats expected_b_local(
+      "RTCIceCandidate_" + b_local->id(), report->timestamp_us());
+  expected_b_local.ip = "42.42.42.42";
+  expected_b_local.port = 42;
+  expected_b_local.protocol = "b_local's protocol";
+  expected_b_local.candidate_type = "host";
+  expected_b_local.priority = 42;
+  EXPECT_TRUE(report->Get(expected_b_local.id()));
+  EXPECT_EQ(expected_b_local,
+            report->Get(expected_b_local.id())->cast_to<
+                RTCLocalIceCandidateStats>());
+
+  RTCRemoteIceCandidateStats expected_b_remote(
+      "RTCIceCandidate_" + b_remote->id(), report->timestamp_us());
+  expected_b_remote.ip = "42.42.42.42";
+  expected_b_remote.port = 42;
+  expected_b_remote.protocol = "b_remote's protocol";
+  expected_b_remote.candidate_type = "host";
+  expected_b_remote.priority = 42;
+  EXPECT_TRUE(report->Get(expected_b_remote.id()));
+  EXPECT_EQ(expected_b_remote,
+            report->Get(expected_b_remote.id())->cast_to<
+                RTCRemoteIceCandidateStats>());
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidatePairStats) {
   std::unique_ptr<cricket::Candidate> local_candidate = CreateFakeCandidate(
       "42.42.42.42", 42, "protocol", cricket::LOCAL_PORT_TYPE, 42);
   std::unique_ptr<cricket::Candidate> remote_candidate = CreateFakeCandidate(
       "42.42.42.42", 42, "protocol", cricket::LOCAL_PORT_TYPE, 42);
 
   SessionStats session_stats;
 
@@ skipping 43 matching lines @@
   expected_pair.requests_sent = 2000;
   expected_pair.responses_received = 4321;
   expected_pair.responses_sent = 1000;
   expected_pair.consent_requests_sent = (2020 - 2000);
 
   EXPECT_TRUE(report->Get(expected_pair.id()));
   EXPECT_EQ(
       expected_pair,
       report->Get(expected_pair.id())->cast_to<RTCIceCandidatePairStats>());
 
-  EXPECT_TRUE(report->Get(*expected_pair.local_candidate_id));
-  ExpectReportContainsCandidate(report, connection_info.local_candidate, true);
-  EXPECT_TRUE(report->Get(*expected_pair.remote_candidate_id));
-  ExpectReportContainsCandidate(report, connection_info.remote_candidate,
-                                false);
+  RTCLocalIceCandidateStats expected_local_candidate(
+      *expected_pair.local_candidate_id, report->timestamp_us());
+  expected_local_candidate.ip = "42.42.42.42";
+  expected_local_candidate.port = 42;
+  expected_local_candidate.protocol = "protocol";
+  expected_local_candidate.candidate_type = "host";
+  expected_local_candidate.priority = 42;
+  ASSERT_TRUE(report->Get(expected_local_candidate.id()));
+  EXPECT_EQ(expected_local_candidate,
+            report->Get(expected_local_candidate.id())->cast_to<
+                RTCLocalIceCandidateStats>());
+
+  RTCRemoteIceCandidateStats expected_remote_candidate(
+      *expected_pair.remote_candidate_id, report->timestamp_us());
+  expected_remote_candidate.ip = "42.42.42.42";
+  expected_remote_candidate.port = 42;
+  expected_remote_candidate.protocol = "protocol";
+  expected_remote_candidate.candidate_type = "host";
+  expected_remote_candidate.priority = 42;
+  ASSERT_TRUE(report->Get(expected_remote_candidate.id()));
+  EXPECT_EQ(expected_remote_candidate,
+            report->Get(expected_remote_candidate.id())->cast_to<
+                RTCRemoteIceCandidateStats>());
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCPeerConnectionStats) {
   {
     rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
     RTCPeerConnectionStats expected("RTCPeerConnection",
                                     report->timestamp_us());
     expected.data_channels_opened = 0;
     expected.data_channels_closed = 0;
     EXPECT_TRUE(report->Get("RTCPeerConnection"));
@@ skipping 831 matching lines @@
   rtc::scoped_refptr<FakeRTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
   collector_->VerifyThreadUsageAndResultsMerging();
 }
 
 }  // namespace
 
 }  // namespace webrtc