22.locale.synopsis.cpp

Go to the documentation of this file.

 
#include <rw/_defs.h>
 
// disable implicit inclusion to work around a limitation in
// IBM VAC++ 5.0.2.0 (PR #26959)
#if defined __IBMCPP__ && !defined _RWSTD_NO_IMPLICIT_INCLUSION
#  define _RWSTD_NO_IMPLICIT_INCLUSION
#endif
 
// make protected members accessible if possible
#if defined _RWSTD_NO_EXPORT && !defined _MSC_VER
#  define protected public
#endif
 
#include <iterator>
#include <locale>
 
#include <rw_driver.h>
 
static void
test_lc_defs ()
{
    rw_info (0, __FILE__, __LINE__, "checking LC_XXX constants");
 
    // check that <locale> doesn't introduce any LC_XXX constants
    // (not required, but it's good practice to keep headers clean)
    static const char* const lc_defs[] =
    {
#ifdef LC_ALL
        "LC_ALL",
#endif   // LC_ALL
#ifdef LC_COLLATE
        "LC_COLLATE",
#endif   // LC_COLLATE
#ifdef LC_CTYPE
        "LC_CTYPE",
#endif   // LC_CTYPE
#ifdef LC_MONETARY
        "LC_MONETARY",
#endif   // LC_MONETARY
#ifdef LC_NUMERIC
        "LC_NUMERIC",
#endif   // LC_NUMERIC
#ifdef LC_TIME
        "LC_TIME",
#endif   // LC_TIME
#ifdef LC_MESSAGES
        "LC_MESSAGES",
#endif   // LC_MESSAGES
 
        0
    };
 
    for (unsigned i = 0; i != sizeof lc_defs / sizeof *lc_defs; ++i) {
        rw_assert (!lc_defs [i], __FILE__, __LINE__,
                   "<locale> unexpectedly #defines %s", lc_defs [i]);
    }
}
 
static void
test_isxxx ()
{
    rw_info (0, __FILE__, __LINE__, "checking isxxx() macros");
 
    // check that <locale> doesn't introduce any isxxx() macros
    static const char* const isxxx[] =
    {
#ifdef isspace
        "isspace",
#endif   // isspace
#ifdef isprint
        "isprint",
#endif   // isprint
#ifdef iscntrl
        "iscntrl",
#endif   // iscntrl
#ifdef isupper
        "isupper",
#endif   // isupper
#ifdef islower
        "islower",
#endif   // islower
#ifdef isalpha
        "isalpha",
#endif   // isalpha
#ifdef isdigit
        "isdigit",
#endif   // isdigit
#ifdef ispunct
        "ispunct",
#endif   // ispunct
#ifdef isxdigit
        "isxdigit",
#endif   // isxdigit
#ifdef isalnum
        "isalnum",
#endif   // isalnum
#ifdef isgraph
        "isgraph",
#endif   // isgraph
#ifdef toupper
        "toupper",
#endif   // toupper
#ifdef tolower
        "tolower",
#endif   // tolower
 
        0
    };
 
    for (unsigned i = 0; i != sizeof isxxx / sizeof *isxxx; ++i) {
        rw_assert (!isxxx [i], __FILE__, __LINE__,
                   "<locale> unexpectedly #defines %s", isxxx [i]);
    }
}
 
 
#include <clocale>   // for LC_XXX macros
#include <cwchar>    // for mbstate_t
 
#if !defined LC_MESSAGES && defined _RWSTD_LC_MESSAGES
#  define LC_MESSAGES _RWSTD_LC_MESSAGES
#endif   // !LC_MESSAGES && _RWSTD_LC_MESSAGES
 
// exercise the signature of a nonmember (or static member) function
#define FUN(result, name, arg_list) do {                              \
        /* make name unique to prevent bogus gcc -Wshadow warnings */ \
        result (*_RWSTD_PASTE (pf, __LINE__)) arg_list = &name;       \
        _RWSTD_UNUSED (_RWSTD_PASTE (pf, __LINE__));                  \
    } while (0)
 
 
// exercise the signatures of std::{has,use}_facet<>()
template <class charT>
static void
test_have_use_facet ()
{
    rw_info (0, __FILE__, __LINE__,
             "std::has_facet<Facet>(std::locale&) synopsis");
    rw_info (0, __FILE__, __LINE__,
             "std::use_facet<Facet>(std::locale&) synopsis");
 
#if !defined __HP_aCC || __HP_aCC > 33100
 
// working around an HP aCC bug (see PR #23312)
 
#  if    !(defined __GNUG__ || __GNUG__ > 2 || __GNUC_MINOR__ > 96) \
      && !(defined _MSC_VER || _MSC_VER >= 0x1300)
 
    // working around a gcc 2.9{5,6} ICE
    // working around an MSVC 6.0 bug (PR #26307)
    FUN (const std::ctype<charT>&,
         std::use_facet<std::ctype<charT> >, (const std::locale&));
    FUN (bool, std::has_facet<std::ctype<charT> >, (const std::locale&));
 
#  endif   // gcc > 2.96 && MSVC > 6.0
 
#endif   // __HP_aCC > 33000
}
 
 
// exercise the signatures of the convenience locale interfaces
template <class charT>
static void
test_convenience_funs ()
{
    rw_info (0, __FILE__, __LINE__,
             "std::isxxx(std::locale&) convenience functions synopsis");
 
    FUN (bool, std::isspace, (charT, const std::locale&));
    FUN (bool, std::isprint, (charT, const std::locale&));
    FUN (bool, std::iscntrl, (charT, const std::locale&));
    FUN (bool, std::isupper, (charT, const std::locale&));
    FUN (bool, std::islower, (charT, const std::locale&));
    FUN (bool, std::isalpha, (charT, const std::locale&));
    FUN (bool, std::isdigit, (charT, const std::locale&));
    FUN (bool, std::ispunct, (charT, const std::locale&));
    FUN (bool, std::isxdigit, (charT, const std::locale&));
    FUN (bool, std::isalnum, (charT, const std::locale&));
    FUN (bool, std::isgraph, (charT, const std::locale&));
    FUN (charT, std::toupper, (charT, const std::locale&));
    FUN (charT, std::tolower, (charT, const std::locale&));
}
 
