Refactor event log analyser bindings unit test

Bug: None
Change-Id: If343333a46b9cdd8c8df8753ceddca3a14a98cf8
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/350040
Commit-Queue: Björn Terelius <terelius@webrtc.org>
Reviewed-by: Jeremy Leconte <jleconte@google.com>
Cr-Commit-Position: refs/heads/main@{#42244}

rtc_tools/rtc_event_log_visualizer/analyzer_bindings.cc

@@ -100,7 +100,8 @@ void analyze_rtc_event_log(const char* log_contents,
   std::string serialized_charts = proto_charts.SerializeAsString();
   if (rtc::checked_cast<uint32_t>(serialized_charts.size()) > *output_size) {
     std::cerr << "Serialized charts larger than available output buffer: "
-              << serialized_charts.size() << " vs " << *output_size;
+              << serialized_charts.size() << " vs " << *output_size
+              << std::endl;
     *output_size = 0;
     return;
   }

rtc_tools/rtc_event_log_visualizer/analyzer_bindings_unittest.cc

@@ -10,7 +10,6 @@
 
 #include "rtc_tools/rtc_event_log_visualizer/analyzer_bindings.h"
 
-#include <memory>
 #include <string>
 #include <vector>
 
@@ -26,50 +25,86 @@
 #include "rtc_tools/rtc_event_log_visualizer/proto/chart.pb.h"
 #endif
 
-TEST(RtcEventLogAnalyzerBindingsTest, ProducesCharts) {
+class RtcEventLogAnalyzerBindingsTest : public ::testing::Test {
-  constexpr int kInputBufferSize = 1'000'000;
+  void SetUp() override {
-  constexpr int kOutputBufferSize = 1'000'000;
-  std::unique_ptr<char[]> input = std::make_unique<char[]>(kInputBufferSize);
-  std::unique_ptr<char[]> output = std::make_unique<char[]>(kOutputBufferSize);
-
     // Read an RTC event log to a char buffer.
     std::string file_name = webrtc::test::ResourcePath(
         "rtc_event_log/rtc_event_log_500kbps", "binarypb");
     webrtc::FileWrapper file = webrtc::FileWrapper::OpenReadOnly(file_name);
     ASSERT_TRUE(file.is_open());
+
     absl::optional<size_t> file_size = file.FileSize();
     ASSERT_TRUE(file_size.has_value());
-  ASSERT_LE(*file_size, static_cast<size_t>(kInputBufferSize));
+    constexpr size_t kMaxFileSize = 1'000'000;
     ASSERT_GT(*file_size, 0u);
-  size_t input_size = file.Read(input.get(), *file_size);
+    ASSERT_LE(*file_size, kMaxFileSize);
-  ASSERT_EQ(*file_size, input_size);
+
+    event_log_contents_.resize(*file_size);
+    size_t read_size =
+        file.Read(event_log_contents_.data(), event_log_contents_.size());
+    ASSERT_EQ(*file_size, read_size);
+  }
+
+ protected:
+  std::vector<char> event_log_contents_;
+};
+
+TEST_F(RtcEventLogAnalyzerBindingsTest, OutgoingBitrateChart) {
+  uint32_t kMaxOutputSize = 1'000'000;
+  std::vector<char> output(kMaxOutputSize);
 
   // Call analyzer.
-  uint32_t output_size = kOutputBufferSize;
+  char selection[] = "outgoing_bitrate";
-  char selection[] = "outgoing_bitrate,network_delay_feedback";
   size_t selection_size = strlen(selection);
-  analyze_rtc_event_log(input.get(), input_size, selection, selection_size,
+  uint32_t output_size = output.size();
-                        output.get(), &output_size);
+  analyze_rtc_event_log(event_log_contents_.data(), event_log_contents_.size(),
+                        selection, selection_size, output.data(), &output_size);
   ASSERT_GT(output_size, 0u);
 
   // Parse output as charts.
   webrtc::analytics::ChartCollection collection;
   bool success =
-      collection.ParseFromArray(output.get(), static_cast<int>(output_size));
+      collection.ParseFromArray(output.data(), static_cast<int>(output_size));
   ASSERT_TRUE(success);
-  EXPECT_EQ(collection.charts().size(), 2);
+  ASSERT_EQ(collection.charts().size(), 1);
-  std::vector<std::string> chart_titles;
+  EXPECT_EQ(collection.charts(0).title(), "Outgoing RTP bitrate");
-  for (const auto& chart : collection.charts()) {
+  EXPECT_EQ(collection.charts(0).id(), "outgoing_bitrate");
-    chart_titles.push_back(chart.title());
 }
-  EXPECT_THAT(chart_titles,
+
-              ::testing::UnorderedElementsAre(
+TEST_F(RtcEventLogAnalyzerBindingsTest, NetWorkDelayFeedbackChart) {
-                  "Outgoing RTP bitrate",
+  uint32_t kMaxOutputSize = 1'000'000;
-                  "Outgoing network delay (based on per-packet feedback)"));
+  std::vector<char> output(kMaxOutputSize);
-  std::vector<std::string> chart_ids;
+
-  for (const auto& chart : collection.charts()) {
+  // Call analyzer.
-    chart_ids.push_back(chart.id());
+  char selection[] = "network_delay_feedback";
+  size_t selection_size = strlen(selection);
+  uint32_t output_size = output.size();
+  analyze_rtc_event_log(event_log_contents_.data(), event_log_contents_.size(),
+                        selection, selection_size, output.data(), &output_size);
+  ASSERT_GT(output_size, 0u);
+
+  // Parse output as charts.
+  webrtc::analytics::ChartCollection collection;
+  bool success =
+      collection.ParseFromArray(output.data(), static_cast<int>(output_size));
+  ASSERT_TRUE(success);
+  ASSERT_EQ(collection.charts().size(), 1);
+  EXPECT_EQ(collection.charts(0).title(),
+            "Outgoing network delay (based on per-packet feedback)");
+  EXPECT_EQ(collection.charts(0).id(), "network_delay_feedback");
 }
-  EXPECT_THAT(chart_ids, ::testing::UnorderedElementsAre(
+
-                             "outgoing_bitrate", "network_delay_feedback"));
+TEST_F(RtcEventLogAnalyzerBindingsTest, OutputbufferTooSmall) {
+  uint32_t kMaxOutputSize = 100;
+  std::vector<char> output(kMaxOutputSize);
+
+  // Call analyzer.
+  char selection[] = "outgoing_bitrate";
+  size_t selection_size = strlen(selection);
+  uint32_t output_size = output.size();
+  analyze_rtc_event_log(event_log_contents_.data(), event_log_contents_.size(),
+                        selection, selection_size, output.data(), &output_size);
+
+  // No output since the buffer is too small.
+  ASSERT_EQ(output_size, 0u);
 }