Implement the second part of P0482 (char8_t)

[mclow.lists]

Summary

The first part was type_traits and numeric_limits (already committed)
This implements the changes to string/string/view/char_traits

I defined the feature test macro __cpp_lib_char8_t even though we don't fully support it (yet) because I want the tests to use it.

Drive-by fixes include fixing the rest of the feature-test macros which were using the never-defined symbol _TEST_STD_VER.

There's more to come on P0482, but this is a self-contained chunk.

[mclow.lists]

test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp

79

Oops. This was supposed to be an addition, not a replacement

test/std/strings/string.view/string_view.literals/literal.pass.cpp

21

Remove this comment.

39

Tab

[ldionne]

Two overarching comments.

1. Maybe we could/should encapsulate the logic for checking the feature test macro in a utility header for the tests. This way, we wouldn't have to copy/paste

#if TEST_STD_VER > 17
  LIBCPP_ASSERT(IS_DEFINED(__cpp_lib_char8_t)); // libc++ implements this
# if defined(__cpp_lib_char8_t)
#  if __cpp_lib_char8_t < 201811L
#   error "__cpp_lib_char8_t has an invalid value"
#  endif
# endif
#endif

so many times. Also, it would then be reasonable to have this instead:

#if TEST_STD_VER > 17
# if defined(_LIBCPP_VERSION) && !defined(__cpp_lib_char8_t)
#   error "libc++ implements this"
# endif
# if defined(__cpp_lib_char8_t)
#  if __cpp_lib_char8_t < 201811L
#   error "__cpp_lib_char8_t has an invalid value"
#  endif
# endif
#endif

This would remove the need for the IS_DEFINED macro, which is a bit hacky.

2. Maybe we should consider having a LIT feature to represent char8_t support, that way we could mark tests as unsupported? Otherwise, I would say just assume that a compiler implementing c++2a supports char8_t and don't bother disabling the tests.

test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp

19

This should be <istream>

test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp

19

<limits>

test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp

19

<locale>

test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp

19

<ostream>

test/std/strings/basic.string.hash/enabled_hashes.pass.cpp

26

Why would the value ever be less than 201811L? Genuinely asking.

test/std/strings/basic.string.literals/literal.pass.cpp

19

I don't understand the part of the comment that says "re-enable when we implement that". With this patch, I think defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L is true, right?

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.cpp

25

This would have to be guarded in a #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L too, I think.

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.cpp

26

This needs to be guarded in a #if too?

[mclow.lists]

In D55308#1320586, @ldionne wrote:

2. Maybe we should consider having a LIT feature to represent char8_t support, that way we could mark tests as unsupported?

I thought about that, but I didn't want to start a trend of adding lit features (because there would be several).

Otherwise, I would say just assume that a compiler implementing c++2a supports char8_t and don't bother disabling the tests.

This is demonstrably untrue.
clang 7.0, for example, supports -std=c++2a but not char8_t.

test/std/strings/basic.string.literals/literal.pass.cpp

19

I have removed this.

[mclow.lists]

In D55308#1320586, @ldionne wrote:

Two overarching comments.

1. Maybe we could/should encapsulate the logic for checking the feature test macro in a utility header for the tests. This way, we wouldn't have to copy/paste

#if TEST_STD_VER > 17
  LIBCPP_ASSERT(IS_DEFINED(__cpp_lib_char8_t)); // libc++ implements this
# if defined(__cpp_lib_char8_t)
#  if __cpp_lib_char8_t < 201811L
#   error "__cpp_lib_char8_t has an invalid value"
#  endif
# endif
#endif

so many times. Also, it would then be reasonable to have this instead:

#if TEST_STD_VER > 17
# if defined(_LIBCPP_VERSION) && !defined(__cpp_lib_char8_t)
#   error "libc++ implements this"
# endif
# if defined(__cpp_lib_char8_t)
#  if __cpp_lib_char8_t < 201811L
#   error "__cpp_lib_char8_t has an invalid value"
#  endif
# endif
#endif

This would remove the need for the IS_DEFINED macro, which is a bit tacky.

Agreed.
Though I like the formulation that I posted to livcxx-dev:

#if TEST_STD_VER > 17
# if !defined(__cpp_lib_char8_t)  
  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
# else
#  if __cpp_lib_char8_t < 201811L
#   error "__cpp_lib_char8_t has an invalid value"
#  endif
# endif
#endif

This fails silently if the macro is not defined - for libraries other than libc++.
If other library maintainers want to add (say) a libstdc++-specific assertion, then there's a place for it.

[mclow.lists]

test/std/strings/basic.string.hash/enabled_hashes.pass.cpp

26

No, but it could get bigger (if we add other char8_t stuff, and then the test for the new stuff would be:
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201903L, so I just used the same pattern.

[mclow.lists]

Addressed Louis' comments.

[mclow.lists]

test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp

19

Whoops. Should be <ostream> Will fix before commit.

[ldionne]

In D55308#1320679, @mclow.lists wrote:

Agreed.
Though I like the formulation that I posted to livcxx-dev:

#if TEST_STD_VER > 17
# if !defined(__cpp_lib_char8_t)  
  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
# else
#  if __cpp_lib_char8_t < 201811L
#   error "__cpp_lib_char8_t has an invalid value"
#  endif
# endif
#endif

This fails silently if the macro is not defined - for libraries other than libc++.
If other library maintainers want to add (say) a libstdc++-specific assertion, then there's a place for it.

I'd err on the side of what Richard said and always assert, but otherwise I'm fine with something like this. But it would be nice to extract this check into a separate utility header to avoid duplication.

test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp

19

Still wrong?

test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp

19

Still wrong?

[mclow.lists]

In D55308#1321975, @ldionne wrote:

In D55308#1320679, @mclow.lists wrote:

Agreed.
Though I like the formulation that I posted to livcxx-dev:

#if TEST_STD_VER > 17
# if !defined(__cpp_lib_char8_t)  
  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
# else
#  if __cpp_lib_char8_t < 201811L
#   error "__cpp_lib_char8_t has an invalid value"
#  endif
# endif
#endif

This fails silently if the macro is not defined - for libraries other than libc++.
If other library maintainers want to add (say) a libstdc++-specific assertion, then there's a place for it.

I'd err on the side of what Richard said and always assert, but otherwise I'm fine with something like this.

I would not; consider the test algorithm.version.pass.cpp, which should check for six different flags. Do you want that test to fail until libc++ implements all six of them? I do not. I want the tests to check for all the flags that libc++ has defined, and make sure that they are (a) defined, and (b) have a sane value. Things that we haven't implemented yet should not cause test failures.

But it would be nice to extract this check into a separate utility header to avoid duplication.

I don't think that's a good idea; that header would quickly grow into all the tests for all the feature flags.
But I'm willing to discuss that.

[mclow.lists]

In D55308#1323439, @mclow.lists wrote:

In D55308#1321975, @ldionne wrote:

But it would be nice to extract this check into a separate utility header to avoid duplication.

I don't think that's a good idea; that header would quickly grow into all the tests for all the feature flags.
But I'm willing to discuss that.

Or at least all the tests for all the feature flags that have to support more than one header.

[mclow.lists]

test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp

19

Fixed locally.

test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp

19

Fixed locally.

[ldionne]

In D55308#1323439, @mclow.lists wrote:

I would not; consider the test algorithm.version.pass.cpp, which should check for six different flags. Do you want that test to fail until libc++ implements all six of them? I do not. I want the tests to check for all the flags that libc++ has defined, and make sure that they are (a) defined, and (b) have a sane value. Things that we haven't implemented yet should not cause test failures.

I disagree here (in an ideal world). Otherwise, what we have is not a C++ Standard conformance test suite, it's a libc++ test suite only. But okay, that's part of a larger discussion anyway.

But it would be nice to extract this check into a separate utility header to avoid duplication.

I don't think that's a good idea; that header would quickly grow into all the tests for all the feature flags.
But I'm willing to discuss that.

That would be one header per feature-test macro. Maybe that's too much, but I dislike the replication. Leave it as-is, we can always change later when we define more feature test macros if it makes sense then.

include/__string

404

_LIBCPP_INLINE_VISIBILITY here and below.

484

nullptr?

include/string

4173

I hate feature test macros already. This should just be #if _LIBCPP_STD_VER > 17... Can't we take the slightly more aggressive stance of "if you're trying to use libc++ as a c++20 library but your compiler does not support c++20, you're out of luck"?

[mclow.lists]

include/__string

404

Right.

484

Meh. Sure.
Not going to go back and fix the other char_traits specializations in this patch, though.

include/string

4173

I hate feature test macros already.

Agreed.

Can't we take the slightly more aggressive stance of "if you're trying to use libc++ as a c++20 library but your compiler does not support c++20, you're out of luck"

We can't do that, because (for example) LLVM 7.0 claims to support C++20, but doesn't support char8_t.

In general, I agree with you, but this feature (char8_t) requires a compiler feature, or it doesn't work.

[mclow.lists]

include/__string

404

After talking with Louis, we decided that *all* of the char_traits stuff needs _LIBCPP_INLINE_VISIBILITY pixie dust (for the case when _LIBCPP_HIDE_FROM_ABI_PER_TU is defined), but we'll handle that in a different patch.

[ldionne]

include/string

4173

We can't do that, because (for example) LLVM 7.0 claims to support C++20, but doesn't support char8_t.

Isn't that claim wrong, then? Also, surely you can't claim you implement C++20 at this point since it hasn't been voted?

I'm not trying to be rhetorical -- I'd _really_ like to avoid having to guard everything with a feature test macro because that will make the library much more complex and I'm sure it will introduce some tricky bugs. Just supporting many compilers and many C++ Standard versions is already difficult -- supporting partial implementations of a standard scares me a lot.

[mclow.lists]

include/string

4173

I agree; we don't want to do that; and, in general, we won't need to do so.

BUT, in this case, we need a particular bit of functionality from the compiler, and the way to see if the compiler has implemented it is via a feature-test macro. In other places, we use __has_builtin or other ways of querying the compiler. This is the first place (that I know of) that we're using a feature-test macro to do so.

[mclow.lists]

include/string

4173

Would you feel better if I defined _LIBCPP_HAS_CHAR8_T in <__config> and used that throughout?

It would look like this:

#if _LIBCPP_STD_VER > 17 && defined(__cpp_char8_t)
#define _LIBCPP_HAS_CHAR8_T
#endif

[ldionne]

LGTM with the fixes to the tests.

include/string

4173

Ah, I see. No, I think using __cpp_char8_t is OK in that case -- I wasn't seeing it that way.

[mclow.lists]

include/string

4173

Instead I turned it around:

#if _LIBCPP_STD_VER <= 17 || !defined(__cpp_char8_t)
#define _LIBCPP_HAS_NO_CHAR8_T
#endif

That way someone can #define _LIBCPP_HAS_NO_CHAR8_T and it will all go away.

[mclow.lists]

Committed as revision 348828

include/__string

 
 template <> struct char_traits<char>;
 template <> struct char_traits<wchar_t>;
+template <> struct char_traits<char8_t>;  // c++20
 
 }  // std
 

 }
 
 
