/***************************************************************************
 *
 * 22.codecvt.out.cpp - test exercising the std::codecvt::out()
 *
 * $Id$
 *
 ***************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  "License"); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 *
 * Copyright 2005-2006 Rogue Wave Software.
 *
 **************************************************************************/

#ifdef __SUNPRO_CC
    // working around a SunPro/SunOS bug (PR #26255)
#  include <time.h>
#endif   // __SUNPRO_CC

#include <locale>    // for codecvt

#include <climits>   // for MB_LEN_MAX
#include <clocale>   // for LC_CTYPE, setlocale()
#include <cstdio>    // for sprintf()
#include <cstdlib>   // for MB_CUR_MAX, free(), size_t
#include <cstring>   // for strcpy(), strlen()
#include <cwchar>    // for codecvt

#include <driver.h>      // for rw_test(), ...
#include <file.h>        // for rw_fwrite()
#include <rw_locale.h>   // for rw_locales(), rw_set_locale_root()
#include <rw_printf.h>   // for rw_sprintf()
#include <valcmp.h>      // for rw_strcmp()

/****************************************************************************/

// the root of the locale directory (RWSTD_LOCALE_ROOT)
// set in main() instead of here to avoid Solaris 7 putenv() bug (PR #30017)
const char* locale_root /* = set in main() */;


// creates a table-based multibyte locale
static const char*
create_locale ()
{
    char cm_fname [1024];
    std::sprintf (cm_fname, "%s%c%s", locale_root, _RWSTD_PATH_SEP, "charmap");

    static const char charmap[] = {
        "<code_set_name> test_charmap \n"
        "<comment_char>  % \n"
        "<escape_char>   / \n"
        "<mb_cur_min>    1 \n"
        "<mb_cur_max>    9 \n"
        "CHARMAP \n"
        "<U0000>   /x30                                   0 \n"
        "<U0001>   /x31                                   1 \n"
        "<U0002>   /x32/x32                               22 \n"
        "<U0003>   /x33/x33/x33                           333 \n"
        "<U0004>   /x34/x34/x34/x34                       4444 \n"
        "<U0005>   /x35/x35/x35/x35/x35                   55555 \n"
        "<U0006>   /x36/x36/x36/x36/x36/x36               666666 \n"
        "<U0007>   /x37/x37/x37/x37/x37/x37/x37           7777777 \n"
        "<U0008>   /x38/x38/x38/x38/x38/x38/x38/x38       88888888 \n"
        "<U0009>   /x39/x39/x39/x39/x39/x39/x39/x39/x39   999999999 \n"
        "<U0010>   /x41                                   A \n"
        "<U0011>   /x42                                   B \n"
        "<U0012>   /x43                                   C \n"
        "<U0013>   /x44                                   D \n"
        "<U0014>   /x45                                   E \n"
        "<U0015>   /x46                                   F \n"
        "END CHARMAP \n"
    };

    if (std::size_t (-1) == rw_fwrite (cm_fname, charmap))
        return 0;

    char src_fname [1024];
    std::sprintf (src_fname, "%s%c%s", locale_root, _RWSTD_PATH_SEP, "source");

    if (std::size_t (-1) == rw_fwrite (src_fname, "LC_CTYPE\nEND LC_CTYPE\n"))
        return 0;

    // invoke localedef to create the named locale
    // silence the following warnings:
    // 701: no compatible locale found
    // 702: member of portable character set <x> not found
    //      in the character map
    // 706: iconv_open() failed
    const char* const locname =
        rw_localedef ("-w701 -w702 -w706",
                      src_fname, cm_fname, "mb_cur_max-9");

    return locname;
}

/****************************************************************************/

// finds a multibyte character that is `bytes' long if `bytes' is less
// than or equal to MB_CUR_MAX, or the longest multibyte sequence in
// the current locale, and sets `wchar' to the wide character that
// corresponds to it
// returns `mbchar' on success, 0 on failure to find a multibute
// character of the specified length
static const char*
get_mb_char (wchar_t *wchar, char *mbchar, std::size_t bytes)
{
    RW_ASSERT (0 != wchar);
    RW_ASSERT (0 != mbchar);

    *mbchar = '\0';

    if (0 == bytes)
        return mbchar;

    const bool exact = bytes <= MB_CUR_MAX;

    if (!exact)
        bytes = MB_CUR_MAX;

    wchar_t wc;

    // search the first 64K characters sequentially
    for (wc = wchar_t (1); wc != wchar_t (0xffff); ++wc) {

        if (   int (bytes) == std::wctomb (mbchar, wc)
            && int (bytes) == std::mblen (mbchar, bytes)) {
            // NUL-terminate the multibyte character of the requested length
            mbchar [bytes] = '\0';
            *wchar = wc;
            break;
        }

        *mbchar = '\0';
    }

#if 2 < _RWSTD_WCHAR_SIZE

    // if a multibyte character of the requested size is not found
    // in the low 64K range, try to find one using a random search
    if (wchar_t (0xffff) == wc) {

        // iterate only so many times to prevent an infinite loop
        // in case when MB_CUR_MAX is greater than the longest
        // multibyte character
        for (int i = 0; i != 0x100000; ++i) {

            wc = 0;

            typedef unsigned char UChar;

            // set wc to a random value (rand() returns a value
            // less than or equal to RAND_MAX so the loop makes
            // sure all bits are initialized)
            for (int j = 0; j < int (sizeof wc); ++j) {
                wc <<= 8;
                wc  |= wchar_t (UChar (std::rand ()));
            }

            if (   int (bytes) == std::wctomb (mbchar, wc)
                && int (bytes) == std::mblen (mbchar, bytes)) {
                // NUL-terminate the multibyte character
                mbchar [bytes] = '\0';
                *wchar = wc;
                break;
            }

            *mbchar = '\0';
        }
    }

#endif   // 2 < _RWSTD_WCHAR_SIZE

    // return 0 on failure to find a sequence exactly `bytes' long
    return !exact || bytes == std::strlen (mbchar) ? mbchar : 0;
}

