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

 *

 * locale.money.put.cpp - tests exercising the std::money_get facet

 *

 * $Id: 22.locale.money.get.cpp 279135 2005-09-06 21:50:57Z 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.

 * 

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

#include <ios>

#include <locale>

#include <cstdio>    // for sscanf()

#include <cstdlib>   // for mbstowcs(), wcstombs()

#include <cstring>   // for strcat(), strlen()

#include <cmdopt.h>

#include <driver.h>

#include <valcmp.h>

#ifdef __SYMBIAN32__

#include<assert.h>

#include<sstream>

#include<iterator>

#include<istream>

#include"std_log_result.h"

#define LOG_FILENAME_LINE __FILE__, __LINE__

int failures=0;

#endif 

using namespace std;

#ifndef _RWSTD_NO_LONG_DOUBLE

#  define LongDouble long double

#else

#  define LongDouble   double

#  define rw_ldblcmp   rw_dblcmp

#endif   // _RWSTD_NO_LONG_DOUBLE

#define	SAME_AS_UNIX_COMMENT	

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

// set to non-zero value when the basic_string overloads

// of moneY-put::put() shouldn't be exercised

static int no_basic_string;

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

// 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_;

int foo ()

{

    static int i;

    return ++i;

}

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

template <class charT, bool Intl>

struct Punct: std::moneypunct<charT, Intl>

{

    typedef std::moneypunct<charT, Intl> Base;

    typedef typename Base::char_type     char_type;

    typedef typename Base::string_type   string_type;

    static char_type                 decimal_point_;

    static char_type                 thousands_sep_;

    static const char               *grouping_;

    static const char_type          *curr_symbol_;

    static const char_type          *positive_sign_;

    static const char_type          *negative_sign_;

    static std::money_base::pattern  format_ [2];

    static int                       frac_digits_;

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

    Punct (std::size_t ref): Base (ref) { }

    char_type do_decimal_point () const {

        return decimal_point_;

    }

    int do_frac_digits () const {

        return frac_digits_;

    }

    virtual string_type do_curr_symbol () const {

        foo ();

        return curr_symbol_ ? curr_symbol_ : string_type ();

    }

    virtual std::string do_grouping () const {

        return grouping_ ? std::string (grouping_) : std::string ();

    }

    virtual char_type do_thousands_sep () const {

        ++n_thousands_sep_;

        return thousands_sep_;

    }

    virtual string_type do_positive_sign () const {

        return positive_sign_ ? positive_sign_ : string_type ();

    }

    virtual string_type do_negative_sign () const {

        return negative_sign_ ? negative_sign_ : string_type ();

    }

    virtual std::money_base::pattern do_pos_format () const {

        return format_ [0];

    }

    virtual std::money_base::pattern do_neg_format () const {

        return format_ [1];

    }

};

template <class charT, bool Intl>

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

template <class charT, bool Intl>

typename Punct<charT, Intl>::char_type

Punct<charT, Intl>::decimal_point_ = '.';

template <class charT, bool Intl>

typename Punct<charT, Intl>::char_type

Punct<charT, Intl>::thousands_sep_ = ',';

template <class charT, bool Intl>

const typename Punct<charT, Intl>::char_type*

Punct<charT, Intl>::curr_symbol_;

template <class charT, bool Intl>

const typename Punct<charT, Intl>::char_type*

Punct<charT, Intl>::positive_sign_;

template <class charT, bool Intl>

const typename Punct<charT, Intl>::char_type*

Punct<charT, Intl>::negative_sign_;

template <class charT, bool Intl>

std::money_base::pattern Punct<charT, Intl>::format_[2] = {

    { { // positive

        std::money_base::symbol, std::money_base::sign,

        std::money_base::none,   std::money_base::value

    } },

    { { // negative

        std::money_base::symbol, std::money_base::sign,

        std::money_base::none,   std::money_base::value

    } }

};

template <class charT, bool Intl>

int Punct<charT, Intl>::frac_digits_;

template <class charT, bool Intl>

int Punct<charT, Intl>::n_thousands_sep_;

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

template <class charT>

struct Ios: std::basic_ios<charT>

{

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

};

template <class charT>

struct MoneyGet: std::money_get<charT, const charT*> { };

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

const char* narrow (char *dst, const char *src)

{

    if (src == dst || !src || !dst)

        return src;

  #ifdef __SYMBIAN32__

    memcpy (dst, src, strlen (src) + 1);

  #else  

    std::memcpy (dst, src, std::strlen (src) + 1);

  #endif  

    return dst;

}

