blob: 9c5eced44ef0424f327433e5740bc1b7b803f4a1 [file] [log] [blame]
// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/test/repeating_test_future.h"
#include "base/task/single_thread_task_runner.h"
#include "base/test/bind.h"
#include "base/test/gtest_util.h"
#include "base/test/task_environment.h"
#include "testing/gtest/include/gtest/gtest-spi.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace base::test {
namespace {
struct MoveOnlyValue {
public:
MoveOnlyValue() = default;
explicit MoveOnlyValue(std::string data) : data(std::move(data)) {}
MoveOnlyValue(const MoveOnlyValue&) = delete;
auto& operator=(const MoveOnlyValue&) = delete;
MoveOnlyValue(MoveOnlyValue&&) = default;
MoveOnlyValue& operator=(MoveOnlyValue&&) = default;
~MoveOnlyValue() = default;
std::string data;
};
} // namespace
class RepeatingTestFutureTest : public ::testing::Test {
public:
RepeatingTestFutureTest() = default;
RepeatingTestFutureTest(const RepeatingTestFutureTest&) = delete;
RepeatingTestFutureTest& operator=(const RepeatingTestFutureTest&) = delete;
~RepeatingTestFutureTest() override = default;
void RunLater(OnceClosure callable) {
SingleThreadTaskRunner::GetCurrentDefault()->PostTask(FROM_HERE,
std::move(callable));
}
private:
test::SingleThreadTaskEnvironment environment_;
};
TEST_F(RepeatingTestFutureTest, ShouldBeEmptyInitially) {
RepeatingTestFuture<std::string> future;
EXPECT_TRUE(future.IsEmpty());
}
TEST_F(RepeatingTestFutureTest, ShouldNotBeEmptyAfterAddingAValue) {
RepeatingTestFuture<std::string> future;
future.AddValue("a value");
EXPECT_FALSE(future.IsEmpty());
}
TEST_F(RepeatingTestFutureTest, ShouldBeEmptyAfterTakingTheOnlyElement) {
RepeatingTestFuture<std::string> future;
future.AddValue("a value");
future.Take();
EXPECT_TRUE(future.IsEmpty());
}
TEST_F(RepeatingTestFutureTest,
ShouldNotBeEmptyIfTakingOneElementFromAfutureWith2Elements) {
RepeatingTestFuture<std::string> future;
future.AddValue("first value");
future.AddValue("second value");
future.Take();
EXPECT_FALSE(future.IsEmpty());
}
TEST_F(RepeatingTestFutureTest, ShouldTakeElementsFiFo) {
RepeatingTestFuture<std::string> future;
future.AddValue("first value");
future.AddValue("second value");
EXPECT_EQ(future.Take(), "first value");
EXPECT_EQ(future.Take(), "second value");
}
TEST_F(RepeatingTestFutureTest, WaitShouldBlockUntilElementArrives) {
RepeatingTestFuture<std::string> future;
RunLater(BindLambdaForTesting([&future]() { future.AddValue("a value"); }));
EXPECT_TRUE(future.IsEmpty());
EXPECT_TRUE(future.Wait());
EXPECT_FALSE(future.IsEmpty());
}
TEST_F(RepeatingTestFutureTest, WaitShouldReturnTrueWhenValueArrives) {
RepeatingTestFuture<std::string> future;
RunLater(BindLambdaForTesting([&future]() { future.AddValue("a value"); }));
EXPECT_TRUE(future.Wait());
EXPECT_FALSE(future.IsEmpty());
}
TEST_F(RepeatingTestFutureTest,
WaitShouldReturnTrueImmediatelyWhenValueIsAlreadyPresent) {
RepeatingTestFuture<std::string> future;
future.AddValue("value already present");
EXPECT_TRUE(future.Wait());
}
TEST_F(RepeatingTestFutureTest, WaitShouldReturnFalseIfTimeoutHappens) {
test::ScopedRunLoopTimeout timeout(FROM_HERE, Milliseconds(1));
// `ScopedRunLoopTimeout` will automatically fail the test when a timeout
// happens, so we use EXPECT_NONFATAL_FAILURE to handle this failure.
// EXPECT_NONFATAL_FAILURE only works on static objects.
static bool success;
static RepeatingTestFuture<std::string> future;
EXPECT_NONFATAL_FAILURE({ success = future.Wait(); }, "timed out");
EXPECT_FALSE(success);
}
TEST_F(RepeatingTestFutureTest, TakeShouldBlockUntilAnElementArrives) {
RepeatingTestFuture<std::string> future;
RunLater(BindLambdaForTesting(
[&future]() { future.AddValue("value pushed delayed"); }));
EXPECT_EQ(future.Take(), "value pushed delayed");
}
TEST_F(RepeatingTestFutureTest, TakeShouldDcheckIfTimeoutHappens) {
test::ScopedRunLoopTimeout timeout(FROM_HERE, Milliseconds(1));
RepeatingTestFuture<std::string> future;
EXPECT_DCHECK_DEATH_WITH(future.Take(), "timed out");
}
TEST_F(RepeatingTestFutureTest, TakeShouldWorkWithMoveOnlyValue) {
RepeatingTestFuture<MoveOnlyValue> future;
RunLater(BindLambdaForTesting(
[&future]() { future.AddValue(MoveOnlyValue("move only value")); }));
MoveOnlyValue result = future.Take();
EXPECT_EQ(result.data, "move only value");
}
TEST_F(RepeatingTestFutureTest, ShouldStoreValuePassedToCallback) {
RepeatingTestFuture<std::string> future;
RunLater(BindOnce(future.GetCallback(), "value"));
EXPECT_EQ("value", future.Take());
}
TEST_F(RepeatingTestFutureTest, ShouldAllowInvokingCallbackMultipleTimes) {
RepeatingTestFuture<std::string> future;
RunLater(BindLambdaForTesting([callback = future.GetCallback()]() {
callback.Run("first value");
callback.Run("second value");
callback.Run("third value");
}));
EXPECT_EQ("first value", future.Take());
EXPECT_EQ("second value", future.Take());
EXPECT_EQ("third value", future.Take());
}
TEST_F(RepeatingTestFutureTest, ShouldAllowReferenceArgumentsForCallback) {
RepeatingTestFuture<std::string> future;
RepeatingCallback<void(const std::string&)> callback =
future.GetCallback<const std::string&>();
RunLater(BindOnce(std::move(callback), "expected value"));
EXPECT_EQ("expected value", future.Take());
}
TEST_F(RepeatingTestFutureTest, ShouldStoreMultipleValuesInATuple) {
const int expected_int_value = 5;
const std::string expected_string_value = "value";
RepeatingTestFuture<int, std::string> future;
RunLater(BindLambdaForTesting(
[&]() { future.AddValue(expected_int_value, expected_string_value); }));
std::tuple<int, std::string> actual = future.Take();
EXPECT_EQ(expected_int_value, std::get<0>(actual));
EXPECT_EQ(expected_string_value, std::get<1>(actual));
}
TEST_F(RepeatingTestFutureTest, ShouldAllowCallbackWithMultipleValues) {
const int expected_int_value = 5;
const std::string expected_string_value = "value";
RepeatingTestFuture<int, std::string> future;
RunLater(BindOnce(future.GetCallback(), expected_int_value,
expected_string_value));
std::tuple<int, std::string> actual = future.Take();
EXPECT_EQ(expected_int_value, std::get<0>(actual));
EXPECT_EQ(expected_string_value, std::get<1>(actual));
}
TEST_F(RepeatingTestFutureTest,
ShouldAllowCallbackWithMultipleReferenceValues) {
const int expected_int_value = 5;
const std::string expected_string_value = "value";
RepeatingTestFuture<int, std::string> future;
RepeatingCallback<void(const int&, std::string)> callback =
future.GetCallback<const int&, std::string>();
RunLater(
BindOnce(std::move(callback), expected_int_value, expected_string_value));
std::tuple<int, std::string> actual = future.Take();
EXPECT_EQ(expected_int_value, std::get<0>(actual));
EXPECT_EQ(expected_string_value, std::get<1>(actual));
}
TEST_F(RepeatingTestFutureTest, ShouldSupportCvRefType) {
std::string expected_value = "value";
RepeatingTestFuture<const std::string&> future;
base::OnceCallback<void(const std::string&)> callback = future.GetCallback();
std::move(callback).Run(expected_value);
std::string actual = future.Take();
EXPECT_EQ(expected_value, actual);
}
TEST_F(RepeatingTestFutureTest, ShouldSupportMultipleCvRefType) {
const int expected_first_value = 5;
std::string expected_second_value = "value";
const long expected_third_value = 10;
RepeatingTestFuture<const int, std::string&, const long&> future;
base::OnceCallback<void(const int, std::string&, const long&)> callback =
future.GetCallback();
std::move(callback).Run(expected_first_value, expected_second_value,
expected_third_value);
std::tuple<int, std::string, long> take_result = future.Take();
EXPECT_EQ(expected_first_value, std::get<0>(take_result));
EXPECT_EQ(expected_second_value, std::get<1>(take_result));
EXPECT_EQ(expected_third_value, std::get<2>(take_result));
}
} // namespace base::test