22.locale.numpunct.cpp

Go to the documentation of this file.

 
#include <rw/_defs.h>
 
#if defined (__IBMCPP__) && !defined (_RWSTD_NO_IMPLICIT_INCLUSION)
// Disable implicit inclusion to work around
// a limitation in IBM's VisualAge 5.0.2.0 (see PR#26959)
 
#  define _RWSTD_NO_IMPLICIT_INCLUSION
#endif
 
 
#include <clocale>   // for struct lconv, setlocale()
#include <cstdio>    // for sprintf()
#include <cstdlib>   // for getenv()
#include <cstring>   // for strcmp()
#include <locale>
 
#include <rw_driver.h>
#include <rw_environ.h>
#include <rw_locale.h>
 
 
template <class charT>
void run_test (charT*);
 
template <class charT>
void check_decimal_point (charT, const char*, const std::locale*);
 
template <class charT>
void check_thousands_sep (charT, const char*, const std::locale*);
 
template <class charT>
void check_grouping (charT, const char*, const std::string&, const std::locale*);
 
template <class charT>
void check_falsename (const std::basic_string<charT>&,
                      const char*, const std::locale*);
 
template <class charT>
void check_truename (const std::basic_string<charT>&,
                     const char*, const std::locale*);
 
template <class charT>
bool check_numpunct (charT, const char*, const char*, const std::locale*);
 
 
 
template <class charT>
void run_test (charT, const char *tname)
{
    rw_info (0, 0, __LINE__, "classic \"C\" locale");
 
    // create a copy of the classic ("C") locale
    std::locale *loc = new std::locale (std::locale::classic ());
 
    // verify (at compile time) that _byname facets can be used
    // to specialize use_facet() and has_facet()
    typedef std::numpunct_byname<charT> NumpunctByname;
 
    if (_STD_HAS_FACET (NumpunctByname, *loc))
        _STD_USE_FACET (NumpunctByname, *loc);
 
    // verify values as per 7.4 of C89, and 7.11, p2 of C99
    check_decimal_point (charT ('.'), tname, loc);
 
    // verify 22.2.3.1.2, p2
    check_thousands_sep (charT (','), tname, loc);
    check_grouping (charT (), tname, "", loc);
 
    const charT fn[] = { 'f', 'a', 'l', 's', 'e', '\0' };
    const charT tn[]  = { 't', 'r', 'u', 'e', '\0' };
 
    check_falsename (std::basic_string<charT>(fn), tname, loc);
    check_truename (std::basic_string<charT>(tn), tname, loc);
 
    delete loc;
    loc = 0;
 
    // verify that the facet can be safely used on its own, without
    // first having to be installed in a locale and retrieved using
    // use_facet
 
    check_decimal_point (charT ('.'), tname, loc);
    check_thousands_sep (charT (','), tname, loc);
    check_grouping (charT (), tname, "", loc);
 
    check_falsename (std::basic_string<charT>(fn), tname, loc);
    check_truename (std::basic_string<charT>(tn), tname, loc);
 
    // exercise the native locale (affected by the environment
    // variables LANG, LC_ALL, LC_NUMERIC, etc.)
    check_numpunct (charT (), tname, "", loc);   // native locale
 
    // the name of the first non-C (and non-POSIX) locale
    const char *first_non_c = 0;
 
    // exercise named locales (including "C" and "POSIX")
    for (const char* s = rw_locales (); *s; s += std::strlen (s) + 1) {
        if (check_numpunct (charT (), tname, s, loc))
            if (   !first_non_c
                && std::strcmp ("C", s)
                && std::strcmp ("POSIX", s))
            first_non_c = s;
    }
 
    // verify that numpunct behaves correctly when LC_ALL is set
    // to the name of the (non-C, non-POSIX) locale
    char envvar [80];
    std::sprintf (envvar, "LC_ALL=%s", first_non_c);
    rw_putenv (envvar);
    check_numpunct (charT (), tname, "", loc);
}
 
 
char widen (char, const char *s)
{
    return *s;
}
 
#ifndef _RWSTD_NO_WCHAR_T
 
wchar_t widen (wchar_t, const char *s)
{
    wchar_t wc = 0;
 
#  ifndef _RWSTD_NO_MBTOWC
 
    const int n = s && *s ? std::mbtowc (&wc, s, std::strlen (s)) : 0;
 
#  else   // if defined (_RWSTD_NO_MBTOWC)
 
    const int n = 1;
 
    wc = s ? wchar_t (_RWSTD_STATIC_CAST (unsigned char, *s)) : 0;
 
#  endif   // _RWSTD_NO_MBTOWC
 
    return n > 0 ? wc : n ? -1 : 0;
}
 