const char* widen (char *dst, const char *src)

{

    if (src == dst || !src || !dst)

         return src;

  #ifdef __SYMBIAN32__

    memcpy (dst, src, strlen (src) + 1);

   #else  

    std::memcpy (dst, src, std::strlen (src) + 1);

#endif 

    return dst;

}

const char* narrow (char *dst, const wchar_t *src)

{

    static char buf [4096];

    if (!src)

        return 0;

    if (!dst)

        dst = buf;

  #ifdef __SYMBIAN32__

    size_t len = wcslen (src);

  #else  

    std::size_t len = std::wcslen (src);

  #endif

    _RWSTD_ASSERT (len < sizeof buf);

  #ifdef __SYMBIAN32__

   len = wcstombs (dst, src, sizeof buf / sizeof *buf);

  #else 

    len = std::wcstombs (dst, src, sizeof buf / sizeof *buf);

  #endif

    if (std::size_t (-1) == len)

        *dst = 0;

    return dst;

}

const wchar_t* widen (wchar_t *dst, const char *src)

{

    static wchar_t buf [4096];

    if (!src)

        return 0;

    if (!dst)

         dst = buf;

   #ifdef __SYMBIAN32__

    size_t len = strlen (src);

   #else    

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

   #endif 

    _RWSTD_ASSERT (len < sizeof buf /sizeof *buf);

    #ifdef __SYMBIAN32__

      len =mbstowcs (dst, src, sizeof buf / sizeof *buf); 

    #else  

    len = std::mbstowcs (dst, src, sizeof buf / sizeof *buf);

    #endif

    if (std::size_t (-1) == len)

        *dst = 0;

    return dst;

}

//#ifndef __SYMBIAN32__

template <class charT>

void do_test (charT       which,   // which overload to exercise

              const char *cname,   // the name of the charT type

              const char *tname,   // the name of the floating point type

              int         lineno,  // line number

              LongDouble  val,     // the expected extracted value

              const char *str,     // the sequence to extract from

              int         consumed = -1,   // expected number extractions

              int         flags = 0,       // initial ios flags

              int         err_expect = -1, // expected final state

              int         frac_digits = 0, // fractional digits

              const char *fmat = 0,        // money_base::pattern

              const char *cursym = 0,      // currency symbol

              const char *grouping = "",   // grouping string

              bool intl = false)           // international?

