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

 *

 * 22.locale.num.get.cpp - test exercising the std::num_get facet

 *

 * $Id: 22.locale.num.get.cpp 290831 2005-09-21 21:15:42Z 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 <cstdlib>

// Usage:

//   #define NO_GET_${T}, where ${T} is the name of the arithmetic

//   type the num_get<charT>::get(..., ${T}&) overload, to disable

//   the corresponding test

//

//   #define NO_GET_INTEGER to disable tests of all integer types

//   #define NO_GET_FLOATING to disable testst of all floating types

//   #define NO_GET_ERRNO to disable errno tests

#define	SAME_AS_UNIX_COMMENT	

#define	FLT_MIN_NOT_SAME		

#define	FLT_MAX_NOT_SAME

#ifdef NO_GET_INTEGER

#  define NO_GET_BOOL

// no NO_GET_USHRT

#  define NO_GET_SHRT

// no NO_GET_UINT

#  define NO_GET_INT

#  define NO_GET_ULONG

#  define NO_GET_LONG

#  define NO_GET_ULLONG

#  define NO_GET_LLONG

#endif   // NO_GET_INTEGER

#ifdef NO_GET_FLOATING

#  define NO_GET_FLT

#  define NO_GET_DBL

#  define NO_GET_LDBL

#endif   // NO_GET_FLOATING

#define	_RWSTD_DBL_MIN	DBL_MIN

#define	_RWSTD_DBL_MAX	DBL_MAX

#define	_RWSTD_ULONG_MAX ULONG_MAX

#define	_RWSTD_LONG_MAX	LONG_MAX

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

#include <cfloat>

#include <climits>   // XXX_MAX, XXX_MIN

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

#include <cstdio>    // for sprintf(), sscanf()

#include <cstring>   // for memset(), strerror(), strlen()

#include <cstddef>

#include <cerrno>    // for ERANGE, errno

#include <ios>

#include <limits>

#include <locale>

#include <any.h>         // for rw_any_t

#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;

#ifdef __SYMBIAN32__

#include<assert.h>

#endif //__SYMBIAN32__

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

//#if 0

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

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

static int rw_opt_no_uflow       = 0;   // --no-underflow

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

// 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 () { /* working around a bug in older versions of EDG eccp */ }

};

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

#define TEST   do_test

#define T      __LINE__, charT ()

// if non-zero expected to point to a maximum valid value

// of type T that's being tested below (used for floating

// point ranges)

// on function return, the pointed to value is overwritten

// with the actual extracted value

void *pmax = 0;

template <class nativeT>

class rw_any_template_native_t

{

public:

	rw_any_template_native_t(nativeT aNativeT) : iNativeT(aNativeT)

	{

	}

	const char* const type_name ()

	{

	iNativeT.type_name();

	}

private:

	nativeT iNativeT;

};

template <class charT, class nativeT>

int do_test (int         lineno,          // line number

             charT       /* dummy */,

             nativeT     val,             // value expected to be extracted

             const char *str,             // input sequence

             int         consumed = -1,   // number of consumed characters

             int         flags = 0,       // initial set of flags

             int         err_expect = -1, // expected iostate

             const char *grouping = "")   // optional grouping string

{

    if (!rw_enabled (lineno)) {

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

        return 0;

    }

    static const char* const cname = rw_any_t (charT ()).type_name ();

    static const char* const tname =cname;//rw_any_template_native_t<nativeT>(nativeT ()).type_name (); //FIX

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

    NumGet<charT> ng;

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

                           (const std::numpunct<charT>*)&pun));

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

    pun.grouping_ = grouping;

    // initialize x to a value other than the expected one except when

    // get() is expected to fail (in which case the value isn't supposed

    // to be modified, except when the failure is caused by an invalid

    // grouping)

    // doing so exercises the requirement that the get() functions not

    // modify their argument on failure (except when the failure is due

    // to bad grouping)

    nativeT x =

        err_expect & std::ios::failbit || *grouping ? val : nativeT (!val);

    charT wstr_buf [256];   // small buffer to widen `str' to

    charT *wstr = 0;        // points to wstr_buf if large enough

    const charT *next;    // iterator to the next character where to parse

    char nbuf [4096];    // narrow character buffer

    // if the string `str' starts with a '%', treat it as a printf()

    // format specifier and take the string produced by sprintf()

    // below as the expected result, otherwise treat it literally

    // as the expected result

#ifdef __SYMBIAN32__

    if ('%' == *str && 0 < sprintf (nbuf, str, val))

        str = nbuf;

     const size_t str_len = strlen (str);   

#else

    if ('%' == *str && 0 < std::sprintf (nbuf, str, val))

        str = nbuf;

   const std::size_t str_len = std::strlen (str);     

