maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Export of internal Abseil changes.

Browse source 
--
70b243f160a2f0f222066f62e06cc4346aea683d by Gennadiy Civil <misterg@google.com>:

Replace tests with new googletest Test Suite APIs

PiperOrigin-RevId: 228901526

--
28fe449f416c3d3fe882ef3dfa4289b94be5f8af by CJ Johnson <johnsoncj@google.com>:

Changes the style of enable_if on InlinedVector::insert(...) to match all others

PiperOrigin-RevId: 228878640

--
5b4732f783d16cfb19c8c42962201aafe12b3c0f by Abseil Team <absl-team@google.com>:

Update the absl::FromDateTime() deprecation message to refer to
absl::FromCivil(), the recommended replacement despite a slight
change in behavior for skipped civil times.

PiperOrigin-RevId: 228820837

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

Bump googletest to the latest

PiperOrigin-RevId: 228792994

--
aebc04f76b83a26432dba8e6199c971d5b69df0f by CJ Johnson <johnsoncj@google.com>:

Switches InlinedVector input/forward iterator tagged dispatch from callsite to template decorator

PiperOrigin-RevId: 228771063
GitOrigin-RevId: 70b243f160a2f0f222066f62e06cc4346aea683d
Change-Id: I5f8cd05685ff642eff81187b8e207a0bdbcf073a
This commit is contained in:
Abseil Team 2019-01-11 10:16:39 -08:00 • committed by Alex Strelnikov
parent 66f9becbb9
commit 5eea0f713c
23 changed files with 97 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

6
WORKSPACE
View file

