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

 *

 * 22.locale.num.put.cpp - tests exercising the std::num_put facet

 *

 * $Id: 22.locale.num.put.cpp 290034 2005-09-19 00:48:21Z sebor $

 *

 ***************************************************************************

 *

 * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave

 * Software division. Licensed 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.

 * 

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

#ifdef __GNUG__

   // prevent gcc -Wshadow warnings for convenience types

#  define ushort __rw_ushort

#  define uint   __rw_uint

#  define ulong  __rw_ulong

#  include <sys/types.h>

#  undef ushort

#  undef uint

#  undef ulong

#endif   // __GNUG__

#include <ios>

#include <locale>

#include <cerrno>    // for ERANGE, errno

#include <cfloat>    // for floating limits macros

#include <climits>   // for integral limits macros

#include <clocale>   // for LC_NUMERIC, setlocale()

#include <cstdio>    // for sprintf()

#include <cstdlib>   // for mbstowcs()

#include <any.h>         // for TOSTR()

#include <cmdopt.h>      // for rw_enabled

#include <driver.h>      // for rw_test

#include <localedef.h>   // for rw_locales

#include <valcmp.h>      // for rw_equal

#include"std_log_result.h"

#define LOG_FILENAME_LINE __FILE__, __LINE__

int failures=0;

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

//#if 0

// set by the command line option handler in response to:

static int rw_opt_enable_num_get = 0;   // --enable-num_get

static int rw_opt_no_errno       = 0;   // --no-errno

static int rw_opt_no_grouping    = 0;   // --no-grouping

static int rw_opt_no_widen       = 0;   // --no-widen

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

// replacement ctype facet

template <class charT>

struct Ctype: std::ctype<charT>

{

    typedef std::ctype<charT> Base;

    typedef typename Base::char_type char_type;

    static int n_widen_;

    Ctype (): Base (0, 0, 1) { }

    virtual char_type do_widen (char c) const {

        ++n_widen_;

        switch (c) {

        case '0': c = '9'; break;

        case '1': c = '8'; break;

        case '2': c = '7'; break;

        case '3': c = '6'; break;

        case '4': c = '5'; break;

        case '5': c = '4'; break;

        case '6': c = '3'; break;

        case '7': c = '2'; break;

        case '8': c = '1'; break;

        case '9': c = '0'; break;

        default: break;

        }

        return char_type (c);

    }

    virtual const char_type*

    do_widen (const char *lo, const char *hi, char_type *dst) const {

        return Base::do_widen (lo, hi, dst);

    }

};

template <class charT>

int Ctype<charT>::n_widen_;

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

// replacement numpunct facet

template <class charT>

struct Punct: std::numpunct<charT>

{

    typedef typename std::numpunct<charT>::char_type   char_type;

    typedef typename std::numpunct<charT>::string_type string_type;

    static char_type        decimal_point_;

    static char_type        thousands_sep_;

    static const char      *grouping_;

    static const char_type *truename_;

    static const char_type *falsename_;

    static int n_objs_;            // number of facet objects in existence

    static int n_thousands_sep_;   // number of calls to do_thousands_sep()

    Punct (std::size_t ref = 0)

        : std::numpunct<charT>(ref) {

        ++n_objs_;

    }

    ~Punct () {

        --n_objs_;

    }

    virtual char_type do_decimal_point () const {

        return decimal_point_;

    }

    virtual std::string do_grouping () const {

        return grouping_;

    }

    virtual char_type do_thousands_sep () const {

        ++n_thousands_sep_;

        return thousands_sep_;

    }

    virtual string_type do_truename () const {

        return truename_ ? string_type (truename_) : string_type ();

    }

    virtual string_type do_falsename () const {

        return falsename_ ? string_type (falsename_) : string_type ();

    }

};

template <class charT>

const char* Punct<charT>::grouping_ = "";

template <class charT>

typename Punct<charT>::char_type Punct<charT>::decimal_point_ = '.';

template <class charT>

typename Punct<charT>::char_type Punct<charT>::thousands_sep_ = ',';

template <class charT>

const typename Punct<charT>::char_type* Punct<charT>::truename_;

template <class charT>

const typename Punct<charT>::char_type* Punct<charT>::falsename_;

template <class charT>

int Punct<charT>::n_thousands_sep_;

template <class charT>

int Punct<charT>::n_objs_;

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

template <class charT>

struct Ios: std::basic_ios<charT>

{

    Ios () { this->init (0); }

};

template <class charT>

struct NumGet: std::num_get<charT, const charT*> { NumGet () { } };

template <class charT>

struct NumPut: std::num_put<charT, charT*>

{

    typedef std::num_put<charT, charT*> Base;

    typedef typename Base::char_type    char_type;

    typedef typename Base::iter_type    iter_type;

    enum {

        test_bool, test_short, test_ushort, test_int, test_uint,

        test_long, test_ulong, test_llong, test_ullong,

        test_pvoid, test_float, test_double, test_ldouble

    };

