Export of internal Abseil changes.

--
2c12ae8d6cbb8cbeb3ff446393578dd0d6d0cf8c by Andy Getzendanner <durandal@google.com>:

Fix printf POSIX reference link to point at printf(3) (the C API) instead of printf(1) (the shell utility).

PiperOrigin-RevId: 231719473

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

Fixes "correct" but poor semantics `allocator_and_tag_` initializations in InlinedVector to the proper version that gets a reference/const reference to allocator_type

PiperOrigin-RevId: 231691608

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

Removes pathologically deleted move constructor and assignment operator from benchmark test type

PiperOrigin-RevId: 231680297

--
b2b52859e5f0e14a25047e528c8163b12ea9ca32 by Matt Armstrong <marmstrong@google.com>:

Assert on elapsed time, not absolute time.

This is a cosmetic change that aims to make
test failures clearer.  Human readers no longer
need to do as much mental math to deduce the
magnitude of the failure.  It does not change the
semantics of the test assertions.

PiperOrigin-RevId: 231644805
GitOrigin-RevId: 2c12ae8d6cbb8cbeb3ff446393578dd0d6d0cf8c
Change-Id: Ic121a26a7a6bb7441da6a8c1d7797bee4f705fdc

5 files changed, 20 insertions, 12 deletions

diff --git a/absl/container/inlined_vector.h b/absl/container/inlined_vector.h
index 493bd8eb38db..5c9e6d97a420 100644
--- a/absl/container/inlined_vector.h
+++ b/absl/container/inlined_vector.h
@@ -53,7 +53,6 @@
 #include "absl/memory/memory.h"
 
 namespace absl {
-
 // -----------------------------------------------------------------------------
 // InlinedVector
 // -----------------------------------------------------------------------------
@@ -159,7 +158,7 @@ class InlinedVector {
 
   // Creates a copy of `other` using `other`'s allocator.
   InlinedVector(const InlinedVector& other)
-      : InlinedVector(other, other.get_allocator()) {}
+      : InlinedVector(other, other.allocator()) {}
 
   // Creates a copy of `other` but with a specified allocator.
   InlinedVector(const InlinedVector& other, const allocator_type& alloc)
@@ -187,17 +186,19 @@ class InlinedVector {
   InlinedVector(InlinedVector&& other) noexcept(
       absl::allocator_is_nothrow<allocator_type>::value ||
       std::is_nothrow_move_constructible<value_type>::value)
-      : allocator_and_tag_(other.allocator_and_tag_) {
+      : allocator_and_tag_(other.allocator()) {
     if (other.allocated()) {
       // We can just steal the underlying buffer from the source.
       // That leaves the source empty, so we clear its size.
       init_allocation(other.allocation());
+      tag().set_allocated_size(other.size());
       other.tag() = Tag();
     } else {
       UninitializedCopy(
           std::make_move_iterator(other.inlined_space()),
           std::make_move_iterator(other.inlined_space() + other.size()),
           inlined_space());
+      tag().set_inline_size(other.size());
     }
   }
 
diff --git a/absl/container/inlined_vector_benchmark.cc b/absl/container/inlined_vector_benchmark.cc
index a3ad0f8ae4f1..9ca93b27be9a 100644
--- a/absl/container/inlined_vector_benchmark.cc
+++ b/absl/container/inlined_vector_benchmark.cc
@@ -159,15 +159,14 @@ struct LargeCopyableOnly {
 
 struct LargeCopyableSwappable {
   LargeCopyableSwappable() : d(1024, 17) {}
+
   LargeCopyableSwappable(const LargeCopyableSwappable& o) = default;
-  LargeCopyableSwappable(LargeCopyableSwappable&& o) = delete;
 
   LargeCopyableSwappable& operator=(LargeCopyableSwappable o) {
     using std::swap;
     swap(*this, o);
     return *this;
   }
-  LargeCopyableSwappable& operator=(LargeCopyableSwappable&& o) = delete;
 
   friend void swap(LargeCopyableSwappable& a, LargeCopyableSwappable& b) {
     using std::swap;
diff --git a/absl/strings/str_format.h b/absl/strings/str_format.h
index 2d07725de21f..060909a2bfc1 100644
--- a/absl/strings/str_format.h
+++ b/absl/strings/str_format.h
@@ -186,7 +186,7 @@ class FormatCountCapture {
 // A format string generally follows the POSIX syntax as used within the POSIX
 // `printf` specification.
 //
-// (See http://pubs.opengroup.org/onlinepubs/9699919799/utilities/printf.html.)
+// (See http://pubs.opengroup.org/onlinepubs/9699919799/functions/fprintf.html.)
 //
 // In specific, the `FormatSpec` supports the following type specifiers:
 //   * `c` for characters
diff --git a/absl/synchronization/internal/per_thread_sem_test.cc b/absl/synchronization/internal/per_thread_sem_test.cc
index c29d8403df43..81cbe9578444 100644
--- a/absl/synchronization/internal/per_thread_sem_test.cc
+++ b/absl/synchronization/internal/per_thread_sem_test.cc
@@ -152,12 +152,16 @@ TEST_F(PerThreadSemTest, WithTimeout) {
 }
 
 TEST_F(PerThreadSemTest, Timeouts) {
-  absl::Time timeout = absl::Now() + absl::Milliseconds(50);
+  const absl::Duration delay = absl::Milliseconds(50);
+  const absl::Time start = absl::Now();
+  EXPECT_FALSE(Wait(start + delay));
+  const absl::Duration elapsed = absl::Now() - start;
   // Allow for a slight early return, to account for quality of implementation
   // issues on various platforms.
   const absl::Duration slop = absl::Microseconds(200);
-  EXPECT_FALSE(Wait(timeout));
-  EXPECT_LE(timeout, absl::Now() + slop);
+  EXPECT_LE(delay - slop, elapsed)
+      << "Wait returned " << delay - elapsed
+      << " early (with " << slop << " slop), start time was " << start;
 
   absl::Time negative_timeout = absl::UnixEpoch() - absl::Milliseconds(100);
   EXPECT_FALSE(Wait(negative_timeout));
diff --git a/absl/synchronization/notification_test.cc b/absl/synchronization/notification_test.cc
index d8708d551a15..95bde0bd1682 100644
--- a/absl/synchronization/notification_test.cc
+++ b/absl/synchronization/notification_test.cc
@@ -72,12 +72,16 @@ static void BasicTests(bool notify_before_waiting, Notification* notification) {
   EXPECT_FALSE(notification->WaitForNotificationWithDeadline(absl::Now()));
 
   const absl::Duration delay = absl::Milliseconds(50);
+  const absl::Time start = absl::Now();
+  EXPECT_FALSE(notification->WaitForNotificationWithTimeout(delay));
+  const absl::Duration elapsed = absl::Now() - start;
+
   // Allow for a slight early return, to account for quality of implementation
   // issues on various platforms.
   const absl::Duration slop = absl::Microseconds(200);
-  absl::Time start = absl::Now();
-  EXPECT_FALSE(notification->WaitForNotificationWithTimeout(delay));
-  EXPECT_LE(start + delay, absl::Now() + slop);
+  EXPECT_LE(delay - slop, elapsed)
+      << "WaitForNotificationWithTimeout returned " << delay - elapsed
+      << " early (with " << slop << " slop), start time was " << start;
 
   ThreadSafeCounter ready_counter;
   ThreadSafeCounter done_counter;