/****************************************************************************/

struct WideCode
{
    wchar_t wchar;
    char    mbchar [MB_LEN_MAX];
};

typedef WideCode mb_char_array_t [MB_LEN_MAX];

// fills consecutive elemenets of the `mb_chars' array with wide
// and multibyte characters between 1 and MB_CUR_MAX bytes long
// for the given locale returns the number of elements populated
// (normally, MB_CUR_MAX)
static std::size_t
get_mb_chars (mb_char_array_t mb_chars)
{
    RW_ASSERT (0 != mb_chars);

    const char* mbc =
        get_mb_char (&mb_chars [0].wchar,
                     mb_chars [0].mbchar,
                     std::size_t (-1));

    if (!mbc) {
        std::fprintf (stderr, "*** unable to find any multibyte characters "
                      "in locale \"%s\" with MB_CUR_MAX = %u\n",
                      std::setlocale (LC_CTYPE, 0), MB_CUR_MAX);
        return 0;
    }

    std::size_t mb_cur_max = std::strlen (mbc);

    if (MB_LEN_MAX < mb_cur_max)
        mb_cur_max = MB_LEN_MAX;

    // fill each element of `mb_chars' a multibyte character
    // of the corresponding length
    for (std::size_t i = mb_cur_max; i; --i) {

        const std::size_t inx = i - 1;

        // try to generate a multibyte character `i' bytes long
        mbc = get_mb_char (&mb_chars [inx].wchar, mb_chars [inx].mbchar, i);

        if (0 == mbc) {
            if (i < mb_cur_max) {
                std::fprintf (stderr, "*** unable to find %u-byte characters "
                              "in locale \"%s\" with MB_CUR_MAX = %u\n",
                              i + 1, std::setlocale (LC_CTYPE, 0), MB_CUR_MAX);
                mb_cur_max = 0;
                break;
            }
            --mb_cur_max;
        }
    }

    return mb_cur_max;
}

/****************************************************************************/

// finds the multibyte locale with the largest MB_CUR_MAX value and
// fills consecutive elemenets of the `mb_chars' array with multibyte
// characters between 1 and MB_CUR_MAX bytes long for such a locale
static const char*
find_mb_locale (std::size_t *mb_cur_max, mb_char_array_t mb_chars)
{
    RW_ASSERT (0 != mb_cur_max);
    RW_ASSERT (0 != mb_chars);

    if (2 > MB_LEN_MAX) {
        std::fprintf (stderr, "MB_LEN_MAX = %d, giving up\n", MB_LEN_MAX);
        return 0;
    }

    static const char *mb_locale_name;

    char saved_locale_name [1024];
    std::strcpy (saved_locale_name, std::setlocale (LC_CTYPE, 0));

    *mb_cur_max = 0;

    // iterate over all installed locales
    for (const char *name = rw_locales (); name && *name;
         name += std::strlen (name) + 1) {

        if (std::setlocale (LC_CTYPE, name)) {

            // try to generate a set of multibyte characters
            // with lengths from 1 and MB_CUR_MAX (or less)
            const std::size_t cur_max = get_mb_chars (mb_chars);

            if (*mb_cur_max < cur_max) {
                *mb_cur_max    = cur_max;
                mb_locale_name = name;

                // break when we've found a multibyte locale
                // with the longest possible encoding
                if (MB_LEN_MAX == *mb_cur_max)
                    break;
            }
        }
    }

    if (*mb_cur_max < 2) {
        std::fprintf (stderr, "*** unable to find a full set of multibyte "
                      "characters in locale \"%s\" with MB_CUR_MAX = %u "
                      "(computed)", mb_locale_name, *mb_cur_max);
        mb_locale_name = 0;
    }
    else {
        // (re)generate the multibyte characters for the saved locale
        // as they may have been overwritten in subsequent iterations
        // of the loop above (while searching for a locale with greater
        // value of MB_CUR_MAX)
        std::setlocale (LC_CTYPE, mb_locale_name);
        get_mb_chars (mb_chars);
    }

    std::setlocale (LC_CTYPE, saved_locale_name);

    return mb_locale_name;
}

/****************************************************************************/

inline const char* codecvt_result (std::codecvt_base::result res)
{
    return   std::codecvt_base::error == res ? "error"
           : std::codecvt_base::ok == res ? "ok"
           : std::codecvt_base::partial == res ? "partial"
           : "noconv";
}


