| /* | |
| * 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. | |
| */ | |
| #ifndef TEST_SCENARIO_SCENARIO_H_ | |
| #define TEST_SCENARIO_SCENARIO_H_ | |
| #include <memory> | |
| #include <string> | |
| #include <utility> | |
| #include <vector> | |
| #include "absl/functional/any_invocable.h" | |
| #include "absl/strings/string_view.h" | |
| #include "api/task_queue/task_queue_base.h" | |
| #include "api/test/time_controller.h" | |
| #include "rtc_base/fake_clock.h" | |
| #include "rtc_base/task_utils/repeating_task.h" | |
| #include "test/gtest.h" | |
| #include "test/logging/log_writer.h" | |
| #include "test/network/network_emulation_manager.h" | |
| #include "test/scenario/audio_stream.h" | |
| #include "test/scenario/call_client.h" | |
| #include "test/scenario/column_printer.h" | |
| #include "test/scenario/network_node.h" | |
| #include "test/scenario/scenario_config.h" | |
| #include "test/scenario/video_stream.h" | |
| namespace webrtc { | |
| namespace test { | |
| // Scenario is a class owning everything for a test scenario. It creates and | |
| // holds network nodes, call clients and media streams. It also provides methods | |
| // for changing behavior at runtime. Since it always keeps ownership of the | |
| // created components, it generally returns non-owning pointers. It maintains | |
| // the life of its objects until it is destroyed. | |
| // For methods accepting configuration structs, a modifier function interface is | |
| // generally provided. This allows simple partial overriding of the default | |
| // configuration. | |
| class Scenario { | |
| public: | |
| Scenario(); | |
| explicit Scenario(const testing::TestInfo* test_info); | |
| explicit Scenario(absl::string_view file_name); | |
| Scenario(absl::string_view file_name, bool real_time); | |
| Scenario(std::unique_ptr<LogWriterFactoryInterface> log_writer_manager, | |
| bool real_time); | |
| ~Scenario(); | |
| Scenario(const Scenario&) = delete; | |
| Scenario& operator=(const Scenario&) = delete; | |
| NetworkEmulationManagerImpl* net() { return &network_manager_; } | |
| EmulatedNetworkNode* CreateSimulationNode(NetworkSimulationConfig config); | |
| EmulatedNetworkNode* CreateSimulationNode( | |
| std::function<void(NetworkSimulationConfig*)> config_modifier); | |
| SimulationNode* CreateMutableSimulationNode(NetworkSimulationConfig config); | |
| SimulationNode* CreateMutableSimulationNode( | |
| std::function<void(NetworkSimulationConfig*)> config_modifier); | |
| CallClient* CreateClient(absl::string_view name, CallClientConfig config); | |
| CallClient* CreateClient( | |
| absl::string_view name, | |
| std::function<void(CallClientConfig*)> config_modifier); | |
| CallClientPair* CreateRoutes(CallClient* first, | |
| std::vector<EmulatedNetworkNode*> send_link, | |
| CallClient* second, | |
| std::vector<EmulatedNetworkNode*> return_link); | |
| CallClientPair* CreateRoutes(CallClient* first, | |
| std::vector<EmulatedNetworkNode*> send_link, | |
| DataSize first_overhead, | |
| CallClient* second, | |
| std::vector<EmulatedNetworkNode*> return_link, | |
| DataSize second_overhead); | |
| void ChangeRoute(std::pair<CallClient*, CallClient*> clients, | |
| std::vector<EmulatedNetworkNode*> over_nodes); | |
| void ChangeRoute(std::pair<CallClient*, CallClient*> clients, | |
| std::vector<EmulatedNetworkNode*> over_nodes, | |
| DataSize overhead); | |
| VideoStreamPair* CreateVideoStream( | |
| std::pair<CallClient*, CallClient*> clients, | |
| std::function<void(VideoStreamConfig*)> config_modifier); | |
| VideoStreamPair* CreateVideoStream( | |
| std::pair<CallClient*, CallClient*> clients, | |
| VideoStreamConfig config); | |
| AudioStreamPair* CreateAudioStream( | |
| std::pair<CallClient*, CallClient*> clients, | |
| std::function<void(AudioStreamConfig*)> config_modifier); | |
| AudioStreamPair* CreateAudioStream( | |
| std::pair<CallClient*, CallClient*> clients, | |
| AudioStreamConfig config); | |
| // Runs the provided function with a fixed interval. For real time tests, | |
| // `function` starts being called after `interval` from the call to Every(). | |
| void Every(TimeDelta interval, absl::AnyInvocable<void(TimeDelta)> function); | |
| void Every(TimeDelta interval, absl::AnyInvocable<void()> function); | |
| // Runs the provided function on the internal task queue. This ensure that | |
| // it's run on the main thread for simulated time tests. | |
| void Post(absl::AnyInvocable<void() &&> function); | |
| // Runs the provided function after given duration has passed. For real time | |
| // tests, `function` is called after `target_time_since_start` from the call | |
| // to Every(). | |
| void At(TimeDelta offset, absl::AnyInvocable<void() &&> function); | |
| // Sends a packet over the nodes and runs `action` when it has been delivered. | |
| void NetworkDelayedAction(std::vector<EmulatedNetworkNode*> over_nodes, | |
| size_t packet_size, | |
| std::function<void()> action); | |
| // Runs the scenario for the given time. | |
| void RunFor(TimeDelta duration); | |
| // Runs the scenario until `target_time_since_start`. | |
| void RunUntil(TimeDelta target_time_since_start); | |
| // Runs the scenario until `target_time_since_start` or `exit_function` | |
| // returns true. `exit_function` is polled after each `check_interval` has | |
| // passed. | |
| void RunUntil(TimeDelta target_time_since_start, | |
| TimeDelta check_interval, | |
| std::function<bool()> exit_function); | |
| void Start(); | |
| void Stop(); | |
| // Triggers sending of dummy packets over the given nodes. | |
| void TriggerPacketBurst(std::vector<EmulatedNetworkNode*> over_nodes, | |
| size_t num_packets, | |
| size_t packet_size); | |
| ColumnPrinter TimePrinter(); | |
| StatesPrinter* CreatePrinter(absl::string_view name, | |
| TimeDelta interval, | |
| std::vector<ColumnPrinter> printers); | |
| // Returns the current time. | |
| Timestamp Now(); | |
| // Return the duration of the current session so far. | |
| TimeDelta TimeSinceStart(); | |
| std::unique_ptr<RtcEventLogOutput> GetLogWriter(absl::string_view name) { | |
| if (!log_writer_factory_ || name.empty()) | |
| return nullptr; | |
| return log_writer_factory_->Create(name); | |
| } | |
| std::unique_ptr<LogWriterFactoryInterface> GetLogWriterFactory( | |
| absl::string_view name) { | |
| if (!log_writer_factory_ || name.empty()) | |
| return nullptr; | |
| return std::make_unique<LogWriterFactoryAddPrefix>( | |
| log_writer_factory_.get(), name); | |
| } | |
| private: | |
| TimeDelta TimeUntilTarget(TimeDelta target_time_offset); | |
| const std::unique_ptr<LogWriterFactoryInterface> log_writer_factory_; | |
| NetworkEmulationManagerImpl network_manager_; | |
| Clock* clock_; | |
| std::vector<std::unique_ptr<CallClient>> clients_; | |
| std::vector<std::unique_ptr<CallClientPair>> client_pairs_; | |
| std::vector<std::unique_ptr<VideoStreamPair>> video_streams_; | |
| std::vector<std::unique_ptr<AudioStreamPair>> audio_streams_; | |
| std::vector<std::unique_ptr<SimulationNode>> simulation_nodes_; | |
| std::vector<std::unique_ptr<StatesPrinter>> printers_; | |
| rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory_; | |
| rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory_; | |
| Timestamp start_time_ = Timestamp::PlusInfinity(); | |
| // Defined last so it's destroyed first. | |
| std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue_; | |
| }; | |
| } // namespace test | |
| } // namespace webrtc | |
| #endif // TEST_SCENARIO_SCENARIO_H_ |