    static int ncalls_ [13];

    NumPut (std::size_t ref = 0): Base (ref) { }

#ifndef _RWSTD_NO_BOOL

    virtual iter_type

    do_put (iter_type it, std::ios_base &f, char_type fill, bool v) const {

        ++ncalls_ [test_bool];

        return Base::do_put (it, f, fill, v);

    }

#endif   // _RWSTD_NO_BOOL

    virtual iter_type

    do_put (iter_type it, std::ios_base &f, char_type fill, long v) const {

        ++ncalls_ [test_long];

        return Base::do_put (it, f, fill, v);

    }

    virtual iter_type

    do_put (iter_type it, std::ios_base &f, char_type fill,

            unsigned long v) const {

        ++ncalls_ [test_ulong];

        return Base::do_put (it, f, fill, v);

    }

#ifdef _RWSTD_LONG_LONG

    // provided as an extension unless _RWSTD_NO_LONG_LONG is #defined

    virtual iter_type

    do_put (iter_type it, std::ios_base &f, char_type fill,

            unsigned _RWSTD_LONG_LONG v) const {

        ++ncalls_ [test_ullong];

        return Base::do_put (it, f, fill, v);

    }

    // provided as an extension unless _RWSTD_NO_LONG_LONG is #defined

    virtual iter_type

    do_put (iter_type it, std::ios_base &f, char_type fill,

            _RWSTD_LONG_LONG v) const {

        ++ncalls_ [test_llong];

        return Base::do_put (it, f, fill, v);

    }

#endif   // _RWSTD_LONG_LONG

    virtual iter_type

    do_put (iter_type it, std::ios_base &f, char_type fill, double v) const {

        ++ncalls_ [test_double];

        return Base::do_put (it, f, fill, v);

    }

#ifndef __SYMBIAN32__

#ifndef _RWSTD_NO_LONG_DOUBLE

    virtual iter_type

    do_put (iter_type it, std::ios_base &f, char_type fill,

            long double v) const {

        ++ncalls_ [test_ldouble];

        return Base::do_put (it, f, fill, v);

    }

#endif 

#endif   // _RWSTD_NO_LONG_DOUBLE

    virtual iter_type

    do_put (iter_type it, std::ios_base &f, char_type fill,

            const void *v) const {

        ++ncalls_ [test_pvoid];

        return Base::do_put (it, f, fill, v);

    }

};

// explicit initialization of the static array below used

// to work around a SunPro 5.4 bug (PR #27293)

template <class charT>

/* static */ int NumPut<charT>::ncalls_ [13] = { 0 };

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

template <class charT, class T>

void do_test (charT           /* dummy */,

              const char     *cname,    // charT name

              const char     *tname,    // T name

              int             lineno,   // line number

              T               val,      // value to format

              int             flags,    // ios flags

              std::streamsize prec,     // precision

              std::streamsize width,    // field width

              char            fill,     // fill character

              const char     *grouping, // grouping string

              const char     *str,      // expected output

              int             err_expect = -1,   // expected iostate

              T val_expect = T ()       /* expected num_get result */)