template <class internT>
void test_out (int                                                line,
               const char*                                        tname,
               const std::mbstate_t                              *pstate,
               const std::codecvt<internT, char, std::mbstate_t> &cvt,
               const internT                                     *src,
               std::size_t                                        src_len,
               std::size_t                                        src_off,
               const char                                        *res,
               std::size_t                                        res_len,
               std::size_t                                        res_off,
               std::codecvt_base::result                          result)
{
    static const std::mbstate_t initial_state = std::mbstate_t ();

    std::mbstate_t state = pstate ? *pstate : initial_state;

    // create and invalidate a buffer for the destination sequence
    char buf [1024];
    std::memset (buf, -1, sizeof buf);

    // set up from, from_end, and from_next arguments
    const internT* const from      = src;
    const internT* const from_end  = from + src_len;
    const internT*       from_next = 0;

    // set up to, to_end, and to_next arguments
    char* const to      = buf;
    char* const to_end  = to + res_len;
    char*       to_next = 0;

    // call codecvt::out () with the arguments above
    const std::codecvt_base::result cvtres =
        cvt.out (state,
                 from, from_end, from_next,
                 to, to_end, to_next);

    // format a string describing the function call above
    static char fcall [4096];
    std::memset (fcall, 0, sizeof fcall);

    rw_sprintf (fcall,
                "codecvt<%s, char, mbstate_t>::out(state, "
                "from = %{*.*Ac}, from + %td, from + %td, "
                "to = %{#*s}, to + %d, to + %d)",
                tname, int (sizeof *from), int (src_len), from,
                from_end - from, from_next - from,
                int (to_next - to), to, to_end - to, to_next - to);

    RW_ASSERT (std::strlen (fcall) < sizeof fcall);

    // verify the expected result of the conversion
    rw_assert (cvtres == result, __FILE__, line,
               "line %d: %s == %s, got %s",
               __LINE__, fcall,
               codecvt_result (result),
               codecvt_result (cvtres));

    // verify that the from_next pointer is set just past the last
    // successfully converted character in the source sequence
    rw_assert (from_next == from + src_off, __FILE__, line,
               "line %d: %s: from_next == from + %d, got from + %d",
               __LINE__, fcall,
               src_off, from_next - from);

    // verify that the to_next pointer is set just past the last
    // external character in the converted (destination) sequence
    rw_assert (to_next == to + res_off, __FILE__, line,
               "line %d: %s: to_next == to + %d, got to + %d",
               __LINE__, fcall,
               res_off, to_next - to);

    // compare the converted sequence against the expected result
    rw_assert (0 == rw_strncmp (to, res, res_off), __FILE__, line,
               "line %d: %s: expected %{#*s}, got %{#*s}",
               __LINE__, fcall,
               int (res_off), res, int (to_next - to), to);

    // verify that the function didn't write past the end
    // of the destination buffer
    rw_assert (char (-1) == to [res_off], 0, line,
               "line %d: %s: expected %{#lc}, got %{#lc} "
               "at end of destination buffer (offset %zu)",
               __LINE__, fcall,
               -1, to [res_off], res_off);

    // verify that the conversion state is as expected
    rw_assert (!pstate || !std::memcmp (pstate, &state, sizeof state),
               __FILE__, line,
               "line %d: %s: unexpected conversion state",
               __LINE__, fcall);
}

/****************************************************************************/

typedef std::codecvt<char, char, std::mbstate_t>           Codecvt;
typedef std::codecvt_byname<char, char, std::mbstate_t>    CodecvtByname;


static void
test_codecvt (const Codecvt *pcvt = 0)
{
    if (0 == pcvt)
        rw_info (0, 0, __LINE__,
                 "std::codecvt<char, char, mbstate_t>::out("
                 "state_type&, "
                 "const intern_type*, const intern_type*, "
                 "const intern_type*, "
                 "extern_type*, extern_type*, exterm_type*&)");

    const std::locale classic = std::locale::classic ();

    const Codecvt &cvt = pcvt ? *pcvt : std::use_facet<Codecvt>(classic);

#undef TEST
#define TEST(from, from_end_off, from_next_off,      \
             res, res_end_off, res_next_off, result) \
    test_out (__LINE__, "char", 0, cvt,              \
              from, from_end_off, from_next_off,     \
              res, res_end_off, res_next_off,        \
              std::codecvt_base::result)

    //    +---------------------------- source sequence before conversion
    //    |      +--------------------- (from_end - from) before conversion
    //    |      |  +------------------ (from_next - from) after conversion
    //    |      |  |  +--------------- destination sequence after conversion
    //    |      |  |  |      +-------- (to_end - to) before conversion
    //    |      |  |  |      |  +----- (to_next - to) after conversion
    //    |      |  |  |      |  |  +-- conversion result
    //    |      |  |  |      |  |  |
    //    V      V  V  V      V  V  V
    TEST ("",    0, 0, "",    0, 0, noconv);
    TEST ("a",   1, 0, "",    0, 0, noconv);
    TEST ("b",   1, 0, "",    1, 0, noconv);
    TEST ("ab",  2, 0, "",    0, 0, noconv);
    TEST ("bc",  2, 0, "",    1, 0, noconv);
    TEST ("cd",  2, 0, "",    2, 0, noconv);
    TEST ("abc", 3, 0, "",    0, 0, noconv);
    TEST ("\0",  1, 0, "",    0, 0, noconv);
}

/****************************************************************************/

static void
test_codecvt_byname ()
{
    rw_info (0, 0, __LINE__,
             "std::codecvt_byname<char, char, mbstate_t>::out("
             "state_type&, const intern_type*, const intern_type*, "
             "const intern_type*, "
             "extern_type*, extern_type*, exterm_type*&)");

    const CodecvtByname cvt ("");

    test_codecvt (&cvt);
}

/****************************************************************************/

#ifndef _RWSTD_NO_WCHAR_T

typedef std::codecvt<wchar_t, char, std::mbstate_t>        WCodecvt;
typedef std::codecvt_byname<wchar_t, char, std::mbstate_t> WCodecvtByname;


