diff options
Diffstat (limited to 'absl/base')
| -rw-r--r-- | absl/base/exception_safety_testing_test.cc | 60 | ||||
| -rw-r--r-- | absl/base/internal/exception_safety_testing.h | 138 |
2 files changed, 99 insertions, 99 deletions
diff --git a/absl/base/exception_safety_testing_test.cc b/absl/base/exception_safety_testing_test.cc index 9141e39c796b..106bc34b00f7 100644 --- a/absl/base/exception_safety_testing_test.cc +++ b/absl/base/exception_safety_testing_test.cc @@ -548,21 +548,21 @@ TEST(ExceptionSafetyTesterTest, IncompleteTypesAreNotTestable) { // Test that providing operation and inveriants still does not allow for the // the invocation of .Test() and .Test(op) because it lacks a factory auto without_fac = - testing::MakeExceptionSafetyTester().WithOperation(op).WithInvariants( + testing::MakeExceptionSafetyTester().WithOperation(op).WithContracts( inv, testing::strong_guarantee); EXPECT_FALSE(HasNullaryTest(without_fac)); EXPECT_FALSE(HasUnaryTest(without_fac)); - // Test that providing invariants and factory allows the invocation of + // Test that providing contracts and factory allows the invocation of // .Test(op) but does not allow for .Test() because it lacks an operation auto without_op = testing::MakeExceptionSafetyTester() - .WithInvariants(inv, testing::strong_guarantee) + .WithContracts(inv, testing::strong_guarantee) .WithFactory(fac); EXPECT_FALSE(HasNullaryTest(without_op)); EXPECT_TRUE(HasUnaryTest(without_op)); // Test that providing operation and factory still does not allow for the - // the invocation of .Test() and .Test(op) because it lacks invariants + // the invocation of .Test() and .Test(op) because it lacks contracts auto without_inv = testing::MakeExceptionSafetyTester().WithOperation(op).WithFactory(fac); EXPECT_FALSE(HasNullaryTest(without_inv)); @@ -577,7 +577,7 @@ std::unique_ptr<ExampleStruct> ExampleFunctionFactory() { void ExampleFunctionOperation(ExampleStruct*) {} -testing::AssertionResult ExampleFunctionInvariant(ExampleStruct*) { +testing::AssertionResult ExampleFunctionContract(ExampleStruct*) { return testing::AssertionSuccess(); } @@ -593,16 +593,16 @@ struct { struct { testing::AssertionResult operator()(ExampleStruct* example_struct) const { - return ExampleFunctionInvariant(example_struct); + return ExampleFunctionContract(example_struct); } -} example_struct_invariant; +} example_struct_contract; auto example_lambda_factory = []() { return ExampleFunctionFactory(); }; auto example_lambda_operation = [](ExampleStruct*) {}; -auto example_lambda_invariant = [](ExampleStruct* example_struct) { - return ExampleFunctionInvariant(example_struct); +auto example_lambda_contract = [](ExampleStruct* example_struct) { + return ExampleFunctionContract(example_struct); }; // Testing that function references, pointers, structs with operator() and @@ -612,28 +612,28 @@ TEST(ExceptionSafetyTesterTest, MixedFunctionTypes) { EXPECT_TRUE(testing::MakeExceptionSafetyTester() .WithFactory(ExampleFunctionFactory) .WithOperation(ExampleFunctionOperation) - .WithInvariants(ExampleFunctionInvariant) + .WithContracts(ExampleFunctionContract) .Test()); // function pointer EXPECT_TRUE(testing::MakeExceptionSafetyTester() .WithFactory(&ExampleFunctionFactory) .WithOperation(&ExampleFunctionOperation) - .WithInvariants(&ExampleFunctionInvariant) + .WithContracts(&ExampleFunctionContract) .Test()); // struct EXPECT_TRUE(testing::MakeExceptionSafetyTester() .WithFactory(example_struct_factory) .WithOperation(example_struct_operation) - .WithInvariants(example_struct_invariant) + .WithContracts(example_struct_contract) .Test()); // lambda EXPECT_TRUE(testing::MakeExceptionSafetyTester() .WithFactory(example_lambda_factory) .WithOperation(example_lambda_operation) - .WithInvariants(example_lambda_invariant) + .WithContracts(example_lambda_contract) .Test()); } @@ -658,9 +658,9 @@ struct { } invoker; auto tester = - testing::MakeExceptionSafetyTester().WithOperation(invoker).WithInvariants( + testing::MakeExceptionSafetyTester().WithOperation(invoker).WithContracts( CheckNonNegativeInvariants); -auto strong_tester = tester.WithInvariants(testing::strong_guarantee); +auto strong_tester = tester.WithContracts(testing::strong_guarantee); struct FailsBasicGuarantee : public NonNegative { void operator()() { @@ -690,7 +690,7 @@ TEST(ExceptionCheckTest, StrongGuaranteeFailure) { EXPECT_FALSE(strong_tester.WithInitialValue(FollowsBasicGuarantee{}).Test()); } -struct BasicGuaranteeWithExtraInvariants : public NonNegative { +struct BasicGuaranteeWithExtraContracts : public NonNegative { // After operator(), i is incremented. If operator() throws, i is set to 9999 void operator()() { int old_i = i; @@ -701,21 +701,21 @@ struct BasicGuaranteeWithExtraInvariants : public NonNegative { static constexpr int kExceptionSentinel = 9999; }; -constexpr int BasicGuaranteeWithExtraInvariants::kExceptionSentinel; +constexpr int BasicGuaranteeWithExtraContracts::kExceptionSentinel; -TEST(ExceptionCheckTest, BasicGuaranteeWithExtraInvariants) { +TEST(ExceptionCheckTest, BasicGuaranteeWithExtraContracts) { auto tester_with_val = - tester.WithInitialValue(BasicGuaranteeWithExtraInvariants{}); + tester.WithInitialValue(BasicGuaranteeWithExtraContracts{}); EXPECT_TRUE(tester_with_val.Test()); EXPECT_TRUE( tester_with_val - .WithInvariants([](BasicGuaranteeWithExtraInvariants* o) { - if (o->i == BasicGuaranteeWithExtraInvariants::kExceptionSentinel) { + .WithContracts([](BasicGuaranteeWithExtraContracts* o) { + if (o->i == BasicGuaranteeWithExtraContracts::kExceptionSentinel) { return testing::AssertionSuccess(); } return testing::AssertionFailure() << "i should be " - << BasicGuaranteeWithExtraInvariants::kExceptionSentinel + << BasicGuaranteeWithExtraContracts::kExceptionSentinel << ", but is " << o->i; }) .Test()); @@ -740,7 +740,7 @@ struct HasReset : public NonNegative { void reset() { i = 0; } }; -testing::AssertionResult CheckHasResetInvariants(HasReset* h) { +testing::AssertionResult CheckHasResetContracts(HasReset* h) { h->reset(); return testing::AssertionResult(h->i == 0); } @@ -759,14 +759,14 @@ TEST(ExceptionCheckTest, ModifyingChecker) { }; EXPECT_FALSE(tester.WithInitialValue(FollowsBasicGuarantee{}) - .WithInvariants(set_to_1000, is_1000) + .WithContracts(set_to_1000, is_1000) .Test()); EXPECT_TRUE(strong_tester.WithInitialValue(FollowsStrongGuarantee{}) - .WithInvariants(increment) + .WithContracts(increment) .Test()); EXPECT_TRUE(testing::MakeExceptionSafetyTester() .WithInitialValue(HasReset{}) - .WithInvariants(CheckHasResetInvariants) + .WithContracts(CheckHasResetContracts) .Test(invoker)); } @@ -799,7 +799,7 @@ TEST(ExceptionCheckTest, NonEqualityComparable) { return testing::AssertionResult(nec->i == NonEqualityComparable().i); }; auto strong_nec_tester = tester.WithInitialValue(NonEqualityComparable{}) - .WithInvariants(nec_is_strong); + .WithContracts(nec_is_strong); EXPECT_TRUE(strong_nec_tester.Test()); EXPECT_FALSE(strong_nec_tester.Test( @@ -833,14 +833,14 @@ struct { testing::AssertionResult operator()(ExhaustivenessTester<T>*) const { return testing::AssertionSuccess(); } -} CheckExhaustivenessTesterInvariants; +} CheckExhaustivenessTesterContracts; template <typename T> unsigned char ExhaustivenessTester<T>::successes = 0; TEST(ExceptionCheckTest, Exhaustiveness) { auto exhaust_tester = testing::MakeExceptionSafetyTester() - .WithInvariants(CheckExhaustivenessTesterInvariants) + .WithContracts(CheckExhaustivenessTesterContracts) .WithOperation(invoker); EXPECT_TRUE( @@ -849,7 +849,7 @@ TEST(ExceptionCheckTest, Exhaustiveness) { EXPECT_TRUE( exhaust_tester.WithInitialValue(ExhaustivenessTester<ThrowingValue<>>{}) - .WithInvariants(testing::strong_guarantee) + .WithContracts(testing::strong_guarantee) .Test()); EXPECT_EQ(ExhaustivenessTester<ThrowingValue<>>::successes, 0xF); } diff --git a/absl/base/internal/exception_safety_testing.h b/absl/base/internal/exception_safety_testing.h index de4f0e2827cb..5665a1b67db2 100644 --- a/absl/base/internal/exception_safety_testing.h +++ b/absl/base/internal/exception_safety_testing.h @@ -191,19 +191,19 @@ class TrackedObject { ~TrackedObject() noexcept { ConstructorTracker::ObjectDestructed(this); } }; -template <typename Factory, typename Operation, typename Invariant> -absl::optional<testing::AssertionResult> TestSingleInvariantAtCountdownImpl( +template <typename Factory, typename Operation, typename Contract> +absl::optional<testing::AssertionResult> TestSingleContractAtCountdownImpl( const Factory& factory, const Operation& operation, int count, - const Invariant& invariant) { + const Contract& contract) { auto t_ptr = factory(); absl::optional<testing::AssertionResult> current_res; SetCountdown(count); try { operation(t_ptr.get()); } catch (const exceptions_internal::TestException& e) { - current_res.emplace(invariant(t_ptr.get())); + current_res.emplace(contract(t_ptr.get())); if (!current_res.value()) { - *current_res << e.what() << " failed invariant check"; + *current_res << e.what() << " failed contract check"; } } UnsetCountdown(); @@ -211,22 +211,22 @@ absl::optional<testing::AssertionResult> TestSingleInvariantAtCountdownImpl( } template <typename Factory, typename Operation> -absl::optional<testing::AssertionResult> TestSingleInvariantAtCountdownImpl( +absl::optional<testing::AssertionResult> TestSingleContractAtCountdownImpl( const Factory& factory, const Operation& operation, int count, StrongGuaranteeTagType) { using TPtr = typename decltype(factory())::pointer; auto t_is_strong = [&](TPtr t) { return *t == *factory(); }; - return TestSingleInvariantAtCountdownImpl(factory, operation, count, - t_is_strong); + return TestSingleContractAtCountdownImpl(factory, operation, count, + t_is_strong); } -template <typename Factory, typename Operation, typename Invariant> -int TestSingleInvariantAtCountdown( +template <typename Factory, typename Operation, typename Contract> +int TestSingleContractAtCountdown( const Factory& factory, const Operation& operation, int count, - const Invariant& invariant, + const Contract& contract, absl::optional<testing::AssertionResult>* reduced_res) { // If reduced_res is empty, it means the current call to - // TestSingleInvariantAtCountdown(...) is the first test being run so we do + // TestSingleContractAtCountdown(...) is the first test being run so we do // want to run it. Alternatively, if it's not empty (meaning a previous test // has run) we want to check if it passed. If the previous test did pass, we // want to contine running tests so we do want to run the current one. If it @@ -234,22 +234,22 @@ int TestSingleInvariantAtCountdown( // output. If that's the case, we do not run the current test and instead we // simply return. if (!reduced_res->has_value() || reduced_res->value()) { - *reduced_res = TestSingleInvariantAtCountdownImpl(factory, operation, count, - invariant); + *reduced_res = + TestSingleContractAtCountdownImpl(factory, operation, count, contract); } return 0; } -template <typename Factory, typename Operation, typename... Invariants> -inline absl::optional<testing::AssertionResult> TestAllInvariantsAtCountdown( +template <typename Factory, typename Operation, typename... Contracts> +inline absl::optional<testing::AssertionResult> TestAllContractsAtCountdown( const Factory& factory, const Operation& operation, int count, - const Invariants&... invariants) { + const Contracts&... contracts) { absl::optional<testing::AssertionResult> reduced_res; // Run each checker, short circuiting after the first failure int dummy[] = { - 0, (TestSingleInvariantAtCountdown(factory, operation, count, invariants, - &reduced_res))...}; + 0, (TestSingleContractAtCountdown(factory, operation, count, contracts, + &reduced_res))...}; static_cast<void>(dummy); return reduced_res; } @@ -884,15 +884,15 @@ class DefaultFactory { T t_; }; -template <size_t LazyInvariantsCount, typename LazyFactory, +template <size_t LazyContractsCount, typename LazyFactory, typename LazyOperation> using EnableIfTestable = typename absl::enable_if_t< - LazyInvariantsCount != 0 && + LazyContractsCount != 0 && !std::is_same<LazyFactory, UninitializedT>::value && !std::is_same<LazyOperation, UninitializedT>::value>; template <typename Factory = UninitializedT, - typename Operation = UninitializedT, typename... Invariants> + typename Operation = UninitializedT, typename... Contracts> class ExceptionSafetyTester; } // namespace exceptions_internal @@ -903,7 +903,7 @@ namespace exceptions_internal { /* * Builds a tester object that tests if performing a operation on a T follows - * exception safety guarantees. Verification is done via invariant assertion + * exception safety guarantees. Verification is done via contract assertion * callbacks applied to T instances post-throw. * * Template parameters for ExceptionSafetyTester: @@ -921,18 +921,18 @@ namespace exceptions_internal { * fresh T instance so it's free to modify and destroy the T instances as it * pleases. * - * - Invariants...: The invariant assertion callback objects (passed in via - * tester.WithInvariants(...)) must be invocable with the signature + * - Contracts...: The contract assertion callback objects (passed in via + * tester.WithContracts(...)) must be invocable with the signature * `testing::AssertionResult operator()(T*) const` where T is the type being - * tested. Invariant assertion callbacks are provided T instances post-throw. - * They must return testing::AssertionSuccess when the type invariants of the - * provided T instance hold. If the type invariants of the T instance do not + * tested. Contract assertion callbacks are provided T instances post-throw. + * They must return testing::AssertionSuccess when the type contracts of the + * provided T instance hold. If the type contracts of the T instance do not * hold, they must return testing::AssertionFailure. Execution order of - * Invariants... is unspecified. They will each individually get a fresh T + * Contracts... is unspecified. They will each individually get a fresh T * instance so they are free to modify and destroy the T instances as they * please. */ -template <typename Factory, typename Operation, typename... Invariants> +template <typename Factory, typename Operation, typename... Contracts> class ExceptionSafetyTester { public: /* @@ -948,7 +948,7 @@ class ExceptionSafetyTester { * tester.WithFactory(...). */ template <typename T> - ExceptionSafetyTester<DefaultFactory<T>, Operation, Invariants...> + ExceptionSafetyTester<DefaultFactory<T>, Operation, Contracts...> WithInitialValue(const T& t) const { return WithFactory(DefaultFactory<T>(t)); } @@ -961,9 +961,9 @@ class ExceptionSafetyTester { * method tester.WithInitialValue(...). */ template <typename NewFactory> - ExceptionSafetyTester<absl::decay_t<NewFactory>, Operation, Invariants...> + ExceptionSafetyTester<absl::decay_t<NewFactory>, Operation, Contracts...> WithFactory(const NewFactory& new_factory) const { - return {new_factory, operation_, invariants_}; + return {new_factory, operation_, contracts_}; } /* @@ -972,39 +972,39 @@ class ExceptionSafetyTester { * tester. */ template <typename NewOperation> - ExceptionSafetyTester<Factory, absl::decay_t<NewOperation>, Invariants...> + ExceptionSafetyTester<Factory, absl::decay_t<NewOperation>, Contracts...> WithOperation(const NewOperation& new_operation) const { - return {factory_, new_operation, invariants_}; + return {factory_, new_operation, contracts_}; } /* - * Returns a new ExceptionSafetyTester with the provided MoreInvariants... - * combined with the Invariants... that were already included in the instance - * on which the method was called. Invariants... cannot be removed or replaced + * Returns a new ExceptionSafetyTester with the provided MoreContracts... + * combined with the Contracts... that were already included in the instance + * on which the method was called. Contracts... cannot be removed or replaced * once added to an ExceptionSafetyTester instance. A fresh object must be - * created in order to get an empty Invariants... list. + * created in order to get an empty Contracts... list. * - * In addition to passing in custom invariant assertion callbacks, this method + * In addition to passing in custom contract assertion callbacks, this method * accepts `testing::strong_guarantee` as an argument which checks T instances * post-throw against freshly created T instances via operator== to verify * that any state changes made during the execution of the operation were * properly rolled back. */ - template <typename... MoreInvariants> - ExceptionSafetyTester<Factory, Operation, Invariants..., - absl::decay_t<MoreInvariants>...> - WithInvariants(const MoreInvariants&... more_invariants) const { - return {factory_, operation_, - std::tuple_cat(invariants_, - std::tuple<absl::decay_t<MoreInvariants>...>( - more_invariants...))}; + template <typename... MoreContracts> + ExceptionSafetyTester<Factory, Operation, Contracts..., + absl::decay_t<MoreContracts>...> + WithContracts(const MoreContracts&... more_contracts) const { + return { + factory_, operation_, + std::tuple_cat(contracts_, std::tuple<absl::decay_t<MoreContracts>...>( + more_contracts...))}; } /* * Returns a testing::AssertionResult that is the reduced result of the * exception safety algorithm. The algorithm short circuits and returns - * AssertionFailure after the first invariant callback returns an - * AssertionFailure. Otherwise, if all invariant callbacks return an + * AssertionFailure after the first contract callback returns an + * AssertionFailure. Otherwise, if all contract callbacks return an * AssertionSuccess, the reduced result is AssertionSuccess. * * The passed-in testable operation will not be saved in a new tester instance @@ -1013,33 +1013,33 @@ class ExceptionSafetyTester { * * Preconditions for tester.Test(const NewOperation& new_operation): * - * - May only be called after at least one invariant assertion callback and a + * - May only be called after at least one contract assertion callback and a * factory or initial value have been provided. */ template < typename NewOperation, - typename = EnableIfTestable<sizeof...(Invariants), Factory, NewOperation>> + typename = EnableIfTestable<sizeof...(Contracts), Factory, NewOperation>> testing::AssertionResult Test(const NewOperation& new_operation) const { - return TestImpl(new_operation, absl::index_sequence_for<Invariants...>()); + return TestImpl(new_operation, absl::index_sequence_for<Contracts...>()); } /* * Returns a testing::AssertionResult that is the reduced result of the * exception safety algorithm. The algorithm short circuits and returns - * AssertionFailure after the first invariant callback returns an - * AssertionFailure. Otherwise, if all invariant callbacks return an + * AssertionFailure after the first contract callback returns an + * AssertionFailure. Otherwise, if all contract callbacks return an * AssertionSuccess, the reduced result is AssertionSuccess. * * Preconditions for tester.Test(): * - * - May only be called after at least one invariant assertion callback, a + * - May only be called after at least one contract assertion callback, a * factory or initial value and a testable operation have been provided. */ - template <typename LazyOperation = Operation, - typename = - EnableIfTestable<sizeof...(Invariants), Factory, LazyOperation>> + template < + typename LazyOperation = Operation, + typename = EnableIfTestable<sizeof...(Contracts), Factory, LazyOperation>> testing::AssertionResult Test() const { - return TestImpl(operation_, absl::index_sequence_for<Invariants...>()); + return TestImpl(operation_, absl::index_sequence_for<Contracts...>()); } private: @@ -1051,8 +1051,8 @@ class ExceptionSafetyTester { ExceptionSafetyTester() {} ExceptionSafetyTester(const Factory& f, const Operation& o, - const std::tuple<Invariants...>& i) - : factory_(f), operation_(o), invariants_(i) {} + const std::tuple<Contracts...>& i) + : factory_(f), operation_(o), contracts_(i) {} template <typename SelectedOperation, size_t... Indices> testing::AssertionResult TestImpl(const SelectedOperation& selected_operation, @@ -1064,28 +1064,28 @@ class ExceptionSafetyTester { // Run the full exception safety test algorithm for the current countdown auto reduced_res = - TestAllInvariantsAtCountdown(factory_, selected_operation, count, - std::get<Indices>(invariants_)...); - // If there is no value in the optional, no invariants were run because no + TestAllContractsAtCountdown(factory_, selected_operation, count, + std::get<Indices>(contracts_)...); + // If there is no value in the optional, no contracts were run because no // exception was thrown. This means that the test is complete and the loop // can exit successfully. if (!reduced_res.has_value()) { return testing::AssertionSuccess(); } - // If the optional is not empty and the value is falsy, an invariant check + // If the optional is not empty and the value is falsy, an contract check // failed so the test must exit to propegate the failure. if (!reduced_res.value()) { return reduced_res.value(); } // If the optional is not empty and the value is not falsy, it means - // exceptions were thrown but the invariants passed so the test must + // exceptions were thrown but the contracts passed so the test must // continue to run. } } Factory factory_; Operation operation_; - std::tuple<Invariants...> invariants_; + std::tuple<Contracts...> contracts_; }; } // namespace exceptions_internal @@ -1096,7 +1096,7 @@ class ExceptionSafetyTester { * instances of ExceptionSafetyTester. * * In order to test a T for exception safety, a factory for that T, a testable - * operation, and at least one invariant callback returning an assertion + * operation, and at least one contract callback returning an assertion * result must be applied using the respective methods. */ inline exceptions_internal::ExceptionSafetyTester<> |