mirror of
https://github.com/klzgrad/naiveproxy.git
synced 2024-11-24 14:26:09 +03:00
118 lines
4.4 KiB
C++
118 lines
4.4 KiB
C++
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "base/test/test_timeouts.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include "base/command_line.h"
|
|
#include "base/debug/debugger.h"
|
|
#include "base/logging.h"
|
|
#include "base/strings/string_number_conversions.h"
|
|
#include "base/test/test_switches.h"
|
|
#include "build/build_config.h"
|
|
|
|
namespace {
|
|
|
|
// Sets value to the greatest of:
|
|
// 1) value's current value multiplied by kTimeoutMultiplier (assuming
|
|
// InitializeTimeout is called only once per value).
|
|
// 2) min_value.
|
|
// 3) the numerical value given by switch_name on the command line multiplied
|
|
// by kTimeoutMultiplier.
|
|
void InitializeTimeout(const char* switch_name, int min_value, int* value) {
|
|
DCHECK(value);
|
|
int command_line_timeout = 0;
|
|
if (base::CommandLine::ForCurrentProcess()->HasSwitch(switch_name)) {
|
|
std::string string_value(base::CommandLine::ForCurrentProcess()->
|
|
GetSwitchValueASCII(switch_name));
|
|
if (!base::StringToInt(string_value, &command_line_timeout)) {
|
|
LOG(FATAL) << "Timeout value \"" << string_value << "\" was parsed as "
|
|
<< command_line_timeout;
|
|
}
|
|
}
|
|
|
|
#if defined(MEMORY_SANITIZER)
|
|
// ASan/TSan/MSan instrument each memory access. This may slow the execution
|
|
// down significantly.
|
|
// For MSan the slowdown depends heavily on the value of msan_track_origins
|
|
// build flag. The multiplier below corresponds to msan_track_origins = 1.
|
|
constexpr int kTimeoutMultiplier = 6;
|
|
#elif defined(ADDRESS_SANITIZER) && defined(OS_WIN)
|
|
// ASan/Win has not been optimized yet, give it a higher
|
|
// timeout multiplier. See http://crbug.com/412471
|
|
constexpr int kTimeoutMultiplier = 3;
|
|
#elif defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER)
|
|
constexpr int kTimeoutMultiplier = 2;
|
|
#else
|
|
constexpr int kTimeoutMultiplier = 1;
|
|
#endif
|
|
|
|
*value = std::max(std::max(*value, command_line_timeout) * kTimeoutMultiplier,
|
|
min_value);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
// static
|
|
bool TestTimeouts::initialized_ = false;
|
|
|
|
// The timeout values should increase in the order they appear in this block.
|
|
// static
|
|
int TestTimeouts::tiny_timeout_ms_ = 100;
|
|
int TestTimeouts::action_timeout_ms_ = 10000;
|
|
#ifndef NDEBUG
|
|
int TestTimeouts::action_max_timeout_ms_ = 45000;
|
|
#else
|
|
int TestTimeouts::action_max_timeout_ms_ = 30000;
|
|
#endif // NDEBUG
|
|
|
|
int TestTimeouts::test_launcher_timeout_ms_ = 45000;
|
|
|
|
// static
|
|
void TestTimeouts::Initialize() {
|
|
DCHECK(!initialized_);
|
|
initialized_ = true;
|
|
|
|
if (base::debug::BeingDebugged()) {
|
|
fprintf(stdout,
|
|
"Detected presence of a debugger, running without test timeouts.\n");
|
|
}
|
|
|
|
// Note that these timeouts MUST be initialized in the correct order as
|
|
// per the CHECKS below.
|
|
|
|
InitializeTimeout(switches::kTestTinyTimeout, 0, &tiny_timeout_ms_);
|
|
|
|
// All timeouts other than the "tiny" one should be set to very large values
|
|
// when in a debugger or when run interactively, so that tests will not get
|
|
// auto-terminated. By setting the UI test action timeout to at least this
|
|
// value, we guarantee the subsequent timeouts will be this large also.
|
|
// Setting the "tiny" timeout to a large value as well would make some tests
|
|
// hang (because it's used as a task-posting delay). In particular this
|
|
// causes problems for some iOS device tests, which are always run inside a
|
|
// debugger (thus BeingDebugged() is true even on the bots).
|
|
int min_ui_test_action_timeout = tiny_timeout_ms_;
|
|
if (base::debug::BeingDebugged() ||
|
|
base::CommandLine::ForCurrentProcess()->HasSwitch(
|
|
switches::kTestLauncherInteractive)) {
|
|
constexpr int kVeryLargeTimeoutMs = 100'000'000;
|
|
min_ui_test_action_timeout = kVeryLargeTimeoutMs;
|
|
}
|
|
|
|
InitializeTimeout(switches::kUiTestActionTimeout, min_ui_test_action_timeout,
|
|
&action_timeout_ms_);
|
|
InitializeTimeout(switches::kUiTestActionMaxTimeout, action_timeout_ms_,
|
|
&action_max_timeout_ms_);
|
|
|
|
// Test launcher timeout is independent from anything above action timeout.
|
|
InitializeTimeout(switches::kTestLauncherTimeout, action_timeout_ms_,
|
|
&test_launcher_timeout_ms_);
|
|
|
|
// The timeout values should be increasing in the right order.
|
|
CHECK_LE(tiny_timeout_ms_, action_timeout_ms_);
|
|
CHECK_LE(action_timeout_ms_, action_max_timeout_ms_);
|
|
CHECK_LE(action_timeout_ms_, test_launcher_timeout_ms_);
|
|
}
|