_RWSTD_NAMESPACE (std) {
 
#if !defined _MSC_VER
 
// verify that specializations are present in the lib
_RWSTD_SPECIALIZED_CLASS class ctype<char>;
_RWSTD_SPECIALIZED_CLASS class ctype_byname<char>;
 
#  ifndef _RWSTD_NO_WCHAR_T
 
_RWSTD_SPECIALIZED_CLASS class ctype<wchar_t>;
_RWSTD_SPECIALIZED_CLASS class ctype_byname<wchar_t>;
 
#  endif   // _RWSTD_NO_WCHAR_T
 
#endif   // _MSC_VER
 
}   // namespace std
 
 
// test for the presence of the required facet templates
// and their specializations (as required by Table 52)
template <class charT>
static void
test_facets ()
{
    // introduce a typedef to work around a SunPro 5.3 bug (see PR #25967)
    typedef charT char_type;
 
    const std::locale::facet *pfac;
    _RWSTD_UNUSED (pfac);
 
    {
        // collate category
        const std::collate<char_type>        *col        = 0;
        const std::collate_byname<char_type> *col_byname = 0;
 
        // verify that facet publicly derives from locale::facet
        pfac = col;
        col  = col_byname;
    }
 
    {
        // ctype category
 
        // force a link failure if required specializations aren't
        // provided (e.g., if only the primary template is defined)
        const std::ctype<char_type>        *ctp = 0;
        const std::ctype_byname<char_type> *ctp_byname = 0;
 
        // verify that facet publicly derives from locale::facet
        const std::ctype_base *ctpbase = ctp;
        pfac = ctp;
        ctp  = ctp_byname;
 
        _RWSTD_UNUSED (ctpbase);
    }
 
    {
        const std::codecvt<char_type, char, std::mbstate_t> *cvt = 0;
        const std::codecvt_byname<char_type, char, std::mbstate_t>
            *cvt_byname = 0;
 
        // verify that facet publicly derives from locale::facet
        pfac = cvt;
 
        const std::codecvt_base *pcvtbase = cvt;
        _RWSTD_UNUSED (pcvtbase);
 
        cvt = cvt_byname;
    }
 
    typedef std::char_traits<char_type>               CTr;
    typedef std::istreambuf_iterator<char_type, CTr > IIt;
    typedef std::ostreambuf_iterator<char_type, CTr > OIt;
 
    {
        // monetary category
 
        const std::moneypunct<char_type, false>        *mpun             = 0;
        const std::moneypunct<char_type, true>         *mpun_intl        = 0;
        const std::moneypunct_byname<char_type, false> *mpun_byname      = 0;
        const std::moneypunct_byname<char_type, true>  *mpun_intl_byname = 0;
        const std::money_get<char_type, IIt>           *mget             = 0;
        const std::money_put<char_type, OIt>           *mput             = 0;
 
        // verify that facets publicly derive from locale::facet
        pfac = mpun;
        pfac = mpun_intl;
        pfac = mget;
        pfac = mput;
 
        mpun      = mpun_byname;
        mpun_intl = mpun_intl_byname;
 
        // verify that punct facets publicly derive from money_base
        const std::money_base *pmbase = mpun;
        pmbase = mpun_intl;
        _RWSTD_UNUSED (pmbase);
 
#ifndef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
 
        const std::moneypunct<char_type> *pmpun_noarg = mpun;
        _RWSTD_UNUSED (pmpun_noarg);
 
        // verify default template arguments
        const std::money_get<char_type> *pmget = mget;
        const std::money_put<char_type> *pmput = mput;
        _RWSTD_UNUSED (pmget);
        _RWSTD_UNUSED (pmput);
 
#endif   // _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
 
    }
 
    {
        // numeric category
 
        const std::num_get<char_type, IIt> *nget = 0;
        const std::num_put<char_type, OIt> *nput = 0;
 
        // verify that facets publicly derive from locale::facet
        pfac = nget;
        pfac = nput;
 
#ifndef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
 
        // verify default template arguments
        const std::num_get<char_type> *pnget = nget;
        const std::num_put<char_type> *pnput = nput;
        _RWSTD_UNUSED (pnget);
        _RWSTD_UNUSED (pnput);
 
#endif   // _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
 
    }
 
    {
        // time category
 
        const std::time_get<char_type, IIt> *tget = 0;
        const std::time_put<char_type, OIt> *tput = 0;
 
        // verify that facets publicly derive from locale::facet
        pfac = tget;
        pfac = tput;
 
#ifndef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
 
        // verify default template arguments
        const std::time_get<char_type> *ptget = tget;
        const std::time_put<char_type> *ptput = tput;
        _RWSTD_UNUSED (ptget);
        _RWSTD_UNUSED (ptput);
 
#endif   // _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
 
    }
 
    {
        // messages category
 
        const std::messages<char_type>        *msgs = 0;
        const std::messages_byname<char_type> *msgs_byname = 0;
 
        // verify that facets publicly derive from locale::facet
        pfac = msgs;
 
        const std::messages_base       *pmsgbase = msgs;
        const std::messages<char_type> *pmsgs    = msgs_byname;
 
        _RWSTD_UNUSED (pmsgbase);
        _RWSTD_UNUSED (pmsgs);
    }
}
 
 
// helper to verify that locale and facet ctors are explicit
// not defined since they must not be referenced if test is successful
void is_explicit (const std::locale&);
void is_explicit (const std::locale::facet&);
 
void is_explicit (const std::collate<char>&);
void is_explicit (const std::ctype<char>&);
 
#  ifndef _RWSTD_NO_WCHAR_T
 
void is_explicit (const std::collate<wchar_t>&);
void is_explicit (const std::ctype<wchar_t>&);
 
#  endif   // _RWSTD_NO_WCHAR_T
 
struct has_implicit_ctor
{
    // NOT explicit
 
    // for locale::facet::facet (size_t = 0) and derived facet ctors
    has_implicit_ctor (std::size_t) { /* empty */ }
 
    // for ctype<char>::ctype (const mask*, bool = false, size_t = 0)
    has_implicit_ctor (const std::ctype_base::mask*) { /* empty */ }
 
    // for locale::locale (const char*, size_t = 0)
    has_implicit_ctor (const char*) { /* empty */ }
};
 
// calls to the overloaded is_explicit() resolve to the function below
void is_explicit (const has_implicit_ctor&) { /* empty */ }
 
 
// local to test_locale
static bool dtor_called = false;
 
struct Facet: std::locale::facet
{
    typedef std::locale::facet Base;
 
    // default argument provided to work around a library limitation
    // that requires all facets to have default ctors
    Facet (std::size_t refs = 0): Base (refs) { /* empty */ }
 
    ~Facet () {
        dtor_called = true;
    }
 
    static std::locale::id id;
};
 
 
std::locale::id Facet::id;
 
