[libc++] Extend check for non-ASCII characters to src/, test/ and benchmarks/

[Mordante]

Thanks for working on this! LGTM!

libcxx/utils/ci/run-buildbot

193

I like this exclusion list!

[ldionne]

The CI failure is a timeout. Shipping this.

libcxx/benchmarks/algorithms/common.h

static constexpr const char* Names[] = {"Random",     "Ascending",
                                           "PipeOrgan",  "Heap",
                                           "QuickSortAdversary"};
 };
 
 // fillAdversarialQuickSortInput fills the input vector with N int-like values.
 // These values are arranged in such a way that they would invoke O(N^2)
 // behavior on any quick sort implementation that satisifies certain conditions.
 // Details are available in the following paper:
-// "A Killer Adversary for Quicksort", M. D. McIlroy, Software—Practice &
-// ExperienceVolume 29 Issue 4 April 10, 1999 pp 341–344.
+// "A Killer Adversary for Quicksort", M. D. McIlroy, Software-Practice &
+// Experience Volume 29 Issue 4 April 10, 1999 pp 341-344.
 // https://dl.acm.org/doi/10.5555/311868.311871.
 template <class T>
 void fillAdversarialQuickSortInput(T& V, size_t N) {
   assert(N > 0);
   // If an element is equal to gas, it indicates that the value of the element
   // is still to be decided and may change over the course of time.
   const unsigned int gas = N - 1;
   V.resize(N);

libcxx/benchmarks/formatter_float.bench.cpp

 
 template <>
 struct Precision<PrecisionE::Small> {
   static constexpr const char* fmt = ".10";
 };
 
 template <>
 struct Precision<PrecisionE::Huge> {
-  // The maximum precision for a minimal sub normal long double is ±0x1p-16494.
+  // The maximum precision for a minimal sub normal long double is +/- 0x1p-16494.
   // This value is always larger than that value forcing the trailing zero path
   // to be executed.
   static constexpr const char* fmt = ".17000";
 };
 
 template <class L, class DT, class T, class V, class A, class P>
 struct FloatingPoint {
   using F = typename Type<T::value>::type;

libcxx/src/atomic.cpp

static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile* __ptr,
                                               bool __notify_one)
 {
     syscall(SYS_futex, __ptr, FUTEX_WAKE_PRIVATE, __notify_one ? 1 : INT_MAX, 0, 0, 0);
 }
 
 #elif defined(__APPLE__) && defined(_LIBCPP_USE_ULOCK)
 
 extern "C" int __ulock_wait(uint32_t operation, void *addr, uint64_t value,
-    uint32_t timeout); /* timeout is specified in microseconds */
+                            uint32_t timeout); /* timeout is specified in microseconds */
 extern "C" int __ulock_wake(uint32_t operation, void *addr, uint64_t wake_value);
 
-#define UL_COMPARE_AND_WAIT       1
-#define ULF_WAKE_ALL          0x00000100
+#define UL_COMPARE_AND_WAIT 1
+#define ULF_WAKE_ALL        0x00000100
 
 static void __libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr,
                                               __cxx_contention_t __val)
 {
     __ulock_wait(UL_COMPARE_AND_WAIT,
                  const_cast<__cxx_atomic_contention_t*>(__ptr), __val, 0);
 }
 

libcxx/src/charconv.cpp

 #ifndef _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
 
 namespace __itoa
 {
 
 _LIBCPP_FUNC_VIS char*
 __u32toa(uint32_t value, char* buffer) noexcept
 {
-  return __base_10_u32(buffer, value);
+  return __base_10_u32(buffer, value);
 }
 
 _LIBCPP_FUNC_VIS char*
 __u64toa(uint64_t value, char* buffer) noexcept
 {
-  return __base_10_u64(buffer, value);
+  return __base_10_u64(buffer, value);
 }
 
 }  // namespace __itoa
 
 #endif // _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
 
 // The original version of floating-point to_chars was written by Microsoft and
 // contributed with the following license.

libcxx/src/ios.cpp

 atomic<int> ios_base::__xindex_{0};
 #else
 int ios_base::__xindex_ = 0;
 #endif
 
 template <typename _Tp>
 static size_t __ios_new_cap(size_t __req_size, size_t __current_cap)
 { // Precondition: __req_size > __current_cap
-  const size_t mx = std::numeric_limits<size_t>::max() / sizeof(_Tp);
-  if (__req_size < mx/2)
-    return _VSTD::max(2 * __current_cap, __req_size);
-  else
-    return mx;
+    const size_t mx = std::numeric_limits<size_t>::max() / sizeof(_Tp);
+    if (__req_size < mx/2)
+        return _VSTD::max(2 * __current_cap, __req_size);
+    else
+        return mx;
 }
 
 int
 ios_base::xalloc()
 {
     return __xindex_++;
 }
 

libcxx/src/iostream.cpp