static void
test_wcodecvt ()
{
    rw_info (0, 0, __LINE__,
             "std::codecvt<wchar_t, char, mbstate_t>::out("
             "state_type&, "
             "const intern_type*, const intern_type*, "
             "const intern_type*, "
             "extern_type*, extern_type*, exterm_type*&)");

    const std::locale classic = std::locale::classic ();

    const WCodecvt &cvt = std::use_facet<WCodecvt>(classic);

#undef TEST
#define TEST(from, from_end_off, from_next_off,      \
             res, res_end_off, res_next_off, result) \
    test_out (__LINE__, "wchar_t", 0, cvt,           \
              from, from_end_off, from_next_off,     \
              res, res_end_off, res_next_off,        \
              std::codecvt_base::result)

    //    +------------------------------- source sequence before conversion
    //    |        +---------------------- (from_end - from) before conversion
    //    |        |  +------------------- (from_next - from) after conversion
    //    |        |  |  +---------------- destination sequence
    //    |        |  |  |       +-------- (to_end - to) before conversion
    //    |        |  |  |       |  +----- (to_next - to) after conversion
    //    |        |  |  |       |  |  +-- conversion result
    //    |        |  |  |       |  |  |
    //    V        V  V  V       V  V  V
    TEST (L"",     0, 0, "",     0, 0, ok);
    TEST (L"a",    1, 1, "a",    1, 1, ok);
    TEST (L"ab",   2, 2, "ab",   2, 2, ok);
    TEST (L"abc",  3, 3, "abc",  3, 3, ok);
    TEST (L"\0",   1, 1, "\0",   1, 1, ok);
    TEST (L"\x80", 1, 1, "\x80", 1, 1, ok);
    TEST (L"\xff", 1, 1, "\xff", 1, 1, ok);
    TEST (L"a\0",  2, 2, "a\0",  2, 2, ok);
    TEST (L"a\0b", 3, 3, "a\0b", 3, 3, ok);
    TEST (L"\0\0", 2, 2, "\0\0", 2, 2, ok);

    TEST (L"123",  3, 0, "",     0, 0, partial);
    TEST (L"234",  3, 1, "2",    1, 1, partial);
    TEST (L"345",  3, 2, "34",   2, 2, partial);
    TEST (L"456",  3, 3, "456",  3, 3, ok);
    TEST (L"567",  3, 3, "567",  4, 3, ok);
    TEST (L"6789", 3, 3, "678",  4, 3, ok);
}

/****************************************************************************/

// exercises an algorithmic multibyte encoding
static void
test_wcodecvt_byname_algorithmic ()
{
    rw_info (0, 0, __LINE__, "locale (\"UTF-8@UCS\") [algorithmic encoding]");

    // lowercase utf ==> relaxed checking (i.e., some, but not all,
    // invalid UTF-8 sequence are accepted)
    const WCodecvtByname cvt_relaxd ("utf-8@UCS");

    // capital UTF ==> strict checking
    const WCodecvtByname cvt_strict ("UTF-8@UCS");

#undef STRICT
#define STRICT(from, from_end_off, from_next_off,    \
             res, res_end_off, res_next_off, result) \
    test_out (__LINE__, "wchar_t", 0, cvt_strict,    \
              from, from_end_off, from_next_off,     \
              res, res_end_off, res_next_off,        \
              std::codecvt_base::result)

#undef RELAXD
#define RELAXD(from, from_end_off, from_next_off,    \
             res, res_end_off, res_next_off, result) \
    test_out (__LINE__, "wchar_t", 0, cvt_relaxd,    \
              from, from_end_off, from_next_off,     \
              res, res_end_off, res_next_off,        \
              std::codecvt_base::result)

#undef TEST
#define TEST(from, from_end_off, from_next_off,      \
             res, res_end_off, res_next_off, result) \
    STRICT (from, from_end_off, from_next_off,       \
            res, res_end_off, res_next_off, result); \
    RELAXD (from, from_end_off, from_next_off,       \
            res, res_end_off, res_next_off, result)

    //    +------------------------------- source sequence before conversion
    //    |        +---------------------- (from_end - from) before conversion
    //    |        |  +------------------- (from_next - from) after conversion
    //    |        |  |  +---------------- destination sequence
    //    |        |  |  |       +-------- (to_end - to) before conversion
    //    |        |  |  |       |  +----- (to_next - to) after conversion
    //    |        |  |  |       |  |  +-- conversion result
    //    |        |  |  |       |  |  |
    //    V        V  V  V       V  V  V
    TEST (L"",     0, 0, "",     0, 0, ok);
    TEST (L"a",    1, 1, "a",    1, 1, ok);
    TEST (L"ab",   2, 2, "ab",   2, 2, ok);
    TEST (L"abc",  3, 3, "abc",  3, 3, ok);
    TEST (L"\0",   1, 1, "\0",   1, 1, ok);
    TEST (L"a\0",  2, 2, "a\0",  2, 2, ok);
    TEST (L"a\0b", 3, 3, "a\0b", 3, 3, ok);

    TEST (L"123",  3, 0, "",     0, 0, partial);
    TEST (L"234",  3, 1, "2",    1, 1, partial);
    TEST (L"345",  3, 2, "34",   2, 2, partial);
    TEST (L"456",  3, 3, "456",  3, 3, ok);
    TEST (L"567",  3, 3, "567",  4, 3, ok);

    // exercise multibyte sequences
    TEST (L"\x100",     1, 0, "\xc4\x80",  0, 0, partial);
    TEST (L"\x101",     1, 0, "\xc4\x81",  1, 0, partial);
    TEST (L"\x102",     1, 1, "\xc4\x82",  2, 2, ok);

    TEST (L"\x103x",    2, 0, "\xc4\x83",  0, 0, partial);
    TEST (L"\x104y",    2, 1, "\xc4\x84",  2, 2, partial);
    TEST (L"\x105z",    2, 2, "\xc4\x85z", 3, 3, ok);
    TEST (L"\x106zz",   2, 2, "\xc4\x86z", 4, 3, ok);

    TEST (L"\x0901",    1, 0, "\xe0\xa4\x81", 0, 0, partial);
    TEST (L"\x0902",    1, 0, "\xe0\xa4\x82", 1, 0, partial);
    TEST (L"\x0903",    1, 0, "\xe0\xa4\x83", 2, 0, partial);
    TEST (L"\x0904",    1, 1, "\xe0\xa4\x84", 3, 3, ok);

    TEST (L"\x0905\x0916", 2, 1, "\xe0\xa4\x85\xe0\xa4\x96", 4, 3, partial);
    TEST (L"\x0906\x0917", 2, 1, "\xe0\xa4\x86\xe0\xa4\x97", 5, 3, partial);
    TEST (L"\x0907\x0918", 2, 2, "\xe0\xa4\x87\xe0\xa4\x98", 6, 6, ok);

    // U+D800 to U+DFFF (UTF-16 surrogates) as well as U+FFFE and U+FFFF
    // must not occur in normal UCS-4 data and should be treated like
    // malformed or overlong sequences.

    STRICT (L"\xd800",       1, 0, "",    6, 0, error);
    STRICT (L"\xd801",       1, 0, "",    6, 0, error);
    STRICT (L"A\xd802",      2, 1, "A",   6, 1, error);
    STRICT (L"AB\xd803",     3, 2, "AB",  6, 2, error);
    STRICT (L"ABC\xd804",    4, 3, "ABC", 6, 3, error);
    STRICT (L"\xdffe",       1, 0, "",    6, 0, error);
    STRICT (L"\xdfff",       1, 0, "",    6, 0, error);

    TEST   (L"\xe000",       1, 1, "\xee\x80\x80", 6, 3, ok);
    TEST   (L"\xd7ff",       1, 1, "\xed\x9f\xbf", 6, 3, ok);

    STRICT (L"\xd800",       1, 0, "", 6, 0, error);
    STRICT (L"\xd801",       1, 0, "", 6, 0, error);
    STRICT (L"\xdffe",       1, 0, "", 6, 0, error);
    STRICT (L"\xdfff",       1, 0, "", 6, 0, error);

    TEST   (L"\xe000",       1, 1, "\xee\x80\x80", 6, 3, ok);

    // verify that surrogate pairs are accepted in relaxed mode
    RELAXD (L"\xd800",       1, 1, "\xed\xa0\x80", 6, 3, ok);
    RELAXD (L"\xd801",       1, 1, "\xed\xa0\x81", 6, 3, ok);
    RELAXD (L"\xdffe",       1, 1, "\xed\xbf\xbe", 6, 3, ok);
    RELAXD (L"\xdfff",       1, 1, "\xed\xbf\xbf", 6, 3, ok);
}