// using a global in favor of a static local
// to work around an MSVC 6.0 bug (see PR #26305)
static bool is_dtor_virtual;
 
 
template <class charT>
struct StringTypes
{
    typedef std::char_traits<charT>                          traits_type;
    typedef std::allocator<charT>                            Allocator;
    typedef std::basic_string<charT, traits_type, Allocator> string_type;
};
 
 
// test class locale definition
static void
test_locale ()
{
    rw_info (0, __FILE__, __LINE__, "class std::locale synopsis");
 
    // 21.1.1.1.1
    const std::locale::category *pcat = (int*)0;
 
#ifndef _RWSTD_NO_STATIC_CONST_MEMBER_INIT
 
    // verify that category constants are defined
    pcat = &std::locale::none;
    pcat = &std::locale::collate;
    pcat = &std::locale::ctype;
    pcat = &std::locale::monetary;
    pcat = &std::locale::numeric;
    pcat = &std::locale::time;
    pcat = &std::locale::messages;
    pcat = &std::locale::all;
 
#endif   // _RWSTD_NO_STATIC_CONST_MEMBER_INIT
 
    // verify that category constants are constant integral expressions
    switch (*pcat) {
    case std::locale::none:
    case std::locale::collate:
    case std::locale::ctype:
    case std::locale::monetary:
    case std::locale::numeric:
    case std::locale::time:
    case std::locale::messages:
    case std::locale::all:
        break;
    }
 
    static const int c_cats [] = {
        LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, LC_TIME
 
#ifdef LC_MESSAGES
        , LC_MESSAGES
#endif   // LC_MESSAGES
 
    };
 
    static const std::locale::category cats[] = {
        std::locale::none, std::locale::collate, std::locale::ctype,
        std::locale::monetary, std::locale::numeric, std::locale::time,
        std::locale::messages, std::locale::all
    };
 
    for (pcat = cats; pcat != cats + sizeof cats / sizeof *cats - 1; ++pcat) {
 
        bool success = true;
 
        for (unsigned i = pcat - cats + 1; i < sizeof cats / sizeof *cats; ++i)
            if (   *pcat != std::locale::all
                && cats [i] != std::locale::all
                && (*pcat & cats [i]))
                rw_assert (success = false, __FILE__, __LINE__,
                           "(%{Lc} & %{Lc}) != 0", *pcat, cats [i]);
 
        for (unsigned j = 0; j != sizeof c_cats / sizeof *c_cats; ++j) {
            // locale::category values must not conflict with LC_XXX constants
            if (*pcat & c_cats [j])
                rw_assert (success = false, __FILE__, __LINE__,
                           "(%{Lc} & %{Lc}) != 0", *pcat, c_cats [j]);
 
            if (*pcat == c_cats [j])
                rw_assert (success = false, __FILE__, __LINE__,
                           "%{Lc} != %{Lc}", *pcat, c_cats [j]);
        }
 
        rw_assert (success, __FILE__, __LINE__, "%{Lc}", *pcat);
    }
 
    // 21.1.1.1.1, p1
    const int all =   std::locale::collate
                    | std::locale::ctype
                    | std::locale::monetary
                    | std::locale::numeric
                    | std::locale::time
                    | std::locale::messages;
 
    rw_assert (std::locale::all == all, __FILE__, __LINE__,
               "std::locale::all == %#x, got %#x", all, std::locale::all);
 
    // 22.1.1.1.2
 
    // verify that locale::facet::facet (size_t) is explicit
    is_explicit (std::size_t ());
 
    {
        // verify that ctor takes a default argument
        struct Facet: std::locale::facet {
 
            typedef std::locale::facet Base;
 
            Facet (): Base () { /* empty */ }
            Facet (std::size_t ref): Base (ref) {/* empty */  }
            ~Facet () {
                is_dtor_virtual = true;
            }
 
        };
 
        // delete a derived object using a pointer to the base
        delete (std::locale::facet*)new Facet ();
        rw_assert (is_dtor_virtual, __FILE__, __LINE__,
                   "locale::facet::~facet() not virtual");
    }
 
    // 22.1.1.1.3 - dfeault ctor and dtor are public
    std::locale::id id;
    _RWSTD_UNUSED (id);
 
    // 22.1.1.2, p1
    const std::locale l;
 
    // 22.1.1.2, p3
    std::locale l2 (l);
 
    // 22.1.1.2, p6
    (void)std::locale ("");
 
    // verify that locale::locale (const char*) is explicit
    is_explicit ((const char*)"");
 
    // 22.1.1.2, p9
    (void)std::locale (l, "", std::locale::all);
 
    Facet *pf = new Facet (1 /* ref count */);
 
    {
        // 22.1.1.2, p12
        // enclose unnamed temporary in its own scope to work around
        // a SunPro 5.4 bug which amkes it calls the dtor too late
        // see PR #27543
        (void)std::locale (l, pf);
    }
 
    // exercise 22.1.1.1.2, p2, refs == 1
    rw_assert (!dtor_called, __FILE__, __LINE__,
               "facet dtor called for ref count of 1");
 
    if (!dtor_called)
        delete pf;
 
    dtor_called = false;
 
    // exercise 22.1.1.1.2, p2, refs == 0
    pf = new Facet (0 /* ref count */);
 
    {
        // create an unnamed temporary object and force it to go out of
        // scope (in case the compiler, such as SunPro 5.4, fails to
        // detsroy it at the end of the expression) so that it is forced
        // to destroy the user-defined facet
        (void)std::locale (l, pf);
    }
 
    rw_assert (dtor_called, __FILE__, __LINE__,
               "UD facet dtor not called for ref count of 0");
 
    if (!dtor_called)
        delete pf;
 
    pf = 0;
 
    // 22.1.1.2, p14
    (void)std::locale (l, l, std::locale::all);
 
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#define MEMFUN(result, name, arg_list)                                   \
        do {                                                             \
           /* jumping thru hoops to avoid bogus gcc -Wshadow warnings */ \
           result (std::locale::* _RWSTD_PASTE (pf, __LINE__))           \
               arg_list = &std::locale::name;                            \
           _RWSTD_UNUSED (_RWSTD_PASTE (pf, __LINE__));                  \
         }  while (0)
 
#if !defined __HP_aCC || __HP_aCC > 33100
 
    // working around an HP aCC bug (see PR #23312)
 
    // 22.1.1.2, p4
    MEMFUN (const std::locale&, operator=,(const std::locale&) _PTR_THROWS(()));
 
#endif   // __HP_aCC > 33000
 
#if !defined __HP_aCC || __HP_aCC > 33100
 
    // working around an HP aCC bug (see PR #23312)
 
    // 22.1.1.3, p1
    MEMFUN (std::locale, combine<Facet>, (const std::locale&) const);
 
#endif   // __HP_aCC > 33000
 
    // 22.1.1.3, p5
    MEMFUN (std::string, name, () const);
 
    // 22.1.1.4, p1
    MEMFUN (bool, operator==, (const std::locale&) const);
 
    // 22.1.1.4, p2
    MEMFUN (bool, operator!=, (const std::locale&) const);
 
    // 22.1.1.4, p3
    MEMFUN (bool, operator(), (const std::string&, const std::string&) const);
 
#ifndef _RWSTD_NO_WCHAR_T
 
    MEMFUN (bool, operator(), (const std::wstring&, const std::wstring&)const);
 
#endif   // _RWSTD_NO_WCHAR_T
 
    // exercise a specialization other than on the default char types
    typedef StringTypes<int>::string_type IntString;
 
    MEMFUN (bool, operator(), (const IntString&, const IntString&) const);
 
    // 22.1.1.5
    FUN (std::locale, std::locale::global, (const std::locale&));
    FUN (const std::locale&, std::locale::classic, ());
}
 
 
// test class template ctype definition
 
template <class charT>
struct CtypeDerived: std::ctype<charT>
{
    typedef std::ctype<charT>     CtypeT;
    typedef std::ctype_base::mask M;
    typedef const charT*          PtrT;
 
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#undef MEMFUN
#define MEMFUN(result, name, arg_list)                       \
        do {                                                 \
            result (CtypeT::* pf) arg_list = &CtypeT::name;  \
            _RWSTD_UNUSED (pf);                              \
         }  while (0)
 
    static void test_protected_members () {
        // protected members (see `#define protected public' above)
        MEMFUN (bool, do_is, (M, charT) const);
        MEMFUN (PtrT, do_is, (PtrT, PtrT, M*) const);
 
        // lwg issue 124
        MEMFUN (PtrT, do_scan_is, (M, PtrT, PtrT) const);
        MEMFUN (PtrT, do_scan_not, (M, PtrT, PtrT) const);
        MEMFUN (charT, do_toupper, (charT) const);
        MEMFUN (PtrT, do_toupper, (charT*, PtrT) const);
        MEMFUN (charT, do_tolower, (charT) const);
        MEMFUN (PtrT, do_tolower, (charT*, PtrT) const);
        MEMFUN (charT, do_widen, (char) const);
        MEMFUN (const char*,
                do_widen, (const char*, const char*, charT*) const);
        MEMFUN (char, do_narrow, (charT, char) const);
        MEMFUN (PtrT, do_narrow,
                (PtrT, PtrT, char, char*) const);
    }
};
 
 
// exercise the primary template
template <class charT>
/*static*/ void
test_ctype_specialization ()
{
    CtypeDerived<charT>::test_protected_members ();
}
 
 
struct CtypeCharDerived: std::ctype<char>
{
    typedef std::ctype<char>      CtypeT;
    typedef std::ctype_base::mask Mask;
 
    // verify that all required ctors (or one with default args) exist
    CtypeCharDerived (): CtypeT () { /* empty */ }
    CtypeCharDerived (const Mask *tbl): CtypeT (tbl) { /* empty */ }
    CtypeCharDerived (const Mask *tbl, bool del): CtypeT (tbl, del) { /* empty */ }
    CtypeCharDerived (const Mask *tbl, bool del, std::size_t ref)
        : CtypeT (tbl, del, ref) { /* empty */ }
 