{

    if (!rw_enabled (lineno)) {

        rw_note (0, __FILE__, __LINE__, "test on line %d disabled", lineno);

        return;

    }

    // create a distinct punctuation facet for each iteration to make sure

    // any data cached in between successive calls to the facet's public

    // member functions are flushed

    const Punct<charT> pun (1);

    Ios<charT> ios;

    NumPut<charT> np;

    ios.imbue (std::locale (ios.getloc (), (const std::numpunct<charT>*)&pun));

    ios.flags (std::ios_base::fmtflags (flags));

    ios.precision (prec);

    ios.width (width);

    pun.grouping_ = grouping;

//#if defined (_RWSTD_LDBL_MAX_10_EXP)

//    charT buf [_RWSTD_LDBL_MAX_10_EXP + 2] = { 0 };

//#else   // if !defined (_RWSTD_LDBL_MAX_10_EXP)

    //charT buf [4096] = { 0 };

    charT buf [512] = { 0 };

//#endif   // _RWSTD_LDBL_MAX_10_EXP

    const charT* const bufend = np.put (buf, ios, fill, val);

    // verify 22.2.2.2.2, p21

    if (ios.width ()) {

        static int width_fail = 0;

        // fail at most once for each specialization

        #ifndef __SYMBIAN32__

        rw_assert (!width_fail++, 0, lineno,

                   "%line d: num_put<%s>::put (..., %s = %s) "

                   "failed to reset width from %d; width() = %d",

                   __LINE__, cname, tname, TOSTR (val),

                   TOSTR (buf), width, ios.width ());

       #else

        {

           if(width_fail++)

           {

            failures++;

            std_log(LOG_FILENAME_LINE,"Reason:Failing") ;

             }

        }

        #endif           

    }

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

    if (str) {

        char cbuf [sizeof buf / sizeof *buf] = { '\0' };

        if ('%' == *str) {

            std::sprintf (cbuf, str, val);

            str = cbuf;

#if defined (_WIN32) || defined (_WIN64)

            std::size_t len = std::strlen (str);

            if (   ('e' == cbuf [len - 5] || 'E' == cbuf [len - 5])

                && ('-' == cbuf [len - 4] || '+' == cbuf [len - 4])

                && ('0' == cbuf [len - 3])) {

                cbuf [len - 3] = cbuf [len - 2];

                cbuf [len - 2] = cbuf [len - 1];

                cbuf [len - 1] = cbuf [len];

            }

#endif   // _WIN{32,64}

        }

        #ifndef __SYMBIAN32__

        // compare output produced by num_put with that produced by printf()

        rw_assert (0 == rw_strncmp (buf, str), 0, lineno,

                   "line %d: num_put<%s>::put (..., %s = %s) "

                   "wrote %{*Ac}, expected %{*Ac}, "

                   "flags = %{If}, precision = %d"

                   "%{?}, grouping = \"%#s\"%{;}",

                   __LINE__, cname, tname, TOSTR (val),

                   sizeof *buf, buf, sizeof *str, str,

                   flags, prec,

                   grouping && *grouping, grouping);

        #else

         {

         if(0 != rw_strncmp (buf, str)){

          failures++;

          std_log(LOG_FILENAME_LINE,"Reason: Failing");}

         } 

         #endif  // __SYMBIAN32__    

    }

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

#ifndef NO_NUM_GET

    if (!rw_opt_enable_num_get)

        return;

    // skip negative precision (extension requiring special treatment)

    if (prec < 0)

        return;

    const charT *next = buf;

    // skip leading fill characters (if any)

    for ( ; *next == fill; ++next);

    // find the first non-fill character if it exists

    const charT *last = next;

    for ( ; *last && *last != fill; ++last);

    for ( ; *last && *last == fill; ++last);

    // do not perform extraction if there are any fill characters

    // in the middle of output (they serve as punctuators and break

    // up the input sequence)

    if (next != last && *last)

        return;

    // do not perform extraction if the fill character is the minus

    // sign, the plus sign, the thousands separator, the decimal point,

    // or a digit

    if (   '-' == fill

        || '+' == fill

        || pun.thousands_sep_ == fill

        || pun.decimal_point_ == fill

        || fill >= '0' && fill <= '9')

        return;

    // do not perform extraction if there is no data to extract

    // (unless this is an extraction-only test)

    if (!*next && str)

        return;

    NumGet<charT> ng;

    T x = T ();

    std::ios_base::iostate err = std::ios_base::goodbit;

    if (-1 == err_expect) {

        // lwg issue 17: special treatment for bool:

        // The in iterator is always left pointing one position beyond

        // the last character successfully matched. If val is set, then

        // err is set to str.goodbit; or to str.eofbit if, when seeking

        // another character to match, it is found that (in==end). If

        // val is not set, then err is set to str.failbit; or to

        // (str.failbit|str.eofbit) if the reason for the failure was

        // that (in==end). [Example: for targets true:"a" and false:"abb",

        // the input sequence "a" yields val==true and err==str.eofbit;

        // the input sequence "abc" yields err=str.failbit, with in ending

        // at the 'c' element. For targets true:"1" and false:"0", the

        // input sequence "1" yields val==true and err=str.goodbit. For

        // empty targets (""), any input sequence yields err==str.failbit.

        // --end example]

        err_expect = T (1) == T (2) && flags & std::ios::boolalpha

            ? std::ios::goodbit

            : last == bufend && last [-1] != fill

            ? std::ios::eofbit : std::ios::goodbit;

        val_expect = val;

    }

    last = ng.get (next, bufend, ios, err, x);

#ifndef __SYMBIAN32__

    // verify the state

    rw_assert (err == err_expect, 0, lineno,

               "line %d: num_get<%s>::get (%s, ..., %s&) "

               "flags = %{If}, "

               "%{?}grouping = \"%#s\", %{;}"

               "iostate = %{Is}, expected %{Is}",

               __LINE__, cname,

               TOSTR (next), tname,

               flags,

               grouping && *grouping, grouping,

               err, err_expect);

    // verify the parsed value

    rw_assert (rw_equal (x, val_expect), 0, lineno,

               "line %d: num_get<%s>::get (%s, ..., %s&) got %s, "

               "expected %s, flags = %{If}, "

               "%{?}grouping = \"%#s\", %{;}",

               __LINE__, cname,

               TOSTR (next), tname,

               TOSTR (x), TOSTR (val_expect),

               flags,

               grouping && *grouping, grouping);

  #else

   {

   if(err != err_expect)

     {

     failures++;

     std_log(LOG_FILENAME_LINE,"Reason:Failing");

     }

   if(!rw_equal (x, val_expect))

     {

     failures++;

     std_log(LOG_FILENAME_LINE,"Reason:Failing");

     }

   }             

#endif//__SYMBIAN32__