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

Export of internal Abseil changes.

Browse source 
--
eca34da4ccb7bb6a580f1364dff9ca053418fa3b by Abseil Team <absl-team@google.com>:

Internal change.

PiperOrigin-RevId: 214305433

--
35393bdd21a87c4286f945fd34dda93afc4e0cd6 by Abseil Team <absl-team@google.com>:

Move some implementation details of string_view around to facilitate compiling on NVCC.

Abseil does not officially support NVCC as a reminder.

PiperOrigin-RevId: 214184876

--
61846cab9ab9476a4676ecade7173f68978cd038 by Jorg Brown <jorg@google.com>:

Move the initialization values for constants back to their declaration.

PiperOrigin-RevId: 214135927

--
7ac7df6c5f78f2faf419268c04618b936cb26065 by Abseil Team <absl-team@google.com>:

Performance improvements on format parser.

PiperOrigin-RevId: 214032366

--
90b4c0cf20e9feaa257a7ece40adaf7db40a60a7 by Xiaoyi Zhang <zhangxy@google.com>:

Add static_assert check to absl::visit to make sure all overloads of the visitor return the same type, as required by the C++ standard.

PiperOrigin-RevId: 213677001

--
787995342101b4c181291cde9ecea3048536e4bd by Abseil Team <absl-team@google.com>:

Update comment to indicate finite durations are less than InfiniteDuration.

PiperOrigin-RevId: 213660328

--
d78f0dce7cc31218807e96d93b9e8513b6c80b24 by Jon Cohen <cohenjon@google.com>:

s/invariant/contract in the exceptions safety testing framework.  This is a better term as these can be type invariants or function post conditions.  They also are very similar ground as to what is covered by c++20 Contracts (and could even be replaced by them.

PiperOrigin-RevId: 213631019

--
0b3ff1a640de9a7391a6c233568802cf86245b0e by Abseil Team <absl-team@google.com>:

Add noinline attribute for GetStackTrace/GetStackFrames/... so the skipped frames will not change because of inlining difference.

PiperOrigin-RevId: 213009637
GitOrigin-RevId: eca34da4ccb7bb6a580f1364dff9ca053418fa3b
Change-Id: Iff1022fd24e440fcbdf3c4ab2a915ca8954daa31
This commit is contained in:
Abseil Team 2018-09-24 11:57:52 -07:00 • committed by Derek Mauro
parent 8ff1374008
commit e01d95528e
15 changed files with 251 additions and 223 deletions
Download patch file Download diff file Expand all files Collapse all files

6
absl/types/any_exception_safety_test.cc
View file

@ -107,7 +107,7 @@ TEST(AnyExceptionSafety, Assignment) {
};
auto any_strong_tester = testing::MakeExceptionSafetyTester()
.WithInitialValue(original)
.WithInvariants(AnyInvariants, any_is_strong);
.WithContracts(AnyInvariants, any_is_strong);
Thrower val(2);
absl::any any_val(val);
@ -129,7 +129,7 @@ TEST(AnyExceptionSafety, Assignment) {
auto strong_empty_any_tester =
testing::MakeExceptionSafetyTester()
.WithInitialValue(absl::any{})
.WithInvariants(AnyInvariants, empty_any_is_strong);
.WithContracts(AnyInvariants, empty_any_is_strong);
EXPECT_TRUE(strong_empty_any_tester.Test(assign_any));
EXPECT_TRUE(strong_empty_any_tester.Test(assign_val));
@ -142,7 +142,7 @@ TEST(AnyExceptionSafety, Emplace) {
absl::any{absl::in_place_type_t<Thrower>(), 1, testing::nothrow_ctor};
auto one_tester = testing::MakeExceptionSafetyTester()
.WithInitialValue(initial_val)
.WithInvariants(AnyInvariants, AnyIsEmpty);
.WithContracts(AnyInvariants, AnyIsEmpty);
auto emp_thrower = [](absl::any* ap) { ap->emplace<Thrower>(2); };
auto emp_throwervec = [](absl::any* ap) {

7
absl/types/internal/variant.h
View file

@ -1,4 +1,4 @@
// Copyright 2017 The Abseil Authors.
// Copyright 2018 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.
@ -910,6 +910,11 @@ struct PerformVisitation {
template <std::size_t... TupIs, std::size_t... Is>
constexpr ReturnType Run(std::false_type /*has_valueless*/,
index_sequence<TupIs...>, SizeT<Is>...) const {
static_assert(
std::is_same<ReturnType,
absl::result_of_t<Op(VariantAccessResult<
Is, QualifiedVariants>...)>>::value,
"All visitation overloads must have the same return type.");
return absl::base_internal::Invoke(
absl::forward<Op>(op),
VariantCoreAccess::Access<Is>(

24
absl/types/optional_exception_safety_test.cc
View file

@ -43,7 +43,7 @@ bool ValueThrowsBadOptionalAccess(const OptionalT& optional) try {
}
template <typename OptionalT>
AssertionResult CheckInvariants(OptionalT* optional_ptr) {
AssertionResult OptionalInvariants(OptionalT* optional_ptr) {
// Check the current state post-throw for validity
auto& optional = *optional_ptr;
@ -123,8 +123,8 @@ TEST(OptionalExceptionSafety, NothrowConstructors) {
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 = MakeExceptionSafetyTester().WithContracts(
OptionalInvariants<Optional>, CheckDisengaged<Optional>);
auto disengaged_test_empty = disengaged_test.WithInitialValue(Optional());
auto disengaged_test_nonempty =
disengaged_test.WithInitialValue(Optional(kInitialInteger));
@ -147,11 +147,11 @@ TEST(OptionalExceptionSafety, EverythingThrowsSwap) {
// Test the basic guarantee plus test the result of optional::has_value()
// remains the same
auto test =
MakeExceptionSafetyTester().WithInvariants(CheckInvariants<Optional>);
MakeExceptionSafetyTester().WithContracts(OptionalInvariants<Optional>);
auto disengaged_test_empty = test.WithInitialValue(Optional())
.WithInvariants(CheckDisengaged<Optional>);
.WithContracts(CheckDisengaged<Optional>);
auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
.WithInvariants(CheckEngaged<Optional>);
.WithContracts(CheckEngaged<Optional>);
auto swap_empty = [](Optional* optional_ptr) {
auto empty = Optional();
@ -192,11 +192,11 @@ TEST(OptionalExceptionSafety, CopyAssign) {
// Test the basic guarantee plus test the result of optional::has_value()
// remains the same
auto test =
MakeExceptionSafetyTester().WithInvariants(CheckInvariants<Optional>);
MakeExceptionSafetyTester().WithContracts(OptionalInvariants<Optional>);
auto disengaged_test_empty = test.WithInitialValue(Optional())
.WithInvariants(CheckDisengaged<Optional>);
.WithContracts(CheckDisengaged<Optional>);
auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
.WithInvariants(CheckEngaged<Optional>);
.WithContracts(CheckEngaged<Optional>);
auto copyassign_nonempty = [](Optional* optional_ptr) {
auto nonempty =
@ -218,11 +218,11 @@ TEST(OptionalExceptionSafety, MoveAssign) {
// Test the basic guarantee plus test the result of optional::has_value()
// remains the same
auto test =
MakeExceptionSafetyTester().WithInvariants(CheckInvariants<Optional>);
MakeExceptionSafetyTester().WithContracts(OptionalInvariants<Optional>);
auto disengaged_test_empty = test.WithInitialValue(Optional())
.WithInvariants(CheckDisengaged<Optional>);
.WithContracts(CheckDisengaged<Optional>);
auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
.WithInvariants(CheckEngaged<Optional>);
.WithContracts(CheckEngaged<Optional>);
auto moveassign_empty = [](Optional* optional_ptr) {
auto empty = Optional();

94
absl/types/variant_exception_safety_test.cc
View file

@ -59,7 +59,7 @@ void ToValuelessByException(ThrowingVariant& v) { // NOLINT
}
// Check that variant is still in a usable state after an exception is thrown.
testing::AssertionResult CheckInvariants(ThrowingVariant* v) {
testing::AssertionResult VariantInvariants(ThrowingVariant* v) {
using testing::AssertionFailure;
using testing::AssertionSuccess;
@ -213,8 +213,8 @@ TEST(VariantExceptionSafetyTest, CopyAssign) {
MakeExceptionSafetyTester()
.WithInitialValue(WithThrower())
.WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; });
EXPECT_TRUE(tester.WithInvariants(CheckInvariants).Test());
EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
EXPECT_TRUE(tester.WithContracts(VariantInvariants).Test());
EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
}
{
const ThrowingVariant rhs(ExpectedThrowerVec());
@ -222,8 +222,8 @@ TEST(VariantExceptionSafetyTest, CopyAssign) {
MakeExceptionSafetyTester()
.WithInitialValue(WithThrowerVec())
.WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; });
EXPECT_TRUE(tester.WithInvariants(CheckInvariants).Test());
EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
EXPECT_TRUE(tester.WithContracts(VariantInvariants).Test());
EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
}
// libstdc++ std::variant has bugs on copy assignment regarding exception
// safety.
@ -251,12 +251,12 @@ TEST(VariantExceptionSafetyTest, CopyAssign) {
.WithInitialValue(WithCopyNoThrow())
.WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; });
EXPECT_TRUE(tester
.WithInvariants(CheckInvariants,
[](ThrowingVariant* lhs) {
return lhs->valueless_by_exception();
})
.WithContracts(VariantInvariants,
[](ThrowingVariant* lhs) {
return lhs->valueless_by_exception();
})
.Test());
EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
}
#endif // !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))
{
@ -268,7 +268,7 @@ TEST(VariantExceptionSafetyTest, CopyAssign) {
const ThrowingVariant rhs(MoveNothrow{});
EXPECT_TRUE(MakeExceptionSafetyTester()
.WithInitialValue(WithThrower())
.WithInvariants(CheckInvariants, strong_guarantee)
.WithContracts(VariantInvariants, strong_guarantee)
.Test([&rhs](ThrowingVariant* lhs) { *lhs = rhs; }));
}
}
@ -304,11 +304,11 @@ TEST(VariantExceptionSafetyTest, MoveAssign) {
*lhs = std::move(copy);
});
EXPECT_TRUE(tester
.WithInvariants(
CheckInvariants,
.WithContracts(
VariantInvariants,
[&](ThrowingVariant* lhs) { return lhs->index() == j; })
.Test());
EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
}
{
// - otherwise (index() != j), equivalent to
@ -318,10 +318,10 @@ TEST(VariantExceptionSafetyTest, MoveAssign) {
ThrowingVariant rhs(CopyNothrow{});
EXPECT_TRUE(MakeExceptionSafetyTester()
.WithInitialValue(WithThrower())
.WithInvariants(CheckInvariants,
[](ThrowingVariant* lhs) {
return lhs->valueless_by_exception();
})
.WithContracts(VariantInvariants,
[](ThrowingVariant* lhs) {
return lhs->valueless_by_exception();
})
.Test([&](ThrowingVariant* lhs) {
auto copy = rhs;
*lhs = std::move(copy);
@ -347,12 +347,12 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
.WithInitialValue(WithThrower())
.WithOperation([rhs](ThrowingVariant* lhs) { *lhs = rhs; });
EXPECT_TRUE(copy_tester
.WithInvariants(CheckInvariants,
[](ThrowingVariant* lhs) {
return !lhs->valueless_by_exception();
})
.WithContracts(VariantInvariants,
[](ThrowingVariant* lhs) {
return !lhs->valueless_by_exception();
})
.Test());
EXPECT_FALSE(copy_tester.WithInvariants(strong_guarantee).Test());
EXPECT_FALSE(copy_tester.WithContracts(strong_guarantee).Test());
// move assign
auto move_tester = MakeExceptionSafetyTester()
.WithInitialValue(WithThrower())
@ -361,13 +361,13 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
*lhs = std::move(copy);
});
EXPECT_TRUE(move_tester
.WithInvariants(CheckInvariants,
[](ThrowingVariant* lhs) {
return !lhs->valueless_by_exception();
})
.WithContracts(VariantInvariants,
[](ThrowingVariant* lhs) {
return !lhs->valueless_by_exception();
})
.Test());
EXPECT_FALSE(move_tester.WithInvariants(strong_guarantee).Test());
EXPECT_FALSE(move_tester.WithContracts(strong_guarantee).Test());
}
// Otherwise (*this holds something else), if is_nothrow_constructible_v<Tj,
// T> || !is_nothrow_move_constructible_v<Tj> is true, equivalent to
@ -400,12 +400,12 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
.WithInitialValue(WithCopyNoThrow())
.WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; });
EXPECT_TRUE(copy_tester
.WithInvariants(CheckInvariants,
[](ThrowingVariant* lhs) {
return lhs->valueless_by_exception();
})
.WithContracts(VariantInvariants,
[](ThrowingVariant* lhs) {
return lhs->valueless_by_exception();
})
.Test());
EXPECT_FALSE(copy_tester.WithInvariants(strong_guarantee).Test());
EXPECT_FALSE(copy_tester.WithContracts(strong_guarantee).Test());
// move
auto move_tester = MakeExceptionSafetyTester()
.WithInitialValue(WithCopyNoThrow())
@ -413,12 +413,12 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
*lhs = ExpectedThrower(testing::nothrow_ctor);
});
EXPECT_TRUE(move_tester
.WithInvariants(CheckInvariants,
[](ThrowingVariant* lhs) {
return lhs->valueless_by_exception();
})
.WithContracts(VariantInvariants,
[](ThrowingVariant* lhs) {
return lhs->valueless_by_exception();
})
.Test());
EXPECT_FALSE(move_tester.WithInvariants(strong_guarantee).Test());
EXPECT_FALSE(move_tester.WithContracts(strong_guarantee).Test());
}
// Otherwise (if is_nothrow_constructible_v<Tj, T> == false &&
// is_nothrow_move_constructible<Tj> == true),
@ -432,7 +432,7 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
MoveNothrow rhs;
EXPECT_TRUE(MakeExceptionSafetyTester()
.WithInitialValue(WithThrower())
.WithInvariants(CheckInvariants, strong_guarantee)
.WithContracts(VariantInvariants, strong_guarantee)
.Test([&rhs](ThrowingVariant* lhs) { *lhs = rhs; }));
}
#endif // !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))
@ -450,12 +450,12 @@ TEST(VariantExceptionSafetyTest, Emplace) {
v->emplace<Thrower>(args);
});
EXPECT_TRUE(tester
.WithInvariants(CheckInvariants,
[](ThrowingVariant* v) {
return v->valueless_by_exception();
})
.WithContracts(VariantInvariants,
[](ThrowingVariant* v) {
return v->valueless_by_exception();
})
.Test());
EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
}
}
@ -472,7 +472,7 @@ TEST(VariantExceptionSafetyTest, Swap) {
ThrowingVariant rhs = ExpectedThrower();
EXPECT_TRUE(MakeExceptionSafetyTester()
.WithInitialValue(WithThrower())
.WithInvariants(CheckInvariants)
.WithContracts(VariantInvariants)
.Test([&](ThrowingVariant* lhs) {
auto copy = rhs;
lhs->swap(copy);
@ -486,7 +486,7 @@ TEST(VariantExceptionSafetyTest, Swap) {
ThrowingVariant rhs = ExpectedThrower();
EXPECT_TRUE(MakeExceptionSafetyTester()
.WithInitialValue(WithCopyNoThrow())
.WithInvariants(CheckInvariants)
.WithContracts(VariantInvariants)
.Test([&](ThrowingVariant* lhs) {
auto copy = rhs;
lhs->swap(copy);
@ -496,7 +496,7 @@ TEST(VariantExceptionSafetyTest, Swap) {
ThrowingVariant rhs = ExpectedThrower();
EXPECT_TRUE(MakeExceptionSafetyTester()
.WithInitialValue(WithCopyNoThrow())
.WithInvariants(CheckInvariants)
.WithContracts(VariantInvariants)
.Test([&](ThrowingVariant* lhs) {
auto copy = rhs;
copy.swap(*lhs);