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
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
/*
* Copyright (c) 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/test_main_lib.h"
#include <fstream>
#include <memory>
#include <string>
#include "absl/flags/flag.h"
#include "absl/flags/parse.h"
#include "absl/memory/memory.h"
#include "absl/types/optional.h"
#include "rtc_base/checks.h"
#include "rtc_base/event_tracer.h"
#include "rtc_base/logging.h"
#include "rtc_base/ssl_adapter.h"
#include "rtc_base/ssl_stream_adapter.h"
#include "rtc_base/thread.h"
#include "system_wrappers/include/field_trial.h"
#include "system_wrappers/include/metrics.h"
#include "test/field_trial.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/testsupport/perf_test.h"
#include "test/testsupport/resources_dir_flag.h"
#if defined(WEBRTC_WIN)
#include "rtc_base/win32_socket_init.h"
#endif
#if defined(WEBRTC_IOS)
#include "test/ios/test_support.h"
ABSL_FLAG(std::string,
NSTreatUnknownArgumentsAsOpen,
"",
"Intentionally ignored flag intended for iOS simulator.");
ABSL_FLAG(std::string,
ApplePersistenceIgnoreState,
"",
"Intentionally ignored flag intended for iOS simulator.");
// This is the cousin of isolated_script_test_perf_output, but we can't dictate
// where to write on iOS so the semantics of this flag are a bit different.
ABSL_FLAG(
bool,
write_perf_output_on_ios,
false,
"Store the perf results in Documents/perftest_result.pb in the format "
"described by histogram.proto in "
"https://chromium.googlesource.com/catapult/.");
#else
ABSL_FLAG(
std::string,
isolated_script_test_perf_output,
"",
"Path where the perf results should be stored in proto format described "
"described by histogram.proto in "
"https://chromium.googlesource.com/catapult/.");
#endif
constexpr char kPlotAllMetrics[] = "all";
ABSL_FLAG(std::vector<std::string>,
plot,
{},
"List of metrics that should be exported for plotting (if they are "
"available). Example: psnr,ssim,encode_time. To plot all available "
" metrics pass 'all' as flag value");
ABSL_FLAG(bool, logs, true, "print logs to stderr");
ABSL_FLAG(bool, verbose, false, "verbose logs to stderr");
ABSL_FLAG(std::string,
trace_event,
"",
"Path to collect trace events (json file) for chrome://tracing. "
"If not set, events aren't captured.");
ABSL_FLAG(std::string,
force_fieldtrials,
"",
"Field trials control experimental feature code which can be forced. "
"E.g. running with --force_fieldtrials=WebRTC-FooFeature/Enable/"
" will assign the group Enable to field trial WebRTC-FooFeature.");
namespace webrtc {
namespace {
class TestMainImpl : public TestMain {
public:
int Init(int* argc, char* argv[]) override {
::testing::InitGoogleMock(argc, argv);
absl::ParseCommandLine(*argc, argv);
// Make sure we always pull in the --resources_dir flag, even if the test
// binary doesn't link with fileutils (downstream expects all test mains to
// have this flag).
(void)absl::GetFlag(FLAGS_resources_dir);
// Default to LS_INFO, even for release builds to provide better test
// logging.
if (rtc::LogMessage::GetLogToDebug() > rtc::LS_INFO)
rtc::LogMessage::LogToDebug(rtc::LS_INFO);
if (absl::GetFlag(FLAGS_verbose))
rtc::LogMessage::LogToDebug(rtc::LS_VERBOSE);
rtc::LogMessage::SetLogToStderr(absl::GetFlag(FLAGS_logs) ||
absl::GetFlag(FLAGS_verbose));
// InitFieldTrialsFromString stores the char*, so the char array must
// outlive the application.
field_trials_ = absl::GetFlag(FLAGS_force_fieldtrials);
webrtc::field_trial::InitFieldTrialsFromString(field_trials_.c_str());
webrtc::metrics::Enable();
#if defined(WEBRTC_WIN)
winsock_init_ = std::make_unique<rtc::WinsockInitializer>();
#endif
// Initialize SSL which are used by several tests.
rtc::InitializeSSL();
rtc::SSLStreamAdapter::EnableTimeCallbackForTesting();
// Ensure that main thread gets wrapped as an rtc::Thread.
// TODO(bugs.webrt.org/9714): It might be better to avoid wrapping the main
// thread, or leave it to individual tests that need it. But as long as we
// have automatic thread wrapping, we need this to avoid that some other
// random thread (which one depending on which tests are run) gets
// automatically wrapped.
rtc::ThreadManager::Instance()->WrapCurrentThread();
RTC_CHECK(rtc::Thread::Current());
return 0;
}
int Run(int argc, char* argv[]) override {
std::string trace_event_path = absl::GetFlag(FLAGS_trace_event);
const bool capture_events = !trace_event_path.empty();
if (capture_events) {
rtc::tracing::SetupInternalTracer();
rtc::tracing::StartInternalCapture(trace_event_path.c_str());
}
absl::optional<std::vector<std::string>> metrics_to_plot =
absl::GetFlag(FLAGS_plot);
if (metrics_to_plot->empty()) {
metrics_to_plot = absl::nullopt;
} else {
if (metrics_to_plot->size() == 1 &&
(*metrics_to_plot)[0] == kPlotAllMetrics) {
metrics_to_plot->clear();
}
}
#if defined(WEBRTC_IOS)
rtc::test::InitTestSuite(RUN_ALL_TESTS, argc, argv,
absl::GetFlag(FLAGS_write_perf_output_on_ios),
metrics_to_plot);
rtc::test::RunTestsFromIOSApp();
int exit_code = 0;
#else
int exit_code = RUN_ALL_TESTS();
std::string perf_output_file =
absl::GetFlag(FLAGS_isolated_script_test_perf_output);
if (!perf_output_file.empty()) {
if (!webrtc::test::WritePerfResults(perf_output_file)) {
return 1;
}
}
if (metrics_to_plot) {
webrtc::test::PrintPlottableResults(*metrics_to_plot);
}
#endif
if (capture_events) {
rtc::tracing::StopInternalCapture();
}
#if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) || \
defined(MEMORY_SANITIZER) || defined(THREAD_SANITIZER) || \
defined(UNDEFINED_SANITIZER)
// We want the test flagged as failed only for sanitizer defects,
// in which case the sanitizer will override exit code with 66.
exit_code = 0;
#endif
return exit_code;
}
~TestMainImpl() override = default;
private:
#if defined(WEBRTC_WIN)
std::unique_ptr<rtc::WinsockInitializer> winsock_init_;
#endif
};
} // namespace
std::unique_ptr<TestMain> TestMain::Create() {
return std::make_unique<TestMainImpl>();
}
} // namespace webrtc
|
