diff options
Diffstat (limited to 'absl/types')
| -rw-r--r-- | absl/types/any_exception_safety_test.cc | 6 | ||||
| -rw-r--r-- | absl/types/internal/variant.h | 7 | ||||
| -rw-r--r-- | absl/types/optional_exception_safety_test.cc | 24 | ||||
| -rw-r--r-- | absl/types/variant_exception_safety_test.cc | 94 |
4 files changed, 68 insertions, 63 deletions
diff --git a/absl/types/any_exception_safety_test.cc b/absl/types/any_exception_safety_test.cc index cfb82d80445c..f9dd8c482c25 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<Thrower>(), 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<Thrower>(2); }; auto emp_throwervec = [](absl::any* ap) { diff --git a/absl/types/internal/variant.h b/absl/types/internal/variant.h index f220afd04415..eff4fefed409 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 <std::size_t... TupIs, std::size_t... Is> constexpr ReturnType Run(std::false_type /*has_valueless*/, index_sequence<TupIs...>, SizeT<Is>...) const { + static_assert( + std::is_same<ReturnType, + absl::result_of_t<Op(VariantAccessResult< + Is, QualifiedVariants>...)>>::value, + "All visitation overloads must have the same return type."); return absl::base_internal::Invoke( absl::forward<Op>(op), VariantCoreAccess::Access<Is>( diff --git a/absl/types/optional_exception_safety_test.cc b/absl/types/optional_exception_safety_test.cc index 31eb66df5445..d117ee518491 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 <typename OptionalT> -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<Optional>, CheckDisengaged<Optional>); + auto disengaged_test = MakeExceptionSafetyTester().WithContracts( + OptionalInvariants<Optional>, CheckDisengaged<Optional>); 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<Optional>); + MakeExceptionSafetyTester().WithContracts(OptionalInvariants<Optional>); auto disengaged_test_empty = test.WithInitialValue(Optional()) - .WithInvariants(CheckDisengaged<Optional>); + .WithContracts(CheckDisengaged<Optional>); auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger)) - .WithInvariants(CheckEngaged<Optional>); + .WithContracts(CheckEngaged<Optional>); 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<Optional>); + MakeExceptionSafetyTester().WithContracts(OptionalInvariants<Optional>); auto disengaged_test_empty = test.WithInitialValue(Optional()) - .WithInvariants(CheckDisengaged<Optional>); + .WithContracts(CheckDisengaged<Optional>); auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger)) - .WithInvariants(CheckEngaged<Optional>); + .WithContracts(CheckEngaged<Optional>); 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<Optional>); + MakeExceptionSafetyTester().WithContracts(OptionalInvariants<Optional>); auto disengaged_test_empty = test.WithInitialValue(Optional()) - .WithInvariants(CheckDisengaged<Optional>); + .WithContracts(CheckDisengaged<Optional>); auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger)) - .WithInvariants(CheckEngaged<Optional>); + .WithContracts(CheckEngaged<Optional>); 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 a3c9eac33a75..58436f07b843 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<Tj, // T> || !is_nothrow_move_constructible_v<Tj> 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<Tj, T> == false && // is_nothrow_move_constructible<Tj> == 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<Thrower>(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); |