From e01d95528ea2137a4a27a88d1f57c6cb260aafed Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Mon, 24 Sep 2018 11:57:52 -0700 Subject: Export of internal Abseil changes. -- eca34da4ccb7bb6a580f1364dff9ca053418fa3b by Abseil Team : Internal change. PiperOrigin-RevId: 214305433 -- 35393bdd21a87c4286f945fd34dda93afc4e0cd6 by Abseil Team : Move some implementation details of string_view around to facilitate compiling on NVCC. Abseil does not officially support NVCC as a reminder. PiperOrigin-RevId: 214184876 -- 61846cab9ab9476a4676ecade7173f68978cd038 by Jorg Brown : Move the initialization values for constants back to their declaration. PiperOrigin-RevId: 214135927 -- 7ac7df6c5f78f2faf419268c04618b936cb26065 by Abseil Team : Performance improvements on format parser. PiperOrigin-RevId: 214032366 -- 90b4c0cf20e9feaa257a7ece40adaf7db40a60a7 by Xiaoyi Zhang : Add static_assert check to absl::visit to make sure all overloads of the visitor return the same type, as required by the C++ standard. PiperOrigin-RevId: 213677001 -- 787995342101b4c181291cde9ecea3048536e4bd by Abseil Team : Update comment to indicate finite durations are less than InfiniteDuration. PiperOrigin-RevId: 213660328 -- d78f0dce7cc31218807e96d93b9e8513b6c80b24 by Jon Cohen : s/invariant/contract in the exceptions safety testing framework. This is a better term as these can be type invariants or function post conditions. They also are very similar ground as to what is covered by c++20 Contracts (and could even be replaced by them. PiperOrigin-RevId: 213631019 -- 0b3ff1a640de9a7391a6c233568802cf86245b0e by Abseil Team : Add noinline attribute for GetStackTrace/GetStackFrames/... so the skipped frames will not change because of inlining difference. PiperOrigin-RevId: 213009637 GitOrigin-RevId: eca34da4ccb7bb6a580f1364dff9ca053418fa3b Change-Id: Iff1022fd24e440fcbdf3c4ab2a915ca8954daa31 --- WORKSPACE | 8 +- absl/base/exception_safety_testing_test.cc | 60 ++++----- absl/base/internal/exception_safety_testing.h | 138 ++++++++++----------- .../container/fixed_array_exception_safety_test.cc | 2 +- absl/debugging/stacktrace.cc | 4 + absl/memory/memory_exception_safety_test.cc | 2 +- absl/strings/internal/str_format/parser.cc | 75 ++++++----- absl/strings/internal/str_format/parser_test.cc | 16 ++- absl/strings/string_view.h | 29 ++--- absl/synchronization/internal/graphcycles.cc | 6 +- absl/time/time.h | 3 + absl/types/any_exception_safety_test.cc | 6 +- absl/types/internal/variant.h | 7 +- absl/types/optional_exception_safety_test.cc | 24 ++-- absl/types/variant_exception_safety_test.cc | 94 +++++++------- 15 files changed, 251 insertions(+), 223 deletions(-) diff --git a/WORKSPACE b/WORKSPACE index e4a9119..72ef139 100644 --- a/WORKSPACE +++ b/WORKSPACE @@ -5,11 +5,11 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") http_archive( name = "bazel_toolchains", urls = [ - "https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/archive/287b64e0a211fb7c23b74695f8d5f5205b61f4eb.tar.gz", - "https://github.com/bazelbuild/bazel-toolchains/archive/287b64e0a211fb7c23b74695f8d5f5205b61f4eb.tar.gz", + "https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/archive/bc09b995c137df042bb80a395b73d7ce6f26afbe.tar.gz", + "https://github.com/bazelbuild/bazel-toolchains/archive/bc09b995c137df042bb80a395b73d7ce6f26afbe.tar.gz", ], - strip_prefix = "bazel-toolchains-287b64e0a211fb7c23b74695f8d5f5205b61f4eb", - sha256 = "aca8ac6afd7745027ee4a43032b51a725a61a75a30f02cc58681ee87e4dcdf4b", + strip_prefix = "bazel-toolchains-bc09b995c137df042bb80a395b73d7ce6f26afbe", + sha256 = "4329663fe6c523425ad4d3c989a8ac026b04e1acedeceb56aa4b190fa7f3973c", ) # GoogleTest/GoogleMock framework. Used by most unit-tests. diff --git a/absl/base/exception_safety_testing_test.cc b/absl/base/exception_safety_testing_test.cc index 9141e39..106bc34 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 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*) const { return testing::AssertionSuccess(); } -} CheckExhaustivenessTesterInvariants; +} CheckExhaustivenessTesterContracts; template unsigned char ExhaustivenessTester::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>{}) - .WithInvariants(testing::strong_guarantee) + .WithContracts(testing::strong_guarantee) .Test()); EXPECT_EQ(ExhaustivenessTester>::successes, 0xF); } diff --git a/absl/base/internal/exception_safety_testing.h b/absl/base/internal/exception_safety_testing.h index de4f0e2..5665a1b 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 -absl::optional TestSingleInvariantAtCountdownImpl( +template +absl::optional TestSingleContractAtCountdownImpl( const Factory& factory, const Operation& operation, int count, - const Invariant& invariant) { + const Contract& contract) { auto t_ptr = factory(); absl::optional 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 TestSingleInvariantAtCountdownImpl( } template -absl::optional TestSingleInvariantAtCountdownImpl( +absl::optional 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 -int TestSingleInvariantAtCountdown( +template +int TestSingleContractAtCountdown( const Factory& factory, const Operation& operation, int count, - const Invariant& invariant, + const Contract& contract, absl::optional* 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 -inline absl::optional TestAllInvariantsAtCountdown( +template +inline absl::optional TestAllContractsAtCountdown( const Factory& factory, const Operation& operation, int count, - const Invariants&... invariants) { + const Contracts&... contracts) { absl::optional 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(dummy); return reduced_res; } @@ -884,15 +884,15 @@ class DefaultFactory { T t_; }; -template using EnableIfTestable = typename absl::enable_if_t< - LazyInvariantsCount != 0 && + LazyContractsCount != 0 && !std::is_same::value && !std::is_same::value>; template + 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 +template class ExceptionSafetyTester { public: /* @@ -948,7 +948,7 @@ class ExceptionSafetyTester { * tester.WithFactory(...). */ template - ExceptionSafetyTester, Operation, Invariants...> + ExceptionSafetyTester, Operation, Contracts...> WithInitialValue(const T& t) const { return WithFactory(DefaultFactory(t)); } @@ -961,9 +961,9 @@ class ExceptionSafetyTester { * method tester.WithInitialValue(...). */ template - ExceptionSafetyTester, Operation, Invariants...> + ExceptionSafetyTester, 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 - ExceptionSafetyTester, Invariants...> + ExceptionSafetyTester, 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 - ExceptionSafetyTester...> - WithInvariants(const MoreInvariants&... more_invariants) const { - return {factory_, operation_, - std::tuple_cat(invariants_, - std::tuple...>( - more_invariants...))}; + template + ExceptionSafetyTester...> + WithContracts(const MoreContracts&... more_contracts) const { + return { + factory_, operation_, + std::tuple_cat(contracts_, std::tuple...>( + 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> + typename = EnableIfTestable> testing::AssertionResult Test(const NewOperation& new_operation) const { - return TestImpl(new_operation, absl::index_sequence_for()); + return TestImpl(new_operation, absl::index_sequence_for()); } /* * 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 > + template < + typename LazyOperation = Operation, + typename = EnableIfTestable> testing::AssertionResult Test() const { - return TestImpl(operation_, absl::index_sequence_for()); + return TestImpl(operation_, absl::index_sequence_for()); } private: @@ -1051,8 +1051,8 @@ class ExceptionSafetyTester { ExceptionSafetyTester() {} ExceptionSafetyTester(const Factory& f, const Operation& o, - const std::tuple& i) - : factory_(f), operation_(o), invariants_(i) {} + const std::tuple& i) + : factory_(f), operation_(o), contracts_(i) {} template 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(invariants_)...); - // If there is no value in the optional, no invariants were run because no + TestAllContractsAtCountdown(factory_, selected_operation, count, + std::get(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_; + std::tuple 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<> diff --git a/absl/container/fixed_array_exception_safety_test.cc b/absl/container/fixed_array_exception_safety_test.cc index c123c2a..da63dbf 100644 --- a/absl/container/fixed_array_exception_safety_test.cc +++ b/absl/container/fixed_array_exception_safety_test.cc @@ -97,7 +97,7 @@ testing::AssertionResult ReadMemory(FixedArr* fixed_arr) { TEST(FixedArrayExceptionSafety, Fill) { auto test_fill = testing::MakeExceptionSafetyTester() - .WithInvariants(ReadMemory) + .WithContracts(ReadMemory) .WithOperation([&](FixedArr* fixed_arr_ptr) { auto thrower = Thrower(kUpdatedValue, testing::nothrow_ctor); diff --git a/absl/debugging/stacktrace.cc b/absl/debugging/stacktrace.cc index 61fee61..463fad2 100644 --- a/absl/debugging/stacktrace.cc +++ b/absl/debugging/stacktrace.cc @@ -80,11 +80,13 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, int* sizes, } // anonymous namespace +ABSL_ATTRIBUTE_NOINLINE int GetStackFrames(void** result, int* sizes, int max_depth, int skip_count) { return Unwind(result, sizes, max_depth, skip_count, nullptr, nullptr); } +ABSL_ATTRIBUTE_NOINLINE int GetStackFramesWithContext(void** result, int* sizes, int max_depth, int skip_count, const void* uc, int* min_dropped_frames) { @@ -92,11 +94,13 @@ int GetStackFramesWithContext(void** result, int* sizes, int max_depth, min_dropped_frames); } +ABSL_ATTRIBUTE_NOINLINE int GetStackTrace(void** result, int max_depth, int skip_count) { return Unwind(result, nullptr, max_depth, skip_count, nullptr, nullptr); } +ABSL_ATTRIBUTE_NOINLINE int GetStackTraceWithContext(void** result, int max_depth, int skip_count, const void* uc, int* min_dropped_frames) { return Unwind(result, nullptr, max_depth, skip_count, uc, diff --git a/absl/memory/memory_exception_safety_test.cc b/absl/memory/memory_exception_safety_test.cc index d1f6e84..00d2b19 100644 --- a/absl/memory/memory_exception_safety_test.cc +++ b/absl/memory/memory_exception_safety_test.cc @@ -32,7 +32,7 @@ TEST(MakeUnique, CheckForLeaks) { .WithInitialValue(Thrower(kValue)) // Ensures make_unique does not modify the input. The real // test, though, is ConstructorTracker checking for leaks. - .WithInvariants(testing::strong_guarantee); + .WithContracts(testing::strong_guarantee); EXPECT_TRUE(tester.Test([](Thrower* thrower) { static_cast(absl::make_unique(*thrower)); diff --git a/absl/strings/internal/str_format/parser.cc b/absl/strings/internal/str_format/parser.cc index c3e16fc..5e3d0d0 100644 --- a/absl/strings/internal/str_format/parser.cc +++ b/absl/strings/internal/str_format/parser.cc @@ -84,16 +84,24 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv, const char *pos = src->data(); const char *const end = pos + src->size(); char c; - // Read the next char into `c` and update `pos`. Reads '\0' if at end. - const auto get_char = [&] { c = pos == end ? '\0' : *pos++; }; + // Read the next char into `c` and update `pos`. Returns false if there are + // no more chars to read. +#define ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR() \ + do { \ + if (ABSL_PREDICT_FALSE(pos == end)) return false; \ + c = *pos++; \ + } while (0) const auto parse_digits = [&] { int digits = c - '0'; - // We do not want to overflow `digits` so we consume at most digits10-1 + // We do not want to overflow `digits` so we consume at most digits10 // digits. If there are more digits the parsing will fail later on when the // digit doesn't match the expected characters. - int num_digits = std::numeric_limits::digits10 - 2; - for (get_char(); num_digits && std::isdigit(c); get_char()) { + int num_digits = std::numeric_limits::digits10; + for (;;) { + if (ABSL_PREDICT_FALSE(pos == end || !num_digits)) break; + c = *pos++; + if (!std::isdigit(c)) break; --num_digits; digits = 10 * digits + c - '0'; } @@ -101,14 +109,14 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv, }; if (is_positional) { - get_char(); - if (c < '1' || c > '9') return false; + ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); + if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return false; conv->arg_position = parse_digits(); assert(conv->arg_position > 0); - if (c != '$') return false; + if (ABSL_PREDICT_FALSE(c != '$')) return false; } - get_char(); + ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); // We should start with the basic flag on. assert(conv->flags.basic); @@ -119,32 +127,39 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv, if (c < 'A') { conv->flags.basic = false; - for (; c <= '0'; get_char()) { + for (; c <= '0';) { + // FIXME: We might be able to speed this up reusing the kIds lookup table + // from above. + // It might require changing Flags to be a plain integer where we can |= a + // value. switch (c) { case '-': conv->flags.left = true; - continue; + break; case '+': conv->flags.show_pos = true; - continue; + break; case ' ': conv->flags.sign_col = true; - continue; + break; case '#': conv->flags.alt = true; - continue; + break; case '0': conv->flags.zero = true; - continue; + break; + default: + goto flags_done; } - break; + ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); } +flags_done: if (c <= '9') { if (c >= '0') { int maybe_width = parse_digits(); if (!is_positional && c == '$') { - if (*next_arg != 0) return false; + if (ABSL_PREDICT_FALSE(*next_arg != 0)) return false; // Positional conversion. *next_arg = -1; conv->flags = Flags(); @@ -153,12 +168,12 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv, } conv->width.set_value(maybe_width); } else if (c == '*') { - get_char(); + ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); if (is_positional) { - if (c < '1' || c > '9') return false; + if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return false; conv->width.set_from_arg(parse_digits()); - if (c != '$') return false; - get_char(); + if (ABSL_PREDICT_FALSE(c != '$')) return false; + ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); } else { conv->width.set_from_arg(++*next_arg); } @@ -166,16 +181,16 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv, } if (c == '.') { - get_char(); + ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); if (std::isdigit(c)) { conv->precision.set_value(parse_digits()); } else if (c == '*') { - get_char(); + ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); if (is_positional) { - if (c < '1' || c > '9') return false; + if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return false; conv->precision.set_from_arg(parse_digits()); if (c != '$') return false; - get_char(); + ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); } else { conv->precision.set_from_arg(++*next_arg); } @@ -188,23 +203,23 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv, std::int8_t id = kIds[static_cast(c)]; if (id < 0) { - if (id == none) return false; + if (ABSL_PREDICT_FALSE(id == none)) return false; // It is a length modifier. using str_format_internal::LengthMod; LengthMod length_mod = LengthMod::FromId(static_cast(~id)); - get_char(); + ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); if (c == 'h' && length_mod.id() == LengthMod::h) { conv->length_mod = LengthMod::FromId(LengthMod::hh); - get_char(); + ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); } else if (c == 'l' && length_mod.id() == LengthMod::l) { conv->length_mod = LengthMod::FromId(LengthMod::ll); - get_char(); + ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); } else { conv->length_mod = length_mod; } id = kIds[static_cast(c)]; - if (id < 0) return false; + if (ABSL_PREDICT_FALSE(id < 0)) return false; } assert(CheckFastPathSetting(*conv)); diff --git a/absl/strings/internal/str_format/parser_test.cc b/absl/strings/internal/str_format/parser_test.cc index ac6886d..ae40203 100644 --- a/absl/strings/internal/str_format/parser_test.cc +++ b/absl/strings/internal/str_format/parser_test.cc @@ -84,9 +84,9 @@ class ConsumeUnboundConversionTest : public ::testing::Test { TEST_F(ConsumeUnboundConversionTest, ConsumeSpecification) { struct Expectation { int line; - const char *src; - const char *out; - const char *src_post; + string_view src; + string_view out; + string_view src_post; }; const Expectation kExpect[] = { {__LINE__, "", "", "" }, @@ -236,6 +236,16 @@ TEST_F(ConsumeUnboundConversionTest, WidthAndPrecision) { EXPECT_EQ(9, o.precision.get_from_arg()); EXPECT_FALSE(Run(".*0$d")) << "no arg 0"; + + // Large values + EXPECT_TRUE(Run("999999999.999999999d")); + EXPECT_FALSE(o.width.is_from_arg()); + EXPECT_EQ(999999999, o.width.value()); + EXPECT_FALSE(o.precision.is_from_arg()); + EXPECT_EQ(999999999, o.precision.value()); + + EXPECT_FALSE(Run("1000000000.999999999d")); + EXPECT_FALSE(Run("999999999.1000000000d")); } TEST_F(ConsumeUnboundConversionTest, Flags) { diff --git a/absl/strings/string_view.h b/absl/strings/string_view.h index 9c03108..6bcd3c4 100644 --- a/absl/strings/string_view.h +++ b/absl/strings/string_view.h @@ -173,8 +173,19 @@ class string_view { // Implicit constructor of a `string_view` from nul-terminated `str`. When // accepting possibly null strings, use `absl::NullSafeStringView(str)` // instead (see below). +#if ABSL_HAVE_BUILTIN(__builtin_strlen) || \ + (defined(__GNUC__) && !defined(__clang__)) + // GCC has __builtin_strlen according to + // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but + // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above. + // __builtin_strlen is constexpr. + constexpr string_view(const char* str) // NOLINT(runtime/explicit) + : ptr_(str), + length_(CheckLengthInternal(str ? __builtin_strlen(str) : 0)) {} +#else constexpr string_view(const char* str) // NOLINT(runtime/explicit) - : ptr_(str), length_(CheckLengthInternal(StrLenInternal(str))) {} + : ptr_(str), length_(CheckLengthInternal(str ? strlen(str) : 0)) {} +#endif // Implicit constructor of a `string_view` from a `const char*` and length. constexpr string_view(const char* data, size_type len) @@ -481,22 +492,6 @@ class string_view { static constexpr size_type kMaxSize = std::numeric_limits::max(); - // check whether __builtin_strlen is provided by the compiler. - // GCC doesn't have __has_builtin() - // (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66970), - // but has __builtin_strlen according to - // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html. -#if ABSL_HAVE_BUILTIN(__builtin_strlen) || \ - (defined(__GNUC__) && !defined(__clang__)) - static constexpr size_type StrLenInternal(const char* str) { - return str ? __builtin_strlen(str) : 0; - } -#else - static constexpr size_type StrLenInternal(const char* str) { - return str ? strlen(str) : 0; - } -#endif - static constexpr size_type CheckLengthInternal(size_type len) { return ABSL_ASSERT(len <= kMaxSize), len; } diff --git a/absl/synchronization/internal/graphcycles.cc b/absl/synchronization/internal/graphcycles.cc index ab1f3f8..d3878de 100644 --- a/absl/synchronization/internal/graphcycles.cc +++ b/absl/synchronization/internal/graphcycles.cc @@ -204,8 +204,7 @@ class NodeSet { } private: - static const int32_t kEmpty; - static const int32_t kDel; + enum : int32_t { kEmpty = -1, kDel = -2 }; Vec table_; uint32_t occupied_; // Count of non-empty slots (includes deleted slots) @@ -255,9 +254,6 @@ class NodeSet { NodeSet& operator=(const NodeSet&) = delete; }; -const int32_t NodeSet::kEmpty = -1; -const int32_t NodeSet::kDel = -2; - // We encode a node index and a node version in GraphId. The version // number is incremented when the GraphId is freed which automatically // invalidates all copies of the GraphId. diff --git a/absl/time/time.h b/absl/time/time.h index 36e10b9..2f0fda4 100644 --- a/absl/time/time.h +++ b/absl/time/time.h @@ -322,6 +322,9 @@ Duration Ceil(Duration d, Duration unit); // 0 == d / inf // INT64_MAX == inf / d // +// d < inf +// -inf < d +// // // Division by zero returns infinity, or INT64_MIN/MAX where appropriate. // inf == d / 0 // INT64_MAX == d / absl::ZeroDuration() diff --git a/absl/types/any_exception_safety_test.cc b/absl/types/any_exception_safety_test.cc index cfb82d8..f9dd8c4 100644 --- a/absl/types/any_exception_safety_test.cc +++ b/absl/types/any_exception_safety_test.cc @@ -107,7 +107,7 @@ TEST(AnyExceptionSafety, Assignment) { }; auto any_strong_tester = testing::MakeExceptionSafetyTester() .WithInitialValue(original) - .WithInvariants(AnyInvariants, any_is_strong); + .WithContracts(AnyInvariants, any_is_strong); Thrower val(2); absl::any any_val(val); @@ -129,7 +129,7 @@ TEST(AnyExceptionSafety, Assignment) { auto strong_empty_any_tester = testing::MakeExceptionSafetyTester() .WithInitialValue(absl::any{}) - .WithInvariants(AnyInvariants, empty_any_is_strong); + .WithContracts(AnyInvariants, empty_any_is_strong); EXPECT_TRUE(strong_empty_any_tester.Test(assign_any)); EXPECT_TRUE(strong_empty_any_tester.Test(assign_val)); @@ -142,7 +142,7 @@ TEST(AnyExceptionSafety, Emplace) { absl::any{absl::in_place_type_t(), 1, testing::nothrow_ctor}; auto one_tester = testing::MakeExceptionSafetyTester() .WithInitialValue(initial_val) - .WithInvariants(AnyInvariants, AnyIsEmpty); + .WithContracts(AnyInvariants, AnyIsEmpty); auto emp_thrower = [](absl::any* ap) { ap->emplace(2); }; auto emp_throwervec = [](absl::any* ap) { diff --git a/absl/types/internal/variant.h b/absl/types/internal/variant.h index f220afd..eff4fef 100644 --- a/absl/types/internal/variant.h +++ b/absl/types/internal/variant.h @@ -1,4 +1,4 @@ -// Copyright 2017 The Abseil Authors. +// Copyright 2018 The Abseil Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -910,6 +910,11 @@ struct PerformVisitation { template constexpr ReturnType Run(std::false_type /*has_valueless*/, index_sequence, SizeT...) const { + static_assert( + std::is_same...)>>::value, + "All visitation overloads must have the same return type."); return absl::base_internal::Invoke( absl::forward(op), VariantCoreAccess::Access( diff --git a/absl/types/optional_exception_safety_test.cc b/absl/types/optional_exception_safety_test.cc index 31eb66d..d117ee5 100644 --- a/absl/types/optional_exception_safety_test.cc +++ b/absl/types/optional_exception_safety_test.cc @@ -43,7 +43,7 @@ bool ValueThrowsBadOptionalAccess(const OptionalT& optional) try { } template -AssertionResult CheckInvariants(OptionalT* optional_ptr) { +AssertionResult OptionalInvariants(OptionalT* optional_ptr) { // Check the current state post-throw for validity auto& optional = *optional_ptr; @@ -123,8 +123,8 @@ TEST(OptionalExceptionSafety, NothrowConstructors) { TEST(OptionalExceptionSafety, Emplace) { // Test the basic guarantee plus test the result of optional::has_value() // is false in all cases - auto disengaged_test = MakeExceptionSafetyTester().WithInvariants( - CheckInvariants, CheckDisengaged); + auto disengaged_test = MakeExceptionSafetyTester().WithContracts( + OptionalInvariants, CheckDisengaged); auto disengaged_test_empty = disengaged_test.WithInitialValue(Optional()); auto disengaged_test_nonempty = disengaged_test.WithInitialValue(Optional(kInitialInteger)); @@ -147,11 +147,11 @@ TEST(OptionalExceptionSafety, EverythingThrowsSwap) { // Test the basic guarantee plus test the result of optional::has_value() // remains the same auto test = - MakeExceptionSafetyTester().WithInvariants(CheckInvariants); + MakeExceptionSafetyTester().WithContracts(OptionalInvariants); auto disengaged_test_empty = test.WithInitialValue(Optional()) - .WithInvariants(CheckDisengaged); + .WithContracts(CheckDisengaged); auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger)) - .WithInvariants(CheckEngaged); + .WithContracts(CheckEngaged); auto swap_empty = [](Optional* optional_ptr) { auto empty = Optional(); @@ -192,11 +192,11 @@ TEST(OptionalExceptionSafety, CopyAssign) { // Test the basic guarantee plus test the result of optional::has_value() // remains the same auto test = - MakeExceptionSafetyTester().WithInvariants(CheckInvariants); + MakeExceptionSafetyTester().WithContracts(OptionalInvariants); auto disengaged_test_empty = test.WithInitialValue(Optional()) - .WithInvariants(CheckDisengaged); + .WithContracts(CheckDisengaged); auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger)) - .WithInvariants(CheckEngaged); + .WithContracts(CheckEngaged); auto copyassign_nonempty = [](Optional* optional_ptr) { auto nonempty = @@ -218,11 +218,11 @@ TEST(OptionalExceptionSafety, MoveAssign) { // Test the basic guarantee plus test the result of optional::has_value() // remains the same auto test = - MakeExceptionSafetyTester().WithInvariants(CheckInvariants); + MakeExceptionSafetyTester().WithContracts(OptionalInvariants); auto disengaged_test_empty = test.WithInitialValue(Optional()) - .WithInvariants(CheckDisengaged); + .WithContracts(CheckDisengaged); auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger)) - .WithInvariants(CheckEngaged); + .WithContracts(CheckEngaged); auto moveassign_empty = [](Optional* optional_ptr) { auto empty = Optional(); diff --git a/absl/types/variant_exception_safety_test.cc b/absl/types/variant_exception_safety_test.cc index a3c9eac..58436f0 100644 --- a/absl/types/variant_exception_safety_test.cc +++ b/absl/types/variant_exception_safety_test.cc @@ -59,7 +59,7 @@ void ToValuelessByException(ThrowingVariant& v) { // NOLINT } // Check that variant is still in a usable state after an exception is thrown. -testing::AssertionResult CheckInvariants(ThrowingVariant* v) { +testing::AssertionResult VariantInvariants(ThrowingVariant* v) { using testing::AssertionFailure; using testing::AssertionSuccess; @@ -213,8 +213,8 @@ TEST(VariantExceptionSafetyTest, CopyAssign) { MakeExceptionSafetyTester() .WithInitialValue(WithThrower()) .WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; }); - EXPECT_TRUE(tester.WithInvariants(CheckInvariants).Test()); - EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test()); + EXPECT_TRUE(tester.WithContracts(VariantInvariants).Test()); + EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test()); } { const ThrowingVariant rhs(ExpectedThrowerVec()); @@ -222,8 +222,8 @@ TEST(VariantExceptionSafetyTest, CopyAssign) { MakeExceptionSafetyTester() .WithInitialValue(WithThrowerVec()) .WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; }); - EXPECT_TRUE(tester.WithInvariants(CheckInvariants).Test()); - EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test()); + EXPECT_TRUE(tester.WithContracts(VariantInvariants).Test()); + EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test()); } // libstdc++ std::variant has bugs on copy assignment regarding exception // safety. @@ -251,12 +251,12 @@ TEST(VariantExceptionSafetyTest, CopyAssign) { .WithInitialValue(WithCopyNoThrow()) .WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; }); EXPECT_TRUE(tester - .WithInvariants(CheckInvariants, - [](ThrowingVariant* lhs) { - return lhs->valueless_by_exception(); - }) + .WithContracts(VariantInvariants, + [](ThrowingVariant* lhs) { + return lhs->valueless_by_exception(); + }) .Test()); - EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test()); + EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test()); } #endif // !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__)) { @@ -268,7 +268,7 @@ TEST(VariantExceptionSafetyTest, CopyAssign) { const ThrowingVariant rhs(MoveNothrow{}); EXPECT_TRUE(MakeExceptionSafetyTester() .WithInitialValue(WithThrower()) - .WithInvariants(CheckInvariants, strong_guarantee) + .WithContracts(VariantInvariants, strong_guarantee) .Test([&rhs](ThrowingVariant* lhs) { *lhs = rhs; })); } } @@ -304,11 +304,11 @@ TEST(VariantExceptionSafetyTest, MoveAssign) { *lhs = std::move(copy); }); EXPECT_TRUE(tester - .WithInvariants( - CheckInvariants, + .WithContracts( + VariantInvariants, [&](ThrowingVariant* lhs) { return lhs->index() == j; }) .Test()); - EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test()); + EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test()); } { // - otherwise (index() != j), equivalent to @@ -318,10 +318,10 @@ TEST(VariantExceptionSafetyTest, MoveAssign) { ThrowingVariant rhs(CopyNothrow{}); EXPECT_TRUE(MakeExceptionSafetyTester() .WithInitialValue(WithThrower()) - .WithInvariants(CheckInvariants, - [](ThrowingVariant* lhs) { - return lhs->valueless_by_exception(); - }) + .WithContracts(VariantInvariants, + [](ThrowingVariant* lhs) { + return lhs->valueless_by_exception(); + }) .Test([&](ThrowingVariant* lhs) { auto copy = rhs; *lhs = std::move(copy); @@ -347,12 +347,12 @@ TEST(VariantExceptionSafetyTest, ValueAssign) { .WithInitialValue(WithThrower()) .WithOperation([rhs](ThrowingVariant* lhs) { *lhs = rhs; }); EXPECT_TRUE(copy_tester - .WithInvariants(CheckInvariants, - [](ThrowingVariant* lhs) { - return !lhs->valueless_by_exception(); - }) + .WithContracts(VariantInvariants, + [](ThrowingVariant* lhs) { + return !lhs->valueless_by_exception(); + }) .Test()); - EXPECT_FALSE(copy_tester.WithInvariants(strong_guarantee).Test()); + EXPECT_FALSE(copy_tester.WithContracts(strong_guarantee).Test()); // move assign auto move_tester = MakeExceptionSafetyTester() .WithInitialValue(WithThrower()) @@ -361,13 +361,13 @@ TEST(VariantExceptionSafetyTest, ValueAssign) { *lhs = std::move(copy); }); EXPECT_TRUE(move_tester - .WithInvariants(CheckInvariants, - [](ThrowingVariant* lhs) { - return !lhs->valueless_by_exception(); - }) + .WithContracts(VariantInvariants, + [](ThrowingVariant* lhs) { + return !lhs->valueless_by_exception(); + }) .Test()); - EXPECT_FALSE(move_tester.WithInvariants(strong_guarantee).Test()); + EXPECT_FALSE(move_tester.WithContracts(strong_guarantee).Test()); } // Otherwise (*this holds something else), if is_nothrow_constructible_v || !is_nothrow_move_constructible_v is true, equivalent to @@ -400,12 +400,12 @@ TEST(VariantExceptionSafetyTest, ValueAssign) { .WithInitialValue(WithCopyNoThrow()) .WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; }); EXPECT_TRUE(copy_tester - .WithInvariants(CheckInvariants, - [](ThrowingVariant* lhs) { - return lhs->valueless_by_exception(); - }) + .WithContracts(VariantInvariants, + [](ThrowingVariant* lhs) { + return lhs->valueless_by_exception(); + }) .Test()); - EXPECT_FALSE(copy_tester.WithInvariants(strong_guarantee).Test()); + EXPECT_FALSE(copy_tester.WithContracts(strong_guarantee).Test()); // move auto move_tester = MakeExceptionSafetyTester() .WithInitialValue(WithCopyNoThrow()) @@ -413,12 +413,12 @@ TEST(VariantExceptionSafetyTest, ValueAssign) { *lhs = ExpectedThrower(testing::nothrow_ctor); }); EXPECT_TRUE(move_tester - .WithInvariants(CheckInvariants, - [](ThrowingVariant* lhs) { - return lhs->valueless_by_exception(); - }) + .WithContracts(VariantInvariants, + [](ThrowingVariant* lhs) { + return lhs->valueless_by_exception(); + }) .Test()); - EXPECT_FALSE(move_tester.WithInvariants(strong_guarantee).Test()); + EXPECT_FALSE(move_tester.WithContracts(strong_guarantee).Test()); } // Otherwise (if is_nothrow_constructible_v == false && // is_nothrow_move_constructible == true), @@ -432,7 +432,7 @@ TEST(VariantExceptionSafetyTest, ValueAssign) { MoveNothrow rhs; EXPECT_TRUE(MakeExceptionSafetyTester() .WithInitialValue(WithThrower()) - .WithInvariants(CheckInvariants, strong_guarantee) + .WithContracts(VariantInvariants, strong_guarantee) .Test([&rhs](ThrowingVariant* lhs) { *lhs = rhs; })); } #endif // !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__)) @@ -450,12 +450,12 @@ TEST(VariantExceptionSafetyTest, Emplace) { v->emplace(args); }); EXPECT_TRUE(tester - .WithInvariants(CheckInvariants, - [](ThrowingVariant* v) { - return v->valueless_by_exception(); - }) + .WithContracts(VariantInvariants, + [](ThrowingVariant* v) { + return v->valueless_by_exception(); + }) .Test()); - EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test()); + EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test()); } } @@ -472,7 +472,7 @@ TEST(VariantExceptionSafetyTest, Swap) { ThrowingVariant rhs = ExpectedThrower(); EXPECT_TRUE(MakeExceptionSafetyTester() .WithInitialValue(WithThrower()) - .WithInvariants(CheckInvariants) + .WithContracts(VariantInvariants) .Test([&](ThrowingVariant* lhs) { auto copy = rhs; lhs->swap(copy); @@ -486,7 +486,7 @@ TEST(VariantExceptionSafetyTest, Swap) { ThrowingVariant rhs = ExpectedThrower(); EXPECT_TRUE(MakeExceptionSafetyTester() .WithInitialValue(WithCopyNoThrow()) - .WithInvariants(CheckInvariants) + .WithContracts(VariantInvariants) .Test([&](ThrowingVariant* lhs) { auto copy = rhs; lhs->swap(copy); @@ -496,7 +496,7 @@ TEST(VariantExceptionSafetyTest, Swap) { ThrowingVariant rhs = ExpectedThrower(); EXPECT_TRUE(MakeExceptionSafetyTester() .WithInitialValue(WithCopyNoThrow()) - .WithInvariants(CheckInvariants) + .WithContracts(VariantInvariants) .Test([&](ThrowingVariant* lhs) { auto copy = rhs; copy.swap(*lhs); -- cgit v1.2.3