    static void test_protected_members () {
 
#ifndef _RWSTD_NO_STATIC_CONST_MEMBER_INIT
 
        // verify that table_size is properly defined
        const std::size_t *psz = &std::ctype<char>::table_size;
 
#else
 
        const std::size_t dummy = std::ctype<char>::table_size;
        const std::size_t *psz  = &dummy;
 
#endif   // _RWSTD_NO_STATIC_CONST_MEMBER_INIT
 
        // verify that table_size is an integral constant expression
        switch (*psz) {
        case std::ctype<char>::table_size: break;
        }
 
        MEMFUN (char, do_toupper, (char) const);
        MEMFUN (const char*, do_toupper, (char*, const char*) const);
        MEMFUN (char, do_tolower, (char) const);
        MEMFUN (const char*, do_tolower, (char*, const char*) const);
        MEMFUN (char, do_widen, (char) const);
        MEMFUN (const char*, do_widen,
                (const char*, const char*, char*) const);
        MEMFUN (char, do_narrow, (char, char) const);
        MEMFUN (const char*, do_narrow,
                (const char*, const char*, char, char*) const);
 
        // 22.2.1.3.2, p12
        MEMFUN (const std::ctype_base::mask*,
                table, () const _PTR_THROWS (()));
 
        // 22.2.1.3.3
        FUN (const std::ctype_base::mask*,
             CtypeT::classic_table, () _PTR_THROWS (()));
    }
};
 
 
// exercise the char specialization
_RWSTD_SPECIALIZED_FUNCTION
/*static*/ void
test_ctype_specialization<char> ()
{
    // prevent multiple assertions
    static int called /* = false */;
    if (called++)
        return;
 
    // 22.2.1.3.2, p3 - verify that ctor is explicit
    is_explicit ((const std::ctype_base::mask*)0);
 
    CtypeCharDerived::test_protected_members ();
}
 
 
// skip POSIX-dependent behavior
static int opt_enable_posix      = 0;   // --enable-posix
 
 
template <class charT>
static void
test_ctype (const char* cname)
{
    rw_info (0, __FILE__, __LINE__,
             "std::ctype<%s> synopsis", cname);
 
    std::ctype_base::mask m = std::ctype_base::space;
    _RWSTD_UNUSED (m);
 
    const std::ctype_base::mask *pm = 0;
    _RWSTD_UNUSED (pm);
 
    // verify that mask constants are constant integral expressions
    // whose address can be taken
    switch (m) {
 
#ifndef _RWSTD_NO_STATIC_CONST_MEMBER_INIT
   // see lwg issue 339
#  define ADDR(name)     pm = &std::ctype_base::name
#else
#  define ADDR(ignore)   (void)0
#endif
 
#if !defined __IBMCPP__ || __IBMCPP__ > 800
    // working around an IBM VAC++ bug #559
    case std::ctype_base::mask (): break;
#endif   // !VAC+ || VAC++ > 7.0
 
    case std::ctype_base::space:  ADDR (space); break;
    case std::ctype_base::print:  ADDR (print); break;
    case std::ctype_base::cntrl:  ADDR (cntrl); break;
    case std::ctype_base::upper:  ADDR (upper); break;
    case std::ctype_base::lower:  ADDR (lower); break;
    case std::ctype_base::alpha:  ADDR (alpha); break;
    case std::ctype_base::digit:  ADDR (digit); break;
    case std::ctype_base::punct:  ADDR (punct); break;
    case std::ctype_base::xdigit: ADDR (xdigit); break;
    case std::ctype_base::alnum:  ADDR (alnum); break;
    case std::ctype_base::graph:  ADDR (graph); break;
 
    default: break;
    }
 
    // prevent unnecessary assertions
    if (sizeof (charT) == sizeof (char)) {
        rw_assert (std::ctype_base::alnum ==
                   (std::ctype_base::alpha | std::ctype_base::digit),
                   __FILE__, __LINE__,
                   "std::ctype_base::alnum = %#x, expected %#x",
                   std::ctype_base::alnum,
                   std::ctype_base::alpha | std::ctype_base::digit);
 
        if (opt_enable_posix) {
            // POSIX allows graph characters that aren't alnum or punct
            // 22.2.1 says the numeric values are for exposition only
            // which presumably applies to all the constants
            rw_assert (std::ctype_base::graph
                       == (std::ctype_base::alnum | std::ctype_base::punct),
                       __FILE__, __LINE__,
                       "std::ctype_base::graph = %#x, expected %#x",
                       std::ctype_base::graph,
                       std::ctype_base::alnum | std::ctype_base::punct);
        }
    }
 
    typedef std::ctype<charT>     CtypeT;
    typedef typename CtypeT::mask Mask;
 
    charT *pc = (typename CtypeT::char_type*)0;
    _RWSTD_UNUSED (pc);
 
    typedef const charT* PtrT;
 
    MEMFUN (bool, is, (Mask, charT) const);
    MEMFUN (PtrT, is, (PtrT, PtrT, Mask*) const);
    MEMFUN (PtrT, scan_is, (Mask, PtrT, PtrT) const);
    MEMFUN (PtrT, scan_not, (Mask, PtrT, PtrT) const);
    MEMFUN (charT, toupper, (charT) const);
    MEMFUN (PtrT, toupper, (charT*, PtrT) const);
    MEMFUN (charT, tolower, (charT) const);
    MEMFUN (PtrT, tolower, (charT*, PtrT) const);
    MEMFUN (charT, widen, (char) const);
    MEMFUN (const char*, widen, (const char*, const char*, charT*) const);
    MEMFUN (char, narrow, (charT, char) const);
    MEMFUN (PtrT, narrow,
            (PtrT, PtrT, char, char*) const);
 
    std::locale::id *pid = &CtypeT::id;
    _RWSTD_UNUSED (pid);
 
    // exercise virtuals and other parts that differ between
    // the primary template and the char specialization
    test_ctype_specialization<charT> ();
}
 
 
template <class charT>
struct CodecvtDerived: std::codecvt<charT, char, std::mbstate_t>
{
    typedef std::codecvt<charT, char, std::mbstate_t> Codecvt;
    typedef std::codecvt_base::result                 Result;
    typedef typename Codecvt::intern_type             InternT;
    typedef typename Codecvt::extern_type             ExternT;
    typedef typename Codecvt::state_type              StateT;
 
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#undef MEMFUN
#define MEMFUN(result, name, arg_list)                        \
        do {                                                  \
           result (Codecvt::*pf) arg_list = &Codecvt::name;   \
           _RWSTD_UNUSED (pf);                                \
         }  while (0)
 
    void test_protected_members () {
            // protected virtuals
            MEMFUN (Result, do_out,
                    (StateT&, const InternT*, const InternT*, const InternT*&,
                     ExternT*, ExternT*, ExternT*&) const);
 
            MEMFUN (Result, do_unshift,
                    (StateT&, ExternT*, ExternT*, ExternT*&) const);
 
            MEMFUN (Result, do_in,
                    (StateT&, const ExternT*, const ExternT*, const ExternT*&,
                     InternT*, InternT*, InternT*&) const);
 
            MEMFUN (int, do_encoding, () const _PTR_THROWS (()));
            MEMFUN (bool, do_always_noconv, () const _PTR_THROWS (()));
 
            // lwg issue 75 changes first argument from const StateT& to State&
            MEMFUN (int, do_length,
                    (StateT&, const ExternT*, const ExternT*,
                     std::size_t) const);
 
            MEMFUN (int, do_max_length, () const _PTR_THROWS (()));
        }
    };
 
 
template <class charT>
static void
test_codecvt (const char* cname)
{
    rw_info (0, __FILE__, __LINE__,
             "std::codecvt<%s, char, std::mbstate_t> synopsis", cname);
 
    // verify base class
    std::codecvt_base b;
    std::codecvt_base::result r = b.ok;
 
    // prevent a bogus MSVC warning 4101 (see PR #24178)
    _RWSTD_UNUSED (b);
 
    // verify that result is a constant integral expression
    switch (r) {
    case std::codecvt_base::ok:
    case std::codecvt_base::partial:
    case std::codecvt_base::error:
    case std::codecvt_base::noconv:
        break;
    }
 
    typedef std::codecvt<charT, char, std::mbstate_t> Codecvt;
 
    // verify that nested types exist
    typedef typename Codecvt::intern_type  InternT;
    typedef typename Codecvt::extern_type  ExternT;
    typedef typename Codecvt::state_type   StateT;
 
    // verify nested types
    const InternT *pint = (const charT*)0;
    const ExternT *pext = (const char*)0;
    const StateT  *pst  = (const std::mbstate_t*)0;
 
    _RWSTD_UNUSED (pint);
    _RWSTD_UNUSED (pext);
    _RWSTD_UNUSED (pst);
 
    typedef std::codecvt_base::result Result;
 
    // public non-virtuals
    MEMFUN (Result, out,
            (StateT&, const InternT*, const InternT*, const InternT*&,
             ExternT*, ExternT*, ExternT*&) const);
 
    MEMFUN (Result, unshift, (StateT&, ExternT*, ExternT*, ExternT*&) const);
 
    MEMFUN (Result, in,
            (StateT&, const ExternT*, const ExternT*, const ExternT*&,
             InternT*, InternT*, InternT*&) const);
 
    MEMFUN (int, encoding, () const _PTR_THROWS (()));
    MEMFUN (bool, always_noconv, () const _PTR_THROWS (()));
 
    // lwg issue 75 changes the first argument from const StateT& to State&
    MEMFUN (int, length,
            (StateT&, const ExternT*, const ExternT*, std::size_t) const);
 
    MEMFUN (int, max_length, () const _PTR_THROWS (()));
 
    std::locale::id *pid = &Codecvt::id;
    _RWSTD_UNUSED (pid);
 
    CodecvtDerived<charT>().test_protected_members ();
}
 
 
// user-defined character type; used to exercise requirements in Table 52
// i.e., specializations of facets on types other than char and wchar_t
#define UDC int
 
