Export of internal Abseil changes.

--
0925eb11f7730d5a1e538b9e6c2d1f8239f5fdc0 by Abseil Team <absl-team@google.com>:

Import of CCTZ from GitHub.

PiperOrigin-RevId: 250694613

--
4e1690e492a8399da1b1450ff5f21adf435fcef5 by Greg Falcon <gfalcon@google.com>:

Import of CCTZ from GitHub.

PiperOrigin-RevId: 250684222

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

Fix warnings on Xcode/clang.

PiperOrigin-RevId: 250552120

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

Minor edits to InlinedVector benchmarks: Adds DoNotOptimize to the member functions of NontrivialType, removes unused template parameter for InlVec typeder

PiperOrigin-RevId: 250505482

--
7fe9c02b49121936c5b47034f20272a916111174 by Matt Kulukundis <kfm@google.com>:

Internal change.

PiperOrigin-RevId: 250376825

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

Minor edits to InlinedVector benchmark

PiperOrigin-RevId: 250361830

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

Switches use of allocator_traits to the Abseil backport to leverage existing bug fixes and workarounds

PiperOrigin-RevId: 250359321

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

Updates exception safety test for InlinedVector to use TYPED_TEST (with fixtures) which increases the coverage without complicating the code.

PiperOrigin-RevId: 250359198

--
8ab55c9a8c191aabcb562cf1789f360eba0b1a81 by Abseil Team <absl-team@google.com>:

Internal change.

PiperOrigin-RevId: 250281509

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

Change the suggestions for the non-strict Next/PrevWeekday() calls.

Previously we suggested `PrevWeekday(d, Weekday::thursday) + 7`
to get the _following_ Thursday if d is not already a Thursday,
but `NextWeekday(d - 1, Weekday::thursday)` is more intuitive,
and probably even a little faster.

Similarly for the _previous_ Thursday if d is not already a
Thursday, suggest `PrevWeekday(d + 1, Weekday::thursday)`
instead of `NextWeekday(d, Weekday::thursday) - 7`.

PiperOrigin-RevId: 249840844

--
4775dce26cdb0560011a5d1ecdc8e0c20f856911 by Abseil Team <absl-team@google.com>:

Change the DbgHelp lib pragma to use lowercase and an extension.

This matches the conventions used in the Windows SDK.

PiperOrigin-RevId: 249826229

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

Introduce Abseil prefixed thread annotation macros.

PiperOrigin-RevId: 249825200

--
8e97c8dfbadb78743c2421b494398be25f632cb1 by Abseil Team <absl-team@google.com>:

Internal change.

PiperOrigin-RevId: 249737936

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

Tell CMake Abseil is a C++ project.

PiperOrigin-RevId: 249726509

--
20651845edf236757b3ffb3eaeff330af81be40a by Abseil Team <absl-team@google.com>:

Internal change.

PiperOrigin-RevId: 249726377
GitOrigin-RevId: 0925eb11f7730d5a1e538b9e6c2d1f8239f5fdc0
Change-Id: I05d18d30ad4e9ace6b60a17d2dc6fd699643fe30

CMake/install_test_project/CMakeLists.txt

@@ -16,7 +16,7 @@
 # A simple CMakeLists.txt for testing cmake installation
 # A simple CMakeLists.txt for testing cmake installation
 
 
 cmake_minimum_required(VERSION 3.5)
 cmake_minimum_required(VERSION 3.5)
-project(absl_cmake_testing)
+project(absl_cmake_testing CXX)
 
 
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD 11)
 
 

CMakeLists.txt

@@ -30,7 +30,7 @@ cmake_policy(SET CMP0057 NEW)
 # Project version variables are the empty std::string if version is unspecified
 # Project version variables are the empty std::string if version is unspecified
 cmake_policy(SET CMP0048 NEW)
 cmake_policy(SET CMP0048 NEW)
 
 
-project(absl)
+project(absl CXX)
 
 
 # when absl is included as subproject (i.e. using add_subdirectory(abseil-cpp))
 # when absl is included as subproject (i.e. using add_subdirectory(abseil-cpp))
 # in the source tree of a project that uses it, install rules are disabled.
 # in the source tree of a project that uses it, install rules are disabled.

absl/base/BUILD.bazel

