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

 *

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

 *

 * $Id: 22.locale.money.put.cpp 279137 2005-09-06 21:53:26Z 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 sprintf()

#include <string>

#include <cmdopt.h>   // for rw_enabled()

#include <driver.h>   // for rw_test()

#include <valcmp.h>   // for rw_valcmp()

#include"std_log_result.h"

#define LOG_FILENAME_LINE __FILE__, __LINE__

int failures=0;

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

// set to non-zero value when grouping shouldn't be exercised

static int no_grouping;

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

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

static int no_basic_string;

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

using namespace std;

void char2wchar(char* pstr, wchar_t* pwstr, int size)

{

	//assume little endian

	if ( (!pstr) || (!pwstr) | (strlen(pstr)+1>= size) )

		return;

	int i = 0,j =0;

	int len = strlen(pstr);

	for(;i<=len;i++,j++)

	{

		pwstr[j] = pstr[i];

	}

}

void Helper_(void* array, int size,double val)

{

	if (size == 1)

    {

    	sprintf((char*)array,"%f",val);    	

    }

    else

    {

    	char str[100] = 

    	{

    		0

    	};

    	sprintf((char*)str,"%f",val);

    	char2wchar(str,(wchar_t*)array,100);

    }

}

template<class chtype>

basic_string<chtype>* GetLDasStr(double val)

{

    //convert val from long double to string or wstring based on instantiation

	chtype	str[100] = {0};	

	Helper_((void*)str,sizeof(chtype),val);

	basic_string<chtype> *strLD = new basic_string<chtype>(str);

	return strLD;

}

template <class charT, bool Intl>

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

{

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

    typedef typename std::moneypunct<charT>::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  pos_format_;

    static std::money_base::pattern  neg_format_;

    static int                       frac_digits_;

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

    Punct (): std::moneypunct<charT>(1) { }

    char_type do_decimal_point () const {

        return decimal_point_;

    }

    int do_frac_digits () const {

        return frac_digits_;

    }

    virtual string_type do_curr_symbol () const {

        return curr_symbol_ ? curr_symbol_ : string_type ();

    }

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

    }

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

        return neg_format_;

    }

};

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>::pos_format_ = { {

    std::money_base::symbol,

    std::money_base::sign,

    std::money_base::none,

    std::money_base::value

} };

template <class charT, bool Intl>

std::money_base::pattern

