[libcxx] std::codecvt - short wchar support

[iid_iunknown]

Summary

std::codecvt conversions internally use uint32_t in codecvt specializations for wchar_t, which breaks conversion logic if the '-fshort-wchar' was used during compilation.
This patch modifies std::codecvt_utf8 to use the same logic for short wchar_t as the one for WIN32 where wchar_t is 2 bytes long.

std::codecvt_utf16 and std::codecvt_utf8_utf16 changed to work with both WIN32 and fshort-wchar.

It also improves code reuse by generalizing utf16_to_utf8 and utf8_to_utf16 functions, and fixes the libcxx tests dependent on std::codecvt, which use 4-byte test data or expect UCS-4 encoding.

UPDATE

The libc++ tests not working with short wchar now have their short wchar counterparts. The short_wchar feature added to the libc++ tests. Lit decides which version of a test to run depending on availability of short_wchar.

[jroelofs]

A couple of drive-by comments.

test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp

2

Does win32 not have __SIZEOF_WCHAR_T__?

6

The else should really be something to the tune of: `#error Can't tell how big wchar_t is on this platform". Otherwise this is a potential nightmare for people doing ports.

test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp

6

same here. Maybe this macro should go in one of the test support headers instead?

[mclow.lists]

I don't like the gutting of the tests.
I don't like the confusion added to the code.

src/locale.cpp

0–1

You're changing a function named utf8_to_utf16 to take parameters of type uint32_t *?

Eww. I object.

0–1

Same comment as below.

test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp

1

This is not "fixing the libcxx tests dependent on std::codecvt".

This is *removing the tests*.

[mclow.lists]

src/locale.cpp

0–1

I apologize for this comment. We already have a function that does this.
Still, eww.

[iid_iunknown]

In D8880#153497, @mclow.lists wrote:

I don't like the gutting of the tests.
I don't like the confusion added to the code.

Codecvt_utf8 already handles short wchar properly and does this in exactly same manner. The patch adds short wchar support to other codecvt's, which seem to have been forgotten. The change is similar to how it is done in gcc's libstdc++.

The next patch changes this a bit by introducing the SHORT_WCHAR macro. This saves some typing and, I hope, makes the code more readable. Would you take a look and share your thoughts, please?

Yes, I agree about the tests. The next patch will avoid messing in the tests by splitting such wchar-size-dependent tests into two versions: for short wchar and for "long" wchar. Lit will choose which test to run depending on short_wchar feature availability, which will also be added.

src/locale.cpp

0–1

Objecting to the existing functionality. We already have two utf8_to_utf16 functions and two utf16_to_utf8 to support char16_t and char32_t.

This part of the patch is not a functional change. It just tries to improve code reuse instead.
As this is just an improvement, I can revert it if code repetition looks better to someone or the corrected version seems confusing.

test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp

2

It does not seem to have __SIZEOF_WCHAR_T__, unfortunately.

6

Thank you for your remark. I will introduce such a message in the next patch version.

test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp

6

Ok, I am going to change the way the tests are handled for short wchar, so that they won't contain these #if / #else anymore.

[iid_iunknown]

Changes locale.cpp to make the code look less messy.
Introduces the short_wchar feature to the libc++ tests, creates separate tests for short wchar.

[iid_iunknown]

Abandoning the patch as it is too old.

src/locale.cpp

 //===------------------------- locale.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_t __cloc() {
   // a little resource leak. Better approach would be appreciated.
   static locale_t result = newlocale(LC_ALL_MASK, "C", 0);
   return result;
 }
 #endif // __cloc_defined
 
 namespace {
 
-struct release
+struct release
 {
     void operator()(locale::facet* p) {p->__release_shared();}
 };
 
 template <class T, class A0>
 inline
 T&
 make(A0 a0)

 const locale::category locale::messages;
 const locale::category locale::all;
 
 #if defined(__clang__)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wpadded"
 #endif
 
+#if _WIN32 || __SIZEOF_WCHAR_T__ == 2
+# define SHORT_WCHAR 1
+#elif __SIZEOF_WCHAR_T__ == 4
+# define SHORT_WCHAR 0
+#else
+# error Can't tell how big wchar_t is on this platform
+#endif
+
+#if SHORT_WCHAR
+  typedef uint16_t ucs_char_t;
+#else
+  typedef uint32_t ucs_char_t;
+#endif
+
 class _LIBCPP_HIDDEN locale::__imp
     : public facet
 {
     enum {N = 28};
 #if defined(_LIBCPP_MSVC)
 // FIXME: MSVC doesn't support aligned parameters by value.
 // I can't get the __sso_allocator to work here
 // for MSVC I think for this reason.

 // 001000 - 00CFFF  1000 - CFFF               E1 - EC, 80 - BF, 80 - BF             49152
 // 00D000 - 00D7FF  D000 - D7FF               ED - ED, 80 - 9F, 80 - BF              2048
 // 00D800 - 00DFFF                invalid
 // 00E000 - 00FFFF  E000 - FFFF               EE - EF, 80 - BF, 80 - BF              8192
 // 010000 - 03FFFF  D800 - D8BF, DC00 - DFFF  F0 - F0, 90 - BF, 80 - BF, 80 - BF   196608
 // 040000 - 0FFFFF  D8C0 - DBBF, DC00 - DFFF  F1 - F3, 80 - BF, 80 - BF, 80 - BF   786432
 // 100000 - 10FFFF  DBC0 - DBFF, DC00 - DFFF  F4 - F4, 80 - 8F, 80 - BF, 80 - BF    65536
 
-static
+template <class _FrmType>
+typename enable_if
+<
+    is_same<_FrmType, uint16_t>::value || is_same<_FrmType, uint32_t>::value,
     codecvt_base::result
-utf16_to_utf8(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
-              uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
-              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & generate_header)
-    {
-        if (to_end-to_nxt < 3)
-            return codecvt_base::partial;
-        *to_nxt++ = static_cast<uint8_t>(0xEF);
-        *to_nxt++ = static_cast<uint8_t>(0xBB);
-        *to_nxt++ = static_cast<uint8_t>(0xBF);
-    }
-    for (; frm_nxt < frm_end; ++frm_nxt)
-    {
-        uint16_t wc1 = *frm_nxt;
-        if (wc1 > Maxcode)
-            return codecvt_base::error;
-        if (wc1 < 0x0080)
-        {
-            if (to_end-to_nxt < 1)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(wc1);
-        }
-        else if (wc1 < 0x0800)
-        {
-            if (to_end-to_nxt < 2)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc1 >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x03F));
-        }
-        else if (wc1 < 0xD800)
-        {
-            if (to_end-to_nxt < 3)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
-        }
-        else if (wc1 < 0xDC00)
-        {
-            if (frm_end-frm_nxt < 2)
-                return codecvt_base::partial;
-            uint16_t wc2 = frm_nxt[1];
-            if ((wc2 & 0xFC00) != 0xDC00)
-                return codecvt_base::error;
-            if (to_end-to_nxt < 4)
-                return codecvt_base::partial;
-            if (((((wc1 & 0x03C0UL) >> 6) + 1) << 16) +
-                ((wc1 & 0x003FUL) << 10) + (wc2 & 0x03FF) > Maxcode)
-                return codecvt_base::error;
-            ++frm_nxt;
-            uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
-            *to_nxt++ = static_cast<uint8_t>(0xF0 | (z >> 2));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((z & 0x03) << 4)     | ((wc1 & 0x003C) >> 2));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0003) << 4) | ((wc2 & 0x03C0) >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc2 & 0x003F));
-        }
-        else if (wc1 < 0xE000)
-        {
-            return codecvt_base::error;
-        }
-        else
-        {
-            if (to_end-to_nxt < 3)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
-        }
-    }
-    return codecvt_base::ok;
-}
-
-static
-codecvt_base::result
-utf16_to_utf8(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
+>::type
+utf16_to_utf8(const _FrmType* frm, const _FrmType* frm_end, const _FrmType*& frm_nxt,
               uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
               unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
 {
     frm_nxt = frm;
     to_nxt = to;
     if (mode & generate_header)
     {
         if (to_end-to_nxt < 3)
for (; frm_nxt < frm_end; ++frm_nxt)
             *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
             *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
             *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
         }
     }
     return codecvt_base::ok;
 }
 
-static
+template <class _ToType>
+typename enable_if
+<
+    is_same<_ToType, uint16_t>::value || is_same<_ToType, uint32_t>::value,
     codecvt_base::result
+>::type
 utf8_to_utf16(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
-              uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
+              _ToType* to, _ToType* to_end, _ToType*& to_nxt,
               unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
 {
     frm_nxt = frm;
     to_nxt = to;
     if (mode & consume_header)
     {
         if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
                                                           frm_nxt[2] == 0xBF)
             frm_nxt += 3;
     }
     for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
     {
         uint8_t c1 = *frm_nxt;
         if (c1 > Maxcode)
             return codecvt_base::error;
         if (c1 < 0x80)
         {
-            *to_nxt = static_cast<uint16_t>(c1);
+            *to_nxt = static_cast<_ToType>(c1);
             ++frm_nxt;
         }
         else if (c1 < 0xC2)
         {
             return codecvt_base::error;
         }
         else if (c1 < 0xE0)
         {
             if (frm_end-frm_nxt < 2)
                 return codecvt_base::partial;
             uint8_t c2 = frm_nxt[1];
             if ((c2 & 0xC0) != 0x80)
                 return codecvt_base::error;
             uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
             if (t > Maxcode)
                 return codecvt_base::error;
-            *to_nxt = t;
+            *to_nxt = static_cast<_ToType>(t);
             frm_nxt += 2;
         }
         else if (c1 < 0xF0)
         {
             if (frm_end-frm_nxt < 3)
                 return codecvt_base::partial;
             uint8_t c2 = frm_nxt[1];
             uint8_t c3 = frm_nxt[2];
for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
             }
             if ((c3 & 0xC0) != 0x80)
                 return codecvt_base::error;
             uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
                                              | ((c2 & 0x3F) << 6)
                                              |  (c3 & 0x3F));
             if (t > Maxcode)
                 return codecvt_base::error;
-            *to_nxt = t;
+            *to_nxt = static_cast<_ToType>(t);
             frm_nxt += 3;
         }
         else if (c1 < 0xF5)
         {
             if (frm_end-frm_nxt < 4)
                 return codecvt_base::partial;
             uint8_t c2 = frm_nxt[1];
             uint8_t c3 = frm_nxt[2];
for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
                     return codecvt_base::error;
                  break;
             default:
                 if ((c2 & 0xC0) != 0x80)
                     return codecvt_base::error;
                  break;
             }
             if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
-                return codecvt_base::error;
+                return codecvt_base::error;
             if (to_end-to_nxt < 2)
                 return codecvt_base::partial;
             if ((((c1 & 7UL) << 18) +
                 ((c2 & 0x3FUL) << 12) +
                 ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
                 return codecvt_base::error;
-            *to_nxt = static_cast<uint16_t>(
+            *to_nxt = static_cast<_ToType>(
                     0xD800
                   | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6)
                   | ((c2 & 0x0F) << 2)
                   | ((c3 & 0x30) >> 4));
-            *++to_nxt = static_cast<uint16_t>(
-                    0xDC00
-                  | ((c3 & 0x0F) << 6)
-                  |  (c4 & 0x3F));
-            frm_nxt += 4;
-        }
-        else
-        {
-            return codecvt_base::error;
-        }
-    }
-    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
-}
-
-static
-codecvt_base::result
-utf8_to_utf16(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
-              uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
-              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
-                                                          frm_nxt[2] == 0xBF)
-            frm_nxt += 3;
-    }
-    for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
-    {
-        uint8_t c1 = *frm_nxt;
-        if (c1 > Maxcode)
-            return codecvt_base::error;
-        if (c1 < 0x80)
-        {
-            *to_nxt = static_cast<uint32_t>(c1);
-            ++frm_nxt;
-        }
-        else if (c1 < 0xC2)
-        {
-            return codecvt_base::error;
-        }
-        else if (c1 < 0xE0)
-        {
-            if (frm_end-frm_nxt < 2)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            if ((c2 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
-            if (t > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = static_cast<uint32_t>(t);
-            frm_nxt += 2;
-        }
-        else if (c1 < 0xF0)
-        {
-            if (frm_end-frm_nxt < 3)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            switch (c1)
-            {
-            case 0xE0:
-                if ((c2 & 0xE0) != 0xA0)
-                    return codecvt_base::error;
-                 break;
-            case 0xED:
-                if ((c2 & 0xE0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
-                                             | ((c2 & 0x3F) << 6)
-                                             |  (c3 & 0x3F));
-            if (t > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = static_cast<uint32_t>(t);
-            frm_nxt += 3;
-        }
-        else if (c1 < 0xF5)
-        {
-            if (frm_end-frm_nxt < 4)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            uint8_t c4 = frm_nxt[3];
-            switch (c1)
-            {
-            case 0xF0:
-                if (!(0x90 <= c2 && c2 <= 0xBF))
-                    return codecvt_base::error;
-                 break;
-            case 0xF4:
-                if ((c2 & 0xF0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            if (to_end-to_nxt < 2)
-                return codecvt_base::partial;
-            if ((((c1 & 7UL) << 18) +
-                ((c2 & 0x3FUL) << 12) +
-                ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = static_cast<uint32_t>(
-                    0xD800
-                  | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6)
-                  | ((c2 & 0x0F) << 2)
-                  | ((c3 & 0x30) >> 4));
-            *++to_nxt = static_cast<uint32_t>(
+            *++to_nxt = static_cast<_ToType>(
                     0xDC00
                   | ((c3 & 0x0F) << 6)
                   |  (c4 & 0x3F));
             frm_nxt += 4;
         }
         else
         {
             return codecvt_base::error;
for (size_t nchar16_t = 0; frm_nxt < frm_end && nchar16_t < mx; ++nchar16_t)
         {
             if ((frm_end-frm_nxt < 2) || (frm_nxt[1] & 0xC0) != 0x80)
                 break;
             uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (frm_nxt[1] & 0x3F));
             if (t > Maxcode)
                 break;
             frm_nxt += 2;
         }
-        else if (c1 < 0xF0)
+        else if (c1 < 0xF0)
         {
             if (frm_end-frm_nxt < 3)
                 break;
             uint8_t c2 = frm_nxt[1];
             uint8_t c3 = frm_nxt[2];
             switch (c1)
             {
             case 0xE0:
ucs4_to_utf8(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
     {
         uint32_t wc = *frm_nxt;
         if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
             return codecvt_base::error;
         if (wc < 0x000080)
         {
             if (to_end-to_nxt < 1)
                 return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(wc);
+            *to_nxt++ = static_cast<uint8_t>(wc);
         }
         else if (wc < 0x000800)
         {
             if (to_end-to_nxt < 2)
                 return codecvt_base::partial;
             *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc >> 6));
             *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x03F));
         }
ucs4_to_utf16le(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
     }
     for (; frm_nxt < frm_end; ++frm_nxt)
     {
         uint32_t wc = *frm_nxt;
         if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
             return codecvt_base::error;
         if (wc < 0x010000)
         {
-            if (to_end-to_nxt < 2)
+            if (to_end-to_nxt < 2)
                 return codecvt_base::partial;
             *to_nxt++ = static_cast<uint8_t>(wc);
             *to_nxt++ = static_cast<uint8_t>(wc >> 8);
         }
         else
         {
             if (to_end-to_nxt < 4)
                 return codecvt_base::partial;

 
 // __codecvt_utf8<wchar_t>
 
 __codecvt_utf8<wchar_t>::result
 __codecvt_utf8<wchar_t>::do_out(state_type&,
     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
 {
-#if _WIN32
-    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
-    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
-    const uint16_t* _frm_nxt = _frm;
-#else
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
-#endif
+    const ucs_char_t* _frm = reinterpret_cast<const ucs_char_t*>(frm);
+    const ucs_char_t* _frm_end = reinterpret_cast<const ucs_char_t*>(frm_end);
+    const ucs_char_t* _frm_nxt = _frm;
     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
     uint8_t* _to_nxt = _to;
-#if _WIN32
+#if SHORT_WCHAR
     result r = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
                             _Maxcode_, _Mode_);
 #else
     result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
                             _Maxcode_, _Mode_);
 #endif
     frm_nxt = frm + (_frm_nxt - _frm);
     to_nxt = to + (_to_nxt - _to);
     return r;
 }
 
 __codecvt_utf8<wchar_t>::result
 __codecvt_utf8<wchar_t>::do_in(state_type&,
     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     const uint8_t* _frm_nxt = _frm;
-#if _WIN32
-    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
-    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
-    uint16_t* _to_nxt = _to;
+    ucs_char_t* _to = reinterpret_cast<ucs_char_t*>(to);
+    ucs_char_t* _to_end = reinterpret_cast<ucs_char_t*>(to_end);
+    ucs_char_t* _to_nxt = _to;
+#if SHORT_WCHAR
     result r = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
                             _Maxcode_, _Mode_);
 #else
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
     result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
                             _Maxcode_, _Mode_);
 #endif
     frm_nxt = frm + (_frm_nxt - _frm);
     to_nxt = to + (_to_nxt - _to);
     return r;
 }
 

 }
 
 int
 __codecvt_utf8<wchar_t>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+#if SHORT_WCHAR
+    return utf8_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
+#else
     return utf8_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
+#endif
 }
 
 int
 __codecvt_utf8<wchar_t>::do_max_length() const  _NOEXCEPT
 {
     if (_Mode_ & consume_header)
         return 7;
     return 4;

 
 // __codecvt_utf16<wchar_t, false>
 
 __codecvt_utf16<wchar_t, false>::result
 __codecvt_utf16<wchar_t, false>::do_out(state_type&,
     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
 {
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
+    const ucs_char_t* _frm = reinterpret_cast<const ucs_char_t*>(frm);
+    const ucs_char_t* _frm_end = reinterpret_cast<const ucs_char_t*>(frm_end);
+    const ucs_char_t* _frm_nxt = _frm;
     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
     uint8_t* _to_nxt = _to;
+#if SHORT_WCHAR
+    result r = ucs2_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
+                               _Maxcode_, _Mode_);
+#else
     result r = ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
                                _Maxcode_, _Mode_);
+#endif
     frm_nxt = frm + (_frm_nxt - _frm);
     to_nxt = to + (_to_nxt - _to);
     return r;
 }
 
 __codecvt_utf16<wchar_t, false>::result
 __codecvt_utf16<wchar_t, false>::do_in(state_type&,
     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     const uint8_t* _frm_nxt = _frm;
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
+    ucs_char_t* _to = reinterpret_cast<ucs_char_t*>(to);
+    ucs_char_t* _to_end = reinterpret_cast<ucs_char_t*>(to_end);
+    ucs_char_t* _to_nxt = _to;
+#if SHORT_WCHAR
+    result r = utf16be_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
+                               _Maxcode_, _Mode_);
+#else
     result r = utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
                                _Maxcode_, _Mode_);
+#endif
     frm_nxt = frm + (_frm_nxt - _frm);
     to_nxt = to + (_to_nxt - _to);
     return r;
 }
 
 __codecvt_utf16<wchar_t, false>::result
 __codecvt_utf16<wchar_t, false>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const

 }
 
 int
 __codecvt_utf16<wchar_t, false>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+#if SHORT_WCHAR
+    return utf16be_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
+#else
     return utf16be_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
+#endif
 }
 
 int
 __codecvt_utf16<wchar_t, false>::do_max_length() const  _NOEXCEPT
 {
     if (_Mode_ & consume_header)
         return 6;
     return 4;
 }
 
 // __codecvt_utf16<wchar_t, true>
 
 __codecvt_utf16<wchar_t, true>::result
 __codecvt_utf16<wchar_t, true>::do_out(state_type&,
     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
 {
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
+    const ucs_char_t* _frm = reinterpret_cast<const ucs_char_t*>(frm);
+    const ucs_char_t* _frm_end = reinterpret_cast<const ucs_char_t*>(frm_end);
+    const ucs_char_t* _frm_nxt = _frm;
     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
     uint8_t* _to_nxt = _to;
+#if SHORT_WCHAR
+    result r = ucs2_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
+                               _Maxcode_, _Mode_);
+#else
     result r = ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
                                _Maxcode_, _Mode_);
+#endif
     frm_nxt = frm + (_frm_nxt - _frm);
     to_nxt = to + (_to_nxt - _to);
     return r;
 }
 
 __codecvt_utf16<wchar_t, true>::result
 __codecvt_utf16<wchar_t, true>::do_in(state_type&,
     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     const uint8_t* _frm_nxt = _frm;
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
+    ucs_char_t* _to = reinterpret_cast<ucs_char_t*>(to);
+    ucs_char_t* _to_end = reinterpret_cast<ucs_char_t*>(to_end);
+    ucs_char_t* _to_nxt = _to;
+#if SHORT_WCHAR
+    result r = utf16le_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
+                               _Maxcode_, _Mode_);
+#else
     result r = utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
                                _Maxcode_, _Mode_);
+#endif
     frm_nxt = frm + (_frm_nxt - _frm);
     to_nxt = to + (_to_nxt - _to);
     return r;
 }
 
 __codecvt_utf16<wchar_t, true>::result
 __codecvt_utf16<wchar_t, true>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const

 }
 
 int
 __codecvt_utf16<wchar_t, true>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+#if SHORT_WCHAR
+    return utf16le_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
+#else
     return utf16le_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
+#endif
 }
 
 int
 __codecvt_utf16<wchar_t, true>::do_max_length() const  _NOEXCEPT
 {
     if (_Mode_ & consume_header)
         return 6;
     return 4;

 
 // __codecvt_utf8_utf16<wchar_t>
 
 __codecvt_utf8_utf16<wchar_t>::result
 __codecvt_utf8_utf16<wchar_t>::do_out(state_type&,
     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
 {
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
+    const ucs_char_t* _frm = reinterpret_cast<const ucs_char_t*>(frm);
+    const ucs_char_t* _frm_end = reinterpret_cast<const ucs_char_t*>(frm_end);
+    const ucs_char_t* _frm_nxt = _frm;
     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
     uint8_t* _to_nxt = _to;
     result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
                              _Maxcode_, _Mode_);
     frm_nxt = frm + (_frm_nxt - _frm);
     to_nxt = to + (_to_nxt - _to);
     return r;
 }
 
 __codecvt_utf8_utf16<wchar_t>::result
 __codecvt_utf8_utf16<wchar_t>::do_in(state_type&,
     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     const uint8_t* _frm_nxt = _frm;
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
+    ucs_char_t* _to = reinterpret_cast<ucs_char_t*>(to);
+    ucs_char_t* _to_end = reinterpret_cast<ucs_char_t*>(to_end);
+    ucs_char_t* _to_nxt = _to;
     result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
                              _Maxcode_, _Mode_);
     frm_nxt = frm + (_frm_nxt - _frm);
     to_nxt = to + (_to_nxt - _to);
     return r;
 }
 
 __codecvt_utf8_utf16<wchar_t>::result
case 'd':
         }
         break;
     }
     return time_base::no_order;
 }
 
 template <>
 time_base::dateorder
-__time_get_storage<wchar_t>::__do_date_order() const
+__time_get_storage<wchar_t>::__do_date_order() const
 {
     unsigned i;
     for (i = 0; i < __x_.size(); ++i)
         if (__x_[i] == L'%')
             break;
     ++i;
     switch (__x_[i])
     {
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
     if (lc->p_sign_posn == 0)
 #else // _LIBCPP_MSVCRT
     if (lc->int_p_sign_posn == 0)
 #endif // !_LIBCPP_MSVCRT
         __positive_sign_ = L"()";
     else
     {
         mb = mbstate_t();
-        bb = lc->positive_sign;
+        bb = lc->positive_sign;
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
         j = mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
 #else
         j = __mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
 #endif
         if (j == size_t(-1))
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;

test/CMakeLists.txt

if (LIT_EXECUTABLE)
   if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY)
     set(LIBCXX_CXX_ABI_LIBNAME "none")
   endif()
   set(LIBCXX_TARGET_INFO "libcxx.test.target_info.LocalTI" CACHE STRING
       "TargetInfo to use when setting up test environment.")
   set(LIBCXX_EXECUTOR "None" CACHE STRING
       "Executor to use when running tests.")
 
+  # Detect size of wchar_t
+  include(CheckTypeSize)
+  check_type_size("wchar_t" WCHAR_SIZE)
+
   set(AUTO_GEN_COMMENT "## Autogenerated by libcxx configuration.\n# Do not edit!")
 
   configure_file(
     ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
     ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
     @ONLY)
 
   add_custom_target(check-libcxx

test/libcxx/test/config.py

def configure_features(self):
         if self.long_tests:
             self.config.available_features.add('long_tests')
 
         # Run a compile test for the -fsized-deallocation flag. This is needed
         # in test/std/language.support/support.dynamic/new.delete
         if self.cxx.hasCompileFlag('-fsized-deallocation'):
             self.config.available_features.add('fsized-deallocation')
 
+        if self.config.wchar_size == '2':
+            self.config.available_features.add('short_wchar')
+
     def configure_compile_flags(self):
         no_default_flags = self.get_lit_bool('no_default_flags', False)
         if not no_default_flags:
             self.configure_default_compile_flags()
         # Configure extra flags
         compile_flags_str = self.get_lit_conf('compile_flags', '')
         self.cxx.compile_flags += shlex.split(compile_flags_str)
 

test/lit.site.cfg.in

 config.enable_monotonic_clock   = "@LIBCXX_ENABLE_MONOTONIC_CLOCK@"
 config.cxx_abi                  = "@LIBCXX_CXX_ABI_LIBNAME@"
 config.use_sanitizer            = "@LLVM_USE_SANITIZER@"
 config.abi_library_path         = "@LIBCXX_CXX_ABI_LIBRARY_PATH@"
 config.configuration_variant    = "@LIBCXX_LIT_VARIANT@"
 config.target_triple            = "@LIBCXX_TARGET_TRIPLE@"
 config.sysroot                  = "@LIBCXX_SYSROOT@"
 config.gcc_toolchain            = "@LIBCXX_GCC_TOOLCHAIN@"
+config.wchar_size               = "@WCHAR_SIZE@"
 config.generate_coverage        = "@LIBCXX_GENERATE_COVERAGE@"
 config.target_info              = "@LIBCXX_TARGET_INFO@"
 config.executor                 = "@LIBCXX_EXECUTOR@"
 config.llvm_unwinder            = "@LIBCXXABI_USE_LLVM_UNWINDER@"
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LIBCXX_SOURCE_DIR@/test/lit.cfg")

test/std/localization/locale.stdcvt/codecvt_utf16_in.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.
 //
 //===----------------------------------------------------------------------===//
 
 // <codecvt>
 
 // template <class Elem, unsigned long Maxcode = 0x10ffff,
 //           codecvt_mode Mode = (codecvt_mode)0>
 // class codecvt_utf16
 //     : public codecvt<Elem, char, mbstate_t>
 // {
 //     // unspecified
 // };
 
 // result
 //     in(stateT& state,
 //        const externT* from, const externT* from_end, const externT*& from_next,
 //        internT* to, internT* to_end, internT*& to_next) const;
 
+// UNSUPPORTED: short_wchar
+
 #include <codecvt>
 #include <cassert>
 
 int main()
 {
     {
         typedef std::codecvt_utf16<wchar_t> C;
         C c;
int main()
         assert(np == n);
         assert(w == 0);
 
         n[0] = char(0x10);
         n[1] = char(0x05);
         r = c.in(m, n, n+2, np, &w, &w+1, wp);
         assert(r == std::codecvt_base::error);
         assert(wp == &w);
-        assert(np == n);
+        assert(np == n);
         assert(w == 0);
 
         n[0] = char(0x04);
         n[1] = char(0x53);
         r = c.in(m, n, n+2, np, &w, &w+1, wp);
         assert(r == std::codecvt_base::ok);
         assert(wp == &w+1);
         assert(np == n+2);

test/std/localization/locale.stdcvt/codecvt_utf16_in_short_wchar.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <codecvt>
+
+// template <class Elem, unsigned long Maxcode = 0x10ffff,
+//           codecvt_mode Mode = (codecvt_mode)0>
+// class codecvt_utf16
+//     : public codecvt<Elem, char, mbstate_t>
+// {
+//     // unspecified
+// };
+
+// result
+//     in(stateT& state,
+//        const externT* from, const externT* from_end, const externT*& from_next,
+//        internT* to, internT* to_end, internT*& to_next) const;
+
+// REQUIRES: short_wchar
+
+#include <codecvt>
+#include <cassert>
+
+int main()
+{
+    {
+        typedef std::codecvt_utf16<wchar_t> C;
+        C c;
+        wchar_t w = 0;
+        char n[2] = {char(0x10), char(0x05)};
+        wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x1005);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x1000> C;
+        C c;
+        wchar_t w = 0;
+        char n[2] = {char(0x10), char(0x05)};
+        wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::consume_header> C;
+        C c;
+        wchar_t w = 0;
+        char n[4] = {char(0xFE), char(0xFF), char(0x10), char(0x05)};
+        wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(w == 0x1005);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::little_endian> C;
+        C c;
+        wchar_t w = 0;
+        char n[2] = {char(0x05), char(0x10)};
+        wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x1005);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x1000, std::little_endian> C;
+        C c;
+        wchar_t w = 0;
+        char n[2] = {char(0x05), char(0x10)};
+        wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::codecvt_mode(
+                                                         std::consume_header |
+                                                         std::little_endian)> C;
+        C c;
+        wchar_t w = 0;
+        char n[6] = {char(0xFF), char(0xFE), char(0x05), char(0x10)};
+        wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(w == 0x1005);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<char32_t> C;
+        C c;
+        char32_t w = 0;
+        char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
+        char32_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(w == 0x40003);
+
+        n[0] = char(0x10);
+        n[1] = char(0x05);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x1005);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<char32_t, 0x1000> C;
+        C c;
+        char32_t w = 0;
+        char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
+        char32_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[0] = char(0x10);
+        n[1] = char(0x05);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<char32_t, 0x10ffff, std::consume_header> C;
+        C c;
+        char32_t w = 0;
+        char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
+        char32_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+6);
+        assert(w == 0x40003);
+
+        n[0] = char(0x10);
+        n[1] = char(0x05);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x1005);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<char32_t, 0x10ffff, std::little_endian> C;
+        C c;
+        char32_t w = 0;
+        char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
+        char32_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(w == 0x40003);
+
+        n[1] = char(0x10);
+        n[0] = char(0x05);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x1005);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<char32_t, 0x1000, std::little_endian> C;
+        C c;
+        char32_t w = 0;
+        char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
+        char32_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[1] = char(0x10);
+        n[0] = char(0x05);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<char32_t, 0x10ffff, std::codecvt_mode(
+                                                         std::consume_header |
+                                                         std::little_endian)> C;
+        C c;
+        char32_t w = 0;
+        char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
+        char32_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+6);
+        assert(w == 0x40003);
+
+        n[1] = char(0x10);
+        n[0] = char(0x05);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x1005);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+
+    {
+        typedef std::codecvt_utf16<char16_t> C;
+        C c;
+        char16_t w = 0;
+        char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
+        char16_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[0] = char(0x10);
+        n[1] = char(0x05);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x1005);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<char16_t, 0x1000> C;
+        C c;
+        char16_t w = 0;
+        char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
+        char16_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[0] = char(0x10);
+        n[1] = char(0x05);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<char16_t, 0x10ffff, std::consume_header> C;
+        C c;
+        char16_t w = 0;
+        char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
+        char16_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n+2);
+        assert(w == 0);
+
+        n[0] = char(0x10);
+        n[1] = char(0x05);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x1005);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<char16_t, 0x10ffff, std::little_endian> C;
+        C c;
+        char16_t w = 0;
+        char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
+        char16_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[1] = char(0x10);
+        n[0] = char(0x05);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x1005);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<char16_t, 0x1000, std::little_endian> C;
+        C c;
+        char16_t w = 0;
+        char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
+        char16_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[1] = char(0x10);
+        n[0] = char(0x05);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf16<char16_t, 0x10ffff, std::codecvt_mode(
+                                                         std::consume_header |
+                                                         std::little_endian)> C;
+        C c;
+        char16_t w = 0;
+        char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
+        char16_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n+2);
+        assert(w == 0);
+
+        n[1] = char(0x10);
+        n[0] = char(0x05);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x1005);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x56);
+    }
+}

test/std/localization/locale.stdcvt/codecvt_utf16_length.pass.cpp

 //     : public codecvt<Elem, char, mbstate_t>
 // {
 //     // unspecified
 // };
 
 // int length(stateT& state, const externT* from, const externT* from_end,
 //            size_t max) const;
 
+// UNSUPPORTED: short_wchar
+
 #include <codecvt>
 #include <cassert>
 
 int main()
 {
     {
         typedef std::codecvt_utf16<wchar_t> C;
         C c;

test/std/localization/locale.stdcvt/codecvt_utf16_length_short_wchar.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <codecvt>
+
+// template <class Elem, unsigned long Maxcode = 0x10ffff,
+//           codecvt_mode Mode = (codecvt_mode)0>
+// class codecvt_utf16
+//     : public codecvt<Elem, char, mbstate_t>
+// {
+//     // unspecified
+// };
+
+// int length(stateT& state, const externT* from, const externT* from_end,
+//            size_t max) const;
+
+// REQUIRES: short_wchar
+
+#include <codecvt>
+#include <cassert>
+
+int main()
+{
+    {
+        typedef std::codecvt_utf16<wchar_t> C;
+        C c;
+        char n[2] = {char(0x10), char(0x05)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x1000> C;
+        C c;
+        char n[2] = {char(0x10), char(0x05)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+2, 2);
+        assert(r == 0);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::consume_header> C;
+        C c;
+        char n[4] = {char(0xFE), char(0xFF), char(0x10), char(0x05)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 2);
+        assert(r == 4);
+
+        n[0] = char(0x10);
+        n[1] = char(0x05);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::little_endian> C;
+        C c;
+        char n[2] = {char(0x05), char(0x10)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x1000, std::little_endian> C;
+        C c;
+        char n[2] = {char(0x05), char(0x10)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+2, 2);
+        assert(r == 0);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::codecvt_mode(
+                                                         std::consume_header |
+                                                         std::little_endian)> C;
+        C c;
+        char n[4] = {char(0xFF), char(0xFE), char(0x05), char(0x10)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 2);
+        assert(r == 4);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<char32_t> C;
+        C c;
+        char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 2);
+        assert(r == 4);
+
+        n[0] = char(0x10);
+        n[1] = char(0x05);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<char32_t, 0x1000> C;
+        C c;
+        char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 2);
+        assert(r == 0);
+
+        n[0] = char(0x10);
+        n[1] = char(0x05);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 0);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<char32_t, 0x10ffff, std::consume_header> C;
+        C c;
+        char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+6, 2);
+        assert(r == 6);
+
+        n[0] = char(0x10);
+        n[1] = char(0x05);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<char32_t, 0x10ffff, std::little_endian> C;
+        C c;
+        char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 2);
+        assert(r == 4);
+
+        n[1] = char(0x10);
+        n[0] = char(0x05);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<char32_t, 0x1000, std::little_endian> C;
+        C c;
+        char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 2);
+        assert(r == 0);
+
+        n[1] = char(0x10);
+        n[0] = char(0x05);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 0);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<char32_t, 0x10ffff, std::codecvt_mode(
+                                                         std::consume_header |
+                                                         std::little_endian)> C;
+        C c;
+        char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+6, 2);
+        assert(r == 6);
+
+        n[1] = char(0x10);
+        n[0] = char(0x05);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+
+    {
+        typedef std::codecvt_utf16<char16_t> C;
+        C c;
+        char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 2);
+        assert(r == 0);
+
+        n[0] = char(0x10);
+        n[1] = char(0x05);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<char16_t, 0x1000> C;
+        C c;
+        char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 2);
+        assert(r == 0);
+
+        n[0] = char(0x10);
+        n[1] = char(0x05);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 0);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<char16_t, 0x10ffff, std::consume_header> C;
+        C c;
+        char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+6, 2);
+        assert(r == 2);
+
+        n[0] = char(0x10);
+        n[1] = char(0x05);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x04);
+        n[1] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[0] = char(0x00);
+        n[1] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<char16_t, 0x10ffff, std::little_endian> C;
+        C c;
+        char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 2);
+        assert(r == 0);
+
+        n[1] = char(0x10);
+        n[0] = char(0x05);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<char16_t, 0x1000, std::little_endian> C;
+        C c;
+        char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 2);
+        assert(r == 0);
+
+        n[1] = char(0x10);
+        n[0] = char(0x05);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 0);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+    {
+        typedef std::codecvt_utf16<char16_t, 0x10ffff, std::codecvt_mode(
+                                                         std::consume_header |
+                                                         std::little_endian)> C;
+        C c;
+        char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+6, 2);
+        assert(r == 2);
+
+        n[1] = char(0x10);
+        n[0] = char(0x05);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x04);
+        n[0] = char(0x53);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+
+        n[1] = char(0x00);
+        n[0] = char(0x56);
+        r = c.length(m, n, n+2, 2);
+        assert(r == 2);
+    }
+}

test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp

 //     // unspecified
 // };
 
 // result
 // out(stateT& state,
 //     const internT* from, const internT* from_end, const internT*& from_next,
 //     externT* to, externT* to_end, externT*& to_next) const;
 
+// UNSUPPORTED: short_wchar
+
 #include <codecvt>
 #include <cassert>
 
 int main()
 {
     {
         typedef std::codecvt_utf16<wchar_t> C;
         C c;

test/std/localization/locale.stdcvt/codecvt_utf16_out_short_wchar.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <codecvt>
+
+// template <class Elem, unsigned long Maxcode = 0x10ffff,
+//           codecvt_mode Mode = (codecvt_mode)0>
+// class codecvt_utf16
+//     : public codecvt<Elem, char, mbstate_t>
+// {
+//     // unspecified
+// };
+
+// result
+// out(stateT& state,
+//     const internT* from, const internT* from_end, const internT*& from_next,
+//     externT* to, externT* to_end, externT*& to_next) const;
+
+// REQUIRES: short_wchar
+
+#include <codecvt>
+#include <cassert>
+
+int main()
+{
+    {
+        typedef std::codecvt_utf16<wchar_t> C;
+        C c;
+        wchar_t w = 0x1005;
+        char n[2] = {0};
+        const wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[0] == char(0x10));
+        assert(n[1] == char(0x05));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[0] == char(0x04));
+        assert(n[1] == char(0x53));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[0] == char(0x00));
+        assert(n[1] == char(0x56));
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x1000> C;
+        C c;
+        wchar_t w = 0x1005;
+        char n[2] = {0};
+        const wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(n[0] == char(0));
+        assert(n[1] == char(0));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[0] == char(0x04));
+        assert(n[1] == char(0x53));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[0] == char(0x00));
+        assert(n[1] == char(0x56));
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::generate_header> C;
+        C c;
+        wchar_t w = 0x1005;
+        char n[4] = {0};
+        const wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(n[0] == char(0xFE));
+        assert(n[1] == char(0xFF));
+        assert(n[2] == char(0x10));
+        assert(n[3] == char(0x05));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(n[0] == char(0xFE));
+        assert(n[1] == char(0xFF));
+        assert(n[2] == char(0x04));
+        assert(n[3] == char(0x53));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(n[0] == char(0xFE));
+        assert(n[1] == char(0xFF));
+        assert(n[2] == char(0x00));
+        assert(n[3] == char(0x56));
+    }
+
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x10FFFF, std::little_endian> C;
+        C c;
+        wchar_t w = 0x1005;
+        char n[2] = {0};
+        const wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[1] == char(0x10));
+        assert(n[0] == char(0x05));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[1] == char(0x04));
+        assert(n[0] == char(0x53));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[1] == char(0x00));
+        assert(n[0] == char(0x56));
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x1000, std::little_endian> C;
+        C c;
+        wchar_t w = 0x1005;
+        char n[2] = {0};
+        const wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(n[1] == char(0));
+        assert(n[0] == char(0));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[1] == char(0x04));
+        assert(n[0] == char(0x53));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[1] == char(0x00));
+        assert(n[0] == char(0x56));
+    }
+    {
+        typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::codecvt_mode(
+                                                         std::generate_header |
+                                                         std::little_endian)> C;
+        C c;
+        wchar_t w = 0x1005;
+        char n[4] = {0};
+        const wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(n[1] == char(0xFE));
+        assert(n[0] == char(0xFF));
+        assert(n[3] == char(0x10));
+        assert(n[2] == char(0x05));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(n[1] == char(0xFE));
+        assert(n[0] == char(0xFF));
+        assert(n[3] == char(0x04));
+        assert(n[2] == char(0x53));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(n[1] == char(0xFE));
+        assert(n[0] == char(0xFF));
+        assert(n[3] == char(0x00));
+        assert(n[2] == char(0x56));
+    }
+}

test/std/localization/locale.stdcvt/codecvt_utf8_in.pass.cpp

 //     // unspecified
 // };
 
 // result
 //     in(stateT& state,
 //        const externT* from, const externT* from_end, const externT*& from_next,
 //        internT* to, internT* to_end, internT*& to_next) const;
 
+// UNSUPPORTED: short_wchar
+
 #include <codecvt>
 #include <cassert>
 
 int main()
 {
     {
         typedef std::codecvt_utf8<wchar_t> C;
         C c;
int main()
         assert(w == 0x453);
 
         w = 0x56;
         n[0] = char(0x56);
         r = c.in(m, n, n+1, np, &w, &w+1, wp);
         assert(r == std::codecvt_base::ok);
         assert(wp == &w+1);
         assert(np == n+1);
-        assert(w == 0x56);
+        assert(w == 0x56);
     }
     {
         typedef std::codecvt_utf8<char32_t, 0x1000> C;
         C c;
         char32_t w = 0;
         char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
         char32_t* wp = nullptr;
         std::mbstate_t m;

test/std/localization/locale.stdcvt/codecvt_utf8_in_short_wchar.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <codecvt>
+
+// template <class Elem, unsigned long Maxcode = 0x10ffff,
+//           codecvt_mode Mode = (codecvt_mode)0>
+// class codecvt_utf8
+//     : public codecvt<Elem, char, mbstate_t>
+// {
+//     // unspecified
+// };
+
+// result
+//     in(stateT& state,
+//        const externT* from, const externT* from_end, const externT*& from_next,
+//        internT* to, internT* to_end, internT*& to_next) const;
+
+// REQUIRES: short_wchar
+
+#include <codecvt>
+#include <cassert>
+
+int main()
+{
+    {
+        typedef std::codecvt_utf8<wchar_t> C;
+        C c;
+        wchar_t w = 0;
+        char n[3] = {char(0xE1), char(0x80), char(0x85)};
+        wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        n[0] = char(0xE1);
+        n[1] = char(0x80);
+        n[2] = char(0x85);
+        std::codecvt_base::result r = c.in(m, n, n+3, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+3);
+        assert(w == 0x1005);
+
+        n[0] = char(0xD1);
+        n[1] = char(0x93);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x56);
+        r = c.in(m, n, n+1, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf8<wchar_t, 0x1000> C;
+        C c;
+        wchar_t w = 0;
+        char n[3] = {char(0xE1), char(0x80), char(0x85)};
+        wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+3, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[0] = char(0xD1);
+        n[1] = char(0x93);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x56);
+        r = c.in(m, n, n+1, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf8<wchar_t, 0xFFFFFFFF, std::consume_header> C;
+        C c;
+        wchar_t w = 0;
+        char n[6] = {char(0xEF), char(0xBB), char(0xBF), char(0xE1), char(0x80), char(0x85)};
+        wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+6);
+        assert(w == 0x1005);
+
+        n[0] = char(0xEF);
+        n[1] = char(0xBB);
+        n[2] = char(0xBF);
+        n[3] = char(0xD1);
+        n[4] = char(0x93);
+        r = c.in(m, n, n+5, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+5);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x56);
+        r = c.in(m, n, n+1, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf8<char32_t> C;
+        C c;
+        char32_t w = 0;
+        char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
+        char32_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(w == 0x40003);
+
+        n[0] = char(0xE1);
+        n[1] = char(0x80);
+        n[2] = char(0x85);
+        r = c.in(m, n, n+3, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+3);
+        assert(w == 0x1005);
+
+        n[0] = char(0xD1);
+        n[1] = char(0x93);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x56);
+        r = c.in(m, n, n+1, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf8<char32_t, 0x1000> C;
+        C c;
+        char32_t w = 0;
+        char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
+        char32_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[0] = char(0xE1);
+        n[1] = char(0x80);
+        n[2] = char(0x85);
+        r = c.in(m, n, n+3, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[0] = char(0xD1);
+        n[1] = char(0x93);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x56);
+        r = c.in(m, n, n+1, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf8<char32_t, 0xFFFFFFFF, std::consume_header> C;
+        C c;
+        char32_t w = 0;
+        char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1), char(0x80), char(0x80), char(0x83)};
+        char32_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+7, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+7);
+        assert(w == 0x40003);
+
+        n[0] = char(0xE1);
+        n[1] = char(0x80);
+        n[2] = char(0x85);
+        r = c.in(m, n, n+3, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+3);
+        assert(w == 0x1005);
+
+        n[0] = char(0xEF);
+        n[1] = char(0xBB);
+        n[2] = char(0xBF);
+        n[3] = char(0xD1);
+        n[4] = char(0x93);
+        r = c.in(m, n, n+5, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+5);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x56);
+        r = c.in(m, n, n+1, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf8<char16_t> C;
+        C c;
+        char16_t w = 0;
+        char n[3] = {char(0xE1), char(0x80), char(0x85)};
+        char16_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+3, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+3);
+        assert(w == 0x1005);
+
+        n[0] = char(0xD1);
+        n[1] = char(0x93);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x56);
+        r = c.in(m, n, n+1, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf8<char16_t, 0x1000> C;
+        C c;
+        char16_t w = 0;
+        char n[3] = {char(0xE1), char(0x80), char(0x85)};
+        char16_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+3, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(w == 0);
+
+        n[0] = char(0xD1);
+        n[1] = char(0x93);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x56);
+        r = c.in(m, n, n+1, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(w == 0x56);
+    }
+    {
+        typedef std::codecvt_utf8<char16_t, 0xFFFFFFFF, std::consume_header> C;
+        C c;
+        char16_t w = 0;
+        char n[6] = {char(0xEF), char(0xBB), char(0xBF), char(0xE1), char(0x80), char(0x85)};
+        char16_t* wp = nullptr;
+        std::mbstate_t m;
+        const char* np = nullptr;
+        std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+6);
+        assert(w == 0x1005);
+
+        n[0] = char(0xD1);
+        n[1] = char(0x93);
+        r = c.in(m, n, n+2, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(w == 0x453);
+
+        w = 0x56;
+        n[0] = char(0x56);
+        r = c.in(m, n, n+1, np, &w, &w+1, wp);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(w == 0x56);
+    }
+}

test/std/localization/locale.stdcvt/codecvt_utf8_length.pass.cpp

 //     : public codecvt<Elem, char, mbstate_t>
 // {
 //     // unspecified
 // };
 
 // int length(stateT& state, const externT* from, const externT* from_end,
 //            size_t max) const;
 
+// UNSUPPORTED: short_wchar
+
 #include <codecvt>
 #include <cassert>
 
 int main()
 {
     {
         typedef std::codecvt_utf8<wchar_t> C;
         C c;

test/std/localization/locale.stdcvt/codecvt_utf8_length_short_wchar.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <codecvt>
+
+// template <class Elem, unsigned long Maxcode = 0x10ffff,
+//           codecvt_mode Mode = (codecvt_mode)0>
+// class codecvt_utf8
+//     : public codecvt<Elem, char, mbstate_t>
+// {
+//     // unspecified
+// };
+
+// int length(stateT& state, const externT* from, const externT* from_end,
+//            size_t max) const;
+
+// REQUIRES: short_wchar
+
+#include <codecvt>
+#include <cassert>
+
+int main()
+{
+    {
+        typedef std::codecvt_utf8<wchar_t> C;
+        C c;
+        char n[3] = {char(0xE1), char(0x80), char(0x85)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+3, 2);
+        assert(r == 3);
+
+        n[0] = char(0xD1);
+        n[1] = char(0x93);
+        r = c.length(m, n, n+2, 3);
+        assert(r == 2);
+
+        n[0] = char(0x56);
+        r = c.length(m, n, n+1, 3);
+        assert(r == 1);
+    }
+    {
+        typedef std::codecvt_utf8<wchar_t, 0x1000> C;
+        C c;
+        char n[3] = {char(0xE1), char(0x80), char(0x85)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+3, 2);
+        assert(r == 0);
+
+        n[0] = char(0xD1);
+        n[1] = char(0x93);
+        r = c.length(m, n, n+2, 3);
+        assert(r == 2);
+
+        n[0] = char(0x56);
+        r = c.length(m, n, n+1, 3);
+        assert(r == 1);
+    }
+    {
+        typedef std::codecvt_utf8<wchar_t, 0xFFFFFFFF, std::consume_header> C;
+        C c;
+        char n[6] = {char(0xEF), char(0xBB), char(0xBF), char(0xE1), char(0x80), char(0x85)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+6, 2);
+        assert(r == 6);
+
+        n[0] = char(0xE1);
+        n[1] = char(0x80);
+        n[2] = char(0x85);
+        r = c.length(m, n, n+3, 2);
+        assert(r == 3);
+
+        n[0] = char(0xEF);
+        n[1] = char(0xBB);
+        n[2] = char(0xBF);
+        n[3] = char(0xD1);
+        n[4] = char(0x93);
+        r = c.length(m, n, n+5, 3);
+        assert(r == 5);
+
+        n[0] = char(0x56);
+        r = c.length(m, n, n+1, 3);
+        assert(r == 1);
+    }
+    {
+        typedef std::codecvt_utf8<char32_t> C;
+        C c;
+        char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 1);
+        assert(r == 4);
+
+        n[0] = char(0xE1);
+        n[1] = char(0x80);
+        n[2] = char(0x85);
+        r = c.length(m, n, n+3, 2);
+        assert(r == 3);
+
+        n[0] = char(0xD1);
+        n[1] = char(0x93);
+        r = c.length(m, n, n+2, 3);
+        assert(r == 2);
+
+        n[0] = char(0x56);
+        r = c.length(m, n, n+1, 3);
+        assert(r == 1);
+    }
+    {
+        typedef std::codecvt_utf8<char32_t, 0x1000> C;
+        C c;
+        char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 1);
+        assert(r == 0);
+
+        n[0] = char(0xE1);
+        n[1] = char(0x80);
+        n[2] = char(0x85);
+        r = c.length(m, n, n+3, 2);
+        assert(r == 0);
+
+        n[0] = char(0xD1);
+        n[1] = char(0x93);
+        r = c.length(m, n, n+2, 3);
+        assert(r == 2);
+
+        n[0] = char(0x56);
+        r = c.length(m, n, n+1, 3);
+        assert(r == 1);
+    }
+    {
+        typedef std::codecvt_utf8<char32_t, 0xFFFFFFFF, std::consume_header> C;
+        C c;
+        char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1), char(0x80), char(0x80), char(0x83)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+7, 1);
+        assert(r == 7);
+
+        n[0] = char(0xE1);
+        n[1] = char(0x80);
+        n[2] = char(0x85);
+        r = c.length(m, n, n+3, 2);
+        assert(r == 3);
+
+        n[0] = char(0xEF);
+        n[1] = char(0xBB);
+        n[2] = char(0xBF);
+        n[3] = char(0xD1);
+        n[4] = char(0x93);
+        r = c.length(m, n, n+5, 3);
+        assert(r == 5);
+
+        n[0] = char(0x56);
+        r = c.length(m, n, n+1, 3);
+        assert(r == 1);
+    }
+    {
+        typedef std::codecvt_utf8<char16_t> C;
+        C c;
+        char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 1);
+        assert(r == 0);
+
+        n[0] = char(0xE1);
+        n[1] = char(0x80);
+        n[2] = char(0x85);
+        r = c.length(m, n, n+3, 2);
+        assert(r == 3);
+
+        n[0] = char(0xD1);
+        n[1] = char(0x93);
+        r = c.length(m, n, n+2, 3);
+        assert(r == 2);
+
+        n[0] = char(0x56);
+        r = c.length(m, n, n+1, 3);
+        assert(r == 1);
+    }
+    {
+        typedef std::codecvt_utf8<char16_t, 0x1000> C;
+        C c;
+        char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+4, 1);
+        assert(r == 0);
+
+        n[0] = char(0xE1);
+        n[1] = char(0x80);
+        n[2] = char(0x85);
+        r = c.length(m, n, n+3, 2);
+        assert(r == 0);
+
+        n[0] = char(0xD1);
+        n[1] = char(0x93);
+        r = c.length(m, n, n+2, 3);
+        assert(r == 2);
+
+        n[0] = char(0x56);
+        r = c.length(m, n, n+1, 3);
+        assert(r == 1);
+    }
+    {
+        typedef std::codecvt_utf8<char16_t, 0xFFFFFFFF, std::consume_header> C;
+        C c;
+        char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1), char(0x80), char(0x80), char(0x83)};
+        std::mbstate_t m;
+        int r = c.length(m, n, n+7, 1);
+        assert(r == 3);
+
+        n[0] = char(0xE1);
+        n[1] = char(0x80);
+        n[2] = char(0x85);
+        r = c.length(m, n, n+3, 2);
+        assert(r == 3);
+
+        n[0] = char(0xEF);
+        n[1] = char(0xBB);
+        n[2] = char(0xBF);
+        n[3] = char(0xD1);
+        n[4] = char(0x93);
+        r = c.length(m, n, n+5, 3);
+        assert(r == 5);
+
+        n[0] = char(0x56);
+        r = c.length(m, n, n+1, 3);
+        assert(r == 1);
+    }
+}

test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp

 //     // unspecified
 // };
 
 // result
 // out(stateT& state,
 //     const internT* from, const internT* from_end, const internT*& from_next,
 //     externT* to, externT* to_end, externT*& to_next) const;
 
+// UNSUPPORTED: short_wchar
+
 #include <codecvt>
 #include <cassert>
 
 int main()
 {
     {
         typedef std::codecvt_utf8<wchar_t> C;
         C c;
int main()
         assert(n[0] == char(0));
         assert(n[1] == char(0));
         assert(n[2] == char(0));
         assert(n[3] == char(0));
 
         w = 0x453;
         r = c.out(m, &w, &w+1, wp, n, n+4, np);
         assert(r == std::codecvt_base::ok);
-        assert(wp == &w+1);
+        assert(wp == &w+1);
         assert(np == n+2);
         assert(n[0] == char(0xD1));
         assert(n[1] == char(0x93));
         assert(n[2] == char(0));
         assert(n[3] == char(0));
 
         w = 0x56;
         r = c.out(m, &w, &w+1, wp, n, n+4, np);

test/std/localization/locale.stdcvt/codecvt_utf8_out_short_wchar.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <codecvt>
+
+// template <class Elem, unsigned long Maxcode = 0x10ffff,
+//           codecvt_mode Mode = (codecvt_mode)0>
+// class codecvt_utf8
+//     : public codecvt<Elem, char, mbstate_t>
+// {
+//     // unspecified
+// };
+
+// result
+// out(stateT& state,
+//     const internT* from, const internT* from_end, const internT*& from_next,
+//     externT* to, externT* to_end, externT*& to_next) const;
+
+// REQUIRES: short_wchar
+
+#include <codecvt>
+#include <cassert>
+
+int main()
+{
+    {
+        typedef std::codecvt_utf8<wchar_t> C;
+        C c;
+        wchar_t w = 0x1005;
+        char n[3] = {0};
+        const wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+3, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+3);
+        assert(n[0] == char(0xE1));
+        assert(n[1] == char(0x80));
+        assert(n[2] == char(0x85));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+3, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[0] == char(0xD1));
+        assert(n[1] == char(0x93));
+        assert(n[2] == char(0x85));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+3, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(n[0] == char(0x56));
+        assert(n[1] == char(0x93));
+        assert(n[2] == char(0x85));
+    }
+    {
+        typedef std::codecvt_utf8<wchar_t, 0x1000> C;
+        C c;
+        wchar_t w = 0x1005;
+        char n[2] = {0};
+        const wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(n[0] == char(0));
+        assert(n[1] == char(0));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[0] == char(0xD1));
+        assert(n[1] == char(0x93));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+2, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(n[0] == char(0x56));
+        assert(n[1] == char(0x93));
+    }
+    {
+        typedef std::codecvt_utf8<wchar_t, 0xFFFFFFFF, std::generate_header> C;
+        C c;
+        wchar_t w = 0x1005;
+        char n[6] = {0};
+        const wchar_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+6, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+6);
+        assert(n[0] == char(0xEF));
+        assert(n[1] == char(0xBB));
+        assert(n[2] == char(0xBF));
+        assert(n[3] == char(0xE1));
+        assert(n[4] == char(0x80));
+        assert(n[5] == char(0x85));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+6, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+5);
+        assert(n[0] == char(0xEF));
+        assert(n[1] == char(0xBB));
+        assert(n[2] == char(0xBF));
+        assert(n[3] == char(0xD1));
+        assert(n[4] == char(0x93));
+        assert(n[5] == char(0x85));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+6, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(n[0] == char(0xEF));
+        assert(n[1] == char(0xBB));
+        assert(n[2] == char(0xBF));
+        assert(n[3] == char(0x56));
+        assert(n[4] == char(0x93));
+        assert(n[5] == char(0x85));
+    }
+    {
+        typedef std::codecvt_utf8<char32_t> C;
+        C c;
+        char32_t w = 0x40003;
+        char n[4] = {0};
+        const char32_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(n[0] == char(0xF1));
+        assert(n[1] == char(0x80));
+        assert(n[2] == char(0x80));
+        assert(n[3] == char(0x83));
+
+        w = 0x1005;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+3);
+        assert(n[0] == char(0xE1));
+        assert(n[1] == char(0x80));
+        assert(n[2] == char(0x85));
+        assert(n[3] == char(0x83));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[0] == char(0xD1));
+        assert(n[1] == char(0x93));
+        assert(n[2] == char(0x85));
+        assert(n[3] == char(0x83));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(n[0] == char(0x56));
+        assert(n[1] == char(0x93));
+        assert(n[2] == char(0x85));
+        assert(n[3] == char(0x83));
+    }
+    {
+        typedef std::codecvt_utf8<char32_t, 0x1000> C;
+        C c;
+        char32_t w = 0x40003;
+        char n[4] = {0};
+        const char32_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(n[0] == char(0));
+        assert(n[1] == char(0));
+        assert(n[2] == char(0));
+        assert(n[3] == char(0));
+
+        w = 0x1005;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(n[0] == char(0));
+        assert(n[1] == char(0));
+        assert(n[2] == char(0));
+        assert(n[3] == char(0));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[0] == char(0xD1));
+        assert(n[1] == char(0x93));
+        assert(n[2] == char(0));
+        assert(n[3] == char(0));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(n[0] == char(0x56));
+        assert(n[1] == char(0x93));
+        assert(n[2] == char(0));
+        assert(n[3] == char(0));
+    }
+    {
+        typedef std::codecvt_utf8<char32_t, 0xFFFFFFFF, std::generate_header> C;
+        C c;
+        char32_t w = 0x40003;
+        char n[7] = {0};
+        const char32_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+7, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+7);
+        assert(n[0] == char(0xEF));
+        assert(n[1] == char(0xBB));
+        assert(n[2] == char(0xBF));
+        assert(n[3] == char(0xF1));
+        assert(n[4] == char(0x80));
+        assert(n[5] == char(0x80));
+        assert(n[6] == char(0x83));
+
+        w = 0x1005;
+        r = c.out(m, &w, &w+1, wp, n, n+7, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+6);
+        assert(n[0] == char(0xEF));
+        assert(n[1] == char(0xBB));
+        assert(n[2] == char(0xBF));
+        assert(n[3] == char(0xE1));
+        assert(n[4] == char(0x80));
+        assert(n[5] == char(0x85));
+        assert(n[6] == char(0x83));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+7, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+5);
+        assert(n[0] == char(0xEF));
+        assert(n[1] == char(0xBB));
+        assert(n[2] == char(0xBF));
+        assert(n[3] == char(0xD1));
+        assert(n[4] == char(0x93));
+        assert(n[5] == char(0x85));
+        assert(n[6] == char(0x83));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+7, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(n[0] == char(0xEF));
+        assert(n[1] == char(0xBB));
+        assert(n[2] == char(0xBF));
+        assert(n[3] == char(0x56));
+        assert(n[4] == char(0x93));
+        assert(n[5] == char(0x85));
+        assert(n[6] == char(0x83));
+    }
+    {
+        typedef std::codecvt_utf8<char16_t> C;
+        C c;
+        char16_t w = 0x1005;
+        char n[4] = {0};
+        const char16_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+3);
+        assert(n[0] == char(0xE1));
+        assert(n[1] == char(0x80));
+        assert(n[2] == char(0x85));
+        assert(n[3] == char(0));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[0] == char(0xD1));
+        assert(n[1] == char(0x93));
+        assert(n[2] == char(0x85));
+        assert(n[3] == char(0));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(n[0] == char(0x56));
+        assert(n[1] == char(0x93));
+        assert(n[2] == char(0x85));
+        assert(n[3] == char(0));
+    }
+    {
+        typedef std::codecvt_utf8<char16_t, 0x1000> C;
+        C c;
+        char16_t w = 0x1005;
+        char n[4] = {0};
+        const char16_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::error);
+        assert(wp == &w);
+        assert(np == n);
+        assert(n[0] == char(0));
+        assert(n[1] == char(0));
+        assert(n[2] == char(0));
+        assert(n[3] == char(0));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+2);
+        assert(n[0] == char(0xD1));
+        assert(n[1] == char(0x93));
+        assert(n[2] == char(0));
+        assert(n[3] == char(0));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+4, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+1);
+        assert(n[0] == char(0x56));
+        assert(n[1] == char(0x93));
+        assert(n[2] == char(0));
+        assert(n[3] == char(0));
+    }
+    {
+        typedef std::codecvt_utf8<char16_t, 0xFFFFFFFF, std::generate_header> C;
+        C c;
+        char16_t w = 0x1005;
+        char n[7] = {0};
+        const char16_t* wp = nullptr;
+        std::mbstate_t m;
+        char* np = nullptr;
+        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+7, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+6);
+        assert(n[0] == char(0xEF));
+        assert(n[1] == char(0xBB));
+        assert(n[2] == char(0xBF));
+        assert(n[3] == char(0xE1));
+        assert(n[4] == char(0x80));
+        assert(n[5] == char(0x85));
+        assert(n[6] == char(0));
+
+        w = 0x453;
+        r = c.out(m, &w, &w+1, wp, n, n+7, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+5);
+        assert(n[0] == char(0xEF));
+        assert(n[1] == char(0xBB));
+        assert(n[2] == char(0xBF));
+        assert(n[3] == char(0xD1));
+        assert(n[4] == char(0x93));
+        assert(n[5] == char(0x85));
+        assert(n[6] == char(0));
+
+        w = 0x56;
+        r = c.out(m, &w, &w+1, wp, n, n+7, np);
+        assert(r == std::codecvt_base::ok);
+        assert(wp == &w+1);
+        assert(np == n+4);
+        assert(n[0] == char(0xEF));
+        assert(n[1] == char(0xBB));
+        assert(n[2] == char(0xBF));
+        assert(n[3] == char(0x56));
+        assert(n[4] == char(0x93));
+        assert(n[5] == char(0x85));
+        assert(n[6] == char(0));
+    }
+}

test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.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>
 
 // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
 
 // size_t converted() const;
 
+// UNSUPPORTED: short_wchar
+
 #include <locale>
 #include <codecvt>
 #include <cassert>
 
 int main()
 {
     typedef std::codecvt_utf8<wchar_t> Codecvt;
     typedef std::wstring_convert<Codecvt> Myconv;

test/std/localization/locales/locale.convenience/conversions/conversions.string/converted_short_wchar.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>
+
+// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
+
+// size_t converted() const;
+
+// REQUIRES: short_wchar
+
+#include <locale>
+#include <codecvt>
+#include <cassert>
+
+int main()
+{
+    typedef std::codecvt_utf8<wchar_t> Codecvt;
+    typedef std::wstring_convert<Codecvt> Myconv;
+    Myconv myconv;
+    assert(myconv.converted() == 0);
+    std::string bs = myconv.to_bytes(L"\x4003");
+    assert(myconv.converted() == 1);
+    bs = myconv.to_bytes(L"\x4003\x65");
+    assert(myconv.converted() == 2);
+    std::wstring ws = myconv.from_bytes("\xE4\x80\x83");
+    assert(myconv.converted() == 3);
+}

test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp

 
 // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
 
 // wide_string from_bytes(char byte);
 // wide_string from_bytes(const char* ptr);
 // wide_string from_bytes(const byte_string& str);
 // wide_string from_bytes(const char* first, const char* last);
 
+// UNSUPPORTED: short_wchar
+
 #include <locale>
 #include <codecvt>
 #include <cassert>
 
 int main()
 {
     {
         std::wstring_convert<std::codecvt_utf8<wchar_t> > myconv;

test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes_short_wchar.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>
+
+// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
+
+// wide_string from_bytes(char byte);
+// wide_string from_bytes(const char* ptr);
+// wide_string from_bytes(const byte_string& str);
+// wide_string from_bytes(const char* first, const char* last);
+
+// REQUIRES: short_wchar
+
+#include <locale>
+#include <codecvt>
+#include <cassert>
+
+int main()
+{
+    {
+        std::wstring_convert<std::codecvt_utf8<wchar_t> > myconv;
+        std::string bs("\xE4\x80\x83");
+        std::wstring ws = myconv.from_bytes('a');
+        assert(ws == L"a");
+        ws = myconv.from_bytes(bs.c_str());
+        assert(ws == L"\x4003");
+        ws = myconv.from_bytes(bs);
+        assert(ws == L"\x4003");
+        ws = myconv.from_bytes(bs.data(), bs.data() + bs.size());
+        assert(ws == L"\x4003");
+        ws = myconv.from_bytes("");
+        assert(ws.size() == 0);
+    }
+}

test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.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>
 
 // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
 
 // byte_string to_bytes(Elem wchar);
 // byte_string to_bytes(const Elem* wptr);
 // byte_string to_bytes(const wide_string& wstr);
 // byte_string to_bytes(const Elem* first, const Elem* last);
 
+// UNSUPPORTED: short_wchar
+
 #include <locale>
 #include <codecvt>
 #include <cassert>
 
 int main()
 {
     {
         std::wstring_convert<std::codecvt_utf8<wchar_t> > myconv;

test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes_short_wchar.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>
+
+// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
+
+// byte_string to_bytes(Elem wchar);
+// byte_string to_bytes(const Elem* wptr);
+// byte_string to_bytes(const wide_string& wstr);
+// byte_string to_bytes(const Elem* first, const Elem* last);
+
+// REQUIRES: short_wchar
+
+#include <locale>
+#include <codecvt>
+#include <cassert>
+
+int main()
+{
+    {
+        std::wstring_convert<std::codecvt_utf8<wchar_t> > myconv;
+        std::wstring ws(1, L'\x4003');
+        std::string bs = myconv.to_bytes(ws[0]);
+        assert(bs == "\xE4\x80\x83");
+        bs = myconv.to_bytes(ws.c_str());
+        assert(bs == "\xE4\x80\x83");
+        bs = myconv.to_bytes(ws);
+        assert(bs == "\xE4\x80\x83");
+        bs = myconv.to_bytes(ws.data(), ws.data() + ws.size());
+        assert(bs == "\xE4\x80\x83");
+        bs = myconv.to_bytes(L"");
+        assert(bs.size() == 0);
+    }
+}