Export of internal Abseil changes.

--
a874475e842d2adeb31bb7bd37bdd6eb15a2aeb9 by Mark Barolak <mbar@google.com>:

Import of CCTZ from GitHub.

PiperOrigin-RevId: 256414250

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

Update the license year + run clang-format for the FixedArray and InlinedVector test files

PiperOrigin-RevId: 256376285

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

Migrate the Linux CMake tests from GCC 4.8 to the GCC latest
version. This will allow us to delete the GCC 4.8 test since that is
currently our only CMake coverage. This also means that we don't have
to update the script every time we move to a new minumum GCC version.

This change includes a fix for a -Wstringops-truncation warning in
symbolize_test.cc that triggers when it is built in release mode with
the latest GCC.

PiperOrigin-RevId: 256370092
GitOrigin-RevId: a874475e842d2adeb31bb7bd37bdd6eb15a2aeb9
Change-Id: Ia2ec58f9b9dfc382d043344e346cb397b802270a

4 files changed, 52 insertions, 64 deletions

diff --git a/absl/container/fixed_array_benchmark.cc b/absl/container/fixed_array_benchmark.cc
index ff56f466c9b0..3c7a5a723450 100644
--- a/absl/container/fixed_array_benchmark.cc
+++ b/absl/container/fixed_array_benchmark.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Abseil Authors.
+// Copyright 2019 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.
@@ -12,12 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "absl/container/fixed_array.h"
-
 #include <stddef.h>
+
 #include <string>
 
 #include "benchmark/benchmark.h"
