re2 1.23.0 → 1.23.2

package/vendor/abseil-cpp/absl/algorithm/container_test.cc

@@ -1408,6 +1408,824 @@ TEST(ConstexprTest, SearchNWithPredicate) {
                 kArray.begin());
 }
 
+TEST(ConstexprTest, Copy) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayCopy = [] {
+    std::array<int, 3> array;
+    absl::c_copy(kArray, array.begin());
+    return array;
+  }();
+  static_assert(kArrayCopy == kArray);
+}
+
+TEST(ConstexprTest, CopyN) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayCopy = [] {
+    std::array<int, 2> array;
+    absl::c_copy_n(kArray, 2, array.begin());
+    return array;
+  }();
+  static_assert(kArrayCopy == std::array{1, 2});
+}
+
+TEST(ConstexprTest, CopyIf) {
+  static constexpr std::array kArray = {1, 2, 3, 4};
+  static constexpr auto kArrayCopy = [] {
+    std::array<int, 3> array;
+    absl::c_copy_if(kArray, array.begin(), [](int x) { return x > 1; });
+    return array;
+  }();
+  static_assert(kArrayCopy == std::array{2, 3, 4});
+}
+
+TEST(ConstexprTest, CopyBackward) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayCopy = [] {
+    std::array<int, 3> array;
+    absl::c_copy_backward(kArray, array.end());
+    return array;
+  }();
+  static_assert(kArrayCopy == kArray);
+}
+
+TEST(ConstexprTest, Move) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayMove = [] {
+    std::array<int, 3> array;
+    absl::c_move(kArray, array.begin());
+    return array;
+  }();
+  static_assert(kArrayMove == kArray);
+}
+
+TEST(ConstexprTest, MoveBackward) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayMove = [] {
+    std::array<int, 3> array;
+    absl::c_move_backward(kArray, array.end());
+    return array;
+  }();
+  static_assert(kArrayMove == kArray);
+}
+
+TEST(ConstexprTest, SwapRanges) {
+  static constexpr std::array kArray1 = {1, 2, 3};
+  static constexpr std::array kArray2 = {4, 5, 6};
+
+  static constexpr auto kSwapped = [] {
+    std::array arr1 = kArray1;
+    std::array arr2 = kArray2;
+    absl::c_swap_ranges(arr1, arr2);
+    return std::make_pair(arr1, arr2);
+  }();
+
+  static_assert(kSwapped.first == kArray2);
+  static_assert(kSwapped.second == kArray1);
+}
+
+TEST(ConstexprTest, Transform) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayTransform = [] {
+    std::array<int, 3> array;
+    absl::c_transform(kArray, array.begin(), [](int x) { return x + 1; });
+    return array;
+  }();
+  static_assert(kArrayTransform == std::array{2, 3, 4});
+}
+
+TEST(ConstexprTest, Replace) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayReplace = [] {
+    std::array array = kArray;
+    absl::c_replace(array, 1, 4);
+    return array;
+  }();
+  static_assert(kArrayReplace == std::array{4, 2, 3});
+}
+
+TEST(ConstexprTest, ReplaceIf) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayReplaceIf = [] {
+    std::array array = kArray;
+    absl::c_replace_if(array, [](int x) { return x == 1; }, 4);
+    return array;
+  }();
+  static_assert(kArrayReplaceIf == std::array{4, 2, 3});
+}
+
+TEST(ConstexprTest, ReplaceCopy) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayReplaceCopy = [] {
+    std::array<int, 3> array;
+    absl::c_replace_copy(kArray, array.begin(), 1, 4);
+    return array;
+  }();
+  static_assert(kArrayReplaceCopy == std::array{4, 2, 3});
+}
+
+TEST(ConstexprTest, ReplaceCopyIf) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayReplaceCopyIf = [] {
+    std::array<int, 3> array;
+    absl::c_replace_copy_if(
+        kArray, array.begin(), [](int x) { return x == 1; }, 4);
+    return array;
+  }();
+  static_assert(kArrayReplaceCopyIf == std::array{4, 2, 3});
+}
+
+TEST(ConstexprTest, Fill) {
+  static constexpr auto kArrayFill = [] {
+    std::array<int, 3> array;
+    absl::c_fill(array, 4);
+    return array;
+  }();
+  static_assert(kArrayFill == std::array{4, 4, 4});
+}
+
+TEST(ConstexprTest, FillN) {
+  static constexpr auto kArrayFillN = [] {
+    std::array array = {0, 0, 0};
+    absl::c_fill_n(array, 2, 4);
+    return array;
+  }();
+  static_assert(kArrayFillN == std::array{4, 4, 0});
+}
+
+TEST(ConstexprTest, Generate) {
+  static constexpr auto kArrayGenerate = [] {
+    std::array<int, 3> array;
+    absl::c_generate(array, []() { return 4; });
+    return array;
+  }();
+  static_assert(kArrayGenerate == std::array{4, 4, 4});
+}
+
+TEST(ConstexprTest, GenerateN) {
+  static constexpr auto kArrayGenerateN = [] {
+    std::array array = {0, 0, 0};
+    absl::c_generate_n(array, 2, []() { return 4; });
+    return array;
+  }();
+  static_assert(kArrayGenerateN == std::array{4, 4, 0});
+}
+
+TEST(ConstexprTest, RemoveCopy) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayRemoveCopy = [] {
+    std::array<int, 2> array;
+    absl::c_remove_copy(kArray, array.begin(), 1);
+    return array;
+  }();
+  static_assert(kArrayRemoveCopy == std::array{2, 3});
+}
+
+TEST(ConstexprTest, RemoveCopyIf) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayRemoveCopyIf = [] {
+    std::array<int, 2> array;
+    absl::c_remove_copy_if(kArray, array.begin(), [](int x) { return x == 1; });
+    return array;
+  }();
+  static_assert(kArrayRemoveCopyIf == std::array{2, 3});
+}
+
+TEST(ConstexprTest, UniqueCopy) {
+  static constexpr std::array kArray = {1, 2, 2, 3};
+  static constexpr auto kArrayUniqueCopy = [] {
+    std::array<int, 3> array;
+    absl::c_unique_copy(kArray, array.begin());
+    return array;
+  }();
+  static_assert(kArrayUniqueCopy == std::array{1, 2, 3});
+}
+
+TEST(ConstexprTest, UniqueCopyWithPredicate) {
+  static constexpr std::array kArray = {1, 2, 2, 3};
+  static constexpr auto kArrayUniqueCopy = [] {
+    std::array<int, 3> array;
+    absl::c_unique_copy(kArray, array.begin(), std::equal_to<>());
+    return array;
+  }();
+  static_assert(kArrayUniqueCopy == std::array{1, 2, 3});
+}
+
+TEST(ConstexprTest, Reverse) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayReverse = [] {
+    std::array array = kArray;
+    absl::c_reverse(array);
+    return array;
+  }();
+  static_assert(kArrayReverse == std::array{3, 2, 1});
+}
+
+TEST(ConstexprTest, ReverseCopy) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayReverseCopy = [] {
+    std::array<int, 3> array;
+    absl::c_reverse_copy(kArray, array.begin());
+    return array;
+  }();
+  static_assert(kArrayReverseCopy == std::array{3, 2, 1});
+}
+
+TEST(ConstexprTest, Rotate) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayRotate = [] {
+    std::array array = kArray;
+    absl::c_rotate(array, array.begin() + 1);
+    return array;
+  }();
+  static_assert(kArrayRotate == std::array{2, 3, 1});
+}
+
+TEST(ConstexprTest, RotateCopy) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayRotateCopy = [] {
+    std::array<int, 3> array;
+    absl::c_rotate_copy(kArray, kArray.begin() + 1, array.begin());
+    return array;
+  }();
+  static_assert(kArrayRotateCopy == std::array{2, 3, 1});
+}
+
+TEST(ConstexprTest, IsPartitioned) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static_assert(!absl::c_is_partitioned(kArray, [](int x) { return x > 1; }));
+
+  static constexpr std::array kPartitionedArray = {2, 3, 1};
+  static_assert(
+      absl::c_is_partitioned(kPartitionedArray, [](int x) { return x > 1; }));
+}
+
+TEST(ConstexprTest, Partition) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayPartition = [] {
+    std::array array = kArray;
+    absl::c_partition(array, [](int x) { return x > 1; });
+    return array;
+  }();
+  static_assert(
+      absl::c_is_partitioned(kArrayPartition, [](int x) { return x > 1; }));
+}
+
+TEST(ConstexprTest, PartitionCopy) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kPartitioned = [] {
+    std::array<int, 2> true_part;
+    std::array<int, 1> false_part;
+    absl::c_partition_copy(kArray, true_part.begin(), false_part.begin(),
+                           [](int x) { return x > 1; });
+    return std::make_pair(true_part, false_part);
+  }();
+  static_assert(kPartitioned.first == std::array{2, 3});
+  static_assert(kPartitioned.second == std::array{1});
+}
+
+TEST(ConstexprTest, PartitionPoint) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kPartitionPoint =
+      absl::c_partition_point(kArray, [](int x) { return x > 1; });
+  static_assert(kPartitionPoint == kArray.end());
+}
+
+TEST(ConstexprTest, Sort) {
+  static constexpr std::array kArray = {2, 1, 3};
+  static constexpr auto kArraySort = [] {
+    std::array array = kArray;
+    absl::c_sort(array);
+    return array;
+  }();
+  static_assert(kArraySort == std::array{1, 2, 3});
+}
+
+TEST(ConstexprTest, SortWithPredicate) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArraySort = [] {
+    std::array array = kArray;
+    absl::c_sort(array, std::greater<>());
+    return array;
+  }();
+  static_assert(kArraySort == std::array{3, 2, 1});
+}
+
+TEST(ConstexprTest, IsSorted) {
+  static constexpr std::array kSortedArray = {1, 2, 3};
+  static_assert(absl::c_is_sorted(kSortedArray));
+  static constexpr std::array kUnsortedArray = {1, 3, 2};
+  static_assert(!absl::c_is_sorted(kUnsortedArray));
+}
+
+TEST(ConstexprTest, IsSortedWithPredicate) {
+  static constexpr std::array kSortedArray = {3, 2, 1};
+  static_assert(absl::c_is_sorted(kSortedArray, std::greater<>()));
+  static constexpr std::array kUnsortedArray = {1, 3, 2};
+  static_assert(!absl::c_is_sorted(kUnsortedArray, std::greater<>()));
+}
+
+TEST(ConstexprTest, PartialSort) {
+  static constexpr std::array kArray = {3, 1, 4, 2};
+  static constexpr auto kArrayPartialSort = [] {
+    std::array array = kArray;
+    absl::c_partial_sort(array, array.begin() + 2);
+    return array;
+  }();
+  static_assert(kArrayPartialSort[0] == 1);
+  static_assert(kArrayPartialSort[1] == 2);
+}
+
+TEST(ConstexprTest, PartialSortWithPredicate) {
+  static constexpr std::array kArray = {3, 1, 4, 2};
+  static constexpr auto kArrayPartialSort = [] {
+    std::array array = kArray;
+    absl::c_partial_sort(array, array.begin() + 2, std::greater<>());
+    return array;
+  }();
+  static_assert(kArrayPartialSort[0] == 4);
+  static_assert(kArrayPartialSort[1] == 3);
+}
+
+TEST(ConstexprTest, PartialSortCopy) {
+  static constexpr std::array kArray = {3, 1, 4, 2};
+  static constexpr auto kArrayPartialSort = [] {
+    std::array<int, 4> array;
+    absl::c_partial_sort_copy(kArray, array);
+    return array;
+  }();
+  static_assert(kArrayPartialSort[0] == 1);
+  static_assert(kArrayPartialSort[1] == 2);
+}
+
+TEST(ConstexprTest, PartialSortCopyWithPredicate) {
+  static constexpr std::array kArray = {3, 1, 4, 2};
+  static constexpr auto kArrayPartialSort = [] {
+    std::array<int, 4> array;
+    absl::c_partial_sort_copy(kArray, array, std::greater<>());
+    return array;
+  }();
+  static_assert(kArrayPartialSort[0] == 4);
+  static_assert(kArrayPartialSort[1] == 3);
+}
+
+TEST(ConstexprTest, IsSortedUntil) {
+  static constexpr std::array kSortedArray = {1, 2, 3};
+  static_assert(absl::c_is_sorted_until(kSortedArray) == kSortedArray.end());
+  static constexpr std::array kUnsortedArray = {1, 3, 2};
+  static_assert(absl::c_is_sorted_until(kUnsortedArray) ==
+                kUnsortedArray.begin() + 2);
+}
+
+TEST(ConstexprTest, IsSortedUntilWithPredicate) {
+  static constexpr std::array kSortedArray = {3, 2, 1};
+  static_assert(absl::c_is_sorted_until(kSortedArray, std::greater<>()) ==
+                kSortedArray.end());
+  static constexpr std::array kUnsortedArray = {1, 3, 2};
+  static_assert(absl::c_is_sorted_until(kUnsortedArray, std::greater<>()) ==
+                kUnsortedArray.begin() + 1);
+}
+
+TEST(ConstexprTest, NthElement) {
+  static constexpr std::array kArray = {2, 1, 3, 4};
+  static constexpr auto kArrayNthElement = [] {
+    std::array array = kArray;
+    absl::c_nth_element(array, array.begin() + 2);
+    return array;
+  }();
+  static_assert(kArrayNthElement[2] == 3);
+  static_assert(kArrayNthElement[0] <= kArrayNthElement[2]);
+  static_assert(kArrayNthElement[1] <= kArrayNthElement[2]);
+  static_assert(kArrayNthElement[3] >= kArrayNthElement[2]);
+}
+
+TEST(ConstexprTest, NthElementWithPredicate) {
+  static constexpr std::array kArray = {1, 2, 3, 4};
+  static constexpr auto kArrayNthElement = [] {
+    std::array array = kArray;
+    absl::c_nth_element(array, array.begin() + 2, std::greater<>());
+    return array;
+  }();
+  static_assert(kArrayNthElement[2] == 2);
+  static_assert(std::greater<>()(kArrayNthElement[0], kArrayNthElement[2]) ||
+                kArrayNthElement[0] == kArrayNthElement[2]);
+  static_assert(std::greater<>()(kArrayNthElement[1], kArrayNthElement[2]) ||
+                kArrayNthElement[1] == kArrayNthElement[2]);
+  static_assert(std::greater<>()(kArrayNthElement[2], kArrayNthElement[3]) ||
+                kArrayNthElement[2] == kArrayNthElement[3]);
+}
+
+TEST(ConstexprTest, LowerBound) {
+  static constexpr std::array kArray = {1, 2, 3, 4};
+  static constexpr auto kLowerBound = absl::c_lower_bound(kArray, 2);
+  static_assert(kLowerBound == kArray.begin() + 1);
+}
+
+TEST(ConstexprTest, LowerBoundWithPredicate) {
+  static constexpr std::array kArray = {4, 3, 2, 1};
+  static constexpr auto kLowerBound =
+      absl::c_lower_bound(kArray, 2, std::greater<>());
+  static_assert(kLowerBound == kArray.begin() + 2);
+}
+
+TEST(ConstexprTest, UpperBound) {
+  static constexpr std::array kArray = {1, 2, 3, 4};
+  static constexpr auto kUpperBound = absl::c_upper_bound(kArray, 2);
+  static_assert(kUpperBound == kArray.begin() + 2);
+}
+
+TEST(ConstexprTest, UpperBoundWithPredicate) {
+  static constexpr std::array kArray = {4, 3, 2, 1};
+  static constexpr auto kUpperBound =
+      absl::c_upper_bound(kArray, 2, std::greater<>());
+  static_assert(kUpperBound == kArray.begin() + 3);
+}
+
+TEST(ConstexprTest, EqualRange) {
+  static constexpr std::array kArray = {1, 2, 3, 4};
+  static constexpr auto kEqualRange = absl::c_equal_range(kArray, 2);
+  static_assert(kEqualRange.first == kArray.begin() + 1);
+  static_assert(kEqualRange.second == kArray.begin() + 2);
+}
+
+TEST(ConstexprTest, EqualRangeWithPredicate) {
+  static constexpr std::array kArray = {4, 3, 2, 1};
+  static constexpr auto kEqualRange =
+      absl::c_equal_range(kArray, 2, std::greater<>());
+  static_assert(kEqualRange.first == kArray.begin() + 2);
+  static_assert(kEqualRange.second == kArray.begin() + 3);
+}
+
+TEST(ConstexprTest, BinarySearch) {
+  static constexpr std::array kArray = {1, 2, 3, 4};
+  static constexpr bool kBinarySearch = absl::c_binary_search(kArray, 2);
+  static_assert(kBinarySearch);
+}
+
+TEST(ConstexprTest, BinarySearchWithPredicate) {
+  static constexpr std::array kArray = {4, 3, 2, 1};
+  static constexpr bool kBinarySearch =
+      absl::c_binary_search(kArray, 2, std::greater<>());
+  static_assert(kBinarySearch);
+}
+
+TEST(ConstexprTest, Merge) {
+  static constexpr std::array kArray1 = {1, 2, 3};
+  static constexpr std::array kArray2 = {4, 5, 6};
+  static constexpr auto kArrayMerge = [] {
+    std::array<int, 6> array;
+    absl::c_merge(kArray1, kArray2, array.begin());
+    return array;
+  }();
+  static_assert(kArrayMerge == std::array{1, 2, 3, 4, 5, 6});
+}
+
+TEST(ConstexprTest, MergeWithPredicate) {
+  static constexpr std::array kArray1 = {3, 2, 1};
+  static constexpr std::array kArray2 = {6, 5, 4};
+  static constexpr auto kArrayMerge = [] {
+    std::array<int, 6> array;
+    absl::c_merge(kArray1, kArray2, array.begin(), std::greater<>());
+    return array;
+  }();
+  static_assert(kArrayMerge == std::array{6, 5, 4, 3, 2, 1});
+}
+
+TEST(ConstexprTest, Includes) {
+  static constexpr std::array kArray1 = {1, 2, 3, 4, 5, 6};
+  static constexpr std::array kArray2 = {2, 3, 5};
+  static constexpr bool kIncludes = absl::c_includes(kArray1, kArray2);
+  static_assert(kIncludes);
+}
+
+TEST(ConstexprTest, IncludesWithPredicate) {
+  static constexpr std::array kArray1 = {6, 5, 4, 3, 2, 1};
+  static constexpr std::array kArray2 = {5, 3, 2};
+  static constexpr bool kIncludes =
+      absl::c_includes(kArray1, kArray2, std::greater<>());
+  static_assert(kIncludes);
+}
+
+TEST(ConstexprTest, SetUnion) {
+  static constexpr std::array kArray1 = {1, 2, 3};
+  static constexpr std::array kArray2 = {1, 3, 4};
+  static constexpr auto kArraySetUnion = [] {
+    std::array<int, 4> array;
+    absl::c_set_union(kArray1, kArray2, array.begin());
+    return array;
+  }();
+  static_assert(kArraySetUnion == std::array{1, 2, 3, 4});
+}
+
+TEST(ConstexprTest, SetUnionWithPredicate) {
+  static constexpr std::array kArray1 = {3, 2, 1};
+  static constexpr std::array kArray2 = {4, 3, 1};
+  static constexpr auto kArraySetUnion = [] {
+    std::array<int, 4> array;
+    absl::c_set_union(kArray1, kArray2, array.begin(), std::greater<>());
+    return array;
+  }();
+  static_assert(kArraySetUnion == std::array{4, 3, 2, 1});
+}
+
+TEST(ConstexprTest, SetIntersection) {
+  static constexpr std::array kArray1 = {1, 2, 3};
+  static constexpr std::array kArray2 = {1, 3, 4};
+  static constexpr auto kArraySetIntersection = [] {
+    std::array<int, 2> array;
+    absl::c_set_intersection(kArray1, kArray2, array.begin());
+    return array;
+  }();
+  static_assert(kArraySetIntersection == std::array{1, 3});
+}
+
+TEST(ConstexprTest, SetIntersectionWithPredicate) {
+  static constexpr std::array kArray1 = {3, 2, 1};
+  static constexpr std::array kArray2 = {4, 3, 1};
+  static constexpr auto kArraySetIntersection = [] {
+    std::array<int, 2> array;
+    absl::c_set_intersection(kArray1, kArray2, array.begin(), std::greater<>());
+    return array;
+  }();
+  static_assert(kArraySetIntersection == std::array{3, 1});
+}
+
+TEST(ConstexprTest, SetDifference) {
+  static constexpr std::array kArray1 = {1, 2, 3};
+  static constexpr std::array kArray2 = {1, 3, 4};
+  static constexpr auto kArraySetDifference = [] {
+    std::array<int, 1> array;
+    absl::c_set_difference(kArray1, kArray2, array.begin());
+    return array;
+  }();
+  static_assert(kArraySetDifference == std::array{2});
+}
+
+TEST(ConstexprTest, SetDifferenceWithPredicate) {
+  static constexpr std::array kArray1 = {3, 2, 1};
+  static constexpr std::array kArray2 = {4, 3, 1};
+  static constexpr auto kArraySetDifference = [] {
+    std::array<int, 1> array;
+    absl::c_set_difference(kArray1, kArray2, array.begin(), std::greater<>());
+    return array;
+  }();
+  static_assert(kArraySetDifference == std::array{2});
+}
+
+TEST(ConstexprTest, SetSymmetricDifference) {
+  static constexpr std::array kArray1 = {1, 2, 3};
+  static constexpr std::array kArray2 = {1, 3, 4};
+  static constexpr auto kArraySetSymmetricDifference = [] {
+    std::array<int, 2> array;
+    absl::c_set_symmetric_difference(kArray1, kArray2, array.begin());
+    return array;
+  }();
+  static_assert(kArraySetSymmetricDifference == std::array{2, 4});
+}
+
+TEST(ConstexprTest, SetSymmetricDifferenceWithPredicate) {
+  static constexpr std::array kArray1 = {3, 2, 1};
+  static constexpr std::array kArray2 = {4, 3, 1};
+  static constexpr auto kArraySetSymmetricDifference = [] {
+    std::array<int, 2> array;
+    absl::c_set_symmetric_difference(kArray1, kArray2, array.begin(),
+                                     std::greater<>());
+    return array;
+  }();
+  static_assert(kArraySetSymmetricDifference == std::array{4, 2});
+}
+
+TEST(ConstexprTest, PushHeap) {
+  static constexpr auto kArray = [] {
+    std::array array = {1, 2, 3, 4};
+    absl::c_push_heap(array);
+    return array;
+  }();
+  static_assert(kArray[0] == 4);
+}
+
+TEST(ConstexprTest, PushHeapWithPredicate) {
+  static constexpr auto kArray = [] {
+    std::array array = {4, 3, 2, 1};
+    absl::c_push_heap(array, std::greater<>());
+    return array;
+  }();
+  static_assert(kArray[0] == 1);
+}
+
+TEST(ConstexprTest, PopHeap) {
+  static constexpr auto kArray = [] {
+    std::array array = {4, 3, 2, 1};
+    absl::c_pop_heap(array);
+    return array;
+  }();
+  static_assert(kArray[3] == 4);
+}
+
+TEST(ConstexprTest, PopHeapWithPredicate) {
+  static constexpr auto kArray = [] {
+    std::array array = {1, 2, 3, 4};
+    absl::c_pop_heap(array, std::greater<>());
+    return array;
+  }();
+  static_assert(kArray[3] == 1);
+}
+
+TEST(ConstexprTest, MakeHeap) {
+  static constexpr auto kArray = [] {
+    std::array array = {1, 2, 3, 4};
+    absl::c_make_heap(array);
+    return array;
+  }();
+  static_assert(absl::c_is_heap(kArray));
+}
+
+TEST(ConstexprTest, MakeHeapWithPredicate) {
+  static constexpr auto kArray = [] {
+    std::array array = {4, 3, 2, 1};
+    absl::c_make_heap(array, std::greater<>());
+    return array;
+  }();
+  static_assert(absl::c_is_heap(kArray, std::greater<>()));
+}
+
+TEST(ConstexprTest, SortHeap) {
+  static constexpr auto kArray = [] {
+    std::array array = {1, 2, 3, 4};
+    absl::c_make_heap(array);
+    absl::c_sort_heap(array);
+    return array;
+  }();
+  static_assert(kArray == std::array{1, 2, 3, 4});
+}
+
+TEST(ConstexprTest, SortHeapWithPredicate) {
+  static constexpr auto kArray = [] {
+    std::array array = {4, 3, 2, 1};
+    absl::c_make_heap(array, std::greater<>());
+    absl::c_sort_heap(array, std::greater<>());
+    return array;
+  }();
+  static_assert(kArray == std::array{4, 3, 2, 1});
+}
+
+TEST(ConstexprTest, IsHeap) {
+  static constexpr std::array kHeap = {4, 2, 3, 1};
+  static_assert(absl::c_is_heap(kHeap));
+  static constexpr std::array kNotHeap = {1, 2, 3, 4};
+  static_assert(!absl::c_is_heap(kNotHeap));
+}
+
+TEST(ConstexprTest, IsHeapWithPredicate) {
+  static constexpr std::array kHeap = {1, 2, 3, 4};
+  static_assert(absl::c_is_heap(kHeap, std::greater<>()));
+  static constexpr std::array kNotHeap = {4, 3, 2, 1};
+  static_assert(!absl::c_is_heap(kNotHeap, std::greater<>()));
+}
+
+TEST(ConstexprTest, IsHeapUntil) {
+  static constexpr std::array kHeap = {4, 2, 3, 1};
+  static_assert(absl::c_is_heap_until(kHeap) == kHeap.end());
+  static constexpr std::array kNotHeap = {4, 2, 3, 5};
+  static_assert(absl::c_is_heap_until(kNotHeap) == kNotHeap.begin() + 3);
+}
+
+TEST(ConstexprTest, IsHeapUntilWithPredicate) {
+  static constexpr std::array kHeap = {1, 2, 3, 4};
+  static_assert(absl::c_is_heap_until(kHeap, std::greater<>()) == kHeap.end());
+  static constexpr std::array kNotHeap = {1, 2, 3, 0};
+  static_assert(absl::c_is_heap_until(kNotHeap, std::greater<>()) ==
+                kNotHeap.begin() + 3);
+}
+
+TEST(ConstexprTest, LexicographicalCompare) {
+  static constexpr std::array kArray1 = {1, 2, 3};
+  static constexpr std::array kArray2 = {1, 2, 4};
+  static constexpr std::array kArray3 = {1, 2, 3};
+  static_assert(absl::c_lexicographical_compare(kArray1, kArray2));
+  static_assert(!absl::c_lexicographical_compare(kArray2, kArray1));
+  static_assert(!absl::c_lexicographical_compare(kArray1, kArray3));
+}
+
+TEST(ConstexprTest, LexicographicalCompareWithPredicate) {
+  static constexpr std::array kArray1 = {1, 2, 3};
+  static constexpr std::array kArray2 = {1, 2, 4};
+  static constexpr std::array kArray3 = {1, 2, 3};
+  static_assert(
+      !absl::c_lexicographical_compare(kArray1, kArray2, std::greater<>()));
+  static_assert(
+      absl::c_lexicographical_compare(kArray2, kArray1, std::greater<>()));
+  static_assert(
+      !absl::c_lexicographical_compare(kArray1, kArray3, std::greater<>()));
+}
+
+TEST(ConstexprTest, NextPermutation) {
+  static constexpr auto kArray = [] {
+    std::array array = {1, 2, 3};
+    absl::c_next_permutation(array);
+    return array;
+  }();
+  static_assert(kArray == std::array{1, 3, 2});
+}
+
+TEST(ConstexprTest, NextPermutationWithPredicate) {
+  static constexpr auto kArray = [] {
+    std::array array = {3, 2, 1};
+    absl::c_next_permutation(array, std::greater<>());
+    return array;
+  }();
+  static_assert(kArray == std::array{3, 1, 2});
+}
+
+TEST(ConstexprTest, PrevPermutation) {
+  static constexpr auto kArray = [] {
+    std::array array = {1, 3, 2};
+    absl::c_prev_permutation(array);
+    return array;
+  }();
+  static_assert(kArray == std::array{1, 2, 3});
+}
+
+TEST(ConstexprTest, PrevPermutationWithPredicate) {
+  static constexpr auto kArray = [] {
+    std::array array = {1, 2, 3};
+    absl::c_prev_permutation(array, std::greater<>());
+    return array;
+  }();
+  static_assert(kArray == std::array{1, 3, 2});
+}
+
+TEST(ConstexprTest, Iota) {
+  static constexpr auto kArray = [] {
+    std::array<int, 3> array;
+    absl::c_iota(array, 1);
+    return array;
+  }();
+  static_assert(kArray == std::array{1, 2, 3});
+}
+
+TEST(ConstexprTest, Accumulate) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static_assert(absl::c_accumulate(kArray, 0) == 6);
+}
+
+TEST(ConstexprTest, AccumulateWithPredicate) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static_assert(absl::c_accumulate(kArray, 1, std::multiplies<>()) == 6);
+}
+
+TEST(ConstexprTest, InnerProduct) {
+  static constexpr std::array kArray1 = {1, 2, 3};
+  static constexpr std::array kArray2 = {4, 5, 6};
+  static_assert(absl::c_inner_product(kArray1, kArray2, 0) == 32);
+}
+
+TEST(ConstexprTest, InnerProductWithPredicate) {
+  static constexpr std::array kArray1 = {1, 2, 3};
+  static constexpr std::array kArray2 = {4, 5, 6};
+  static_assert(absl::c_inner_product(kArray1, kArray2, 1, std::multiplies<>(),
+                                      std::plus<>()) == 315);
+}
+
+TEST(ConstexprTest, AdjacentDifference) {
+  static constexpr std::array kArray = {1, 2, 4};
+  static constexpr auto kArrayAdjacentDifference = [] {
+    std::array<int, 3> array;
+    absl::c_adjacent_difference(kArray, array.begin());
+    return array;
+  }();
+  static_assert(kArrayAdjacentDifference == std::array{1, 1, 2});
+}
+
+TEST(ConstexprTest, AdjacentDifferenceWithPredicate) {
+  static constexpr std::array kArray = {1, 2, 4};
+  static constexpr auto kArrayAdjacentDifference = [] {
+    std::array<int, 3> array;
+    absl::c_adjacent_difference(kArray, array.begin(), std::multiplies<>());
+    return array;
+  }();
+  static_assert(kArrayAdjacentDifference == std::array{1, 2, 8});
+}
+
+TEST(ConstexprTest, PartialSum) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayPartialSum = [] {
+    std::array<int, 3> array;
+    absl::c_partial_sum(kArray, array.begin());
+    return array;
+  }();
+  static_assert(kArrayPartialSum == std::array{1, 3, 6});
+}
+
+TEST(ConstexprTest, PartialSumWithPredicate) {
+  static constexpr std::array kArray = {1, 2, 3};
+  static constexpr auto kArrayPartialSum = [] {
+    std::array<int, 3> array;
+    absl::c_partial_sum(kArray, array.begin(), std::multiplies<>());
+    return array;
+  }();
+  static_assert(kArrayPartialSum == std::array{1, 2, 6});
+}
+
 #endif  // defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&
         //  ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L