tvl-depot/absl/base/throw_delegate_test.cc
Abseil Team 1948f6f967 Export of internal Abseil changes
--
bc74316103bbda92541896f588f71c9d45bea768 by Gennadiy Civil <misterg@google.com>:

Manually fixing the BUILD.bazel files

--
d41bf9ea916a0dc8c69e6ba77f58f9d55649880e by Shaindel Schwartz <shaindel@google.com>:

Minor cleanup to miscellaneous BUILD files.

PiperOrigin-RevId: 266420157

--
08a8dc2cbd48d27e1115809f9ca8d178551cd66e by Gennadiy Civil <misterg@google.com>:

Internal Change
BEGIN_PUBLIC
Internal Change
END_PUBLIC

--
8617d58fde1ece40e4aa79eaa5e250b42d19835f by Shaindel Schwartz <shaindel@google.com>:

Internal Change
BEGIN_PUBLIC
Internal Change
END_PUBLIC

--
3a0fc7d48bdc70c4f7dffc219578693dea84eb2d by Derek Mauro <dmauro@google.com>:

Implement absl::string_view::at()

PiperOrigin-RevId: 266024644

--
ba53a9da8ede8fe7b8971eaab6b3a1fa34763ff6 by Andy Soffer <asoffer@google.com>:

Remove forcing of optimization levels in MSVC.

PiperOrigin-RevId: 265927588

--
df86f2046b54bba7da2e345040806d43470de5c0 by Shaindel Schwartz <shaindel@google.com>:

Internal change

PiperOrigin-RevId: 265811077

--
e2e3a6e8194363e7c6377672560c806d638a7c74 by Derek Mauro <dmauro@google.com>:

Remove ABI unsafe mixed exceptions mode compilation.
Testing will now be done on CI with the exceptions flag set globally.

PiperOrigin-RevId: 265796079
GitOrigin-RevId: bc74316103bbda92541896f588f71c9d45bea768
Change-Id: Ibccd00f4829520454aa55c4f55c7cb2dc9c6b65a
2019-08-30 15:38:01 -04:00

107 lines
3.5 KiB
C++

// 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/base/internal/throw_delegate.h"
#include <functional>
#include <new>
#include <stdexcept>
#include "absl/base/config.h"
#include "gtest/gtest.h"
namespace {
using absl::base_internal::ThrowStdLogicError;
using absl::base_internal::ThrowStdInvalidArgument;
using absl::base_internal::ThrowStdDomainError;
using absl::base_internal::ThrowStdLengthError;
using absl::base_internal::ThrowStdOutOfRange;
using absl::base_internal::ThrowStdRuntimeError;
using absl::base_internal::ThrowStdRangeError;
using absl::base_internal::ThrowStdOverflowError;
using absl::base_internal::ThrowStdUnderflowError;
using absl::base_internal::ThrowStdBadFunctionCall;
using absl::base_internal::ThrowStdBadAlloc;
constexpr const char* what_arg = "The quick brown fox jumps over the lazy dog";
template <typename E>
void ExpectThrowChar(void (*f)(const char*)) {
#ifdef ABSL_HAVE_EXCEPTIONS
try {
f(what_arg);
FAIL() << "Didn't throw";
} catch (const E& e) {
EXPECT_STREQ(e.what(), what_arg);
}
#else
EXPECT_DEATH_IF_SUPPORTED(f(what_arg), what_arg);
#endif
}
template <typename E>
void ExpectThrowString(void (*f)(const std::string&)) {
#ifdef ABSL_HAVE_EXCEPTIONS
try {
f(what_arg);
FAIL() << "Didn't throw";
} catch (const E& e) {
EXPECT_STREQ(e.what(), what_arg);
}
#else
EXPECT_DEATH_IF_SUPPORTED(f(what_arg), what_arg);
#endif
}
template <typename E>
void ExpectThrowNoWhat(void (*f)()) {
#ifdef ABSL_HAVE_EXCEPTIONS
try {
f();
FAIL() << "Didn't throw";
} catch (const E& e) {
}
#else
EXPECT_DEATH_IF_SUPPORTED(f(), "");
#endif
}
TEST(ThrowHelper, Test) {
// Not using EXPECT_THROW because we want to check the .what() message too.
ExpectThrowChar<std::logic_error>(ThrowStdLogicError);
ExpectThrowChar<std::invalid_argument>(ThrowStdInvalidArgument);
ExpectThrowChar<std::domain_error>(ThrowStdDomainError);
ExpectThrowChar<std::length_error>(ThrowStdLengthError);
ExpectThrowChar<std::out_of_range>(ThrowStdOutOfRange);
ExpectThrowChar<std::runtime_error>(ThrowStdRuntimeError);
ExpectThrowChar<std::range_error>(ThrowStdRangeError);
ExpectThrowChar<std::overflow_error>(ThrowStdOverflowError);
ExpectThrowChar<std::underflow_error>(ThrowStdUnderflowError);
ExpectThrowString<std::logic_error>(ThrowStdLogicError);
ExpectThrowString<std::invalid_argument>(ThrowStdInvalidArgument);
ExpectThrowString<std::domain_error>(ThrowStdDomainError);
ExpectThrowString<std::length_error>(ThrowStdLengthError);
ExpectThrowString<std::out_of_range>(ThrowStdOutOfRange);
ExpectThrowString<std::runtime_error>(ThrowStdRuntimeError);
ExpectThrowString<std::range_error>(ThrowStdRangeError);
ExpectThrowString<std::overflow_error>(ThrowStdOverflowError);
ExpectThrowString<std::underflow_error>(ThrowStdUnderflowError);
ExpectThrowNoWhat<std::bad_function_call>(ThrowStdBadFunctionCall);
ExpectThrowNoWhat<std::bad_alloc>(ThrowStdBadAlloc);
}
} // namespace