Log audio network adapter decisions in event log.

webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc

Index: webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc
diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc b/webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ec5b972e5419a279354cf40ccead8accc30994aa
--- /dev/null
+++ b/webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc
@@ -0,0 +1,174 @@
+/*
+ *  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.
+ */
+
+#include <memory>
+
+#include "webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h"
+#include "webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer.h"
+#include "webrtc/test/gtest.h"
+
+namespace webrtc {
+
+namespace {
+constexpr int kMinBitreateChangeBps = 5000;

[minyue-webrtc, 2016/12/20 10:39:29]

add a line break before 20

[michaelt, 2016/12/20 13:41:41]

Done.

+constexpr float kMinPacketLossChangeFraction = 0.5;
+
+constexpr int kBitrateBps = 50000;
+constexpr int kFrameLengthMs = 60;
+constexpr bool kEnableFec = true;
+constexpr bool kEnableDtx = true;
+constexpr float kPacketLossFraction = 0.05;
+constexpr size_t kNumChannels = 1;
+
+MATCHER_P(EncoderRuntimeConfigIs, config, "") {
+  return arg.bitrate_bps == config.bitrate_bps &&
+         arg.frame_length_ms == config.frame_length_ms &&
+         arg.uplink_packet_loss_fraction ==
+             config.uplink_packet_loss_fraction &&
+         arg.enable_fec == config.enable_fec &&
+         arg.enable_dtx == config.enable_dtx &&
+         arg.num_channels == config.num_channels;
+}
+
+struct EventLogWriterStates {
+  std::unique_ptr<EventLogWriter> event_log_writer;
+  std::unique_ptr<MockRtcEventLog> event_log;
+  AudioNetworkAdaptor::EncoderRuntimeConfig runtime_config;

[minyue-webrtc, 2016/12/20 10:39:29]

it feels that runtime_config does not need to be a state. You need it only
because you wanted to create it easily.

You may put runtime_config out of states, but an easier fix can be make the
verification really depends on states. I suggest

void Verify(const EventLogWriterStates& state) {
  EXPECT_CALL(state.event_log,
LogEncoderRuntimeConfig(EncoderRuntimeConfigIs(state.runtime_config)))
      .Times(1);
  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
}

Then everytime you want to verify, call Verify. Before Verify, you can change
state.

[michaelt, 2016/12/20 13:41:41]

There are some tests which expect that log LogEncoderRuntimeConfig is not called
so I can not put the expetion and the "maylog.." function in to the Verify
function.

I changed the interface of ExpectLogEncoderConfig to take the state.

[minyue-webrtc, 2016/12/20 14:11:05]

I think that can make it worse. now, people need to read both the test and
ExpectLogEncoderConfig to see how it works.

how about giving an arg to Verify(bool expect_log)?

[michaelt, 2016/12/20 14:34:03]

I don't like the Verify idea. Would prefer then to Move the exception back in to
the Tests. 

+};
+
+EventLogWriterStates CreateEventLogWriter() {
+  EventLogWriterStates state;
+  state.event_log.reset(new MockRtcEventLog());
+  state.event_log_writer.reset(
+      new EventLogWriter(state.event_log.get(), kMinBitreateChangeBps,
+                         kMinPacketLossChangeFraction));
+  state.runtime_config.bitrate_bps = rtc::Optional<int>(kBitrateBps);
+  state.runtime_config.frame_length_ms = rtc::Optional<int>(kFrameLengthMs);
+  state.runtime_config.uplink_packet_loss_fraction =
+      rtc::Optional<float>(kPacketLossFraction);
+  state.runtime_config.enable_fec = rtc::Optional<bool>(kEnableFec);
+  state.runtime_config.enable_dtx = rtc::Optional<bool>(kEnableDtx);
+  state.runtime_config.num_channels = rtc::Optional<size_t>(kNumChannels);
+  return state;
+}
+
+void ExpectLogEncoderRuntimeConfig(
+    const std::unique_ptr<MockRtcEventLog>& event_log,
+    const AudioNetworkAdaptor::EncoderRuntimeConfig& runtime_config) {
+  EXPECT_CALL(*event_log,
+              LogEncoderRuntimeConfig(EncoderRuntimeConfigIs(runtime_config)))
+      .Times(1);
+}
+
+}  // namespace
+
+TEST(EventLogWriterTest, FirstConfigIsLogged) {
+  auto state = CreateEventLogWriter();
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+}
+
+TEST(EventLogWriterTest, SameConfigIsNotLogged) {
+  auto state = CreateEventLogWriter();
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+}
+
+TEST(EventLogWriterTest, LogOnFecStateChange) {
+  auto state = CreateEventLogWriter();
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+
+  state.runtime_config.enable_fec = rtc::Optional<bool>(!kEnableFec);
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+}
+
+TEST(EventLogWriterTest, LogOnDtxStateChange) {
+  auto state = CreateEventLogWriter();
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+
+  state.runtime_config.enable_dtx = rtc::Optional<bool>(!kEnableDtx);
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+}
+
+TEST(EventLogWriterTest, LogOnChannelChange) {
+  auto state = CreateEventLogWriter();
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+
+  state.runtime_config.num_channels = rtc::Optional<size_t>(kNumChannels + 1);
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+}
+
+TEST(EventLogWriterTest, LogOnFrameLengthChange) {
+  auto state = CreateEventLogWriter();
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+
+  state.runtime_config.frame_length_ms = rtc::Optional<int>(20);
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+}
+
+TEST(EventLogWriterTest, DoNotLogSmallBitrateChange) {
+  auto state = CreateEventLogWriter();
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+  state.runtime_config.bitrate_bps =
+      rtc::Optional<int>(kBitrateBps + kMinBitreateChangeBps - 1);

[minyue-webrtc, 2016/12/20 10:39:29]

bitrate

[michaelt, 2016/12/20 13:41:41]

Done.

+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+}
+
+TEST(EventLogWriterTest, LogBigBitrateChange) {
+  auto state = CreateEventLogWriter();
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+  state.runtime_config.bitrate_bps =
+      rtc::Optional<int>(kBitrateBps + kMinBitreateChangeBps);
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+}
+
+TEST(EventLogWriterTest, DoNotLogSmallPacketLossFractionChange) {
+  auto state = CreateEventLogWriter();
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+  state.runtime_config.uplink_packet_loss_fraction = rtc::Optional<float>(
+      kPacketLossFraction + kMinPacketLossChangeFraction * kPacketLossFraction -
+      0.001);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+}
+
+TEST(EventLogWriterTest, LogBigPacketLossFractionChange) {
+  auto state = CreateEventLogWriter();
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+  state.runtime_config.uplink_packet_loss_fraction = rtc::Optional<float>(
+      kPacketLossFraction + kMinPacketLossChangeFraction * kPacketLossFraction);
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+}
+
+TEST(EventLogWriterTest, LogJustOnceOnMultipleChanges) {
+  auto state = CreateEventLogWriter();
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+  state.runtime_config.uplink_packet_loss_fraction = rtc::Optional<float>(
+      kPacketLossFraction + kMinPacketLossChangeFraction * kPacketLossFraction);
+  state.runtime_config.frame_length_ms = rtc::Optional<int>(20);
+  ExpectLogEncoderRuntimeConfig(state.event_log, state.runtime_config);
+  state.event_log_writer->MayLogEncoderRuntimeConfig(state.runtime_config);
+}
+}  // namespace webrtc