summaryrefslogtreecommitdiff
path: root/absl/types
diff options
context:
space:
mode:
authorGravatar Abseil Team <absl-team@google.com>2018-05-31 12:26:35 -0700
committerGravatar Mark Barolak <mbar@google.com>2018-05-31 15:58:36 -0400
commit7aacab8ae05d7115049923da9cfbf584dc1f8338 (patch)
tree4394fc5eeed08a356d02ccfef33d1201f21b0dc3 /absl/types
parent99477fa9f1e89a7d8253c8aeee331864710d080c (diff)
- e2f6b8ac647271815b4fed2991f405524dd762c3 Release cctz microbenchmarks. by Alex Strelnikov <strel@google.com>
- 924ba2a3f9fca695d73c6bf491d20669e2b96b8e Changed RawPtr to use std::addressof() instead of operato... by Abseil Team <absl-team@google.com> - e8cf67f9fa74d4c5632da35547025ad2301c6819 Import of CCTZ from GitHub. by Alex Strelnikov <strel@google.com> - 2ece8a96611afcddd7b91e0197dadb896248250c Abandon ".inc" files in favor of ".h" headers. by Jorg Brown <jorg@google.com> - 37f5ed5da4058f90fb3e6a2733fce5b1fd0aaedf Add exception safety tests for absl::optional<T> by Abseil Team <absl-team@google.com> - 337f995a866b8f905f64ca6b271b5fec8f248a60 Update WORKSPACE to grab specific commits of dependencies... by Alex Strelnikov <strel@google.com> - 93e5b134607a554993387ad913e6c1621606004b Release Charmap microbenchmark. by Alex Strelnikov <strel@google.com> - 95c2e29b6d93ec1334484ee37d91f63101c45307 Release OStringStream microbenchmarks. by Alex Strelnikov <strel@google.com> - 250f51839ed26dd1e6b658d35aa291413e5f4825 Internal change by Greg Falcon <gfalcon@google.com> - ce34900fa3d1a95a8446bc943cdd801fac95be25 Improve compatibility of cctz cc_test targets for portabl... by Shaindel Schwartz <shaindel@google.com> - ce7e31dbf2c1ee93c79aae5b7dc7c603cb4babcf Improve portability of cc_tests. (Mark more tests that ca... by Abseil Team <absl-team@google.com> - dfcd4e455923703c1a1dcd523c5f915f7990fa2a Accept strings with custom allocators as arguments to abs... by Greg Falcon <gfalcon@google.com> - 2946b41ed3d5b8b5a8dc11182e443cf1ab6e3bde Link against benchmark_main instead of using BENCHMARK_MA... by Alex Strelnikov <strel@google.com> - f09de9e03bf8edd363069c4b352d8009423f531c Adds link to doc about the formats allowed by SimpleAtof(... by Greg Miller <jgm@google.com> - 59b0977e7a308e0800277886cf60226b2cc426a1 Simplify the HideMask() calculation so that it doesn't us... by Jorg Brown <jorg@google.com> GitOrigin-RevId: e2f6b8ac647271815b4fed2991f405524dd762c3 Change-Id: Ib9c8547ed7fe217fad6cb3ab1362e96181aa5cfa
Diffstat (limited to 'absl/types')
-rw-r--r--absl/types/BUILD.bazel14
-rw-r--r--absl/types/CMakeLists.txt17
-rw-r--r--absl/types/optional_exception_safety_test.cc284
3 files changed, 315 insertions, 0 deletions
diff --git a/absl/types/BUILD.bazel b/absl/types/BUILD.bazel
index f8d53c26..c26c68d0 100644
--- a/absl/types/BUILD.bazel
+++ b/absl/types/BUILD.bazel
@@ -193,6 +193,20 @@ cc_test(
],
)
+cc_test(
+ name = "optional_exception_safety_test",
+ srcs = [
+ "optional_exception_safety_test.cc",
+ ],
+ copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+ deps = [
+ ":optional",
+ "//absl/base:exception_safety_testing",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+
cc_library(
name = "variant",
srcs = ["internal/variant.h"],
diff --git a/absl/types/CMakeLists.txt b/absl/types/CMakeLists.txt
index fbd83740..2f2e3a77 100644
--- a/absl/types/CMakeLists.txt
+++ b/absl/types/CMakeLists.txt
@@ -209,3 +209,20 @@ absl_test(
)
+# test optional_exception_safety_test
+set(OPTIONAL_EXCEPTION_SAFETY_TEST_SRC "optional_exception_safety_test.cc")
+set(OPTIONAL_EXCEPTION_SAFETY_TEST_PUBLIC_LIBRARIES
+ absl::optional
+ absl_base_internal_exception_safety_testing
+)
+
+absl_test(
+ TARGET
+ optional_exception_safety_test
+ SOURCES
+ ${OPTIONAL_EXCEPTION_SAFETY_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${OPTIONAL_EXCEPTION_SAFETY_TEST_PUBLIC_LIBRARIES}
+ PRIVATE_COMPILE_FLAGS
+ ${ABSL_EXCEPTIONS_FLAG}
+)
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<testing::TypeSpec::kEverythingThrows>;
+using Optional = absl::optional<Thrower>;
+
+using MoveThrower = testing::ThrowingValue<testing::TypeSpec::kNoThrowMove>;
+using MoveOptional = absl::optional<MoveThrower>;
+
+constexpr int kInitialInteger = 5;
+constexpr int kUpdatedInteger = 10;
+
+template <typename OptionalT>
+bool ValueThrowsBadOptionalAccess(const OptionalT& optional) try {
+ return (static_cast<void>(optional.value()), false);
+} catch (absl::bad_optional_access) {
+ return true;
+}
+
+template <typename OptionalT>
+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 <typename OptionalT>
+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 <typename OptionalT>
+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<Optional>(thrower_nonempty);
+
+ auto integer_nonempty = absl::optional<int>(kInitialInteger);
+ testing::TestThrowingCtor<Optional>(integer_nonempty);
+ testing::TestThrowingCtor<Optional>(std::move(integer_nonempty)); // NOLINT
+
+ testing::TestThrowingCtor<Optional>(kInitialInteger);
+ using ThrowerVec = std::vector<Thrower, testing::ThrowingAllocator<Thrower>>;
+ testing::TestThrowingCtor<absl::optional<ThrowerVec>>(
+ absl::in_place,
+ std::initializer_list<Thrower>{Thrower(), Thrower(), Thrower()},
+ testing::ThrowingAllocator<Thrower>());
+}
+
+TEST(OptionalExceptionSafety, NothrowConstructors) {
+ // This constructor is marked noexcept. If it throws, the program will
+ // terminate.
+ testing::TestThrowingCtor<MoveOptional>(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<Optional>, CheckDisengaged<Optional>);
+ 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<Optional>);
+ auto disengaged_test_empty = test.WithInitialValue(Optional())
+ .WithInvariants(CheckDisengaged<Optional>);
+ auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
+ .WithInvariants(CheckEngaged<Optional>);
+
+ 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<Optional>);
+ auto disengaged_test_empty = test.WithInitialValue(Optional())
+ .WithInvariants(CheckDisengaged<Optional>);
+ auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
+ .WithInvariants(CheckEngaged<Optional>);
+
+ 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<Optional>);
+ auto disengaged_test_empty = test.WithInitialValue(Optional())
+ .WithInvariants(CheckDisengaged<Optional>);
+ auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
+ .WithInvariants(CheckEngaged<Optional>);
+
+ 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