Added logging for audio send/receive stream configs.

webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc

 /*
  *  Copyright (c) 2015 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 182 matching lines @@
   config->rtp.rtx.payload_type = prng->Rand(0, 127);
   // Add header extensions.
   for (unsigned i = 0; i < kNumExtensions; i++) {
     if (extensions_bitvector & (1u << i)) {
       config->rtp.extensions.push_back(
           RtpExtension(kExtensionNames[i], prng->Rand<int>()));
     }
   }
 }
 
+void GenerateAudioReceiveConfig(uint32_t extensions_bitvector,
+                                AudioReceiveStream::Config* config,
+                                Random* prng) {
+  // Add SSRCs for the stream.
+  config->rtp.remote_ssrc = prng->Rand<uint32_t>();
+  config->rtp.local_ssrc = prng->Rand<uint32_t>();
+  // Add header extensions.
+  for (unsigned i = 0; i < kNumExtensions; i++) {
+    if (extensions_bitvector & (1u << i)) {
+      config->rtp.extensions.push_back(
+          RtpExtension(kExtensionNames[i], prng->Rand<int>()));
+    }
+  }
+}
+
+void GenerateAudioSendConfig(uint32_t extensions_bitvector,
+                             AudioSendStream::Config* config,
+                             Random* prng) {
+  // Add SSRC to the stream.
+  config->rtp.ssrc = prng->Rand<uint32_t>();
+  // Add header extensions.
+  for (unsigned i = 0; i < kNumExtensions; i++) {
+    if (extensions_bitvector & (1u << i)) {
+      config->rtp.extensions.push_back(
+          RtpExtension(kExtensionNames[i], prng->Rand<int>()));
+    }
+  }
+}
+
 // Test for the RtcEventLog class. Dumps some RTP packets and other events
 // to disk, then reads them back to see if they match.
 void LogSessionAndReadBack(size_t rtp_count,
                            size_t rtcp_count,
                            size_t playout_count,
                            size_t bwe_loss_count,
                            uint32_t extensions_bitvector,
                            uint32_t csrcs_count,
                            unsigned int random_seed) {
   ASSERT_LE(rtcp_count, rtp_count);
@@ skipping 104 matching lines @@
   const size_t event_count = config_count + playout_count + bwe_loss_count +
                              rtcp_count + rtp_count + 2;
   EXPECT_GE(1000u, event_count);  // The events must fit in the message queue.
   EXPECT_EQ(event_count, parsed_log.GetNumberOfEvents());
   if (event_count != parsed_log.GetNumberOfEvents()) {
     // Print the expected and actual event types for easier debugging.
     PrintActualEvents(parsed_log);
     PrintExpectedEvents(rtp_count, rtcp_count, playout_count, bwe_loss_count);
   }
   RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
-  RtcEventLogTestHelper::VerifyReceiveStreamConfig(parsed_log, 1,
-                                                   receiver_config);
-  RtcEventLogTestHelper::VerifySendStreamConfig(parsed_log, 2, sender_config);
+  RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, 1,
+                                                        receiver_config);
+  RtcEventLogTestHelper::VerifyVideoSendStreamConfig(parsed_log, 2,
+                                                     sender_config);
   size_t event_index = config_count + 1;
   size_t rtcp_index = 1;
   size_t playout_index = 1;
   size_t bwe_loss_index = 1;
   for (size_t i = 1; i <= rtp_count; i++) {
     RtcEventLogTestHelper::VerifyRtpEvent(
         parsed_log, event_index,
         (i % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
         (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO,
         rtp_packets[i - 1].data(), rtp_packets[i - 1].headers_size(),
@@ skipping 110 matching lines @@
   RtcEventLogTestHelper::VerifyRtcpEvent(parsed_log, 2, kOutgoingPacket,
                                          MediaType::VIDEO, rtcp_packet.data(),
                                          rtcp_packet.size());
 
   RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 3);
 
   // Clean up temporary file - can be pretty slow.
   remove(temp_filename.c_str());
 }
 
+class ConfigReadWriteTest {
+ public:
+  ConfigReadWriteTest() : prng(987654321) {}
+  virtual ~ConfigReadWriteTest() {}
+  virtual void GenerateConfig(uint32_t extensions_bitvector) = 0;
+  virtual void VerifyConfig(const ParsedRtcEventLog& parsed_log,
+                            size_t index) = 0;
+  virtual void LogConfig(RtcEventLog* event_log) = 0;
+
+  void DoTest() {
+    // Find the name of the current test, in order to use it as a temporary
+    // filename.
+    auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
+    const std::string temp_filename =
+        test::OutputPath() + test_info->test_case_name() + test_info->name();
+
+    // Use all extensions.
+    uint32_t extensions_bitvector = (1u << kNumExtensions) - 1;
+    GenerateConfig(extensions_bitvector);
+
+    // Log a single config event and stop logging.
+    SimulatedClock fake_clock(prng.Rand<uint32_t>());
+    std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create(&fake_clock));
+
+    log_dumper->StartLogging(temp_filename, 10000000);
+    LogConfig(log_dumper.get());
+    log_dumper->StopLogging();
+
+    // Read the generated file from disk.
+    ParsedRtcEventLog parsed_log;
+    ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
+
+    // Check the generated number of events.
+    EXPECT_EQ(3u, parsed_log.GetNumberOfEvents());
+
+    RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
+
+    // Verify that the parsed config struct matches the one that was logged.
+    VerifyConfig(parsed_log, 1);
+
+    RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 2);
+
+    // Clean up temporary file - can be pretty slow.
+    remove(temp_filename.c_str());
+  }
+  Random prng;
+};
+
+class AudioReceiveConfigReadWriteTest : public ConfigReadWriteTest {
+ public:
+  void GenerateConfig(uint32_t extensions_bitvector) override {
+    GenerateAudioReceiveConfig(extensions_bitvector, &config, &prng);
+  }
+  void LogConfig(RtcEventLog* event_log) override {
+    event_log->LogAudioReceiveStreamConfig(config);
+  }
+  void VerifyConfig(const ParsedRtcEventLog& parsed_log,
+                    size_t index) override {
+    RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(parsed_log, index,
+                                                          config);
+  }
+  AudioReceiveStream::Config config;
+};
+
+class AudioSendConfigReadWriteTest : public ConfigReadWriteTest {
+ public:
+  AudioSendConfigReadWriteTest() : config(nullptr) {}
+  void GenerateConfig(uint32_t extensions_bitvector) override {
+    GenerateAudioSendConfig(extensions_bitvector, &config, &prng);
+  }
+  void LogConfig(RtcEventLog* event_log) override {
+    event_log->LogAudioSendStreamConfig(config);
+  }
+  void VerifyConfig(const ParsedRtcEventLog& parsed_log,
+                    size_t index) override {
+    RtcEventLogTestHelper::VerifyAudioSendStreamConfig(parsed_log, index,
+                                                       config);
+  }
+  AudioSendStream::Config config;
+};
+
+class VideoReceiveConfigReadWriteTest : public ConfigReadWriteTest {
+ public:
+  VideoReceiveConfigReadWriteTest() : config(nullptr) {}
+  void GenerateConfig(uint32_t extensions_bitvector) override {
+    GenerateVideoReceiveConfig(extensions_bitvector, &config, &prng);
+  }
+  void LogConfig(RtcEventLog* event_log) override {
+    event_log->LogVideoReceiveStreamConfig(config);
+  }
+  void VerifyConfig(const ParsedRtcEventLog& parsed_log,
+                    size_t index) override {
+    RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, index,
+                                                          config);
+  }
+  VideoReceiveStream::Config config;
+};
+
+class VideoSendConfigReadWriteTest : public ConfigReadWriteTest {
+ public:
+  VideoSendConfigReadWriteTest() : config(nullptr) {}
+  void GenerateConfig(uint32_t extensions_bitvector) override {
+    GenerateVideoSendConfig(extensions_bitvector, &config, &prng);
+  }
+  void LogConfig(RtcEventLog* event_log) override {
+    event_log->LogVideoSendStreamConfig(config);
+  }
+  void VerifyConfig(const ParsedRtcEventLog& parsed_log,
+                    size_t index) override {
+    RtcEventLogTestHelper::VerifyVideoSendStreamConfig(parsed_log, index,
+                                                       config);
+  }
+  VideoSendStream::Config config;
+};
+
+TEST(RtcEventLogTest, LogAudioReceiveConfig) {
+  AudioReceiveConfigReadWriteTest test;
+  test.DoTest();
+}
+
+TEST(RtcEventLogTest, LogAudioSendConfig) {
+  AudioSendConfigReadWriteTest test;
+  test.DoTest();
+}
+
+TEST(RtcEventLogTest, LogVideoReceiveConfig) {
+  VideoReceiveConfigReadWriteTest test;
+  test.DoTest();
+}
+
+TEST(RtcEventLogTest, LogVideoSendConfig) {
+  VideoSendConfigReadWriteTest test;
+  test.DoTest();
+}
 }  // namespace webrtc