// numeric category
 
namespace std {
 
// provide an explicit specialization of numpunct on UDC necessary
// in order to exercise num_get<UDC> and num_put<UDC>
 
_RWSTD_SPECIALIZED_CLASS
struct numpunct<UDC>: locale::facet
{
    typedef UDC                                 char_type;
    typedef StringTypes<char_type>::string_type string_type;
 
    // working around an MSVC 6.0 bug
    typedef locale::facet           Base;
 
    explicit numpunct (size_t refs = 0)
        : Base (refs) { /* empty */ }
 
    static locale::id id;
 
    char_type decimal_point () const { return char_type (); }
    char_type thousands_sep () const { return char_type (); }
    string grouping () const { return ""; }
    string_type falsename () const { return string_type (); }
    string_type truename () const { return string_type (); }
};
 
locale::id numpunct<UDC>::id;
 
}   // namespace std
 
 
template <class charT>
struct NumPunctDerived: std::numpunct<charT>
{
    typedef std::numpunct<charT>                     NumPunct;
    typedef typename StringTypes<charT>::string_type StringT;
 
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#undef MEMFUN
#define MEMFUN(result, name, arg_list)                          \
        do {                                                    \
           result (NumPunct::*pf) arg_list = &NumPunct::name;   \
           _RWSTD_UNUSED (pf);                                  \
         }  while (0)
 
    static void test_protected_members () {
        // protected virtuals
        MEMFUN (charT, do_decimal_point, () const);
        MEMFUN (charT, do_thousands_sep, () const);
        MEMFUN (std::string, do_grouping, () const);
        MEMFUN (StringT, do_truename, () const);
        MEMFUN (StringT, do_falsename, () const);
    }
};
 
 
template <class charT>
static void
test_numpunct (const char* cname)
{
    rw_info (0, __FILE__, __LINE__,
             "std::numpunct<%s> synopsis", cname);
 
    typedef std::numpunct<charT>                     NumPunct;
    typedef typename StringTypes<charT>::string_type StringT;
 
    // verify nested types
    typename NumPunct::char_type   *pc   = (charT*)0;
    typename NumPunct::string_type *pstr = (StringT*)0;
 
    _RWSTD_UNUSED (pc);
    _RWSTD_UNUSED (pstr);
 
    // public interface
    MEMFUN (charT, decimal_point, () const);
    MEMFUN (charT, thousands_sep, () const);
    MEMFUN (std::string, grouping, () const);
    MEMFUN (StringT, truename, () const);
    MEMFUN (StringT, falsename, () const);
 
    // verify that id is defined and non-const
    std::locale::id *pid = &NumPunct::id;
    _RWSTD_UNUSED (pid);
 
    NumPunctDerived<charT>::test_protected_members ();
}
 
 
typedef std::ios_base          IosBase;
typedef std::ios_base::iostate IoState;
 
 
template <class charT, class IterT>
struct NumGetDerived: std::num_get<charT, IterT>
{
    typedef std::num_get<charT, IterT> NumGet;
 
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#undef MEMFUN
#define MEMFUN(result, name, arg_list)                      \
        do {                                                \
           result (NumGet::*pf) arg_list = &NumGet::name;   \
           _RWSTD_UNUSED (pf);                              \
         }  while (0)
 
    static void test_protected_members () {
        // protected virtuals
        MEMFUN (IterT, do_get,
                (IterT, IterT, IosBase&, IoState&, bool&) const);
        MEMFUN (IterT, do_get,
                (IterT, IterT, IosBase& ,IoState&, long&) const);
        MEMFUN (IterT, do_get,
                (IterT, IterT, IosBase&, IoState&, unsigned short&) const);
        MEMFUN (IterT, do_get,
                (IterT, IterT, IosBase&, IoState&, unsigned&) const);
        MEMFUN (IterT, do_get,
                (IterT, IterT, IosBase&, IoState&, unsigned long&) const);
 
#ifdef _RWSTD_LONG_LONG
 
        // extensions disabled in strict ANSI mode
        MEMFUN (IterT, do_get,
                (IterT, IterT, IosBase&, IoState&, _RWSTD_LONG_LONG&) const);
        MEMFUN (IterT, do_get,
                (IterT, IterT, IosBase&, IoState&,
                 unsigned _RWSTD_LONG_LONG&) const);
 
#endif   // _RWSTD_LONG_LONG
 
        MEMFUN (IterT, do_get,
                (IterT, IterT, IosBase&, IoState&, float&) const);
        MEMFUN (IterT, do_get,
                (IterT, IterT, IosBase&, IoState&, double&) const);
        MEMFUN (IterT, do_get,
                (IterT, IterT, IosBase&, IoState&, long double&) const);
        MEMFUN (IterT, do_get,
                (IterT, IterT, IosBase&, IoState&, void*&) const);
    }
};
 
 
template <class charT, class IterT>
static void
test_num_get (const char* cname, const char* iname)
{
    rw_info (0, __FILE__, __LINE__,
             "std::num_get<%s, %s > synopsis", cname, iname);
 
    typedef std::num_get<charT, IterT> NumGet;
 
    // verify nested types
    typename NumGet::char_type *pc = (charT*)0;
    typename NumGet::iter_type *pi = (IterT*)0;
 
    _RWSTD_UNUSED (pc);
    _RWSTD_UNUSED (pi);
 
    // public interface
    MEMFUN (IterT, get, (IterT, IterT, IosBase&, IoState&, bool&) const);
    MEMFUN (IterT, get, (IterT, IterT, IosBase&, IoState&, long&) const);
    MEMFUN (IterT, get,
            (IterT, IterT, IosBase&, IoState&, unsigned short&) const);
    MEMFUN (IterT, get,
            (IterT, IterT, IosBase&, IoState&, unsigned&) const);
    MEMFUN (IterT, get,
            (IterT, IterT, IosBase&, IoState&, unsigned long&) const);
 
#ifdef _RWSTD_LONG_LONG
 
    // extensions disabled in strict ANSI mode
    MEMFUN (IterT, get,
            (IterT, IterT, IosBase&, IoState&, _RWSTD_LONG_LONG&) const);
    MEMFUN (IterT, get,
            (IterT, IterT, IosBase&, IoState&,
             unsigned _RWSTD_LONG_LONG&) const);
 
#endif   // _RWSTD_LONG_LONG
 
    MEMFUN (IterT, get,
            (IterT, IterT, IosBase&, IoState&, float&) const);
    MEMFUN (IterT, get,
            (IterT, IterT, IosBase&, IoState&, double&) const);
    MEMFUN (IterT, get,
            (IterT, IterT, IosBase&, IoState&, long double&) const);
    MEMFUN (IterT, get,
            (IterT, IterT, IosBase&, IoState&, void*&) const);
 
    std::locale::id *pid = &NumGet::id;
    _RWSTD_UNUSED (pid);
 
    NumGetDerived<charT, IterT>::test_protected_members ();
}
 
 
template <class charT, class IterT>
struct NumPutDerived: std::num_put<charT, IterT>
{
    typedef std::num_put<charT, IterT> NumPut;
 
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#undef MEMFUN
#define MEMFUN(result, name, arg_list)                      \
        do {                                                \
           result (NumPut::*pf) arg_list = &NumPut::name;   \
           _RWSTD_UNUSED (pf);                              \
         }  while (0)
 
