Revert "[base] Make test Run() timeouts fatal unless using GTest."
This reverts commit e7f522eeb9
.
Reason for revert: suspect causing compile failure on linux-chromeos-chrome.
Sample build: https://ci.chromium.org/p/chrome/builders/ci/linux-chromeos-chrome/2923
Sample log: https://logs.chromium.org/logs/chrome/buildbucket/cr-buildbucket.appspot.com/8888898680396285712/+/steps/compile/0/stdout?format=raw
E.g.
../../chrome/browser/ui/ash/assistant/assistant_test_mixin.cc:323:42: error: variable has incomplete type 'const base::test::ScopedRunLoopTimeout'
const base::test::ScopedRunLoopTimeout run_timeout(wait_timeout);
^
../../base/run_loop.h:28:7: note: forward declaration of 'base::test::ScopedRunLoopTimeout'
class ScopedRunLoopTimeout;
^
../../chrome/browser/ui/ash/assistant/assistant_test_mixin.cc:356:42: error: variable has incomplete type 'const base::test::ScopedRunLoopTimeout'
const base::test::ScopedRunLoopTimeout run_timeout(wait_timeout);
^
../../base/run_loop.h:28:7: note: forward declaration of 'base::test::ScopedRunLoopTimeout'
class ScopedRunLoopTimeout;
^
../../chrome/browser/ui/ash/assistant/assistant_test_mixin.cc:371:42: error: variable has incomplete type 'const base::test::ScopedRunLoopTimeout'
const base::test::ScopedRunLoopTimeout run_timeout(wait_timeout);
^
../../base/run_loop.h:28:7: note: forward declaration of 'base::test::ScopedRunLoopTimeout'
class ScopedRunLoopTimeout;
^
3 errors generated.
Original change's description:
> [base] Make test Run() timeouts fatal unless using GTest.
>
> The Run() timeouts set for tests now default to crashing the calling
> process. This ensures that Run() timeouts cause visible failures
> regardless of whether the calling suite uses GTest. Suites which do use
> GTest can switch to having timeouts reported via GTEST_FAIL() by calling:
>
> base::test::ScopedRunLoopTimeout::SetUseGTestFailOnTimeout();
>
> Test suites derived from base::TestSuite will have this option set for
> them as part of the TestSuite initialization.
>
> The RunLoop::ScopedRunTimeoutForTest helper is moved to
> base::test::ScopedRunLoopTimeout, to allow it to have GTest dependencies.
>
> Bug: 1021777, 1014767
> Change-Id: Id372c666c6455e56e52034ae528b417a0c23143c
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1932464
> Commit-Queue: Wez <wez@chromium.org>
> Auto-Submit: Wez <wez@chromium.org>
> Reviewed-by: Scott Violet <sky@chromium.org>
> Reviewed-by: Gabriel Charette <gab@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#739760}
TBR=sky@chromium.org,wez@chromium.org,gab@chromium.org,kmarshall@chromium.org
Change-Id: Ib0927699042f216971448da8b1d70619c0545367
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 1021777, 1014767
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2045697
Reviewed-by: Takashi Sakamoto <tasak@google.com>
Commit-Queue: Takashi Sakamoto <tasak@google.com>
Cr-Commit-Position: refs/heads/master@{#739790}
This commit is contained in:

committed by
Commit Bot

parent
736aeeec58
commit
21fa8d0bbd
base
chrome
browser
service
cloud_print
components/visitedlink/test
content
docs
media/test
net/nqe
services/network/public/cpp
third_party/blink/renderer/modules/peerconnection
ui
@ -2700,7 +2700,6 @@ test("base_unittests") {
|
||||
"test/scoped_feature_list_unittest.cc",
|
||||
"test/scoped_mock_clock_override_unittest.cc",
|
||||
"test/scoped_mock_time_message_loop_task_runner_unittest.cc",
|
||||
"test/scoped_run_loop_timeout_unittest.cc",
|
||||
"test/task_environment_unittest.cc",
|
||||
"test/test_mock_time_task_runner_unittest.cc",
|
||||
"test/test_pending_task_unittest.cc",
|
||||
|
@ -15,7 +15,9 @@ namespace base {
|
||||
namespace fuchsia {
|
||||
|
||||
ServiceDirectoryTestBase::ServiceDirectoryTestBase()
|
||||
: run_timeout_(TestTimeouts::action_timeout()) {
|
||||
: run_timeout_(TestTimeouts::action_timeout(), BindRepeating([]() {
|
||||
ADD_FAILURE() << "Run() timed out.";
|
||||
})) {
|
||||
// Mount service dir and publish the service.
|
||||
outgoing_directory_ = std::make_unique<sys::OutgoingDirectory>();
|
||||
fidl::InterfaceHandle<::fuchsia::io::Directory> directory;
|
||||
|
@ -13,7 +13,7 @@
|
||||
#include "base/fuchsia/scoped_service_binding.h"
|
||||
#include "base/fuchsia/test_interface_impl.h"
|
||||
#include "base/fuchsia/testfidl/cpp/fidl.h"
|
||||
#include "base/test/scoped_run_loop_timeout.h"
|
||||
#include "base/run_loop.h"
|
||||
#include "base/test/task_environment.h"
|
||||
#include "testing/gtest/include/gtest/gtest.h"
|
||||
|
||||
@ -29,7 +29,7 @@ class ServiceDirectoryTestBase : public testing::Test {
|
||||
zx_status_t expected_error);
|
||||
|
||||
protected:
|
||||
const test::ScopedRunLoopTimeout run_timeout_;
|
||||
const RunLoop::ScopedRunTimeoutForTest run_timeout_;
|
||||
|
||||
base::test::SingleThreadTaskEnvironment task_environment_{
|
||||
base::test::SingleThreadTaskEnvironment::MainThreadType::IO};
|
||||
|
@ -34,18 +34,49 @@ void ProxyToTaskRunner(scoped_refptr<SequencedTaskRunner> task_runner,
|
||||
task_runner->PostTask(FROM_HERE, std::move(closure));
|
||||
}
|
||||
|
||||
ThreadLocalPointer<const RunLoop::RunLoopTimeout>& RunLoopTimeoutTLS() {
|
||||
static NoDestructor<ThreadLocalPointer<const RunLoop::RunLoopTimeout>> tls;
|
||||
ThreadLocalPointer<RunLoop::ScopedRunTimeoutForTest>&
|
||||
ScopedRunTimeoutForTestTLS() {
|
||||
static NoDestructor<ThreadLocalPointer<RunLoop::ScopedRunTimeoutForTest>> tls;
|
||||
return *tls;
|
||||
}
|
||||
|
||||
void OnRunLoopTimeout(RunLoop* run_loop, OnceClosure on_timeout) {
|
||||
void OnRunTimeout(RunLoop* run_loop, OnceClosure on_timeout) {
|
||||
run_loop->Quit();
|
||||
std::move(on_timeout).Run();
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
RunLoop::ScopedRunTimeoutForTest::ScopedRunTimeoutForTest(
|
||||
TimeDelta timeout,
|
||||
RepeatingClosure on_timeout)
|
||||
: timeout_(timeout),
|
||||
on_timeout_(std::move(on_timeout)),
|
||||
nested_timeout_(ScopedRunTimeoutForTestTLS().Get()) {
|
||||
DCHECK_GT(timeout_, TimeDelta());
|
||||
DCHECK(on_timeout_);
|
||||
ScopedRunTimeoutForTestTLS().Set(this);
|
||||
}
|
||||
|
||||
RunLoop::ScopedRunTimeoutForTest::~ScopedRunTimeoutForTest() {
|
||||
ScopedRunTimeoutForTestTLS().Set(nested_timeout_);
|
||||
}
|
||||
|
||||
// static
|
||||
const RunLoop::ScopedRunTimeoutForTest*
|
||||
RunLoop::ScopedRunTimeoutForTest::Current() {
|
||||
return ScopedRunTimeoutForTestTLS().Get();
|
||||
}
|
||||
|
||||
RunLoop::ScopedDisableRunTimeoutForTest::ScopedDisableRunTimeoutForTest()
|
||||
: nested_timeout_(ScopedRunTimeoutForTestTLS().Get()) {
|
||||
ScopedRunTimeoutForTestTLS().Set(nullptr);
|
||||
}
|
||||
|
||||
RunLoop::ScopedDisableRunTimeoutForTest::~ScopedDisableRunTimeoutForTest() {
|
||||
ScopedRunTimeoutForTestTLS().Set(nested_timeout_);
|
||||
}
|
||||
|
||||
RunLoop::Delegate::Delegate() {
|
||||
// The Delegate can be created on another thread. It is only bound in
|
||||
// RegisterDelegateForCurrentThread().
|
||||
@ -106,16 +137,16 @@ void RunLoop::Run() {
|
||||
if (!BeforeRun())
|
||||
return;
|
||||
|
||||
// If there is a RunLoopTimeout active then set the timeout.
|
||||
// If there is a ScopedRunTimeoutForTest active then set the timeout.
|
||||
// TODO(crbug.com/905412): Use real-time for Run() timeouts so that they
|
||||
// can be applied even in tests which mock TimeTicks::Now().
|
||||
CancelableOnceClosure cancelable_timeout;
|
||||
const RunLoopTimeout* run_timeout = GetTimeoutForCurrentThread();
|
||||
ScopedRunTimeoutForTest* run_timeout = ScopedRunTimeoutForTestTLS().Get();
|
||||
if (run_timeout) {
|
||||
cancelable_timeout.Reset(
|
||||
BindOnce(&OnRunLoopTimeout, Unretained(this), run_timeout->on_timeout));
|
||||
origin_task_runner_->PostDelayedTask(
|
||||
FROM_HERE, cancelable_timeout.callback(), run_timeout->timeout);
|
||||
BindOnce(&OnRunTimeout, Unretained(this), run_timeout->on_timeout()));
|
||||
ThreadTaskRunnerHandle::Get()->PostDelayedTask(
|
||||
FROM_HERE, cancelable_timeout.callback(), run_timeout->timeout());
|
||||
}
|
||||
|
||||
DCHECK_EQ(this, delegate_->active_run_loops_.top());
|
||||
@ -273,12 +304,10 @@ RunLoop::ScopedDisallowRunningForTesting::~ScopedDisallowRunningForTesting() =
|
||||
#endif // DCHECK_IS_ON()
|
||||
|
||||
void RunLoop::RunUntilConditionForTest(RepeatingCallback<bool()> condition) {
|
||||
CHECK(GetTimeoutForCurrentThread());
|
||||
const RunLoopTimeout* old_timeout = GetTimeoutForCurrentThread();
|
||||
RunLoopTimeout run_timeout;
|
||||
run_timeout.timeout = old_timeout->timeout;
|
||||
run_timeout.on_timeout = DoNothing();
|
||||
RunLoopTimeoutTLS().Set(&run_timeout);
|
||||
CHECK(ScopedRunTimeoutForTest::Current());
|
||||
OnceClosure on_failure = ScopedRunTimeoutForTest::Current()->on_timeout();
|
||||
ScopedRunTimeoutForTest run_timeout(
|
||||
ScopedRunTimeoutForTest::Current()->timeout(), DoNothing());
|
||||
auto check_condition = BindRepeating(
|
||||
[](const RepeatingCallback<bool()>& condition, RunLoop* loop) {
|
||||
if (condition.Run())
|
||||
@ -290,22 +319,7 @@ void RunLoop::RunUntilConditionForTest(RepeatingCallback<bool()> condition) {
|
||||
check_condition);
|
||||
Run();
|
||||
if (!condition.Run())
|
||||
old_timeout->on_timeout.Run();
|
||||
RunLoopTimeoutTLS().Set(old_timeout);
|
||||
}
|
||||
|
||||
RunLoop::RunLoopTimeout::RunLoopTimeout() = default;
|
||||
|
||||
RunLoop::RunLoopTimeout::~RunLoopTimeout() = default;
|
||||
|
||||
// static
|
||||
void RunLoop::SetTimeoutForCurrentThread(const RunLoopTimeout* timeout) {
|
||||
RunLoopTimeoutTLS().Set(timeout);
|
||||
}
|
||||
|
||||
// static
|
||||
const RunLoop::RunLoopTimeout* RunLoop::GetTimeoutForCurrentThread() {
|
||||
return RunLoopTimeoutTLS().Get();
|
||||
std::move(on_failure).Run();
|
||||
}
|
||||
|
||||
bool RunLoop::BeforeRun() {
|
||||
|
@ -12,7 +12,6 @@
|
||||
#include "base/callback.h"
|
||||
#include "base/compiler_specific.h"
|
||||
#include "base/containers/stack.h"
|
||||
#include "base/gtest_prod_util.h"
|
||||
#include "base/macros.h"
|
||||
#include "base/memory/ref_counted.h"
|
||||
#include "base/memory/weak_ptr.h"
|
||||
@ -23,12 +22,6 @@
|
||||
#include "build/build_config.h"
|
||||
|
||||
namespace base {
|
||||
|
||||
namespace test {
|
||||
class ScopedRunLoopTimeout;
|
||||
class ScopedDisableRunLoopTimeout;
|
||||
} // namespace test
|
||||
|
||||
#if defined(OS_ANDROID)
|
||||
class MessagePumpForUI;
|
||||
#endif
|
||||
@ -253,6 +246,65 @@ class BASE_EXPORT RunLoop {
|
||||
static void QuitCurrentWhenIdleDeprecated();
|
||||
static RepeatingClosure QuitCurrentWhenIdleClosureDeprecated();
|
||||
|
||||
// Configures all RunLoop::Run() calls on the current thread to run the
|
||||
// supplied |on_timeout| callback if they run for longer than |timeout|.
|
||||
//
|
||||
// Specifying Run() timeouts per-thread avoids the need to cope with Run()s
|
||||
// executing concurrently with ScopedRunTimeoutForTest initialization or
|
||||
// teardown, and allows "default" timeouts to be specified by suites, rather
|
||||
// than explicitly configuring them for every RunLoop, in each test.
|
||||
//
|
||||
// Tests can temporarily override any currently-active Run() timeout, e.g. to
|
||||
// allow a step to Run() for longer than the suite's default timeout, by
|
||||
// creating a new ScopedRunTimeoutForTest on their stack, e.g:
|
||||
//
|
||||
// ScopedRunTimeoutForTest default_timeout(kDefaultRunTimeout, on_timeout);
|
||||
// ... do other test stuff ...
|
||||
// RunLoop().Run(); // Run for up to kDefaultRunTimeout.
|
||||
// ...
|
||||
// {
|
||||
// ScopedRunTimeoutForTest specific_timeout(kTestSpecificTimeout, ...);
|
||||
// RunLoop().Run(); // Run for up to kTestSpecificTimeout.
|
||||
// }
|
||||
// ...
|
||||
// RunLoop().Run(); // Run for up to kDefaultRunTimeout.
|
||||
//
|
||||
// The currently-active timeout can also be temporarily disabled:
|
||||
// ScopedDisableRunTimeoutForTest disable_timeout;
|
||||
//
|
||||
// TaskEnvironment applies a default Run() timeout after which a
|
||||
// LOG(FATAL) is performed, to dump a crash stack for diagnosis. Tests adding
|
||||
// their own Run() timeouts can use e.g. MakeExpectedNotRunClosure().
|
||||
|
||||
class BASE_EXPORT ScopedRunTimeoutForTest {
|
||||
public:
|
||||
ScopedRunTimeoutForTest(TimeDelta timeout, RepeatingClosure on_timeout);
|
||||
~ScopedRunTimeoutForTest();
|
||||
|
||||
// Returns the active ScopedRunTimeoutForTest on the calling thread, if any,
|
||||
// or null otherwise.
|
||||
static const RunLoop::ScopedRunTimeoutForTest* Current();
|
||||
|
||||
TimeDelta timeout() const { return timeout_; }
|
||||
const RepeatingClosure& on_timeout() const { return on_timeout_; }
|
||||
|
||||
private:
|
||||
const TimeDelta timeout_;
|
||||
const RepeatingClosure on_timeout_;
|
||||
ScopedRunTimeoutForTest* const nested_timeout_;
|
||||
DISALLOW_COPY_AND_ASSIGN(ScopedRunTimeoutForTest);
|
||||
};
|
||||
|
||||
class BASE_EXPORT ScopedDisableRunTimeoutForTest {
|
||||
public:
|
||||
ScopedDisableRunTimeoutForTest();
|
||||
~ScopedDisableRunTimeoutForTest();
|
||||
|
||||
private:
|
||||
ScopedRunTimeoutForTest* const nested_timeout_;
|
||||
DISALLOW_COPY_AND_ASSIGN(ScopedDisableRunTimeoutForTest);
|
||||
};
|
||||
|
||||
// Run() will DCHECK if called while there's a ScopedDisallowRunningForTesting
|
||||
// in scope on its thread. This is useful to add safety to some test
|
||||
// constructs which allow multiple task runners to share the main thread in
|
||||
@ -283,15 +335,6 @@ class BASE_EXPORT RunLoop {
|
||||
// is not feasible. Use Run() and QuitClosure() where possible.
|
||||
void RunUntilConditionForTest(RepeatingCallback<bool()> condition);
|
||||
|
||||
// Support for //base/test/scoped_run_loop_timeout.h.
|
||||
// This must be public for access by the implementation code in run_loop.cc.
|
||||
struct BASE_EXPORT RunLoopTimeout {
|
||||
RunLoopTimeout();
|
||||
~RunLoopTimeout();
|
||||
TimeDelta timeout;
|
||||
RepeatingClosure on_timeout;
|
||||
};
|
||||
|
||||
private:
|
||||
FRIEND_TEST_ALL_PREFIXES(MessageLoopTypedTest, RunLoopQuitOrderAfter);
|
||||
|
||||
@ -307,13 +350,6 @@ class BASE_EXPORT RunLoop {
|
||||
friend class MessagePumpUIApplication;
|
||||
#endif
|
||||
|
||||
// Support for //base/test/scoped_run_loop_timeout.h.
|
||||
friend class test::ScopedRunLoopTimeout;
|
||||
friend class test::ScopedDisableRunLoopTimeout;
|
||||
|
||||
static void SetTimeoutForCurrentThread(const RunLoopTimeout* timeout);
|
||||
static const RunLoopTimeout* GetTimeoutForCurrentThread();
|
||||
|
||||
// Return false to abort the Run.
|
||||
bool BeforeRun();
|
||||
void AfterRun();
|
||||
|
@ -19,7 +19,6 @@
|
||||
#include "base/synchronization/waitable_event.h"
|
||||
#include "base/test/bind_test_util.h"
|
||||
#include "base/test/gtest_util.h"
|
||||
#include "base/test/scoped_run_loop_timeout.h"
|
||||
#include "base/test/task_environment.h"
|
||||
#include "base/test/test_timeouts.h"
|
||||
#include "base/threading/platform_thread.h"
|
||||
@ -556,11 +555,10 @@ TEST(RunLoopUntilConditionTest, FailsTestOnTimeout) {
|
||||
|
||||
// Expect the Run() timeout to be run when |condition| is false and the loop
|
||||
// times out.
|
||||
const test::ScopedRunLoopTimeout short_timeout(
|
||||
TimeDelta::FromMilliseconds(10));
|
||||
EXPECT_FATAL_FAILURE(
|
||||
RunLoop().RunUntilConditionForTest(BindRepeating([]() { return false; })),
|
||||
"RunLoop::Run() timed out.");
|
||||
const RunLoop::ScopedRunTimeoutForTest short_timeout(
|
||||
TimeDelta::FromMilliseconds(10),
|
||||
MakeExpectedRunAtLeastOnceClosure(FROM_HERE));
|
||||
RunLoop().RunUntilConditionForTest(BindRepeating([]() { return false; }));
|
||||
}
|
||||
|
||||
TEST(RunLoopUntilConditionTest, FailsTestIfConditionNotMetOnQuit) {
|
||||
@ -569,13 +567,12 @@ TEST(RunLoopUntilConditionTest, FailsTestIfConditionNotMetOnQuit) {
|
||||
|
||||
// Expect the Run() timeout to be run when |condition| is false and the loop
|
||||
// Quit()s prematurely.
|
||||
const test::ScopedRunLoopTimeout short_timeout(
|
||||
TimeDelta::FromMilliseconds(10));
|
||||
const RunLoop::ScopedRunTimeoutForTest short_timeout(
|
||||
TimeDelta::FromMilliseconds(10),
|
||||
MakeExpectedRunAtLeastOnceClosure(FROM_HERE));
|
||||
|
||||
// Running with a never-true condition will fire the on-timeout callback.
|
||||
EXPECT_FATAL_FAILURE(
|
||||
RunLoop().RunUntilConditionForTest(BindRepeating([]() { return false; })),
|
||||
"RunLoop::Run() timed out.");
|
||||
RunLoop().RunUntilConditionForTest(BindRepeating([]() { return false; }));
|
||||
}
|
||||
|
||||
TEST(RunLoopUntilConditionTest, NoEffectIfConditionMetOnQuit) {
|
||||
@ -583,8 +580,8 @@ TEST(RunLoopUntilConditionTest, NoEffectIfConditionMetOnQuit) {
|
||||
RunLoop loop;
|
||||
|
||||
// Verify that the call does not trigger the Run() timeout.
|
||||
const test::ScopedRunLoopTimeout short_timeout(
|
||||
TimeDelta::FromMilliseconds(10));
|
||||
const RunLoop::ScopedRunTimeoutForTest short_timeout(
|
||||
TimeDelta::FromMilliseconds(10), MakeExpectedNotRunClosure(FROM_HERE));
|
||||
SequencedTaskRunnerHandle::Get()->PostTask(FROM_HERE, loop.QuitClosure());
|
||||
RunLoop().RunUntilConditionForTest(BindRepeating([]() { return true; }));
|
||||
}
|
||||
@ -596,8 +593,8 @@ TEST(RunLoopUntilConditionTest, NoEffectIfConditionMetOnTimeout) {
|
||||
// Verify that the call does not trigger the Run() timeout.
|
||||
// Note that |short_timeout| must be shorter than the RunUntilConditionForTest
|
||||
// polling frequency.
|
||||
const test::ScopedRunLoopTimeout short_timeout(
|
||||
TimeDelta::FromMilliseconds(10));
|
||||
const RunLoop::ScopedRunTimeoutForTest short_timeout(
|
||||
TimeDelta::FromMilliseconds(10), MakeExpectedNotRunClosure(FROM_HERE));
|
||||
RunLoop().RunUntilConditionForTest(BindRepeating([]() { return true; }));
|
||||
}
|
||||
|
||||
@ -606,7 +603,8 @@ TEST(RunLoopUntilConditionTest, QuitsLoopIfConditionMetOnPoll) {
|
||||
RunLoop loop;
|
||||
|
||||
// Configure a long timeout so it won't fire before we poll.
|
||||
const test::ScopedRunLoopTimeout long_timeout(TestTimeouts::action_timeout());
|
||||
const RunLoop::ScopedRunTimeoutForTest long_timeout(
|
||||
TestTimeouts::action_timeout(), MakeExpectedNotRunClosure(FROM_HERE));
|
||||
|
||||
// Arrange to post a task to the loop after the Run()-timeout has been
|
||||
// started, set to run after the |condition| is polled and before the Run()
|
||||
|
@ -104,8 +104,6 @@ static_library("test_support") {
|
||||
"scoped_mock_time_message_loop_task_runner.h",
|
||||
"scoped_path_override.cc",
|
||||
"scoped_path_override.h",
|
||||
"scoped_run_loop_timeout.cc",
|
||||
"scoped_run_loop_timeout.h",
|
||||
"sequenced_task_runner_test_template.cc",
|
||||
"sequenced_task_runner_test_template.h",
|
||||
"simple_test_clock.cc",
|
||||
|
@ -1,65 +0,0 @@
|
||||
// Copyright 2019 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/scoped_run_loop_timeout.h"
|
||||
|
||||
#include "base/bind.h"
|
||||
#include "base/location.h"
|
||||
#include "base/time/time.h"
|
||||
#include "testing/gtest/include/gtest/gtest.h"
|
||||
|
||||
namespace base {
|
||||
namespace test {
|
||||
|
||||
namespace {
|
||||
bool g_add_gtest_failure_on_timeout = false;
|
||||
}
|
||||
|
||||
ScopedRunLoopTimeout::ScopedRunLoopTimeout(TimeDelta timeout)
|
||||
: nested_timeout_(RunLoop::GetTimeoutForCurrentThread()) {
|
||||
DCHECK_GT(timeout, TimeDelta());
|
||||
run_timeout_.timeout = timeout;
|
||||
|
||||
if (g_add_gtest_failure_on_timeout) {
|
||||
run_timeout_.on_timeout = base::BindRepeating(
|
||||
[]() { GTEST_FAIL() << "RunLoop::Run() timed out."; });
|
||||
} else {
|
||||
run_timeout_.on_timeout = base::BindRepeating(
|
||||
[]() { LOG(FATAL) << "RunLoop::Run() timed out."; });
|
||||
}
|
||||
|
||||
RunLoop::SetTimeoutForCurrentThread(&run_timeout_);
|
||||
}
|
||||
|
||||
ScopedRunLoopTimeout::~ScopedRunLoopTimeout() {
|
||||
RunLoop::SetTimeoutForCurrentThread(nested_timeout_);
|
||||
}
|
||||
|
||||
// static
|
||||
bool ScopedRunLoopTimeout::ExistsForCurrentThread() {
|
||||
return RunLoop::GetTimeoutForCurrentThread() != nullptr;
|
||||
}
|
||||
|
||||
// static
|
||||
void ScopedRunLoopTimeout::SetAddGTestFailureOnTimeout() {
|
||||
g_add_gtest_failure_on_timeout = true;
|
||||
}
|
||||
|
||||
// static
|
||||
const RunLoop::RunLoopTimeout*
|
||||
ScopedRunLoopTimeout::GetTimeoutForCurrentThread() {
|
||||
return RunLoop::GetTimeoutForCurrentThread();
|
||||
}
|
||||
|
||||
ScopedDisableRunLoopTimeout::ScopedDisableRunLoopTimeout()
|
||||
: nested_timeout_(RunLoop::GetTimeoutForCurrentThread()) {
|
||||
RunLoop::SetTimeoutForCurrentThread(nullptr);
|
||||
}
|
||||
|
||||
ScopedDisableRunLoopTimeout::~ScopedDisableRunLoopTimeout() {
|
||||
RunLoop::SetTimeoutForCurrentThread(nested_timeout_);
|
||||
}
|
||||
|
||||
} // namespace test
|
||||
} // namespace base
|
@ -1,97 +0,0 @@
|
||||
// Copyright 2019 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.
|
||||
|
||||
#ifndef BASE_TEST_SCOPED_RUN_LOOP_TIMEOUT_H_
|
||||
#define BASE_TEST_SCOPED_RUN_LOOP_TIMEOUT_H_
|
||||
|
||||
#include "base/run_loop.h"
|
||||
#include "base/time/time.h"
|
||||
|
||||
namespace content {
|
||||
FORWARD_DECLARE_TEST(ContentBrowserTest, RunTimeoutInstalled);
|
||||
}
|
||||
|
||||
namespace base {
|
||||
namespace test {
|
||||
|
||||
FORWARD_DECLARE_TEST(TaskEnvironmentTest, SetsDefaultRunTimeout);
|
||||
|
||||
// Configures all RunLoop::Run() calls on the current thread to run the
|
||||
// supplied |on_timeout| callback if they run for longer than |timeout|.
|
||||
//
|
||||
// Specifying Run() timeouts per-thread avoids the need to cope with Run()s
|
||||
// executing concurrently with ScopedRunLoopTimeout initialization or
|
||||
// teardown, and allows "default" timeouts to be specified by suites, rather
|
||||
// than explicitly configuring them for every RunLoop, in each test.
|
||||
//
|
||||
// This is used by test classes including TaskEnvironment and TestSuite to
|
||||
// set a default Run() timeout on the main thread of all tests which use them.
|
||||
//
|
||||
// Tests which have steps which need to Run() for longer than their suite's
|
||||
// default (if any) allows can override the active timeout by creating a nested
|
||||
// ScopedRunLoopTimeout on their stack, e.g:
|
||||
//
|
||||
// ScopedRunLoopTimeout default_timeout(kDefaultRunTimeout);
|
||||
// ... do other test stuff ...
|
||||
// RunLoop().Run(); // Run for up to kDefaultRunTimeout.
|
||||
// ...
|
||||
// {
|
||||
// ScopedRunLoopTimeout specific_timeout(kTestSpecificTimeout);
|
||||
// RunLoop().Run(); // Run for up to kTestSpecificTimeout.
|
||||
// }
|
||||
// ...
|
||||
// RunLoop().Run(); // Run for up to kDefaultRunTimeout.
|
||||
//
|
||||
// The currently-active timeout can also be temporarily disabled:
|
||||
// ScopedDisableRunLoopTimeout disable_timeout;
|
||||
//
|
||||
// By default LOG(FATAL) will be invoked on Run() timeout. Test binaries
|
||||
// can opt-in to using ADD_FAILURE() instead by calling
|
||||
// SetAddGTestFailureOnTimeout() during process initialization.
|
||||
//
|
||||
// TaskEnvironment applies a default Run() timeout.
|
||||
|
||||
class ScopedRunLoopTimeout {
|
||||
public:
|
||||
ScopedRunLoopTimeout(TimeDelta timeout);
|
||||
~ScopedRunLoopTimeout();
|
||||
|
||||
ScopedRunLoopTimeout(const ScopedRunLoopTimeout&) = delete;
|
||||
ScopedRunLoopTimeout& operator=(const ScopedRunLoopTimeout&) = delete;
|
||||
|
||||
// Returns true if there is a Run() timeout configured on the current thread.
|
||||
static bool ExistsForCurrentThread();
|
||||
|
||||
static void SetAddGTestFailureOnTimeout();
|
||||
|
||||
protected:
|
||||
FRIEND_TEST_ALL_PREFIXES(ScopedRunLoopRunTimeoutTest, TimesOut);
|
||||
FRIEND_TEST_ALL_PREFIXES(ScopedRunLoopRunTimeoutTest, RunTasksUntilTimeout);
|
||||
FRIEND_TEST_ALL_PREFIXES(TaskEnvironmentTest, SetsDefaultRunTimeout);
|
||||
FRIEND_TEST_ALL_PREFIXES(content::ContentBrowserTest, RunTimeoutInstalled);
|
||||
|
||||
// Exposes the RunLoopTimeout to the friend tests (see above).
|
||||
static const RunLoop::RunLoopTimeout* GetTimeoutForCurrentThread();
|
||||
|
||||
const RunLoop::RunLoopTimeout* const nested_timeout_;
|
||||
RunLoop::RunLoopTimeout run_timeout_;
|
||||
};
|
||||
|
||||
class ScopedDisableRunLoopTimeout {
|
||||
public:
|
||||
ScopedDisableRunLoopTimeout();
|
||||
~ScopedDisableRunLoopTimeout();
|
||||
|
||||
ScopedDisableRunLoopTimeout(const ScopedDisableRunLoopTimeout&) = delete;
|
||||
ScopedDisableRunLoopTimeout& operator=(const ScopedDisableRunLoopTimeout&) =
|
||||
delete;
|
||||
|
||||
private:
|
||||
const RunLoop::RunLoopTimeout* const nested_timeout_;
|
||||
};
|
||||
|
||||
} // namespace test
|
||||
} // namespace base
|
||||
|
||||
#endif // BASE_TEST_SCOPED_RUN_LOOP_TIMEOUT_H_
|
@ -1,65 +0,0 @@
|
||||
// Copyright 2020 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/scoped_run_loop_timeout.h"
|
||||
|
||||
#include "base/bind.h"
|
||||
#include "base/bind_helpers.h"
|
||||
#include "base/location.h"
|
||||
#include "base/test/bind_test_util.h"
|
||||
#include "base/test/gtest_util.h"
|
||||
#include "base/test/task_environment.h"
|
||||
#include "base/threading/sequenced_task_runner_handle.h"
|
||||
#include "base/time/time.h"
|
||||
#include "testing/gtest/include/gtest/gtest-spi.h"
|
||||
#include "testing/gtest/include/gtest/gtest.h"
|
||||
|
||||
namespace base {
|
||||
namespace test {
|
||||
|
||||
TEST(ScopedRunLoopTimeoutTest, TimesOut) {
|
||||
TaskEnvironment task_environment;
|
||||
RunLoop run_loop;
|
||||
|
||||
static constexpr auto kArbitraryTimeout = TimeDelta::FromMilliseconds(10);
|
||||
ScopedRunLoopTimeout run_timeout(kArbitraryTimeout);
|
||||
|
||||
// Since the delayed task will be posted only after the message pump starts
|
||||
// running, the ScopedRunLoopTimeout will already have started to elapse,
|
||||
// so if Run() exits at the correct time then our delayed task will not run.
|
||||
SequencedTaskRunnerHandle::Get()->PostTask(
|
||||
FROM_HERE,
|
||||
BindOnce(IgnoreResult(&SequencedTaskRunner::PostDelayedTask),
|
||||
SequencedTaskRunnerHandle::Get(), FROM_HERE,
|
||||
MakeExpectedNotRunClosure(FROM_HERE), kArbitraryTimeout));
|
||||
|
||||
// This task should get to run before Run() times-out.
|
||||
SequencedTaskRunnerHandle::Get()->PostDelayedTask(
|
||||
FROM_HERE, MakeExpectedRunClosure(FROM_HERE), kArbitraryTimeout);
|
||||
|
||||
// EXPECT_FATAL_FAILURE() can only reference globals and statics.
|
||||
static RunLoop& static_loop = run_loop;
|
||||
EXPECT_FATAL_FAILURE(static_loop.Run(), "Run() timed out.");
|
||||
}
|
||||
|
||||
TEST(ScopedRunLoopTimeoutTest, RunTasksUntilTimeout) {
|
||||
TaskEnvironment task_environment;
|
||||
RunLoop run_loop;
|
||||
|
||||
static constexpr auto kArbitraryTimeout = TimeDelta::FromMilliseconds(10);
|
||||
ScopedRunLoopTimeout run_timeout(kArbitraryTimeout);
|
||||
|
||||
// Posting a task with the same delay as our timeout, immediately before
|
||||
// calling Run(), means it should get to run. Since this uses QuitWhenIdle(),
|
||||
// the Run() timeout callback should also get to run.
|
||||
SequencedTaskRunnerHandle::Get()->PostDelayedTask(
|
||||
FROM_HERE, MakeExpectedRunClosure(FROM_HERE), kArbitraryTimeout);
|
||||
|
||||
// EXPECT_FATAL_FAILURE() can only reference globals and statics.
|
||||
static RunLoop& static_loop = run_loop;
|
||||
EXPECT_FATAL_FAILURE(static_loop.Run(), "Run() timed out.");
|
||||
}
|
||||
|
||||
} // namespace test
|
||||
} // namespace base
|
@ -380,11 +380,22 @@ TaskEnvironment::TaskEnvironment(
|
||||
scoped_lazy_task_runner_list_for_testing_(
|
||||
std::make_unique<internal::ScopedLazyTaskRunnerListForTesting>()),
|
||||
// TODO(https://crbug.com/922098): Enable Run() timeouts even for
|
||||
// instances created with TimeSource::MOCK_TIME.
|
||||
run_loop_timeout_(mock_time_domain_
|
||||
? nullptr
|
||||
: std::make_unique<ScopedRunLoopTimeout>(
|
||||
TestTimeouts::action_timeout())) {
|
||||
// instances created with *MOCK_TIME.
|
||||
run_loop_timeout_(
|
||||
mock_time_domain_
|
||||
? nullptr
|
||||
: std::make_unique<RunLoop::ScopedRunTimeoutForTest>(
|
||||
TestTimeouts::action_timeout(),
|
||||
BindRepeating(
|
||||
[](sequence_manager::SequenceManager*
|
||||
sequence_manager) {
|
||||
ADD_FAILURE()
|
||||
<< "RunLoop::Run() timed out with the following "
|
||||
"pending task(s) in its TaskEnvironment's "
|
||||
"main thread queue:\n"
|
||||
<< sequence_manager->DescribeAllPendingTasks();
|
||||
},
|
||||
Unretained(sequence_manager_.get())))) {
|
||||
CHECK(!base::ThreadTaskRunnerHandle::IsSet());
|
||||
// If |subclass_creates_default_taskrunner| is true then initialization is
|
||||
// deferred until DeferredInitFromSubclass().
|
||||
|
@ -11,10 +11,10 @@
|
||||
#include "base/macros.h"
|
||||
#include "base/memory/ref_counted.h"
|
||||
#include "base/observer_list.h"
|
||||
#include "base/run_loop.h"
|
||||
#include "base/single_thread_task_runner.h"
|
||||
#include "base/task/lazy_thread_pool_task_runner.h"
|
||||
#include "base/task/sequence_manager/sequence_manager.h"
|
||||
#include "base/test/scoped_run_loop_timeout.h"
|
||||
#include "base/threading/thread_checker.h"
|
||||
#include "base/time/time.h"
|
||||
#include "base/traits_bag.h"
|
||||
@ -394,7 +394,7 @@ class TaskEnvironment {
|
||||
scoped_lazy_task_runner_list_for_testing_;
|
||||
|
||||
// Sets RunLoop::Run() to LOG(FATAL) if not Quit() in a timely manner.
|
||||
std::unique_ptr<ScopedRunLoopTimeout> run_loop_timeout_;
|
||||
std::unique_ptr<RunLoop::ScopedRunTimeoutForTest> run_loop_timeout_;
|
||||
|
||||
std::unique_ptr<bool> owns_instance_ = std::make_unique<bool>(true);
|
||||
|
||||
|
@ -23,7 +23,6 @@
|
||||
#include "base/test/gtest_util.h"
|
||||
#include "base/test/mock_callback.h"
|
||||
#include "base/test/mock_log.h"
|
||||
#include "base/test/scoped_run_loop_timeout.h"
|
||||
#include "base/test/test_timeouts.h"
|
||||
#include "base/threading/platform_thread.h"
|
||||
#include "base/threading/sequence_local_storage_slot.h"
|
||||
@ -839,8 +838,8 @@ TEST_F(TaskEnvironmentTest, ThreadPoolPoolAllowsMTA) {
|
||||
#endif // defined(OS_WIN)
|
||||
|
||||
TEST_F(TaskEnvironmentTest, SetsDefaultRunTimeout) {
|
||||
const RunLoop::RunLoopTimeout* old_run_timeout =
|
||||
ScopedRunLoopTimeout::GetTimeoutForCurrentThread();
|
||||
const RunLoop::ScopedRunTimeoutForTest* old_run_timeout =
|
||||
RunLoop::ScopedRunTimeoutForTest::Current();
|
||||
|
||||
{
|
||||
TaskEnvironment task_environment;
|
||||
@ -848,21 +847,22 @@ TEST_F(TaskEnvironmentTest, SetsDefaultRunTimeout) {
|
||||
// TaskEnvironment should set a default Run() timeout that fails the
|
||||
// calling test (before test_launcher_timeout()).
|
||||
|
||||
const RunLoop::RunLoopTimeout* run_timeout =
|
||||
ScopedRunLoopTimeout::GetTimeoutForCurrentThread();
|
||||
const RunLoop::ScopedRunTimeoutForTest* run_timeout =
|
||||
RunLoop::ScopedRunTimeoutForTest::Current();
|
||||
EXPECT_NE(run_timeout, old_run_timeout);
|
||||
EXPECT_TRUE(run_timeout);
|
||||
if (!debug::BeingDebugged()) {
|
||||
EXPECT_LT(run_timeout->timeout, TestTimeouts::test_launcher_timeout());
|
||||
EXPECT_LT(run_timeout->timeout(), TestTimeouts::test_launcher_timeout());
|
||||
}
|
||||
static const RepeatingClosure& static_on_timeout = run_timeout->on_timeout;
|
||||
EXPECT_FATAL_FAILURE(static_on_timeout.Run(), "RunLoop::Run() timed out");
|
||||
EXPECT_NONFATAL_FAILURE({ run_timeout->on_timeout().Run(); },
|
||||
"RunLoop::Run() timed out");
|
||||
}
|
||||
|
||||
EXPECT_EQ(ScopedRunLoopTimeout::GetTimeoutForCurrentThread(),
|
||||
old_run_timeout);
|
||||
EXPECT_EQ(RunLoop::ScopedRunTimeoutForTest::Current(), old_run_timeout);
|
||||
}
|
||||
|
||||
namespace {}
|
||||
|
||||
TEST_F(TaskEnvironmentTest, DescribePendingMainThreadTasks) {
|
||||
TaskEnvironment task_environment;
|
||||
ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, DoNothing());
|
||||
@ -1028,7 +1028,7 @@ TEST_F(TaskEnvironmentTest, RunLoopDriveable) {
|
||||
|
||||
// Disable Run() timeout here, otherwise we'll fast-forward to it before we
|
||||
// reach the quit task.
|
||||
ScopedDisableRunLoopTimeout disable_timeout;
|
||||
RunLoop::ScopedDisableRunTimeoutForTest disable_timeout;
|
||||
|
||||
RunLoop run_loop;
|
||||
ThreadTaskRunnerHandle::Get()->PostDelayedTask(
|
||||
|
@ -37,7 +37,6 @@
|
||||
#include "base/test/mock_entropy_provider.h"
|
||||
#include "base/test/multiprocess_test.h"
|
||||
#include "base/test/scoped_feature_list.h"
|
||||
#include "base/test/scoped_run_loop_timeout.h"
|
||||
#include "base/test/test_switches.h"
|
||||
#include "base/test/test_timeouts.h"
|
||||
#include "base/threading/platform_thread.h"
|
||||
@ -581,8 +580,6 @@ void TestSuite::SuppressErrorDialogs() {
|
||||
void TestSuite::Initialize() {
|
||||
DCHECK(!is_initialized_);
|
||||
|
||||
test::ScopedRunLoopTimeout::SetAddGTestFailureOnTimeout();
|
||||
|
||||
const CommandLine* command_line = CommandLine::ForCurrentProcess();
|
||||
#if !defined(OS_IOS)
|
||||
if (command_line->HasSwitch(switches::kWaitForDebugger)) {
|
||||
|
@ -430,8 +430,9 @@ TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeNoPageInModel) {
|
||||
#if defined(OS_ANDROID)
|
||||
// TODO(https://crbug.com/1002762): Fix this test to run in < action_timeout()
|
||||
// on the Android bots.
|
||||
const base::test::ScopedRunLoopTimeout increased_run_timeout(
|
||||
TestTimeouts::action_max_timeout());
|
||||
const base::RunLoop::ScopedRunTimeoutForTest increased_run_timeout(
|
||||
TestTimeouts::action_max_timeout(),
|
||||
base::MakeExpectedNotRunClosure(FROM_HERE, "RunLoop::Run() timed out."));
|
||||
#endif // defined(OS_ANDROID)
|
||||
|
||||
clock()->Advance(base::TimeDelta::FromHours(3));
|
||||
|
@ -13,6 +13,7 @@
|
||||
#include "ash/public/mojom/assistant_state_controller.mojom-shared.h"
|
||||
#include "base/auto_reset.h"
|
||||
#include "base/run_loop.h"
|
||||
#include "base/test/bind_test_util.h"
|
||||
#include "base/time/time.h"
|
||||
#include "chrome/browser/chromeos/login/test/embedded_test_server_mixin.h"
|
||||
#include "chrome/browser/chromeos/login/test/fake_gaia_mixin.h"
|
||||
@ -320,8 +321,8 @@ void AssistantTestMixin::TearDownOnMainThread() {
|
||||
|
||||
void AssistantTestMixin::StartAssistantAndWaitForReady(
|
||||
base::TimeDelta wait_timeout) {
|
||||
const base::test::ScopedRunLoopTimeout run_timeout(wait_timeout);
|
||||
|
||||
const base::RunLoop::ScopedRunTimeoutForTest run_timeout(
|
||||
wait_timeout, base::MakeExpectedNotRunClosure(FROM_HERE));
|
||||
// Note: You might be tempted to call this function from SetUpOnMainThread(),
|
||||
// but that will not work as the Assistant service can not start until
|
||||
// |BrowserTestBase| calls InitializeNetworkProcess(), which it only does
|
||||
@ -353,7 +354,8 @@ void AssistantTestMixin::SendTextQuery(const std::string& query) {
|
||||
void AssistantTestMixin::ExpectCardResponse(
|
||||
const std::string& expected_response,
|
||||
base::TimeDelta wait_timeout) {
|
||||
const base::test::ScopedRunLoopTimeout run_timeout(wait_timeout);
|
||||
const base::RunLoop::ScopedRunTimeoutForTest run_timeout(
|
||||
wait_timeout, base::MakeExpectedNotRunClosure(FROM_HERE));
|
||||
CardResponseWaiter waiter(test_api_->ui_element_container(),
|
||||
{expected_response});
|
||||
waiter.RunUntilResponseReceived();
|
||||
@ -368,7 +370,8 @@ void AssistantTestMixin::ExpectTextResponse(
|
||||
void AssistantTestMixin::ExpectAnyOfTheseTextResponses(
|
||||
const std::vector<std::string>& expected_responses,
|
||||
base::TimeDelta wait_timeout) {
|
||||
const base::test::ScopedRunLoopTimeout run_timeout(wait_timeout);
|
||||
const base::RunLoop::ScopedRunTimeoutForTest run_timeout(
|
||||
wait_timeout, base::MakeExpectedNotRunClosure(FROM_HERE));
|
||||
TextResponseWaiter waiter(test_api_->ui_element_container(),
|
||||
expected_responses);
|
||||
waiter.RunUntilResponseReceived();
|
||||
|
@ -15,7 +15,6 @@
|
||||
#include "base/single_thread_task_runner.h"
|
||||
#include "base/strings/stringprintf.h"
|
||||
#include "base/test/bind_test_util.h"
|
||||
#include "base/test/scoped_run_loop_timeout.h"
|
||||
#include "base/test/task_environment.h"
|
||||
#include "base/threading/thread_task_runner_handle.h"
|
||||
#include "chrome/common/cloud_print/cloud_print_constants.h"
|
||||
@ -609,8 +608,13 @@ void PrinterJobHandlerTest::BeginTest(int timeout_seconds) {
|
||||
base::RunLoop run_loop;
|
||||
active_run_loop_quit_closure_ = run_loop.QuitWhenIdleClosure();
|
||||
|
||||
base::test::ScopedRunLoopTimeout run_timeout(
|
||||
base::TimeDelta::FromSeconds(timeout_seconds));
|
||||
base::RunLoop::ScopedRunTimeoutForTest run_timeout(
|
||||
base::TimeDelta::FromSeconds(timeout_seconds),
|
||||
base::BindLambdaForTesting([&]() {
|
||||
ADD_FAILURE();
|
||||
run_loop.QuitWhenIdle();
|
||||
}));
|
||||
|
||||
run_loop.Run();
|
||||
}
|
||||
|
||||
|
@ -8,8 +8,8 @@
|
||||
|
||||
#include "base/files/file_path.h"
|
||||
#include "base/files/file_util.h"
|
||||
#include "base/run_loop.h"
|
||||
#include "base/strings/stringprintf.h"
|
||||
#include "base/test/scoped_run_loop_timeout.h"
|
||||
#include "base/test/test_file_util.h"
|
||||
#include "base/timer/elapsed_timer.h"
|
||||
#include "components/visitedlink/browser/visitedlink_writer.h"
|
||||
@ -183,7 +183,7 @@ TEST_F(VisitedLink, TestAddAndQuery) {
|
||||
|
||||
// Tests how long it takes to write and read a large database to and from disk.
|
||||
TEST_F(VisitedLink, TestBigTable) {
|
||||
base::test::ScopedDisableRunLoopTimeout disable_run_timeout;
|
||||
base::RunLoop::ScopedDisableRunTimeoutForTest disable_run_timeout;
|
||||
// create a big DB
|
||||
{
|
||||
TimeLogger table_initialization_timer(kMetricTableInitMs);
|
||||
|
@ -28,7 +28,6 @@
|
||||
#include "base/task/post_task.h"
|
||||
#include "base/task/thread_pool/thread_pool_instance.h"
|
||||
#include "base/test/bind_test_util.h"
|
||||
#include "base/test/scoped_run_loop_timeout.h"
|
||||
#include "base/test/test_timeouts.h"
|
||||
#include "base/threading/thread_restrictions.h"
|
||||
#include "build/build_config.h"
|
||||
@ -604,14 +603,16 @@ void BrowserTestBase::ProxyRunTestOnMainThreadLoop() {
|
||||
#endif
|
||||
|
||||
// Install a RunLoop timeout if none is present but do not override tests that
|
||||
// set a ScopedLoopRunTimeout from their fixture's constructor (which
|
||||
// set a ScopedRunTimeoutForTest from their fixture's constructor (which
|
||||
// happens as part of setting up the test factory in gtest while
|
||||
// ProxyRunTestOnMainThreadLoop() happens later as part of SetUp()).
|
||||
base::Optional<base::test::ScopedRunLoopTimeout> scoped_run_timeout;
|
||||
if (!base::test::ScopedRunLoopTimeout::ExistsForCurrentThread()) {
|
||||
base::Optional<base::RunLoop::ScopedRunTimeoutForTest> scoped_run_timeout;
|
||||
if (!base::RunLoop::ScopedRunTimeoutForTest::Current()) {
|
||||
// TODO(https://crbug.com/918724): determine whether the timeout can be
|
||||
// reduced from action_max_timeout() to action_timeout().
|
||||
scoped_run_timeout.emplace(TestTimeouts::action_max_timeout());
|
||||
scoped_run_timeout.emplace(TestTimeouts::action_max_timeout(),
|
||||
base::MakeExpectedNotRunClosure(
|
||||
FROM_HERE, "RunLoop::Run() timed out."));
|
||||
}
|
||||
|
||||
#if defined(OS_POSIX)
|
||||
|
@ -16,7 +16,6 @@
|
||||
#include "base/test/launcher/test_launcher.h"
|
||||
#include "base/test/launcher/test_launcher_test_utils.h"
|
||||
#include "base/test/scoped_feature_list.h"
|
||||
#include "base/test/scoped_run_loop_timeout.h"
|
||||
#include "base/test/test_switches.h"
|
||||
#include "base/test/test_timeouts.h"
|
||||
#include "base/threading/thread_restrictions.h"
|
||||
@ -302,14 +301,12 @@ IN_PROC_BROWSER_TEST_F(ContentBrowserTest, NonNestableTask) {
|
||||
IN_PROC_BROWSER_TEST_F(ContentBrowserTest, RunTimeoutInstalled) {
|
||||
// Verify that a RunLoop timeout is installed and shorter than the test
|
||||
// timeout itself.
|
||||
const base::RunLoop::RunLoopTimeout* run_timeout =
|
||||
base::test::ScopedRunLoopTimeout::GetTimeoutForCurrentThread();
|
||||
const auto* run_timeout = base::RunLoop::ScopedRunTimeoutForTest::Current();
|
||||
EXPECT_TRUE(run_timeout);
|
||||
EXPECT_LT(run_timeout->timeout, TestTimeouts::test_launcher_timeout());
|
||||
EXPECT_LT(run_timeout->timeout(), TestTimeouts::test_launcher_timeout());
|
||||
|
||||
static const base::RepeatingClosure& static_on_timeout =
|
||||
run_timeout->on_timeout;
|
||||
EXPECT_FATAL_FAILURE(static_on_timeout.Run(), "RunLoop::Run() timed out");
|
||||
EXPECT_NONFATAL_FAILURE({ run_timeout->on_timeout().Run(); },
|
||||
"RunLoop::Run() timed out");
|
||||
}
|
||||
|
||||
} // namespace content
|
||||
|
@ -691,10 +691,10 @@ Tests can run the `base::test::TaskEnvironment`'s message pump using a
|
||||
`RunLoop::QuitClosure()`), or to `RunUntilIdle()` ready-to-run tasks and
|
||||
immediately return.
|
||||
|
||||
TaskEnvironment configures RunLoop::Run() to GTEST_FAIL() if it hasn't been
|
||||
TaskEnvironment configures RunLoop::Run() to LOG(FATAL) if it hasn't been
|
||||
explicitly quit after TestTimeouts::action_timeout(). This is preferable to
|
||||
having the test hang if the code under test fails to trigger the RunLoop to
|
||||
quit. The timeout can be overridden with base::test::ScopedRunLoopTimeout.
|
||||
quit. The timeout can be overridden with ScopedRunTimeoutForTest.
|
||||
|
||||
```cpp
|
||||
class MyTest : public testing::Test {
|
||||
|
@ -11,7 +11,6 @@
|
||||
#include "base/callback_forward.h"
|
||||
#include "base/hash/md5.h"
|
||||
#include "base/run_loop.h"
|
||||
#include "base/test/scoped_run_loop_timeout.h"
|
||||
#include "base/test/task_environment.h"
|
||||
#include "media/audio/clockless_audio_sink.h"
|
||||
#include "media/audio/null_audio_sink.h"
|
||||
@ -159,7 +158,7 @@ class PipelineIntegrationTestBase : public Pipeline::Client {
|
||||
bool fuzzing_;
|
||||
#if defined(ADDRESS_SANITIZER) || defined(UNDEFINED_SANITIZER)
|
||||
// TODO(https://crbug.com/924030): ASAN causes Run() timeouts to be reached.
|
||||
const base::test::ScopedDisableRunLoopTimeout disable_run_timeout_;
|
||||
const base::RunLoop::ScopedDisableRunTimeoutForTest disable_run_timeout_;
|
||||
#endif
|
||||
std::unique_ptr<Demuxer> demuxer_;
|
||||
std::unique_ptr<DataSource> data_source_;
|
||||
|
@ -20,6 +20,7 @@
|
||||
#include "base/run_loop.h"
|
||||
#include "base/single_thread_task_runner.h"
|
||||
#include "base/strings/string_number_conversions.h"
|
||||
#include "base/test/bind_test_util.h"
|
||||
#include "base/test/metrics/histogram_tester.h"
|
||||
#include "base/test/scoped_feature_list.h"
|
||||
#include "base/test/simple_test_tick_clock.h"
|
||||
@ -779,8 +780,9 @@ TEST_F(ThroughputAnalyzerTest, TestThroughputWithNetworkRequestsOverlap) {
|
||||
// of network requests overlap, and the minimum number of in flight requests
|
||||
// when taking an observation is more than 1.
|
||||
TEST_F(ThroughputAnalyzerTest, TestThroughputWithMultipleNetworkRequests) {
|
||||
const base::test::ScopedRunLoopTimeout increased_run_timeout(
|
||||
TestTimeouts::action_max_timeout());
|
||||
const base::RunLoop::ScopedRunTimeoutForTest increased_run_timeout(
|
||||
TestTimeouts::action_max_timeout(),
|
||||
base::MakeExpectedNotRunClosure(FROM_HERE, "RunLoop::Run() timed out."));
|
||||
|
||||
const base::TickClock* tick_clock = base::DefaultTickClock::GetInstance();
|
||||
TestNetworkQualityEstimator network_quality_estimator;
|
||||
|
@ -226,11 +226,14 @@ class SimpleLoaderTestHelper : public SimpleURLLoaderStreamConsumer {
|
||||
// StartSimpleLoaderAndWait, but exposed so some tests can start the
|
||||
// SimpleURLLoader directly.
|
||||
void Wait() {
|
||||
const base::test::ScopedRunLoopTimeout run_timeout(
|
||||
base::RunLoop::ScopedRunTimeoutForTest run_timeout(
|
||||
// Some of the bots run tests quite slowly, and the default timeout is
|
||||
// too short for them for some of the heavier weight tests.
|
||||
// See https://crbug.com/1046745 and https://crbug.com/1035127.
|
||||
TestTimeouts::action_max_timeout());
|
||||
TestTimeouts::action_max_timeout(), base::BindLambdaForTesting([&]() {
|
||||
ADD_FAILURE() << "Run loop timed out";
|
||||
run_loop_.Quit();
|
||||
}));
|
||||
run_loop_.Run();
|
||||
}
|
||||
|
||||
|
@ -35,7 +35,7 @@ include_rules = [
|
||||
specific_include_rules = {
|
||||
".*test.*": [
|
||||
"+base/run_loop.h",
|
||||
"+base/test/scoped_run_loop_timeout.h",
|
||||
"+base/test/bind_test_util.h",
|
||||
"+base/test/test_timeouts.h",
|
||||
"+base/threading/thread.h",
|
||||
"+media/audio/audio_sink_parameters.h",
|
||||
|
10
third_party/blink/renderer/modules/peerconnection/webrtc_media_stream_track_adapter_map_test.cc
vendored
10
third_party/blink/renderer/modules/peerconnection/webrtc_media_stream_track_adapter_map_test.cc
vendored
@ -10,7 +10,7 @@
|
||||
#include "base/memory/scoped_refptr.h"
|
||||
#include "base/run_loop.h"
|
||||
#include "base/single_thread_task_runner.h"
|
||||
#include "base/test/scoped_run_loop_timeout.h"
|
||||
#include "base/test/bind_test_util.h"
|
||||
#include "base/test/test_timeouts.h"
|
||||
#include "testing/gtest/include/gtest/gtest.h"
|
||||
#include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
|
||||
@ -261,7 +261,11 @@ class WebRtcMediaStreamTrackAdapterMapStressTest
|
||||
: public WebRtcMediaStreamTrackAdapterMapTest {
|
||||
public:
|
||||
WebRtcMediaStreamTrackAdapterMapStressTest()
|
||||
: increased_run_timeout_(TestTimeouts::action_max_timeout()) {}
|
||||
: WebRtcMediaStreamTrackAdapterMapTest(),
|
||||
increased_run_timeout_(
|
||||
TestTimeouts::action_max_timeout(),
|
||||
base::MakeExpectedNotRunClosure(FROM_HERE,
|
||||
"RunLoop::Run() timed out.")) {}
|
||||
|
||||
void RunStressTest(size_t iterations) {
|
||||
base::RunLoop run_loop;
|
||||
@ -340,7 +344,7 @@ class WebRtcMediaStreamTrackAdapterMapStressTest
|
||||
private:
|
||||
// TODO(https://crbug.com/1002761): Fix this test to run in < action_timeout()
|
||||
// on slower bots (e.g. Debug, ASAN, etc).
|
||||
const base::test::ScopedRunLoopTimeout increased_run_timeout_;
|
||||
const base::RunLoop::ScopedRunTimeoutForTest increased_run_timeout_;
|
||||
|
||||
size_t remaining_iterations_;
|
||||
};
|
||||
|
@ -10,6 +10,7 @@
|
||||
#include "base/bind.h"
|
||||
#include "base/macros.h"
|
||||
#include "base/run_loop.h"
|
||||
#include "base/test/bind_test_util.h"
|
||||
#include "base/test/task_environment.h"
|
||||
#include "base/test/test_simple_task_runner.h"
|
||||
#include "base/test/test_timeouts.h"
|
||||
@ -205,8 +206,9 @@ TEST_P(SnapshotAuraTest, MAYBE_FullScreenWindow) {
|
||||
#if defined(OS_LINUX)
|
||||
// TODO(https://crbug.com/1002716): Fix this test to run in < action_timeout()
|
||||
// on the Linux Debug & TSAN bots.
|
||||
const base::test::ScopedRunLoopTimeout increased_run_timeout(
|
||||
TestTimeouts::action_max_timeout());
|
||||
const base::RunLoop::ScopedRunTimeoutForTest increased_run_timeout(
|
||||
TestTimeouts::action_max_timeout(),
|
||||
base::MakeExpectedNotRunClosure(FROM_HERE, "RunLoop::Run() timed out."));
|
||||
#endif // defined(OS_LINUX)
|
||||
|
||||
#if defined(OS_WIN)
|
||||
|
@ -13,7 +13,6 @@
|
||||
#include "base/power_monitor/power_monitor.h"
|
||||
#include "base/power_monitor/power_monitor_device_source.h"
|
||||
#include "base/run_loop.h"
|
||||
#include "base/test/scoped_run_loop_timeout.h"
|
||||
#include "base/test/task_environment.h"
|
||||
#include "base/test/test_discardable_memory_allocator.h"
|
||||
#include "base/test/test_timeouts.h"
|
||||
@ -134,7 +133,7 @@ int main(int argc, char** argv) {
|
||||
#endif
|
||||
|
||||
// This app isn't a test and shouldn't timeout.
|
||||
base::test::ScopedDisableRunLoopTimeout disable_timeout;
|
||||
base::RunLoop::ScopedDisableRunTimeoutForTest disable_timeout;
|
||||
|
||||
base::RunLoop run_loop;
|
||||
views::examples::ShowExamplesWindow(run_loop.QuitClosure());
|
||||
|
Reference in New Issue
Block a user