Punct<charT, Intl>::neg_format_ = { {

    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>::n_thousands_sep_;

template <class charT, bool Intl>

int

Punct<charT, Intl>::frac_digits_;

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

template <class charT>

struct Ios: std::basic_ios<charT>

{

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

};

template <class charT>

struct MoneyPut: std::money_put<charT, charT*> { };

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

bool test_neg_zero;

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

std::money_base::pattern

set_pattern (const char *format)

{

    std::money_base::pattern pat;

    for (unsigned i = 0; i != sizeof pat.field / sizeof *pat.field; ++i) {

        switch (format [i]) {

        case '\0': case '@': pat.field [i] = std::money_base::none; break;

        case '\1': case ' ': pat.field [i] = std::money_base::space; break;

        case '\2': case '$': pat.field [i] = std::money_base::symbol; break;

        case '\3': case '-': pat.field [i] = std::money_base::sign; break;

        case '\4': case '1': pat.field [i] = std::money_base::value; break;

        default:

            rw_error (0, __FILE__, __LINE__,

                      "test error: bad format specifier: '%c'", format [i]);

        }

    }

    return pat;

}

template <class charT>

int type_test (int         lineno,

               charT       /* unused */,

#ifdef	__SYMBIAN32__

				double val,

#else

               long double val /* value to format */,

#endif               

               const char *str /* expected result */,

               char        fill        = ' ',

               int         flags       = 0,

               int         frac_digits = 0,

               int         width       = 0,

               const char *format      = 0 /* pattern or printf() format */,

               const char *grouping    = 0)

{

    if (!rw_enabled (lineno)) {

           failures++;

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

	std_log(LOG_FILENAME_LINE,"test on line %d disabled", lineno);

        return 0;

    }

    static const char* const cname = 1 < sizeof (charT) ? "wchar_t" : "char";

    static int i = 0;   // assertion number per specialization of type_test()

    if (!i) {

        rw_info (0, 0, 0, "std::money_put<%s>::put(ostreambuf_iterator"

                 "<%s>, bool, ios_base, %s, long double)",

                 cname, cname, cname);

        rw_info (0, 0, 0, "std::money_put<%s>::put(ostreambuf_iterator"

                 "<%s>, bool, ios_base, %s, "

                 "const basic_string<%s>&))",

                 cname, cname, cname, cname);

    }

    //////////////////////////////////////////////////////////////////

    // exercise put (..., long double) overload

    int nfail = 0;   // number of failed assertions

    // unless 0, or unless it starts with '%', the `format' argument

    // is treated as a money_base::pattern string; otherwise the

    // default pattern is used

    // default format as in locale ("C")

    const char *fmt_pat = !format || *format == '%' ? "\2\3\4\0" : format;

    if (!grouping) {

        // default grouping as in locale ("C")

        grouping = "";

    }

    const Punct<charT, false> pun;

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

    pun.grouping_    = grouping;

    pun.frac_digits_ = frac_digits;

    if (val < 0.0) {

        pun.neg_format_ = set_pattern (fmt_pat);

        pun.pos_format_ = std::money_base::pattern ();

    }

    else if (val > 0.0) {

        pun.neg_format_ = std::money_base::pattern ();

        pun.pos_format_ = set_pattern (fmt_pat);

    }

    else {

        // 0.0 and -0.0

        pun.neg_format_ = set_pattern (fmt_pat);

        pun.pos_format_ = pun.neg_format_;

    }

    // ios-derived object to pass to the facet

    Ios<charT> ios;

    // money_put-derived object

    const MoneyPut<charT> mp;

    // install the moneypunct facet in a locale and imbue the latter

    // in the ios-derived object used by money_put

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

    ios.imbue (loc);

    // set the formatting flags and the width

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

    ios.width (std::streamsize (width));

    bool success;

    charT buf [256] = { 0 };

    if (rw_enabled ("long double")) {

#ifdef __SYMBIAN32__

	    basic_string<charT> *strLD = GetLDasStr<charT>(val);

    *mp.put (buf, false, ios, charT (fill), *strLD) = charT ();

	delete strLD;

#else

        // exercise 22.2.6.2.1, long double overload

     *mp.put (buf, false, ios, charT (fill), val) = charT ();

      rw_assert (0 == ios.width (), __FILE__, lineno,

                   "money_put<%s>::put (%#p, false, const ios_base&, "

                   "%{#c}, %LfL) reset width from %d",

                   cname, buf, fill, val, width);

#endif

          if(0 != ios.width ())

	  {

	   failures++;

	   std_log(LOG_FILENAME_LINE,"Failing");

	  }

        success = 0 == rw_strncmp (buf, str);

//#ifndef __SYMBIAN32__

     	if (!success)

            ++nfail;

        rw_assert (success, __FILE__, lineno,

                   "money_put<%s>::put (%#p, false, "

                   "const ios_base&, %{#c}, %LfL) == %{#s} got %{#s}; "

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

                   cname, buf,

                   fill, val, str, buf,

                   flags, grouping);

//#else

	if(!success)

	{

	  failures++;

	  std_log(LOG_FILENAME_LINE,"Failing");

	}

//#endif 

    }

    else {

        static int msg_issued;

        rw_note (msg_issued++, __FILE__, 0, "long double test disabled");

    }

    //////////////////////////////////////////////////////////////////

    // exercise put (..., const basic_string&) overload

    if (frac_digits < 0) {

        // do not perform string test(s) for negative values of frac_digits

        // (extension implemented only for the long double overload of put())

        ++i;

        return nfail;

    }

    if (no_basic_string) {

        rw_note (0, __FILE__, __LINE__,

                 "basic_string<%s> test on line %d disabled", lineno, cname);

        return nfail;

    }

    // zero out buffer

    std::char_traits<charT>::assign (buf, sizeof buf / sizeof *buf, charT ());

    // if the format string starts with a '%',

    // use it to format the floating point value

    if (!format || *format != '%')

        format = "%.0" _RWSTD_LDBL_PRINTF_PREFIX "f";

    char valbuf [256] = "";

    const std::size_t valbuflen = sprintf (valbuf, format, val);

    typedef std::char_traits<charT> Traits;

    typedef std::allocator<charT>   Allocator;

    const std::basic_string<charT, Traits, Allocator>

        valstr (valbuf, valbuf + valbuflen);

    // set width (reset by a previous call)

    ios.width (std::streamsize (width));

    // exercise 22.2.6.2.1, basic_string overload

    *mp.put (buf, false, ios, charT (fill), valstr) = charT ();

    success = 0 == rw_strncmp (buf, str);

    if (!success)

        ++nfail;

#ifndef __SYMBIAN32__

    rw_assert (success, __FILE__, lineno,

               "money_put<%s>::put (%#p, false, "

               "const ios_base&, %{#S}) == %{#s} got %{#s}; "

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

               cname, fill, &valstr, buf, str,

               flags, grouping);

#else

   if(!success)    

   {

    failures++;

    std_log(LOG_FILENAME_LINE,"Failing");

   }

#endif   

    ++i;

    return nfail;

}

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

// for convenience

#define Boolalpha   std::ios_base::boolalpha

#define Dec         std::ios_base::dec

#define Fixed       std::ios_base::fixed

#define Hex         std::ios_base::hex

#define Internal    std::ios_base::internal

#define Left        std::ios_base::left

#define Oct         std::ios_base::oct

#define Right       std::ios_base::right

#define Scientific  std::ios_base::scientific

#define Showbase    std::ios_base::showbase

#define Showpoint   std::ios_base::showpoint

#define Showpos     std::ios_base::showpos

#define Skipws      std::ios_base::skipws

#define Unitbuf     std::ios_base::unitbuf

#define Uppercase   std::ios_base::uppercase

#define Bin         std::ios_base::bin

#define Adjustfield std::ios_base::adjustfield

#define Basefield   std::ios_base::basefield

#define Floatfield  std::ios_base::floatfield

#define Nolock      std::ios_base::nolock

#define Nolockbuf   std::ios_base::nolockbuf

#define Eofbit      std::ios_base::eofbit

#define Failbit     std::ios_base::failbit

#define Goodbit     std::ios_base::goodbit

//#ifndef __SYMBIAN32__  // Error

template <class charT>

void ldbl_test (charT)

{

    static const charT curr_symbol1 [8] = { '$', '\0' };

    Punct<charT, false>::curr_symbol_   = curr_symbol1;

    Punct<charT, false>::decimal_point_ = ':';

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

    static const charT signs1[][4] = {

        // negative            positive

        { '~', '\0' }, { '\0', },

    };

    Punct<charT, false>::negative_sign_ = signs1 [0];

    Punct<charT, false>::positive_sign_ = signs1 [1];

    int ntried  = 0;

    int nfailed = 0;

#define T      __LINE__, charT ()

#define TEST   ++ntried, nfailed += type_test

    // enum part { none, space, symbol, sign, value };

    // no symbol, empty sign, default format

    std_log(LOG_FILENAME_LINE,"Test start");

    TEST (T,         0.,         "0", ' ');

    std_log(LOG_FILENAME_LINE,"Test end");

    std_log(LOG_FILENAME_LINE,"Test Start");

    TEST (T,         1.,         "1", ' ');

    std_log(LOG_FILENAME_LINE,"Test end");

    std_log(LOG_FILENAME_LINE,"Test Start");

    TEST (T,        12.,        "12", ' ');

    std_log(LOG_FILENAME_LINE,"Test end");

    std_log(LOG_FILENAME_LINE,"Test Start");

    TEST (T,       123.,       "123", ' ');

    std_log(LOG_FILENAME_LINE,"Test end");

    std_log(LOG_FILENAME_LINE,"Test Start");

    TEST (T,      1234.,      "1234", ' ');

    std_log(LOG_FILENAME_LINE,"Test end");

    std_log(LOG_FILENAME_LINE,"Test Start");

    TEST (T,     12345.,     "12345", ' ');

    std_log(LOG_FILENAME_LINE,"Test end");

    std_log(LOG_FILENAME_LINE,"Test Start");

    TEST (T,    123456.,    "123456", ' ');

    std_log(LOG_FILENAME_LINE,"Test end");