@ -15,9 +15,9 @@ http_archive(
# GoogleTest/GoogleMock framework. Used by most unit-tests. # GoogleTest/GoogleMock framework. Used by most unit-tests.
http_archive( http_archive(
name = "com_google_googletest", name = "com_google_googletest",
urls = ["https://github.com/google/googletest/archive/b4d4438df9479675a632b2f11125e57133822ece.zip"], # 2018-07-16 urls = ["https://github.com/google/googletest/archive/b6cd405286ed8635ece71c72f118e659f4ade3fb.zip"], # 2019-01-07
strip_prefix = "googletest-b4d4438df9479675a632b2f11125e57133822ece", strip_prefix = "googletest-b6cd405286ed8635ece71c72f118e659f4ade3fb",
sha256 = "5aaa5d566517cae711e2a3505ea9a6438be1b37fcaae0ebcb96ccba9aa56f23a", sha256 = "ff7a82736e158c077e76188232eac77913a15dac0b22508c390ab3f88e6d6d86",
) )
# Google benchmark. # Google benchmark.

6
absl/container/flat_hash_map_test.cc
View file

@ -40,9 +40,9 @@ using MapTypes =
Map<EnumClass, int>, Map<int, NonStandardLayout>, Map<EnumClass, int>, Map<int, NonStandardLayout>,
Map<NonStandardLayout, int>>; Map<NonStandardLayout, int>>;
INSTANTIATE_TYPED_TEST_CASE_P(FlatHashMap, ConstructorTest, MapTypes); INSTANTIATE_TYPED_TEST_SUITE_P(FlatHashMap, ConstructorTest, MapTypes);
INSTANTIATE_TYPED_TEST_CASE_P(FlatHashMap, LookupTest, MapTypes); INSTANTIATE_TYPED_TEST_SUITE_P(FlatHashMap, LookupTest, MapTypes);
INSTANTIATE_TYPED_TEST_CASE_P(FlatHashMap, ModifiersTest, MapTypes); INSTANTIATE_TYPED_TEST_SUITE_P(FlatHashMap, ModifiersTest, MapTypes);
TEST(FlatHashMap, StandardLayout) { TEST(FlatHashMap, StandardLayout) {
struct Int { struct Int {

6
absl/container/flat_hash_set_test.cc
View file

@ -40,9 +40,9 @@ using Set =
using SetTypes = using SetTypes =
::testing::Types<Set<int>, Set<std::string>, Set<Enum>, Set<EnumClass>>; ::testing::Types<Set<int>, Set<std::string>, Set<Enum>, Set<EnumClass>>;
INSTANTIATE_TYPED_TEST_CASE_P(FlatHashSet, ConstructorTest, SetTypes); INSTANTIATE_TYPED_TEST_SUITE_P(FlatHashSet, ConstructorTest, SetTypes);
INSTANTIATE_TYPED_TEST_CASE_P(FlatHashSet, LookupTest, SetTypes); INSTANTIATE_TYPED_TEST_SUITE_P(FlatHashSet, LookupTest, SetTypes);
INSTANTIATE_TYPED_TEST_CASE_P(FlatHashSet, ModifiersTest, SetTypes); INSTANTIATE_TYPED_TEST_SUITE_P(FlatHashSet, ModifiersTest, SetTypes);
TEST(FlatHashSet, EmplaceString) { TEST(FlatHashSet, EmplaceString) {
std::vector<std::string> v = {"a", "b"}; std::vector<std::string> v = {"a", "b"};

73
absl/container/inlined_vector.h
View file

@ -71,18 +71,31 @@ class InlinedVector {
return static_cast<typename A::size_type>(N); return static_cast<typename A::size_type>(N);
} }
template <typename Iterator>
using IsAtLeastInputIterator = std::is_convertible<
typename std::iterator_traits<Iterator>::iterator_category,
std::input_iterator_tag>;
template <typename Iterator>
using IsAtLeastForwardIterator = std::is_convertible<
typename std::iterator_traits<Iterator>::iterator_category,
std::forward_iterator_tag>;
template <typename Iterator> template <typename Iterator>
using DisableIfIntegral = using DisableIfIntegral =
absl::enable_if_t<!std::is_integral<Iterator>::value>; absl::enable_if_t<!std::is_integral<Iterator>::value>;
template <typename Iterator> template <typename Iterator>
using EnableIfInputIterator = absl::enable_if_t<std::is_convertible< using EnableIfAtLeastInputIterator =
typename std::iterator_traits<Iterator>::iterator_category, absl::enable_if_t<IsAtLeastInputIterator<Iterator>::value>;
std::input_iterator_tag>::value>;
template <typename Iterator> template <typename Iterator>
using IteratorCategory = using EnableIfAtLeastForwardIterator =
typename std::iterator_traits<Iterator>::iterator_category; absl::enable_if_t<IsAtLeastForwardIterator<Iterator>::value>;
template <typename Iterator>
using DisableIfAtLeastForwardIterator =
absl::enable_if_t<!IsAtLeastForwardIterator<Iterator>::value>;
using rvalue_reference = typename A::value_type&&; using rvalue_reference = typename A::value_type&&;
@ -130,8 +143,7 @@ class InlinedVector {
InlinedVector(std::initializer_list<value_type> init_list, InlinedVector(std::initializer_list<value_type> init_list,
const allocator_type& alloc = allocator_type()) const allocator_type& alloc = allocator_type())
: allocator_and_tag_(alloc) { : allocator_and_tag_(alloc) {
AppendRange(init_list.begin(), init_list.end(), AppendRange(init_list.begin(), init_list.end());
IteratorCategory<decltype(init_list.begin())>{});
} }
// Creates an inlined vector with elements constructed from the provided // Creates an inlined vector with elements constructed from the provided
@ -144,7 +156,7 @@ class InlinedVector {
InlinedVector(InputIterator first, InputIterator last, InlinedVector(InputIterator first, InputIterator last,
const allocator_type& alloc = allocator_type()) const allocator_type& alloc = allocator_type())
: allocator_and_tag_(alloc) { : allocator_and_tag_(alloc) {
AppendRange(first, last, IteratorCategory<InputIterator>{}); AppendRange(first, last);
} }
// Creates a copy of `other` using `other`'s allocator. // Creates a copy of `other` using `other`'s allocator.
@ -422,8 +434,7 @@ class InlinedVector {
// Replaces the contents of the inlined vector with copies of the elements in // Replaces the contents of the inlined vector with copies of the elements in
// the provided `std::initializer_list`. // the provided `std::initializer_list`.
InlinedVector& operator=(std::initializer_list<value_type> init_list) { InlinedVector& operator=(std::initializer_list<value_type> init_list) {
AssignRange(init_list.begin(), init_list.end(), AssignRange(init_list.begin(), init_list.end());
IteratorCategory<decltype(init_list.begin())>{});
return *this; return *this;
} }
@ -500,15 +511,14 @@ class InlinedVector {
// inlined vector with copies of the values in the provided // inlined vector with copies of the values in the provided
// `std::initializer_list`. // `std::initializer_list`.
void assign(std::initializer_list<value_type> init_list) { void assign(std::initializer_list<value_type> init_list) {
AssignRange(init_list.begin(), init_list.end(), AssignRange(init_list.begin(), init_list.end());
IteratorCategory<decltype(init_list.begin())>{});
} }
// Overload of `InlinedVector::assign()` to replace the contents of the // Overload of `InlinedVector::assign()` to replace the contents of the
// inlined vector with values constructed from the range [`first`, `last`). // inlined vector with values constructed from the range [`first`, `last`).
template <typename InputIterator, DisableIfIntegral<InputIterator>* = nullptr> template <typename InputIterator, DisableIfIntegral<InputIterator>* = nullptr>
void assign(InputIterator first, InputIterator last) { void assign(InputIterator first, InputIterator last) {
AssignRange(first, last, IteratorCategory<InputIterator>{}); AssignRange(first, last);
} }
// `InlinedVector::resize()` // `InlinedVector::resize()`
@ -593,11 +603,10 @@ class InlinedVector {
// NOTE: The `enable_if` is intended to disambiguate the two three-argument // NOTE: The `enable_if` is intended to disambiguate the two three-argument
// overloads of `insert()`. // overloads of `insert()`.
template <typename InputIterator, template <typename InputIterator,
typename = EnableIfInputIterator<InputIterator>> EnableIfAtLeastInputIterator<InputIterator>* = nullptr>
iterator insert(const_iterator position, InputIterator first, iterator insert(const_iterator position, InputIterator first,
InputIterator last) { InputIterator last) {
return InsertWithRange(position, first, last, return InsertWithRange(position, first, last);
IteratorCategory<InputIterator>());
} }
// `InlinedVector::emplace()` // `InlinedVector::emplace()`
@ -1077,8 +1086,9 @@ class InlinedVector {
} }
} }
template <typename Iterator> template <typename ForwardIterator,
void AssignRange(Iterator first, Iterator last, std::forward_iterator_tag) { EnableIfAtLeastForwardIterator<ForwardIterator>* = nullptr>
void AssignRange(ForwardIterator first, ForwardIterator last) {
auto length = std::distance(first, last); auto length = std::distance(first, last);
// Prefer reassignment to copy construction for elements. // Prefer reassignment to copy construction for elements.
if (static_cast<size_type>(length) <= size()) { if (static_cast<size_type>(length) <= size()) {
@ -1097,8 +1107,9 @@ class InlinedVector {
} }
} }
template <typename Iterator> template <typename InputIterator,
void AssignRange(Iterator first, Iterator last, std::input_iterator_tag) { DisableIfAtLeastForwardIterator<InputIterator>* = nullptr>
void AssignRange(InputIterator first, InputIterator last) {
// Optimized to avoid reallocation. // Optimized to avoid reallocation.
// Prefer reassignment to copy construction for elements. // Prefer reassignment to copy construction for elements.
iterator out = begin(); iterator out = begin();
@ -1109,8 +1120,9 @@ class InlinedVector {
std::copy(first, last, std::back_inserter(*this)); std::copy(first, last, std::back_inserter(*this));
} }
template <typename Iterator> template <typename ForwardIterator,
void AppendRange(Iterator first, Iterator last, std::forward_iterator_tag) { EnableIfAtLeastForwardIterator<ForwardIterator>* = nullptr>
void AppendRange(ForwardIterator first, ForwardIterator last) {
auto length = std::distance(first, last); auto length = std::distance(first, last);
reserve(size() + length); reserve(size() + length);
if (allocated()) { if (allocated()) {
@ -1122,8 +1134,9 @@ class InlinedVector {
} }
} }
template <typename Iterator> template <typename InputIterator,
void AppendRange(Iterator first, Iterator last, std::input_iterator_tag) { DisableIfAtLeastForwardIterator<InputIterator>* = nullptr>
void AppendRange(InputIterator first, InputIterator last) {
std::copy(first, last, std::back_inserter(*this)); std::copy(first, last, std::back_inserter(*this));
} }
@ -1140,9 +1153,10 @@ class InlinedVector {
return it_pair.first; return it_pair.first;
} }
template <typename ForwardIterator> template <typename ForwardIterator,
EnableIfAtLeastForwardIterator<ForwardIterator>* = nullptr>
iterator InsertWithRange(const_iterator position, ForwardIterator first, iterator InsertWithRange(const_iterator position, ForwardIterator first,
ForwardIterator last, std::forward_iterator_tag) { ForwardIterator last) {
assert(position >= begin() && position <= end()); assert(position >= begin() && position <= end());
if (ABSL_PREDICT_FALSE(first == last)) if (ABSL_PREDICT_FALSE(first == last))
return const_cast<iterator>(position); return const_cast<iterator>(position);
@ -1150,15 +1164,16 @@ class InlinedVector {
auto n = std::distance(first, last); auto n = std::distance(first, last);
std::pair<iterator, iterator> it_pair = ShiftRight(position, n); std::pair<iterator, iterator> it_pair = ShiftRight(position, n);
size_type used_spots = it_pair.second - it_pair.first; size_type used_spots = it_pair.second - it_pair.first;
ForwardIterator open_spot = std::next(first, used_spots); auto open_spot = std::next(first, used_spots);
std::copy(first, open_spot, it_pair.first); std::copy(first, open_spot, it_pair.first);
UninitializedCopy(open_spot, last, it_pair.second); UninitializedCopy(open_spot, last, it_pair.second);
return it_pair.first; return it_pair.first;
} }
template <typename InputIterator> template <typename InputIterator,
DisableIfAtLeastForwardIterator<InputIterator>* = nullptr>
iterator InsertWithRange(const_iterator position, InputIterator first, iterator InsertWithRange(const_iterator position, InputIterator first,
InputIterator last, std::input_iterator_tag) { InputIterator last) {
assert(position >= begin() && position <= end()); assert(position >= begin() && position <= end());
size_type index = position - cbegin(); size_type index = position - cbegin();
size_type i = index; size_type i = index;

2
absl/container/inlined_vector_test.cc
View file

@ -70,7 +70,7 @@ MATCHER_P(ValueIs, e, "") {
// test_instance_tracker.h. // test_instance_tracker.h.
template <typename T> template <typename T>
class InstanceTest : public ::testing::Test {}; class InstanceTest : public ::testing::Test {};
TYPED_TEST_CASE_P(InstanceTest); TYPED_TEST_SUITE_P(InstanceTest);
// A simple reference counted class to make sure that the proper elements are // A simple reference counted class to make sure that the proper elements are
// destroyed in the erase(begin, end) test. // destroyed in the erase(begin, end) test.

10
absl/container/internal/hash_function_defaults_test.cc
View file

@ -77,14 +77,14 @@ struct EqString : ::testing::Test {
hash_default_eq<T> key_eq; hash_default_eq<T> key_eq;
}; };
TYPED_TEST_CASE(EqString, StringTypes); TYPED_TEST_SUITE(EqString, StringTypes);
template <class T> template <class T>
struct HashString : ::testing::Test { struct HashString : ::testing::Test {
hash_default_hash<T> hasher; hash_default_hash<T> hasher;
}; };
TYPED_TEST_CASE(HashString, StringTypes); TYPED_TEST_SUITE(HashString, StringTypes);
TYPED_TEST(EqString, Works) { TYPED_TEST(EqString, Works) {
auto eq = this->key_eq; auto eq = this->key_eq;
@ -121,14 +121,14 @@ struct EqPointer : ::testing::Test {
hash_default_eq<T> key_eq; hash_default_eq<T> key_eq;
}; };
TYPED_TEST_CASE(EqPointer, PointerTypes); TYPED_TEST_SUITE(EqPointer, PointerTypes);
template <class T> template <class T>
struct HashPointer : ::testing::Test { struct HashPointer : ::testing::Test {
hash_default_hash<T> hasher; hash_default_hash<T> hasher;
}; };
TYPED_TEST_CASE(HashPointer, PointerTypes); TYPED_TEST_SUITE(HashPointer, PointerTypes);
TYPED_TEST(EqPointer, Works) { TYPED_TEST(EqPointer, Works) {
int dummy; int dummy;
@ -248,7 +248,7 @@ TYPED_TEST_P(StringLikeTest, HashEq) {
EXPECT_NE(this->hash(this->a1), this->hash(this->b2)); EXPECT_NE(this->hash(this->a1), this->hash(this->b2));
} }
TYPED_TEST_CASE(StringLikeTest, StringTypesCartesianProduct); TYPED_TEST_SUITE(StringLikeTest, StringTypesCartesianProduct);
} // namespace } // namespace
} // namespace container_internal } // namespace container_internal

2
absl/container/internal/unordered_map_constructor_test.h
View file

@ -29,7 +29,7 @@ namespace container_internal {
template <class UnordMap> template <class UnordMap>
class ConstructorTest : public ::testing::Test {}; class ConstructorTest : public ::testing::Test {};
TYPED_TEST_CASE_P(ConstructorTest); TYPED_TEST_SUITE_P(ConstructorTest);
TYPED_TEST_P(ConstructorTest, NoArgs) { TYPED_TEST_P(ConstructorTest, NoArgs) {
TypeParam m; TypeParam m;

2
absl/container/internal/unordered_map_lookup_test.h
View file

@ -26,7 +26,7 @@ namespace container_internal {
template <class UnordMap> template <class UnordMap>
class LookupTest : public ::testing::Test {}; class LookupTest : public ::testing::Test {};
TYPED_TEST_CASE_P(LookupTest); TYPED_TEST_SUITE_P(LookupTest);
TYPED_TEST_P(LookupTest, At) { TYPED_TEST_P(LookupTest, At) {
using T = hash_internal::GeneratedType<TypeParam>; using T = hash_internal::GeneratedType<TypeParam>;

2
absl/container/internal/unordered_map_modifiers_test.h
View file

@ -26,7 +26,7 @@ namespace container_internal {
template <class UnordMap> template <class UnordMap>
class ModifiersTest : public ::testing::Test {}; class ModifiersTest : public ::testing::Test {};
TYPED_TEST_CASE_P(ModifiersTest); TYPED_TEST_SUITE_P(ModifiersTest);
TYPED_TEST_P(ModifiersTest, Clear) { TYPED_TEST_P(ModifiersTest, Clear) {
using T = hash_internal::GeneratedType<TypeParam>; using T = hash_internal::GeneratedType<TypeParam>;

6
absl/container/internal/unordered_map_test.cc
View file

@ -29,9 +29,9 @@ using MapTypes = ::testing::Types<
StatefulTestingEqual, StatefulTestingEqual,
Alloc<std::pair<const std::string, std::string>>>>; Alloc<std::pair<const std::string, std::string>>>>;
INSTANTIATE_TYPED_TEST_CASE_P(UnorderedMap, ConstructorTest, MapTypes); INSTANTIATE_TYPED_TEST_SUITE_P(UnorderedMap, ConstructorTest, MapTypes);
INSTANTIATE_TYPED_TEST_CASE_P(UnorderedMap, LookupTest, MapTypes); INSTANTIATE_TYPED_TEST_SUITE_P(UnorderedMap, LookupTest, MapTypes);
INSTANTIATE_TYPED_TEST_CASE_P(UnorderedMap, ModifiersTest, MapTypes); INSTANTIATE_TYPED_TEST_SUITE_P(UnorderedMap, ModifiersTest, MapTypes);
} // namespace } // namespace
} // namespace container_internal } // namespace container_internal

2
absl/container/internal/unordered_set_constructor_test.h
View file

@ -29,7 +29,7 @@ namespace container_internal {
template <class UnordMap> template <class UnordMap>
class ConstructorTest : public ::testing::Test {}; class ConstructorTest : public ::testing::Test {};
TYPED_TEST_CASE_P(ConstructorTest); TYPED_TEST_SUITE_P(ConstructorTest);
TYPED_TEST_P(ConstructorTest, NoArgs) { TYPED_TEST_P(ConstructorTest, NoArgs) {
TypeParam m; TypeParam m;

2
absl/container/internal/unordered_set_lookup_test.h
View file

@ -26,7 +26,7 @@ namespace container_internal {
template <class UnordSet> template <class UnordSet>
class LookupTest : public ::testing::Test {}; class LookupTest : public ::testing::Test {};
TYPED_TEST_CASE_P(LookupTest); TYPED_TEST_SUITE_P(LookupTest);
TYPED_TEST_P(LookupTest, Count) { TYPED_TEST_P(LookupTest, Count) {
using T = hash_internal::GeneratedType<TypeParam>; using T = hash_internal::GeneratedType<TypeParam>;

2
absl/container/internal/unordered_set_modifiers_test.h
View file

@ -26,7 +26,7 @@ namespace container_internal {
template <class UnordSet> template <class UnordSet>
class ModifiersTest : public ::testing::Test {}; class ModifiersTest : public ::testing::Test {};
TYPED_TEST_CASE_P(ModifiersTest); TYPED_TEST_SUITE_P(ModifiersTest);
TYPED_TEST_P(ModifiersTest, Clear) { TYPED_TEST_P(ModifiersTest, Clear) {
using T = hash_internal::GeneratedType<TypeParam>; using T = hash_internal::GeneratedType<TypeParam>;

6
absl/container/internal/unordered_set_test.cc
View file

@ -28,9 +28,9 @@ using SetTypes =
std::unordered_set<std::string, StatefulTestingHash, std::unordered_set<std::string, StatefulTestingHash,
StatefulTestingEqual, Alloc<std::string>>>; StatefulTestingEqual, Alloc<std::string>>>;
INSTANTIATE_TYPED_TEST_CASE_P(UnorderedSet, ConstructorTest, SetTypes); INSTANTIATE_TYPED_TEST_SUITE_P(UnorderedSet, ConstructorTest, SetTypes);
INSTANTIATE_TYPED_TEST_CASE_P(UnorderedSet, LookupTest, SetTypes); INSTANTIATE_TYPED_TEST_SUITE_P(UnorderedSet, LookupTest, SetTypes);
INSTANTIATE_TYPED_TEST_CASE_P(UnorderedSet, ModifiersTest, SetTypes); INSTANTIATE_TYPED_TEST_SUITE_P(UnorderedSet, ModifiersTest, SetTypes);
} // namespace } // namespace
} // namespace container_internal } // namespace container_internal

6
absl/container/node_hash_map_test.cc
View file

@ -34,9 +34,9 @@ using MapTypes = ::testing::Types<
StatefulTestingEqual, StatefulTestingEqual,
Alloc<std::pair<const std::string, std::string>>>>; Alloc<std::pair<const std::string, std::string>>>>;
INSTANTIATE_TYPED_TEST_CASE_P(NodeHashMap, ConstructorTest, MapTypes); INSTANTIATE_TYPED_TEST_SUITE_P(NodeHashMap, ConstructorTest, MapTypes);
INSTANTIATE_TYPED_TEST_CASE_P(NodeHashMap, LookupTest, MapTypes); INSTANTIATE_TYPED_TEST_SUITE_P(NodeHashMap, LookupTest, MapTypes);
INSTANTIATE_TYPED_TEST_CASE_P(NodeHashMap, ModifiersTest, MapTypes); INSTANTIATE_TYPED_TEST_SUITE_P(NodeHashMap, ModifiersTest, MapTypes);
using M = absl::node_hash_map<std::string, Tracked<int>>; using M = absl::node_hash_map<std::string, Tracked<int>>;

6
absl/container/node_hash_set_test.cc
View file

@ -34,9 +34,9 @@ using SetTypes = ::testing::Types<
node_hash_set<EnumClass, StatefulTestingHash, StatefulTestingEqual, node_hash_set<EnumClass, StatefulTestingHash, StatefulTestingEqual,
Alloc<EnumClass>>>; Alloc<EnumClass>>>;
INSTANTIATE_TYPED_TEST_CASE_P(NodeHashSet, ConstructorTest, SetTypes); INSTANTIATE_TYPED_TEST_SUITE_P(NodeHashSet, ConstructorTest, SetTypes);
INSTANTIATE_TYPED_TEST_CASE_P(NodeHashSet, LookupTest, SetTypes); INSTANTIATE_TYPED_TEST_SUITE_P(NodeHashSet, LookupTest, SetTypes);
INSTANTIATE_TYPED_TEST_CASE_P(NodeHashSet, ModifiersTest, SetTypes); INSTANTIATE_TYPED_TEST_SUITE_P(NodeHashSet, ModifiersTest, SetTypes);
TEST(NodeHashSet, MoveableNotCopyableCompiles) { TEST(NodeHashSet, MoveableNotCopyableCompiles) {
node_hash_set<std::unique_ptr<void*>> t; node_hash_set<std::unique_ptr<void*>> t;

2
absl/debugging/failure_signal_handler_test.cc
View file

@ -140,7 +140,7 @@ std::string SignalParamToString(const ::testing::TestParamInfo<int>& info) {
return result; return result;
} }
INSTANTIATE_TEST_CASE_P(AbslDeathTest, FailureSignalHandlerDeathTest, INSTANTIATE_TEST_SUITE_P(AbslDeathTest, FailureSignalHandlerDeathTest,
::testing::ValuesIn(kFailureSignals), ::testing::ValuesIn(kFailureSignals),
SignalParamToString); SignalParamToString);

4
absl/hash/hash_test.cc
View file

@ -50,7 +50,7 @@ using absl::hash_internal::SpyHashState;
template <typename T> template <typename T>
class HashValueIntTest : public testing::Test { class HashValueIntTest : public testing::Test {
}; };
TYPED_TEST_CASE_P(HashValueIntTest); TYPED_TEST_SUITE_P(HashValueIntTest);
template <typename T> template <typename T>
SpyHashState SpyHash(const T& value) { SpyHashState SpyHash(const T& value) {
@ -273,7 +273,7 @@ TEST(HashTest, NoOpsAreEquivalent) {
template <typename T> template <typename T>
class HashIntTest : public testing::Test { class HashIntTest : public testing::Test {
}; };
TYPED_TEST_CASE_P(HashIntTest); TYPED_TEST_SUITE_P(HashIntTest);
TYPED_TEST_P(HashIntTest, BasicUsage) { TYPED_TEST_P(HashIntTest, BasicUsage) {
EXPECT_NE(Hash<NoOp>()({}), Hash<TypeParam>()(0)); EXPECT_NE(Hash<NoOp>()({}), Hash<TypeParam>()(0));

4
absl/numeric/int128_test.cc
View file

@ -51,7 +51,7 @@ template <typename T>
class Uint128FloatTraitsTest : public ::testing::Test {}; class Uint128FloatTraitsTest : public ::testing::Test {};
typedef ::testing::Types<float, double, long double> FloatingPointTypes; typedef ::testing::Types<float, double, long double> FloatingPointTypes;
TYPED_TEST_CASE(Uint128IntegerTraitsTest, IntegerTypes); TYPED_TEST_SUITE(Uint128IntegerTraitsTest, IntegerTypes);
TYPED_TEST(Uint128IntegerTraitsTest, ConstructAssignTest) { TYPED_TEST(Uint128IntegerTraitsTest, ConstructAssignTest) {
static_assert(std::is_constructible<absl::uint128, TypeParam>::value, static_assert(std::is_constructible<absl::uint128, TypeParam>::value,
@ -62,7 +62,7 @@ TYPED_TEST(Uint128IntegerTraitsTest, ConstructAssignTest) {
"TypeParam must not be assignable from absl::uint128"); "TypeParam must not be assignable from absl::uint128");
} }
TYPED_TEST_CASE(Uint128FloatTraitsTest, FloatingPointTypes); TYPED_TEST_SUITE(Uint128FloatTraitsTest, FloatingPointTypes);
TYPED_TEST(Uint128FloatTraitsTest, ConstructAssignTest) { TYPED_TEST(Uint128FloatTraitsTest, ConstructAssignTest) {
static_assert(std::is_constructible<absl::uint128, TypeParam>::value, static_assert(std::is_constructible<absl::uint128, TypeParam>::value,

2
absl/strings/internal/str_format/convert_test.cc
View file

@ -232,7 +232,7 @@ TEST_F(FormatConvertTest, Enum) {
template <typename T> template <typename T>
class TypedFormatConvertTest : public FormatConvertTest { }; class TypedFormatConvertTest : public FormatConvertTest { };
TYPED_TEST_CASE_P(TypedFormatConvertTest); TYPED_TEST_SUITE_P(TypedFormatConvertTest);
std::vector<std::string> AllFlagCombinations() { std::vector<std::string> AllFlagCombinations() {
const char kFlags[] = {'-', '#', '0', '+', ' '}; const char kFlags[] = {'-', '#', '0', '+', ' '};

6
absl/synchronization/mutex_test.cc
View file

@ -610,7 +610,7 @@ TEST_P(CondVarWaitDeadlock, Test) {
waiter2.reset(); // "join" waiter2 waiter2.reset(); // "join" waiter2
} }
INSTANTIATE_TEST_CASE_P(CondVarWaitDeadlockTest, CondVarWaitDeadlock, INSTANTIATE_TEST_SUITE_P(CondVarWaitDeadlockTest, CondVarWaitDeadlock,
::testing::Range(0, 8), ::testing::Range(0, 8),
::testing::PrintToStringParamName()); ::testing::PrintToStringParamName());
@ -1367,7 +1367,7 @@ std::vector<TimeoutTestParam> MakeTimeoutTestParamValues() {
} }
// Instantiate `TimeoutTest` with `MakeTimeoutTestParamValues()`. // Instantiate `TimeoutTest` with `MakeTimeoutTestParamValues()`.
INSTANTIATE_TEST_CASE_P(All, TimeoutTest, INSTANTIATE_TEST_SUITE_P(All, TimeoutTest,
testing::ValuesIn(MakeTimeoutTestParamValues())); testing::ValuesIn(MakeTimeoutTestParamValues()));
TEST_P(TimeoutTest, Await) { TEST_P(TimeoutTest, Await) {
@ -1548,7 +1548,7 @@ static std::vector<int> AllThreadCountValues() {
class MutexVariableThreadCountTest : public ::testing::TestWithParam<int> {}; class MutexVariableThreadCountTest : public ::testing::TestWithParam<int> {};
// Instantiate the above with AllThreadCountOptions(). // Instantiate the above with AllThreadCountOptions().
INSTANTIATE_TEST_CASE_P(ThreadCounts, MutexVariableThreadCountTest, INSTANTIATE_TEST_SUITE_P(ThreadCounts, MutexVariableThreadCountTest,
::testing::ValuesIn(AllThreadCountValues()), ::testing::ValuesIn(AllThreadCountValues()),
::testing::PrintToStringParamName()); ::testing::PrintToStringParamName());

4
absl/time/time.h
View file

@ -1149,7 +1149,9 @@ TimeConversion ConvertDateTime(int64_t year, int mon, int day, int hour,
// absl::Time t = absl::FromDateTime(2017, 9, 26, 9, 30, 0, lax); // absl::Time t = absl::FromDateTime(2017, 9, 26, 9, 30, 0, lax);
// // t = 2017-09-26 09:30:00 -0700 // // t = 2017-09-26 09:30:00 -0700
// //
// Deprecated. Use `absl::TimeZone::At(CivilSecond).pre`. // Deprecated. Use `absl::FromCivil(CivilSecond, TimeZone)`. Note that the
// behavior of `FromCivil()` differs from `FromDateTime()` for skipped civil
// times. If you care about that see `absl::TimeZone::At(absl::CivilSecond)`.
inline Time FromDateTime(int64_t year, int mon, int day, int hour, inline Time FromDateTime(int64_t year, int mon, int day, int hour,
int min, int sec, TimeZone tz) { int min, int sec, TimeZone tz) {
return ConvertDateTime(year, mon, day, hour, min, sec, tz).pre; return ConvertDateTime(year, mon, day, hour, min, sec, tz).pre;

2
absl/types/variant_test.cc
View file

@ -257,7 +257,7 @@ class NonCopyable {
// each type. // each type.
template <typename T> template <typename T>
class VariantTypesTest : public ::testing::Test {}; class VariantTypesTest : public ::testing::Test {};
TYPED_TEST_CASE(VariantTypesTest, VariantTypes); TYPED_TEST_SUITE(VariantTypesTest, VariantTypes);
//////////////////// ////////////////////
// [variant.ctor] // // [variant.ctor] //