+#include "absl/container/fixed_array.h"
 
 namespace {
 
@@ -25,8 +25,9 @@ namespace {
 // set an int to a constant..
 class SimpleClass {
  public:
-  SimpleClass() : i(3) { }
+  SimpleClass() : i(3) {}
   ~SimpleClass() { i = 0; }
+
  private:
   int i;
 };
diff --git a/absl/container/fixed_array_exception_safety_test.cc b/absl/container/fixed_array_exception_safety_test.cc
index 826eca612dd1..9984a5e2ae41 100644
--- a/absl/container/fixed_array_exception_safety_test.cc
+++ b/absl/container/fixed_array_exception_safety_test.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Abseil Authors.
+// Copyright 2019 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.
@@ -14,10 +14,9 @@
 
 #include <initializer_list>
 
-#include "absl/container/fixed_array.h"
-
 #include "gtest/gtest.h"
 #include "absl/base/internal/exception_safety_testing.h"
+#include "absl/container/fixed_array.h"
 
 namespace absl {
 
diff --git a/absl/container/fixed_array_test.cc b/absl/container/fixed_array_test.cc
index a4f2498b7a88..2b1cf47eacb8 100644
--- a/absl/container/fixed_array_test.cc
+++ b/absl/container/fixed_array_test.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Abseil Authors.
+// Copyright 2019 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.
@@ -15,6 +15,7 @@
 #include "absl/container/fixed_array.h"
 
 #include <stdio.h>
+
 #include <cstring>
 #include <list>
 #include <memory>
@@ -42,11 +43,7 @@ static bool IsOnStack(const ArrayType& a) {
 
 class ConstructionTester {
  public:
-  ConstructionTester()
-      : self_ptr_(this),
-        value_(0) {
-    constructions++;
-  }
+  ConstructionTester() : self_ptr_(this), value_(0) { constructions++; }
   ~ConstructionTester() {
     assert(self_ptr_ == this);
     self_ptr_ = nullptr;
@@ -58,9 +55,7 @@ class ConstructionTester {
   static int constructions;
   static int destructions;
 
-  void CheckConstructed() {
-    assert(self_ptr_ == this);
-  }
+  void CheckConstructed() { assert(self_ptr_ == this); }
 
   void set(int value) { value_ = value; }
   int get() { return value_; }
@@ -160,13 +155,13 @@ TEST(FixedArrayTest, SmallObjects) {
     // same amount of stack space
     absl::FixedArray<int> array1(0);
     absl::FixedArray<char> array2(0);
-    EXPECT_LE(sizeof(array1), sizeof(array2)+100);
-    EXPECT_LE(sizeof(array2), sizeof(array1)+100);
+    EXPECT_LE(sizeof(array1), sizeof(array2) + 100);
+    EXPECT_LE(sizeof(array2), sizeof(array1) + 100);
   }
 
   {
     // Ensure that vectors are properly constructed inside a fixed array.
-    absl::FixedArray<std::vector<int> > array(2);
+    absl::FixedArray<std::vector<int>> array(2);
     EXPECT_EQ(0, array[0].size());
     EXPECT_EQ(0, array[1].size());
   }
@@ -270,8 +265,8 @@ static void TestArray(int n) {
       array.data()[i].set(i + 1);
     }
     for (int i = 0; i < n; i++) {
-      EXPECT_THAT(array[i].get(), i+1);
-      EXPECT_THAT(array.data()[i].get(), i+1);
+      EXPECT_THAT(array[i].get(), i + 1);
+      EXPECT_THAT(array.data()[i].get(), i + 1);
     }
   }  // Close scope containing 'array'.
 
@@ -296,7 +291,7 @@ static void TestArrayOfArrays(int n) {
 
     ASSERT_EQ(array.size(), n);
     ASSERT_EQ(array.memsize(),
-             sizeof(ConstructionTester) * elements_per_inner_array * n);
+              sizeof(ConstructionTester) * elements_per_inner_array * n);
     ASSERT_EQ(array.begin() + n, array.end());
 
     // Check that all elements were constructed
@@ -316,7 +311,7 @@ static void TestArrayOfArrays(int n) {
     }
     for (int i = 0; i < n; i++) {
       for (int j = 0; j < elements_per_inner_array; j++) {
-        ASSERT_EQ((array[i])[j].get(),  i * elements_per_inner_array + j);
+        ASSERT_EQ((array[i])[j].get(), i * elements_per_inner_array + j);
         ASSERT_EQ((array.data()[i])[j].get(), i * elements_per_inner_array + j);
       }
     }
@@ -329,8 +324,7 @@ static void TestArrayOfArrays(int n) {
     }
     for (int i = 0; i < n; i++) {
       for (int j = 0; j < elements_per_inner_array; j++) {
-        ASSERT_EQ((array[i])[j].get(),
-                  (i + 1) * elements_per_inner_array + j);
+        ASSERT_EQ((array[i])[j].get(), (i + 1) * elements_per_inner_array + j);
         ASSERT_EQ((array.data()[i])[j].get(),
                   (i + 1) * elements_per_inner_array + j);
       }
@@ -343,7 +337,7 @@ static void TestArrayOfArrays(int n) {
 }
 
 TEST(IteratorConstructorTest, NonInline) {
-  int const kInput[] = { 2, 3, 5, 7, 11, 13, 17 };
+  int const kInput[] = {2, 3, 5, 7, 11, 13, 17};
   absl::FixedArray<int, ABSL_ARRAYSIZE(kInput) - 1> const fixed(
       kInput, kInput + ABSL_ARRAYSIZE(kInput));
   ASSERT_EQ(ABSL_ARRAYSIZE(kInput), fixed.size());
@@ -353,7 +347,7 @@ TEST(IteratorConstructorTest, NonInline) {
 }
 
 TEST(IteratorConstructorTest, Inline) {
-  int const kInput[] = { 2, 3, 5, 7, 11, 13, 17 };
+  int const kInput[] = {2, 3, 5, 7, 11, 13, 17};
   absl::FixedArray<int, ABSL_ARRAYSIZE(kInput)> const fixed(
       kInput, kInput + ABSL_ARRAYSIZE(kInput));
   ASSERT_EQ(ABSL_ARRAYSIZE(kInput), fixed.size());
@@ -363,8 +357,8 @@ TEST(IteratorConstructorTest, Inline) {
 }
 
 TEST(IteratorConstructorTest, NonPod) {
-  char const* kInput[] =
-      { "red", "orange", "yellow", "green", "blue", "indigo", "violet" };
+  char const* kInput[] = {"red",  "orange", "yellow", "green",
+                          "blue", "indigo", "violet"};
   absl::FixedArray<std::string> const fixed(kInput,
                                             kInput + ABSL_ARRAYSIZE(kInput));
   ASSERT_EQ(ABSL_ARRAYSIZE(kInput), fixed.size());
@@ -381,7 +375,7 @@ TEST(IteratorConstructorTest, FromEmptyVector) {
 }
 
 TEST(IteratorConstructorTest, FromNonEmptyVector) {
-  int const kInput[] = { 2, 3, 5, 7, 11, 13, 17 };
+  int const kInput[] = {2, 3, 5, 7, 11, 13, 17};
   std::vector<int> const items(kInput, kInput + ABSL_ARRAYSIZE(kInput));
   absl::FixedArray<int> const fixed(items.begin(), items.end());
   ASSERT_EQ(items.size(), fixed.size());
@@ -391,7 +385,7 @@ TEST(IteratorConstructorTest, FromNonEmptyVector) {
 }
 
 TEST(IteratorConstructorTest, FromBidirectionalIteratorRange) {
-  int const kInput[] = { 2, 3, 5, 7, 11, 13, 17 };
+  int const kInput[] = {2, 3, 5, 7, 11, 13, 17};
   std::list<int> const items(kInput, kInput + ABSL_ARRAYSIZE(kInput));
   absl::FixedArray<int> const fixed(items.begin(), items.end());
   EXPECT_THAT(fixed, testing::ElementsAreArray(kInput));
@@ -508,9 +502,8 @@ struct PickyDelete {
 
 TEST(FixedArrayTest, UsesGlobalAlloc) { absl::FixedArray<PickyDelete, 0> a(5); }
 
-
 TEST(FixedArrayTest, Data) {
-  static const int kInput[] = { 2, 3, 5, 7, 11, 13, 17 };
+  static const int kInput[] = {2, 3, 5, 7, 11, 13, 17};
   absl::FixedArray<int> fa(std::begin(kInput), std::end(kInput));
   EXPECT_EQ(fa.data(), &*fa.begin());
   EXPECT_EQ(fa.data(), &fa[0]);
@@ -824,7 +817,7 @@ TEST(AllocatorSupportTest, SizeValAllocConstructor) {
 #ifdef ADDRESS_SANITIZER
 TEST(FixedArrayTest, AddressSanitizerAnnotations1) {
   absl::FixedArray<int, 32> a(10);
-  int *raw = a.data();
+  int* raw = a.data();
   raw[0] = 0;
   raw[9] = 0;
   EXPECT_DEATH(raw[-2] = 0, "container-overflow");
@@ -835,7 +828,7 @@ TEST(FixedArrayTest, AddressSanitizerAnnotations1) {
 
 TEST(FixedArrayTest, AddressSanitizerAnnotations2) {
   absl::FixedArray<char, 17> a(12);
-  char *raw = a.data();
+  char* raw = a.data();
   raw[0] = 0;
   raw[11] = 0;
   EXPECT_DEATH(raw[-7] = 0, "container-overflow");
@@ -846,7 +839,7 @@ TEST(FixedArrayTest, AddressSanitizerAnnotations2) {
 
 TEST(FixedArrayTest, AddressSanitizerAnnotations3) {
   absl::FixedArray<uint64_t, 20> a(20);
-  uint64_t *raw = a.data();
+  uint64_t* raw = a.data();
   raw[0] = 0;
   raw[19] = 0;
   EXPECT_DEATH(raw[-1] = 0, "container-overflow");
@@ -855,7 +848,7 @@ TEST(FixedArrayTest, AddressSanitizerAnnotations3) {
 
 TEST(FixedArrayTest, AddressSanitizerAnnotations4) {
   absl::FixedArray<ThreeInts> a(10);
-  ThreeInts *raw = a.data();
+  ThreeInts* raw = a.data();
   raw[0] = ThreeInts();
   raw[9] = ThreeInts();
   // Note: raw[-1] is pointing to 12 bytes before the container range. However,
diff --git a/absl/container/inlined_vector_test.cc b/absl/container/inlined_vector_test.cc
index 60fe89b28aee..76c470f3471b 100644
--- a/absl/container/inlined_vector_test.cc
+++ b/absl/container/inlined_vector_test.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Abseil Authors.
+// Copyright 2019 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.
@@ -76,12 +76,9 @@ TYPED_TEST_SUITE_P(InstanceTest);
 // destroyed in the erase(begin, end) test.
 class RefCounted {
  public:
-  RefCounted(int value, int* count) : value_(value), count_(count) {
-    Ref();
-  }
+  RefCounted(int value, int* count) : value_(value), count_(count) { Ref(); }
 
-  RefCounted(const RefCounted& v)
-      : value_(v.value_), count_(v.count_) {
+  RefCounted(const RefCounted& v) : value_(v.value_), count_(v.count_) {
     Ref();
   }
 
@@ -290,7 +287,7 @@ TEST(RefCountedVec, EraseBeginEnd) {
         }
 
         // Check that the elements at the end are preserved.
-        for (int i = erase_end; i< len; ++i) {
+        for (int i = erase_end; i < len; ++i) {
           EXPECT_EQ(1, counts[i]);
         }
       }
@@ -552,10 +549,10 @@ TEST(IntVec, Resize) {
     static const int kResizeElem = 1000000;
     for (int k = 0; k < 10; k++) {
       // Enlarging resize
-      v.resize(len+k, kResizeElem);
-      EXPECT_EQ(len+k, v.size());
-      EXPECT_LE(len+k, v.capacity());
-      for (int i = 0; i < len+k; i++) {
+      v.resize(len + k, kResizeElem);
+      EXPECT_EQ(len + k, v.size());
+      EXPECT_LE(len + k, v.capacity());
+      for (int i = 0; i < len + k; i++) {
         if (i < len) {
           EXPECT_EQ(i, v[i]);
         } else {
@@ -866,7 +863,7 @@ TYPED_TEST_P(InstanceTest, Swap) {
       auto min_len = std::min(l1, l2);
       auto max_len = std::max(l1, l2);
       for (int i = 0; i < l1; i++) a.push_back(Instance(i));
-      for (int i = 0; i < l2; i++) b.push_back(Instance(100+i));
+      for (int i = 0; i < l2; i++) b.push_back(Instance(100 + i));
       EXPECT_EQ(tracker.instances(), l1 + l2);
       tracker.ResetCopiesMovesSwaps();
       {
@@ -934,7 +931,7 @@ TEST(IntVec, EqualAndNotEqual) {
     EXPECT_FALSE(a == b);
     EXPECT_TRUE(a != b);
 
-    b[i] = b[i] - 1;    // Back to before
+    b[i] = b[i] - 1;  // Back to before
     EXPECT_TRUE(a == b);
     EXPECT_FALSE(a != b);
   }
@@ -1001,7 +998,7 @@ TYPED_TEST_P(InstanceTest, CountConstructorsDestructors) {
 
     // reserve() must not increase the number of initialized objects
     SCOPED_TRACE("reserve");
-    v.reserve(len+1000);
+    v.reserve(len + 1000);
     EXPECT_EQ(tracker.instances(), len);
     EXPECT_EQ(tracker.copies() + tracker.moves(), len);
 
@@ -1247,9 +1244,8 @@ void InstanceCountElemAssignWithAllocationTest() {
     absl::InlinedVector<Instance, 2> v(original_contents.begin(),
                                        original_contents.end());
     v.assign(3, Instance(123));
-    EXPECT_THAT(v,
-                AllOf(SizeIs(3),
-                      ElementsAre(ValueIs(123), ValueIs(123), ValueIs(123))));
+    EXPECT_THAT(v, AllOf(SizeIs(3), ElementsAre(ValueIs(123), ValueIs(123),
+                                                ValueIs(123))));
     EXPECT_LE(v.size(), v.capacity());
   }
 }
@@ -1528,8 +1524,8 @@ TYPED_TEST_P(InstanceTest, InitializerListAssign) {
     SCOPED_TRACE(original_size);
     absl::InlinedVector<Instance, 2> v(original_size, Instance(12345));
     v.assign({Instance(3), Instance(4), Instance(5)});
-    EXPECT_THAT(v, AllOf(SizeIs(3),
-                         ElementsAre(ValueIs(3), ValueIs(4), ValueIs(5))));
+    EXPECT_THAT(
+        v, AllOf(SizeIs(3), ElementsAre(ValueIs(3), ValueIs(4), ValueIs(5))));
     EXPECT_LE(3, v.capacity());
   }
 }
@@ -1554,7 +1550,7 @@ TEST(DynamicVec, DynamicVecCompiles) {
 TEST(AllocatorSupportTest, Constructors) {
   using MyAlloc = CountingAllocator<int>;
   using AllocVec = absl::InlinedVector<int, 4, MyAlloc>;
-  const int ia[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+  const int ia[] = {0, 1, 2, 3, 4, 5, 6, 7};
   int64_t allocated = 0;
   MyAlloc alloc(&allocated);
   { AllocVec ABSL_ATTRIBUTE_UNUSED v; }
@@ -1570,7 +1566,7 @@ TEST(AllocatorSupportTest, Constructors) {
 TEST(AllocatorSupportTest, CountAllocations) {
   using MyAlloc = CountingAllocator<int>;
   using AllocVec = absl::InlinedVector<int, 4, MyAlloc>;
-  const int ia[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+  const int ia[] = {0, 1, 2, 3, 4, 5, 6, 7};
   int64_t allocated = 0;
   MyAlloc alloc(&allocated);
   {
@@ -1634,8 +1630,8 @@ TEST(AllocatorSupportTest, SwapBothAllocated) {
   int64_t allocated1 = 0;
   int64_t allocated2 = 0;
   {
-    const int ia1[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
-    const int ia2[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
+    const int ia1[] = {0, 1, 2, 3, 4, 5, 6, 7};
+    const int ia2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
     MyAlloc a1(&allocated1);
     MyAlloc a2(&allocated2);
     AllocVec v1(ia1, ia1 + ABSL_ARRAYSIZE(ia1), a1);
@@ -1659,8 +1655,8 @@ TEST(AllocatorSupportTest, SwapOneAllocated) {
   int64_t allocated1 = 0;
   int64_t allocated2 = 0;
   {
-    const int ia1[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
-    const int ia2[] = { 0, 1, 2, 3 };
+    const int ia1[] = {0, 1, 2, 3, 4, 5, 6, 7};
+    const int ia2[] = {0, 1, 2, 3};
     MyAlloc a1(&allocated1);
     MyAlloc a2(&allocated2);
     AllocVec v1(ia1, ia1 + ABSL_ARRAYSIZE(ia1), a1);
@@ -1681,8 +1677,7 @@ TEST(AllocatorSupportTest, SwapOneAllocated) {
 
 TEST(AllocatorSupportTest, ScopedAllocatorWorks) {
   using StdVector = std::vector<int, CountingAllocator<int>>;
-  using MyAlloc =
-      std::scoped_allocator_adaptor<CountingAllocator<StdVector>>;
+  using MyAlloc = std::scoped_allocator_adaptor<CountingAllocator<StdVector>>;
   using AllocVec = absl::InlinedVector<StdVector, 4, MyAlloc>;
 
   // MSVC 2017's std::vector allocates different amounts of memory in debug