#endif   // _RWSTD_NO_WCHAR_T
 
 
template <class charT>
bool check_numpunct (charT,
                     const char        *tname,
                     const char        *locname,
                     const std::locale *loc)
{
    // (try to) set the global C locale
    const char *tmploc = std::setlocale (LC_ALL, locname);
    if (!tmploc)
        return false;
 
    // future setlocale() calls may change tmploc's value, so make a copy
    // (fixed-size char buf is clunky but avoids memory-leak potential)
    char locnamebuf [1024];
    RW_ASSERT ((std::strlen (tmploc) + 1) < sizeof locnamebuf);
    std::strcpy (locnamebuf, tmploc);
 
    _TRY {
 
        rw_info (0, 0, __LINE__,
                 "locale (%s) -> \"%s\"; LANG=%s, "
                 "LC_ALL=%s, LC_NUMERIC=%s",
                 locname, loc,
                 std::getenv ("LANG"),
                 std::getenv ("LC_ALL"),
                 std::getenv ("LC_NUMERIC"));
 
        // get a pointer to lconv
        const std::lconv *plconv = std::localeconv ();
 
        if (!plconv)
            return false;
 
        // copy important data; the contents of *plconv may
        // be overwritten by the call sto setlocale() below
        // note that decimal_point at al may be multbyte character
        // strings that need to be widened according to the rules
        // of the same locale
        const charT decimal_point = widen (charT (), plconv->decimal_point);
        const charT thousands_sep = widen (charT (), plconv->thousands_sep);
 
        const std::string grouping =
            plconv->grouping ? plconv->grouping : "";
 
        // reset to default locale given by LC_LANG
        std::setlocale (LC_ALL, "");
 
        loc = new std::locale (locname);
 
        // check that newly constructed locale matches
 
        if (   ('C' == locnamebuf [0] && '\0' == locnamebuf [1])
            || ('C' == locname [0] && '\0' == locname [1])
            || *loc == std::locale::classic ()) {
            // follow requirements in 22.2.3.1.2. p1, 2, and 3
            check_decimal_point (charT ('.'), tname, loc);
            check_thousands_sep (charT (','), tname, loc);
 
            check_grouping (charT (), tname, "", loc);
        }
        else {
            // cast to prevent sign extension between (signed) char and wchar_t
            // tmp guards against possibly passing along a "(nil)" pointer
            check_decimal_point (decimal_point, tname, loc);
            check_thousands_sep (thousands_sep, tname, loc);
            check_grouping (charT (), tname, grouping.c_str (), loc);
        }
 
        // FIXME: exercise falsename() and truename() in named locales
 
        delete loc;
        loc = 0;
    }
    _CATCH (...) {
        return false;
    }
    return true;
}
 
 
template <class charT>
void check_decimal_point (charT              expect,
                          const char        *tname,
                          const std::locale *loc)
{
    typedef std::numpunct<charT>    Punct;
    typedef std::char_traits<charT> Traits;
 
    const charT c = loc ?
          _STD_USE_FACET (Punct, *loc).decimal_point ()
        : Punct ().decimal_point ();
 
 
    rw_assert (Traits::eq (c, expect), 0, __LINE__,
               "numpunct<%s>::decimal_point() == %{#lc}, got %{#lc}",
               tname, expect, c);
}
 
 
template <class charT>
void check_thousands_sep (charT              expect,
                          const char        *tname,
                          const std::locale *loc)
{
    typedef std::numpunct<charT>    Punct;
    typedef std::char_traits<charT> Traits;
 
    const charT c = loc ?
          _STD_USE_FACET (Punct, *loc).thousands_sep ()
        : Punct ().thousands_sep ();
 
    rw_assert (Traits::eq (c, expect), 0, __LINE__,
               "numpunct<%s>::thousands_sep() == %{#lc}, got %{#lc}",
               tname, expect, c);
}
 
 
template <class charT>
void check_grouping (charT,
                     const char        *tname,
                     const std::string &expect,
                     const std::locale *loc)
{
    typedef std::numpunct<charT> Punct;
 
    const std::string s = loc ?
          _STD_USE_FACET (Punct, *loc).grouping ()
        : Punct ().grouping ();
 
    if (   s != expect
        && s.size () != expect.size () && s.size () && expect.size ()) {
 
        // if the grouping is not exactly the same as the expected result,
        // verify that the actual grouping is equivalent to the expected
        // one, e.g., that "\003\003" is equivalent to "\003"
 
        const std::string *lng  = s.size () > expect.size () ? &expect : &s;
        const std::string *shrt = s.size () < expect.size () ? &expect : &s;
 
        std::size_t i = shrt->size () - 1;
 
        for ( ; i != lng->size (); ++i)
            if ((*shrt) [shrt->size () - 1] != (*lng)[i])
                break;
 
        rw_assert (i == lng->size (), 0, __LINE__,
                   "numpunct<%s>::grouping() equivalent to %{#S}, got %{#S}",
                   tname, &expect, &s);
    }
    else
        rw_assert (s == expect, 0, __LINE__,
                   "numpunct<%s>::grouping() == %{#S}, got %{#S}",
                   tname, &expect, &s);
}
 
 
template <class charT>
void check_falsename (const std::basic_string<charT> &expect,
                      const char                     *tname,
                      const std::locale              *loc)
{
    typedef std::numpunct<charT> Punct;
 
    const std::basic_string<charT> s = loc ?
          _STD_USE_FACET (Punct, *loc).falsename ()
        : Punct ().falsename ();
 
    const int char_size = int (sizeof (charT));
 
    rw_assert (s == expect, 0, __LINE__,
               "numpunct<%s>::falsename() == %{#*S}, got %{#*S}",
               tname, char_size, &expect, char_size, &s);
}
 
 
template <class charT>
void check_truename (const std::basic_string<charT> &expect,
                     const char                     *tname,
                     const std::locale              *loc)
{
    typedef std::numpunct<charT> Punct;
 
    const std::basic_string<charT> s = loc ?
          _STD_USE_FACET (Punct, *loc).truename ()
        : Punct ().truename ();
 
    const int char_size = int (sizeof (charT));
 
    rw_assert (s == expect, 0, __LINE__,
               "numpunct<%s>::truename() == %{#*S}, got %{#*S}",
               tname, char_size, &expect, char_size, &s);
}
 
 
static int
run_test (int, char**)
{
    run_test (char (), "char");
 
#ifndef _RWSTD_WCHAR_T
 
    run_test (wchar_t (), "wchar_t");
 
#endif   // _RWSTD_WCHAR_T
 
    return 0;
}
 
 
int main (int argc, char *argv[])
{
    return rw_test (argc, argv, __FILE__,
                    "lib.locale.numpunct",
                    "", run_test,
                    "",
                    (void*)0);
}