Add probe logging to RtcEventLog.

webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc

 /*
  *  Copyright (c) 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 24 matching lines @@
     case rtclog::MediaType::AUDIO:
       return MediaType::AUDIO;
     case rtclog::MediaType::VIDEO:
       return MediaType::VIDEO;
     case rtclog::MediaType::DATA:
       return MediaType::DATA;
   }
   RTC_NOTREACHED();
   return MediaType::ANY;
 }
+
+rtclog::BweProbeResult::ResultType ConvertProbeResultType(
+    ProbeFailureReason failure_reason) {
+  switch (failure_reason) {
+    case kInvalidSendReceiveInterval:
+      return rtclog::BweProbeResult::INVALID_SEND_RECEIVE_INTERVAL;
+    case kInvalidSendReceiveRatio:
+      return rtclog::BweProbeResult::INVALID_SEND_RECEIVE_RATIO;
+    case kTimeout:
+      return rtclog::BweProbeResult::TIMEOUT;
+  }
+  RTC_NOTREACHED();
+  return rtclog::BweProbeResult::SUCCESS;
+}
+
 }  // namespace
 
 // Checks that the event has a timestamp, a type and exactly the data field
 // corresponding to the type.
 ::testing::AssertionResult IsValidBasicEvent(const rtclog::Event& event) {
   if (!event.has_timestamp_us()) {
     return ::testing::AssertionFailure() << "Event has no timestamp";
   }
   if (!event.has_type()) {
     return ::testing::AssertionFailure() << "Event has no event type";
@@ skipping 36 matching lines @@
            << (event.has_audio_receiver_config() ? "" : "no ")
            << "audio receiver config";
   }
   if ((type == rtclog::Event::AUDIO_SENDER_CONFIG_EVENT) !=
       event.has_audio_sender_config()) {
     return ::testing::AssertionFailure()
            << "Event of type " << type << " has "
            << (event.has_audio_sender_config() ? "" : "no ")
            << "audio sender config";
   }
+  if ((type == rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT) !=
+      event.has_probe_cluster()) {
+    return ::testing::AssertionFailure()
+           << "Event of type " << type << " has "
+           << (event.has_probe_cluster() ? "" : "no ") << "bwe probe cluster";
+  }
+  if ((type == rtclog::Event::BWE_PROBE_RESULT_EVENT) !=
+      event.has_probe_result()) {
+    return ::testing::AssertionFailure()
+           << "Event of type " << type << " has "
+           << (event.has_probe_result() ? "" : "no ") << "bwe probe result";
+  }
+
   return ::testing::AssertionSuccess();
 }
 
 void RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
     const VideoReceiveStream::Config& config) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT, event.type());
@@ skipping 374 matching lines @@
 }
 
 void RtcEventLogTestHelper::VerifyLogEndEvent(
     const ParsedRtcEventLog& parsed_log,
     size_t index) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   EXPECT_EQ(rtclog::Event::LOG_END, event.type());
 }
 
+void RtcEventLogTestHelper::VerifyBweProbeCluster(
+    const ParsedRtcEventLog& parsed_log,
+    size_t index,
+    uint32_t id,
+    uint32_t bitrate_bps,
+    uint32_t min_probes,
+    uint32_t min_bytes) {
+  const rtclog::Event& event = parsed_log.events_[index];
+  ASSERT_TRUE(IsValidBasicEvent(event));
+  EXPECT_EQ(rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT, event.type());
+
+  const rtclog::BweProbeCluster& bwe_event = event.probe_cluster();
+  ASSERT_TRUE(bwe_event.has_id());
+  EXPECT_EQ(id, bwe_event.id());
+  ASSERT_TRUE(bwe_event.has_bitrate_bps());
+  EXPECT_EQ(bitrate_bps, bwe_event.bitrate_bps());
+  ASSERT_TRUE(bwe_event.has_min_probes());
+  EXPECT_EQ(min_probes, bwe_event.min_probes());
+  ASSERT_TRUE(bwe_event.has_min_bytes());
+  EXPECT_EQ(min_bytes, bwe_event.min_bytes());
+
+  // TODO(philipel): Verify the parser when parsing has been implemented.
+}
+
+void RtcEventLogTestHelper::VerifyProbeResultSuccess(
+    const ParsedRtcEventLog& parsed_log,
+    size_t index,
+    uint32_t id,
+    uint32_t bitrate_bps) {
+  const rtclog::Event& event = parsed_log.events_[index];
+  ASSERT_TRUE(IsValidBasicEvent(event));
+  EXPECT_EQ(rtclog::Event::BWE_PROBE_RESULT_EVENT, event.type());
+
+  const rtclog::BweProbeResult& bwe_event = event.probe_result();
+  ASSERT_TRUE(bwe_event.has_id());
+  EXPECT_EQ(id, bwe_event.id());
+  ASSERT_TRUE(bwe_event.has_bitrate_bps());
+  EXPECT_EQ(bitrate_bps, bwe_event.bitrate_bps());
+  ASSERT_TRUE(bwe_event.has_result());
+  EXPECT_EQ(rtclog::BweProbeResult::SUCCESS, bwe_event.result());
+
+  // TODO(philipel): Verify the parser when parsing has been implemented.
+}
+
+void RtcEventLogTestHelper::VerifyProbeResultFailure(
+    const ParsedRtcEventLog& parsed_log,
+    size_t index,
+    uint32_t id,
+    ProbeFailureReason failure_reason) {
+  const rtclog::Event& event = parsed_log.events_[index];
+  ASSERT_TRUE(IsValidBasicEvent(event));
+  EXPECT_EQ(rtclog::Event::BWE_PROBE_RESULT_EVENT, event.type());
+
+  const rtclog::BweProbeResult& bwe_event = event.probe_result();
+  ASSERT_TRUE(bwe_event.has_id());
+  EXPECT_EQ(id, bwe_event.id());
+  ASSERT_TRUE(bwe_event.has_result());
+  EXPECT_EQ(ConvertProbeResultType(failure_reason), bwe_event.result());
+  ASSERT_FALSE(bwe_event.has_bitrate_bps());
+
+  // TODO(philipel): Verify the parser when parsing has been implemented.
+}
+
 }  // namespace webrtc