1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
/*
* 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_;
scoped_refptr<AudioDecoderFactory> audio_decoder_factory_;
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_
|