/****************************************************************************/

// exercises a table-based multibyte encoding
static void
test_wcodecvt_byname_table_based ()
{
    // create a locale from a generated character set description file
    // where L'\1' maps to "1", L'\2' to "22", ..., and L'\x10' to "A",
    // L'\x11' to "B", L'\x12' to "C", etc.
    const char* const locname = create_locale ();

    if (!locname) {
        rw_error (0, 0, __LINE__, "failed to create a locale database");
        return;
    }

    std::locale loc;

    _TRY {
        loc = std::locale (locname);
    }
    _CATCH (...) {
        rw_error (0, 0, __LINE__, "locale(\"%s\") unexpectedly threw", locname);
        return;
    }

    const WCodecvt &cvt_table = std::use_facet<WCodecvt>(loc);

    rw_info (0, 0, __LINE__, "locale (\"%s\") [table-based encoding]", locname);

#undef TEST
#define TEST(from, from_end_off, from_next_off,      \
             res, res_end_off, res_next_off, result) \
    test_out (__LINE__, "wchar_t", 0, cvt_table,     \
              from, from_end_off, from_next_off,     \
              res, res_end_off, res_next_off,        \
              std::codecvt_base::result)

    TEST (L"",              0, 0, "",     0, 0, ok);
    TEST (L"\x10",          1, 1, "A",    1, 1, ok);
    TEST (L"\x11\x12",      2, 2, "BC",   2, 2, ok);
    TEST (L"\x12\x13\x14",  3, 3, "CDE",  3, 3, ok);

    TEST (L"\1\2\3\4\5\6",  1, 1, "1",               21,  1, ok);
    TEST (L"\1\2\3\4\5\6",  2, 1, "1",                1,  1, partial);
    TEST (L"\1\2\3\4\5\6",  2, 1, "1",                2,  1, partial);
    TEST (L"\1\2\3\4\5\6",  2, 2, "122",              3,  3, ok);
    TEST (L"\1\2\3\4\5\6",  2, 2, "122",             21,  3, ok);
    TEST (L"\1\2\3\4\5\6",  3, 2, "122",              3,  3, partial);
    TEST (L"\1\2\3\4\5\6",  3, 2, "122",              4,  3, partial);
    TEST (L"\1\2\3\4\5\6",  3, 2, "122",              5,  3, partial);
    TEST (L"\1\2\3\4\5\6",  3, 3, "122333",           6,  6, ok);
    TEST (L"\1\2\3\4\5\6",  4, 3, "122333",           7,  6, partial);
    TEST (L"\1\2\3\4\5\6",  3, 3, "122333",          21,  6, ok);
    TEST (L"\1\2\3\4\5\6",  4, 4, "1223334444",      21, 10, ok);
    TEST (L"\1\2\3\4\5\6",  5, 5, "122333444455555", 21, 15, ok);
    TEST (L"\6\5\4\3\2\1",  6, 3, "666666555554444", 15, 15, partial);
    TEST (L"\6\5\4\3\2\1",  6, 3, "666666555554444", 16, 15, partial);

    // exercise the ability to detect invalid characters (e.g., '*')
    TEST (L"*\3\4\5\6\7",   6, 0, "",                27,  0, error);
    TEST (L"\2*\4\5\6\7",   6, 0, "",                 1,  0, partial);
    TEST (L"\2*\4\5\6\7",   6, 1, "22",               2,  2, partial);
    TEST (L"\2*\4\5\6\7",   6, 1, "22",              27,  2, error);
    TEST (L"\2*\4\5\6\7",   6, 1, "22",              27,  2, error);
    TEST (L"\2\3*\5\6\7",   6, 2, "22333",           27,  5, error);
    TEST (L"\2\3\4*\6\7",   6, 3, "223334444",       27,  9, error);
}

/****************************************************************************/