+#if _LIBCPP_STD_VER > 17 && defined(__cpp_char8_t)
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS char_traits<char8_t>
+{
+    typedef char8_t        char_type;
+    typedef unsigned int   int_type;
+    typedef streamoff      off_type;
+    typedef u8streampos    pos_type;
+    typedef mbstate_t      state_type;
+
+    static inline constexpr void assign(char_type& __c1, const char_type& __c2) noexcept
+        {__c1 = __c2;}
+    static inline constexpr bool eq(char_type __c1, char_type __c2) noexcept
+        {return __c1 == __c2;}
+    static inline constexpr bool lt(char_type __c1, char_type __c2) noexcept
+        {return __c1 < __c2;}
+
+    static constexpr
+    int              compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
+
+    static constexpr
+    size_t           length(const char_type* __s) _NOEXCEPT;
+ 
+    _LIBCPP_INLINE_VISIBILITY static constexpr
+    const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
+ 
+    static char_type*       move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
+        {return __n == 0 ? __s1 : (char_type*) memmove(__s1, __s2, __n);}
+ 
+    static char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
+       {
+            _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
+            return __n == 0 ? __s1 : (char_type*)memcpy(__s1, __s2, __n);
+       }
+ 
+    static char_type*       assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
+        {return __n == 0 ? __s : (char_type*)memset(__s, to_int_type(__a), __n);}
+
+    static inline constexpr int_type  not_eof(int_type __c) noexcept
+        {return eq_int_type(__c, eof()) ? ~eof() : __c;}
+    static inline constexpr char_type to_char_type(int_type __c) noexcept
+        {return char_type(__c);}
+    static inline constexpr int_type to_int_type(char_type __c) noexcept
+        {return int_type(__c);}
+    static inline constexpr bool eq_int_type(int_type __c1, int_type __c2) noexcept
+        {return __c1 == __c2;}
+    static inline constexpr int_type eof() noexcept
+        {return int_type(EOF);}
+};
+
+// TODO use '__builtin_strlen' if it ever supports char8_t ??
+inline constexpr
+size_t
+char_traits<char8_t>::length(const char_type* __s) _NOEXCEPT
+{
+    size_t __len = 0;
+    for (; !eq(*__s, char_type(0)); ++__s)
+        ++__len;
+    return __len;
+}
+
+inline constexpr
+int
+char_traits<char8_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
+{
+#if __has_feature(cxx_constexpr_string_builtins)
+    return __builtin_memcmp(__s1, __s2, __n);
+#else
+    for (; __n; --__n, ++__s1, ++__s2)
+    {
+        if (lt(*__s1, *__s2))
+            return -1;
+        if (lt(*__s2, *__s1))
+            return 1;
+    }
+    return 0;
+#endif
+}
+
+// TODO use '__builtin_char_memchr' if it ever supports char8_t ??
+inline constexpr
+const char8_t*
+char_traits<char8_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
+{
+    for (; __n; --__n)
+    {
+        if (eq(*__s, __a))
+            return __s;
+        ++__s;
+    }
+    return 0;
+}
+
+#endif // _LIBCPP_STD_VER > 17 && defined(__cpp_char8_t)
+
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 
 template <>

include/iosfwd

 {
 
 template<class charT> struct char_traits;
+template<>            struct char_traits<char>;
+template<>            struct char_traits<char8_t>;  // C++20
+template<>            struct char_traits<char16_t>;
+template<>            struct char_traits<char32_t>;
+template<>            struct char_traits<wchar_t>;
+
 template<class T>     class allocator;
 
 class ios_base;

 class _LIBCPP_TYPE_VIS ios_base;
 
 template<class _CharT>  struct _LIBCPP_TEMPLATE_VIS char_traits;
+template<> struct char_traits<char>;
+#if _LIBCPP_STD_VER > 17 && defined(__cpp_char8_t)
+template<> struct char_traits<char8_t>;
+#endif
+template<> struct char_traits<char16_t>;
+template<> struct char_traits<char32_t>;
+template<> struct char_traits<wchar_t>;
+
 template<class _Tp>     class _LIBCPP_TEMPLATE_VIS allocator;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >

 template <class _State>             class _LIBCPP_TEMPLATE_VIS fpos;
 typedef fpos<mbstate_t>    streampos;
 typedef fpos<mbstate_t>    wstreampos;
+#if _LIBCPP_STD_VER > 17 && defined(__cpp_char8_t)
+typedef fpos<mbstate_t>    u8streampos;
+#endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 typedef fpos<mbstate_t>    u16streampos;
 typedef fpos<mbstate_t>    u32streampos;

include/istream

 */
 
 #include <__config>
+#include <version>
 #include <ostream>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

include/limits

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
+#include <version>
 
 
 _LIBCPP_BEGIN_NAMESPACE_STD

include/locale

 #include <streambuf>
 #include <iterator>
 #include <limits>
+#include <version>
 #ifndef __APPLE__
 #include <cstdarg>
 #endif

include/ostream

 #include <locale>
 #include <iterator>
 #include <bitset>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/string

     __lhs.swap(__rhs);
 }
 
+#if _LIBCPP_STD_VER > 17 && defined(__cpp_char8_t)
+typedef basic_string<char8_t> u8string;
+#endif
+
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-
 typedef basic_string<char16_t> u16string;
 typedef basic_string<char32_t> u32string;