    static void test_protected_members () {
        // protected virtuals
        MEMFUN (IterT, do_put, (IterT, IosBase&, charT, bool) const);
        MEMFUN (IterT, do_put, (IterT, IosBase&, charT, long) const);
 
        // no overloads for unsigned short or unsigned int
        MEMFUN (IterT, do_put, (IterT, IosBase&, charT, unsigned long) const);
 
#ifdef _RWSTD_LONG_LONG
 
        // extensions disabled when _RWSTD_NO_LONG_LONG is #defined
        MEMFUN (IterT, do_put,
                (IterT, IosBase&, charT, _RWSTD_LONG_LONG) const);
        MEMFUN (IterT, do_put,
                (IterT, IosBase&, charT, unsigned _RWSTD_LONG_LONG) const);
 
#endif   // _RWSTD_LONG_LONG
 
        // no float overload
        MEMFUN (IterT, do_put, (IterT, IosBase&, charT, double) const);
        MEMFUN (IterT, do_put, (IterT, IosBase&, charT, long double) const);
        MEMFUN (IterT, do_put, (IterT, IosBase&, charT, const void*) const);
    }
};
 
 
template <class charT, class IterT>
static void
test_num_put (const char* cname, const char* iname)
{
    rw_info (0, __FILE__, __LINE__,
             "std::num_put<%s, %s > synopsis", cname, iname);
 
    typedef std::num_put<charT, IterT> NumPut;
 
    // verify nested types
    typename NumPut::char_type *pc = (charT*)0;
    typename NumPut::iter_type *pi = (IterT*)0;
 
    _RWSTD_UNUSED (pc);
    _RWSTD_UNUSED (pi);
 
    // public interface
    MEMFUN (IterT, put, (IterT, IosBase&, charT, bool) const);
    MEMFUN (IterT, put, (IterT, IosBase&, charT, long) const);
    MEMFUN (IterT, put, (IterT, IosBase&, charT, unsigned long) const);
 
#ifdef _RWSTD_LONG_LONG
 
    // extensions disabled in strict ANSI mode
    MEMFUN (IterT, put,
            (IterT, IosBase&, charT, _RWSTD_LONG_LONG) const);
    MEMFUN (IterT, put,
            (IterT, IosBase&, charT, unsigned _RWSTD_LONG_LONG) const);
 
#endif   // _RWSTD_LONG_LONG
 
    MEMFUN (IterT, put, (IterT, IosBase&, charT, double) const);
    MEMFUN (IterT, put, (IterT, IosBase&, charT, long double) const);
    MEMFUN (IterT, put, (IterT, IosBase&, charT, const void*) const);
 
    std::locale::id *pid = &NumPut::id;
    _RWSTD_UNUSED (pid);
 
    NumPutDerived<charT, IterT>::test_protected_members ();
}
 
 
// collate category
 
template <class charT>
struct CollateDerived: std::collate<charT>
{
    typedef const charT*                             PtrT;
    typedef std::collate<charT>                      Collate;
    typedef typename StringTypes<charT>::string_type StringT;
 
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#undef MEMFUN
#define MEMFUN(result, name, arg_list)                         \
        do {                                                   \
           result (Collate::* pf) arg_list = &Collate::name;   \
           _RWSTD_UNUSED (pf);                                 \
         }  while (0)
 
    static void test_protected_members () {
 
        MEMFUN (int, compare, (PtrT, PtrT, PtrT, PtrT) const);
 
        MEMFUN (StringT, transform, (PtrT, PtrT) const);
        MEMFUN (long, hash, (PtrT, PtrT) const);
 
        std::locale::id *pid = &Collate::id;
        _RWSTD_UNUSED (pid);
 
        // protected virtuals (see `#define protected public' above)
        MEMFUN (int, do_compare, (PtrT, PtrT, PtrT, PtrT) const);
 
        MEMFUN (StringT, do_transform, (PtrT, PtrT) const);
        MEMFUN (long, do_hash, (PtrT, PtrT) const);
    }
};
 
 
template <class charT>
static void
test_collate (const char* cname)
{
    rw_info (0, __FILE__, __LINE__,
             "std::collate<%s> synopsis", cname);
 
    typedef std::collate<charT> Collate;
    typedef typename StringTypes<charT>::string_type StringT;
 
    // verify nested types
    typename Collate::char_type   *pc   = (charT*)0;
    typename Collate::string_type *pstr = (StringT*)0;
 
    _RWSTD_UNUSED (pc);
    _RWSTD_UNUSED (pstr);
 
    CollateDerived<charT>::test_protected_members ();
}
 
 
// time category
 
template <class charT, class IterT>
struct TimeGetDerived: std::time_get<charT, IterT>
{
    typedef std::time_get<charT, IterT> TimeGet;
 
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#undef MEMFUN
#define MEMFUN(result, name, arg_list)                         \
        do {                                                   \
           result (TimeGet::* pf) arg_list = &TimeGet::name;   \
           _RWSTD_UNUSED (pf);                                 \
         }  while (0)
 
    static void test_protected_members () {
        // protected virtuals
        MEMFUN (std::time_base::dateorder, do_date_order, () const);
        MEMFUN (IterT, do_get_time,
                (IterT, IterT, IosBase&, IoState&, std::tm*) const);
        MEMFUN (IterT, do_get_date,
                (IterT, IterT, IosBase&, IoState&, std::tm*) const);
        MEMFUN (IterT, do_get_weekday,
                (IterT, IterT, IosBase&, IoState&, std::tm*) const);
        MEMFUN (IterT, do_get_monthname,
                (IterT, IterT, IosBase&, IoState&, std::tm*) const);
        MEMFUN (IterT, do_get_year,
                (IterT, IterT, IosBase&, IoState&, std::tm*) const);
    }
};
 
 
template <class charT, class IterT>
static void
test_time_get (const char* cname, const char* iname)
{
    rw_info (0, __FILE__, __LINE__,
             "std::time_get<%s, %s > synopsis", cname, iname);
 
    typedef std::time_get<charT, IterT> TimeGet;
 
    // verify that dateorder constants are constant integral expressions
    std::time_base::dateorder ord = std::time_base::no_order;
    switch (ord) {
    case std::time_base::no_order:
    case std::time_base::dmy: case std::time_base::mdy:
    case std::time_base::ymd: case std::time_base::ydm:
        break;
    }
 
    // verify values
    rw_assert (0 == std::time_base::no_order, __FILE__, __LINE__,
               "std::time_base::no_order");
    rw_assert (1 == std::time_base::dmy, __FILE__, __LINE__,
               "std::time_base::dmy");
    rw_assert (2 == std::time_base::mdy, __FILE__, __LINE__,
               "std::time_base::mdy");
    rw_assert (3 == std::time_base::ymd, __FILE__, __LINE__,
               "std::time_base::ymd");
    rw_assert (4 == std::time_base::ydm, __FILE__, __LINE__,
               "std::time_base::ydm");
 
    // verify nested types
    typename TimeGet::char_type *pc = (charT*)0;
    typename TimeGet::iter_type *pi = (IterT*)0;
 
    _RWSTD_UNUSED (pc);
    _RWSTD_UNUSED (pi);
 
    // public non-virtuals
    MEMFUN (std::time_base::dateorder, date_order, () const);
    MEMFUN (IterT, get_time,
            (IterT, IterT, IosBase&, IoState&, std::tm*) const);
    MEMFUN (IterT, get_date,
            (IterT, IterT, IosBase&, IoState&, std::tm*) const);
    MEMFUN (IterT, get_weekday,
            (IterT, IterT, IosBase&, IoState&, std::tm*) const);
    MEMFUN (IterT, get_monthname,
            (IterT, IterT, IosBase&, IoState&, std::tm*) const);
    MEMFUN (IterT, get_year,
            (IterT, IterT, IosBase&, IoState&, std::tm*) const);
 
    std::locale::id *pid = &TimeGet::id;
    _RWSTD_UNUSED (pid);
 
    TimeGetDerived<charT, IterT>::test_protected_members ();
}
 
 
template <class charT, class IterT>
struct TimePutDerived: std::time_put<charT, IterT>
{
    typedef std::time_put<charT, IterT> TimePut;
 
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#undef MEMFUN
#define MEMFUN(result, name, arg_list)                        \
        do {                                                  \
           result (TimePut::*pf) arg_list = &TimePut::name;   \
           _RWSTD_UNUSED (pf);                                \
         }  while (0)
 