@@ -69,6 +69,9 @@ cc_library(
 
 
 cc_library(
 cc_library(
     name = "core_headers",
     name = "core_headers",
+    srcs = [
+        "internal/thread_annotations.h",
+    ],
     hdrs = [
     hdrs = [
         "attributes.h",
         "attributes.h",
         "const_init.h",
         "const_init.h",
@@ -385,7 +388,6 @@ cc_test(
     srcs = ["internal/endian_test.cc"],
     srcs = ["internal/endian_test.cc"],
     copts = ABSL_TEST_COPTS,
     copts = ABSL_TEST_COPTS,
     deps = [
     deps = [
-        ":base",
         ":config",
         ":config",
         ":endian",
         ":endian",
         "@com_google_googletest//:gtest_main",
         "@com_google_googletest//:gtest_main",

absl/base/CMakeLists.txt

@@ -67,6 +67,7 @@ absl_cc_library(
     "optimization.h"
     "optimization.h"
     "port.h"
     "port.h"
     "thread_annotations.h"
     "thread_annotations.h"
+    "internal/thread_annotations.h"
   COPTS
   COPTS
     ${ABSL_DEFAULT_COPTS}
     ${ABSL_DEFAULT_COPTS}
   DEPS
   DEPS

absl/container/BUILD.bazel

@@ -124,6 +124,7 @@ cc_library(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
     deps = [
         ":compressed_tuple",
         ":compressed_tuple",
+        "//absl/memory",
         "//absl/meta:type_traits",
         "//absl/meta:type_traits",
     ],
     ],
 )
 )

absl/container/CMakeLists.txt

@@ -124,6 +124,7 @@ absl_cc_library(
     ${ABSL_DEFAULT_COPTS}
     ${ABSL_DEFAULT_COPTS}
   DEPS
   DEPS
     absl::compressed_tuple
     absl::compressed_tuple
+    absl::memory
     absl::type_traits
     absl::type_traits
   PUBLIC
   PUBLIC
 )
 )

absl/container/inlined_vector.h

@@ -890,7 +890,7 @@ class InlinedVector {
 
 
   template <typename... Args>
   template <typename... Args>
   reference Construct(pointer p, Args&&... args) {
   reference Construct(pointer p, Args&&... args) {
-    std::allocator_traits<allocator_type>::construct(
+    absl::allocator_traits<allocator_type>::construct(
         *storage_.GetAllocPtr(), p, std::forward<Args>(args)...);
         *storage_.GetAllocPtr(), p, std::forward<Args>(args)...);
     return *p;
     return *p;
   }
   }
@@ -908,8 +908,8 @@ class InlinedVector {
   // Destroy [`from`, `to`) in place.
   // Destroy [`from`, `to`) in place.
   void Destroy(pointer from, pointer to) {
   void Destroy(pointer from, pointer to) {
     for (pointer cur = from; cur != to; ++cur) {
     for (pointer cur = from; cur != to; ++cur) {
-      std::allocator_traits<allocator_type>::destroy(*storage_.GetAllocPtr(),
-                                                     cur);
+      absl::allocator_traits<allocator_type>::destroy(*storage_.GetAllocPtr(),
+                                                      cur);
     }
     }
 #if !defined(NDEBUG)
 #if !defined(NDEBUG)
     // Overwrite unused memory with `0xab` so we can catch uninitialized usage.
     // Overwrite unused memory with `0xab` so we can catch uninitialized usage.

absl/container/inlined_vector_benchmark.cc

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // See the License for the specific language governing permissions and
 // limitations under the License.
 // limitations under the License.
 
 
+#include <array>
 #include <string>
 #include <string>
 #include <vector>
 #include <vector>
 
 
@@ -373,71 +374,75 @@ void BM_StdVectorEmpty(benchmark::State& state) {
 }
 }
 BENCHMARK(BM_StdVectorEmpty);
 BENCHMARK(BM_StdVectorEmpty);
 
 
-constexpr size_t kInlineElements = 4;
-constexpr size_t kSmallSize = kInlineElements / 2;
-constexpr size_t kLargeSize = kInlineElements * 2;
+constexpr size_t kInlinedCapacity = 4;
+constexpr size_t kLargeSize = kInlinedCapacity * 2;
+constexpr size_t kSmallSize = kInlinedCapacity / 2;
 constexpr size_t kBatchSize = 100;
 constexpr size_t kBatchSize = 100;
 
 
+template <typename T>
+using InlVec = absl::InlinedVector<T, kInlinedCapacity>;
+
 struct TrivialType {
 struct TrivialType {
   size_t val;
   size_t val;
 };
 };
 
 
-using TrivialVec = absl::InlinedVector<TrivialType, kInlineElements>;
-
 class NontrivialType {
 class NontrivialType {
  public:
  public:
-  ABSL_ATTRIBUTE_NOINLINE NontrivialType() : val_() {}
+  ABSL_ATTRIBUTE_NOINLINE NontrivialType() : val_() {
+    benchmark::DoNotOptimize(*this);
+  }
 
 
   ABSL_ATTRIBUTE_NOINLINE NontrivialType(const NontrivialType& other)
   ABSL_ATTRIBUTE_NOINLINE NontrivialType(const NontrivialType& other)
-      : val_(other.val_) {}
+      : val_(other.val_) {
+    benchmark::DoNotOptimize(*this);
+  }
 
 
   ABSL_ATTRIBUTE_NOINLINE NontrivialType& operator=(
   ABSL_ATTRIBUTE_NOINLINE NontrivialType& operator=(
       const NontrivialType& other) {
       const NontrivialType& other) {
     val_ = other.val_;
     val_ = other.val_;
+    benchmark::DoNotOptimize(*this);
     return *this;
     return *this;
   }
   }
 
 
-  ABSL_ATTRIBUTE_NOINLINE ~NontrivialType() noexcept {}
+  ABSL_ATTRIBUTE_NOINLINE ~NontrivialType() noexcept {
+    benchmark::DoNotOptimize(*this);
+  }
 
 
  private:
  private:
   size_t val_;
   size_t val_;
 };
 };
 
 
-using NontrivialVec = absl::InlinedVector<NontrivialType, kInlineElements>;
-
-template <typename VecT, typename PrepareVec, typename TestVec>
-void BatchedBenchmark(benchmark::State& state, PrepareVec prepare_vec,
-                      TestVec test_vec) {
-  VecT vectors[kBatchSize];
+template <typename T, typename PrepareVecFn, typename TestVecFn>
+void BatchedBenchmark(benchmark::State& state, PrepareVecFn prepare_vec,
+                      TestVecFn test_vec) {
+  std::array<InlVec<T>, kBatchSize> vector_batch{};
 
 
   while (state.KeepRunningBatch(kBatchSize)) {
   while (state.KeepRunningBatch(kBatchSize)) {
     // Prepare batch
     // Prepare batch
     state.PauseTiming();
     state.PauseTiming();
-    for (auto& vec : vectors) {
+    for (auto& vec : vector_batch) {
       prepare_vec(&vec);
       prepare_vec(&vec);
     }
     }
-    benchmark::DoNotOptimize(vectors);
+    benchmark::DoNotOptimize(vector_batch);
     state.ResumeTiming();
     state.ResumeTiming();
 
 
     // Test batch
     // Test batch
-    for (auto& vec : vectors) {
+    for (auto& vec : vector_batch) {
       test_vec(&vec);
       test_vec(&vec);
     }
     }
   }
   }
 }
 }
 
 
-template <typename VecT, size_t FromSize>
+template <typename T, size_t FromSize>
 void BM_Clear(benchmark::State& state) {
 void BM_Clear(benchmark::State& state) {
-  BatchedBenchmark<VecT>(
+  BatchedBenchmark<T>(
       state,
       state,
-      /* prepare_vec = */ [](VecT* vec) { vec->resize(FromSize); },
-      /* test_vec = */ [](VecT* vec) { vec->clear(); });
+      /* prepare_vec = */ [](InlVec<T>* vec) { vec->resize(FromSize); },
+      /* test_vec = */ [](InlVec<T>* vec) { vec->clear(); });
 }
 }
-
-BENCHMARK_TEMPLATE(BM_Clear, TrivialVec, kSmallSize);
-BENCHMARK_TEMPLATE(BM_Clear, TrivialVec, kLargeSize);
-
-BENCHMARK_TEMPLATE(BM_Clear, NontrivialVec, kSmallSize);
-BENCHMARK_TEMPLATE(BM_Clear, NontrivialVec, kLargeSize);
+BENCHMARK_TEMPLATE(BM_Clear, TrivialType, kLargeSize);
+BENCHMARK_TEMPLATE(BM_Clear, TrivialType, kSmallSize);
+BENCHMARK_TEMPLATE(BM_Clear, NontrivialType, kLargeSize);
+BENCHMARK_TEMPLATE(BM_Clear, NontrivialType, kSmallSize);
 
 
 }  // namespace
 }  // namespace

absl/container/inlined_vector_exception_safety_test.cc

@@ -20,36 +20,85 @@
 
 
 namespace {
 namespace {
 
 
-constexpr size_t kInlined = 4;
-constexpr size_t kSmallSize = kInlined / 2;
-constexpr size_t kLargeSize = kInlined * 2;
+constexpr size_t kInlinedCapacity = 4;
+constexpr size_t kLargeSize = kInlinedCapacity * 2;
+constexpr size_t kSmallSize = kInlinedCapacity / 2;
 
 
 using Thrower = testing::ThrowingValue<>;
 using Thrower = testing::ThrowingValue<>;
-using ThrowerAlloc = testing::ThrowingAllocator<Thrower>;
+using MovableThrower = testing::ThrowingValue<testing::TypeSpec::kNoThrowMove>;
+using ThrowAlloc = testing::ThrowingAllocator<Thrower>;
 
 
-template <typename Allocator = std::allocator<Thrower>>
-using InlVec = absl::InlinedVector<Thrower, kInlined, Allocator>;
+using ThrowerVec = absl::InlinedVector<Thrower, kInlinedCapacity>;
+using MovableThrowerVec = absl::InlinedVector<MovableThrower, kInlinedCapacity>;
 
 
-TEST(InlinedVector, DefaultConstructor) {
-  testing::TestThrowingCtor<InlVec<>>();
+using ThrowAllocThrowerVec =
+    absl::InlinedVector<Thrower, kInlinedCapacity, ThrowAlloc>;
+using ThrowAllocMovableThrowerVec =
+    absl::InlinedVector<MovableThrower, kInlinedCapacity, ThrowAlloc>;
 
 
-  testing::TestThrowingCtor<InlVec<ThrowerAlloc>>();
+template <typename TheVecT, size_t... TheSizes>
+class TestParams {
+ public:
+  using VecT = TheVecT;
+  constexpr static size_t GetSizeAt(size_t i) { return kSizes[1 + i]; }
+
+ private:
+  constexpr static size_t kSizes[1 + sizeof...(TheSizes)] = {1, TheSizes...};
+};
+
+using NoSizeTestParams =
+    ::testing::Types<TestParams<ThrowerVec>, TestParams<MovableThrowerVec>,
+                     TestParams<ThrowAllocThrowerVec>,
+                     TestParams<ThrowAllocMovableThrowerVec>>;
+
+using OneSizeTestParams =
+    ::testing::Types<TestParams<ThrowerVec, kLargeSize>,
+                     TestParams<ThrowerVec, kSmallSize>,
+                     TestParams<MovableThrowerVec, kLargeSize>,
+                     TestParams<MovableThrowerVec, kSmallSize>,
+                     TestParams<ThrowAllocThrowerVec, kLargeSize>,
+                     TestParams<ThrowAllocThrowerVec, kSmallSize>,
+                     TestParams<ThrowAllocMovableThrowerVec, kLargeSize>,
+                     TestParams<ThrowAllocMovableThrowerVec, kSmallSize>>;
+
+template <typename>
+struct NoSizeTest : ::testing::Test {};
+TYPED_TEST_SUITE(NoSizeTest, NoSizeTestParams);
+
+template <typename>
+struct OneSizeTest : ::testing::Test {};
+TYPED_TEST_SUITE(OneSizeTest, OneSizeTestParams);
+
+// Function that always returns false is correct, but refactoring is required
+// for clarity. It's needed to express that, as a contract, certain operations
+// should not throw at all. Execution of this function means an exception was
+// thrown and thus the test should fail.
+// TODO(johnsoncj): Add `testing::NoThrowGuarantee` to the framework
+template <typename VecT>
+bool NoThrowGuarantee(VecT* /* vec */) {
+  return false;
 }
 }
 
 
-TEST(InlinedVector, AllocConstructor) {
-  auto alloc = std::allocator<Thrower>();
-  testing::TestThrowingCtor<InlVec<>>(alloc);
+TYPED_TEST(NoSizeTest, DefaultConstructor) {
+  using VecT = typename TypeParam::VecT;
+  using allocator_type = typename VecT::allocator_type;
 
 
-  auto throw_alloc = ThrowerAlloc();
-  testing::TestThrowingCtor<InlVec<ThrowerAlloc>>(throw_alloc);
+  testing::TestThrowingCtor<VecT>();
+
+  testing::TestThrowingCtor<VecT>(allocator_type{});
 }
 }
 
 
-TEST(InlinedVector, Clear) {
-  auto small_vec = InlVec<>(kSmallSize);
-  EXPECT_TRUE(testing::TestNothrowOp([&]() { small_vec.clear(); }));
+TYPED_TEST(OneSizeTest, Clear) {
+  using VecT = typename TypeParam::VecT;
+  constexpr static auto size = TypeParam::GetSizeAt(0);
+
+  auto tester = testing::MakeExceptionSafetyTester()
+                    .WithInitialValue(VecT(size))
+                    .WithContracts(NoThrowGuarantee<VecT>);
 
 
-  auto large_vec = InlVec<>(kLargeSize);
-  EXPECT_TRUE(testing::TestNothrowOp([&]() { large_vec.clear(); }));
+  EXPECT_TRUE(tester.Test([](VecT* vec) {
+    vec->clear();  //
+  }));
 }
 }
 
 
 }  // namespace
 }  // namespace

absl/container/internal/hashtablez_sampler_test.cc

@@ -199,7 +199,7 @@ TEST(HashtablezSamplerTest, Sample) {
   SetHashtablezSampleParameter(100);
   SetHashtablezSampleParameter(100);
   int64_t num_sampled = 0;
   int64_t num_sampled = 0;
   int64_t total = 0;
   int64_t total = 0;
-  double sample_rate;
+  double sample_rate = 0.0;
   for (int i = 0; i < 1000000; ++i) {
   for (int i = 0; i < 1000000; ++i) {
     HashtablezInfoHandle h = Sample();
     HashtablezInfoHandle h = Sample();
     ++total;
     ++total;

absl/container/internal/inlined_vector.h

@@ -22,6 +22,7 @@
 #include <utility>
 #include <utility>
 
 
 #include "absl/container/internal/compressed_tuple.h"
 #include "absl/container/internal/compressed_tuple.h"
+#include "absl/memory/memory.h"
 #include "absl/meta/type_traits.h"
 #include "absl/meta/type_traits.h"
 
 
 namespace absl {
 namespace absl {
@@ -35,15 +36,7 @@ using IsAtLeastForwardIterator = std::is_convertible<
 template <typename AllocatorType, typename ValueType, typename SizeType>
 template <typename AllocatorType, typename ValueType, typename SizeType>
 void DestroyElements(AllocatorType* alloc_ptr, ValueType* destroy_first,
 void DestroyElements(AllocatorType* alloc_ptr, ValueType* destroy_first,
                      SizeType destroy_size) {
                      SizeType destroy_size) {
-  using AllocatorTraits = std::allocator_traits<AllocatorType>;
-
-  // Destroys `destroy_size` elements from `destroy_first`.
-  //
-  // Destroys the range
-  //   [`destroy_first`, `destroy_first + destroy_size`).
-  //
-  // NOTE: We assume destructors do not throw and thus make no attempt to roll
-  // back.
+  using AllocatorTraits = absl::allocator_traits<AllocatorType>;
   for (SizeType i = 0; i < destroy_size; ++i) {
   for (SizeType i = 0; i < destroy_size; ++i) {
     AllocatorTraits::destroy(*alloc_ptr, destroy_first + i);
     AllocatorTraits::destroy(*alloc_ptr, destroy_first + i);
   }
   }
@@ -75,7 +68,7 @@ class Storage {
   using const_iterator = const_pointer;
   using const_iterator = const_pointer;
   using reverse_iterator = std::reverse_iterator<iterator>;
   using reverse_iterator = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-  using AllocatorTraits = std::allocator_traits<allocator_type>;
+  using AllocatorTraits = absl::allocator_traits<allocator_type>;
 
 
   explicit Storage(const allocator_type& alloc)
   explicit Storage(const allocator_type& alloc)
       : metadata_(alloc, /* empty and inlined */ 0) {}
       : metadata_(alloc, /* empty and inlined */ 0) {}

absl/debugging/symbolize_win32.inc

@@ -23,7 +23,7 @@
 #include <DbgHelp.h>
 #include <DbgHelp.h>
 #pragma warning(pop)
 #pragma warning(pop)
 
 
-#pragma comment(lib, "DbgHelp")
+#pragma comment(lib, "dbghelp.lib")
 
 
 #include <algorithm>
 #include <algorithm>
 #include <cstring>
 #include <cstring>

absl/strings/str_format_test.cc

@@ -271,7 +271,7 @@ TEST_F(FormatEntryPointTest, FPrintFError) {
   EXPECT_EQ(errno, EBADF);
   EXPECT_EQ(errno, EBADF);
 }
 }
 
 
-#if __GLIBC__
+#ifdef __GLIBC__
 TEST_F(FormatEntryPointTest, FprintfTooLarge) {
 TEST_F(FormatEntryPointTest, FprintfTooLarge) {
   std::FILE* f = std::fopen("/dev/null", "w");
   std::FILE* f = std::fopen("/dev/null", "w");
   int width = 2000000000;
   int width = 2000000000;

absl/time/civil_time.h

@@ -407,9 +407,9 @@ inline Weekday GetWeekday(CivilDay cd) {
 //
 //
 //   absl::CivilDay d = ...
 //   absl::CivilDay d = ...
 //   // Gets the following Thursday if d is not already Thursday
 //   // Gets the following Thursday if d is not already Thursday
-//   absl::CivilDay thurs1 = absl::PrevWeekday(d, absl::Weekday::thursday) + 7;
+//   absl::CivilDay thurs1 = absl::NextWeekday(d - 1, absl::Weekday::thursday);
 //   // Gets the previous Thursday if d is not already Thursday
 //   // Gets the previous Thursday if d is not already Thursday
-//   absl::CivilDay thurs2 = absl::NextWeekday(d, absl::Weekday::thursday) - 7;
+//   absl::CivilDay thurs2 = absl::PrevWeekday(d + 1, absl::Weekday::thursday);
 //
 //
 inline CivilDay NextWeekday(CivilDay cd, Weekday wd) {
 inline CivilDay NextWeekday(CivilDay cd, Weekday wd) {
   return CivilDay(time_internal::cctz::next_weekday(cd, wd));
   return CivilDay(time_internal::cctz::next_weekday(cd, wd));

absl/time/civil_time_test.cc

@@ -1028,7 +1028,7 @@ TEST(CivilTime, LeapYears) {
 TEST(CivilTime, FirstThursdayInMonth) {
 TEST(CivilTime, FirstThursdayInMonth) {
   const absl::CivilDay nov1(2014, 11, 1);
   const absl::CivilDay nov1(2014, 11, 1);
   const absl::CivilDay thursday =
   const absl::CivilDay thursday =
-      absl::PrevWeekday(nov1, absl::Weekday::thursday) + 7;
+      absl::NextWeekday(nov1 - 1, absl::Weekday::thursday);
   EXPECT_EQ("2014-11-06", absl::FormatCivilTime(thursday));
   EXPECT_EQ("2014-11-06", absl::FormatCivilTime(thursday));
 
 
   // Bonus: Date of Thanksgiving in the United States
   // Bonus: Date of Thanksgiving in the United States

absl/types/BUILD.bazel

@@ -18,9 +18,9 @@ load(
     "//absl:copts/configure_copts.bzl",
     "//absl:copts/configure_copts.bzl",
     "ABSL_DEFAULT_COPTS",
     "ABSL_DEFAULT_COPTS",
     "ABSL_DEFAULT_LINKOPTS",
     "ABSL_DEFAULT_LINKOPTS",
-    "ABSL_TEST_COPTS",
     "ABSL_EXCEPTIONS_FLAG",
     "ABSL_EXCEPTIONS_FLAG",
     "ABSL_EXCEPTIONS_FLAG_LINKOPTS",
     "ABSL_EXCEPTIONS_FLAG_LINKOPTS",
+    "ABSL_TEST_COPTS",
 )
 )
 
 
 package(default_visibility = ["//visibility:public"])
 package(default_visibility = ["//visibility:public"])