-
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
 
 _LIBCPP_FUNC_VIS int                stoi  (const string& __str, size_t* __idx = 0, int __base = 10);

         return basic_string<wchar_t> (__str, __len);
     }
 
+#if _LIBCPP_STD_VER > 17 && defined(__cpp_char8_t)
     inline _LIBCPP_INLINE_VISIBILITY
+    basic_string<char8_t> operator "" s(const char8_t *__str, size_t __len) _NOEXCEPT
+    {
+        return basic_string<char8_t> (__str, __len);
+    }
+#endif
+
+    inline _LIBCPP_INLINE_VISIBILITY
     basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len )
     {
         return basic_string<char16_t> (__str, __len);

include/string_view

 }
 
 typedef basic_string_view<char>     string_view;
+#if _LIBCPP_STD_VER > 17 && defined(__cpp_char8_t)
+typedef basic_string_view<char8_t>  u8string_view;
+#endif
 typedef basic_string_view<char16_t> u16string_view;
 typedef basic_string_view<char32_t> u32string_view;
 typedef basic_string_view<wchar_t>  wstring_view;

         return basic_string_view<wchar_t> (__str, __len);
     }
 
+#if _LIBCPP_STD_VER > 17 && defined(__cpp_char8_t)
     inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+    basic_string_view<char8_t> operator "" sv(const char8_t *__str, size_t __len) _NOEXCEPT
+    {
+        return basic_string_view<char8_t> (__str, __len);
+    }
+#endif
+
+    inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     basic_string_view<char16_t> operator "" sv(const char16_t *__str, size_t __len) _NOEXCEPT
     {
         return basic_string_view<char16_t> (__str, __len);

include/version

 __cpp_lib_bool_constant                     201505L <type_traits>
 __cpp_lib_boyer_moore_searcher              201603L <functional>
 __cpp_lib_byte                              201603L <cstddef>
+__cpp_lib_char8_t                           201811L <atomic> <filesystem> <istream> <limits>
+                                                    <locale> <ostream> <string> <string_view>
 __cpp_lib_chrono                            201611L <chrono>
 __cpp_lib_chrono_udls                       201304L <chrono>
 __cpp_lib_clamp                             201603L <algorithm>

 #endif
 
 #if _LIBCPP_STD_VER > 17
+#ifdef __cpp_char8_t
+# define __cpp_lib_char8_t                              201811L
 #endif
+#endif
 
 #endif  // _LIBCPP_VERSIONH

test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp

 */
 
 #include <algorithm>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp

 */
 
 #include <any>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp

 */
 
 #include <array>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp

 // <atomic> feature macros
 
 /*  Constant                                    Value
+    __cpp_lib_char8_t                           201811L
     __cpp_lib_atomic_is_always_lock_free        201603L
     __cpp_lib_atomic_ref                        201806L
 

 // UNSUPPORTED: libcpp-has-no-threads
 
 #include <atomic>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

 {
 //  ensure that the macros that are supposed to be defined in <atomic> are defined.
 
-#if _TEST_STD_VER > 14
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_char8_t)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# else
+#  if __cpp_lib_char8_t < 201811L
+#   error "__cpp_lib_char8_t has an invalid value"
+#  endif
+# endif
+#endif
+
+#if TEST_STD_VER > 14
 # if !defined(__cpp_lib_atomic_is_always_lock_free)
 #  error "__cpp_lib_atomic_is_always_lock_free is not defined"
 # elif __cpp_lib_atomic_is_always_lock_free < 201603L

test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp

 */
 
 #include <bit>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/charconv.pass.cpp

 */
 
 #include <charconv>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp

 */
 
 #include <chrono>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp

 */
 
 #include <cmath>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp

 */
 
 #include <complex>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/concepts.version.pass.cpp

 
 // XFAIL
 // #include <concepts>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp

 */
 
 #include <cstddef>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp

 */
 
 #include <deque>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp

 */
 
 #include <exception>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/execution.version.pass.cpp

 
 // XFAIL
 // #include <execution>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp

 // <filesystem> feature macros
 
 /*  Constant                                    Value
+    __cpp_lib_char8_t                           201811L
     __cpp_lib_filesystem                        201703L
 
 */
 
 #include <filesystem>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

 {
 //  ensure that the macros that are supposed to be defined in <filesystem> are defined.
 
-#if _TEST_STD_VER > 14
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_char8_t)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# else
+#  if __cpp_lib_char8_t < 201811L
+#   error "__cpp_lib_char8_t has an invalid value"
+#  endif
+# endif
+#endif
+
+#if TEST_STD_VER > 14
 # if !defined(__cpp_lib_filesystem)
 #  error "__cpp_lib_filesystem is not defined"
 # elif __cpp_lib_filesystem < 201703L

test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp

 */
 
 #include <forward_list>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp

 */
 
 #include <functional>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

 {
 //  ensure that the macros that are supposed to be defined in <functional> are defined.
 
-#if _TEST_STD_VER > 14
+#if TEST_STD_VER > 14
 # if !defined(__cpp_lib_invoke)
 #  error "__cpp_lib_invoke is not defined"
 # elif __cpp_lib_invoke < 201411L

test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp

 */
 
 #include <iomanip>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/istream.version.pass.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <istream> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_char8_t                           201811L
+
+*/
+
+#include <istream>
+#include <cassert>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <istream> are defined.
+
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_char8_t)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# else
+#  if __cpp_lib_char8_t < 201811L
+#   error "__cpp_lib_char8_t has an invalid value"
+#  endif
+# endif
+#endif
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp

 */
 
 #include <iterator>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/limits.version.pass.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <limits> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_char8_t                           201811L
+
+*/
+
+#include <istream>
+#include <cassert>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <limits> are defined.
+
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_char8_t)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# else
+#  if __cpp_lib_char8_t < 201811L
+#   error "__cpp_lib_char8_t has an invalid value"
+#  endif
+# endif
+#endif
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp

 */
 
 #include <list>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/locale.version.pass.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <locale> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_char8_t                           201811L
+
+*/
+
+#include <istream>
+#include <cassert>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <locale> are defined.
+
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_char8_t)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# else
+#  if __cpp_lib_char8_t < 201811L
+#   error "__cpp_lib_char8_t has an invalid value"
+#  endif
+# endif
+#endif
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp

 */
 
 #include <map>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp

 */
 
 #include <memory>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/memory_resource.version.pass.cpp

 
 // XFAIL
 // #include <memory_resource>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp

 */
 
 #include <mutex>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp

 */
 
 #include <new>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp

 */
 
 #include <numeric>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp

 */
 
 #include <optional>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/ostream.version.pass.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <ostream> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_char8_t                           201811L