    static void test_protected_members () {
        // protected virtuals
        MEMFUN (IterT, do_put, (IterT, IosBase&, charT, const std::tm*,
                                char, char) const);
    }
};
 
 
template <class charT, class IterT>
static void
test_time_put (const char* cname, const char* iname)
{
    rw_info (0, __FILE__, __LINE__,
             "std::time_put<%s, %s > synopsis", cname, iname);
 
    typedef std::time_put<charT, IterT> TimePut;
 
    // verify nested types
    typename TimePut::char_type *pc = (charT*)0;
    typename TimePut::iter_type *pi = (IterT*)0;
 
    _RWSTD_UNUSED (pc);
    _RWSTD_UNUSED (pi);
 
    // public non-virtuals
    MEMFUN (IterT, put, (IterT, IosBase&, charT, const std::tm*,
                          const charT*, const charT*) const);
    MEMFUN (IterT, put, (IterT, IosBase&, charT, const std::tm*,
                         char, char) const);
 
    std::locale::id *pid = &TimePut::id;
    _RWSTD_UNUSED (pid);
 
    TimePutDerived<charT, IterT>::test_protected_members ();
}
 
 
// monetary category
 
namespace std {
 
// (in the absence of support for partial specialization) provide explicit
// specializations of moneypunct on UDC necessary in order to exercise
// money_get<UDC> and money_put<UDC>
 
_RWSTD_SPECIALIZED_CLASS
struct moneypunct<UDC, false>: locale::facet, money_base
{
    typedef UDC                                 char_type;
    typedef StringTypes<char_type>::string_type string_type;
 
    // working around an MSVC 6.0 bug
    typedef locale::facet           Base;
 
    explicit moneypunct (size_t refs = 0)
        : Base (refs), money_base () { /* empty */ }
 
    static locale::id id;
 
    enum { intl = false };
 
    char_type decimal_point () const { return char_type (); }
    char_type thousands_sep () const { return char_type (); }
    string grouping () const { return ""; }
    string_type curr_symbol () const { return string_type (); }
    string_type positive_sign () const { return string_type (); }
    string_type negative_sign () const { return string_type (); }
    int frac_digits () const { return 0; }
    pattern pos_format () const { return pattern (); }
    pattern neg_format () const { return pattern (); }
};
 
locale::id moneypunct<UDC, false>::id;
 
 
_RWSTD_SPECIALIZED_CLASS
struct moneypunct<UDC, true>: locale::facet, money_base
{
    typedef UDC                                 char_type;
    typedef StringTypes<char_type>::string_type string_type;
 
    // working around an MSVC 6.0 bug
    typedef locale::facet           Base;
 
    explicit moneypunct (size_t refs = 0)
        : Base (refs), money_base () { /* empty */ }
 
    static locale::id id;
 
    enum { intl = true };
 
    char_type decimal_point () const { return char_type (); }
    char_type thousands_sep () const { return char_type (); }
    string grouping () const { return ""; }
    string_type curr_symbol () const { return string_type (); }
    string_type positive_sign () const { return string_type (); }
    string_type negative_sign () const { return string_type (); }
    int frac_digits () const { return 0; }
    pattern pos_format () const { return pattern (); }
    pattern neg_format () const { return pattern (); }
};
 
locale::id moneypunct<UDC, true>::id;
 
}   // namespace std
 
 
template <class charT, bool Intl>
struct MoneyPunctDerived: std::moneypunct<charT, Intl>
{
    typedef std::moneypunct<charT, Intl>             MoneyPunct;
    typedef typename StringTypes<charT>::string_type StringT;
 
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#undef MEMFUN
#define MEMFUN(result, name, arg_list)                               \
        do {                                                         \
           result (MoneyPunct::* pf) arg_list = &MoneyPunct::name;   \
           _RWSTD_UNUSED (pf);                                       \
         }  while (0)
 
    static void test_protected_members () {
 
        // protected virtuals
        MEMFUN (charT, do_decimal_point, () const);
        MEMFUN (charT, do_thousands_sep, () const );
        MEMFUN (std::string, do_grouping, () const );
        MEMFUN (StringT, do_curr_symbol, () const);
        MEMFUN (StringT, do_positive_sign, () const);
        MEMFUN (StringT, do_negative_sign, () const);
        MEMFUN (int, do_frac_digits, () const);
        MEMFUN (std::money_base::pattern, do_pos_format, () const);
        MEMFUN (std::money_base::pattern, do_neg_format, () const);
    }
};
 
 
template <class charT>
static void
test_moneypunct (const char* cname)
{
    rw_info (0, __FILE__, __LINE__,
             "std::moneypunct<%s, bool> synopsis", cname);
 
    typedef std::moneypunct<charT, false>            MoneyPunct;
    typedef typename StringTypes<charT>::string_type StringT;
 
    typename MoneyPunct::char_type *pc = (charT*)0;
    typename MoneyPunct::string_type *ps = (StringT*)0;
 
    _RWSTD_UNUSED (pc);
    _RWSTD_UNUSED (ps);
 
    MEMFUN (charT, decimal_point, () const );
    MEMFUN (charT, thousands_sep, () const );
    MEMFUN (std::string, grouping, () const );
    MEMFUN (StringT, curr_symbol, () const);
    MEMFUN (StringT, positive_sign, () const);
    MEMFUN (StringT, negative_sign, () const);
    MEMFUN (int, frac_digits, () const);
    MEMFUN (std::money_base::pattern, pos_format, () const);
    MEMFUN (std::money_base::pattern, neg_format, () const);
 
    std::locale::id *pid = &MoneyPunct::id;
    _RWSTD_UNUSED (pid);
 
    MoneyPunctDerived<charT, false>::test_protected_members ();
}
 
 
template <class charT, class IterT>
struct MoneyGetDerived: std::money_get<charT, IterT>
{
    typedef std::money_get<charT, IterT>             MoneyGet;
    typedef typename StringTypes<charT>::string_type StringT;
 
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#undef MEMFUN
#define MEMFUN(result, name, arg_list)                          \
        do {                                                    \
           result (MoneyGet::*pf) arg_list = &MoneyGet::name;   \
           _RWSTD_UNUSED (pf);                                  \
         }  while (0)
 
    static void test_protected_members () {
        // protected virtuals
 
#ifndef _RWSTD_NO_LONG_DOUBLE
 
        MEMFUN (IterT, do_get, (IterT, IterT, bool, IosBase&,
                                IoState&, long double&) const);
 
#else   // if defined _RWSTD_NO_LONG_DOUBLE
 
        MEMFUN (IterT, do_get, (IterT, IterT, bool, IosBase&,
                                IoState&, double&) const);
 
#endif   // _RWSTD_NO_LONG_DOUBLE
 
        MEMFUN (IterT, do_get, (IterT, IterT, bool, IosBase&,
                                IoState&, StringT&) const);
    }
};
 
 
template <class charT, class IterT>
static void
test_money_get (const char* cname, const char* iname)
{
    rw_info (0, __FILE__, __LINE__,
             "std::money_get<%s, %s > synopsis", cname, iname);
 
    typedef std::money_get<charT, IterT>             MoneyGet;
    typedef typename StringTypes<charT>::string_type StringT;
 
    // verify nested types
    typename MoneyGet::char_type *pc = (charT*)0;
    typename MoneyGet::iter_type *pi = (IterT*)0;
    typename MoneyGet::string_type *ps = (StringT*)0;
 
    _RWSTD_UNUSED (pc);
    _RWSTD_UNUSED (pi);
    _RWSTD_UNUSED (ps);
 
    // public interface
    MEMFUN (IterT, get, (IterT, IterT, bool, IosBase&,
                        IoState&, long double&) const);
    MEMFUN (IterT, get, (IterT, IterT, bool, IosBase&,
                        IoState&, StringT&) const);
 
    std::locale::id *pid = &MoneyGet::id;
    _RWSTD_UNUSED (pid);
 
    MoneyGetDerived<charT, IterT>::test_protected_members ();
}
 
 
template <class charT, class IterT>
struct MoneyPutDerived: std::money_put<charT, IterT>
{
    typedef std::money_put<charT, IterT>             MoneyPut;
    typedef typename StringTypes<charT>::string_type StringT;
 
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#undef MEMFUN
#define MEMFUN(result, name, arg_list)                          \
        do {                                                    \
           result (MoneyPut::*pf) arg_list = &MoneyPut::name;   \
           _RWSTD_UNUSED (pf);                                  \
         }  while (0)
 