static void
make_strings (const char *pat, std::size_t patsize,
              wchar_t *wstr, char *mbstr,
              const mb_char_array_t mb_chars)
{
    RW_ASSERT (0 != pat);
    RW_ASSERT (0 != wstr);
    RW_ASSERT (0 != mbstr);
    RW_ASSERT (0 != mb_chars);

    typedef unsigned char UChar;

    *mbstr = '\0';

    for (const char *s = pat; s != pat + patsize; ++s, ++wstr) {

        if ('%' == *s) {

            ++s;

            RW_ASSERT ('0' <= *s && *s <= char ('0' + MB_LEN_MAX));

            std::size_t char_inx = *s - '0';

            *wstr = mb_chars [char_inx].wchar;

            std::strcpy (mbstr, mb_chars [char_inx].mbchar);
            mbstr += std::strlen (mbstr);
        }
        else {
            *wstr    = UChar (*s);
            *mbstr++ = *s;
            *mbstr   = '\0';
        }
    }

    *wstr = L'\0';
}

/****************************************************************************/

// exercises a libc-based multibyte encoding
static void
test_wcodecvt_byname_libc_based ()
{
    // find `mb_cur_max' multibyte characters in increasing length
    // from 1 to mb_cur_max bytes long

    // i.e., initialize the first (N + 1) elements of mb_chars as follows:
    // [0].mbstr = "0";         // where "0" is a single byte character
    // [1].mbstr = "11";        // where "11" is a two-byte character
    // [2].mbstr = "222";       // where "222" is a three-byte character
    // ...
    // [N].mbstr = "NNN...N";   // where "NNN...N" is an N-byte character

    std::size_t mb_cur_max = 0;

    mb_char_array_t mb_chars;

    const char* const locname = find_mb_locale (&mb_cur_max, mb_chars);

    if (0 == locname) {
        rw_warn (0, 0, __LINE__, "unable to find a multibyte locale");
        return;
    }

    std::locale loc;

    _TRY {
        loc = std::locale (locname);
    }
    _CATCH (...) {
        rw_error (0, 0, __LINE__, "locale(\"%s\") unexpectedly threw", locname);
        return;
    }

    const WCodecvt &cvt_libc = std::use_facet<WCodecvt>(loc);

    rw_info (0, 0, __LINE__, "locale (\"%s\") [libc-based encoding, "
             "single-byte characters]", locname);

    //////////////////////////////////////////////////////////////////
    // exercise sequences containing single-byte characters

#undef TEST
#define TEST(from, from_end_off, from_next_off,      \
             res, res_end_off, res_next_off, result) \
    test_out (__LINE__, "wchar_t", 0, cvt_libc,      \
              from, from_end_off, from_next_off,     \
              res, res_end_off, res_next_off,        \
              std::codecvt_base::result)

    //    +----------------------------------- source sequence (from)
    //    |          +------------------------ from_end offset from from
    //    |          |  +--------------------- expected from_next offset
    //    |          |  |  +------------------ expected destination sequence
    //    |          |  |  |         +-------- to_end offset from to
    //    |          |  |  |         |  +----- expected to_next offset
    //    |          |  |  |         |  |  +-- expected result (to)
    //    |          |  |  |         |  |  |
    //    V          V  V  V         V  V  V
    TEST (L"",       0, 0, "",       0, 0, ok);
    TEST (L"a",      1, 1, "a",      1, 1, ok);
    TEST (L"b",      1, 1, "b",      2, 1, ok);
    TEST (L"c",      1, 1, "c",      3, 1, ok);
    TEST (L"d",      1, 1, "d",      4, 1, ok);
    TEST (L"e",      1, 1, "e",      5, 1, ok);
    TEST (L"f",      1, 1, "f",      6, 1, ok);
    TEST (L"ab",     2, 2, "ab",     6, 2, ok);
    TEST (L"abc",    3, 3, "abc",    6, 3, ok);
    TEST (L"abcd",   4, 4, "abcd",   6, 4, ok);
    TEST (L"abcde",  5, 5, "abcde",  6, 5, ok);
    TEST (L"abcdef", 6, 6, "abcdef", 6, 6, ok);

    TEST (L"\n",     1, 1, "\n",     1, 1, ok);
    TEST (L"\n\377", 1, 1, "\n",     1, 1, ok);

    // exercise embedded NULs
    TEST (L"\0abcdef", 7, 7, "\0abcdef", 7, 7, ok);
    TEST (L"a\0bcdef", 7, 7, "a\0bcdef", 7, 7, ok);
    TEST (L"ab\0cdef", 7, 7, "ab\0cdef", 7, 7, ok);
    TEST (L"abc\0def", 7, 7, "abc\0def", 7, 7, ok);
    TEST (L"abcd\0ef", 7, 7, "abcd\0ef", 7, 7, ok);
    TEST (L"abcde\0f", 7, 7, "abcde\0f", 7, 7, ok);
    TEST (L"abcdef\0", 7, 7, "abcdef\0", 7, 7, ok);

    TEST (L"ab\0cd\0ef", 8, 8, "ab\0cd\0ef", 8, 8, ok);

    //////////////////////////////////////////////////////////////////
    // exercise sequences containing 2-byte characters

    if (mb_cur_max < 2) {
        rw_warn (0, 0, __LINE__, "no multibyte characters found");
        return;
    }

    size_t bufsize = 0;
    char *sequences = 0;

    // verify the length of each character
    for (std::size_t i = 0; i < mb_cur_max; ++i) {
        const std::size_t mb_len = std::strlen (mb_chars [i].mbchar);

        if (i + 1 != mb_len) {
            rw_assert (0, 0, __LINE__,
                       "unexpected multibyte character length: "
                       "%u, expected %u", mb_len, i + 1);
            return;
        }

        rw_asnprintf (&sequences, &bufsize,
                      "%{+}%s{ %{#lc}, %{#s} }",
                      i ? ", " : "",
                      mb_chars [i].wchar,
                      mb_chars [i].mbchar);
    }

    rw_info (0, 0, __LINE__,
             "locale (\"%s\") [libc-based encoding, "
             "MB_CUR_MAX = %u, multi-byte characters: %s]",
             locname, mb_cur_max, (const char*)sequences);

    std::free (sequences);

