1 files changed, 0 insertions, 292 deletions
diff --git a/third_party/abseil_cpp/absl/types/optional_exception_safety_test.cc b/third_party/abseil_cpp/absl/types/optional_exception_safety_test.cc
deleted file mode 100644
index 8e5fe851db..0000000000
--- a/third_party/abseil_cpp/absl/types/optional_exception_safety_test.cc
+++ /dev/null
@@ -1,292 +0,0 @@
-// 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
-//
-//      https://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 "absl/base/config.h"
-
-// This test is a no-op when absl::optional is an alias for std::optional and
-// when exceptions are not enabled.
-#if !defined(ABSL_USES_STD_OPTIONAL) && defined(ABSL_HAVE_EXCEPTIONS)
-
-#include "gtest/gtest.h"
-#include "absl/base/internal/exception_safety_testing.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-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 (const absl::bad_optional_access&) {
-  return true;
-}
-
-template <typename OptionalT>
-AssertionResult OptionalInvariants(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().WithContracts(
-      OptionalInvariants<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().WithContracts(OptionalInvariants<Optional>);
-  auto disengaged_test_empty = test.WithInitialValue(Optional())
-                                   .WithContracts(CheckDisengaged<Optional>);
-  auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
-                                   .WithContracts(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 empty = MoveOptional();
-    auto nonempty = MoveOptional(kInitialInteger);
-    EXPECT_TRUE(testing::TestNothrowOp([&]() { nonempty.swap(empty); }));
-  }
-  {
-    auto nonempty = MoveOptional(kUpdatedInteger);
-    auto empty = MoveOptional();
-    EXPECT_TRUE(testing::TestNothrowOp([&]() { empty.swap(nonempty); }));
-  }
-  {
-    auto nonempty_from = MoveOptional(kUpdatedInteger);
-    auto nonempty_to = MoveOptional(kInitialInteger);
-    EXPECT_TRUE(
-        testing::TestNothrowOp([&]() { nonempty_to.swap(nonempty_from); }));
-  }
-}
-
-TEST(OptionalExceptionSafety, CopyAssign) {
-  // Test the basic guarantee plus test the result of optional::has_value()
-  // remains the same
-  auto test =
-      MakeExceptionSafetyTester().WithContracts(OptionalInvariants<Optional>);
-  auto disengaged_test_empty = test.WithInitialValue(Optional())
-                                   .WithContracts(CheckDisengaged<Optional>);
-  auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
-                                   .WithContracts(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().WithContracts(OptionalInvariants<Optional>);
-  auto disengaged_test_empty = test.WithInitialValue(Optional())
-                                   .WithContracts(CheckDisengaged<Optional>);
-  auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
-                                   .WithContracts(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 empty = MoveOptional();
-    auto nonempty = MoveOptional(kInitialInteger);
-    EXPECT_TRUE(testing::TestNothrowOp([&]() { nonempty = std::move(empty); }));
-  }
-  {
-    auto nonempty = MoveOptional(kInitialInteger);
-    auto empty = MoveOptional();
-    EXPECT_TRUE(testing::TestNothrowOp([&]() { empty = std::move(nonempty); }));
-  }
-  {
-    auto nonempty_from = MoveOptional(kUpdatedInteger);
-    auto nonempty_to = MoveOptional(kInitialInteger);
-    EXPECT_TRUE(testing::TestNothrowOp(
-        [&]() { nonempty_to = std::move(nonempty_from); }));
-  }
-  {
-    auto thrower = MoveThrower(kUpdatedInteger);
-    auto empty = MoveOptional();
-    EXPECT_TRUE(testing::TestNothrowOp([&]() { empty = std::move(thrower); }));
-  }
-  {
-    auto thrower = MoveThrower(kUpdatedInteger);
-    auto nonempty = MoveOptional(kInitialInteger);
-    EXPECT_TRUE(
-        testing::TestNothrowOp([&]() { nonempty = std::move(thrower); }));
-  }
-}
-
-}  // namespace
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // #if !defined(ABSL_USES_STD_OPTIONAL) && defined(ABSL_HAVE_EXCEPTIONS)