|
|
@@ -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<>
|
Abseil Team