Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 196 insertions, 0 deletions

diff --git a/third_party/libwebrtc/test/scenario/scenario_unittest.cc b/third_party/libwebrtc/test/scenario/scenario_unittest.cc
new file mode 100644
index 0000000000..6861151a2d
--- /dev/null
+++ b/third_party/libwebrtc/test/scenario/scenario_unittest.cc
@@ -0,0 +1,196 @@
+/*
+ *  Copyright 2018 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 "test/scenario/scenario.h"
+
+#include <atomic>
+
+#include "api/test/network_emulation/create_cross_traffic.h"
+#include "api/test/network_emulation/cross_traffic.h"
+#include "test/field_trial.h"
+#include "test/gtest.h"
+#include "test/logging/memory_log_writer.h"
+#include "test/scenario/stats_collection.h"
+
+namespace webrtc {
+namespace test {
+TEST(ScenarioTest, StartsAndStopsWithoutErrors) {
+  std::atomic<bool> packet_received(false);
+  std::atomic<bool> bitrate_changed(false);
+  Scenario s;
+  CallClientConfig call_client_config;
+  call_client_config.transport.rates.start_rate = DataRate::KilobitsPerSec(300);
+  auto* alice = s.CreateClient("alice", call_client_config);
+  auto* bob = s.CreateClient("bob", call_client_config);
+  NetworkSimulationConfig network_config;
+  auto alice_net = s.CreateSimulationNode(network_config);
+  auto bob_net = s.CreateSimulationNode(network_config);
+  auto route = s.CreateRoutes(alice, {alice_net}, bob, {bob_net});
+
+  VideoStreamConfig video_stream_config;
+  s.CreateVideoStream(route->forward(), video_stream_config);
+  s.CreateVideoStream(route->reverse(), video_stream_config);
+
+  AudioStreamConfig audio_stream_config;
+  audio_stream_config.encoder.min_rate = DataRate::KilobitsPerSec(6);
+  audio_stream_config.encoder.max_rate = DataRate::KilobitsPerSec(64);
+  audio_stream_config.encoder.allocate_bitrate = true;
+  audio_stream_config.stream.in_bandwidth_estimation = false;
+  s.CreateAudioStream(route->forward(), audio_stream_config);
+  s.CreateAudioStream(route->reverse(), audio_stream_config);
+
+  RandomWalkConfig cross_traffic_config;
+  s.net()->StartCrossTraffic(CreateRandomWalkCrossTraffic(
+      s.net()->CreateCrossTrafficRoute({alice_net}), cross_traffic_config));
+
+  s.NetworkDelayedAction({alice_net, bob_net}, 100,
+                         [&packet_received] { packet_received = true; });
+  s.Every(TimeDelta::Millis(10), [alice, bob, &bitrate_changed] {
+    if (alice->GetStats().send_bandwidth_bps != 300000 &&
+        bob->GetStats().send_bandwidth_bps != 300000)
+      bitrate_changed = true;
+  });
+  s.RunUntil(TimeDelta::Seconds(2), TimeDelta::Millis(5),
+             [&bitrate_changed, &packet_received] {
+               return packet_received && bitrate_changed;
+             });
+  EXPECT_TRUE(packet_received);
+  EXPECT_TRUE(bitrate_changed);
+}
+namespace {
+void SetupVideoCall(Scenario& s, VideoQualityAnalyzer* analyzer) {
+  CallClientConfig call_config;
+  auto* alice = s.CreateClient("alice", call_config);
+  auto* bob = s.CreateClient("bob", call_config);
+  NetworkSimulationConfig network_config;
+  network_config.bandwidth = DataRate::KilobitsPerSec(1000);
+  network_config.delay = TimeDelta::Millis(50);
+  auto alice_net = s.CreateSimulationNode(network_config);
+  auto bob_net = s.CreateSimulationNode(network_config);
+  auto route = s.CreateRoutes(alice, {alice_net}, bob, {bob_net});
+  VideoStreamConfig video;
+  if (analyzer) {
+    video.source.capture = VideoStreamConfig::Source::Capture::kVideoFile;
+    video.source.video_file.name = "foreman_cif";
+    video.source.video_file.width = 352;
+    video.source.video_file.height = 288;
+    video.source.framerate = 30;
+    video.encoder.codec = VideoStreamConfig::Encoder::Codec::kVideoCodecVP8;
+    video.encoder.implementation =
+        VideoStreamConfig::Encoder::Implementation::kSoftware;
+    video.hooks.frame_pair_handlers = {analyzer->Handler()};
+  }
+  s.CreateVideoStream(route->forward(), video);
+  s.CreateAudioStream(route->forward(), AudioStreamConfig());
+}
+}  // namespace
+
+TEST(ScenarioTest, SimTimeEncoding) {
+  VideoQualityAnalyzerConfig analyzer_config;
+  analyzer_config.psnr_coverage = 0.1;
+  VideoQualityAnalyzer analyzer(analyzer_config);
+  {
+    Scenario s("scenario/encode_sim", false);
+    SetupVideoCall(s, &analyzer);
+    s.RunFor(TimeDelta::Seconds(2));
+  }
+  // Regression tests based on previous runs.
+  EXPECT_EQ(analyzer.stats().lost_count, 0);
+  EXPECT_NEAR(analyzer.stats().psnr_with_freeze.Mean(), 38, 5);
+}
+
+// TODO(bugs.webrtc.org/10515): Remove this when performance has been improved.
+#if defined(WEBRTC_IOS) && defined(WEBRTC_ARCH_ARM64) && !defined(NDEBUG)
+#define MAYBE_RealTimeEncoding DISABLED_RealTimeEncoding
+#else
+#define MAYBE_RealTimeEncoding RealTimeEncoding
+#endif
+TEST(ScenarioTest, MAYBE_RealTimeEncoding) {
+  VideoQualityAnalyzerConfig analyzer_config;
+  analyzer_config.psnr_coverage = 0.1;
+  VideoQualityAnalyzer analyzer(analyzer_config);
+  {
+    Scenario s("scenario/encode_real", true);
+    SetupVideoCall(s, &analyzer);
+    s.RunFor(TimeDelta::Seconds(2));
+  }
+  // Regression tests based on previous runs.
+  EXPECT_LT(analyzer.stats().lost_count, 2);
+  // This far below expected but ensures that we get something.
+  EXPECT_GT(analyzer.stats().psnr_with_freeze.Mean(), 10);
+}
+
+TEST(ScenarioTest, SimTimeFakeing) {
+  Scenario s("scenario/encode_sim", false);
+  SetupVideoCall(s, nullptr);
+  s.RunFor(TimeDelta::Seconds(2));
+}
+
+TEST(ScenarioTest, WritesToRtcEventLog) {
+  MemoryLogStorage storage;
+  {
+    Scenario s(storage.CreateFactory(), false);
+    SetupVideoCall(s, nullptr);
+    s.RunFor(TimeDelta::Seconds(1));
+  }
+  auto logs = storage.logs();
+  // We expect that a rtc event log has been created and that it has some data.
+  EXPECT_GE(storage.logs().at("alice.rtc.dat").size(), 1u);
+}
+
+TEST(ScenarioTest,
+     RetransmitsVideoPacketsInAudioAndVideoCallWithSendSideBweAndLoss) {
+  // Make sure audio packets are included in transport feedback.
+  test::ScopedFieldTrials override_field_trials(
+      "WebRTC-Audio-ABWENoTWCC/Disabled/");
+
+  Scenario s;
+  CallClientConfig call_client_config;
+  call_client_config.transport.rates.start_rate = DataRate::KilobitsPerSec(300);
+  auto* alice = s.CreateClient("alice", call_client_config);
+  auto* bob = s.CreateClient("bob", call_client_config);
+  NetworkSimulationConfig network_config;
+  // Add some loss and delay.
+  network_config.delay = TimeDelta::Millis(200);
+  network_config.loss_rate = 0.05;
+  auto alice_net = s.CreateSimulationNode(network_config);
+  auto bob_net = s.CreateSimulationNode(network_config);
+  auto route = s.CreateRoutes(alice, {alice_net}, bob, {bob_net});
+
+  // First add an audio stream, then a video stream.
+  // Needed to make sure audio RTP module is selected first when sending
+  // transport feedback message.
+  AudioStreamConfig audio_stream_config;
+  audio_stream_config.encoder.min_rate = DataRate::KilobitsPerSec(6);
+  audio_stream_config.encoder.max_rate = DataRate::KilobitsPerSec(64);
+  audio_stream_config.encoder.allocate_bitrate = true;
+  audio_stream_config.stream.in_bandwidth_estimation = true;
+  s.CreateAudioStream(route->forward(), audio_stream_config);
+  s.CreateAudioStream(route->reverse(), audio_stream_config);
+
+  VideoStreamConfig video_stream_config;
+  auto video = s.CreateVideoStream(route->forward(), video_stream_config);
+  s.CreateVideoStream(route->reverse(), video_stream_config);
+
+  // Run for 10 seconds.
+  s.RunFor(TimeDelta::Seconds(10));
+  // Make sure retransmissions have happened.
+  int retransmit_packets = 0;
+
+  VideoSendStream::Stats stats;
+  alice->SendTask([&]() { stats = video->send()->GetStats(); });
+
+  for (const auto& substream : stats.substreams) {
+    retransmit_packets += substream.second.rtp_stats.retransmitted.packets;
+  }
+  EXPECT_GT(retransmit_packets, 0);
+}
+
+}  // namespace test
+}  // namespace webrtc