#ifdef _RWSTD_OS_SUNOS

    if (0 == std::strcmp ("5.7", _RWSTD_OS_RELEASE)) {

        rw_warn (0, 0, __LINE__, "skipping tests due to a SunOS 5.7 libc bug");
        return;
    }

#endif   // _RWSTD_OS_SUNOS

    wchar_t wstr [256];
    char    mbstr [256];

#undef TEST
#define TEST(pat, from_end_off, from_next_off,       \
             res_end_off, res_next_off, result)      \
    make_strings (pat, sizeof pat - 1,               \
                  wstr, mbstr, mb_chars);            \
    test_out (__LINE__, "wchar_t", 0, cvt_libc,      \
              wstr, from_end_off, from_next_off,     \
              mbstr, res_end_off, res_next_off,      \
              std::codecvt_base::result)

    // %N for N in [0, MB_CUR_MAX) represents a wide character
    // whose multibyte representation is (N + 1) bytes long
    // any other (narrow) character, including the NUL, is
    // widened to a wchar_t as if by an ordinary cast

    //    +------------------------------ source sequence (from)
    //    |               +-------------- initial (from_end - from)
    //    |               |  +----------- expected (from_next - from)
    //    |               |  |  +-------- initial (to_limit - to)
    //    |               |  |  |  +----- expected (to_next - to)
    //    |               |  |  |  |  +-- expected conversion result
    //    |               |  |  |  |  |
    //    V               V  V  V  V  V
    TEST ("%0",           0, 0, 0, 0, ok);
    TEST ("%0",           1, 0, 0, 0, partial);
    TEST ("%0",           1, 1, 1, 1, ok);
    TEST ("%1",           1, 0, 0, 0, partial);
    TEST ("%1",           1, 0, 1, 0, partial);
    TEST ("%1",           1, 1, 2, 2, ok);

    TEST ("a%1",          2, 1, 2, 1, partial);
    TEST ("b%1",          2, 2, 3, 3, ok);

    TEST ("%1%1",         2, 0, 1, 0, partial);
    TEST ("%1%1",         2, 1, 2, 2, partial);
    TEST ("%1%1",         2, 1, 3, 2, partial);
    TEST ("%1%1",         2, 2, 4, 4, ok);

    TEST ("%1X%1Y%1Z",    6, 0, 1, 0, partial);
    TEST ("%1X%1Y%1Z",    6, 1, 2, 2, partial);
    TEST ("%1X%1Y%1Z",    6, 2, 3, 3, partial);
    TEST ("%1X%1Y%1Z",    6, 2, 4, 3, partial);
    TEST ("%1X%1Y%1Z",    6, 3, 5, 5, partial);
    TEST ("%1X%1Y%1Z",    6, 4, 6, 6, partial);
    TEST ("%1X%1Y%1Z",    6, 4, 7, 6, partial);
    TEST ("%1X%1Y%1Z",    6, 5, 8, 8, partial);
    TEST ("%1X%1Y%1Z",    6, 6, 9, 9, ok);

    // exercise embedded NULs
    TEST ("\0",           1, 1, 1, 1, ok);
    TEST ("\0X",          2, 2, 2, 2, ok);
    TEST ("\0X\0",        3, 3, 3, 3, ok);
    TEST ("\0X\0Y",       4, 4, 4, 4, ok);
    TEST ("\0X\0Y\0",     5, 5, 5, 5, ok);
    TEST ("\0X\0Y\0Z",    6, 6, 6, 6, ok);
    TEST ("\0XYZ\0",      5, 5, 5, 5, ok);

    TEST ("%1\0",         2, 2, 3, 3, ok);
    TEST ("\0%1",         2, 2, 3, 3, ok);

    TEST ("%1\0%1",       3, 3, 5, 5, ok);
    TEST ("\0%1\0",       3, 3, 4, 4, ok);

    TEST ("%1\0%1\0%1\0", 6, 2, 3, 3, partial);
    TEST ("%1\0%1\0%1\0", 6, 3, 5, 5, partial);
    TEST ("%1\0%1\0%1\0", 6, 4, 6, 6, partial);
    TEST ("%1\0%1\0%1\0", 6, 5, 8, 8, partial);
    TEST ("%1\0%1\0%1\0", 6, 6, 9, 9, ok);

    // exercise consecutive embedded NULs
    TEST ("\0\0%1\0\0%1\0\0", 8, 8, 10, 10, ok);
    TEST ("\0\0\0\0\0\0\0XY", 9, 9,  9,  9, ok);

    //////////////////////////////////////////////////////////////////
    // exercise sequences containing 3-byte characters

    if (mb_cur_max < 3)
        return;

    TEST ("%2",   1, 0, 0, 0, partial);
    TEST ("%2",   1, 0, 1, 0, partial);
    TEST ("%2",   1, 0, 2, 0, partial);
    TEST ("%2",   1, 1, 3, 3, ok);

    TEST ("%2%1", 2, 0, 0, 0, partial);
    TEST ("%2%1", 2, 0, 1, 0, partial);
    TEST ("%2%1", 2, 0, 2, 0, partial);
    TEST ("%2%1", 2, 1, 3, 3, partial);
    TEST ("%2%1", 2, 1, 4, 3, partial);
    TEST ("%2%1", 2, 2, 5, 5, ok);

    TEST ("%2%2", 2, 0, 0, 0, partial);
    TEST ("%2%2", 2, 0, 1, 0, partial);
    TEST ("%2%2", 2, 0, 2, 0, partial);
    TEST ("%2%2", 2, 1, 3, 3, partial);
    TEST ("%2%2", 2, 1, 4, 3, partial);
    TEST ("%2%2", 2, 1, 5, 3, partial);
    TEST ("%2%2", 2, 2, 6, 6, ok);

    TEST ("%2%1%2", 3, 0, 0, 0, partial);
    TEST ("%2%1%2", 3, 0, 1, 0, partial);
    TEST ("%2%1%2", 3, 0, 2, 0, partial);
    TEST ("%2%1%2", 3, 1, 3, 3, partial);
    TEST ("%2%1%2", 3, 1, 4, 3, partial);
    TEST ("%2%1%2", 3, 2, 5, 5, partial);
    TEST ("%2%1%2", 3, 2, 6, 5, partial);
    TEST ("%2%1%2", 3, 2, 7, 5, partial);
    TEST ("%2%1%2", 3, 3, 8, 8, ok);

    TEST ("%2%1%2%0%1%2$", 6, 6, 14, 14, ok);

    // exercise embedded NULs
    TEST ("\0%2$",       2, 2, 4, 4, ok);
    TEST ("%2\0$",       2, 2, 4, 4, ok);
    TEST ("\0\0%2$",     3, 3, 5, 5, ok);
    TEST ("%2\0\0$",     3, 3, 5, 5, ok);
    TEST ("\0\0%2\0%2$", 5, 5, 9, 9, ok);
    TEST ("\0%2\0\0%2$", 5, 5, 9, 9, ok);
    TEST ("\0%2\0%2\0$", 5, 5, 9, 9, ok);
    TEST ("%2\0\0%2\0$", 5, 5, 9, 9, ok);
    TEST ("%2\0%2\0\0$", 5, 5, 9, 9, ok);

    //////////////////////////////////////////////////////////////////
    // exercise sequences containing 4-byte characters

    if (mb_cur_max < 4)
        return;

    TEST ("%3",     1, 0,  0,  0, partial);
    TEST ("%3",     1, 0,  1,  0, partial);
    TEST ("%3",     1, 0,  2,  0, partial);
    TEST ("%3",     1, 0,  3,  0, partial);
    TEST ("%3",     1, 1,  4,  4, ok);

    TEST ("%3%3",   2, 0,  3,  0, partial);
    TEST ("%3%3",   2, 1,  4,  4, partial);
    TEST ("%3%3",   2, 1,  5,  4, partial);
    TEST ("%3%3",   2, 1,  6,  4, partial);
    TEST ("%3%3",   2, 1,  7,  4, partial);
    TEST ("%3%3",   2, 2,  8,  8, ok);

    TEST ("%3G%3",  3, 2,  8,  5, partial);
    TEST ("%3G%3",  3, 3,  9,  9, ok);

    TEST ("%3%1%3", 3, 2,  9,  6, partial);
    TEST ("%3%1%3", 3, 3, 10, 10, ok);

    TEST ("%3%2%1%0%1%2%3", 7, 7, 19, 19, ok);

    //      4+1+3+1+2+1+1+1+2+1+3+1+4 = 25 bytes (13 wchar_t)
    TEST ("%3\0%2\0%1\0%0\0%1\0%2\0%3$", 13, 13, 25, 25, ok);
    //      4+1+1+3+2+1+1+1+2+1+3+4+1 = 25 bytes (13 wchar_t)
    TEST ("%3\0\0%2%1\0%0\0%1\0%2%3\0$", 13, 13, 25, 25, ok);
    //      1+4+3+1+2+1+1+1+2+1+3+4+1 = 25 bytes (13 wchar_t)
    TEST ("\0%3%2\0%1\0\0%0%1\0%2%3\0$", 13, 13, 25, 25, ok);
    //      1+4+3+1+2+1+2+1+3+4+1+1+1 = 25 bytes (13 wchar_t)
    TEST ("\0%3%2\0%1%0%1\0%2%3\0\0\0$", 13, 13, 25, 25, ok);
    //      1+1+1+1+1+1+4+3+2+1+2+3+4  = 25 bytes (13 wchar_t)
    TEST ("\0\0\0\0\0\0%3%2%1%0%1%2%3$", 13, 13, 25, 25, ok);
}

