mdebray/tvl-depot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

- 60c1f40a5e0bc33f93392ff6827528072d749a29 Move ExceptionSafetyTester from the absl:: namespace to t... by Abseil Team <absl-team@google.com>

Browse source 
- abd40a98f8ae746eb151e777ea8a8b5223d68a4b Splits the NoThrow flags into TypeSpec and AllocSpec flag... by Abseil Team <absl-team@google.com>
  - c16d0b5509b36679b384147b474135e7951afccf Change the abbreviation for the breakdowns of InfinitePas... by Abseil Team <absl-team@google.com>
  - 8ac104351764f23d666b52dce7536a34c05abf00 Use ABSL_CONST_INIT with std::atomic variables in static ... by Matt Armstrong <marmstrong@google.com>

GitOrigin-RevId: 60c1f40a5e0bc33f93392ff6827528072d749a29
Change-Id: I9d45a6ed30ed32ae57e9eff93f4205dbcd71feb2
This commit is contained in:
Abseil Team 2018-04-30 11:44:26 -07:00 committed by vslashg
parent 28f5b89070
commit 9613678332
13 changed files with 303 additions and 218 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

128
absl/base/exception_safety_testing_test.cc
View file

@ -25,11 +25,13 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
namespace absl { namespace testing {
namespace { namespace {
using ::absl::exceptions_internal::SetCountdown;
using ::absl::exceptions_internal::TestException; using ::testing::exceptions_internal::SetCountdown;
using ::absl::exceptions_internal::UnsetCountdown; using ::testing::exceptions_internal::TestException;
using ::testing::exceptions_internal::UnsetCountdown;
// EXPECT_NO_THROW can't inspect the thrown inspection in general. // EXPECT_NO_THROW can't inspect the thrown inspection in general.
template <typename F> template <typename F>
@ -166,17 +168,17 @@ TEST(ThrowingValueTest, ThrowingAllocatingOps) {
} }
TEST(ThrowingValueTest, NonThrowingMoveCtor) { TEST(ThrowingValueTest, NonThrowingMoveCtor) {
ThrowingValue<NoThrow::kMoveCtor> nothrow_ctor; ThrowingValue<TypeSpec::kNoThrowMove> nothrow_ctor;
SetCountdown(); SetCountdown();
ExpectNoThrow([&nothrow_ctor]() { ExpectNoThrow([&nothrow_ctor]() {
ThrowingValue<NoThrow::kMoveCtor> nothrow1 = std::move(nothrow_ctor); ThrowingValue<TypeSpec::kNoThrowMove> nothrow1 = std::move(nothrow_ctor);
}); });
UnsetCountdown(); UnsetCountdown();
} }
TEST(ThrowingValueTest, NonThrowingMoveAssign) { TEST(ThrowingValueTest, NonThrowingMoveAssign) {
ThrowingValue<NoThrow::kMoveAssign> nothrow_assign1, nothrow_assign2; ThrowingValue<TypeSpec::kNoThrowMove> nothrow_assign1, nothrow_assign2;
SetCountdown(); SetCountdown();
ExpectNoThrow([&nothrow_assign1, &nothrow_assign2]() { ExpectNoThrow([&nothrow_assign1, &nothrow_assign2]() {
@ -185,32 +187,58 @@ TEST(ThrowingValueTest, NonThrowingMoveAssign) {
UnsetCountdown(); UnsetCountdown();
} }
TEST(ThrowingValueTest, ThrowingCopyCtor) {
ThrowingValue<> tv;
TestOp([&]() { ThrowingValue<> tv_copy(tv); });
}
TEST(ThrowingValueTest, ThrowingCopyAssign) {
ThrowingValue<> tv1, tv2;
TestOp([&]() { tv1 = tv2; });
}
TEST(ThrowingValueTest, NonThrowingCopyCtor) {
ThrowingValue<TypeSpec::kNoThrowCopy> nothrow_ctor;
SetCountdown();
ExpectNoThrow([&nothrow_ctor]() {
ThrowingValue<TypeSpec::kNoThrowCopy> nothrow1(nothrow_ctor);
});
UnsetCountdown();
}
TEST(ThrowingValueTest, NonThrowingCopyAssign) {
ThrowingValue<TypeSpec::kNoThrowCopy> nothrow_assign1, nothrow_assign2;
SetCountdown();
ExpectNoThrow([&nothrow_assign1, &nothrow_assign2]() {
nothrow_assign1 = nothrow_assign2;
});
UnsetCountdown();
}
TEST(ThrowingValueTest, ThrowingSwap) { TEST(ThrowingValueTest, ThrowingSwap) {
ThrowingValue<> bomb1, bomb2; ThrowingValue<> bomb1, bomb2;
TestOp([&]() { std::swap(bomb1, bomb2); }); TestOp([&]() { std::swap(bomb1, bomb2); });
ThrowingValue<NoThrow::kMoveCtor> bomb3, bomb4;
TestOp([&]() { std::swap(bomb3, bomb4); });
ThrowingValue<NoThrow::kMoveAssign> bomb5, bomb6;
TestOp([&]() { std::swap(bomb5, bomb6); });
} }
TEST(ThrowingValueTest, NonThrowingSwap) { TEST(ThrowingValueTest, NonThrowingSwap) {
ThrowingValue<NoThrow::kMoveAssign | NoThrow::kMoveCtor> bomb1, bomb2; ThrowingValue<TypeSpec::kNoThrowMove> bomb1, bomb2;
ExpectNoThrow([&]() { std::swap(bomb1, bomb2); }); ExpectNoThrow([&]() { std::swap(bomb1, bomb2); });
} }
TEST(ThrowingValueTest, NonThrowingAllocation) { TEST(ThrowingValueTest, NonThrowingAllocation) {
ThrowingValue<NoThrow::kAllocation>* allocated; ThrowingValue<TypeSpec::kNoThrowNew>* allocated;
ThrowingValue<NoThrow::kAllocation>* array; ThrowingValue<TypeSpec::kNoThrowNew>* array;
ExpectNoThrow([&allocated]() { ExpectNoThrow([&allocated]() {
allocated = new ThrowingValue<NoThrow::kAllocation>(1); allocated = new ThrowingValue<TypeSpec::kNoThrowNew>(1);
delete allocated; delete allocated;
}); });
ExpectNoThrow([&array]() { ExpectNoThrow([&array]() {
array = new ThrowingValue<NoThrow::kAllocation>[2]; array = new ThrowingValue<TypeSpec::kNoThrowNew>[2];
delete[] array; delete[] array;
}); });
} }
@ -284,15 +312,15 @@ TEST(ThrowingAllocatorTest, MemoryManagement) {
int* i_array = int_alloc.allocate(2); int* i_array = int_alloc.allocate(2);
int_alloc.deallocate(i_array, 2); int_alloc.deallocate(i_array, 2);
ThrowingAllocator<ThrowingValue<>> ef_alloc; ThrowingAllocator<ThrowingValue<>> tv_alloc;
ThrowingValue<>* efp = ef_alloc.allocate(1); ThrowingValue<>* ptr = tv_alloc.allocate(1);
ef_alloc.deallocate(efp, 1); tv_alloc.deallocate(ptr, 1);
ThrowingValue<>* ef_array = ef_alloc.allocate(2); ThrowingValue<>* tv_array = tv_alloc.allocate(2);
ef_alloc.deallocate(ef_array, 2); tv_alloc.deallocate(tv_array, 2);
} }
TEST(ThrowingAllocatorTest, CallsGlobalNew) { TEST(ThrowingAllocatorTest, CallsGlobalNew) {
ThrowingAllocator<ThrowingValue<>, NoThrow::kNoThrow> nothrow_alloc; ThrowingAllocator<ThrowingValue<>, AllocSpec::kNoThrowAllocate> nothrow_alloc;
ThrowingValue<>* ptr; ThrowingValue<>* ptr;
SetCountdown(); SetCountdown();
@ -322,7 +350,7 @@ TEST(ThrowingAllocatorTest, ThrowingConstructors) {
TEST(ThrowingAllocatorTest, NonThrowingConstruction) { TEST(ThrowingAllocatorTest, NonThrowingConstruction) {
{ {
ThrowingAllocator<int, NoThrow::kNoThrow> int_alloc; ThrowingAllocator<int, AllocSpec::kNoThrowAllocate> int_alloc;
int* ip = nullptr; int* ip = nullptr;
SetCountdown(); SetCountdown();
@ -347,19 +375,20 @@ TEST(ThrowingAllocatorTest, NonThrowingConstruction) {
} }
{ {
ThrowingAllocator<ThrowingValue<NoThrow::kIntCtor>, NoThrow::kNoThrow> ThrowingAllocator<ThrowingValue<>, AllocSpec::kNoThrowAllocate>
ef_alloc; nothrow_alloc;
ThrowingValue<NoThrow::kIntCtor>* efp; ThrowingValue<>* ptr;
SetCountdown(); SetCountdown();
ExpectNoThrow([&]() { efp = ef_alloc.allocate(1); }); ExpectNoThrow([&]() { ptr = nothrow_alloc.allocate(1); });
SetCountdown(); SetCountdown();
ExpectNoThrow([&]() { ef_alloc.construct(efp, 2); }); ExpectNoThrow(
[&]() { nothrow_alloc.construct(ptr, 2, testing::no_throw_ctor); });
EXPECT_EQ(efp->Get(), 2); EXPECT_EQ(ptr->Get(), 2);
ef_alloc.destroy(efp); nothrow_alloc.destroy(ptr);
ef_alloc.deallocate(efp, 1); nothrow_alloc.deallocate(ptr, 1);
UnsetCountdown(); UnsetCountdown();
} }
@ -448,15 +477,15 @@ TEST(ExceptionSafetyTesterTest, IncompleteTypesAreNotTestable) {
// Test that providing operation and inveriants still does not allow for the // Test that providing operation and inveriants still does not allow for the
// the invocation of .Test() and .Test(op) because it lacks a factory // the invocation of .Test() and .Test(op) because it lacks a factory
auto without_fac = auto without_fac =
absl::MakeExceptionSafetyTester().WithOperation(op).WithInvariants( testing::MakeExceptionSafetyTester().WithOperation(op).WithInvariants(
inv, absl::strong_guarantee); inv, testing::strong_guarantee);
EXPECT_FALSE(HasNullaryTest(without_fac)); EXPECT_FALSE(HasNullaryTest(without_fac));
EXPECT_FALSE(HasUnaryTest(without_fac)); EXPECT_FALSE(HasUnaryTest(without_fac));
// Test that providing invariants and factory allows the invocation of // Test that providing invariants and factory allows the invocation of
// .Test(op) but does not allow for .Test() because it lacks an operation // .Test(op) but does not allow for .Test() because it lacks an operation
auto without_op = absl::MakeExceptionSafetyTester() auto without_op = testing::MakeExceptionSafetyTester()
.WithInvariants(inv, absl::strong_guarantee) .WithInvariants(inv, testing::strong_guarantee)
.WithFactory(fac); .WithFactory(fac);
EXPECT_FALSE(HasNullaryTest(without_op)); EXPECT_FALSE(HasNullaryTest(without_op));
EXPECT_TRUE(HasUnaryTest(without_op)); EXPECT_TRUE(HasUnaryTest(without_op));
@ -464,7 +493,7 @@ TEST(ExceptionSafetyTesterTest, IncompleteTypesAreNotTestable) {
// Test that providing operation and factory still does not allow for the // Test that providing operation and factory still does not allow for the
// the invocation of .Test() and .Test(op) because it lacks invariants // the invocation of .Test() and .Test(op) because it lacks invariants
auto without_inv = auto without_inv =
absl::MakeExceptionSafetyTester().WithOperation(op).WithFactory(fac); testing::MakeExceptionSafetyTester().WithOperation(op).WithFactory(fac);
EXPECT_FALSE(HasNullaryTest(without_inv)); EXPECT_FALSE(HasNullaryTest(without_inv));
EXPECT_FALSE(HasUnaryTest(without_inv)); EXPECT_FALSE(HasUnaryTest(without_inv));
} }
@ -509,28 +538,28 @@ auto example_lambda_invariant = [](ExampleStruct* example_struct) {
// lambdas can all be used with ExceptionSafetyTester // lambdas can all be used with ExceptionSafetyTester
TEST(ExceptionSafetyTesterTest, MixedFunctionTypes) { TEST(ExceptionSafetyTesterTest, MixedFunctionTypes) {
// function reference // function reference
EXPECT_TRUE(absl::MakeExceptionSafetyTester() EXPECT_TRUE(testing::MakeExceptionSafetyTester()
.WithFactory(ExampleFunctionFactory) .WithFactory(ExampleFunctionFactory)
.WithOperation(ExampleFunctionOperation) .WithOperation(ExampleFunctionOperation)
.WithInvariants(ExampleFunctionInvariant) .WithInvariants(ExampleFunctionInvariant)
.Test()); .Test());
// function pointer // function pointer
EXPECT_TRUE(absl::MakeExceptionSafetyTester() EXPECT_TRUE(testing::MakeExceptionSafetyTester()
.WithFactory(&ExampleFunctionFactory) .WithFactory(&ExampleFunctionFactory)
.WithOperation(&ExampleFunctionOperation) .WithOperation(&ExampleFunctionOperation)
.WithInvariants(&ExampleFunctionInvariant) .WithInvariants(&ExampleFunctionInvariant)
.Test()); .Test());
// struct // struct
EXPECT_TRUE(absl::MakeExceptionSafetyTester() EXPECT_TRUE(testing::MakeExceptionSafetyTester()
.WithFactory(example_struct_factory) .WithFactory(example_struct_factory)
.WithOperation(example_struct_operation) .WithOperation(example_struct_operation)
.WithInvariants(example_struct_invariant) .WithInvariants(example_struct_invariant)
.Test()); .Test());
// lambda // lambda
EXPECT_TRUE(absl::MakeExceptionSafetyTester() EXPECT_TRUE(testing::MakeExceptionSafetyTester()
.WithFactory(example_lambda_factory) .WithFactory(example_lambda_factory)
.WithOperation(example_lambda_operation) .WithOperation(example_lambda_operation)
.WithInvariants(example_lambda_invariant) .WithInvariants(example_lambda_invariant)
@ -558,9 +587,9 @@ struct {
} invoker; } invoker;
auto tester = auto tester =
absl::MakeExceptionSafetyTester().WithOperation(invoker).WithInvariants( testing::MakeExceptionSafetyTester().WithOperation(invoker).WithInvariants(
CheckNonNegativeInvariants); CheckNonNegativeInvariants);
auto strong_tester = tester.WithInvariants(absl::strong_guarantee); auto strong_tester = tester.WithInvariants(testing::strong_guarantee);
struct FailsBasicGuarantee : public NonNegative { struct FailsBasicGuarantee : public NonNegative {
void operator()() { void operator()() {
@ -664,7 +693,7 @@ TEST(ExceptionCheckTest, ModifyingChecker) {
EXPECT_TRUE(strong_tester.WithInitialValue(FollowsStrongGuarantee{}) EXPECT_TRUE(strong_tester.WithInitialValue(FollowsStrongGuarantee{})
.WithInvariants(increment) .WithInvariants(increment)
.Test()); .Test());
EXPECT_TRUE(absl::MakeExceptionSafetyTester() EXPECT_TRUE(testing::MakeExceptionSafetyTester()
.WithInitialValue(HasReset{}) .WithInitialValue(HasReset{})
.WithInvariants(CheckHasResetInvariants) .WithInvariants(CheckHasResetInvariants)
.Test(invoker)); .Test(invoker));
@ -739,7 +768,7 @@ template <typename T>
unsigned char ExhaustivenessTester<T>::successes = 0; unsigned char ExhaustivenessTester<T>::successes = 0;
TEST(ExceptionCheckTest, Exhaustiveness) { TEST(ExceptionCheckTest, Exhaustiveness) {
auto exhaust_tester = absl::MakeExceptionSafetyTester() auto exhaust_tester = testing::MakeExceptionSafetyTester()
.WithInvariants(CheckExhaustivenessTesterInvariants) .WithInvariants(CheckExhaustivenessTesterInvariants)
.WithOperation(invoker); .WithOperation(invoker);
@ -749,7 +778,7 @@ TEST(ExceptionCheckTest, Exhaustiveness) {
EXPECT_TRUE( EXPECT_TRUE(
exhaust_tester.WithInitialValue(ExhaustivenessTester<ThrowingValue<>>{}) exhaust_tester.WithInitialValue(ExhaustivenessTester<ThrowingValue<>>{})
.WithInvariants(absl::strong_guarantee) .WithInvariants(testing::strong_guarantee)
.Test()); .Test());
EXPECT_EQ(ExhaustivenessTester<ThrowingValue<>>::successes, 0xF); EXPECT_EQ(ExhaustivenessTester<ThrowingValue<>>::successes, 0xF);
} }
@ -768,7 +797,7 @@ struct LeaksIfCtorThrows : private exceptions_internal::TrackedObject {
int LeaksIfCtorThrows::counter = 0; int LeaksIfCtorThrows::counter = 0;
TEST(ExceptionCheckTest, TestLeakyCtor) { TEST(ExceptionCheckTest, TestLeakyCtor) {
absl::TestThrowingCtor<LeaksIfCtorThrows>(); testing::TestThrowingCtor<LeaksIfCtorThrows>();
EXPECT_EQ(LeaksIfCtorThrows::counter, 1); EXPECT_EQ(LeaksIfCtorThrows::counter, 1);
LeaksIfCtorThrows::counter = 0; LeaksIfCtorThrows::counter = 0;
} }
@ -839,4 +868,5 @@ TEST(ThrowingAllocatorTraitsTest, Assignablility) {
} }
} // namespace } // namespace
} // namespace absl
} // namespace testing

6
absl/base/internal/exception_safety_testing.cc
View file

@ -17,7 +17,7 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "absl/meta/type_traits.h" #include "absl/meta/type_traits.h"
namespace absl { namespace testing {
exceptions_internal::NoThrowTag no_throw_ctor; exceptions_internal::NoThrowTag no_throw_ctor;
exceptions_internal::StrongGuaranteeTagType strong_guarantee; exceptions_internal::StrongGuaranteeTagType strong_guarantee;
@ -37,5 +37,7 @@ testing::AssertionResult FailureMessage(const TestException& e,
int countdown) noexcept { int countdown) noexcept {
return testing::AssertionFailure() << "Exception thrown from " << e.what(); return testing::AssertionFailure() << "Exception thrown from " << e.what();
} }
} // namespace exceptions_internal } // namespace exceptions_internal
} // namespace absl
} // namespace testing

204
absl/base/internal/exception_safety_testing.h
View file

@ -35,38 +35,36 @@
#include "absl/strings/substitute.h" #include "absl/strings/substitute.h"
#include "absl/types/optional.h" #include "absl/types/optional.h"
namespace absl { namespace testing {
// A configuration enum for Throwing*. Operations whose flags are set will enum class TypeSpec;
// throw, everything else won't. This isn't meant to be exhaustive, more flags enum class AllocSpec;
// can always be made in the future.
enum class NoThrow : uint8_t {
kNone = 0,
kMoveCtor = 1,
kMoveAssign = 1 << 1,
kAllocation = 1 << 2,
kIntCtor = 1 << 3,
kNoThrow = static_cast<uint8_t>(-1)
};
constexpr NoThrow operator|(NoThrow a, NoThrow b) { constexpr TypeSpec operator|(TypeSpec a, TypeSpec b) {
using T = absl::underlying_type_t<NoThrow>; using T = absl::underlying_type_t<TypeSpec>;
return static_cast<NoThrow>(static_cast<T>(a) | static_cast<T>(b)); return static_cast<TypeSpec>(static_cast<T>(a) | static_cast<T>(b));
} }
constexpr NoThrow operator&(NoThrow a, NoThrow b) { constexpr TypeSpec operator&(TypeSpec a, TypeSpec b) {
using T = absl::underlying_type_t<NoThrow>; using T = absl::underlying_type_t<TypeSpec>;
return static_cast<NoThrow>(static_cast<T>(a) & static_cast<T>(b)); return static_cast<TypeSpec>(static_cast<T>(a) & static_cast<T>(b));
}
constexpr AllocSpec operator|(AllocSpec a, AllocSpec b) {
using T = absl::underlying_type_t<AllocSpec>;
return static_cast<AllocSpec>(static_cast<T>(a) | static_cast<T>(b));
}
constexpr AllocSpec operator&(AllocSpec a, AllocSpec b) {
using T = absl::underlying_type_t<AllocSpec>;
return static_cast<AllocSpec>(static_cast<T>(a) & static_cast<T>(b));
} }
namespace exceptions_internal { namespace exceptions_internal {
struct NoThrowTag {}; struct NoThrowTag {};
struct StrongGuaranteeTagType {}; struct StrongGuaranteeTagType {};
constexpr bool ThrowingAllowed(NoThrow flags, NoThrow flag) {
return !static_cast<bool>(flags & flag);
}
// A simple exception class. We throw this so that test code can catch // A simple exception class. We throw this so that test code can catch
// exceptions specifically thrown by ThrowingValue. // exceptions specifically thrown by ThrowingValue.
class TestException { class TestException {
@ -246,47 +244,69 @@ class ThrowingBool {
bool b_; bool b_;
}; };
// A testing class instrumented to throw an exception at a controlled time. /*
// * Configuration enum for the ThrowingValue type that defines behavior for the
// ThrowingValue implements a slightly relaxed version of the Regular concept -- * lifetime of the instance. Use testing::no_throw_ctor to prevent the integer
// that is it's a value type with the expected semantics. It also implements * constructor from throwing.
// arithmetic operations. It doesn't implement member and pointer operators *
// like operator-> or operator[]. * kEverythingThrows: Every operation can throw an exception
// * kNoThrowCopy: Copy construction and copy assignment will not throw
// ThrowingValue can be instrumented to have certain operations be noexcept by * kNoThrowMove: Move construction and move assignment will not throw
// using compile-time bitfield flag template arguments. That is, to make an * kNoThrowNew: Overloaded operators new and new[] will not throw
// ThrowingValue which has a noexcept move constructor and noexcept move */
// assignment, use enum class TypeSpec {
// ThrowingValue<absl::NoThrow::kMoveCtor | absl::NoThrow::kMoveAssign>. kEverythingThrows = 0,
template <NoThrow Flags = NoThrow::kNone> kNoThrowCopy = 1,
kNoThrowMove = 1 << 1,
kNoThrowNew = 1 << 2,
};
/*
* A testing class instrumented to throw an exception at a controlled time.
*
* ThrowingValue implements a slightly relaxed version of the Regular concept --
* that is it's a value type with the expected semantics. It also implements
* arithmetic operations. It doesn't implement member and pointer operators
* like operator-> or operator[].
*
* ThrowingValue can be instrumented to have certain operations be noexcept by
* using compile-time bitfield template arguments. That is, to make an
* ThrowingValue which has noexcept move construction/assignment and noexcept
* copy construction/assignment, use the following:
* ThrowingValue<testing::kNoThrowMove | testing::kNoThrowCopy> my_thrwr{val};
*/
template <TypeSpec Spec = TypeSpec::kEverythingThrows>
class ThrowingValue : private exceptions_internal::TrackedObject { class ThrowingValue : private exceptions_internal::TrackedObject {
constexpr static bool IsSpecified(TypeSpec spec) {
return static_cast<bool>(Spec & spec);
}
public: public:
ThrowingValue() : TrackedObject(ABSL_PRETTY_FUNCTION) { ThrowingValue() : TrackedObject(ABSL_PRETTY_FUNCTION) {
exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
dummy_ = 0; dummy_ = 0;
} }
ThrowingValue(const ThrowingValue& other) ThrowingValue(const ThrowingValue& other) noexcept(
IsSpecified(TypeSpec::kNoThrowCopy))
: TrackedObject(ABSL_PRETTY_FUNCTION) { : TrackedObject(ABSL_PRETTY_FUNCTION) {
if (!IsSpecified(TypeSpec::kNoThrowCopy)) {
exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
}
dummy_ = other.dummy_; dummy_ = other.dummy_;
} }
ThrowingValue(ThrowingValue&& other) noexcept( ThrowingValue(ThrowingValue&& other) noexcept(
!exceptions_internal::ThrowingAllowed(Flags, NoThrow::kMoveCtor)) IsSpecified(TypeSpec::kNoThrowMove))
: TrackedObject(ABSL_PRETTY_FUNCTION) { : TrackedObject(ABSL_PRETTY_FUNCTION) {
if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kMoveCtor)) { if (!IsSpecified(TypeSpec::kNoThrowMove)) {
exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
} }
dummy_ = other.dummy_; dummy_ = other.dummy_;
} }
explicit ThrowingValue(int i) noexcept( explicit ThrowingValue(int i) : TrackedObject(ABSL_PRETTY_FUNCTION) {
!exceptions_internal::ThrowingAllowed(Flags, NoThrow::kIntCtor))
: TrackedObject(ABSL_PRETTY_FUNCTION) {
if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kIntCtor)) {
exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
}
dummy_ = i; dummy_ = i;
} }
@ -296,15 +316,18 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
// absl expects nothrow destructors // absl expects nothrow destructors
~ThrowingValue() noexcept = default; ~ThrowingValue() noexcept = default;
ThrowingValue& operator=(const ThrowingValue& other) { ThrowingValue& operator=(const ThrowingValue& other) noexcept(
IsSpecified(TypeSpec::kNoThrowCopy)) {
if (!IsSpecified(TypeSpec::kNoThrowCopy)) {
exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
}
dummy_ = other.dummy_; dummy_ = other.dummy_;
return *this; return *this;
} }
ThrowingValue& operator=(ThrowingValue&& other) noexcept( ThrowingValue& operator=(ThrowingValue&& other) noexcept(
!exceptions_internal::ThrowingAllowed(Flags, NoThrow::kMoveAssign)) { IsSpecified(TypeSpec::kNoThrowMove)) {
if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kMoveAssign)) { if (!IsSpecified(TypeSpec::kNoThrowMove)) {
exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
} }
dummy_ = other.dummy_; dummy_ = other.dummy_;
@ -533,8 +556,8 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
// Args.. allows us to overload regular and placement new in one shot // Args.. allows us to overload regular and placement new in one shot
template <typename... Args> template <typename... Args>
static void* operator new(size_t s, Args&&... args) noexcept( static void* operator new(size_t s, Args&&... args) noexcept(
!exceptions_internal::ThrowingAllowed(Flags, NoThrow::kAllocation)) { IsSpecified(TypeSpec::kNoThrowNew)) {
if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kAllocation)) { if (!IsSpecified(TypeSpec::kNoThrowNew)) {
exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true); exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
} }
return ::operator new(s, std::forward<Args>(args)...); return ::operator new(s, std::forward<Args>(args)...);
@ -542,8 +565,8 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
template <typename... Args> template <typename... Args>
static void* operator new[](size_t s, Args&&... args) noexcept( static void* operator new[](size_t s, Args&&... args) noexcept(
!exceptions_internal::ThrowingAllowed(Flags, NoThrow::kAllocation)) { IsSpecified(TypeSpec::kNoThrowNew)) {
if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kAllocation)) { if (!IsSpecified(TypeSpec::kNoThrowNew)) {
exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true); exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
} }
return ::operator new[](s, std::forward<Args>(args)...); return ::operator new[](s, std::forward<Args>(args)...);
@ -581,20 +604,35 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
}; };
// While not having to do with exceptions, explicitly delete comma operator, to // While not having to do with exceptions, explicitly delete comma operator, to
// make sure we don't use it on user-supplied types. // make sure we don't use it on user-supplied types.
template <NoThrow N, typename T> template <TypeSpec Spec, typename T>
void operator,(const ThrowingValue<N>& ef, T&& t) = delete; void operator,(const ThrowingValue<Spec>&, T&&) = delete;
template <NoThrow N, typename T> template <TypeSpec Spec, typename T>
void operator,(T&& t, const ThrowingValue<N>& ef) = delete; void operator,(T&&, const ThrowingValue<Spec>&) = delete;
// An allocator type which is instrumented to throw at a controlled time, or not /*
// to throw, using NoThrow. The supported settings are the default of every * Configuration enum for the ThrowingAllocator type that defines behavior for
// function which is allowed to throw in a conforming allocator possibly * the lifetime of the instance.
// throwing, or nothing throws, in line with the ABSL_ALLOCATOR_THROWS *
// configuration macro. * kEverythingThrows: Calls to the member functions may throw
template <typename T, NoThrow Flags = NoThrow::kNone> * kNoThrowAllocate: Calls to the member functions will not throw
*/
enum class AllocSpec {
kEverythingThrows = 0,
kNoThrowAllocate = 1,
};
/*
* An allocator type which is instrumented to throw at a controlled time, or not
* to throw, using AllocSpec. The supported settings are the default of every
* function which is allowed to throw in a conforming allocator possibly
* throwing, or nothing throws, in line with the ABSL_ALLOCATOR_THROWS
* configuration macro.
*/
template <typename T, AllocSpec Spec = AllocSpec::kEverythingThrows>
class ThrowingAllocator : private exceptions_internal::TrackedObject { class ThrowingAllocator : private exceptions_internal::TrackedObject {
static_assert(Flags == NoThrow::kNone || Flags == NoThrow::kNoThrow, constexpr static bool IsSpecified(AllocSpec spec) {
"Invalid flag"); return static_cast<bool>(Spec & spec);
}
public: public:
using pointer = T*; using pointer = T*;
@ -607,7 +645,8 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
using size_type = size_t; using size_type = size_t;
using difference_type = ptrdiff_t; using difference_type = ptrdiff_t;
using is_nothrow = std::integral_constant<bool, Flags == NoThrow::kNoThrow>; using is_nothrow =
std::integral_constant<bool, Spec == AllocSpec::kNoThrowAllocate>;
using propagate_on_container_copy_assignment = std::true_type; using propagate_on_container_copy_assignment = std::true_type;
using propagate_on_container_move_assignment = std::true_type; using propagate_on_container_move_assignment = std::true_type;
using propagate_on_container_swap = std::true_type; using propagate_on_container_swap = std::true_type;
@ -619,8 +658,7 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
} }
template <typename U> template <typename U>
ThrowingAllocator( // NOLINT ThrowingAllocator(const ThrowingAllocator<U, Spec>& other) noexcept // NOLINT
const ThrowingAllocator<U, Flags>& other) noexcept
: TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(other.State()) {} : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(other.State()) {}
// According to C++11 standard [17.6.3.5], Table 28, the move/copy ctors of // According to C++11 standard [17.6.3.5], Table 28, the move/copy ctors of
@ -629,8 +667,7 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
: TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(other.State()) {} : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(other.State()) {}
template <typename U> template <typename U>
ThrowingAllocator( // NOLINT ThrowingAllocator(ThrowingAllocator<U, Spec>&& other) noexcept // NOLINT
ThrowingAllocator<U, Flags>&& other) noexcept
: TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(std::move(other.State())) {} : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(std::move(other.State())) {}
ThrowingAllocator(ThrowingAllocator&& other) noexcept ThrowingAllocator(ThrowingAllocator&& other) noexcept
@ -645,29 +682,30 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
template <typename U> template <typename U>
ThrowingAllocator& operator=( ThrowingAllocator& operator=(
const ThrowingAllocator<U, Flags>& other) noexcept { const ThrowingAllocator<U, Spec>& other) noexcept {
dummy_ = other.State(); dummy_ = other.State();
return *this; return *this;
} }
template <typename U> template <typename U>
ThrowingAllocator& operator=(ThrowingAllocator<U, Flags>&& other) noexcept { ThrowingAllocator& operator=(ThrowingAllocator<U, Spec>&& other) noexcept {
dummy_ = std::move(other.State()); dummy_ = std::move(other.State());
return *this; return *this;
} }
template <typename U> template <typename U>
struct rebind { struct rebind {
using other = ThrowingAllocator<U, Flags>; using other = ThrowingAllocator<U, Spec>;
}; };
pointer allocate(size_type n) noexcept( pointer allocate(size_type n) noexcept(
!exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) { IsSpecified(AllocSpec::kNoThrowAllocate)) {
ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION); ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
return static_cast<pointer>(::operator new(n * sizeof(T))); return static_cast<pointer>(::operator new(n * sizeof(T)));
} }
pointer allocate(size_type n, const_void_pointer) noexcept( pointer allocate(size_type n, const_void_pointer) noexcept(
!exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) { IsSpecified(AllocSpec::kNoThrowAllocate)) {
return allocate(n); return allocate(n);
} }
@ -678,7 +716,7 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
template <typename U, typename... Args> template <typename U, typename... Args>
void construct(U* ptr, Args&&... args) noexcept( void construct(U* ptr, Args&&... args) noexcept(
!exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) { IsSpecified(AllocSpec::kNoThrowAllocate)) {
ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION); ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
::new (static_cast<void*>(ptr)) U(std::forward<Args>(args)...); ::new (static_cast<void*>(ptr)) U(std::forward<Args>(args)...);
} }
@ -694,23 +732,23 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
} }
ThrowingAllocator select_on_container_copy_construction() noexcept( ThrowingAllocator select_on_container_copy_construction() noexcept(
!exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) { IsSpecified(AllocSpec::kNoThrowAllocate)) {
auto& out = *this; auto& out = *this;
ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION); ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
return out; return out;
} }
template <typename U> template <typename U>
bool operator==(const ThrowingAllocator<U, Flags>& other) const noexcept { bool operator==(const ThrowingAllocator<U, Spec>& other) const noexcept {
return dummy_ == other.dummy_; return dummy_ == other.dummy_;
} }
template <typename U> template <typename U>
bool operator!=(const ThrowingAllocator<U, Flags>& other) const noexcept { bool operator!=(const ThrowingAllocator<U, Spec>& other) const noexcept {
return dummy_ != other.dummy_; return dummy_ != other.dummy_;
} }
template <typename U, NoThrow B> template <typename, AllocSpec>
friend class ThrowingAllocator; friend class ThrowingAllocator;
private: private:
@ -724,7 +762,7 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
} }
void ReadStateAndMaybeThrow(absl::string_view msg) const { void ReadStateAndMaybeThrow(absl::string_view msg) const {
if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) { if (!IsSpecified(AllocSpec::kNoThrowAllocate)) {
exceptions_internal::MaybeThrow( exceptions_internal::MaybeThrow(
absl::Substitute("Allocator id $0 threw from $1", *dummy_, msg)); absl::Substitute("Allocator id $0 threw from $1", *dummy_, msg));
} }
@ -734,8 +772,8 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
std::shared_ptr<const int> dummy_; std::shared_ptr<const int> dummy_;
}; };
template <typename T, NoThrow Throws> template <typename T, AllocSpec Spec>
int ThrowingAllocator<T, Throws>::next_id_ = 0; int ThrowingAllocator<T, Spec>::next_id_ = 0;
// Tests for resource leaks by attempting to construct a T using args repeatedly // Tests for resource leaks by attempting to construct a T using args repeatedly
// until successful, using the countdown method. Side effects can then be // until successful, using the countdown method. Side effects can then be
@ -873,7 +911,7 @@ class ExceptionSafetyTester {
* created in order to get an empty Invariants... list. * created in order to get an empty Invariants... list.
* *
* In addition to passing in custom invariant assertion callbacks, this method * In addition to passing in custom invariant assertion callbacks, this method
* accepts `absl::strong_guarantee` as an argument which checks T instances * accepts `testing::strong_guarantee` as an argument which checks T instances
* post-throw against freshly created T instances via operator== to verify * post-throw against freshly created T instances via operator== to verify
* that any state changes made during the execution of the operation were * that any state changes made during the execution of the operation were
* properly rolled back. * properly rolled back.
@ -934,7 +972,7 @@ class ExceptionSafetyTester {
template <typename, typename, typename...> template <typename, typename, typename...>
friend class ExceptionSafetyTester; friend class ExceptionSafetyTester;
friend ExceptionSafetyTester<> absl::MakeExceptionSafetyTester(); friend ExceptionSafetyTester<> testing::MakeExceptionSafetyTester();
ExceptionSafetyTester() {} ExceptionSafetyTester() {}
@ -992,6 +1030,6 @@ MakeExceptionSafetyTester() {
return {}; return {};
} }
} // namespace absl } // namespace testing
#endif // ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_ #endif // ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_

3
absl/debugging/internal/stacktrace_aarch64-inl.inc
View file

@ -14,6 +14,7 @@
#include <cstdint> #include <cstdint>
#include <iostream> #include <iostream>
#include "absl/base/attributes.h"
#include "absl/debugging/internal/address_is_readable.h" #include "absl/debugging/internal/address_is_readable.h"
#include "absl/debugging/internal/vdso_support.h" // a no-op on non-elf or non-glibc systems #include "absl/debugging/internal/vdso_support.h" // a no-op on non-elf or non-glibc systems
#include "absl/debugging/stacktrace.h" #include "absl/debugging/stacktrace.h"
@ -24,7 +25,7 @@ static const uintptr_t kUnknownFrameSize = 0;
// Returns the address of the VDSO __kernel_rt_sigreturn function, if present. // Returns the address of the VDSO __kernel_rt_sigreturn function, if present.
static const unsigned char* GetKernelRtSigreturnAddress() { static const unsigned char* GetKernelRtSigreturnAddress() {
constexpr uintptr_t kImpossibleAddress = 1; constexpr uintptr_t kImpossibleAddress = 1;
static std::atomic<uintptr_t> memoized{kImpossibleAddress}; ABSL_CONST_INIT static std::atomic<uintptr_t> memoized{kImpossibleAddress};
uintptr_t address = memoized.load(std::memory_order_relaxed); uintptr_t address = memoized.load(std::memory_order_relaxed);
if (address != kImpossibleAddress) { if (address != kImpossibleAddress) {
return reinterpret_cast<const unsigned char*>(address); return reinterpret_cast<const unsigned char*>(address);

3
absl/debugging/internal/vdso_support.h
View file

@ -41,6 +41,7 @@
#include <atomic> #include <atomic>
#include "absl/base/attributes.h"
#include "absl/debugging/internal/elf_mem_image.h" #include "absl/debugging/internal/elf_mem_image.h"
#ifdef ABSL_HAVE_ELF_MEM_IMAGE #ifdef ABSL_HAVE_ELF_MEM_IMAGE
@ -132,7 +133,7 @@ class VDSOSupport {
// This function pointer may point to InitAndGetCPU, // This function pointer may point to InitAndGetCPU,
// GetCPUViaSyscall, or __vdso_getcpu at different stages of initialization. // GetCPUViaSyscall, or __vdso_getcpu at different stages of initialization.
static std::atomic<GetCpuFn> getcpu_fn_; ABSL_CONST_INIT static std::atomic<GetCpuFn> getcpu_fn_;
friend int GetCPU(void); // Needs access to getcpu_fn_. friend int GetCPU(void); // Needs access to getcpu_fn_.

2
absl/time/BUILD.bazel
View file

@ -51,6 +51,7 @@ cc_library(
cc_library( cc_library(
name = "test_util", name = "test_util",
testonly = 1,
srcs = [ srcs = [
"internal/test_util.cc", "internal/test_util.cc",
"internal/zoneinfo.inc", "internal/zoneinfo.inc",
@ -64,6 +65,7 @@ cc_library(
":time", ":time",
"//absl/base", "//absl/base",
"//absl/time/internal/cctz:time_zone", "//absl/time/internal/cctz:time_zone",
"@com_google_googletest//:gtest",
], ],
) )

9
absl/time/format_test.cc
View file

@ -155,8 +155,7 @@ TEST(ParseTime, Basics) {
"2013-06-28 19:08:09 -0800", &t, &err)) "2013-06-28 19:08:09 -0800", &t, &err))
<< err; << err;
absl::Time::Breakdown bd = t.In(absl::FixedTimeZone(-8 * 60 * 60)); absl::Time::Breakdown bd = t.In(absl::FixedTimeZone(-8 * 60 * 60));
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 6, 28, 19, 8, 9, -8 * 60 * 60, false, ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 6, 28, 19, 8, 9, -8 * 60 * 60, false);
"UTC-8");
EXPECT_EQ(absl::ZeroDuration(), bd.subsecond); EXPECT_EQ(absl::ZeroDuration(), bd.subsecond);
} }
@ -179,8 +178,7 @@ TEST(ParseTime, WithTimeZone) {
absl::ParseTime("%Y-%m-%d %H:%M:%S", "2013-06-28 19:08:09", tz, &t, &e)) absl::ParseTime("%Y-%m-%d %H:%M:%S", "2013-06-28 19:08:09", tz, &t, &e))
<< e; << e;
absl::Time::Breakdown bd = t.In(tz); absl::Time::Breakdown bd = t.In(tz);
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 6, 28, 19, 8, 9, -7 * 60 * 60, true, ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 6, 28, 19, 8, 9, -7 * 60 * 60, true);
"PDT");
EXPECT_EQ(absl::ZeroDuration(), bd.subsecond); EXPECT_EQ(absl::ZeroDuration(), bd.subsecond);
// But the timezone is ignored when a UTC offset is present. // But the timezone is ignored when a UTC offset is present.
@ -188,8 +186,7 @@ TEST(ParseTime, WithTimeZone) {
"2013-06-28 19:08:09 +0800", tz, &t, &e)) "2013-06-28 19:08:09 +0800", tz, &t, &e))
<< e; << e;
bd = t.In(absl::FixedTimeZone(8 * 60 * 60)); bd = t.In(absl::FixedTimeZone(8 * 60 * 60));
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 6, 28, 19, 8, 9, 8 * 60 * 60, false, ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 6, 28, 19, 8, 9, 8 * 60 * 60, false);
"UTC+8");
EXPECT_EQ(absl::ZeroDuration(), bd.subsecond); EXPECT_EQ(absl::ZeroDuration(), bd.subsecond);
} }