#endif //__SYMBIAN32__

    // convert the narrow character string `str' to a wide character

    // string `wstr' if charT is wider than char

    if (sizeof (charT) > sizeof (char)) {

        // widen `str' to the wide character buffer if the latter

        // is large enough, or to a dynamically allocated buffer

        // otherwise

        wstr = str_len < sizeof wstr_buf / sizeof *wstr_buf ?

            wstr_buf : new charT [str_len + 1];

        typedef unsigned char UChar;

        for (std::size_t j = 0; j != str_len + 1; ++j)

            wstr [j] = charT (UChar (str [j]));

        next = wstr;

    }

    else {

        // charT == char, just point next at `str'

        next = (const charT*)str;

    }

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

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

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

    // do not test the number of extracted characters

    // if (consumed == -1) holds

    int success = -1 == consumed || last - next == consumed;

    int nfailures = !success;

#ifndef __SYMBIAN32__

    rw_assert (success, 0, lineno,

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

               "fmtflags = %{If}; "

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

               "ate %td, expected %d",

               __LINE__, cname, str, tname,

               flags,

               *grouping && '%' != *grouping, grouping,

               last - next, consumed);

#else

 if(!success)

 {

  failures++;

  std_log(LOG_FILENAME_LINE,"Reason:Failing");

  }

  #endif

    const nativeT val_max = pmax ? *(nativeT*)pmax : val;

    // if pmax is non-zero it points to the upper bound of the range

    // that the extracted value can be in

    success =

           err == err_expect

        && (rw_equal (x, val) || val <= x && x <= val_max);

    nfailures += !success;

   #ifndef __SYMBIAN32__

    rw_assert (success, 0, lineno,

               "line %d: num_get<%s>::get (%{*Ac}, ..., %s&); "

               "fmtflags = %{If}; "

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

               "got %s (%{Is}); "

               "expected %s%{?} <= %s %{;} "

               "(%{Is})",

               __LINE__, cname, sizeof *str, str, tname,

               flags,

               *grouping && '%' != *grouping, grouping,

               TOSTR (x), err,

               TOSTR (val), 0 != pmax, TOSTR (val_max),

               err_expect);

   #else

    if(!success)

    {

     failures++;

     std_log(LOG_FILENAME_LINE,"Reason:Failing");

     }

    #endif //__SYMBIAN32__ 

    if (pmax) {

        // store the extracted value into the pointed to location

        *(nativeT*)pmax = x;

    }

    if (*grouping && '%' == *grouping) {

        // if the `grouping' string starts with a '%', treat it as

        // a scanf() format specifier and use sscanf() to parse the

        // tested string `str'; then compare for equality the number

        // parsed with sscanf() with that parsed with num_get::get()

        const char* const scanspec = grouping;

        nativeT y = nativeT ();

        #ifdef __SYMBIAN32__

        const int n = sscanf (str, scanspec, &y);

        #else

        const int n = std::sscanf (str, scanspec, &y);

        #endif //__SYMBIAN32__

        success =

            !(   err & std::ios::failbit    && n > 0

              || !(err & std::ios::failbit) && 1 != n

              || !rw_equal (x, y));

        nfailures += !success;

      #ifndef __SYMBIAN32__

        rw_assert (success, 0, lineno,

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

                   "got %s, but scanf (..., \"%s\", ...) extracted %s "

                   "and returned %d; fmtflags = %{If}, iostate = %{Is}",

                   __LINE__, cname, str, tname,

                   TOSTR (x), scanspec, TOSTR (y),

                   n, flags, err);

       #else

        if(!success)

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason:Failing") ;

         }  

         #endif//__SYMBIAN32__         

    }

    if (wstr != wstr_buf)

        delete[] wstr;

    return nfailures;

}

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

// 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 Bad         std::ios_base::badbit

#define Eof         std::ios_base::eofbit

#define Fail        std::ios_base::failbit

#define Good        std::ios_base::goodbit

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

template <class numT>

class rw_any_template_t

{

public:

	rw_any_template_t(numT aNumT) : iNumT(aNumT)

	{

	}

	const char* const type_name ()

	{

	iNumT.type_name();

	}

private:

	numT iNumT;

};

template <class charT, class numT>

void test_errno (charT, numT)

{

    // verify that errno doesn't change after, or affects

    // a successful extraction

    const char* const cname = rw_any_t (charT ()).type_name ();

    const char* const tname = cname;//rw_any_template_t <numT>(numT()).type_name (); //FIX

    rw_info (0, 0, 0, "std::num_get<%s>::get (..., %s&) and errno",

             cname, tname);

    const int errnos[] = {

        ERANGE, -4, -3, -2, -1, 0, 1, 2, 3, 4,

        Bad, Eof, Fail, Bad | Eof, Bad | Fail, Eof | Fail, Bad | Eof | Fail

    };

    int i;

#define TEST_ERRNO(val)                                              \

    for (i = 0; i != sizeof errnos / sizeof *errnos; ++i) {          \

        errno = errnos [i];                                          \

        TEST (T, numT (val), _RWSTD_STR (val),                       \

              sizeof (_RWSTD_STR (val)) -1, 0, Eof);                 \

         if(errnos [i] != errno)                                     \

         {                                                           \

           failures++;                                               \

         std_log(LOG_FILENAME_LINE,"%d. errno unexpectedly changed from %d to %d",   \

                    i, errnos [i], errno);                           \

                    }                                                 \