/****************************************************************************/

static void
test_wcodecvt_byname ()
{
    rw_info (0, 0, __LINE__,
             "std::codecvt_byname<wchar_t, char, mbstate_t>::out("
             "state_type&, "
             "const intern_type*, const intern_type*, "
             "const intern_type*, "
             "extern_type*, extern_type*, exterm_type*&)");

    test_wcodecvt_byname_algorithmic ();
    test_wcodecvt_byname_table_based ();
    test_wcodecvt_byname_libc_based ();
}

#endif   // _RWSTD_NO_WCHAR_T

/****************************************************************************/

static int
run_test (int, char**)
{
    // set up RWSTD_LOCALE_ROOT and other environment variables
    // here as opposed to at program startup to work around a
    // SunOS 5.7 bug in putenv() (PR #30017)
    locale_root = rw_set_locale_root ();

    test_codecvt ();
    test_codecvt_byname ();

#ifndef _RWSTD_NO_WCHAR_T

    // exercise wchar_t specializations
    test_wcodecvt ();
    test_wcodecvt_byname ();

#else   // if defined (_RWSTD_NO_WCHAR_T)

    rw_warn (0, 0, __LINE__, "_RWSTD_NO_WCHAR_T #defined, cannot test");

#endif   // _RWSTD_NO_WCHAR_T

    return 0;
}

/****************************************************************************/

int main (int argc, char *argv[])
{
    return rw_test (argc, argv, __FILE__,
                    "lib.locale.codecvt.virtuals",
                    0 /* no comment */,
                    run_test,
                    "",
                    (void*)0   /* sentinel */);
}