7
absl/time/internal/test_util.cc
View file

@ -26,6 +26,13 @@ namespace cctz = absl::time_internal::cctz;
namespace absl { namespace absl {
namespace time_internal { namespace time_internal {
// TODO(bww): Reinstate when the FixedTimeZone() abbreviations are updated.
#if 1 || GTEST_USES_SIMPLE_RE
extern const char kZoneAbbrRE[] = ".*"; // just punt
#else
extern const char kZoneAbbrRE[] = "[A-Za-z]{3,4}|[-+][0-9]{2}([0-9]{2})?";
#endif
TimeZone LoadTimeZone(const std::string& name) { TimeZone LoadTimeZone(const std::string& name) {
TimeZone tz; TimeZone tz;
ABSL_RAW_CHECK(LoadTimeZone(name, &tz), name.c_str()); ABSL_RAW_CHECK(LoadTimeZone(name, &tz), name.c_str());

10
absl/time/internal/test_util.h
View file

@ -17,6 +17,8 @@
#include <string> #include <string>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "absl/time/time.h" #include "absl/time/time.h"
// This helper is a macro so that failed expectations show up with the // This helper is a macro so that failed expectations show up with the
@ -24,7 +26,7 @@
// //
// This is for internal testing of the Base Time library itself. This is not // This is for internal testing of the Base Time library itself. This is not
// part of a public API. // part of a public API.
#define ABSL_INTERNAL_EXPECT_TIME(bd, y, m, d, h, min, s, off, isdst, zone) \ #define ABSL_INTERNAL_EXPECT_TIME(bd, y, m, d, h, min, s, off, isdst) \
do { \ do { \
EXPECT_EQ(y, bd.year); \ EXPECT_EQ(y, bd.year); \
EXPECT_EQ(m, bd.month); \ EXPECT_EQ(m, bd.month); \
@ -34,12 +36,16 @@
EXPECT_EQ(s, bd.second); \ EXPECT_EQ(s, bd.second); \
EXPECT_EQ(off, bd.offset); \ EXPECT_EQ(off, bd.offset); \
EXPECT_EQ(isdst, bd.is_dst); \ EXPECT_EQ(isdst, bd.is_dst); \
EXPECT_STREQ(zone, bd.zone_abbr); \ EXPECT_THAT(bd.zone_abbr, \
testing::MatchesRegex(absl::time_internal::kZoneAbbrRE)); \
} while (0) } while (0)
namespace absl { namespace absl {
namespace time_internal { namespace time_internal {
// A regular expression that matches all zone abbreviations (%Z).
extern const char kZoneAbbrRE[];
// Loads the named timezone, but dies on any failure. // Loads the named timezone, but dies on any failure.
absl::TimeZone LoadTimeZone(const std::string& name); absl::TimeZone LoadTimeZone(const std::string& name);

4
absl/time/time.cc
View file

@ -71,7 +71,7 @@ inline absl::Time::Breakdown InfiniteFutureBreakdown() {
bd.yearday = 365; bd.yearday = 365;
bd.offset = 0; bd.offset = 0;
bd.is_dst = false; bd.is_dst = false;
bd.zone_abbr = "-0000"; bd.zone_abbr = "-00";
return bd; return bd;
} }
@ -88,7 +88,7 @@ inline Time::Breakdown InfinitePastBreakdown() {
bd.yearday = 1; bd.yearday = 1;
bd.offset = 0; bd.offset = 0;
bd.is_dst = false; bd.is_dst = false;
bd.zone_abbr = "-0000"; bd.zone_abbr = "-00";
return bd; return bd;
} }

68
absl/time/time_norm_test.cc
View file

@ -18,6 +18,7 @@
#include <cstdint> #include <cstdint>
#include <limits> #include <limits>
#include "gmock/gmock.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "absl/time/internal/test_util.h" #include "absl/time/internal/test_util.h"
#include "absl/time/time.h" #include "absl/time/time.h"
@ -32,31 +33,31 @@ TEST(TimeNormCase, SimpleOverflow) {
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
absl::Time::Breakdown bd = tc.pre.In(utc); absl::Time::Breakdown bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 16, 33, 0, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 16, 33, 0, 0, false);
tc = absl::ConvertDateTime(2013, 11, 15, 16, 59 + 1, 14, utc); tc = absl::ConvertDateTime(2013, 11, 15, 16, 59 + 1, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 17, 0, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 17, 0, 14, 0, false);
tc = absl::ConvertDateTime(2013, 11, 15, 23 + 1, 32, 14, utc); tc = absl::ConvertDateTime(2013, 11, 15, 23 + 1, 32, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 16, 0, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 16, 0, 32, 14, 0, false);
tc = absl::ConvertDateTime(2013, 11, 30 + 1, 16, 32, 14, utc); tc = absl::ConvertDateTime(2013, 11, 30 + 1, 16, 32, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 12, 1, 16, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 12, 1, 16, 32, 14, 0, false);
tc = absl::ConvertDateTime(2013, 12 + 1, 15, 16, 32, 14, utc); tc = absl::ConvertDateTime(2013, 12 + 1, 15, 16, 32, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2014, 1, 15, 16, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2014, 1, 15, 16, 32, 14, 0, false);
} }
TEST(TimeNormCase, SimpleUnderflow) { TEST(TimeNormCase, SimpleUnderflow) {
@ -66,31 +67,31 @@ TEST(TimeNormCase, SimpleUnderflow) {
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
absl::Time::Breakdown bd = tc.pre.In(utc); absl::Time::Breakdown bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 16, 31, 59, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 16, 31, 59, 0, false);
tc = ConvertDateTime(2013, 11, 15, 16, 0 - 1, 14, utc); tc = ConvertDateTime(2013, 11, 15, 16, 0 - 1, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 15, 59, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 15, 59, 14, 0, false);
tc = ConvertDateTime(2013, 11, 15, 0 - 1, 32, 14, utc); tc = ConvertDateTime(2013, 11, 15, 0 - 1, 32, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 14, 23, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 14, 23, 32, 14, 0, false);
tc = ConvertDateTime(2013, 11, 1 - 1, 16, 32, 14, utc); tc = ConvertDateTime(2013, 11, 1 - 1, 16, 32, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 10, 31, 16, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 10, 31, 16, 32, 14, 0, false);
tc = ConvertDateTime(2013, 1 - 1, 15, 16, 32, 14, utc); tc = ConvertDateTime(2013, 1 - 1, 15, 16, 32, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2012, 12, 15, 16, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2012, 12, 15, 16, 32, 14, 0, false);
} }
TEST(TimeNormCase, MultipleOverflow) { TEST(TimeNormCase, MultipleOverflow) {
@ -99,7 +100,7 @@ TEST(TimeNormCase, MultipleOverflow) {
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
absl::Time::Breakdown bd = tc.pre.In(utc); absl::Time::Breakdown bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2014, 1, 1, 0, 0, 0, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2014, 1, 1, 0, 0, 0, 0, false);
} }
TEST(TimeNormCase, MultipleUnderflow) { TEST(TimeNormCase, MultipleUnderflow) {
@ -108,7 +109,7 @@ TEST(TimeNormCase, MultipleUnderflow) {
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
absl::Time::Breakdown bd = tc.pre.In(utc); absl::Time::Breakdown bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 12, 31, 23, 59, 59, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 12, 31, 23, 59, 59, 0, false);
} }
TEST(TimeNormCase, OverflowLimits) { TEST(TimeNormCase, OverflowLimits) {
@ -122,7 +123,7 @@ TEST(TimeNormCase, OverflowLimits) {
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 185085715, 11, 27, 12, 21, 7, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 185085715, 11, 27, 12, 21, 7, 0, false);
const int kintmin = std::numeric_limits<int>::min(); const int kintmin = std::numeric_limits<int>::min();
tc = absl::ConvertDateTime(0, kintmin, kintmin, kintmin, kintmin, kintmin, tc = absl::ConvertDateTime(0, kintmin, kintmin, kintmin, kintmin, kintmin,
@ -130,8 +131,7 @@ TEST(TimeNormCase, OverflowLimits) {
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, -185085717, 10, 31, 10, 37, 52, 0, false, ABSL_INTERNAL_EXPECT_TIME(bd, -185085717, 10, 31, 10, 37, 52, 0, false);
"UTC");
const int64_t max_year = std::numeric_limits<int64_t>::max(); const int64_t max_year = std::numeric_limits<int64_t>::max();
tc = absl::ConvertDateTime(max_year, 12, 31, 23, 59, 59, utc); tc = absl::ConvertDateTime(max_year, 12, 31, 23, 59, 59, utc);
@ -154,31 +154,31 @@ TEST(TimeNormCase, ComplexOverflow) {
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
absl::Time::Breakdown bd = tc.pre.In(utc); absl::Time::Breakdown bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2017, 10, 14, 14, 5, 23, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2017, 10, 14, 14, 5, 23, 0, false);
tc = absl::ConvertDateTime(2013, 11, 15, 16, 32 + 1234567, 14, utc); tc = absl::ConvertDateTime(2013, 11, 15, 16, 32 + 1234567, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2016, 3, 22, 0, 39, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2016, 3, 22, 0, 39, 14, 0, false);
tc = absl::ConvertDateTime(2013, 11, 15, 16 + 123456, 32, 14, utc); tc = absl::ConvertDateTime(2013, 11, 15, 16 + 123456, 32, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2027, 12, 16, 16, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2027, 12, 16, 16, 32, 14, 0, false);
tc = absl::ConvertDateTime(2013, 11, 15 + 1234, 16, 32, 14, utc); tc = absl::ConvertDateTime(2013, 11, 15 + 1234, 16, 32, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2017, 4, 2, 16, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2017, 4, 2, 16, 32, 14, 0, false);
tc = absl::ConvertDateTime(2013, 11 + 123, 15, 16, 32, 14, utc); tc = absl::ConvertDateTime(2013, 11 + 123, 15, 16, 32, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2024, 2, 15, 16, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2024, 2, 15, 16, 32, 14, 0, false);
} }
TEST(TimeNormCase, ComplexUnderflow) { TEST(TimeNormCase, ComplexUnderflow) {
@ -189,37 +189,37 @@ TEST(TimeNormCase, ComplexUnderflow) {
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
absl::Time::Breakdown bd = tc.pre.In(utc); absl::Time::Breakdown bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 1999, 2, 28, 0, 0, 0, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 1999, 2, 28, 0, 0, 0, 0, false);
tc = absl::ConvertDateTime(2013, 11, 15, 16, 32, 14 - 123456789, utc); tc = absl::ConvertDateTime(2013, 11, 15, 16, 32, 14 - 123456789, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2009, 12, 17, 18, 59, 5, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2009, 12, 17, 18, 59, 5, 0, false);
tc = absl::ConvertDateTime(2013, 11, 15, 16, 32 - 1234567, 14, utc); tc = absl::ConvertDateTime(2013, 11, 15, 16, 32 - 1234567, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2011, 7, 12, 8, 25, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2011, 7, 12, 8, 25, 14, 0, false);
tc = absl::ConvertDateTime(2013, 11, 15, 16 - 123456, 32, 14, utc); tc = absl::ConvertDateTime(2013, 11, 15, 16 - 123456, 32, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 1999, 10, 16, 16, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 1999, 10, 16, 16, 32, 14, 0, false);
tc = absl::ConvertDateTime(2013, 11, 15 - 1234, 16, 32, 14, utc); tc = absl::ConvertDateTime(2013, 11, 15 - 1234, 16, 32, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2010, 6, 30, 16, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2010, 6, 30, 16, 32, 14, 0, false);
tc = absl::ConvertDateTime(2013, 11 - 123, 15, 16, 32, 14, utc); tc = absl::ConvertDateTime(2013, 11 - 123, 15, 16, 32, 14, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2003, 8, 15, 16, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2003, 8, 15, 16, 32, 14, 0, false);
} }
TEST(TimeNormCase, Mishmash) { TEST(TimeNormCase, Mishmash) {
@ -231,14 +231,14 @@ TEST(TimeNormCase, Mishmash) {
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
absl::Time::Breakdown bd = tc.pre.In(utc); absl::Time::Breakdown bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 1991, 5, 9, 3, 6, 5, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 1991, 5, 9, 3, 6, 5, 0, false);
tc = absl::ConvertDateTime(2013, 11 + 123, 15 - 1234, 16 + 123456, tc = absl::ConvertDateTime(2013, 11 + 123, 15 - 1234, 16 + 123456,
32 - 1234567, 14 + 123456789, utc); 32 - 1234567, 14 + 123456789, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2036, 5, 24, 5, 58, 23, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2036, 5, 24, 5, 58, 23, 0, false);
// Here is a normalization case we got wrong for a while. Because the // Here is a normalization case we got wrong for a while. Because the
// day is converted to "1" within a 400-year (146097-day) period, we // day is converted to "1" within a 400-year (146097-day) period, we
@ -247,7 +247,7 @@ TEST(TimeNormCase, Mishmash) {
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 1613, 11, 1, 16, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 1613, 11, 1, 16, 32, 14, 0, false);
// Even though the month overflow compensates for the day underflow, // Even though the month overflow compensates for the day underflow,
// this should still be marked as normalized. // this should still be marked as normalized.
@ -255,7 +255,7 @@ TEST(TimeNormCase, Mishmash) {
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 1, 16, 32, 14, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 1, 16, 32, 14, 0, false);
} }
TEST(TimeNormCase, LeapYears) { TEST(TimeNormCase, LeapYears) {
@ -266,25 +266,25 @@ TEST(TimeNormCase, LeapYears) {
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
absl::Time::Breakdown bd = tc.pre.In(utc); absl::Time::Breakdown bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 3, 1, 0, 0, 0, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 3, 1, 0, 0, 0, 0, false);
tc = absl::ConvertDateTime(2012, 2, 28 + 1, 0, 0, 0, utc); tc = absl::ConvertDateTime(2012, 2, 28 + 1, 0, 0, 0, utc);
EXPECT_FALSE(tc.normalized); EXPECT_FALSE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2012, 2, 29, 0, 0, 0, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2012, 2, 29, 0, 0, 0, 0, false);
tc = absl::ConvertDateTime(2000, 2, 28 + 1, 0, 0, 0, utc); tc = absl::ConvertDateTime(2000, 2, 28 + 1, 0, 0, 0, utc);
EXPECT_FALSE(tc.normalized); EXPECT_FALSE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 2000, 2, 29, 0, 0, 0, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 2000, 2, 29, 0, 0, 0, 0, false);
tc = absl::ConvertDateTime(1900, 2, 28 + 1, 0, 0, 0, utc); tc = absl::ConvertDateTime(1900, 2, 28 + 1, 0, 0, 0, utc);
EXPECT_TRUE(tc.normalized); EXPECT_TRUE(tc.normalized);
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
bd = tc.pre.In(utc); bd = tc.pre.In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, 1900, 3, 1, 0, 0, 0, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 1900, 3, 1, 0, 0, 0, 0, false);
} }
// Convert all the days from 1970-1-1 to 1970-1-146097 (aka 2369-12-31) // Convert all the days from 1970-1-1 to 1970-1-146097 (aka 2369-12-31)

20
absl/time/time_test.cc
View file

@ -85,7 +85,7 @@ TEST(Time, ValueSemantics) {
TEST(Time, UnixEpoch) { TEST(Time, UnixEpoch) {
absl::Time::Breakdown bd = absl::UnixEpoch().In(absl::UTCTimeZone()); absl::Time::Breakdown bd = absl::UnixEpoch().In(absl::UTCTimeZone());
ABSL_INTERNAL_EXPECT_TIME(bd, 1970, 1, 1, 0, 0, 0, 0, false, "UTC"); ABSL_INTERNAL_EXPECT_TIME(bd, 1970, 1, 1, 0, 0, 0, 0, false);
EXPECT_EQ(absl::ZeroDuration(), bd.subsecond); EXPECT_EQ(absl::ZeroDuration(), bd.subsecond);
EXPECT_EQ(4, bd.weekday); // Thursday EXPECT_EQ(4, bd.weekday); // Thursday
} }
@ -96,14 +96,14 @@ TEST(Time, Breakdown) {
// The Unix epoch as seen in NYC. // The Unix epoch as seen in NYC.
absl::Time::Breakdown bd = t.In(tz); absl::Time::Breakdown bd = t.In(tz);
ABSL_INTERNAL_EXPECT_TIME(bd, 1969, 12, 31, 19, 0, 0, -18000, false, "EST"); ABSL_INTERNAL_EXPECT_TIME(bd, 1969, 12, 31, 19, 0, 0, -18000, false);
EXPECT_EQ(absl::ZeroDuration(), bd.subsecond); EXPECT_EQ(absl::ZeroDuration(), bd.subsecond);
EXPECT_EQ(3, bd.weekday); // Wednesday EXPECT_EQ(3, bd.weekday); // Wednesday
// Just before the epoch. // Just before the epoch.
t -= absl::Nanoseconds(1); t -= absl::Nanoseconds(1);
bd = t.In(tz); bd = t.In(tz);
ABSL_INTERNAL_EXPECT_TIME(bd, 1969, 12, 31, 18, 59, 59, -18000, false, "EST"); ABSL_INTERNAL_EXPECT_TIME(bd, 1969, 12, 31, 18, 59, 59, -18000, false);
EXPECT_EQ(absl::Nanoseconds(999999999), bd.subsecond); EXPECT_EQ(absl::Nanoseconds(999999999), bd.subsecond);
EXPECT_EQ(3, bd.weekday); // Wednesday EXPECT_EQ(3, bd.weekday); // Wednesday
@ -112,7 +112,7 @@ TEST(Time, Breakdown) {
t += absl::Hours(18) + absl::Minutes(30) + absl::Seconds(15) + t += absl::Hours(18) + absl::Minutes(30) + absl::Seconds(15) +
absl::Nanoseconds(9); absl::Nanoseconds(9);
bd = t.In(tz); bd = t.In(tz);
ABSL_INTERNAL_EXPECT_TIME(bd, 1977, 6, 28, 14, 30, 15, -14400, true, "EDT"); ABSL_INTERNAL_EXPECT_TIME(bd, 1977, 6, 28, 14, 30, 15, -14400, true);
EXPECT_EQ(8, bd.subsecond / absl::Nanoseconds(1)); EXPECT_EQ(8, bd.subsecond / absl::Nanoseconds(1));
EXPECT_EQ(2, bd.weekday); // Tuesday EXPECT_EQ(2, bd.weekday); // Tuesday
} }
@ -983,16 +983,18 @@ TEST(Time, ConversionSaturation) {
// Checks how Time::In() saturates on infinities. // Checks how Time::In() saturates on infinities.
absl::Time::Breakdown bd = absl::InfiniteFuture().In(utc); absl::Time::Breakdown bd = absl::InfiniteFuture().In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, std::numeric_limits<int64_t>::max(), 12, 31, 23, ABSL_INTERNAL_EXPECT_TIME(bd, std::numeric_limits<int64_t>::max(), 12, 31, 23,
59, 59, 0, false, "-0000"); 59, 59, 0, false);
EXPECT_EQ(absl::InfiniteDuration(), bd.subsecond); EXPECT_EQ(absl::InfiniteDuration(), bd.subsecond);
EXPECT_EQ(4, bd.weekday); // Thursday EXPECT_EQ(4, bd.weekday); // Thursday
EXPECT_EQ(365, bd.yearday); EXPECT_EQ(365, bd.yearday);
EXPECT_STREQ("-00", bd.zone_abbr); // artifact of absl::Time::In()
bd = absl::InfinitePast().In(utc); bd = absl::InfinitePast().In(utc);
ABSL_INTERNAL_EXPECT_TIME(bd, std::numeric_limits<int64_t>::min(), 1, 1, 0, 0, ABSL_INTERNAL_EXPECT_TIME(bd, std::numeric_limits<int64_t>::min(), 1, 1, 0, 0,
0, 0, false, "-0000"); 0, 0, false);
EXPECT_EQ(-absl::InfiniteDuration(), bd.subsecond); EXPECT_EQ(-absl::InfiniteDuration(), bd.subsecond);
EXPECT_EQ(7, bd.weekday); // Sunday EXPECT_EQ(7, bd.weekday); // Sunday
EXPECT_EQ(1, bd.yearday); EXPECT_EQ(1, bd.yearday);
EXPECT_STREQ("-00", bd.zone_abbr); // artifact of absl::Time::In()
// Approach the maximal Time value from below. // Approach the maximal Time value from below.
t = absl::FromDateTime(292277026596, 12, 4, 15, 30, 6, utc); t = absl::FromDateTime(292277026596, 12, 4, 15, 30, 6, utc);
@ -1054,13 +1056,11 @@ TEST(Time, ExtendedConversionSaturation) {
// The maximal time converted in each zone. // The maximal time converted in each zone.
bd = max.In(syd); bd = max.In(syd);
ABSL_INTERNAL_EXPECT_TIME(bd, 292277026596, 12, 5, 2, 30, 7, 39600, true, ABSL_INTERNAL_EXPECT_TIME(bd, 292277026596, 12, 5, 2, 30, 7, 39600, true);
"AEDT");
t = absl::FromDateTime(292277026596, 12, 5, 2, 30, 7, syd); t = absl::FromDateTime(292277026596, 12, 5, 2, 30, 7, syd);
EXPECT_EQ(max, t); EXPECT_EQ(max, t);
bd = max.In(nyc); bd = max.In(nyc);
ABSL_INTERNAL_EXPECT_TIME(bd, 292277026596, 12, 4, 10, 30, 7, -18000, false, ABSL_INTERNAL_EXPECT_TIME(bd, 292277026596, 12, 4, 10, 30, 7, -18000, false);
"EST");
t = absl::FromDateTime(292277026596, 12, 4, 10, 30, 7, nyc); t = absl::FromDateTime(292277026596, 12, 4, 10, 30, 7, nyc);
EXPECT_EQ(max, t); EXPECT_EQ(max, t);

29
absl/types/any_exception_safety_test.cc
View file

@ -20,12 +20,12 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "absl/base/internal/exception_safety_testing.h" #include "absl/base/internal/exception_safety_testing.h"
using Thrower = absl::ThrowingValue<>; using Thrower = testing::ThrowingValue<>;
using NoThrowMoveThrower = using NoThrowMoveThrower =
absl::ThrowingValue<absl::NoThrow::kMoveCtor | absl::NoThrow::kMoveAssign>; testing::ThrowingValue<testing::TypeSpec::kNoThrowMove>;
using ThrowerList = std::initializer_list<Thrower>; using ThrowerList = std::initializer_list<Thrower>;
using ThrowerVec = std::vector<Thrower>; using ThrowerVec = std::vector<Thrower>;
using ThrowingAlloc = absl::ThrowingAllocator<Thrower>; using ThrowingAlloc = testing::ThrowingAllocator<Thrower>;
using ThrowingThrowerVec = std::vector<Thrower, ThrowingAlloc>; using ThrowingThrowerVec = std::vector<Thrower, ThrowingAlloc>;
namespace { namespace {
@ -81,30 +81,31 @@ testing::AssertionResult AnyIsEmpty(absl::any* a) {
TEST(AnyExceptionSafety, Ctors) { TEST(AnyExceptionSafety, Ctors) {
Thrower val(1); Thrower val(1);
absl::TestThrowingCtor<absl::any>(val); testing::TestThrowingCtor<absl::any>(val);
Thrower copy(val); Thrower copy(val);
absl::TestThrowingCtor<absl::any>(copy); testing::TestThrowingCtor<absl::any>(copy);
absl::TestThrowingCtor<absl::any>(absl::in_place_type_t<Thrower>(), 1); testing::TestThrowingCtor<absl::any>(absl::in_place_type_t<Thrower>(), 1);
absl::TestThrowingCtor<absl::any>(absl::in_place_type_t<ThrowerVec>(), testing::TestThrowingCtor<absl::any>(absl::in_place_type_t<ThrowerVec>(),
ThrowerList{val}); ThrowerList{val});
absl::TestThrowingCtor<absl::any, absl::in_place_type_t<ThrowingThrowerVec>, testing::TestThrowingCtor<absl::any,
absl::in_place_type_t<ThrowingThrowerVec>,
ThrowerList, ThrowingAlloc>( ThrowerList, ThrowingAlloc>(
absl::in_place_type_t<ThrowingThrowerVec>(), {val}, ThrowingAlloc()); absl::in_place_type_t<ThrowingThrowerVec>(), {val}, ThrowingAlloc());
} }
TEST(AnyExceptionSafety, Assignment) { TEST(AnyExceptionSafety, Assignment) {
auto original = auto original =
absl::any(absl::in_place_type_t<Thrower>(), 1, absl::no_throw_ctor); absl::any(absl::in_place_type_t<Thrower>(), 1, testing::no_throw_ctor);
auto any_is_strong = [original](absl::any* ap) { auto any_is_strong = [original](absl::any* ap) {
return testing::AssertionResult(ap->has_value() && return testing::AssertionResult(ap->has_value() &&
absl::any_cast<Thrower>(original) == absl::any_cast<Thrower>(original) ==
absl::any_cast<Thrower>(*ap)); absl::any_cast<Thrower>(*ap));
}; };
auto any_strong_tester = absl::MakeExceptionSafetyTester() auto any_strong_tester = testing::MakeExceptionSafetyTester()
.WithInitialValue(original) .WithInitialValue(original)
.WithInvariants(AnyInvariants, any_is_strong); .WithInvariants(AnyInvariants, any_is_strong);
@ -126,7 +127,7 @@ TEST(AnyExceptionSafety, Assignment) {
return testing::AssertionResult{!ap->has_value()}; return testing::AssertionResult{!ap->has_value()};
}; };
auto strong_empty_any_tester = auto strong_empty_any_tester =
absl::MakeExceptionSafetyTester() testing::MakeExceptionSafetyTester()
.WithInitialValue(absl::any{}) .WithInitialValue(absl::any{})
.WithInvariants(AnyInvariants, empty_any_is_strong); .WithInvariants(AnyInvariants, empty_any_is_strong);
@ -138,14 +139,14 @@ TEST(AnyExceptionSafety, Assignment) {
#if !defined(ABSL_HAVE_STD_ANY) #if !defined(ABSL_HAVE_STD_ANY)
TEST(AnyExceptionSafety, Emplace) { TEST(AnyExceptionSafety, Emplace) {
auto initial_val = auto initial_val =
absl::any{absl::in_place_type_t<Thrower>(), 1, absl::no_throw_ctor}; absl::any{absl::in_place_type_t<Thrower>(), 1, testing::no_throw_ctor};
auto one_tester = absl::MakeExceptionSafetyTester() auto one_tester = testing::MakeExceptionSafetyTester()
.WithInitialValue(initial_val) .WithInitialValue(initial_val)
.WithInvariants(AnyInvariants, AnyIsEmpty); .WithInvariants(AnyInvariants, AnyIsEmpty);
auto emp_thrower = [](absl::any* ap) { ap->emplace<Thrower>(2); }; auto emp_thrower = [](absl::any* ap) { ap->emplace<Thrower>(2); };
auto emp_throwervec = [](absl::any* ap) { auto emp_throwervec = [](absl::any* ap) {
std::initializer_list<Thrower> il{Thrower(2, absl::no_throw_ctor)}; std::initializer_list<Thrower> il{Thrower(2, testing::no_throw_ctor)};
ap->emplace<ThrowerVec>(il); ap->emplace<ThrowerVec>(il);
}; };
auto emp_movethrower = [](absl::any* ap) { auto emp_movethrower = [](absl::any* ap) {