+
+*/
+
+#include <istream>
+#include <cassert>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <ostream> are defined.
+
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_char8_t)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# else
+#  if __cpp_lib_char8_t < 201811L
+#   error "__cpp_lib_char8_t has an invalid value"
+#  endif
+# endif
+#endif
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp

 */
 
 #include <regex>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp

 */
 
 #include <scoped_allocator>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp

 */
 
 #include <set>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 
 #include <shared_mutex>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp

 
 /*  Constant                                    Value
     __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_char8_t                           201811L
     __cpp_lib_nonmember_container_access        201411L
     __cpp_lib_string_udls                       201304L
     __cpp_lib_string_view                       201606L

 */
 
 #include <string>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

 {
 //  ensure that the macros that are supposed to be defined in <string> are defined.
 
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_char8_t)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# else
+#  if __cpp_lib_char8_t < 201811L
+#   error "__cpp_lib_char8_t has an invalid value"
+#  endif
+# endif
+#endif
+
 /*
 #if !defined(__cpp_lib_fooby)
 # error "__cpp_lib_fooby is not defined"

test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp

 // <string_view> feature macros
 
 /*  Constant                                    Value
+    __cpp_lib_char8_t                           201811L
     __cpp_lib_string_view                       201606L
 
 */
 
 #include <string_view>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

 {
 //  ensure that the macros that are supposed to be defined in <string_view> are defined.
 
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_char8_t)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# else
+#  if __cpp_lib_char8_t < 201811L
+#   error "__cpp_lib_char8_t has an invalid value"
+#  endif
+# endif
+#endif
+
 /*
 #if !defined(__cpp_lib_fooby)
 # error "__cpp_lib_fooby is not defined"

test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp

 */
 
 #include <tuple>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp

 */
 
 #include <type_traits>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

 {
 //  ensure that the macros that are supposed to be defined in <type_traits> are defined.
 
-#if _TEST_STD_VER > 14
+#if TEST_STD_VER > 14
 # if !defined(__cpp_lib_void_t)
 #  error "__cpp_lib_void_t is not defined"
 # elif __cpp_lib_void_t < 201411L

test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp

 */
 
 #include <unordered_map>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp

 */
 
 #include <unordered_set>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp

 */
 
 #include <utility>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp

 */
 
 #include <variant>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp

 */
 
 #include <vector>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

 */
 
 #include <version>
+#include <cassert>
 #include "test_macros.h"
 
 int main()

 {
 //  ensure that the macros that are supposed to be defined in <version> are defined.
 
-#if _TEST_STD_VER > 14
+#if TEST_STD_VER > 14
 # if !defined(__cpp_lib_atomic_is_always_lock_free)
 #  error "__cpp_lib_atomic_is_always_lock_free is not defined"
 # elif __cpp_lib_atomic_is_always_lock_free < 201603L

 # endif
 #endif
 
-#if _TEST_STD_VER > 14
+#if TEST_STD_VER > 14
 # if !defined(__cpp_lib_filesystem)
 #  error "__cpp_lib_filesystem is not defined"
 # elif __cpp_lib_filesystem < 201703L

 # endif
 #endif
 
-#if _TEST_STD_VER > 14
+#if TEST_STD_VER > 14
 # if !defined(__cpp_lib_invoke)
 #  error "__cpp_lib_invoke is not defined"
 # elif __cpp_lib_invoke < 201411L

 # endif
 #endif
 
-#if _TEST_STD_VER > 14
+#if TEST_STD_VER > 14
 # if !defined(__cpp_lib_void_t)
 #  error "__cpp_lib_void_t is not defined"
 # elif __cpp_lib_void_t < 201411L

 # endif
 #endif
 
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_char8_t)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# else
+#  if __cpp_lib_char8_t < 201811L
+#   error "__cpp_lib_char8_t has an invalid value"
+#  endif
+# endif
+#endif
+
 /*
 #if !defined(__cpp_lib_fooby)
 # error "__cpp_lib_fooby is not defined"

test/std/strings/basic.string.hash/enabled_hashes.pass.cpp

   {
     test_hash_enabled_for_type<std::string>();
     test_hash_enabled_for_type<std::wstring>();
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test_hash_enabled_for_type<std::u8string>();
+#endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test_hash_enabled_for_type<std::u16string>();
     test_hash_enabled_for_type<std::u32string>();

test/std/strings/basic.string.hash/strings.pass.cpp

 int main()
 {
     test<std::string>();
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test<std::u8string>();
+#endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<std::u16string>();
     test<std::u32string>();

test/std/strings/basic.string.literals/literal.pass.cpp

 
 #include "test_macros.h"
 
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    typedef std::u8string u8string;
+#else
+    typedef std::string   u8string;
+#endif
+
+
 int main()
 {
     using namespace std::literals::string_literals;
 
     static_assert ( std::is_same<decltype(   "Hi"s), std::string>::value, "" );
-//  This is changed by P0482 to return a std::u8string
-#if TEST_STD_VER <= 17
-    static_assert ( std::is_same<decltype( u8"Hi"s), std::string>::value, "" );
-#endif
+    static_assert ( std::is_same<decltype( u8"Hi"s), u8string>::value, "" );
     static_assert ( std::is_same<decltype(  L"Hi"s), std::wstring>::value, "" );
     static_assert ( std::is_same<decltype(  u"Hi"s), std::u16string>::value, "" );
     static_assert ( std::is_same<decltype(  U"Hi"s), std::u32string>::value, "" );

 
     std::string foo;
     std::wstring Lfoo;
+    u8string u8foo;
     std::u16string ufoo;
     std::u32string Ufoo;
 
-    foo  =   ""s;     assert( foo.size() == 0);
-//  This is changed by P0482 to return a std::u8string
-#if TEST_STD_VER <= 17
-    foo  = u8""s;     assert( foo.size() == 0);
-#endif
-    Lfoo =  L""s;     assert(Lfoo.size() == 0);
-    ufoo =  u""s;     assert(ufoo.size() == 0);
-    Ufoo =  U""s;     assert(Ufoo.size() == 0);
+    foo   =   ""s;     assert(  foo.size() == 0);
+    u8foo = u8""s;     assert(u8foo.size() == 0);
+    Lfoo  =  L""s;     assert( Lfoo.size() == 0);
+    ufoo  =  u""s;     assert( ufoo.size() == 0);
+    Ufoo  =  U""s;     assert( Ufoo.size() == 0);
 
-    foo  =   " "s;     assert( foo.size() == 1);
-//  This is changed by P0482 to return a std::u8string
-#if TEST_STD_VER <= 17
-    foo  = u8" "s;     assert( foo.size() == 1);
-#endif
-    Lfoo =  L" "s;     assert(Lfoo.size() == 1);
-    ufoo =  u" "s;     assert(ufoo.size() == 1);
-    Ufoo =  U" "s;     assert(Ufoo.size() == 1);
+    foo   =   " "s;    assert(  foo.size() == 1);
+    u8foo = u8" "s;    assert(u8foo.size() == 1);
+    Lfoo  =  L" "s;    assert( Lfoo.size() == 1);
+    ufoo  =  u" "s;    assert( ufoo.size() == 1);
+    Ufoo  =  U" "s;    assert( Ufoo.size() == 1);
 
-    foo  =   "ABC"s;     assert( foo ==   "ABC");   assert( foo == std::string   (  "ABC"));
-//  This is changed by P0482 to return a std::u8string
-#if TEST_STD_VER <= 17
-    foo  = u8"ABC"s;     assert( foo == u8"ABC");   assert( foo == std::string   (u8"ABC"));
-#endif
-    Lfoo =  L"ABC"s;     assert(Lfoo ==  L"ABC");   assert(Lfoo == std::wstring  ( L"ABC"));
-    ufoo =  u"ABC"s;     assert(ufoo ==  u"ABC");   assert(ufoo == std::u16string( u"ABC"));
-    Ufoo =  U"ABC"s;     assert(Ufoo ==  U"ABC");   assert(Ufoo == std::u32string( U"ABC"));
+    foo   =   "ABC"s;     assert(  foo ==   "ABC");   assert(  foo == std::string   (  "ABC"));
+    u8foo = u8"ABC"s;     assert(u8foo == u8"ABC");   assert(u8foo == u8string      (u8"ABC"));
+    Lfoo  =  L"ABC"s;     assert( Lfoo ==  L"ABC");   assert( Lfoo == std::wstring  ( L"ABC"));
+    ufoo  =  u"ABC"s;     assert( ufoo ==  u"ABC");   assert( ufoo == std::u16string( u"ABC"));
+    Ufoo  =  U"ABC"s;     assert( Ufoo ==  U"ABC");   assert( Ufoo == std::u32string( U"ABC"));
 }

test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp

     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
     }
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     {
+    std::u8string_view sv = u8"12345678901234";
+    std::basic_string s1{sv, min_allocator<char8_t>{}};
+    using S = decltype(s1); // what type did we get?
+    static_assert(std::is_same_v<S::value_type,                      char8_t>,  "");
+    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char8_t>>, "");
+    static_assert(std::is_same_v<S::allocator_type,    min_allocator<char8_t>>, "");
+    assert(s1.size() == sv.size());
+    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    }
+#endif
+    {
     std::u16string_view sv = u"12345678901234";
     std::basic_string s1{sv, min_allocator<char16_t>{}};
     using S = decltype(s1); // what type did we get?

test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp

     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
     }
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     {
+    std::u8string_view sv = u8"12345678901234";
+    std::basic_string s1{sv, 0, 4, min_allocator<char8_t>{}};
+    using S = decltype(s1); // what type did we get?
+    static_assert(std::is_same_v<S::value_type,                      char8_t>,  "");
+    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char8_t>>, "");
+    static_assert(std::is_same_v<S::allocator_type,    min_allocator<char8_t>>, "");
+    assert(s1.size() == 4);
+    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    }
+#endif
+    {
     std::u16string_view sv = u"12345678901234";
     std::basic_string s1{sv, 0, 4, min_allocator<char16_t>{}};
     using S = decltype(s1); // what type did we get?

test/std/strings/basic.string/string.iterators/iterators.pass.cpp

         assert ( !(ii1 != cii ));
     }
 
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    {
+        typedef std::u8string C;
+        C::iterator ii1{}, ii2{};
+        C::iterator ii4 = ii1;
+        C::const_iterator cii{};
+        assert ( ii1 == ii2 );
+        assert ( ii1 == ii4 );
+        assert ( ii1 == cii );
+        assert ( !(ii1 != ii2 ));
+        assert ( !(ii1 != cii ));
+    }
+#endif
+
     { // N3644 testing
         typedef std::u16string C;
         C::iterator ii1{}, ii2{};

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.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++98, c++03, c++11, c++14, c++17
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static constexpr void assign(char_type& c1, const char_type& c2);
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+constexpr bool test_constexpr()
+{
+    char8_t c = u'1';
+    std::char_traits<char8_t>::assign(c, u'a');
+    return c == u'a';
+}
+
+int main()
+{
+    char8_t c = u8'\0';
+    std::char_traits<char8_t>::assign(c, u8'a');
+    assert(c == u8'a');
+
+    static_assert(test_constexpr(), "");
+}
+#else
+int main () {}
+#endif

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static char_type* assign(char_type* s, size_t n, char_type a);
+
+#include <string>
+#include <cassert>
+
+int main()
+{
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    char8_t s2[3] = {0};
+    assert(std::char_traits<char8_t>::assign(s2, 3, char8_t(5)) == s2);
+    assert(s2[0] == char8_t(5));
+    assert(s2[1] == char8_t(5));
+    assert(s2[2] == char8_t(5));
+    assert(std::char_traits<char8_t>::assign(NULL, 0, char8_t(5)) == NULL);
+#endif
+}

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/compare.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static constexpr int compare(const char_type* s1, const char_type* s2, size_t n);
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+constexpr bool test_constexpr()
+{
+    return std::char_traits<char8_t>::compare(u8"123", u8"223", 3) < 0
+        && std::char_traits<char8_t>::compare(u8"223", u8"123", 3) > 0
+        && std::char_traits<char8_t>::compare(u8"123", u8"123", 3) == 0;
+}
+
+
+int main()
+{
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    assert(std::char_traits<char8_t>::compare(u8"", u8"", 0) == 0);
+    assert(std::char_traits<char8_t>::compare(NULL, NULL, 0) == 0);
+
+    assert(std::char_traits<char8_t>::compare(u8"1", u8"1", 1) == 0);
+    assert(std::char_traits<char8_t>::compare(u8"1", u8"2", 1) < 0);
+    assert(std::char_traits<char8_t>::compare(u8"2", u8"1", 1) > 0);
+
+    assert(std::char_traits<char8_t>::compare(u8"12", u8"12", 2) == 0);
+    assert(std::char_traits<char8_t>::compare(u8"12", u8"13", 2) < 0);
+    assert(std::char_traits<char8_t>::compare(u8"12", u8"22", 2) < 0);
+    assert(std::char_traits<char8_t>::compare(u8"13", u8"12", 2) > 0);
+    assert(std::char_traits<char8_t>::compare(u8"22", u8"12", 2) > 0);
+
+    assert(std::char_traits<char8_t>::compare(u8"123", u8"123", 3) == 0);
+    assert(std::char_traits<char8_t>::compare(u8"123", u8"223", 3) < 0);
+    assert(std::char_traits<char8_t>::compare(u8"123", u8"133", 3) < 0);
+    assert(std::char_traits<char8_t>::compare(u8"123", u8"124", 3) < 0);
+    assert(std::char_traits<char8_t>::compare(u8"223", u8"123", 3) > 0);
+    assert(std::char_traits<char8_t>::compare(u8"133", u8"123", 3) > 0);
+    assert(std::char_traits<char8_t>::compare(u8"124", u8"123", 3) > 0);
+
+    static_assert(test_constexpr(), "" );
+#endif
+}

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static char_type* copy(char_type* s1, const char_type* s2, size_t n);
+
+#include <string>
+#include <cassert>
+
+int main()
+{
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    char8_t s1[] = {1, 2, 3};
+    char8_t s2[3] = {0};
+    assert(std::char_traits<char8_t>::copy(s2, s1, 3) == s2);
+    assert(s2[0] == char8_t(1));
+    assert(s2[1] == char8_t(2));
+    assert(s2[2] == char8_t(3));
+    assert(std::char_traits<char8_t>::copy(NULL, s1, 0) == NULL);
+    assert(std::char_traits<char8_t>::copy(s1, NULL, 0) == s1);
+#endif
+}

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eof.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static constexpr int_type eof();
+
+#include <string>
+#include <cassert>
+
+int main()
+{
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    std::char_traits<char8_t>::int_type i = std::char_traits<char8_t>::eof();
+    ((void)i); // Prevent unused warning
+#endif
+}

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static constexpr bool eq(char_type c1, char_type c2);
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    assert( std::char_traits<char8_t>::eq(u8'a', u8'a'));
+    assert(!std::char_traits<char8_t>::eq(u8'a', u8'A'));
+#endif
+}

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq_int_type.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static constexpr bool eq_int_type(int_type c1, int_type c2);
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    assert( std::char_traits<char8_t>::eq_int_type(u8'a', u8'a'));
+    assert(!std::char_traits<char8_t>::eq_int_type(u8'a', u8'A'));
+    assert(!std::char_traits<char8_t>::eq_int_type(std::char_traits<char8_t>::eof(), u8'A'));
+    assert( std::char_traits<char8_t>::eq_int_type(std::char_traits<char8_t>::eof(),
+                                                    std::char_traits<char8_t>::eof()));
+#endif
+}

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a);
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+constexpr bool test_constexpr()
+{
+    constexpr const char8_t *p = u8"123";
+    return std::char_traits<char8_t>::find(p, 3, u8'1') == p
+        && std::char_traits<char8_t>::find(p, 3, u8'2') == p + 1
+        && std::char_traits<char8_t>::find(p, 3, u8'3') == p + 2
+        && std::char_traits<char8_t>::find(p, 3, u8'4') == nullptr;
+}
+
+int main()
+{
+    char8_t s1[] = {1, 2, 3};
+    assert(std::char_traits<char8_t>::find(s1, 3, char8_t(1)) == s1);
+    assert(std::char_traits<char8_t>::find(s1, 3, char8_t(2)) == s1+1);
+    assert(std::char_traits<char8_t>::find(s1, 3, char8_t(3)) == s1+2);
+    assert(std::char_traits<char8_t>::find(s1, 3, char8_t(4)) == 0);
+    assert(std::char_traits<char8_t>::find(s1, 3, char8_t(0)) == 0);
+    assert(std::char_traits<char8_t>::find(NULL, 0, char8_t(0)) == 0);
+
+    static_assert(test_constexpr(), "" );
+}
+#else
+int main () {}
+#endif

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/length.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static constexpr size_t length(const char_type* s);
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+constexpr bool test_constexpr()
+{
+    return std::char_traits<char8_t>::length(u8"") == 0
+        && std::char_traits<char8_t>::length(u8"abcd") == 4;
+}
+
+int main()
+{
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    assert(std::char_traits<char8_t>::length(u8"") == 0);
+    assert(std::char_traits<char8_t>::length(u8"a") == 1);
+    assert(std::char_traits<char8_t>::length(u8"aa") == 2);
+    assert(std::char_traits<char8_t>::length(u8"aaa") == 3);
+    assert(std::char_traits<char8_t>::length(u8"aaaa") == 4);
+
+    static_assert(test_constexpr(), "");
+#endif
+}

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/lt.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static constexpr bool lt(char_type c1, char_type c2);
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    assert(!std::char_traits<char8_t>::lt(u8'a', u8'a'));
+    assert( std::char_traits<char8_t>::lt(u8'A', u8'a'));
+#endif
+}

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static char_type* move(char_type* s1, const char_type* s2, size_t n);
+
+#include <string>
+#include <cassert>
+
+int main()
+{
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    char8_t s1[] = {1, 2, 3};
+    assert(std::char_traits<char8_t>::move(s1, s1+1, 2) == s1);
+    assert(s1[0] == char8_t(2));
+    assert(s1[1] == char8_t(3));
+    assert(s1[2] == char8_t(3));
+    s1[2] = char8_t(0);
+    assert(std::char_traits<char8_t>::move(s1+1, s1, 2) == s1+1);
+    assert(s1[0] == char8_t(2));
+    assert(s1[1] == char8_t(2));
+    assert(s1[2] == char8_t(3));
+    assert(std::char_traits<char8_t>::move(NULL, s1, 0) == NULL);
+    assert(std::char_traits<char8_t>::move(s1, NULL, 0) == s1);
+#endif
+}

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/not_eof.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static constexpr int_type not_eof(int_type c);
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    assert(std::char_traits<char8_t>::not_eof(u8'a') == u8'a');
+    assert(std::char_traits<char8_t>::not_eof(u8'A') == u8'A');
+    assert(std::char_traits<char8_t>::not_eof(0) == 0);
+    assert(std::char_traits<char8_t>::not_eof(std::char_traits<char8_t>::eof()) !=
+           std::char_traits<char8_t>::eof());
+#endif
+}

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_char_type.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static constexpr char_type to_char_type(int_type c);
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    assert(std::char_traits<char8_t>::to_char_type(u8'a') == u8'a');
+    assert(std::char_traits<char8_t>::to_char_type(u8'A') == u8'A');
+    assert(std::char_traits<char8_t>::to_char_type(0) == 0);
+#endif
+}

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_int_type.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// static constexpr int_type to_int_type(char_type c);
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    assert(std::char_traits<char8_t>::to_int_type(u8'a') == u8'a');
+    assert(std::char_traits<char8_t>::to_int_type(u8'A') == u8'A');
+    assert(std::char_traits<char8_t>::to_int_type(0) == 0);
+#endif
+}

test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.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++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// typedef char8_t       char_type;
+// typedef unsigned int   int_type;
+// typedef streamoff      off_type;
+// typedef u16streampos   pos_type;
+// typedef mbstate_t      state_type;
+
+#include <string>
+#include <type_traits>
+#include <cstdint>
+
+int main()
+{
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    static_assert((std::is_same<std::char_traits<char8_t>::char_type,  char8_t>::value), "");
+    static_assert((std::is_same<std::char_traits<char8_t>::int_type,   unsigned int>::value), "");
+    static_assert((std::is_same<std::char_traits<char8_t>::off_type,   std::streamoff>::value), "");
+    static_assert((std::is_same<std::char_traits<char8_t>::pos_type,   std::u16streampos>::value), "");
+    static_assert((std::is_same<std::char_traits<char8_t>::state_type, std::mbstate_t>::value), "");
+#endif
+}

test/std/strings/string.classes/typedefs.pass.cpp

 // Test for the existence of:
 
 // basic_string typedef names
-// typedef basic_string<char> string;
+// typedef basic_string<char>     string;
 // typedef basic_string<char16_t> u16string;
+// typedef basic_string<char8_t>  u8string;  // C++20
 // typedef basic_string<char32_t> u32string;
-// typedef basic_string<wchar_t> wstring;
+// typedef basic_string<wchar_t>  wstring;
 
 #include <string>
 #include <type_traits>
 
+#include "test_macros.h"
+
 int main()
 {
     static_assert((std::is_same<std::string, std::basic_string<char> >::value), "");
     static_assert((std::is_same<std::wstring, std::basic_string<wchar_t> >::value), "");
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    static_assert((std::is_same<std::u8string, std::basic_string<char8_t> >::value), "");
+#endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     static_assert((std::is_same<std::u16string, std::basic_string<char16_t> >::value), "");
     static_assert((std::is_same<std::u32string, std::basic_string<char32_t> >::value), "");

test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp

   {
     test_hash_enabled_for_type<std::string_view>();
     test_hash_enabled_for_type<std::wstring_view>();
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test_hash_enabled_for_type<std::u8string_view>();
+#endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test_hash_enabled_for_type<std::u16string_view>();
     test_hash_enabled_for_type<std::u32string_view>();

test/std/strings/string.view/string.view.hash/string_view.pass.cpp

 int main()
 {
     test<std::string_view>();
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test<std::u8string_view>();
+#endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<std::u16string_view>();
     test<std::u32string_view>();

test/std/strings/string.view/string.view.capacity/capacity.pass.cpp

 }
 
 int main () {
-    typedef std::string_view    string_view;
-    typedef std::u16string_view u16string_view;
-    typedef std::u32string_view u32string_view;
-    typedef std::wstring_view   wstring_view;
+    test1<std::string_view> ();
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test1<std::u8string_view> ();
+#endif
+    test1<std::u16string_view> ();
+    test1<std::u32string_view> ();
+    test1<std::wstring_view> ();
 
-    test1<string_view> ();
-    test1<u16string_view> ();
-    test1<u32string_view> ();
-    test1<wstring_view> ();
-
     test2 ( "ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE", 105 );
     test2 ( "ABCDE", 5 );
     test2 ( "a", 1 );

     test2 ( L"a", 1 );
     test2 ( L"", 0 );
 
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test2 ( u8"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE", 105 );
+    test2 ( u8"ABCDE", 5 );
+    test2 ( u8"a", 1 );
+    test2 ( u8"", 0 );
+#endif
+
 #if TEST_STD_VER >= 11
     test2 ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE", 105 );
     test2 ( u"ABCDE", 5 );

test/std/strings/string.view/string.view.cons/assign.pass.cpp

 
 int main () {
 
-    assert( test<std::string_view>    ( "1234"));
+    assert( test<std::string_view>    (  "1234"));
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    assert( test<std::u8string_view>  (u8"1234"));
+#endif
 #if TEST_STD_VER >= 11
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    assert( test<std::u16string_view> (u"1234"));
-    assert( test<std::u32string_view> (U"1234"));
+    assert( test<std::u16string_view> ( u"1234"));
+    assert( test<std::u32string_view> ( U"1234"));
 #endif
 #endif
-    assert( test<std::wstring_view>   (L"1234"));
+    assert( test<std::wstring_view>   ( L"1234"));
 
 #if TEST_STD_VER > 11
-    static_assert( test<std::string_view>    ({ "abc", 3}), "");
+    static_assert( test<std::string_view>    ({  "abc", 3}), "");
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    static_assert( test<std::u8string_view>  ({u8"abc", 3}), "");
+#endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    static_assert( test<std::u16string_view> ({u"abc", 3}), "");
-    static_assert( test<std::u32string_view> ({U"abc", 3}), "");
+    static_assert( test<std::u16string_view> ({ u"abc", 3}), "");
+    static_assert( test<std::u32string_view> ({ U"abc", 3}), "");
 #endif
-    static_assert( test<std::wstring_view>   ({L"abc", 3}), "");
+    static_assert( test<std::wstring_view>   ({ L"abc", 3}), "");
 #endif
 }

test/std/strings/string.view/string.view.cons/default.pass.cpp

 }
 
 int main () {
-    typedef std::string_view    string_view;
-    typedef std::u16string_view u16string_view;
-    typedef std::u32string_view u32string_view;
-    typedef std::wstring_view   wstring_view;
+    test<std::string_view> ();
+    test<std::u16string_view> ();
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test<std::u8string_view> ();
+#endif
+    test<std::u32string_view> ();
+    test<std::wstring_view> ();
 
-    test<string_view> ();
-    test<u16string_view> ();
-    test<u32string_view> ();
-    test<wstring_view> ();
-
 }

test/std/strings/string.view/string.view.cons/from_string.pass.cpp

     test ( std::wstring(L"") );
     test ( std::wstring() );
 
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test ( std::u8string{u8"QBCDE"} );
+    test ( std::u8string{u8""} );
+    test ( std::u8string{} );
+#endif
+
 #if TEST_STD_VER >= 11
     test ( std::u16string{u"QBCDE"} );
     test ( std::u16string{u""} );

test/std/strings/string.view/string.view.iterators/begin.pass.cpp

 int main()
 {
     typedef std::string_view    string_view;
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    typedef std::u8string_view  u8string_view;
+#endif
     typedef std::u16string_view u16string_view;
     typedef std::u32string_view u32string_view;
     typedef std::wstring_view   wstring_view;

     test(wstring_view  ());
     test(string_view   ( "123"));
     test(wstring_view  (L"123"));
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test(u8string_view{u8"123"});
+#endif
 #if TEST_STD_VER >= 11
     test(u16string_view{u"123"});
     test(u32string_view{U"123"});

 #if TEST_STD_VER > 11
     {
     constexpr string_view       sv { "123", 3 };
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    constexpr u8string_view u8sv  {u8"123", 3 };
+#endif
     constexpr u16string_view u16sv {u"123", 3 };
     constexpr u32string_view u32sv {U"123", 3 };
     constexpr wstring_view     wsv {L"123", 3 };
 
     static_assert (    *sv.begin() ==    sv[0], "" );
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    static_assert (  *u8sv.begin() ==  u8sv[0], "" );
+#endif
     static_assert ( *u16sv.begin() == u16sv[0], "" );
     static_assert ( *u32sv.begin() == u32sv[0], "" );
     static_assert (   *wsv.begin() ==   wsv[0], "" );
 
     static_assert (    *sv.cbegin() ==    sv[0], "" );
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    static_assert (  *u8sv.cbegin() ==  u8sv[0], "" );
+#endif
     static_assert ( *u16sv.cbegin() == u16sv[0], "" );
     static_assert ( *u32sv.cbegin() == u32sv[0], "" );
     static_assert (   *wsv.cbegin() ==   wsv[0], "" );

test/std/strings/string.view/string.view.iterators/end.pass.cpp

 int main()
 {
     typedef std::string_view    string_view;
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    typedef std::u8string_view  u8string_view;
+#endif
     typedef std::u16string_view u16string_view;
     typedef std::u32string_view u32string_view;
     typedef std::wstring_view   wstring_view;

     test(wstring_view  ());
     test(string_view   ( "123"));
     test(wstring_view  (L"123"));
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test(u8string_view{u8"123"});
+#endif
 #if TEST_STD_VER >= 11
     test(u16string_view{u"123"});
     test(u32string_view{U"123"});

 #if TEST_STD_VER > 11
     {
     constexpr string_view       sv { "123", 3 };
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    constexpr u8string_view u8sv  {u8"123", 3 };
+#endif
     constexpr u16string_view u16sv {u"123", 3 };
     constexpr u32string_view u32sv {U"123", 3 };
     constexpr wstring_view     wsv {L"123", 3 };
 
     static_assert (    sv.begin() !=    sv.end(), "" );
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    static_assert (  u8sv.begin() !=  u8sv.end(), "" );
+#endif
     static_assert ( u16sv.begin() != u16sv.end(), "" );
     static_assert ( u32sv.begin() != u32sv.end(), "" );
     static_assert (   wsv.begin() !=   wsv.end(), "" );
 
     static_assert (    sv.begin() !=    sv.cend(), "" );
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    static_assert (  u8sv.begin() !=  u8sv.cend(), "" );
+#endif
     static_assert ( u16sv.begin() != u16sv.cend(), "" );
     static_assert ( u32sv.begin() != u32sv.cend(), "" );
     static_assert (   wsv.begin() !=   wsv.cend(), "" );

test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp

 int main()
 {
     typedef std::string_view    string_view;
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    typedef std::u8string_view  u8string_view;
+#endif
     typedef std::u16string_view u16string_view;
     typedef std::u32string_view u32string_view;
     typedef std::wstring_view   wstring_view;

     test(wstring_view  ());
     test(string_view   ( "123"));
     test(wstring_view  (L"123"));
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test(u8string_view{u8"123"});
+#endif
 #if TEST_STD_VER >= 11
     test(u16string_view{u"123"});
     test(u32string_view{U"123"});

 #if TEST_STD_VER > 14
     {
     constexpr string_view       sv { "123", 3 };
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    constexpr u8string_view u8sv  {u8"123", 3 };
+#endif
     constexpr u16string_view u16sv {u"123", 3 };
     constexpr u32string_view u32sv {U"123", 3 };
     constexpr wstring_view     wsv {L"123", 3 };
 
     static_assert (    *sv.rbegin() ==    sv[2], "" );
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    static_assert (  *u8sv.rbegin() ==  u8sv[2], "" );
+#endif
     static_assert ( *u16sv.rbegin() == u16sv[2], "" );
     static_assert ( *u32sv.rbegin() == u32sv[2], "" );
     static_assert (   *wsv.rbegin() ==   wsv[2], "" );
 
     static_assert (    *sv.crbegin() ==    sv[2], "" );
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    static_assert (  *u8sv.crbegin() == u8sv[2], "" );
+#endif
     static_assert ( *u16sv.crbegin() == u16sv[2], "" );
     static_assert ( *u32sv.crbegin() == u32sv[2], "" );
     static_assert (   *wsv.crbegin() ==   wsv[2], "" );

test/std/strings/string.view/string.view.iterators/rend.pass.cpp

 int main()
 {
     typedef std::string_view    string_view;
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    typedef std::u8string_view u8string_view;
+#endif
     typedef std::u16string_view u16string_view;
     typedef std::u32string_view u32string_view;
     typedef std::wstring_view   wstring_view;

     test(wstring_view  ());
     test(string_view   ( "123"));
     test(wstring_view  (L"123"));
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test(u8string_view{u8"123"});
+#endif
 #if TEST_STD_VER >= 11
     test(u16string_view{u"123"});
     test(u32string_view{U"123"});

 #if TEST_STD_VER > 14
     {
     constexpr string_view       sv { "123", 3 };
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    constexpr u8string_view u8sv {u8"123", 3 };
+#endif
     constexpr u16string_view u16sv {u"123", 3 };
     constexpr u32string_view u32sv {U"123", 3 };
     constexpr wstring_view     wsv {L"123", 3 };
 
     static_assert (    *--sv.rend() ==    sv[0], "" );
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    static_assert (  *--u8sv.rend() ==  u8sv[0], "" );
+#endif
     static_assert ( *--u16sv.rend() == u16sv[0], "" );
     static_assert ( *--u32sv.rend() == u32sv[0], "" );
     static_assert (   *--wsv.rend() ==   wsv[0], "" );
 
     static_assert (    *--sv.crend() ==    sv[0], "" );
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    static_assert (  *--u8sv.crend() ==  u8sv[0], "" );
+#endif
     static_assert ( *--u16sv.crend() == u16sv[0], "" );
     static_assert ( *--u32sv.crend() == u32sv[0], "" );
     static_assert (   *--wsv.crend() ==   wsv[0], "" );

test/std/strings/string.view/string_view.literals/literal.pass.cpp

 
 #include "test_macros.h"
 
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    typedef std::u8string_view u8string_view;
+#else
+    typedef std::string_view   u8string_view;
+#endif
+
 int main()
 {
     using namespace std::literals::string_view_literals;
 
     static_assert ( std::is_same<decltype(   "Hi"sv), std::string_view>::value, "" );
-//  This is changed by P0482 to return a std::u8string - re-enable when we implement that.
-#if TEST_STD_VER <= 17
-    static_assert ( std::is_same<decltype( u8"Hi"sv), std::string_view>::value, "" );
-#endif
+    static_assert ( std::is_same<decltype( u8"Hi"sv), u8string_view>::value, "" );
     static_assert ( std::is_same<decltype(  L"Hi"sv), std::wstring_view>::value, "" );
     static_assert ( std::is_same<decltype(  u"Hi"sv), std::u16string_view>::value, "" );
     static_assert ( std::is_same<decltype(  U"Hi"sv), std::u32string_view>::value, "" );

 
     std::string_view foo;
     std::wstring_view Lfoo;
+    u8string_view u8foo;
     std::u16string_view ufoo;
     std::u32string_view Ufoo;
 
-    foo  =   ""sv;     assert( foo.size() == 0);
-//  This is changed by P0482 to return a std::u8string - re-enable when we implement that.
-#if TEST_STD_VER <= 17
-    foo  = u8""sv;     assert( foo.size() == 0);
-#endif
-    Lfoo =  L""sv;     assert(Lfoo.size() == 0);
-    ufoo =  u""sv;     assert(ufoo.size() == 0);
-    Ufoo =  U""sv;     assert(Ufoo.size() == 0);
+    
+    foo  =    ""sv;     assert(  foo.size() == 0);
+    u8foo = u8""sv;     assert(u8foo.size() == 0);
+    Lfoo  =  L""sv;     assert( Lfoo.size() == 0);
+    ufoo  =  u""sv;     assert( ufoo.size() == 0);
+    Ufoo  =  U""sv;     assert( Ufoo.size() == 0);
 
-    foo  =   " "sv;     assert( foo.size() == 1);
-//  This is changed by P0482 to return a std::u8string - re-enable when we implement that.
-#if TEST_STD_VER <= 17
-    foo  = u8" "sv;     assert( foo.size() == 1);
-#endif
-    Lfoo =  L" "sv;     assert(Lfoo.size() == 1);
-    ufoo =  u" "sv;     assert(ufoo.size() == 1);
-    Ufoo =  U" "sv;     assert(Ufoo.size() == 1);
+    foo   =   " "sv;    assert(  foo.size() == 1);
+    u8foo = u8" "sv;    assert(u8foo.size() == 1);
+    Lfoo  =  L" "sv;    assert( Lfoo.size() == 1);
+    ufoo  =  u" "sv;    assert( ufoo.size() == 1);
+    Ufoo  =  U" "sv;    assert( Ufoo.size() == 1);
 
-    foo  =   "ABC"sv;     assert( foo ==   "ABC");   assert( foo == std::string_view   (  "ABC"));
-//  This is changed by P0482 to return a std::u8string - re-enable when we implement that.
-#if TEST_STD_VER <= 17
-    foo  = u8"ABC"sv;     assert( foo == u8"ABC");   assert( foo == std::string_view   (u8"ABC"));
-#endif
-    Lfoo =  L"ABC"sv;     assert(Lfoo ==  L"ABC");   assert(Lfoo == std::wstring_view  ( L"ABC"));
-    ufoo =  u"ABC"sv;     assert(ufoo ==  u"ABC");   assert(ufoo == std::u16string_view( u"ABC"));
-    Ufoo =  U"ABC"sv;     assert(Ufoo ==  U"ABC");   assert(Ufoo == std::u32string_view( U"ABC"));
+    foo   =   "ABC"sv;  assert(  foo ==   "ABC");   assert(  foo == std::string_view   (  "ABC"));
+    u8foo = u8"ABC"sv;  assert(u8foo == u8"ABC");   assert(u8foo == u8string_view      (u8"ABC"));
+    Lfoo  =  L"ABC"sv;  assert( Lfoo ==  L"ABC");   assert( Lfoo == std::wstring_view  ( L"ABC"));
+    ufoo  =  u"ABC"sv;  assert( ufoo ==  u"ABC");   assert( ufoo == std::u16string_view( u"ABC"));
+    Ufoo  =  U"ABC"sv;  assert( Ufoo ==  U"ABC");   assert( Ufoo == std::u32string_view( U"ABC"));
 
     static_assert(  "ABC"sv.size() == 3, "");
-//  This is changed by P0482 to return a std::u8string - re-enable when we implement that.
-#if TEST_STD_VER <= 17
     static_assert(u8"ABC"sv.size() == 3, "");
-#endif
     static_assert( L"ABC"sv.size() == 3, "");
     static_assert( u"ABC"sv.size() == 3, "");
     static_assert( U"ABC"sv.size() == 3, "");
 
     static_assert(noexcept(  "ABC"sv), "");
-//  This is changed by P0482 to return a std::u8string - re-enable when we implement that.
-#if TEST_STD_VER <= 17
     static_assert(noexcept(u8"ABC"sv), "");
-#endif
     static_assert(noexcept( L"ABC"sv), "");
     static_assert(noexcept( u"ABC"sv), "");
     static_assert(noexcept( U"ABC"sv), "");

test/std/strings/string.view/types.pass.cpp

 {
     test<std::char_traits<char> >();
     test<std::char_traits<wchar_t> >();
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test<std::char_traits<char8_t> >();
+#endif
     static_assert((std::is_same<std::basic_string_view<char>::traits_type,
                                 std::char_traits<char> >::value), "");
 }

test/std/utilities/memory/ptr.align/assume_aligned.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++98, c++03, c++11, c++14, c++17
+
+// #include <memory>
+
+// template<size_t N, class T>
+//     [[nodiscard]] constexpr T* assume_aligned(T* ptr);
+
+#include <memory>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main ()
+{
+    int *p = nullptr;
+    std::assume_aligned(p, 4);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}

test/std/utilities/memory/ptr.align/assume_aligned.pass.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++98, c++03, c++11, c++14, c++17
+
+// #include <memory>
+
+// template<size_t N, class T>
+//     [[nodiscard]] constexpr T* assume_aligned(T* ptr);
+
+#include <memory>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+constexpr bool is_aligned(T* p, size_t n)
+{ return (reinterpret_cast<std::uintptr_t>(p) & ((1 << n) - 1)) == 0; }
+
+template <typename T>
+void test(T *p)
+{
+    ASSERT_SAME_TYPE(T*, decltype(std::assume_aligned<1, T>(p)));
+    LIBCPP_ASSERT_NOEXCEPT(       std::assume_aligned<1, T>(p));
+
+    assert((p == std::assume_aligned<1>(p)));
+    if (is_aligned(p,   2))
+        assert((p == std::assume_aligned<  2>(p)));
+    if (is_aligned(p,   4))
+        assert((p == std::assume_aligned<  4>(p)));
+    if (is_aligned(p,   8))
+        assert((p == std::assume_aligned<  8>(p)));
+    if (is_aligned(p,  16))
+        assert((p == std::assume_aligned< 16>(p)));
+    if (is_aligned(p,  32))
+        assert((p == std::assume_aligned< 32>(p)));
+    if (is_aligned(p,  64))
+        assert((p == std::assume_aligned< 64>(p)));
+    if (is_aligned(p, 128))
+        assert((p == std::assume_aligned<128>(p)));
+}
+
+template <typename T>
+constexpr bool constexpr_test(T *p)
+{
+    ASSERT_SAME_TYPE(T*, decltype(std::assume_aligned<1, T>(p)));
+    const size_t al = alignof(T);
+
+    if (p != std::assume_aligned<1>(p)) return false;
+    if (al >= 2)
+        if (p != std::assume_aligned<2>(p)) return false;
+    if (al >= 2)
+        if (p != std::assume_aligned<2>(p)) return false;
+    if (al >= 4)
+        if (p != std::assume_aligned<4>(p)) return false;
+    if (al >= 8)
+        if (p != std::assume_aligned<8>(p)) return false;
+    if (al >= 16)
+        if (p != std::assume_aligned<16>(p)) return false;
+    if (al >= 32)
+        if (p != std::assume_aligned<32>(p)) return false;
+    if (al >= 64)
+        if (p != std::assume_aligned<64>(p)) return false;
+    if (al >= 128)
+        if (p != std::assume_aligned<128>(p)) return false;
+    return true;
+}
+
+int i;
+long l;
+double d;
+long double ld;
+
+struct              S    {};
+struct alignas(  4) S4   {};
+struct alignas(  8) S8   {};
+struct alignas( 16) S16  {};
+struct alignas( 32) S32  {};
+struct alignas( 64) S64  {};
+struct alignas(128) S128 {};
+
+S       s;
+S4     s4;
+S8     s8;
+S16   s16;
+S32   s32;
+S64   s64;
+S128 s128;
+
+
+int main ()
+{
+
+    test( &i);
+    test( &l);
+    test( &d);
+    test(&ld);
+    
+    test(&s);
+    test(&s4);
+    test(&s8);
+    test(&s16);
+    test(&s32);
+    test(&s64);
+    test(&s128);
+
+//  static_assert(constexpr_test( &i), "");
+//  static_assert(constexpr_test( &l), ""); 
+//  static_assert(constexpr_test( &d), ""); 
+//  static_assert(constexpr_test(&ld), ""); 
+// 
+//  static_assert(constexpr_test(   &s), "");
+//  static_assert(constexpr_test(  &s4), "");
+//  static_assert(constexpr_test(  &s8), "");
+//  static_assert(constexpr_test( &s16), "");
+//  static_assert(constexpr_test( &s32), "");
+//  static_assert(constexpr_test( &s64), "");
+//  static_assert(constexpr_test(&s128), "");
+}

test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp

     test_is_integral<signed char>();
     test_is_integral<unsigned char>();
     test_is_integral<wchar_t>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     test_is_integral<char8_t>();
 #endif