[libcxx] [test] Include missing <limits> header.

[amakc11]

Summary

The C++ standard requires the class template numeric_limits to be located in the <limits> header. Some tests use this class template, but do not include this header directly. As a result, these tests don't compile against some compatible libraries. This patch fixes the problem.

[mclow.lists]

LGTM

[amakc11]

I have no commit access to Monorepo. Somebody should commit this revision. Thanks.

[amakc11]

Detected one more file missing this header. Diff is updated.

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp

 // void last_write_time(const path& p, file_time_type new_type,
 //                      std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <chrono>
 #include <fstream>
 #include <cstdlib>
+#include <limits>
 
 #include "test_macros.h"
 #include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 #include <sys/stat.h>
 #include <iostream>
 

libcxx/test/std/iterators/iterator.container/ssize.pass.cpp

 // template <class C> constexpr auto ssize(const C& c)
 //     -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>;                    // C++20
 // template <class T, ptrdiff_t> constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept; // C++20
 
 #include <iterator>
 #include <cassert>
 #include <vector>
 #include <array>
+#include <limits>
 #include <list>
 #include <initializer_list>
 #include <string_view>
 
 #include "test_macros.h"
 
 
 struct short_container {

libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp

 // The number of consecutive 1 bits, starting from the most significant bit.
 //   [ Note: Returns N if x == std::numeric_limits<T>::max(). ]
 //
 // Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
 #include <cstdint>
+#include <limits>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };

libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp

 // Returns: The number of consecutive 0 bits, starting from the most significant bit.
 //   [ Note: Returns N if x == 0. ]
 //
 // Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
 #include <cstdint>
+#include <limits>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };

libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp

 // Returns: The number of consecutive 1 bits, starting from the least significant bit.
 //   [ Note: Returns N if x == std::numeric_limits<T>::max(). ]
 //
 // Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
 #include <cstdint>
+#include <limits>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };

libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp

 // Returns: The number of consecutive 0 bits, starting from the most significant bit.
 //   [ Note: Returns N if x == 0. ]
 //
 // Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
 #include <cstdint>
+#include <limits>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };

libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp

 
 // Returns: The number of bits set to one in the value of x.
 //
 // Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
 #include <cstdint>
+#include <limits>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };

libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp

 // template <class T>
 //   constexpr int rotl(T x, unsigned int s) noexcept;
 
 // Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
 #include <cstdint>
+#include <limits>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };

libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp

 // template <class T>
 //   constexpr int rotr(T x, unsigned int s) noexcept;
 
 // Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
 #include <cstdint>
+#include <limits>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 // <numeric>
 
 // template <class _Float>
 // _Tp midpoint(_Float __a, _Float __b) noexcept
 //
 
+#include <limits>
 #include <numeric>
 #include <cassert>
 
 #include "test_macros.h"
 #include "fp_compare.h"
 
 //  Totally arbitrary picks for precision
 template <typename T>

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/max.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class IntType = int>
 // class geometric_distribution
 
 // result_type max() const;
 
 #include <random>
+#include <limits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
         D d(.25);
         assert(d.max() == std::numeric_limits<int>::max());
     }
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class IntType = int>
 // class negative_binomial_distribution
 
 // result_type max() const;
 
 #include <random>
+#include <limits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
         D d(4, .25);
         assert(d.max() == std::numeric_limits<int>::max());
     }
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/max.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class exponential_distribution
 
 // result_type max() const;
 
 #include <random>
+#include <limits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
         D d(.25);
         D::result_type m = d.max();
         assert(m == std::numeric_limits<D::result_type>::infinity());
     }
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class IntType = int>
 // class poisson_distribution
 
 // result_type max() const;
 
 #include <random>
+#include <limits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
         D d(.25);
         D::result_type m = d.max();
         assert(m == std::numeric_limits<int>::max());
     }
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp

 
 // template<class _IntType = int>
 // class uniform_int_distribution
 
 // explicit uniform_int_distribution(IntType a = 0,
 //                                   IntType b = numeric_limits<IntType>::max());
 
 #include <random>
+#include <limits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;

libcxx/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType, size_t bits, class URNG>
 //     RealType generate_canonical(URNG& g);
 
 #include <random>
+#include <limits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "truncate_fp.h"
 
 int main(int, char**)
 {
     {

libcxx/test/std/strings/string.conversions/stoi.pass.cpp

 // int stoi(const string& str, size_t *idx = 0, int base = 10);
 // int stoi(const wstring& str, size_t *idx = 0, int base = 10);
 
 // When back-deploying to macosx10.7, the RTTI for exception classes
 // incorrectly provided by libc++.dylib is mixed with the one in
 // libc++abi.dylib and exceptions are not caught properly.
 // XFAIL: with_system_cxx_lib=macosx10.7
 
+#include <limits>
 #include <string>
 #include <cassert>
 #include <stdexcept>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {

libcxx/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp

 // XFAIL: with_system_cxx_lib=macosx10.8
 // XFAIL: with_system_cxx_lib=macosx10.7
 
 // <charconv>
 
 // from_chars_result from_chars(const char* first, const char* last,
 //                              Integral& value, int base = 10)
 
+#include <limits>
+
 #include "test_macros.h"
 #include "charconv_test_helpers.h"
 
 template <typename T>
 struct test_basics : roundtrip_test_base<T>
 {
     using roundtrip_test_base<T>::test;
 

libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp

 // XFAIL: with_system_cxx_lib=macosx10.8
 // XFAIL: with_system_cxx_lib=macosx10.7
 
 // <charconv>
 
 // to_chars_result to_chars(char* first, char* last, Integral value,
 //                          int base = 10)
 
+#include <limits>
+
 #include "test_macros.h"
 #include "charconv_test_helpers.h"
 
 template <typename T>
 struct test_basics : to_chars_test_base<T>
 {
     using to_chars_test_base<T>::test;
     using to_chars_test_base<T>::test_value;