From 7aacab8ae05d7115049923da9cfbf584dc1f8338 Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Thu, 31 May 2018 12:26:35 -0700 Subject: - e2f6b8ac647271815b4fed2991f405524dd762c3 Release cctz microbenchmarks. by Alex Strelnikov - 924ba2a3f9fca695d73c6bf491d20669e2b96b8e Changed RawPtr to use std::addressof() instead of operato... by Abseil Team - e8cf67f9fa74d4c5632da35547025ad2301c6819 Import of CCTZ from GitHub. by Alex Strelnikov - 2ece8a96611afcddd7b91e0197dadb896248250c Abandon ".inc" files in favor of ".h" headers. by Jorg Brown - 37f5ed5da4058f90fb3e6a2733fce5b1fd0aaedf Add exception safety tests for absl::optional by Abseil Team - 337f995a866b8f905f64ca6b271b5fec8f248a60 Update WORKSPACE to grab specific commits of dependencies... by Alex Strelnikov - 93e5b134607a554993387ad913e6c1621606004b Release Charmap microbenchmark. by Alex Strelnikov - 95c2e29b6d93ec1334484ee37d91f63101c45307 Release OStringStream microbenchmarks. by Alex Strelnikov - 250f51839ed26dd1e6b658d35aa291413e5f4825 Internal change by Greg Falcon - ce34900fa3d1a95a8446bc943cdd801fac95be25 Improve compatibility of cctz cc_test targets for portabl... by Shaindel Schwartz - ce7e31dbf2c1ee93c79aae5b7dc7c603cb4babcf Improve portability of cc_tests. (Mark more tests that ca... by Abseil Team - dfcd4e455923703c1a1dcd523c5f915f7990fa2a Accept strings with custom allocators as arguments to abs... by Greg Falcon - 2946b41ed3d5b8b5a8dc11182e443cf1ab6e3bde Link against benchmark_main instead of using BENCHMARK_MA... by Alex Strelnikov - f09de9e03bf8edd363069c4b352d8009423f531c Adds link to doc about the formats allowed by SimpleAtof(... by Greg Miller - 59b0977e7a308e0800277886cf60226b2cc426a1 Simplify the HideMask() calculation so that it doesn't us... by Jorg Brown GitOrigin-RevId: e2f6b8ac647271815b4fed2991f405524dd762c3 Change-Id: Ib9c8547ed7fe217fad6cb3ab1362e96181aa5cfa --- absl/types/optional_exception_safety_test.cc | 284 +++++++++++++++++++++++++++ 1 file changed, 284 insertions(+) create mode 100644 absl/types/optional_exception_safety_test.cc (limited to 'absl/types/optional_exception_safety_test.cc') diff --git a/absl/types/optional_exception_safety_test.cc b/absl/types/optional_exception_safety_test.cc new file mode 100644 index 00000000..7f6348e1 --- /dev/null +++ b/absl/types/optional_exception_safety_test.cc @@ -0,0 +1,284 @@ +// Copyright 2017 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. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "absl/types/optional.h" + +#include "gtest/gtest.h" +#include "absl/base/internal/exception_safety_testing.h" + +namespace absl { + +namespace { + +using ::testing::AssertionFailure; +using ::testing::AssertionResult; +using ::testing::AssertionSuccess; +using ::testing::MakeExceptionSafetyTester; + +using Thrower = testing::ThrowingValue; +using Optional = absl::optional; + +using MoveThrower = testing::ThrowingValue; +using MoveOptional = absl::optional; + +constexpr int kInitialInteger = 5; +constexpr int kUpdatedInteger = 10; + +template +bool ValueThrowsBadOptionalAccess(const OptionalT& optional) try { + return (static_cast(optional.value()), false); +} catch (absl::bad_optional_access) { + return true; +} + +template +AssertionResult CheckInvariants(OptionalT* optional_ptr) { + // Check the current state post-throw for validity + auto& optional = *optional_ptr; + + if (optional.has_value() && ValueThrowsBadOptionalAccess(optional)) { + return AssertionFailure() + << "Optional with value should not throw bad_optional_access when " + "accessing the value."; + } + if (!optional.has_value() && !ValueThrowsBadOptionalAccess(optional)) { + return AssertionFailure() + << "Optional without a value should throw bad_optional_access when " + "accessing the value."; + } + + // Reset to a known state + optional.reset(); + + // Confirm that the known post-reset state is valid + if (optional.has_value()) { + return AssertionFailure() + << "Optional should not contain a value after being reset."; + } + if (!ValueThrowsBadOptionalAccess(optional)) { + return AssertionFailure() << "Optional should throw bad_optional_access " + "when accessing the value after being reset."; + } + + return AssertionSuccess(); +} + +template +AssertionResult CheckDisengaged(OptionalT* optional_ptr) { + auto& optional = *optional_ptr; + + if (optional.has_value()) { + return AssertionFailure() + << "Expected optional to not contain a value but a value was found."; + } + + return AssertionSuccess(); +} + +template +AssertionResult CheckEngaged(OptionalT* optional_ptr) { + auto& optional = *optional_ptr; + + if (!optional.has_value()) { + return AssertionFailure() + << "Expected optional to contain a value but no value was found."; + } + + return AssertionSuccess(); +} + +TEST(OptionalExceptionSafety, ThrowingConstructors) { + auto thrower_nonempty = Optional(Thrower(kInitialInteger)); + testing::TestThrowingCtor(thrower_nonempty); + + auto integer_nonempty = absl::optional(kInitialInteger); + testing::TestThrowingCtor(integer_nonempty); + testing::TestThrowingCtor(std::move(integer_nonempty)); // NOLINT + + testing::TestThrowingCtor(kInitialInteger); + using ThrowerVec = std::vector>; + testing::TestThrowingCtor>( + absl::in_place, + std::initializer_list{Thrower(), Thrower(), Thrower()}, + testing::ThrowingAllocator()); +} + +TEST(OptionalExceptionSafety, NothrowConstructors) { + // This constructor is marked noexcept. If it throws, the program will + // terminate. + testing::TestThrowingCtor(MoveOptional(kUpdatedInteger)); +} + +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_empty = disengaged_test.WithInitialValue(Optional()); + auto disengaged_test_nonempty = + disengaged_test.WithInitialValue(Optional(kInitialInteger)); + + auto emplace_thrower_directly = [](Optional* optional_ptr) { + optional_ptr->emplace(kUpdatedInteger); + }; + EXPECT_TRUE(disengaged_test_empty.Test(emplace_thrower_directly)); + EXPECT_TRUE(disengaged_test_nonempty.Test(emplace_thrower_directly)); + + auto emplace_thrower_copy = [](Optional* optional_ptr) { + auto thrower = Thrower(kUpdatedInteger, testing::nothrow_ctor); + optional_ptr->emplace(thrower); + }; + EXPECT_TRUE(disengaged_test_empty.Test(emplace_thrower_copy)); + EXPECT_TRUE(disengaged_test_nonempty.Test(emplace_thrower_copy)); +} + +TEST(OptionalExceptionSafety, EverythingThrowsSwap) { + // Test the basic guarantee plus test the result of optional::has_value() + // remains the same + auto test = + MakeExceptionSafetyTester().WithInvariants(CheckInvariants); + auto disengaged_test_empty = test.WithInitialValue(Optional()) + .WithInvariants(CheckDisengaged); + auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger)) + .WithInvariants(CheckEngaged); + + auto swap_empty = [](Optional* optional_ptr) { + auto empty = Optional(); + optional_ptr->swap(empty); + }; + EXPECT_TRUE(engaged_test_nonempty.Test(swap_empty)); + + auto swap_nonempty = [](Optional* optional_ptr) { + auto nonempty = + Optional(absl::in_place, kUpdatedInteger, testing::nothrow_ctor); + optional_ptr->swap(nonempty); + }; + EXPECT_TRUE(disengaged_test_empty.Test(swap_nonempty)); + EXPECT_TRUE(engaged_test_nonempty.Test(swap_nonempty)); +} + +TEST(OptionalExceptionSafety, NoThrowMoveSwap) { + // Tests the nothrow guarantee for optional of T with non-throwing move + auto nothrow_test = + MakeExceptionSafetyTester().WithInvariants(testing::nothrow_guarantee); + auto nothrow_test_empty = nothrow_test.WithInitialValue(MoveOptional()); + auto nothrow_test_nonempty = + nothrow_test.WithInitialValue(MoveOptional(kInitialInteger)); + + auto swap_empty = [](MoveOptional* optional_ptr) { + auto empty = MoveOptional(); + optional_ptr->swap(empty); + }; + EXPECT_TRUE(nothrow_test_nonempty.Test(swap_empty)); + + auto swap_nonempty = [](MoveOptional* optional_ptr) { + auto nonempty = + MoveOptional(absl::in_place, kUpdatedInteger, testing::nothrow_ctor); + optional_ptr->swap(nonempty); + }; + EXPECT_TRUE(nothrow_test_empty.Test(swap_nonempty)); + EXPECT_TRUE(nothrow_test_nonempty.Test(swap_nonempty)); +} + +TEST(OptionalExceptionSafety, CopyAssign) { + // Test the basic guarantee plus test the result of optional::has_value() + // remains the same + auto test = + MakeExceptionSafetyTester().WithInvariants(CheckInvariants); + auto disengaged_test_empty = test.WithInitialValue(Optional()) + .WithInvariants(CheckDisengaged); + auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger)) + .WithInvariants(CheckEngaged); + + auto copyassign_nonempty = [](Optional* optional_ptr) { + auto nonempty = + Optional(absl::in_place, kUpdatedInteger, testing::nothrow_ctor); + *optional_ptr = nonempty; + }; + EXPECT_TRUE(disengaged_test_empty.Test(copyassign_nonempty)); + EXPECT_TRUE(engaged_test_nonempty.Test(copyassign_nonempty)); + + auto copyassign_thrower = [](Optional* optional_ptr) { + auto thrower = Thrower(kUpdatedInteger, testing::nothrow_ctor); + *optional_ptr = thrower; + }; + EXPECT_TRUE(disengaged_test_empty.Test(copyassign_thrower)); + EXPECT_TRUE(engaged_test_nonempty.Test(copyassign_thrower)); +} + +TEST(OptionalExceptionSafety, MoveAssign) { + // Test the basic guarantee plus test the result of optional::has_value() + // remains the same + auto test = + MakeExceptionSafetyTester().WithInvariants(CheckInvariants); + auto disengaged_test_empty = test.WithInitialValue(Optional()) + .WithInvariants(CheckDisengaged); + auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger)) + .WithInvariants(CheckEngaged); + + auto moveassign_empty = [](Optional* optional_ptr) { + auto empty = Optional(); + *optional_ptr = std::move(empty); + }; + EXPECT_TRUE(engaged_test_nonempty.Test(moveassign_empty)); + + auto moveassign_nonempty = [](Optional* optional_ptr) { + auto nonempty = + Optional(absl::in_place, kUpdatedInteger, testing::nothrow_ctor); + *optional_ptr = std::move(nonempty); + }; + EXPECT_TRUE(disengaged_test_empty.Test(moveassign_nonempty)); + EXPECT_TRUE(engaged_test_nonempty.Test(moveassign_nonempty)); + + auto moveassign_thrower = [](Optional* optional_ptr) { + auto thrower = Thrower(kUpdatedInteger, testing::nothrow_ctor); + *optional_ptr = std::move(thrower); + }; + EXPECT_TRUE(disengaged_test_empty.Test(moveassign_thrower)); + EXPECT_TRUE(engaged_test_nonempty.Test(moveassign_thrower)); +} + +TEST(OptionalExceptionSafety, NothrowMoveAssign) { + // Tests the nothrow guarantee for optional of T with non-throwing move + auto nothrow_test = + MakeExceptionSafetyTester().WithInvariants(testing::nothrow_guarantee); + auto nothrow_test_empty = nothrow_test.WithInitialValue(MoveOptional()); + auto nothrow_test_nonempty = + nothrow_test.WithInitialValue(MoveOptional(kInitialInteger)); + + auto moveassign_empty = [](MoveOptional* optional_ptr) { + auto empty = MoveOptional(); + *optional_ptr = std::move(empty); + }; + EXPECT_TRUE(nothrow_test_nonempty.Test(moveassign_empty)); + + auto moveassign_nonempty = [](MoveOptional* optional_ptr) { + auto nonempty = + MoveOptional(absl::in_place, kUpdatedInteger, testing::nothrow_ctor); + *optional_ptr = std::move(nonempty); + }; + EXPECT_TRUE(nothrow_test_empty.Test(moveassign_nonempty)); + EXPECT_TRUE(nothrow_test_nonempty.Test(moveassign_nonempty)); + + auto moveassign_thrower = [](MoveOptional* optional_ptr) { + auto thrower = MoveThrower(kUpdatedInteger, testing::nothrow_ctor); + *optional_ptr = std::move(thrower); + }; + EXPECT_TRUE(nothrow_test_empty.Test(moveassign_thrower)); + EXPECT_TRUE(nothrow_test_nonempty.Test(moveassign_thrower)); +} + +} // namespace + +} // namespace absl -- cgit v1.2.3