/*#else

template <class charT>

 void do_test (charT       which,   // which overload to exercise

              const char *cname,   // the name of the charT type

              const char *tname,   // the name of the floating point type

              int         lineno,  // line number

              basic_string<charT>&  val,     // the expected extracted value

              const char *str,     // the sequence to extract from

              int         consumed = -1,   // expected number extractions

              int         flags = 0,       // initial ios flags

              int         err_expect = -1, // expected final state

              int         frac_digits = 0, // fractional digits

              const char *fmat = 0,        // money_base::pattern

              const char *cursym = 0,      // currency symbol

              const char *grouping = "",   // grouping string

              bool intl = false)           // international?

#endif              */

 {

    if (!rw_enabled (lineno)) {

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

        return;

    }

    if (!fmat) {

        // if fmat isn't set, use the default pattern

        static const std::money_base::pattern pat = { {

            std::money_base::symbol, std::money_base::sign,

            std::money_base::none,   std::money_base::value

        } };

        fmat = pat.field;

    }

    // take care to initialize Punct static data before installing

    // the facet in case locale or the base facet calls the overridden

    // virtuals early to cache the results

    Punct<charT, false>::format_ [1].field [0] = fmat [0];

    Punct<charT, false>::format_ [1].field [1] = fmat [1];

    Punct<charT, false>::format_ [1].field [2] = fmat [2];

    Punct<charT, false>::format_ [1].field [3] = fmat [3];

    // zero out positive format (not used by money_get)

    Punct<charT, false>::format_ [0] = std::money_base::pattern ();

    charT wcursym_buf [40];

    Punct<charT, false>::curr_symbol_ = widen (wcursym_buf, cursym);

    Punct<charT, false>::grouping_    = grouping;

    Punct<charT, false>::frac_digits_ = frac_digits;

    Ios<charT> io;

    MoneyGet<charT> mg;

    // create distinct punctuation facets for each iteration to make sure

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

    // member functions are flushed

    if (intl) {

        const std::moneypunct<charT, true> *pf = new Punct<charT, true>(0);

        io.imbue (std::locale (io.getloc (), pf));

    }

    else {

        const std::moneypunct<charT, false> *pf = new Punct<charT, false>(0);

        io.imbue (std::locale (io.getloc (), pf));

    }

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

    // widen input string if necessary

   //#ifndef __SYMBIAN32__

    charT wstr_buf [4096];

   // const charT *next = widen (wstr_buf, str);

   // const charT *last;

   const charT *next = widen (wstr_buf, str);

   charT *last;

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

   typedef basic_string<charT> stringbuf;

   #ifndef __SYMBIAN32__

    LongDouble x;

   #else 

   stringbuf x;

   #endif

   if (0 == which) {   // exercise get (..., long double)

        //#ifndef __SYMBIAN32__

        last =(charT*)(next + (std::char_traits<charT>::length (next)));

       // long double x = 0;

        last =(charT*) mg.get (next, last, intl, io, err, x);

        /*#else

        string x; 

            last(mg.get (next, last, intl, io, err, x));

        #endif  */

        if (-1 == err_expect)

            err_expect = err;

        const int success =

            !(-1 != consumed && last - next != consumed || err != err_expect);

        rw_assert (success, __FILE__, lineno,

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

                   "ate %d, expected %d, frac_digits = %d, "

                   "flags = %{If}, grouping = %#s, pattern = %{LM}, "

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

                   cname, next, intl, tname,

                   last - next, consumed, frac_digits,

                   flags, grouping, fmat,

                   err, err_expect);

      #ifndef __SYMBIAN32__

        rw_assert (2 > rw_ldblcmp (x, val), __FILE__, lineno,

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

                   "got %Lg, expected %Lg, frac_digits = %d, "

                   "flags = %{If}s, grouping = %#s, pattern = %{LM}, "

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

                   cname, next, intl, tname,

                   x, val, frac_digits,

                   flags, grouping, fmat,

                   err, err_expect);

      #else

        if(!(2>rw_strcmp(x,val)))

        { 

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason : Failing");

         }

      #endif    

    }

    else {   // exercise get (..., string_type)

        static const charT initial[] = { '*', '*', '*', '\0' };

        typename std::money_get<charT, const charT*>::string_type bs (initial);

        last =(charT*)(next + std::char_traits<charT>::length (next));

        last =(charT*)mg.get (next, last, intl, io, err, bs);

        int success =

            !(-1 != consumed && last - next != consumed || err != err_expect);

        #ifndef __SYMBIAN32__

        rw_assert (success, __FILE__, lineno,

                   "money_get<%s>::get (%s, ..., %d, ..., "

                   "basic_string<%s>&), ate %d, expected %d, "

                   "frac_digits = %d, flags = %{If}, grouping = %#s"

                   ", format = %{LM}, state = %{Is}, expected = %{Is}",

                   cname, next, intl,

                   cname, last - next, consumed,

                   frac_digits, flags, grouping,

                   fmat, err, err_expect);

        #else

          if(!success)   

          {

            failures++;

            std_log(LOG_FILENAME_LINE,"Reason:Failing");

            }

         #endif   

        if (success) {

            char narrow_buf [4096];

            narrow (narrow_buf, bs.c_str ());

            LongDouble x = 0;

            // prevent gcc warning: ANSI C does not support

            // the `L' length modifier

            const char fmt[] = "%" _RWSTD_LDBL_PRINTF_PREFIX "g";

            #ifdef __SYMBIAN32__

             int n = sscanf (narrow_buf, fmt, &x);           

            #else

            int n = std::sscanf (narrow_buf, fmt, &x);

            #endif

            success = 

                !(   err_expect & std::ios::failbit && !*grouping

                  && (1 == n || bs != initial)

                  || !(err_expect & std::ios::failbit)

                  && 1 < rw_ldblcmp (x, val));

            #ifndef __SYMBIAN32__

            rw_assert (success, __FILE__, lineno,

                       "money_get<%s>::get (%s, ..., %d, ..., "

                       "basic_string<%s>&), got %s, expected %Lg, "

                       "frac_digits = %d, flags = %{If}, grouping = %#s,"

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

                       cname, next, intl,

                       cname, bs.c_str (), val,

                       frac_digits, flags, grouping,

                       fmat, err, err_expect);

             #else

              if(!success)

              {

                failures++;

                std_log(LOG_FILENAME_LINE,"Reason: Failing");

                }

              #endif  

        }

    }

}

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