static bool once = []() {
     return true;
   }();
   ((void)once);
 #endif
 }
 
 class DoIOSInit {
 public:
-  DoIOSInit();
-  ~DoIOSInit();
+    DoIOSInit();
+    ~DoIOSInit();
 };
 
 DoIOSInit::DoIOSInit()
 {
     force_locale_initialization();
 
     istream* cin_ptr  = ::new(cin)  istream(::new(__cin)  __stdinbuf <char>(stdin, &mb_cin));
     ostream* cout_ptr = ::new(cout) ostream(::new(__cout) __stdoutbuf<char>(stdout, &mb_cout));

libcxx/src/locale.cpp

 const char __num_get_base::__src[33] = "0123456789abcdefABCDEFxX+-pPiInN";
 
 void
 __check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end,
                  ios_base::iostate& __err)
 {
 //  if the grouping pattern is empty _or_ there are no grouping bits, then do nothing
 //  we always have at least a single entry in [__g, __g_end); the end of the input sequence
-  if (__grouping.size() != 0 && __g_end - __g > 1)
+    if (__grouping.size() != 0 && __g_end - __g > 1)
     {
         reverse(__g, __g_end);
         const char* __ig = __grouping.data();
         const char* __eg = __ig + __grouping.size();
         for (unsigned* __r = __g; __r < __g_end-1; ++__r)
         {
             if (0 < *__ig && *__ig < numeric_limits<char>::max())
             {

 
 void
 __num_put_base::__format_int(char* __fmtp, const char* __len, bool __signd,
                              ios_base::fmtflags __flags)
 {
     if ((__flags & ios_base::showpos) &&
         (__flags & ios_base::basefield) != ios_base::oct &&
         (__flags & ios_base::basefield) != ios_base::hex &&
-  __signd)
+        __signd)
         *__fmtp++ = '+';
     if (__flags & ios_base::showbase)
         *__fmtp++ = '#';
     while(*__len)
         *__fmtp++ = *__len++;
     if ((__flags & ios_base::basefield) == ios_base::oct)
         *__fmtp = 'o';
     else if ((__flags & ios_base::basefield) == ios_base::hex)

libcxx/src/optional.cpp

 
 namespace std
 {
 
 bad_optional_access::~bad_optional_access() noexcept = default;
 
 const char* bad_optional_access::what() const noexcept {
   return "bad_optional_access";
-  }
 
 } // std
 
 
 #include <experimental/__config>
 
 //  Preserve std::experimental::bad_optional_access for ABI compatibility
 //  Even though it no longer exists in a header file
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
 
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
-    : public std::logic_error
 {
 public:
-  bad_optional_access() : std::logic_error("Bad optional Access") {}
+  bad_optional_access() : std::logic_error("Bad optional Access") {}
 
-//  Get the key function ~bad_optional_access() into the dylib
-    virtual ~bad_optional_access() noexcept;
+  // Get the key function ~bad_optional_access() into the dylib
 };
 
 bad_optional_access::~bad_optional_access() noexcept = default;
 
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL

libcxx/test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp

 #include <__config>
 
 #include "test_macros.h"
 
 _LIBCPP_NODISCARD_AFTER_CXX17 int foo() { return 6; }
 
 int main(int, char**)
 {
-  foo();  // no error here!
+  foo(); // no error here!
 
   return 0;
 }

libcxx/test/libcxx/diagnostics/nodiscard_aftercxx17.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // Test that _LIBCPP_NODISCARD_AFTER_CXX17 works
-//  #define _LIBCPP_NODISCARD_AFTER_CXX17 [[nodiscard]]
+// #define _LIBCPP_NODISCARD_AFTER_CXX17 [[nodiscard]]
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <__config>
 
 _LIBCPP_NODISCARD_AFTER_CXX17 int foo() { return 6; }
 
 int main(int, char**)
 {
     foo(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp

 //   class basic_filebuf;
 //
 // The char type of the stream and the char_type of the traits have to match
 
 #include <fstream>
 
 int main(int, char**)
 {
-  std::basic_filebuf<char, std::char_traits<wchar_t> > f;
-//  expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
+  std::basic_filebuf<char, std::char_traits<wchar_t> > f;
+  // expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
 
   return 0;
 }

libcxx/test/libcxx/input.output/file.streams/fstreams/fstream.close.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
 //
 //===----------------------------------------------------------------------===//
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_fstream
 
 // close();
 
-//  Inspired by PR#38052 - std::fstream still good after closing and updating content
+// Inspired by PR#38052 - std::fstream still good after closing and updating content
 
 #include <fstream>
 #include <cassert>
 #include "test_macros.h"
 #include "platform_support.h"
 
 int main(int, char**)
 {
     std::string temp = get_temp_file_name();
 
     std::fstream ofs(temp, std::ios::out | std::ios::trunc);
     ofs << "Hello, World!\n";
     assert( ofs.good());
     ofs.close();
     assert( ofs.good());
     ofs << "Hello, World!\n";
     assert(!ofs.good());
 
     std::remove(temp.c_str());
 
     return 0;
 }

libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp

 // class basic_fstream
 
 // The char type of the stream and the char_type of the traits have to match
 
 #include <fstream>
 
 int main(int, char**)
 {
-  std::basic_fstream<char, std::char_traits<wchar_t> > f;
+  std::basic_fstream<char, std::char_traits<wchar_t> > f;
 //  expected-error-re@ios:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
 //  expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
 
 // FIXME: As of commit r324062 Clang incorrectly generates a diagnostic about mismatching
 // exception specifications for types which are already invalid for one reason or another.
 // For now we tolerate this diagnostic.
 // expected-error@ostream:* 0-1 {{exception specification of overriding function is more lax than base version}}
 
   return 0;
 }

libcxx/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp

 // The char type of the stream and the char_type of the traits have to match
 
 // UNSUPPORTED: no-wide-characters
 
 #include <sstream>
 
 int main(int, char**)
 {
-  std::basic_stringbuf<char, std::char_traits<wchar_t> > sb;
+  std::basic_stringbuf<char, std::char_traits<wchar_t> > sb;
 //  expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
 //  expected-error-re@string:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
 
   return 0;
 }

libcxx/test/libcxx/iterators/assert.advance.pass.cpp

 
 #include "check_assertion.h"
 #include "test_iterators.h"
 
 int main(int, char**) {
     int a[] = {1, 2, 3};
 
     bidirectional_iterator<int *> bidi(a+1);
-  std::advance(bidi,  1);  // should work fine
-  std::advance(bidi,  0);  // should work fine
+    std::advance(bidi,  1);  // should work fine
+    std::advance(bidi,  0);  // should work fine
     std::advance(bidi, -1);  // should work fine
 
     forward_iterator<int *> it(a+1);
-  std::advance(it, 1);  // should work fine
-  std::advance(it, 0);  // should work fine
+    std::advance(it, 1);  // should work fine
+    std::advance(it, 0);  // should work fine
     TEST_LIBCPP_ASSERT_FAILURE(std::advance(it, -1), "Attempt to advance(it, n) with negative n on a non-bidirectional iterator");
 
     return 0;
 }

libcxx/test/libcxx/iterators/iterator.requirements/iterator.concepts/iterator.concept.random.access/contiguous_iterator.verify.cpp

struct no_element_type {
     self operator-(difference_type n) const;
     difference_type operator-(const self& n) const;
 
     reference operator[](difference_type n) const;
 };
 
 void test() {
     (void) std::contiguous_iterator<no_element_type>;
-    // expected-error@*:* {{implicit instantiation of undefined template}}
-    // expected-note@*:* {{to_address}}
+        // expected-error@*:* {{implicit instantiation of undefined template}}
+        // expected-note@*:* {{to_address}}
 }

libcxx/test/libcxx/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/failed.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
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // class ostreambuf_iterator
 
 // bool failed() const throw();
 //
-//  Extension: constructing from NULL is UB; we just make it a failed iterator
+// Extension: constructing from NULL is UB; we just make it a failed iterator
 
 #include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {

libcxx/test/libcxx/memory/is_allocator.pass.cpp

 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 
 template <typename T>
 void test_allocators()
 {
-  static_assert(!std::__is_allocator<T>::value, "" );
-  static_assert( std::__is_allocator<std::allocator<T>>::value, "" );
-  static_assert( std::__is_allocator<test_allocator<T>>::value, "" );
-  static_assert( std::__is_allocator<min_allocator<T>>::value, "" );
+    static_assert(!std::__is_allocator<T>::value, "" );
+    static_assert( std::__is_allocator<std::allocator<T>>::value, "" );
+    static_assert( std::__is_allocator<test_allocator<T>>::value, "" );
+    static_assert( std::__is_allocator<min_allocator<T>>::value, "" );
 }
 
 
 int main(int, char**)
 {
-//  test_allocators<void>();
-  test_allocators<char>();
-  test_allocators<int>();
-  test_allocators<std::string>();
+    // test_allocators<void>();
+    test_allocators<char>();
+    test_allocators<int>();
+    test_allocators<std::string>();
 
     return 0;
 }

libcxx/test/std/algorithms/alg.sorting/alg.merge/ranges_inplace_merge.pass.cpp

requires(Iter&& iter, Middle&& mid, Sent&& sent, Comp&& comp, Proj&& proj) {
           std::forward<Middle>(mid),
           std::forward<Sent>(sent),
           std::forward<Comp>(comp),
           std::forward<Proj>(proj));
     };
 
 static_assert(HasInplaceMergeIter<int*, int*, int*>);
 
-// !bidirectional_­iterator<I>
+// !bidirectional_iterator<I>
 static_assert(!HasInplaceMergeIter<BidirectionalIteratorNotDerivedFrom>);
 static_assert(!HasInplaceMergeIter<cpp20_input_iterator<int*>>);
 
 // !sentinel_for<S, I>
 static_assert(!HasInplaceMergeIter<int*, int*, SentinelForNotSemiregular>);
 static_assert(!HasInplaceMergeIter<int*, int*, SentinelForNotWeaklyEqualityComparableWith>);
 
 // !sortable<I, Comp, Proj>
// range overload
       assert(std::ranges::equal(in, std::array{0, 0, 1, 1, 2, 2}, {}, &IntAndID::data));
       assert(std::ranges::equal(in, std::array{0, 1, 0, 1, 0, 1}, {}, &IntAndID::id));
       assert(result == in.end());
     }
   }
 
   // Complexity: Let N = last - first :
   //   - For the overloads with no ExecutionPolicy, and if enough
-  //     additional memory is available, exactly N − 1 comparisons.
+  //     additional memory is available, exactly N - 1 comparisons.
   //   - Otherwise, O(NlogN) comparisons.
   // In either case, twice as many projections as comparisons.
   {
     std::array input{1, 2, 3, 3, 3, 7, 7, 2, 2, 5, 5, 6, 6};
     std::array expected{1, 2, 2, 2, 3, 3, 3, 5, 5, 6, 6, 7, 7};
     auto mid = 7;
     // iterator overload
     {

libcxx/test/std/algorithms/alg.sorting/alg.nth.element/ranges_nth_element.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++03, c++11, c++14, c++17
 
 // <algorithm>
 
-// template<random_­access_­iterator I, sentinel_­for<I> S, class Comp = ranges::less,
+// template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
 //         class Proj = identity>
 //   requires sortable<I, Comp, Proj>
 //   constexpr I
 //     ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});            // since C++20
 //
-// template<random_­access_­range R, class Comp = ranges::less, class Proj = identity>
+// template<random_access_range R, class Comp = ranges::less, class Proj = identity>
 //   requires sortable<iterator_t<R>, Comp, Proj>
 //   constexpr borrowed_iterator_t<R>
 //     ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});          // since C++20
 
 #include <algorithm>
 #include <array>
 #include <concepts>
 #include <functional>

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/ranges_set_union.pass.cpp

struct IntAndOrder {
 
     constexpr auto operator==(const IntAndOrder& o) const { return data == o.data; }
     constexpr auto operator<=>(const IntAndOrder& o) const { return data <=> o.data; }
   };
 
   // Stable ([algorithm.stable]). If [first1, last1) contains m elements that are
   // equivalent to each other and [first2, last2) contains n elements that are
   // equivalent to them, then all m elements from the first range are copied to the
-  // output range, in order, and then the final max(n−m,0) elements from the second
+  // output range, in order, and then the final max(n-m,0) elements from the second
   // range are copied to the output range, in order.
   {
     std::array<IntAndOrder, 3> r1{{{0, 0}, {0, 1}, {0, 2}}};
     std::array<IntAndOrder, 5> r2{{{0, 3}, {0, 4}, {0, 5}, {0, 6}, {0, 7}}};
 
     // iterator overload
     {
       std::array<IntAndOrder, 5> out;

libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp

test_pointer_sort()
     assert(*pv[1] == v[1]);
     assert(*pv[array_size - 1] == v[array_size - 1]);
 }
 
 // test_adversarial_quicksort generates a vector with values arranged in such a
 // way that they would invoke O(N^2) behavior on any quick sort implementation
 // that satisifies certain conditions.  Details are available in the following
 // paper:
-// "A Killer Adversary for Quicksort", M. D. McIlroy, Software—Practice &
-// ExperienceVolume 29 Issue 4 April 10, 1999 pp 341–344.
+// "A Killer Adversary for Quicksort", M. D. McIlroy, Software-Practice &
+// Experience Volume 29 Issue 4 April 10, 1999 pp 341-344.
 // https://dl.acm.org/doi/10.5555/311868.311871.
 struct AdversaryComparator {
   AdversaryComparator(int N, std::vector<int>& input) : gas(N - 1), V(input) {
     V.resize(N);
     // Populate all positions in the generated input to gas to indicate that
     // none of the values have been fixed yet.
     for (int i = 0; i < N; ++i)
       V[i] = gas;

libcxx/test/std/containers/sequences/list/list.ops/remove.pass.cpp

 int main(int, char**) {
   {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {1, 2, 4};
     typedef std::list<int> L;
     L c(a1, a1 + 4);
 #if TEST_STD_VER > 17
     assert(c.remove(3) == 1);
-  ASSERT_SAME_TYPE(L::size_type, decltype(c.remove(3)));
+    ASSERT_SAME_TYPE(L::size_type, decltype(c.remove(3)));
 #else
-  ASSERT_SAME_TYPE(void,         decltype(c.remove(3)));
+    ASSERT_SAME_TYPE(void,         decltype(c.remove(3)));
     c.remove(3);
 #endif
 
     assert(c == std::list<int>(a2, a2 + 3));
   }
   { // LWG issue #526
     int a1[] = {1, 2, 1, 3, 5, 8, 11};
     int a2[] = {2, 3, 5, 8, 11};

libcxx/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp

 {
     {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {3, 4};
     typedef std::list<int> L;
     L c(a1, a1+4);
     Predicate cp(g);
 #if TEST_STD_VER > 17
-  ASSERT_SAME_TYPE(L::size_type, decltype(c.remove_if(std::ref(cp))));
+    ASSERT_SAME_TYPE(L::size_type, decltype(c.remove_if(std::ref(cp))));
     assert(c.remove_if(std::ref(cp)) == 2);
 #else
-  ASSERT_SAME_TYPE(void, decltype(c.remove_if(std::ref(cp))));
+    ASSERT_SAME_TYPE(void, decltype(c.remove_if(std::ref(cp))));
     c.remove_if(std::ref(cp));
 #endif
     assert(c == std::list<int>(a2, a2+2));
     assert(cp.count() == 4);
     }
     {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {1, 3};

libcxx/test/std/containers/sequences/list/list.ops/unique.pass.cpp

 int main(int, char**)
 {
     {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
     int a2[] = {2, 1, 4, 3};
     typedef std::list<int> L;
     L c(a1, a1+sizeof(a1)/sizeof(a1[0]));
 #if TEST_STD_VER > 17
-  ASSERT_SAME_TYPE(L::size_type, decltype(c.unique()));
+    ASSERT_SAME_TYPE(L::size_type, decltype(c.unique()));
     assert(c.unique() == 5);
 #else
-  ASSERT_SAME_TYPE(void,         decltype(c.unique()));
+    ASSERT_SAME_TYPE(void,         decltype(c.unique()));
     c.unique();
 #endif
     assert(c == std::list<int>(a2, a2+4));
     }
 #if TEST_STD_VER >= 11
     {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
     int a2[] = {2, 1, 4, 3};

libcxx/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp

 int main(int, char**)
 {
     {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
     int a2[] = {2, 1, 4, 3};
     typedef std::list<int> L;
     L c(a1, a1+sizeof(a1)/sizeof(a1[0]));
 #if TEST_STD_VER > 17
-  ASSERT_SAME_TYPE(L::size_type, decltype(c.unique(g)));
+    ASSERT_SAME_TYPE(L::size_type, decltype(c.unique(g)));
     assert(c.unique(g) == 5);
 #else
-  ASSERT_SAME_TYPE(void,         decltype(c.unique(g)));
+    ASSERT_SAME_TYPE(void,         decltype(c.unique(g)));
     c.unique(g);
 #endif
     assert(c == std::list<int>(a2, a2+4));
     }
 
     { // LWG issue #526
     int a1[] = {1, 1, 1, 2, 3, 5, 5, 2, 11};
     int a2[] = {1,       2, 3, 5,    2, 11};

libcxx/test/std/containers/views/views.span/span.cons/array.fail.cpp

 // template<size_t N>
 //     constexpr span(element_type (&arr)[N]) noexcept;
 // template<size_t N>
 //     constexpr span(array<value_type, N>& arr) noexcept;
 // template<size_t N>
 //     constexpr span(const array<value_type, N>& arr) noexcept;
 //
 // Remarks: These constructors shall not participate in overload resolution unless:
-//   — extent == dynamic_extent || N == extent is true, and
-//   — remove_pointer_t<decltype(data(arr))>(*)[] is convertible to ElementType(*)[].
+//   - extent == dynamic_extent || N == extent is true, and
+//   - remove_pointer_t<decltype(data(arr))>(*)[] is convertible to ElementType(*)[].
 //
 
 
 #include <span>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"

libcxx/test/std/containers/views/views.span/span.cons/array.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++03, c++11, c++14, c++17
 
 // <span>
 
 // template<size_t N>
 //     constexpr span(element_type (&arr)[N]) noexcept;
 //
 // Remarks: These constructors shall not participate in overload resolution unless:
-//   — extent == dynamic_extent || N == extent is true, and
-//   — remove_pointer_t<decltype(data(arr))>(*)[] is convertible to ElementType(*)[].
+//   - extent == dynamic_extent || N == extent is true, and
+//   - remove_pointer_t<decltype(data(arr))>(*)[] is convertible to ElementType(*)[].
 //
 
 
 #include <span>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"

libcxx/test/std/containers/views/views.span/span.cons/stdarray.pass.cpp

 // <span>
 
 // template<size_t N>
 //     constexpr span(array<value_type, N>& arr) noexcept;
 // template<size_t N>
 //     constexpr span(const array<value_type, N>& arr) noexcept;
 //
 // Remarks: These constructors shall not participate in overload resolution unless:
-//   — extent == dynamic_extent || N == extent is true, and
-//   — remove_pointer_t<decltype(data(arr))>(*)[] is convertible to ElementType(*)[].
+//   - extent == dynamic_extent || N == extent is true, and
+//   - remove_pointer_t<decltype(data(arr))>(*)[] is convertible to ElementType(*)[].
 //
 
 
 #include <span>
 #include <array>
 #include <cassert>
 #include <string>
 

libcxx/test/std/experimental/utilities/meta/meta.detect/nonesuch.fail.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++03, c++11
 // <experimental/type_traits>
 //
 //  struct nonesuch;
-//    nonesuch has no default constructor (C++17 §15.1)
-//    or initializer-list constructor (C++17 §11.6.4),
-//    and is not an aggregate (C++17 §11.6.1).
+//    nonesuch has no default constructor (C++17 section 15.1)
+//    or initializer-list constructor (C++17 section 11.6.4),
+//    and is not an aggregate (C++17 section 11.6.1).
 
 
 #include <experimental/type_traits>
 #include <string>
 
 #include "test_macros.h"
 
 namespace ex = std::experimental;

libcxx/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp

#endif
       // p1: If the path is empty, stop.
       {"", ""},
       // p2: Replace each slash character in the root-name with a preferred
       // separator.
       {"NO_ROOT_NAME_ON_LINUX", "NO_ROOT_NAME_ON_LINUX"},
       // p3: Replace each directory-separator with a preferred-separator.
       // [ Note: The generic pathname grammar ([fs.path.generic]) defines
       //   directory-separator as one or more slashes and preferred-separators.
-      //   — end note ]
+      //   - end note ]
       {"/", "/"},
       {"//", "/"},
       {"///", "/"},
       {"a/b", "a/b"},
       {"a//b", "a/b"},
       {"a///b", "a/b"},
       {"a/b/", "a/b/"},
       {"a/b//", "a/b/"},
#endif
       {"foo/bar/../..", "."},
       {"foo/bar/../../", "."},
       {"foo/bar/baz/../..", "foo/"},
       {"foo/bar/baz/../../", "foo/"},
       {"foo/bar/./..", "foo/"},
       {"foo/bar/./../", "foo/"},
       // p6: If there is a root-directory, remove all dot-dot filenames and any
       // directory-separators immediately following them. [ Note: These dot-dot
-      // filenames attempt to refer to nonexistent parent directories. — end note ]
+      // filenames attempt to refer to nonexistent parent directories. - end note ]
       {"/..", "/"},
       {"/../", "/"},
       {"/foo/../..", "/"},
       {"/../foo", "/foo"},
       {"/../foo/../..", "/"},
       // p7: If the last filename is dot-dot, remove any trailing
       // directory-separator.
       {"../", ".."},

libcxx/test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp

int main(int, char**)
     }
     {
         const my_facet f(LOCALE_ja_JP_UTF_8, 1);
         std::string pat("Today is %A which is the %uth day or alternatively %Ou.");
         cpp17_output_iterator<char*> iter =
             f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, pat.data(), pat.data() + pat.size());
         std::string ex(str, base(iter));
 #if defined(_WIN32) || defined(__APPLE__) || defined(_AIX)
-    // These platforms have no alternative
+        // These platforms have no alternative
         assert(ex == "Today is \xE5\x9C\x9F\xE6\x9B\x9C\xE6\x97\xA5 which is the 6th day or alternatively 6.");
 #else
         assert(ex == "Today is \xE5\x9C\x9F\xE6\x9B\x9C\xE6\x97\xA5 which is the 6th day or alternatively \xE5\x85\xAD.");
 #endif
     }
   return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // template <class T>
 //   constexpr T bit_ceil(T x) noexcept;
 
 // Remarks: This function shall not participate in overload resolution unless
-//  T is an unsigned integer type
+//          T is an unsigned integer type
 
 #include <bit>
 #include <cstdint>
 #include <limits>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };
 
 template <typename T>
 constexpr bool toobig()
 {
-  return 0 == std::bit_ceil(std::numeric_limits<T>::max());
+    return 0 == std::bit_ceil(std::numeric_limits<T>::max());
 }
 
 int main(int, char**)
 {
-//  Make sure we generate a compile-time error for UB
-  static_assert(toobig<unsigned char>(),      ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-  static_assert(toobig<unsigned short>(),     ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-  static_assert(toobig<unsigned>(),           ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-  static_assert(toobig<unsigned long>(),      ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-  static_assert(toobig<unsigned long long>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    // Make sure we generate a compile-time error for UB
+    static_assert(toobig<unsigned char>(),      ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<unsigned short>(),     ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<unsigned>(),           ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<unsigned long>(),      ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<unsigned long long>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
 
-  static_assert(toobig<uint8_t>(), "");   // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-  static_assert(toobig<uint16_t>(), "");   // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-  static_assert(toobig<uint32_t>(), "");   // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-  static_assert(toobig<uint64_t>(), "");   // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-  static_assert(toobig<size_t>(), "");   // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-  static_assert(toobig<uintmax_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-  static_assert(toobig<uintptr_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<uint8_t>(), "");   // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<uint16_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<uint32_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<uint64_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<size_t>(), "");    // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<uintmax_t>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<uintptr_t>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
 
-  return 0;
+    return 0;
 }

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp

test_use_move()
     assert(res2.correctOperatorUsed);
 }
 #endif // TEST_STD_VER > 17
 
 // C++20 can use string in constexpr evaluation, but both libc++ and MSVC
 // don't have the support yet. In these cases omit the constexpr test.
 // FIXME Remove constexpr string workaround introduced in D90569
 #if TEST_STD_VER > 17 && \
-  (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
+    (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
 void
 #else
 TEST_CONSTEXPR_CXX20 void
 #endif
 test_string()
 {
     std::string sa[] = {"a", "b", "c"};
     assert(std::accumulate(sa, sa + 3, std::string()) == "abc");

 
 #if TEST_STD_VER > 17
     test_use_move();
 #endif // TEST_STD_VER > 17
     // C++20 can use string in constexpr evaluation, but both libc++ and MSVC
     // don't have the support yet. In these cases omit the constexpr test.
     // FIXME Remove constexpr string workaround introduced in D90569
 #if TEST_STD_VER > 17 && \
-  (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
-  if (!std::is_constant_evaluated())
+    (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
+    if (!std::is_constant_evaluated())
 #endif
     test_string();
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
     return 0;
 }

libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp

test_use_move()
     for (unsigned i = 1; i < size; ++i) assert(res2[i].correctOperatorUsed);
 }
 #endif // TEST_STD_VER > 17
 
 // C++20 can use string in constexpr evaluation, but both libc++ and MSVC
 // don't have the support yet. In these cases omit the constexpr test.
 // FIXME Remove constexpr string workaround introduced in D90569
 #if TEST_STD_VER > 17 && \
-  (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
+    (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
 void
 #else
 TEST_CONSTEXPR_CXX20 void
 #endif
 test_string()
 {
     std::string sa[] = {"a", "b", "c"};
     std::string sr[] = {"a", "ba", "cb"};

 
 #if TEST_STD_VER > 17
     test_use_move();
 #endif // TEST_STD_VER > 17
     // C++20 can use string in constexpr evaluation, but both libc++ and MSVC
     // don't have the support yet. In these cases omit the constexpr test.
     // FIXME Remove constexpr string workaround introduced in D90569
 #if TEST_STD_VER > 17 && \
-  (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
-  if (!std::is_constant_evaluated())
+    (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
+    if (!std::is_constant_evaluated())
 #endif
     test_string();
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
     return 0;
 }

libcxx/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp

test_use_move()
     assert(res2.correctOperatorUsed);
 }
 #endif // TEST_STD_VER > 17
 
 // C++20 can use string in constexpr evaluation, but both libc++ and MSVC
 // don't have the support yet. In these cases omit the constexpr test.
 // FIXME Remove constexpr string workaround introduced in D90569
 #if TEST_STD_VER > 17 && \
-  (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
+    (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
 void
 #else
 TEST_CONSTEXPR_CXX20 void
 #endif
 test_string()
 {
     std::string sa[] = {"a", "b", "c"};
     assert(std::accumulate(sa, sa + 3, std::string()) == "abc");

 
 #if TEST_STD_VER > 17
     test_use_move();
 #endif // TEST_STD_VER > 17
     // C++20 can use string in constexpr evaluation, but both libc++ and MSVC
     // don't have the support yet. In these cases omit the constexpr test.
     // FIXME Remove constexpr string workaround introduced in D90569
 #if TEST_STD_VER > 17 && \
-  (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
-  if (!std::is_constant_evaluated())
+    (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
+    if (!std::is_constant_evaluated())
 #endif
     test_string();
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
     return 0;
 }

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

//  Check two values "close to each other"
     T d1 = T(3.14);
     T d0 = std::nextafter(d1, T(2));
     T d2 = std::nextafter(d1, T(5));
     assert(d0 < d1);  // sanity checking
     assert(d1 < d2);  // sanity checking
 
 #if defined(__PPC__) && (defined(__LONG_DOUBLE_128__) && __LONG_DOUBLE_128__) &&                                       \
     !(defined(__LONG_DOUBLE_IEEE128__) && __LONG_DOUBLE_IEEE128__)
-//  For 128 bit long double implemented as 2 doubles on PowerPC,
-//  nextafterl() of libm gives imprecise results which fails the
-//  midpoint() tests below. So skip the test for this case.
+//  For 128 bit long double implemented as 2 doubles on PowerPC,
+//  nextafterl() of libm gives imprecise results which fails the
+//  midpoint() tests below. So skip the test for this case.
     if constexpr (sizeof(T) != 16)
 #endif
     {
-  //  Since there's nothing in between, the midpoint has to be one or the other
-    T res;
-    res = std::midpoint(d0, d1);
-    assert(res == d0 || res == d1);
-    assert(d0 <= res);
-    assert(res <= d1);
-    res = std::midpoint(d1, d0);
-    assert(res == d0 || res == d1);
-    assert(d0 <= res);
-    assert(res <= d1);
+    //  Since there's nothing in between, the midpoint has to be one or the other
+        T res;
+        res = std::midpoint(d0, d1);
+        assert(res == d0 || res == d1);
+        assert(d0 <= res);
+        assert(res <= d1);
+        res = std::midpoint(d1, d0);
+        assert(res == d0 || res == d1);
+        assert(d0 <= res);
+        assert(res <= d1);
 
-    res = std::midpoint(d1, d2);
-    assert(res == d1 || res == d2);
-    assert(d1 <= res);
-    assert(res <= d2);
-    res = std::midpoint(d2, d1);
-    assert(res == d1 || res == d2);
-    assert(d1 <= res);
-    assert(res <= d2);
+        res = std::midpoint(d1, d2);
+        assert(res == d1 || res == d2);
+        assert(d1 <= res);
+        assert(res <= d2);
+        res = std::midpoint(d2, d1);
+        assert(res == d1 || res == d2);
+        assert(d1 <= res);
+        assert(res <= d2);
     }
 }
 
 
 int main (int, char**)
 {
     fp_test<float>();
     fp_test<double>();
     fp_test<long double>();
 
     return 0;
 }

libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp

test_use_move()
     for (unsigned i = 1; i < size; ++i) assert(res2[i].correctOperatorUsed);
 }
 #endif // TEST_STD_VER > 17
 
 // C++20 can use string in constexpr evaluation, but both libc++ and MSVC
 // don't have the support yet. In these cases omit the constexpr test.
 // FIXME Remove constexpr string workaround introduced in D90569
 #if TEST_STD_VER > 17 && \
-  (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
+    (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
 void
 #else
 TEST_CONSTEXPR_CXX20 void
 #endif
 test_string()
 {
     std::string sa[] = {"a", "b", "c"};
     std::string sr[] = {"a", "ba", "cb"};

 
 #if TEST_STD_VER > 17
     test_use_move();
 #endif // TEST_STD_VER > 17
     // C++20 can use string in constexpr evaluation, but both libc++ and MSVC
     // don't have the support yet. In these cases omit the constexpr test.
     // FIXME Remove constexpr string workaround introduced in D90569
 #if TEST_STD_VER > 17 && \
-  (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
-  if (!std::is_constant_evaluated())
+    (!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
+    if (!std::is_constant_evaluated())
 #endif
     test_string();
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
 
     return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.join.view/begin.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++03, c++11, c++14, c++17
 
 // constexpr auto begin();
 // constexpr auto begin() const
-//    requires input_­range<const V> &&
+//    requires input_range<const V> &&
 //             is_reference_v<range_reference_t<const V>>;
 
 #include <cassert>
 #include <ranges>
 
 #include "types.h"
 
 struct NonSimpleParentView : std::ranges::view_base {
constexpr bool test() {
   }
 
   {
     const std::ranges::join_view jv(buffer);
     assert(*jv.begin() == 1111);
     static_assert(HasConstBegin<decltype(jv)>);
   }
 
-  // !input_­range<const V>
+  // !input_range<const V>
   {
     std::ranges::join_view jv{ConstNotRange{}};
     static_assert(!HasConstBegin<decltype(jv)>);
   }
 
   // !is_reference_v<range_reference_t<const V>>
   {
     auto innerRValueRange = std::views::iota(0, 5) | std::views::transform([](int) { return ChildView{}; });

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/ctor.other.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++03, c++11, c++14, c++17
 
 // constexpr iterator(iterator<!Const> i)
 //             requires Const &&
-//                      convertible_­to<iterator_t<V>, OuterIter> &&
-//                      convertible_­to<iterator_t<InnerRng>, InnerIter>;
+//                      convertible_to<iterator_t<V>, OuterIter> &&
+//                      convertible_to<iterator_t<InnerRng>, InnerIter>;
 
 #include <cassert>
 #include <ranges>
 
 #include "test_macros.h"
 #include "../types.h"
 
 using ConstCompatibleInner = BufferView<int*>;

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/decrement.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++03, c++11, c++14, c++17
 
 // constexpr iterator& operator--();
-//              requires ref-is-glvalue && bidirectional_­range<Base> &&
-//                       bidirectional_­range<range_reference_t<Base>> &&
-//                       common_­range<range_reference_t<Base>>;
+//              requires ref-is-glvalue && bidirectional_range<Base> &&
+//                       bidirectional_range<range_reference_t<Base>> &&
+//                       common_range<range_reference_t<Base>>;
 // constexpr iterator operator--(int);
-//              requires ref-is-glvalue && bidirectional_­range<Base> &&
-//                       bidirectional_­range<range_reference_t<Base>> &&
-//                       common_­range<range_reference_t<Base>>;
+//              requires ref-is-glvalue && bidirectional_range<Base> &&
+//                       bidirectional_range<range_reference_t<Base>> &&
+//                       common_range<range_reference_t<Base>>;
 
 #include <cassert>
 #include <ranges>
 #include <type_traits>
 
 #include "../types.h"
 
 template <class T>
#endif
     // !ref-is-glvalue
     BidiCommonInner inners[2] = {buffer[0], buffer[1]};
     InnerRValue<BidiCommonOuter<BidiCommonInner>> outer{inners};
     std::ranges::join_view jv(outer);
     noDecrementTest(jv);
   }
 
   {
-    // !bidirectional_­range<Base>
+    // !bidirectional_range<Base>
     BidiCommonInner inners[2] = {buffer[0], buffer[1]};
     SimpleForwardCommonOuter<BidiCommonInner> outer{inners};
     std::ranges::join_view jv(outer);
     noDecrementTest(jv);
   }
 
   {
-    // !bidirectional_­range<range_reference_t<Base>>
+    // !bidirectional_range<range_reference_t<Base>>
     ForwardCommonInner inners[2] = {buffer[0], buffer[1]};
     std::ranges::join_view jv(inners);
     noDecrementTest(jv);
   }
 
   {
     // LWG3313 `join_view::iterator::operator--` is incorrectly constrained
     // `join_view::iterator` should not have `operator--` if
-    // !common_­range<range_reference_t<Base>>
+    // !common_range<range_reference_t<Base>>
     BidiNonCommonInner inners[2] = {buffer[0], buffer[1]};
     std::ranges::join_view jv(inners);
     auto iter = jv.begin();
     static_assert(!CanPreDecrement<decltype(iter)>);
     static_assert(!CanPostDecrement<decltype(iter)>);
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/increment.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++03, c++11, c++14, c++17
 
 // constexpr iterator& operator++();
 // constexpr void operator++(int);
 // constexpr iterator operator++(int)
-//            requires ref-is-glvalue && forward_­range<Base> &&
+//            requires ref-is-glvalue && forward_range<Base> &&
 //                     forward_range<range_reference_t<Base>>;
 
 #include <cassert>
 #include <ranges>
 
 #include "test_macros.h"
 #include "../types.h"
 
// operator++();
     BidiCommonInner inners[2] = {buffer1[0], buffer1[1]};
     InnerRValue<BidiCommonOuter<BidiCommonInner>> outer{inners};
     std::ranges::join_view jv(outer);
     auto iter = jv.begin();
     static_assert(std::is_void_v<decltype(iter++)>);
   }
 
   {
-    // !forward_­range<Base>
+    // !forward_range<Base>
     BufferView<int*> inners[2] = {buffer1[0], buffer1[1]};
     using Outer = SimpleInputCommonOuter<BufferView<int*>>;
     std::ranges::join_view jv{Outer(inners)};
     auto iter = jv.begin();
     static_assert(std::is_void_v<decltype(iter++)>);
   }
 
   {

libcxx/test/std/ranges/range.adaptors/range.join.view/sentinel/ctor.other.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++03, c++11, c++14, c++17
 
 // constexpr sentinel(sentinel<!Const> s);
-//             requires Const && convertible_­to<sentinel_t<V>, sentinel_t<Base>>;
+//             requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
 
 #include <cassert>
 #include <ranges>
 
 #include "../types.h"
 
 template <class T>
 struct convertible_sentinel_wrapper {

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/arithmetic.pass.cpp

 // x += n;
 // x + n;
 // n + x;
 // x -= n;
 // x - n;
 // x - y;
 // All the arithmetic operators have the constraint `requires all-random-access<Const, Views...>;`,
 // except `operator-(x, y)` which instead has the constraint
-//    `requires (sized_­sentinel_­for<iterator_t<maybe-const<Const, Views>>,
+//    `requires (sized_sentinel_for<iterator_t<maybe-const<Const, Views>>,
 //                                  iterator_t<maybe-const<Const, Views>>> && ...);`
 
 #include <ranges>
 
 #include <array>
 #include <concepts>
 #include <functional>
 

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.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++03, c++11, c++14, c++17, c++20
 
 // friend constexpr bool operator==(const iterator& x, const iterator& y)
-//   requires (equality_­comparable<iterator_t<maybe-const<Const, Views>>> && ...);
+//   requires (equality_comparable<iterator_t<maybe-const<Const, Views>>> && ...);
 // friend constexpr bool operator<(const iterator& x, const iterator& y)
 //   requires all-random-access<Const, Views...>;
 // friend constexpr bool operator>(const iterator& x, const iterator& y)
 //   requires all-random-access<Const, Views...>;
 // friend constexpr bool operator<=(const iterator& x, const iterator& y)
 //   requires all-random-access<Const, Views...>;
 // friend constexpr bool operator>=(const iterator& x, const iterator& y)
 //   requires all-random-access<Const, Views...>;
 // friend constexpr auto operator<=>(const iterator& x, const iterator& y)
 //   requires all-random-access<Const, Views...> &&
-//            (three_­way_­comparable<iterator_t<maybe-const<Const, Views>>> && ...);
+//            (three_way_comparable<iterator_t<maybe-const<Const, Views>>> && ...);
 
 #include <ranges>
 #include <compare>
 
 #include "test_iterators.h"
 #include "../types.h"
 
 // This is for testing that zip iterator never calls underlying iterator's >, >=, <=, !=.

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.other.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++03, c++11, c++14, c++17, c++20
 
 // constexpr iterator(iterator<!Const> i)
-//       requires Const && (convertible_­to<iterator_t<Views>,
+//       requires Const && (convertible_to<iterator_t<Views>,
 //                                         iterator_t<maybe-const<Const, Views>>> && ...);
 
 #include <ranges>
 
 #include <cassert>
 #include <tuple>
 
 #include "../types.h"

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/iter_swap.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++03, c++11, c++14, c++17, c++20
 
 // friend constexpr void iter_swap(const iterator& l, const iterator& r) noexcept(see below)
-//   requires (indirectly_­swappable<iterator_t<maybe-const<Const, Views>>> && ...);
+//   requires (indirectly_swappable<iterator_t<maybe-const<Const, Views>>> && ...);
 
 #include <array>
 #include <cassert>
 #include <ranges>
 
 #include "../types.h"
 
 struct ThrowingMove {

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.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++03, c++11, c++14, c++17, c++20
 
 // template <bool OtherConst>
 // requires(sized_sentinel_for<sentinel_t<maybe-const<Const, Views>>,
 //                             iterator_t<maybe-const<OtherConst, Views>>>&&...)
 // friend constexpr common_type_t<range_difference_t<maybe-const<OtherConst, Views>>...>
-//  operator-(const iterator<OtherConst>&, const sentinel&)
+//   operator-(const iterator<OtherConst>&, const sentinel&)
 //
 // template <bool OtherConst>
 // requires(sized_sentinel_for<sentinel_t<maybe-const<Const, Views>>,
 //                             iterator_t<maybe-const<OtherConst, Views>>>&&...)
 // friend constexpr common_type_t<range_difference_t<maybe-const<OtherConst, Views>>...>
 //   operator-(const sentinel&, const iterator<OtherConst>&)
 
 #include <cassert>

libcxx/test/std/re/re.regex/re.regex.construct/deduct.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
 // UNSUPPORTED: c++03, c++11, c++14
 
-// template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
-//    vector(InputIterator, InputIterator, Allocator = Allocator())
-//    -> vector<typename iterator_traits<InputIterator>::value_type, Allocator>;
-//
+// template<class ForwardIterator>
+// basic_regex(ForwardIterator, ForwardIterator,
+//             regex_constants::syntax_option_type = regex_constants::ECMAScript)
+// -> basic_regex<typename iterator_traits<ForwardIterator>::value_type>;
 
 #include <regex>
 #include <string>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 
 int main(int, char**)
 {
-//  Test the explicit deduction guides
+    // Test the explicit deduction guides
     {
-//  basic_regex(ForwardIterator, ForwardIterator)
-//  <int> is not an iterator
+    // basic_regex(ForwardIterator, ForwardIterator)
+    // <int> is not an iterator
     std::basic_regex re(23, 34);   // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'basic_regex'}}
     }
 
     {
-//  basic_regex(ForwardIterator, ForwardIterator, flag_type)
-//  <double> is not an iterator
+    // basic_regex(ForwardIterator, ForwardIterator, flag_type)
+    // <double> is not an iterator
     std::basic_regex re(23.0, 34.0, std::regex_constants::basic);   // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'basic_regex'}}
     }
 
-//  Test the implicit deduction guides
-
-
     return 0;
 }

libcxx/test/std/time/time.hms/time.hms.members/is_negative.pass.cpp

 #include <ratio>
 #include <utility>
 
 #include "test_macros.h"
 
 template <typename Duration>
 constexpr bool check_neg(Duration d)
 {
-  ASSERT_SAME_TYPE(bool, decltype(std::declval<std::chrono::hh_mm_ss<Duration>>().is_negative()));
-  ASSERT_NOEXCEPT(                std::declval<std::chrono::hh_mm_ss<Duration>>().is_negative());
-  return std::chrono::hh_mm_ss<Duration>(d).is_negative();
+    ASSERT_SAME_TYPE(bool, decltype(std::declval<std::chrono::hh_mm_ss<Duration>>().is_negative()));
+    ASSERT_NOEXCEPT(                std::declval<std::chrono::hh_mm_ss<Duration>>().is_negative());
+    return std::chrono::hh_mm_ss<Duration>(d).is_negative();
 }
 
 int main(int, char**)
 {
-  using microfortnights = std::chrono::duration<int, std::ratio<756, 625>>;
+    using microfortnights = std::chrono::duration<int, std::ratio<756, 625>>;
 
-  static_assert(!check_neg(std::chrono::minutes( 1)), "");
-  static_assert( check_neg(std::chrono::minutes(-1)), "");
+    static_assert(!check_neg(std::chrono::minutes( 1)), "");
+    static_assert( check_neg(std::chrono::minutes(-1)), "");
 
-  assert(!check_neg(std::chrono::seconds( 5000)));
-  assert( check_neg(std::chrono::seconds(-5000)));
-  assert(!check_neg(std::chrono::minutes( 5000)));
-  assert( check_neg(std::chrono::minutes(-5000)));
-  assert(!check_neg(std::chrono::hours( 11)));
-  assert( check_neg(std::chrono::hours(-11)));
+    assert(!check_neg(std::chrono::seconds( 5000)));
+    assert( check_neg(std::chrono::seconds(-5000)));
+    assert(!check_neg(std::chrono::minutes( 5000)));
+    assert( check_neg(std::chrono::minutes(-5000)));
+    assert(!check_neg(std::chrono::hours( 11)));
+    assert( check_neg(std::chrono::hours(-11)));
 
-  assert(!check_neg(std::chrono::milliseconds( 123456789LL)));
-  assert( check_neg(std::chrono::milliseconds(-123456789LL)));
-  assert(!check_neg(std::chrono::microseconds( 123456789LL)));
-  assert( check_neg(std::chrono::microseconds(-123456789LL)));
-  assert(!check_neg(std::chrono::nanoseconds( 123456789LL)));
-  assert( check_neg(std::chrono::nanoseconds(-123456789LL)));
+    assert(!check_neg(std::chrono::milliseconds( 123456789LL)));
+    assert( check_neg(std::chrono::milliseconds(-123456789LL)));
+    assert(!check_neg(std::chrono::microseconds( 123456789LL)));
+    assert( check_neg(std::chrono::microseconds(-123456789LL)));
+    assert(!check_neg(std::chrono::nanoseconds( 123456789LL)));
+    assert( check_neg(std::chrono::nanoseconds(-123456789LL)));
 
-  assert(!check_neg(microfortnights( 10000)));
-  assert( check_neg(microfortnights(-10000)));
+    assert(!check_neg(microfortnights( 10000)));
+    assert( check_neg(microfortnights(-10000)));
 
-  return 0;
+    return 0;
 }

libcxx/test/std/time/time.hms/time.hms.members/precision.pass.cpp

 #include <chrono>
 #include <cassert>
 #include <ratio>
 #include <type_traits>
 
 #include "test_macros.h"
 
 constexpr unsigned long long powers[] = {
-  1ULL,
-  10ULL,
-  100ULL,
-  1000ULL,
-  10000ULL,
-  100000ULL,
-  1000000ULL,
-  10000000ULL,
-  100000000ULL,
-  1000000000ULL,
-  10000000000ULL,
-  100000000000ULL,
-  1000000000000ULL,
-  10000000000000ULL,
-  100000000000000ULL,
-  1000000000000000ULL,
-  10000000000000000ULL,
-  100000000000000000ULL,
-  1000000000000000000ULL,
-  10000000000000000000ULL
+    1ULL,
+    10ULL,
+    100ULL,
+    1000ULL,
+    10000ULL,
+    100000ULL,
+    1000000ULL,
+    10000000ULL,
+    100000000ULL,
+    1000000000ULL,
+    10000000000ULL,
+    100000000000ULL,
+    1000000000000ULL,
+    10000000000000ULL,
+    100000000000000ULL,
+    1000000000000000ULL,
+    10000000000000000ULL,
+    100000000000000000ULL,
+    1000000000000000000ULL,
+    10000000000000000000ULL
 };
 
 template <typename Duration, unsigned width>
 constexpr bool check_precision()
 {
-  using HMS = std::chrono::hh_mm_ss<Duration>;
-  using CT  = std::common_type_t<typename Duration::rep, std::chrono::seconds::rep>;
-  using Pre = std::chrono::duration<CT, std::ratio<1, powers[width]>>;
-  return std::is_same_v<typename HMS::precision, Pre>;
+    using HMS = std::chrono::hh_mm_ss<Duration>;
+    using CT  = std::common_type_t<typename Duration::rep, std::chrono::seconds::rep>;
+    using Pre = std::chrono::duration<CT, std::ratio<1, powers[width]>>;
+    return std::is_same_v<typename HMS::precision, Pre>;
 }
 
 int main(int, char**)
 {
-  using microfortnights = std::chrono::duration<int, std::ratio<756, 625>>;
+    using microfortnights = std::chrono::duration<int, std::ratio<756, 625>>;
 
-  static_assert( check_precision<std::chrono::hours,                               0>(), "");
-  static_assert( check_precision<std::chrono::minutes,                             0>(), "");
-  static_assert( check_precision<std::chrono::seconds,                             0>(), "");
-  static_assert( check_precision<std::chrono::milliseconds,                        3>(), "");
-  static_assert( check_precision<std::chrono::microseconds,                        6>(), "");
-  static_assert( check_precision<std::chrono::nanoseconds,                         9>(), "");
-  static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   2>>, 1>(), "");
-  static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   3>>, 6>(), "");
-  static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   4>>, 2>(), "");
-  static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   5>>, 1>(), "");
-  static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   6>>, 6>(), "");
-  static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   7>>, 6>(), "");
-  static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   8>>, 3>(), "");
-  static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   9>>, 6>(), "");
-  static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,  10>>, 1>(), "");
-  static_assert( check_precision<microfortnights,                                  4>(), "");
+    static_assert( check_precision<std::chrono::hours,                               0>(), "");
+    static_assert( check_precision<std::chrono::minutes,                             0>(), "");
+    static_assert( check_precision<std::chrono::seconds,                             0>(), "");
+    static_assert( check_precision<std::chrono::milliseconds,                        3>(), "");
+    static_assert( check_precision<std::chrono::microseconds,                        6>(), "");
+    static_assert( check_precision<std::chrono::nanoseconds,                         9>(), "");
+    static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   2>>, 1>(), "");
+    static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   3>>, 6>(), "");
+    static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   4>>, 2>(), "");
+    static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   5>>, 1>(), "");
+    static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   6>>, 6>(), "");
+    static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   7>>, 6>(), "");
+    static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   8>>, 3>(), "");
+    static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,   9>>, 6>(), "");
+    static_assert( check_precision<std::chrono::duration<int, std::ratio<  1,  10>>, 1>(), "");
+    static_assert( check_precision<microfortnights,                                  4>(), "");
 
-  return 0;
+    return 0;
 }

libcxx/test/std/time/time.hms/time.hms.members/width.pass.cpp

 
 // template <class Duration>
 // class hh_mm_ss
 // {
 // public:
 //     static unsigned constexpr fractional_width = see below;
 //     using precision                            = see below;
 //
-//  fractional_width is the number of fractional decimal digits represented by precision.
+//  fractional_width is the number of fractional decimal digits represented by precision.
 //  fractional_width has the value of the smallest possible integer in the range [0, 18]
 //    such that precision will exactly represent all values of Duration.
 //  If no such value of fractional_width exists, then fractional_width is 6.
 
 
 #include <chrono>
 #include <cassert>
 #include <ratio>
 
 #include "test_macros.h"
 
 template <typename Duration, unsigned width>
 constexpr bool check_width()
 {
-  using HMS = std::chrono::hh_mm_ss<Duration>;
-  return HMS::fractional_width == width;
+    using HMS = std::chrono::hh_mm_ss<Duration>;
+    return HMS::fractional_width == width;
 }
 
 int main(int, char**)
 {
-  using microfortnights = std::chrono::duration<int, std::ratio<756, 625>>;
+    using microfortnights = std::chrono::duration<int, std::ratio<756, 625>>;
 
-  static_assert( check_width<std::chrono::hours,                               0>(), "");
-  static_assert( check_width<std::chrono::minutes,                             0>(), "");
-  static_assert( check_width<std::chrono::seconds,                             0>(), "");
-  static_assert( check_width<std::chrono::milliseconds,                        3>(), "");
-  static_assert( check_width<std::chrono::microseconds,                        6>(), "");
-  static_assert( check_width<std::chrono::nanoseconds,                         9>(), "");
-  static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   2>>, 1>(), "");
-  static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   3>>, 6>(), "");
-  static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   4>>, 2>(), "");
-  static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   5>>, 1>(), "");
-  static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   6>>, 6>(), "");
-  static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   7>>, 6>(), "");
-  static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   8>>, 3>(), "");
-  static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   9>>, 6>(), "");
-  static_assert( check_width<std::chrono::duration<int, std::ratio<  1,  10>>, 1>(), "");
-  static_assert( check_width<microfortnights,                                  4>(), "");
+    static_assert( check_width<std::chrono::hours,                               0>(), "");
+    static_assert( check_width<std::chrono::minutes,                             0>(), "");
+    static_assert( check_width<std::chrono::seconds,                             0>(), "");
+    static_assert( check_width<std::chrono::milliseconds,                        3>(), "");
+    static_assert( check_width<std::chrono::microseconds,                        6>(), "");
+    static_assert( check_width<std::chrono::nanoseconds,                         9>(), "");
+    static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   2>>, 1>(), "");
+    static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   3>>, 6>(), "");
+    static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   4>>, 2>(), "");
+    static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   5>>, 1>(), "");
+    static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   6>>, 6>(), "");
+    static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   7>>, 6>(), "");
+    static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   8>>, 3>(), "");
+    static_assert( check_width<std::chrono::duration<int, std::ratio<  1,   9>>, 6>(), "");
+    static_assert( check_width<std::chrono::duration<int, std::ratio<  1,  10>>, 1>(), "");
+    static_assert( check_width<microfortnights,                                  4>(), "");
 
-  return 0;
+    return 0;
 }

libcxx/test/std/time/time.hms/time.12/is_am.pass.cpp

 #include <chrono>
 #include <cassert>
 #include <utility>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-  using hours = std::chrono::hours;
-  ASSERT_SAME_TYPE(bool, decltype(std::chrono::is_am(std::declval<hours>())));
-  ASSERT_NOEXCEPT(                std::chrono::is_am(std::declval<hours>()));
+    using hours = std::chrono::hours;
+    ASSERT_SAME_TYPE(bool, decltype(std::chrono::is_am(std::declval<hours>())));
+    ASSERT_NOEXCEPT(                std::chrono::is_am(std::declval<hours>()));
 
-  static_assert( std::chrono::is_am(hours( 0)), "");
-  static_assert( std::chrono::is_am(hours(11)), "");
-  static_assert(!std::chrono::is_am(hours(12)), "");
-  static_assert(!std::chrono::is_am(hours(23)), "");
+    static_assert( std::chrono::is_am(hours( 0)), "");
+    static_assert( std::chrono::is_am(hours(11)), "");
+    static_assert(!std::chrono::is_am(hours(12)), "");
+    static_assert(!std::chrono::is_am(hours(23)), "");
 
-  for (int i = 0; i < 12; ++i)
-    assert( std::chrono::is_am(hours(i)));
-  for (int i = 12; i < 24; ++i)
-    assert(!std::chrono::is_am(hours(i)));
+    for (int i = 0; i < 12; ++i)
+        assert( std::chrono::is_am(hours(i)));
+    for (int i = 12; i < 24; ++i)
+        assert(!std::chrono::is_am(hours(i)));
 
     return 0;
 }

libcxx/test/std/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp

 
 // constexpr month operator-(const month& x, const months& y) noexcept;
 //   Returns: x + -y.
 //
 // constexpr months operator-(const month& x, const month& y) noexcept;
 //   Returns: If x.ok() == true and y.ok() == true, returns a value m in the range
 //   [months{0}, months{11}] satisfying y + m == x.
 //   Otherwise the value returned is unspecified.
-//   [Example: January - February == months{11}. —end example]
+//   [Example: January - February == months{11}. -end example]
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <typename M, typename Ms>

libcxx/test/std/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp

 //
 // constexpr month operator+(const months& x, const month& y) noexcept;
 //   Returns:
 //     month{modulo(static_cast<long long>(int{x}) + (y.count() - 1), 12) + 1}
 //   where modulo(n, 12) computes the remainder of n divided by 12 using Euclidean division.
 //   [Note: Given a divisor of 12, Euclidean division truncates towards negative infinity
 //   and always produces a remainder in the range of [0, 11].
 //   Assuming no overflow in the signed summation, this operation results in a month
-//   holding a value in the range [1, 12] even if !x.ok(). —end note]
-//   [Example: February + months{11} == January. —end example]
+//   holding a value in the range [1, 12] even if !x.ok(). -end note]
+//   [Example: February + months{11} == January. -end example]
 
 
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/time/time.cal/time.cal.operators/month_day.pass.cpp

 // constexpr month_day
 //   operator/(int m, const day& d) noexcept;
 // Returns: month(m) / d.
 //
 // constexpr month_day
 //   operator/(const day& d, int m) noexcept;
 // Returns: month(m) / d.
 
-
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {

libcxx/test/std/time/time.cal/time.cal.operators/month_day_last.pass.cpp

 // Returns: m / last.
 //
 // constexpr month_day_last
 //   operator/(last_spec, int m) noexcept;
 // Returns: month(m) / last.
 //
 //
 // [Note: A month_day_last object can be constructed using the expression m/last or last/m,
-//     where m is an expression of type month. — end note]
+//     where m is an expression of type month. - end note]
 // [Example:
 //     constexpr auto mdl = February/last; // mdl is the last day of February of an as yet unspecified year
 //     static_assert(mdl.month() == February);
 // --end example]
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>

libcxx/test/std/time/time.cal/time.cal.operators/month_weekday.pass.cpp

 // constexpr month_weekday
 //   operator/(const weekday_indexed& wdi, const month& m) noexcept;
 // Returns: m / wdi. constexpr month_weekday
 //
 // constexpr month_weekday
 //   operator/(const weekday_indexed& wdi, int m) noexcept;
 // Returns: month(m) / wdi.
 
-
 //
 // [Example:
 // constexpr auto mwd = February/Tuesday[3]; // mwd is the third Tuesday of February of an as yet unspecified year
 //      static_assert(mwd.month() == February);
 //      static_assert(mwd.weekday_indexed() == Tuesday[3]);
-// —end example]
-
-
-
+// -end example]
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)

libcxx/test/std/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp

 // constexpr month_weekday_last
 //   operator/(const weekday_last& wdl, const month& m) noexcept;
 // Returns: m / wdl.
 //
 // constexpr month_weekday_last
 //   operator/(const weekday_last& wdl, int m) noexcept;
 // Returns: month(m) / wdl.
 
-
-
-
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {

libcxx/test/std/time/time.cal/time.cal.operators/year_month.pass.cpp

 // class year_month;
 
 // constexpr year_month operator/(const year& y, const month& m) noexcept;
 //   Returns: {y, m}.
 //
 // constexpr year_month operator/(const year& y, int m) noexcept;
 //   Returns: y / month(m).
 
-
-
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {

libcxx/test/std/time/time.cal/time.cal.operators/year_month_day.pass.cpp

 // constexpr year_month_day
 //   operator/(const month_day& md, const year& y) noexcept;
 // Returns: y / md.
 //
 // constexpr year_month_day
 //   operator/(const month_day& md, int y) noexcept;
 // Returns: year(y) / md.
 
-
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {

libcxx/test/std/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp

 // constexpr year_month_day_last
 //   operator/(const month_day_last& mdl, const year& y) noexcept;
 // Returns: y / mdl.
 //
 // constexpr year_month_day_last
 //   operator/(const month_day_last& mdl, int y) noexcept;
 // Returns: year(y) / mdl.
 
-
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {

libcxx/test/std/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp

 // constexpr year_month_weekday_last
 //   operator/(const month_weekday_last& mwdl, const year& y) noexcept;
 // Returns: y / mwdl.
 //
 // constexpr year_month_weekday_last
 //   operator/(const month_weekday_last& mwdl, int y) noexcept;
 // Returns: year(y) / mwdl.
 
-
-
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {

libcxx/test/std/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp

 //              of the week  corresponds to the local_days dp, and representing
 //              that day of the week in wd_
 //
 //  Remarks: For any value ymd of type year_month_day for which ymd.ok() is true,
 //                ymd == year_month_day{sys_days{ymd}} is true.
 //
 // [Example:
 //  If dp represents 1970-01-01, the constructed weekday represents Thursday by storing 4 in wd_.
-// —end example]
+// -end example]
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)

libcxx/test/std/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp

 //              of the week  corresponds to the sys_days dp, and representing
 //              that day of the week in wd_
 //
 //  Remarks: For any value ymd of type year_month_day for which ymd.ok() is true,
 //                ymd == year_month_day{sys_days{ymd}} is true.
 //
 // [Example:
 //  If dp represents 1970-01-01, the constructed weekday represents Thursday by storing 4 in wd_.
-// —end example]
+// -end example]
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)

libcxx/test/std/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp

 
 // constexpr weekday operator-(const weekday& x, const days& y) noexcept;
 //   Returns: x + -y.
 //
 // constexpr days operator-(const weekday& x, const weekday& y) noexcept;
 // Returns: If x.ok() == true and y.ok() == true, returns a value d in the range
 //    [days{0}, days{6}] satisfying y + d == x.
 // Otherwise the value returned is unspecified.
-// [Example: Sunday - Monday == days{6}. —end example]
+// [Example: Sunday - Monday == days{6}. -end example]
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../../euclidian.h"
 

libcxx/test/std/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp

 //
 // constexpr weekday operator+(const weekday& x, const days& y) noexcept;
 //   Returns:
 //      weekday{modulo(static_cast<long long>(unsigned{x}) + y.count(), 7)}
 //   where modulo(n, 7) computes the remainder of n divided by 7 using Euclidean division.
 //   [Note: Given a divisor of 12, Euclidean division truncates towards negative infinity
 //   and always produces a remainder in the range of [0, 6].
 //   Assuming no overflow in the signed summation, this operation results in a weekday
-//   holding a value in the range [0, 6] even if !x.ok(). —end note]
-//   [Example: Monday + days{6} == Sunday. —end example]
-
-
+//   holding a value in the range [0, 6] even if !x.ok(). -end note]
+//   [Example: Monday + days{6} == Sunday. -end example]
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../../euclidian.h"
 

libcxx/test/std/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp

 
 // constexpr year operator-(const year& x, const years& y) noexcept;
 //   Returns: x + -y.
 //
 // constexpr years operator-(const year& x, const year& y) noexcept;
 //   Returns: If x.ok() == true and y.ok() == true, returns a value m in the range
 //   [years{0}, years{11}] satisfying y + m == x.
 //   Otherwise the value returned is unspecified.
-//   [Example: January - February == years{11}. —end example]
+//   [Example: January - February == years{11}. -end example]
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <typename Y, typename Ys>

libcxx/test/std/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp

 // Remarks: A local_days in the range [days{-12687428}, days{11248737}] which
 //   is converted to a year_month_day shall have the same value when
 //   converted back to a sys_days.
 //
 // [Example:
 //   static_assert(year_month_day{local_days{2017y/January/0}}  == 2016y/December/31);
 //   static_assert(year_month_day{local_days{2017y/January/31}} == 2017y/January/31);
 //   static_assert(year_month_day{local_days{2017y/January/32}} == 2017y/February/1);
-// —end example]
+// -end example]
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 void RunTheExample()

libcxx/test/std/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp

 // Remarks: A sys_days in the range [days{-12687428}, days{11248737}] which
 //   is converted to a year_month_day shall have the same value when
 //   converted back to a sys_days.
 //
 // [Example:
 //   static_assert(year_month_day{sys_days{2017y/January/0}}  == 2016y/December/31);
 //   static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31);
 //   static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1);
-// —end example]
+// -end example]
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 void RunTheExample()

libcxx/test/std/time/time.clock/time.clock.system/local_time.types.pass.cpp

 // struct local_t {};
 // template<class Duration>
 //   using local_time  = time_point<system_clock, Duration>;
 // using local_seconds = sys_time<seconds>;
 // using local_days    = sys_time<days>;
 
 // [Example:
 //   sys_seconds{sys_days{1970y/January/1}}.time_since_epoch() is 0s.
-//   sys_seconds{sys_days{2000y/January/1}}.time_since_epoch() is 946’684’800s, which is 10’957 * 86’400s.
-// —end example]
+//   sys_seconds{sys_days{2000y/January/1}}.time_since_epoch() is 946'684'800s, which is 10'957 * 86'400s.
+// - end example]
 
 
 #include <chrono>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)

libcxx/test/std/time/time.clock/time.clock.system/sys.time.types.pass.cpp

 
 // template<class Duration>
 //   using sys_time  = time_point<system_clock, Duration>;
 // using sys_seconds = sys_time<seconds>;
 // using sys_days    = sys_time<days>;
 
 // [Example:
 //   sys_seconds{sys_days{1970y/January/1}}.time_since_epoch() is 0s.
-//   sys_seconds{sys_days{2000y/January/1}}.time_since_epoch() is 946’684’800s, which is 10’957 * 86’400s.
-// —end example]
+//   sys_seconds{sys_days{2000y/January/1}}.time_since_epoch() is 946'684'800s, which is 10'957 * 86'400s.
+// - end example]
 
 
 #include <chrono>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)

libcxx/test/std/utilities/format/format.functions/format.verify.cpp

 }
 
 struct tiny {
   int bit : 1;
 };
 
 void P2418()
 {
-  auto t = tiny{};
-  std::format("{}", t.bit); // expected-error{{non-const reference cannot bind to bit-field 'bit'}}
+  auto t = tiny{};
+  std::format("{}", t.bit); // expected-error{{non-const reference cannot bind to bit-field 'bit'}}
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  std::format(L"{}", t.bit); // expected-error{{non-const reference cannot bind to bit-field 'bit'}}
+  std::format(L"{}", t.bit); // expected-error{{non-const reference cannot bind to bit-field 'bit'}}
 #endif
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp

 #if TEST_STD_VER >= 11
     assert(globalMemCounter.checkOutstandingNewEq(0));
     { // Test rvalue references
         std::function<int(int)> f = A();
         assert(A::count == 1);
         assert(globalMemCounter.checkOutstandingNewEq(1));
         RTTI_ASSERT(f.target<A>());
         RTTI_ASSERT(f.target<int(*)(int)>() == 0);
-    LIBCPP_ASSERT_NOEXCEPT(std::function<int(int)>(std::move(f)));
+        LIBCPP_ASSERT_NOEXCEPT(std::function<int(int)>(std::move(f)));
 #if TEST_STD_VER > 17
-    ASSERT_NOEXCEPT(std::function<int(int)>(std::move(f)));
+        ASSERT_NOEXCEPT(std::function<int(int)>(std::move(f)));
 #endif
         std::function<int(int)> f2 = std::move(f);
         assert(A::count == 1);
         assert(globalMemCounter.checkOutstandingNewEq(1));
         RTTI_ASSERT(f2.target<A>());
         RTTI_ASSERT(f2.target<int(*)(int)>() == 0);
         RTTI_ASSERT(f.target<A>() == 0);
         RTTI_ASSERT(f.target<int(*)(int)>() == 0);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
         // Test that moving a function constructed from a reference wrapper
         // is done without allocating.
         DisableAllocationGuard g;
         using Ref = std::reference_wrapper<A>;
         A a;
         Ref aref(a);
         std::function<int(int)> f(aref);
         assert(A::count == 1);
         RTTI_ASSERT(f.target<A>() == nullptr);
         RTTI_ASSERT(f.target<Ref>());
-    LIBCPP_ASSERT_NOEXCEPT(std::function<int(int)>(std::move(f)));
+        LIBCPP_ASSERT_NOEXCEPT(std::function<int(int)>(std::move(f)));
 #if TEST_STD_VER > 17
-    ASSERT_NOEXCEPT(std::function<int(int)>(std::move(f)));
+        ASSERT_NOEXCEPT(std::function<int(int)>(std::move(f)));
 #endif
         std::function<int(int)> f2(std::move(f));
         assert(A::count == 1);
         RTTI_ASSERT(f2.target<A>() == nullptr);
         RTTI_ASSERT(f2.target<Ref>());
 #if defined(_LIBCPP_VERSION)
         RTTI_ASSERT(f.target<Ref>()); // f is unchanged because the target is small
 #endif
     }
     {
         // Test that moving a function constructed from a function pointer
         // is done without allocating
         DisableAllocationGuard guard;
         using Ptr = int(*)(int);
         Ptr p = g;
         std::function<int(int)> f(p);
         RTTI_ASSERT(f.target<A>() == nullptr);
         RTTI_ASSERT(f.target<Ptr>());
-    LIBCPP_ASSERT_NOEXCEPT(std::function<int(int)>(std::move(f)));
+        LIBCPP_ASSERT_NOEXCEPT(std::function<int(int)>(std::move(f)));
 #if TEST_STD_VER > 17
-    ASSERT_NOEXCEPT(std::function<int(int)>(std::move(f)));
+        ASSERT_NOEXCEPT(std::function<int(int)>(std::move(f)));
 #endif
         std::function<int(int)> f2(std::move(f));
         RTTI_ASSERT(f2.target<A>() == nullptr);
         RTTI_ASSERT(f2.target<Ptr>());
 #if defined(_LIBCPP_VERSION)
         RTTI_ASSERT(f.target<Ptr>()); // f is unchanged because the target is small
 #endif
     }
 #endif // TEST_STD_VER >= 11
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.unary/meta.unary.comp/is_bounded_array.pass.cpp

 
 #include <type_traits>
 
 #include "test_macros.h"
 
 template <class T, bool B>
 void test_array_imp()
 {
-  static_assert( B == std::is_bounded_array<T>::value, "" );
-  static_assert( B == std::is_bounded_array_v<T>, "" );
+    static_assert( B == std::is_bounded_array<T>::value, "" );
+    static_assert( B == std::is_bounded_array_v<T>, "" );
 }
 
 template <class T, bool B>
 void test_array()
 {
     test_array_imp<T, B>();
     test_array_imp<const T, B>();
     test_array_imp<volatile T, B>();
class Abstract
     virtual ~Abstract() = 0;
 };
 
 enum Enum {zero, one};
 typedef void (*FunctionPtr)();
 
 int main(int, char**)
 {
-//  Non-array types
-  test_array<void,           false>();
-  test_array<std::nullptr_t, false>();
-  test_array<int,            false>();
-  test_array<double,         false>();
-  test_array<void *,         false>();
-  test_array<int &,          false>();
-  test_array<int &&,         false>();
+    // Non-array types
+    test_array<void,           false>();
+    test_array<std::nullptr_t, false>();
+    test_array<int,            false>();
+    test_array<double,         false>();
+    test_array<void *,         false>();
+    test_array<int &,          false>();
+    test_array<int &&,         false>();
     test_array<Empty,          false>();
     test_array<Union,          false>();
     test_array<Abstract,       false>();
     test_array<Enum,           false>();
     test_array<FunctionPtr,    false>();
 
-//  Array types
+    // Array types
     test_array<char[3],           true>();
     test_array<int[0],            false>();
     test_array<char[],            false>();
     test_array<incomplete_type[], false>();
 
   return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.fail.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 struct NonDestructible { ~NonDestructible() = delete; };
 
 int main(int, char**)
 {
-  {
-  std::optional<char &> o1;          // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a reference type is ill-formed}}
-  std::optional<NonDestructible> o2;  // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
-  std::optional<char[20]> o3;          // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with an array type is ill-formed}}
-  }
+    {
+    std::optional<char &> o1;          // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a reference type is ill-formed}}
+    std::optional<NonDestructible> o2; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
+    std::optional<char[20]> o3;        // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with an array type is ill-formed}}
+    }
 
-  {
-  std::optional<               std::in_place_t> o1;  // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
-  std::optional<const          std::in_place_t> o2;  // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
-  std::optional<      volatile std::in_place_t> o3;  // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
-  std::optional<const volatile std::in_place_t> o4;  // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
-  }
+    {
+    std::optional<               std::in_place_t> o1; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
+    std::optional<const          std::in_place_t> o2; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
+    std::optional<      volatile std::in_place_t> o3; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
+    std::optional<const volatile std::in_place_t> o4; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
+    }
 
-  {
-  std::optional<               std::nullopt_t> o1;  // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
-  std::optional<const          std::nullopt_t> o2;  // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
-  std::optional<      volatile std::nullopt_t> o3;  // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
-  std::optional<const volatile std::nullopt_t> o4;  // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
-  }
+    {
+    std::optional<               std::nullopt_t> o1; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+    std::optional<const          std::nullopt_t> o2; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+    std::optional<      volatile std::nullopt_t> o3; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+    std::optional<const volatile std::nullopt_t> o4; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+    }
 
-  return 0;
+    return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp

 //     bool operator>(const unique_ptr<T, D>& x, nullptr_t);
 // template <class T, class D>
 //     bool operator>(nullptr_t, const unique_ptr<T, D>& y);
 // template <class T, class D>
 //     bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
 // template <class T, class D>
 //     bool operator>=(nullptr_t, const unique_ptr<T, D>& y);
 // template<class T, class D>
-//   requires three_­way_­comparable<typename unique_ptr<T, D>::pointer>
+//   requires three_way_comparable<typename unique_ptr<T, D>::pointer>
 //   constexpr compare_three_way_result_t<typename unique_ptr<T, D>::pointer>
 //     operator<=>(const unique_ptr<T, D>& x, nullptr_t);                            // C++20
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_comparisons.h"

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_const_move.pass.cpp

 //   constexpr explicit(see below)
 //     tuple<Types...>::tuple(allocator_arg_t, const Alloc& a,
 //     const tuple<UTypes...>&&);
 //
 // Constraints:
 //  sizeof...(Types) equals sizeof...(UTypes) &&
 //  (is_constructible_v<Types, decltype(get<I>(FWD(u)))> && ...) is true &&
 //  (
-//  sizeof...(Types) is not 1 ||
-//  (
-//    !is_convertible_v<decltype(u), T> &&
-//    !is_constructible_v<T, decltype(u)> &&
-//    !is_same_v<T, U>
-//  )
+//    sizeof...(Types) is not 1 ||
+//    (
+//      !is_convertible_v<decltype(u), T> &&
+//      !is_constructible_v<T, decltype(u)> &&
+//      !is_same_v<T, U>
+//    )
 //  )
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
 #include <cassert>
 #include <tuple>
 
 #include "convert_types.h"

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_non_const_copy.pass.cpp

 //   constexpr explicit(see below)
 //     tuple<Types...>::tuple(allocator_arg_t, const Alloc& a,
 //     tuple<UTypes...>&);
 //
 // Constraints:
 //  sizeof...(Types) equals sizeof...(UTypes) &&
 //  (is_constructible_v<Types, decltype(get<I>(FWD(u)))> && ...) is true &&
 //  (
-//  sizeof...(Types) is not 1 ||
-//  (
-//    !is_convertible_v<decltype(u), T> &&
-//    !is_constructible_v<T, decltype(u)> &&
-//    !is_same_v<T, U>
-//  )
+//    sizeof...(Types) is not 1 ||
+//    (
+//      !is_convertible_v<decltype(u), T> &&
+//      !is_constructible_v<T, decltype(u)> &&
+//      !is_same_v<T, U>
+//    )
 //  )
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
 #include <cassert>
 #include <tuple>
 
 #include "convert_types.h"

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_non_const_pair.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
 //
 //===----------------------------------------------------------------------===//
 
 // <tuple>
 
 // template <class... Types>
 // template <class Alloc, class U1, class U2>
 // constexpr explicit(see below)
-//   tuple<Types...>::tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&
-// u);
+//  tuple<Types...>::tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>& u);
 
 // Constraints:
 // - sizeof...(Types) is 2 and
 // - is_constructible_v<T0, decltype(get<0>(FWD(u)))> is true and
 // - is_constructible_v<T1, decltype(get<1>(FWD(u)))> is true.
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_const_move.pass.cpp

 // template <class... UTypes>
 //   constexpr explicit(see below) tuple<Types>::tuple(const
 //   tuple<UTypes...>&&);
 //
 // Constraints:
 //  sizeof...(Types) equals sizeof...(UTypes) &&
 //  (is_constructible_v<Types, decltype(get<I>(FWD(u)))> && ...) is true &&
 //  (
-//  sizeof...(Types) is not 1 ||
-//  (
-//    !is_convertible_v<decltype(u), T> &&
-//    !is_constructible_v<T, decltype(u)> &&
-//    !is_same_v<T, U>
-//  )
+//    sizeof...(Types) is not 1 ||
+//    (
+//      !is_convertible_v<decltype(u), T> &&
+//      !is_constructible_v<T, decltype(u)> &&
+//      !is_same_v<T, U>
+//    )
 //  )
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
 #include <cassert>
 #include <tuple>
 
 #include "convert_types.h"

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_non_const_copy.pass.cpp

 // template <class... Types>
 // template <class... UTypes>
 //   constexpr explicit(see below) tuple<Types>::tuple(tuple<UTypes...>&);
 //
 // Constraints:
 //  sizeof...(Types) equals sizeof...(UTypes) &&
 //  (is_constructible_v<Types, decltype(get<I>(FWD(u)))> && ...) is true &&
 //  (
-//  sizeof...(Types) is not 1 ||
-//  (
-//    !is_convertible_v<decltype(u), T> &&
-//    !is_constructible_v<T, decltype(u)> &&
-//    !is_same_v<T, U>
-//  )
+//    sizeof...(Types) is not 1 ||
+//    (
+//      !is_convertible_v<decltype(u), T> &&
+//      !is_constructible_v<T, decltype(u)> &&
+//      !is_same_v<T, U>
+//    )
 //  )
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
 #include <cassert>
 #include <tuple>
 
 #include "convert_types.h"

libcxx/test/support/filesystem_test_helper.h

static inline fs::path available_cwd_path() {
         }
         return p;
     }
 };
 
 /// This class generates the following tree:
 ///
 ///     static_test_env
-///     ├── bad_symlink -> dne
-///     ├── dir1
-///     │!! ├── dir2
-///     │!! │!! ├── afile3
-///     │!! │!! ├── dir3
-///     │!! │!! │!! └── file5
-///     │!! │!! ├── file4
-///     │!! │!! └── symlink_to_dir3 -> dir3
-///     │!! ├── file1
-///     │!! └── file2
-///     ├── empty_file
-///     ├── non_empty_file
-///     ├── symlink_to_dir -> dir1
-///     └── symlink_to_empty_file -> empty_file
+///     |-- bad_symlink -> dne
+///     |-- dir1
+///     |   |-- dir2
+///     |   |   |-- afile3
+///     |   |   |-- dir3
+///     |   |   |   `-- file5
+///     |   |   |-- file4
+///     |   |   `-- symlink_to_dir3 -> dir3
+///     |   `-- file1
+///     |   `-- file2
+///     |-- empty_file
+///     |-- non_empty_file
+///     |-- symlink_to_dir -> dir1
+///     `-- symlink_to_empty_file -> empty_file
 ///
 class static_test_env {
     scoped_test_env env_;
 public:
     static_test_env() {
         env_.create_symlink("dne", "bad_symlink", false);
         env_.create_dir("dir1");
         env_.create_dir("dir1/dir2");

libcxx/test/support/fp_compare.h

 #include <algorithm>  // for std::max
 #include <cassert>
 
 // See https://www.boost.org/doc/libs/1_70_0/libs/test/doc/html/boost_test/testing_tools/extended_comparison/floating_point/floating_points_comparison_theory.html
 
 template<typename T>
 bool fptest_close(T val, T expected, T eps)
 {
-  constexpr T zero = T(0);
-  assert(eps >= zero);
+    constexpr T zero = T(0);
+    assert(eps >= zero);
 
-//  Handle the zero cases
-  if (eps      == zero) return val == expected;
-  if (val      == zero) return std::abs(expected) <= eps;
-  if (expected == zero) return std::abs(val)      <= eps;
+    // Handle the zero cases
+    if (eps      == zero) return val == expected;
+    if (val      == zero) return std::abs(expected) <= eps;
+    if (expected == zero) return std::abs(val)      <= eps;
 
-  return std::abs(val - expected) < eps
-      && std::abs(val - expected)/std::abs(val) < eps;
+    return std::abs(val - expected) < eps
+        && std::abs(val - expected)/std::abs(val) < eps;
 }
 
 template<typename T>
 bool fptest_close_pct(T val, T expected, T percent)
 {
-  constexpr T zero = T(0);
-  assert(percent >= zero);
+    constexpr T zero = T(0);
+    assert(percent >= zero);
 
-//  Handle the zero cases
-  if (percent == zero) return val == expected;
-  T eps = (percent / T(100)) * std::max(std::abs(val), std::abs(expected));
+    // Handle the zero cases
+    if (percent == zero) return val == expected;
+    T eps = (percent / T(100)) * std::max(std::abs(val), std::abs(expected));
 
-  return fptest_close(val, expected, eps);
+    return fptest_close(val, expected, eps);
 }
 
 
 #endif // SUPPORT_FP_COMPARE_H

libcxx/utils/ci/run-buildbot

if [ -s ${BUILD_DIR}/generated_output.status ]; then
         echo "It looks like not all the generator scripts were run,"
         echo "did you forget to build the libcxx-generate-files target?"
         echo "Did you add all new files it generated?"
         false
     fi
 
     # Reject patches that introduce non-ASCII characters or hard tabs.
     # Depends on LC_COLLATE set at the top of this script.
-    ! grep -rn '[^ -~]' libcxx/include/ || false
+    ! grep -rn '[^ -~]' libcxx/include libcxx/src libcxx/test libcxx/benchmarks \
+           --exclude '*.dat' \
+           --exclude 'std_format_spec_string_unicode.bench.cpp' \
+           --exclude 'grep.pass.cpp' \
+           --exclude 'locale-specific_form.pass.cpp' \
+           --exclude 'format_tests.h' || false
 
     # Reject code with trailing whitespace
     ! grep -rn '[[:blank:]]$' libcxx/include libcxx/src libcxx/test libcxx/benchmarks || false
 
     # Reject patches that introduce dependency cycles in the headers.
     python3 libcxx/utils/graph_header_deps.py >/dev/null
 ;;
 generic-cxx03)