    static void test_protected_members () {
            // protected virtuals
 
#ifndef _RWSTD_NO_LONG_DOUBLE
 
        MEMFUN (IterT, do_put, (IterT, bool, IosBase&, charT,
                                long double) const);
 
#else   // if defined _RWSTD_NO_LONG_DOUBLE
 
        MEMFUN (IterT, do_put, (IterT, bool, IosBase&, charT, double) const);
 
#endif   // _RWSTD_NO_LONG_DOUBLE
 
        MEMFUN (IterT, do_put, (IterT, bool, IosBase&, charT,
                                const StringT&) const);
    }
};
 
 
template <class charT, class IterT>
static void
test_money_put (const char* cname, const char* iname)
{
    rw_info (0, __FILE__, __LINE__,
             "std::money_put<%s, %s > synopsis", cname, iname);
 
    typedef std::money_put<charT, IterT>             MoneyPut;
    typedef typename StringTypes<charT>::string_type StringT;
 
     //verify nested types
    typename MoneyPut::char_type *pc = (charT*)0;
    typename MoneyPut::iter_type *pi = (IterT*)0;
    typename MoneyPut::string_type *ps = (StringT*)0;
 
    _RWSTD_UNUSED (pc);
    _RWSTD_UNUSED (pi);
    _RWSTD_UNUSED (ps);
 
    // public interface
    MEMFUN (IterT, put, (IterT, bool, IosBase&, charT,
                        long double) const);
    MEMFUN (IterT, put, (IterT, bool, IosBase&, charT,
                        const StringT&) const);
 
    std::locale::id *pid = &MoneyPut::id;
    _RWSTD_UNUSED (pid);
 
    MoneyPutDerived<charT, IterT>::test_protected_members ();
}
 
 
// messges category
 
template <class charT>
struct MessagesDerived: std::messages<charT>
{
    typedef std::messages<charT>                     Messages;
    typedef typename StringTypes<charT>::string_type StringT;
 
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#undef MEMFUN
#define MEMFUN(result, name, arg_list)                           \
        do {                                                     \
           result (Messages::* pf) arg_list = &Messages::name;   \
           _RWSTD_UNUSED (pf);                                   \
         }  while (0)
 
 
    static void test_protected_members () {
        // protected virtuals
        MEMFUN (int,  do_open,
                (const std::string&, const std::locale&) const);
        MEMFUN (StringT, do_get, (int, int, int, const StringT&) const);
        MEMFUN (void, do_close, (int) const);
    }
};
 
 
template <class charT>
static void
test_messages (const char* cname)
{
    rw_info (0, __FILE__, __LINE__,
             "std::messages<%s> synopsis", cname);
 
    typedef std::messages<charT>                     Messages;
    typedef typename StringTypes<charT>::string_type StringT;
 
    // verify nested types
    std::messages_base::catalog    *pcat = (int*)0;
    typename Messages::char_type   *pc   = (charT*)0;
    typename Messages::string_type *pstr = (StringT*)0;
 
    _RWSTD_UNUSED (pcat);
    _RWSTD_UNUSED (pc);
    _RWSTD_UNUSED (pstr);
 
    // public interface
    MEMFUN (int,  open, (const std::string&, const std::locale&) const);
    MEMFUN (StringT, get, (int, int, int, const StringT&) const);
    MEMFUN (void, close, (int) const);
 
    std::locale::id *pid = &Messages::id;
    _RWSTD_UNUSED (pid);
 
    MessagesDerived<charT>::test_protected_members ();
}
 
 
static int
run_test (int /*unused*/, char* /*unused*/ [])
{
    test_lc_defs ();
    test_isxxx ();
 
    // exercise the signatures of std::{has,use}_facet<>()
    test_have_use_facet<char> ();
 
    // exercise the signatures of the convenience locale interfaces
    test_convenience_funs<char> ();
 
    // test for the presence of the required facet templates
    test_facets<char> ();
 
    test_locale ();
 
// don't use _RWSTD_STRSTR so type macros (e.g. UDC) are not expanded
#undef FUN1
#define FUN1(fun, charT) \
        fun< charT > (#charT)
 
    // std::locale::collate category
    FUN1 (test_collate, char);
 
    // std::locale::ctype category
    FUN1 (test_codecvt, char);
    FUN1 (test_ctype, char);
 
#undef FUN2
#define FUN2(fun, charT, IterT) \
        fun< charT, IterT > (#charT, #IterT)
 
    // std::locale::monetary category
    FUN1 (test_moneypunct, char);
    FUN2 (test_money_get, char, std::istreambuf_iterator<char>);
    FUN2 (test_money_get, char, const char*);
    FUN2 (test_money_put, char, std::ostreambuf_iterator<char>);
    FUN2 (test_money_put, char, char*);
 
    // std::locale::numeric category
    FUN1 (test_numpunct, char);
    FUN2 (test_num_get, char, std::istreambuf_iterator<char>);
    FUN2 (test_num_get, char, const char*);
    FUN2 (test_num_put, char, std::ostreambuf_iterator<char>);
    FUN2 (test_num_put, char, char*);
 
    // std::locale::time category
    FUN2 (test_time_get, char, std::istreambuf_iterator<char>);
    FUN2 (test_time_get, char, const char*);
    FUN2 (test_time_put, char, std::ostreambuf_iterator<char>);
    FUN2 (test_time_put, char, char*);
 
    // std::locale::messages category
    FUN1 (test_messages, char);
 
#ifndef _RWSTD_NO_WCHAR_T
 
    // same as above but for wchar_t
    test_have_use_facet<wchar_t> ();
    test_convenience_funs<wchar_t> ();
    test_facets<wchar_t> ();
 
    FUN1 (test_collate, wchar_t);
 
    FUN1 (test_ctype, wchar_t);
    FUN1 (test_codecvt, wchar_t);
 
    FUN1 (test_moneypunct, wchar_t);
    FUN2 (test_money_get, wchar_t, std::istreambuf_iterator<wchar_t>);
    FUN2 (test_money_get, wchar_t, const wchar_t*);
    FUN2 (test_money_put, wchar_t, std::ostreambuf_iterator<wchar_t>);
    FUN2 (test_money_put, wchar_t, wchar_t*);
 
    FUN1 (test_numpunct, wchar_t);
    FUN2 (test_num_get, wchar_t, std::istreambuf_iterator<wchar_t>);
    FUN2 (test_num_get, wchar_t, const wchar_t*);
    FUN2 (test_num_put, wchar_t, std::ostreambuf_iterator<wchar_t>);
    FUN2 (test_num_put, wchar_t, wchar_t*);
 
    FUN2 (test_time_get, wchar_t, std::istreambuf_iterator<wchar_t>);
    FUN2 (test_time_get, wchar_t, const wchar_t*);
    FUN2 (test_time_put, wchar_t, std::ostreambuf_iterator<wchar_t>);
    FUN2 (test_time_put, wchar_t, wchar_t*);
 
    FUN1 (test_messages, wchar_t);
 
#endif   // _RWSTD_NO_WCHAR_T
 
    // test facet specializations on character types other than char and wchar_t
    // and iterator types other than istreambuf_iterator and ostreambuf_iterator
    // as per requirements in Table 52
 
    FUN2 (test_money_get, UDC, std::istreambuf_iterator<UDC>);
    FUN2 (test_money_get, UDC, const UDC*);
 
    FUN2 (test_money_put, UDC, std::ostreambuf_iterator<UDC>);
    FUN2 (test_money_put, UDC, UDC*);
 
    FUN2 (test_num_get, UDC, std::istreambuf_iterator<UDC>);
    FUN2 (test_num_get, UDC, const UDC*);
 
    FUN2 (test_num_put, UDC, std::ostreambuf_iterator<UDC>);
    FUN2 (test_num_put, UDC, UDC*);
 
    FUN2 (test_time_get, char, const char*);
    FUN2 (test_time_put, char, char*);
 
    return 0;
}
 
/* extern */ int
main (int argc, char* argv [])
{
    return rw_test (argc, argv, __FILE__,
                    "lib.locales", "header <locale> synopsis",
                    run_test, "|-enable-posix# ", &opt_enable_posix);
}