class ScopedValueChange

Sets a variable to a value. Restores the old value when going out of scope.

This implementation is geared towards use in testing code. It helps catch

usage errors, at the cost of efficiency.

This implementation is not thread-safe. The variable managed by a

ScopedValueChange must only be used in the thread where the ScopedValueChange

instance is created. ScopedValueChange instances must not be moved across

threads.

Each memory location can be covered by at most one ScopedValueChange at a

time. This limitation is enforced with a ZX_ASSERT(). The limitation removes

the mental model complexity stemming from having a variable covered by

multiple ScopedValueChanges with overlapping lifetimes. That complexity is

considered incompatible with the requirement for simplicity in testing code.

Example usage:

namespace {

int g_timeout_ms = 1'200;

} // namespace

ScopedValueChange

<int

> SomeSystem::OverrideTimeoutMsForTesting(

int timeout_ms) {

return ScopedValueChange(g_timeout_ms, timeout_ms);

}

TEST(SomeSystemTest, TimeoutScenario) {

ScopedValueChange

<int

> timeout_change =

SomeSystem::OverrideTimeoutMsForTesting(0);

// `g_timeout_ms` will be zero for the duration of the test.

// When `timeout_change` goes out of scope, the timeout will be restored

// to its initial value.

}

class ComplexSystemTest : public ::testing::Test {

public:

ComplexSystemTest() :

timeout_change_(SomeSystem::OverrideTimeoutMsForTesting(0)) {}

~ComplexSystemTest() override = default;

protected:

ScopedValueChange

<int

> timeout_change_;

};

TEST(ComplexSystemTest, ComplexTimeoutScenario) {

// `g_timeout_ms` will be zero here.

// This test needs to undo a variable change in a surrounding scope.

timeout_change_.reset();

timeout_change_ = SomeSystem::OverrideTimeoutMsForTesting(32);

// `g_timeout_ms` will be 32 for the rest of the test.

}