1 

     2 

     3 /***************************************************************************

     4  *

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

     6  *

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

     8  *

     9  ***************************************************************************

    10  *

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

    12  * Software division. Licensed under the Apache License, Version 2.0 (the

    13  * "License");  you may  not use this file except  in compliance with the

    14  * License.    You    may   obtain   a   copy   of    the   License    at

    15  * http://www.apache.org/licenses/LICENSE-2.0.    Unless   required    by

    16  * applicable law  or agreed to  in writing,  software  distributed under

    17  * the License is distributed on an "AS IS" BASIS,  WITHOUT WARRANTIES OR

    18  * CONDITIONS OF  ANY KIND, either  express or implied.  See  the License

    19  * for the specific language governing permissions  and limitations under

    20  * the License.

    21  * 

    22  **************************************************************************/

    23 

    24 #ifdef __GNUG__

    25    // prevent gcc -Wshadow warnings for convenience types

    26 #  define ushort __rw_ushort

    27 #  define uint   __rw_uint

    28 #  define ulong  __rw_ulong

    29 #  include <sys/types.h>

    30 #  undef ushort

    31 #  undef uint

    32 #  undef ulong

    33 #endif   // __GNUG__

    34 

    35 #include <ios>

    36 #include <locale>

    37 

    38 #include <cerrno>    // for ERANGE, errno

    39 #include <cfloat>    // for floating limits macros

    40 #include <climits>   // for integral limits macros

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

    42 #include <cstdio>    // for sprintf()

    43 #include <cstdlib>   // for mbstowcs()

    44 

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

    46 #include <cmdopt.h>      // for rw_enabled

    47 #include <driver.h>      // for rw_test

    48 #include <localedef.h>   // for rw_locales

    49 #include <valcmp.h>      // for rw_equal

    50 #include"std_log_result.h"

    51 #define LOG_FILENAME_LINE __FILE__, __LINE__

    52 int failures=0;

    53 

    54 

    55 #ifdef __ARMCC__

    56 #pragma diag_suppress 61

    57 #pragma diag_suppress 236

    58 #endif

    59 

    60 /**************************************************************************/

    61 //#if 0

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

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

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

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

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

    67 

    68 /**************************************************************************/

    69 

    70 // replacement ctype facet

    71 template <class charT>

    72 struct Ctype: std::ctype<charT>

    73 {

    74     typedef std::ctype<charT> Base;

    75 

    76     typedef typename Base::char_type char_type;

    77 

    78     static int n_widen_;

    79 

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

    81 

    82     virtual char_type do_widen (char c) const {

    83         ++n_widen_;

    84 

    85         switch (c) {

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

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

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

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

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

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

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

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

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

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

    96         default: break;

    97         }

    98 

    99         return char_type (c);

   100     }

   101 

   102     virtual const char_type*

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

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

   105     }

   106 };

   107 

   108 template <class charT>

   109 int Ctype<charT>::n_widen_;

   110 

   111 

   112 /**************************************************************************/

   113 

   114 // replacement numpunct facet

   115 

   116 template <class charT>

   117 struct Punct: std::numpunct<charT>

   118 {

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

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

   121 

   122     static char_type        decimal_point_;

   123     static char_type        thousands_sep_;

   124     static const char      *grouping_;

   125     static const char_type *truename_;

   126     static const char_type *falsename_;

   127 

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

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

   130 

   131     Punct (std::size_t ref = 0)

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

   133         ++n_objs_;

   134     }

   135 

   136     ~Punct () {

   137         --n_objs_;

   138     }

   139 

   140     virtual char_type do_decimal_point () const {

   141         return decimal_point_;

   142     }

   143 

   144     virtual std::string do_grouping () const {

   145         return grouping_;

   146     }

   147 

   148     virtual char_type do_thousands_sep () const {

   149         ++n_thousands_sep_;

   150         return thousands_sep_;

   151     }

   152 

   153     virtual string_type do_truename () const {

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

   155     }

   156 

   157     virtual string_type do_falsename () const {

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

   159     }

   160 };

   161 

   162 template <class charT>

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

   164 

   165 template <class charT>

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

   167 

   168 template <class charT>

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

   170 

   171 template <class charT>

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

   173 

   174 template <class charT>

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

   176 

   177 template <class charT>

   178 int Punct<charT>::n_thousands_sep_;

   179 

   180 template <class charT>

   181 int Punct<charT>::n_objs_;

   182 

   183 

   184 /**************************************************************************/

   185 

   186 template <class charT>

   187 struct Ios: std::basic_ios<charT>

   188 {

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

   190 };

   191 

   192 

   193 template <class charT>

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

   195 

   196 

   197 template <class charT>

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

   199 {

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

   201     typedef typename Base::char_type    char_type;

   202     typedef typename Base::iter_type    iter_type;

   203 

   204     enum {

   205         test_bool, test_short, test_ushort, test_int, test_uint,

   206         test_long, test_ulong, test_llong, test_ullong,

   207         test_pvoid, test_float, test_double, test_ldouble

   208     };

   209         

   210     static int ncalls_ [13];

   211 

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

   213 

   214 #ifndef _RWSTD_NO_BOOL

   215 

   216     virtual iter_type

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

   218         ++ncalls_ [test_bool];

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

   220     }

   221 

   222 #endif   // _RWSTD_NO_BOOL

   223 

   224     virtual iter_type

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

   226         ++ncalls_ [test_long];

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

   228     }

   229 

   230     virtual iter_type

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

   232             unsigned long v) const {

   233         ++ncalls_ [test_ulong];

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

   235     }

   236 

   237 #ifdef _RWSTD_LONG_LONG

   238 

   239     // provided as an extension unless _RWSTD_NO_LONG_LONG is #defined

   240     virtual iter_type

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

   242             unsigned _RWSTD_LONG_LONG v) const {

   243         ++ncalls_ [test_ullong];

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

   245     }

   246 

   247     // provided as an extension unless _RWSTD_NO_LONG_LONG is #defined

   248     virtual iter_type

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

   250             _RWSTD_LONG_LONG v) const {

   251         ++ncalls_ [test_llong];

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

   253     }

   254 

   255 #endif   // _RWSTD_LONG_LONG

   256 

   257     virtual iter_type

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

   259         ++ncalls_ [test_double];

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

   261     }

   262 

   263 #ifndef __SYMBIAN32__

   264 #ifndef _RWSTD_NO_LONG_DOUBLE

   265 

   266     virtual iter_type

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

   268             long double v) const {

   269         ++ncalls_ [test_ldouble];

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

   271     }

   272 #endif 

   273 #endif   // _RWSTD_NO_LONG_DOUBLE

   274 

   275     virtual iter_type

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

   277             const void *v) const {

   278         ++ncalls_ [test_pvoid];

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

   280     }

   281 };

   282 

   283 

   284 // explicit initialization of the static array below used

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

   286 template <class charT>

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

   288 

   289 /**************************************************************************/

   290 

   291 template <class charT, class T>

   292 void do_test (charT           /* dummy */,

   293               const char     *cname,    // charT name

   294               const char     *tname,    // T name

   295               int             lineno,   // line number

   296               T               val,      // value to format

   297               int             flags,    // ios flags

   298               std::streamsize prec,     // precision

   299               std::streamsize width,    // field width

   300               char            fill,     // fill character

   301               const char     *grouping, // grouping string

   302               const char     *str,      // expected output

   303               int             err_expect = -1,   // expected iostate

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

   305 {

   306     if (!rw_enabled (lineno)) {

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

   308         return;

   309     }

   310     

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

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

   313     // member functions are flushed

   314     const Punct<charT> pun (1);

   315 

   316     Ios<charT> ios;

   317     NumPut<charT> np;

   318 

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

   320 

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

   322     ios.precision (prec);

   323     ios.width (width);

   324     pun.grouping_ = grouping;

   325 

   326 //#if defined (_RWSTD_LDBL_MAX_10_EXP)

   327 

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

   329 

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

   331 

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

   333     charT buf [512] = { 0 };

   334 

   335 //#endif   // _RWSTD_LDBL_MAX_10_EXP

   336 

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

   338 

   339     // verify 22.2.2.2.2, p21

   340     if (ios.width ()) {

   341 

   342         static int width_fail = 0;

   343 

   344         // fail at most once for each specialization

   345         #ifndef __SYMBIAN32__

   346         rw_assert (!width_fail++, 0, lineno,

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

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

   349                    __LINE__, cname, tname, TOSTR (val),

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

   351        #else

   352         {

   353           

   354            if(width_fail++)

   355            {

   356              

   357             failures++;

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

   359              

   360              }

   361         }

   362                     

   363         #endif           

   364     }

   365 

   366     /******************************************************************/

   367 

   368     if (str) {

   369 

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

   371 

   372         if ('%' == *str) {

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

   374             str = cbuf;

   375 

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

   377 

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

   379 

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

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

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

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

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

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

   386             }

   387 

   388 #endif   // _WIN{32,64}

   389         }

   390 

   391         #ifndef __SYMBIAN32__

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

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

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

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

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

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

   398                    __LINE__, cname, tname, TOSTR (val),

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

   400                    flags, prec,

   401                    grouping && *grouping, grouping);

   402         #else

   403          {

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

   405           failures++;

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

   407                      

   408          } 

   409          #endif  // __SYMBIAN32__    

   410     }

   411 

   412     /******************************************************************/

   413 

   414 #ifndef NO_NUM_GET

   415 

   416     if (!rw_opt_enable_num_get)

   417         return;

   418 

   419     // skip negative precision (extension requiring special treatment)

   420     if (prec < 0)

   421         return;

   422 

   423     const charT *next = buf;

   424 

   425     // skip leading fill characters (if any)

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

   427 

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

   429     const charT *last = next;

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

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

   432 

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

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

   435     // up the input sequence)

   436     if (next != last && *last)

   437         return;

   438 

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

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

   441     // or a digit

   442     if (   '-' == fill

   443         || '+' == fill

   444         || pun.thousands_sep_ == fill

   445         || pun.decimal_point_ == fill

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

   447         return;

   448 

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

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

   451     if (!*next && str)

   452         return;

   453 

   454     NumGet<charT> ng;

   455 

   456     T x = T ();

   457 

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

   459 

   460     if (-1 == err_expect) {

   461 

   462         // lwg issue 17: special treatment for bool:

   463 

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

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

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

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

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

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

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

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

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

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

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

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

   476         // --end example]

   477 

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

   479             ? std::ios::goodbit

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

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

   482 

   483         val_expect = val;

   484     }

   485 

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

   487 #ifndef __SYMBIAN32__

   488     // verify the state

   489     rw_assert (err == err_expect, 0, lineno,

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

   491                "flags = %{If}, "

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

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

   494                __LINE__, cname,

   495                TOSTR (next), tname,

   496                flags,

   497                grouping && *grouping, grouping,

   498                err, err_expect);

   499 

   500     // verify the parsed value

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

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

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

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

   505                __LINE__, cname,

   506                TOSTR (next), tname,

   507                TOSTR (x), TOSTR (val_expect),

   508                flags,

   509                grouping && *grouping, grouping);

   510   #else

   511    {

   512    

   513    if(err != err_expect)

   514      {

   515      failures++;

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

   517      }

   518    if(!rw_equal (x, val_expect))

   519      {

   520      failures++;

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

   522      }

   523    

   524    

   525    

   526    }             

   527 #endif//__SYMBIAN32__

   528 #else

   529 

   530     _RWSTD_UNUSED (bufend);

   531     _RWSTD_UNUSED (err_expect);

   532     _RWSTD_UNUSED (val_expect);

   533 

   534 #endif   // NO_NUM_GET

   535 

   536 }

   537 

   538 /**************************************************************************/

   539 

   540 template <class charT>

   541 struct Streambuf: std::basic_streambuf<charT, std::char_traits<charT> > { };

   542 #if 0 //FIX

   543 template <class charT>

   544 void direct_use_test (charT, const char *cname)

   545 {

   546     _RWSTD_UNUSED (cname);

   547 

   548     // verify that num_put objects can be used directly w/o first

   549     // having been installed in a locale object; the behavior of

   550     // such facets is unspecified (but not undefined)

   551 

   552     Ios<charT> ios;

   553 

   554     const std::num_put<charT> np; //can not directly instantiate num_put, it is illegal, same behaviour in linux also 

   555 

   556     Streambuf<charT> sb;

   557 

   558 #define DIRECT_USE_TEST(T) \

   559     np.put (std::ostreambuf_iterator<charT>(&sb), ios, charT (), (T)0)

   560 

   561 #ifndef _RWSTD_NO_BOOL

   562 

   563     DIRECT_USE_TEST (bool);

   564 

   565 #endif   // _RWSTD_NO_BOOL

   566 

   567     DIRECT_USE_TEST (unsigned long);

   568     DIRECT_USE_TEST (long);

   569     DIRECT_USE_TEST (double);

   570 

   571 #ifndef _RWSTD_NO_LONG_DOUBLE

   572 

   573     DIRECT_USE_TEST (long double);

   574 

   575 #endif

   576 

   577     DIRECT_USE_TEST (void*);

   578 }

   579 #endif 

   580 /**************************************************************************/

   581 

   582 

   583 // for convenience

   584 #define boolalpha   std::ios_base::boolalpha

   585 #define dec         std::ios_base::dec

   586 #define fixed       std::ios_base::fixed

   587 #define hex         std::ios_base::hex

   588 #define internal    std::ios_base::internal

   589 #define left        std::ios_base::left

   590 #define oct         std::ios_base::oct

   591 #define right       std::ios_base::right

   592 #define scientific  std::ios_base::scientific

   593 #define showbase    std::ios_base::showbase

   594 #define showpoint   std::ios_base::showpoint

   595 #define showpos     std::ios_base::showpos

   596 #define skipws      std::ios_base::skipws

   597 #define unitbuf     std::ios_base::unitbuf

   598 #define uppercase   std::ios_base::uppercase

   599 //#define bin         std::ios_base::bin //it is not bin its is binary

   600 #define bin         std::ios_base::binary

   601 #define adjustfield std::ios_base::adjustfield

   602 #define basefield   std::ios_base::basefield

   603 #define floatfield  std::ios_base::floatfield

   604 #define nolock      std::ios_base::nolock

   605 #define nolockbuf   std::ios_base::nolockbuf

   606 

   607 #define Bad         std::ios_base::badbit

   608 #define Eof         std::ios_base::eofbit

   609 #define Fail        std::ios_base::failbit

   610 #define Good        std::ios_base::goodbit

   611 

   612 

   613 template <class charT>

   614 void bool_test (charT, const char *cname)

   615 {

   616 #ifndef _RWSTD_NO_BOOL

   617 

   618     rw_info (0, 0, __LINE__, "std::num_put<%s>::put (..., bool)", cname);

   619 

   620     const char* const tname = "bool";

   621 

   622     static const charT boolnames[][4] = {

   623         { 'y', 'e', 's', '\0' }, { 'n', 'o', '.', '\0' },

   624 

   625         // unusual strings to try to trip up the formatting algorithm

   626         { '+', '1', '\0' },      { '-', '2', '\0' },

   627         { '-', '+', '1', '\0' }, { '+', '-', '0', '\0' },

   628         { '\001', '\0' },        { '\0' }

   629     };

   630 

   631     Punct<charT>::decimal_point_ = '*';

   632     Punct<charT>::truename_      = boolnames [0];

   633     Punct<charT>::falsename_     = boolnames [1];

   634 

   635 // set line number to __LINE__ and perform test so that

   636 // assertion output will point to the failed TEST line

   637 #define TEST  do_test

   638 #define T     charT (), cname, tname, __LINE__

   639 

   640     std_log(LOG_FILENAME_LINE,"Test start");

   641     TEST (T, false, 0, 0, 0, ' ', "", "0");

   642     std_log(LOG_FILENAME_LINE,"Test end");

   643     std_log(LOG_FILENAME_LINE,"Test start");

   644     

   645     TEST (T, true,  0, 0, 0, ' ', "", "1");

   646     std_log(LOG_FILENAME_LINE,"Test end");

   647     std_log(LOG_FILENAME_LINE,"Test start");

   648 

   649     TEST (T, false, 0, 0, 0, ' ', "", "%d");

   650     std_log(LOG_FILENAME_LINE,"Test end");

   651     std_log(LOG_FILENAME_LINE,"Test start");

   652     TEST (T, true,  0, 0, 0, ' ', "", "%d");

   653     std_log(LOG_FILENAME_LINE,"Test end");

   654     std_log(LOG_FILENAME_LINE,"Test start");

   655 

   656     TEST (T, false, showpos, 0, 0, ' ', "", "%+d");

   657     std_log(LOG_FILENAME_LINE,"Test end");

   658     std_log(LOG_FILENAME_LINE,"Test start");

   659     TEST (T, true,  showpos, 0, 0, ' ', "", "%+d");

   660     std_log(LOG_FILENAME_LINE,"Test end");

   661     std_log(LOG_FILENAME_LINE,"Test start");

   662 

   663     TEST (T, false, oct, 0, 0, ' ', "", "%o");

   664     std_log(LOG_FILENAME_LINE,"Test end");

   665     std_log(LOG_FILENAME_LINE,"Test start");

   666     TEST (T, true,  oct, 0, 0, ' ', "", "%o");

   667     std_log(LOG_FILENAME_LINE,"Test end");

   668     std_log(LOG_FILENAME_LINE,"Test start");

   669 

   670     TEST (T, false, dec, 0, 0, ' ', "", "%d");

   671     std_log(LOG_FILENAME_LINE,"Test end");

   672     std_log(LOG_FILENAME_LINE,"Test start");

   673     TEST (T, true,  dec, 0, 0, ' ', "", "%d");

   674     std_log(LOG_FILENAME_LINE,"Test end");

   675     std_log(LOG_FILENAME_LINE,"Test start");

   676 

   677     TEST (T, false, hex, 0, 0, ' ', "", "%x");

   678     std_log(LOG_FILENAME_LINE,"Test end");

   679     std_log(LOG_FILENAME_LINE,"Test start");

   680     TEST (T, true,  hex, 0, 0, ' ', "", "%x");

   681     std_log(LOG_FILENAME_LINE,"Test end");

   682     std_log(LOG_FILENAME_LINE,"Test start");

   683 

   684     rw_info (0, 0, __LINE__, "std::ios::boolalpha");

   685 

   686     TEST (T, false, boolalpha, 0, 0, ' ', "", "no.");

   687     std_log(LOG_FILENAME_LINE,"Test end");

   688     std_log(LOG_FILENAME_LINE,"Test start");

   689     TEST (T, true,  boolalpha, 0, 0, ' ', "", "yes");

   690     std_log(LOG_FILENAME_LINE,"Test end");

   691     std_log(LOG_FILENAME_LINE,"Test start");

   692 

   693     // left justified boolalpha

   694     TEST (T, false, boolalpha | left, 0, 6, ' ', "", "no.   ");

   695     std_log(LOG_FILENAME_LINE,"Test end");

   696     std_log(LOG_FILENAME_LINE,"Test start");

   697     TEST (T, true,  boolalpha | left, 0, 6, ' ', "", "yes   ");

   698     std_log(LOG_FILENAME_LINE,"Test end");

   699     std_log(LOG_FILENAME_LINE,"Test start");

   700 

   701     // right justified boolalpha

   702     TEST (T, false, boolalpha | right, 0, 6, ' ', "", "   no.");

   703     std_log(LOG_FILENAME_LINE,"Test end");

   704     std_log(LOG_FILENAME_LINE,"Test start");

   705     TEST (T, true,  boolalpha | right, 0, 6, ' ', "", "   yes");

   706     std_log(LOG_FILENAME_LINE,"Test end");

   707     std_log(LOG_FILENAME_LINE,"Test start");

   708 

   709     // implied right justified boolalpha (internal bit set)

   710     TEST (T, false, boolalpha | internal, 0, 4, ' ', "", " no.");

   711     std_log(LOG_FILENAME_LINE,"Test end");

   712     std_log(LOG_FILENAME_LINE,"Test start");

   713     TEST (T, true,  boolalpha | internal, 0, 4, ' ', "", " yes");

   714     std_log(LOG_FILENAME_LINE,"Test end");

   715 

   716 

   717 

   718     Punct<charT>::truename_  = boolnames [2];

   719     Punct<charT>::falsename_ = boolnames [3];

   720 

   721     std_log(LOG_FILENAME_LINE,"Test start");

   722 

   723     TEST (T, false, boolalpha, 0, 1, ' ', "", "-2");

   724     std_log(LOG_FILENAME_LINE,"Test end");

   725     std_log(LOG_FILENAME_LINE,"Test start");

   726     TEST (T, true,  boolalpha, 0, 1, ' ', "", "+1");

   727     std_log(LOG_FILENAME_LINE,"Test end");

   728     std_log(LOG_FILENAME_LINE,"Test start");

   729 

   730     TEST (T, false, boolalpha | internal, 0, 4, ' ', "", "  -2");

   731     std_log(LOG_FILENAME_LINE,"Test end");

   732     std_log(LOG_FILENAME_LINE,"Test start");

   733     TEST (T, true,  boolalpha | internal, 0, 4, ' ', "", "  +1");

   734     std_log(LOG_FILENAME_LINE,"Test end");

   735 

   736 

   737 

   738     Punct<charT>::truename_  = boolnames [4];

   739     Punct<charT>::falsename_ = boolnames [5];

   740 

   741     std_log(LOG_FILENAME_LINE,"Test start");

   742 

   743     TEST (T, false, boolalpha, 0, 1, ' ', "", "+-0");

   744     std_log(LOG_FILENAME_LINE,"Test end");

   745     std_log(LOG_FILENAME_LINE,"Test start");

   746     TEST (T, true,  boolalpha, 0, 1, ' ', "", "-+1");

   747     std_log(LOG_FILENAME_LINE,"Test end");

   748     std_log(LOG_FILENAME_LINE,"Test start");

   749 

   750     TEST (T, false, boolalpha | internal, 0, 4, ' ', "", " +-0");

   751     std_log(LOG_FILENAME_LINE,"Test end");

   752     std_log(LOG_FILENAME_LINE,"Test start");

   753     TEST (T, true,  boolalpha | internal, 0, 4, ' ', "", " -+1");

   754     std_log(LOG_FILENAME_LINE,"Test end");

   755 

   756 

   757 

   758     Punct<charT>::truename_  = boolnames [6];

   759     Punct<charT>::falsename_ = boolnames [7];

   760 

   761     std_log(LOG_FILENAME_LINE,"Test start");

   762 

   763     TEST (T, false, boolalpha, 0, 0, ' ', "", "");

   764     std_log(LOG_FILENAME_LINE,"Test end");

   765     std_log(LOG_FILENAME_LINE,"Test start");

   766     TEST (T, true,  boolalpha, 0, 0, ' ', "", "\001");

   767     std_log(LOG_FILENAME_LINE,"Test end");

   768     std_log(LOG_FILENAME_LINE,"Test start");

   769 

   770     TEST (T, false, boolalpha, 0, 1, ' ', "", " ");

   771     std_log(LOG_FILENAME_LINE,"Test end");

   772     std_log(LOG_FILENAME_LINE,"Test start");

   773     TEST (T, true,  boolalpha, 0, 1, ' ', "", "\001");

   774     std_log(LOG_FILENAME_LINE,"Test end");

   775     std_log(LOG_FILENAME_LINE,"Test start");

   776 

   777     TEST (T, false, boolalpha, 0, 1, ',', "", ",");

   778     std_log(LOG_FILENAME_LINE,"Test end");

   779     std_log(LOG_FILENAME_LINE,"Test start");

   780     TEST (T, true,  boolalpha, 0, 1, ',', "", "\001");

   781     std_log(LOG_FILENAME_LINE,"Test end");

   782     std_log(LOG_FILENAME_LINE,"Test start");

   783 

   784     TEST (T, false, boolalpha | internal, 0,4, ',', "", ",,,,");

   785     std_log(LOG_FILENAME_LINE,"Test end");

   786     std_log(LOG_FILENAME_LINE,"Test start");

   787     TEST (T, true,  boolalpha | internal, 0,4, ',', "", ",,,\001");

   788     std_log(LOG_FILENAME_LINE,"Test end");

   789 

   790 

   791 #endif   // _RWSTD_NO_BOOL

   792 

   793 }

   794 

   795 /**************************************************************************/

   796 

   797 template <class charT>

   798 void long_test (charT, const char *cname)

   799 {

   800     const char* const tname = "long";

   801 

   802     rw_info (0, 0, __LINE__, "std::num_put<%s>::put (..., %s)", cname, tname);

   803 

   804 // working around a VAC++/AIX bug where LONG_{MIN,MAX} are

   805 // of type int rather than long as required (see PR #28798)

   806 #ifndef	LONG_MIN 

   807 #undef LONG_MIN

   808 #define LONG_MIN _RWSTD_LONG_MIN

   809 #endif

   810 

   811 #ifndef	LONG_MAX

   812 #undef LONG_MAX

   813 #define LONG_MAX _RWSTD_LONG_MAX

   814 #endif

   815 

   816 #undef GET_FAIL

   817 #define GET_FAIL (Eof | Fail), LONG_MAX

   818 

   819     //////////////////////////////////////////////////////////////////

   820     // implicit decimal output

   821     rw_info (0, 0, __LINE__, "std::ios::fmtflags ()");

   822 

   823     std_log(LOG_FILENAME_LINE,"Test start");

   824 

   825     TEST (T,       0L,   0, 0, 0, ' ', "", "%ld");

   826     std_log(LOG_FILENAME_LINE,"Test end");

   827     std_log(LOG_FILENAME_LINE,"Test start");

   828     TEST (T,       1L,   0, 0, 0, ' ', "", "%ld");

   829     std_log(LOG_FILENAME_LINE,"Test end");

   830     std_log(LOG_FILENAME_LINE,"Test start");

   831     TEST (T,       2L,   0, 0, 0, ' ', "", "%ld");

   832     std_log(LOG_FILENAME_LINE,"Test end");

   833     std_log(LOG_FILENAME_LINE,"Test start");

   834     TEST (T,      -3L,   0, 0, 0, ' ', "", "%ld");

   835     std_log(LOG_FILENAME_LINE,"Test end");

   836     std_log(LOG_FILENAME_LINE,"Test start");

   837     TEST (T,      12L,   0, 0, 0, ' ', "", "%ld");

   838     std_log(LOG_FILENAME_LINE,"Test end");

   839     std_log(LOG_FILENAME_LINE,"Test start");

   840     TEST (T,     -13L,   0, 0, 0, ' ', "", "%ld");

   841     std_log(LOG_FILENAME_LINE,"Test end");

   842     std_log(LOG_FILENAME_LINE,"Test start");

   843     TEST (T,     345L,   0, 0, 0, ' ', "", "%ld");

   844     std_log(LOG_FILENAME_LINE,"Test end");

   845     std_log(LOG_FILENAME_LINE,"Test start");

   846     TEST (T,    -456L,   0, 0, 0, ' ', "", "%ld");

   847     std_log(LOG_FILENAME_LINE,"Test end");

   848     std_log(LOG_FILENAME_LINE,"Test start");

   849     TEST (T,    6789L,   0, 0, 0, ' ', "", "%ld");

   850     std_log(LOG_FILENAME_LINE,"Test end");

   851     std_log(LOG_FILENAME_LINE,"Test start");

   852     TEST (T,   -7890L,   0, 0, 0, ' ', "", "%ld");

   853     std_log(LOG_FILENAME_LINE,"Test end");

   854     std_log(LOG_FILENAME_LINE,"Test start");

   855     TEST (T,   98765L,   0, 0, 0, ' ', "", "%ld");

   856     std_log(LOG_FILENAME_LINE,"Test end");

   857     std_log(LOG_FILENAME_LINE,"Test start");

   858     TEST (T,  -98766L,   0, 0, 0, ' ', "", "%ld");

   859     std_log(LOG_FILENAME_LINE,"Test end");

   860     std_log(LOG_FILENAME_LINE,"Test start");

   861     TEST (T, LONG_MAX,   0, 0, 0, ' ', "", "%ld");

   862     std_log(LOG_FILENAME_LINE,"Test end");

   863     std_log(LOG_FILENAME_LINE,"Test start");

   864     TEST (T, LONG_MIN,   0, 0, 0, ' ', "", "%ld");

   865     std_log(LOG_FILENAME_LINE,"Test end");

   866 

   867 

   868     //////////////////////////////////////////////////////////////////

   869     // explicit decimal ouptut

   870     rw_info (0, 0, __LINE__, "std::ios::dec");

   871 

   872     std_log(LOG_FILENAME_LINE,"Test start");

   873 

   874     TEST (T,       0L, dec, 0, 0, ' ', "", "%ld");

   875     std_log(LOG_FILENAME_LINE,"Test end");

   876     std_log(LOG_FILENAME_LINE,"Test start");

   877     TEST (T,       1L, dec, 0, 0, ' ', "", "%ld");

   878     std_log(LOG_FILENAME_LINE,"Test end");

   879     std_log(LOG_FILENAME_LINE,"Test start");

   880     TEST (T,       2L, dec, 0, 0, ' ', "", "%ld");

   881     std_log(LOG_FILENAME_LINE,"Test end");

   882     std_log(LOG_FILENAME_LINE,"Test start");

   883     TEST (T,      12L, dec, 0, 0, ' ', "", "%ld");

   884     std_log(LOG_FILENAME_LINE,"Test end");

   885     std_log(LOG_FILENAME_LINE,"Test start");

   886     TEST (T,     345L, dec, 0, 0, ' ', "", "%ld");

   887     std_log(LOG_FILENAME_LINE,"Test end");

   888     std_log(LOG_FILENAME_LINE,"Test start");

   889     TEST (T,    6789L, dec, 0, 0, ' ', "", "%ld");

   890     std_log(LOG_FILENAME_LINE,"Test end");

   891     std_log(LOG_FILENAME_LINE,"Test start");

   892     TEST (T,   98765L, dec, 0, 0, ' ', "", "%ld");

   893     std_log(LOG_FILENAME_LINE,"Test end");

   894     std_log(LOG_FILENAME_LINE,"Test start");

   895     TEST (T, LONG_MAX, dec, 0, 0, ' ', "", "%ld");

   896     std_log(LOG_FILENAME_LINE,"Test end");

   897     std_log(LOG_FILENAME_LINE,"Test start");

   898 

   899     TEST (T,      ~0L, dec, 0, 0, ' ', "", "%ld");

   900     std_log(LOG_FILENAME_LINE,"Test end");

   901     std_log(LOG_FILENAME_LINE,"Test start");

   902     TEST (T,      -1L, dec, 0, 0, ' ', "", "%ld");

   903     std_log(LOG_FILENAME_LINE,"Test end");

   904     std_log(LOG_FILENAME_LINE,"Test start");

   905     TEST (T,      -2L, dec, 0, 0, ' ', "", "%ld");

   906     std_log(LOG_FILENAME_LINE,"Test end");

   907     std_log(LOG_FILENAME_LINE,"Test start");

   908     TEST (T,     -12L, dec, 0, 0, ' ', "", "%ld");

   909     std_log(LOG_FILENAME_LINE,"Test end");

   910     std_log(LOG_FILENAME_LINE,"Test start");

   911     TEST (T,    -345L, dec, 0, 0, ' ', "", "%ld");

   912     std_log(LOG_FILENAME_LINE,"Test end");

   913     std_log(LOG_FILENAME_LINE,"Test start");

   914     TEST (T,   -6789L, dec, 0, 0, ' ', "", "%ld");

   915     std_log(LOG_FILENAME_LINE,"Test end");

   916     std_log(LOG_FILENAME_LINE,"Test start");

   917     TEST (T,  -98765L, dec, 0, 0, ' ', "", "%ld");

   918     std_log(LOG_FILENAME_LINE,"Test end");

   919     std_log(LOG_FILENAME_LINE,"Test start");

   920     TEST (T, LONG_MIN, dec, 0, 0, ' ', "", "%ld");

   921     std_log(LOG_FILENAME_LINE,"Test end");

   922 

   923 

   924     rw_info (0, 0, __LINE__, "std::ios::dec | std::ios::showbase");

   925     std_log(LOG_FILENAME_LINE,"Test end");

   926     std_log(LOG_FILENAME_LINE,"Test start");

   927 

   928     TEST (T,       0L, dec | showbase, 0, 0, ' ', "", "%#ld");

   929     std_log(LOG_FILENAME_LINE,"Test end");

   930     std_log(LOG_FILENAME_LINE,"Test start");

   931     TEST (T,    1234L, dec | showbase, 0, 0, ' ', "", "%#ld");

   932     std_log(LOG_FILENAME_LINE,"Test end");

   933     std_log(LOG_FILENAME_LINE,"Test start");

   934     TEST (T,   -1235L, dec | showbase, 0, 0, ' ', "", "%#ld");

   935     std_log(LOG_FILENAME_LINE,"Test end");

   936     std_log(LOG_FILENAME_LINE,"Test start");

   937     TEST (T, LONG_MAX, dec | showbase, 0, 0, ' ', "", "%#ld");

   938     std_log(LOG_FILENAME_LINE,"Test end");

   939     std_log(LOG_FILENAME_LINE,"Test start");

   940     TEST (T, LONG_MIN, dec | showbase, 0, 0, ' ', "", "%#ld");

   941     std_log(LOG_FILENAME_LINE,"Test end");

   942 

   943 

   944     rw_info (0, 0, __LINE__, "std::ios::dec | std::ios::showpos");

   945 

   946     std_log(LOG_FILENAME_LINE,"Test start");

   947 

   948     TEST (T,       0L, dec | showpos, 0, 0, ' ', "", "%+ld");

   949     std_log(LOG_FILENAME_LINE,"Test end");

   950     std_log(LOG_FILENAME_LINE,"Test start");

   951     TEST (T,    1236L, dec | showpos, 0, 0, ' ', "", "%+ld");

   952     std_log(LOG_FILENAME_LINE,"Test end");

   953     std_log(LOG_FILENAME_LINE,"Test start");

   954     TEST (T,   -1237L, dec | showpos, 0, 0, ' ', "", "%+ld");

   955     std_log(LOG_FILENAME_LINE,"Test end");

   956     std_log(LOG_FILENAME_LINE,"Test start");

   957     TEST (T, LONG_MAX, dec | showpos, 0, 0, ' ', "", "%+ld");

   958     std_log(LOG_FILENAME_LINE,"Test end");

   959     std_log(LOG_FILENAME_LINE,"Test start");

   960     TEST (T, LONG_MIN, dec | showpos, 0, 0, ' ', "", "%+ld");

   961     std_log(LOG_FILENAME_LINE,"Test end");

   962 

   963 

   964     rw_info (0, 0, __LINE__,

   965              "std::ios::dec | std::ios::showbase | std::ios::showpos");

   966 

   967     std_log(LOG_FILENAME_LINE,"Test start");

   968 

   969     TEST (T,       0L, dec | showbase | showpos, 0, 0, ' ', "", "%#+ld");

   970     std_log(LOG_FILENAME_LINE,"Test end");

   971     std_log(LOG_FILENAME_LINE,"Test start");

   972     TEST (T,    1238L, dec | showbase | showpos, 0, 0, ' ', "", "%#+ld");

   973     std_log(LOG_FILENAME_LINE,"Test end");

   974     std_log(LOG_FILENAME_LINE,"Test start");

   975     TEST (T,   -1239L, dec | showbase | showpos, 0, 0, ' ', "", "%#+ld");

   976     std_log(LOG_FILENAME_LINE,"Test end");

   977     std_log(LOG_FILENAME_LINE,"Test start");

   978     TEST (T, LONG_MAX, dec | showbase | showpos, 0, 0, ' ', "", "%#+ld");

   979     std_log(LOG_FILENAME_LINE,"Test end");

   980     std_log(LOG_FILENAME_LINE,"Test start");

   981     TEST (T, LONG_MIN, dec | showbase | showpos, 0, 0, ' ', "", "%#+ld");

   982     std_log(LOG_FILENAME_LINE,"Test end");

   983     std_log(LOG_FILENAME_LINE,"Test start");

   984 

   985     // left justfication

   986     rw_info (0, 0, __LINE__, "std::ios::dec | std::ios::left");

   987 

   988     TEST (T,  0L,         dec | left, 0, 10, ' ', "", "%-10ld");

   989     std_log(LOG_FILENAME_LINE,"Test end");

   990     std_log(LOG_FILENAME_LINE,"Test start");

   991     TEST (T,  1L,         dec | left, 0, 10, ' ', "", "%-10ld");

   992     std_log(LOG_FILENAME_LINE,"Test end");

   993     std_log(LOG_FILENAME_LINE,"Test start");

   994     TEST (T,  12L,        dec | left, 0, 10, ' ', "", "%-10ld");

   995     std_log(LOG_FILENAME_LINE,"Test end");

   996     std_log(LOG_FILENAME_LINE,"Test start");

   997     TEST (T,  123L,       dec | left, 0, 10, ' ', "", "%-10ld");

   998     std_log(LOG_FILENAME_LINE,"Test end");

   999     std_log(LOG_FILENAME_LINE,"Test start");

  1000     TEST (T,  1234L,      dec | left, 0, 10, ' ', "", "%-10ld");

  1001     std_log(LOG_FILENAME_LINE,"Test end");

  1002     std_log(LOG_FILENAME_LINE,"Test start");

  1003     TEST (T,  12345L,     dec | left, 0, 10, ' ', "", "%-10ld");

  1004     std_log(LOG_FILENAME_LINE,"Test end");

  1005     std_log(LOG_FILENAME_LINE,"Test start");

  1006     TEST (T,  123456L,    dec | left, 0, 10, ' ', "", "%-10ld");

  1007     std_log(LOG_FILENAME_LINE,"Test end");

  1008     std_log(LOG_FILENAME_LINE,"Test start");

  1009     TEST (T,  1234567L,   dec | left, 0, 10, ' ', "", "%-10ld");

  1010     std_log(LOG_FILENAME_LINE,"Test end");

  1011     std_log(LOG_FILENAME_LINE,"Test start");

  1012     TEST (T,  12345678L,  dec | left, 0, 10, ' ', "", "%-10ld");

  1013     std_log(LOG_FILENAME_LINE,"Test end");

  1014     std_log(LOG_FILENAME_LINE,"Test start");

  1015     TEST (T,  123456789L, dec | left, 0, 10, ' ', "", "%-10ld");

  1016     std_log(LOG_FILENAME_LINE,"Test end");

  1017     std_log(LOG_FILENAME_LINE,"Test start");

  1018 

  1019     // left justfication, signed dec

  1020     TEST (T,  -1L,         dec | left, 0, 10, ' ', "", "-1        ");

  1021     std_log(LOG_FILENAME_LINE,"Test end");

  1022     std_log(LOG_FILENAME_LINE,"Test start");

  1023     TEST (T,  -12L,        dec | left, 0, 10, ' ', "", "-12       ");

  1024     std_log(LOG_FILENAME_LINE,"Test end");

  1025     std_log(LOG_FILENAME_LINE,"Test start");

  1026     TEST (T,  -123L,       dec | left, 0, 10, ' ', "", "-123      ");

  1027     std_log(LOG_FILENAME_LINE,"Test end");

  1028     std_log(LOG_FILENAME_LINE,"Test start");

  1029     TEST (T,  -1234L,      dec | left, 0, 10, ' ', "", "-1234     ");

  1030     std_log(LOG_FILENAME_LINE,"Test end");

  1031     std_log(LOG_FILENAME_LINE,"Test start");

  1032     TEST (T,  -12345L,     dec | left, 0, 10, ' ', "", "-12345    ");

  1033     std_log(LOG_FILENAME_LINE,"Test end");

  1034     std_log(LOG_FILENAME_LINE,"Test start");

  1035     TEST (T,  -123456L,    dec | left, 0, 10, ' ', "", "-123456   ");

  1036     std_log(LOG_FILENAME_LINE,"Test end");

  1037     std_log(LOG_FILENAME_LINE,"Test start");

  1038     TEST (T,  -1234567L,   dec | left, 0, 10, ' ', "", "-1234567  ");

  1039     std_log(LOG_FILENAME_LINE,"Test end");

  1040     std_log(LOG_FILENAME_LINE,"Test start");

  1041     TEST (T,  -12345678L,  dec | left, 0, 10, ' ', "", "-12345678 ");

  1042     std_log(LOG_FILENAME_LINE,"Test end");

  1043     std_log(LOG_FILENAME_LINE,"Test start");

  1044     TEST (T,  -123456789L, dec | left, 0, 10, ' ', "", "-123456789");

  1045     std_log(LOG_FILENAME_LINE,"Test end");

  1046     std_log(LOG_FILENAME_LINE,"Test start");

  1047 

  1048     // left justification with fill char

  1049     TEST (T,  -1L,         dec | left, 0, 10, '#', "", "-1########");

  1050     std_log(LOG_FILENAME_LINE,"Test end");

  1051     std_log(LOG_FILENAME_LINE,"Test start");

  1052     TEST (T,  -12L,        dec | left, 0, 10, '@', "", "-12@@@@@@@");

  1053     std_log(LOG_FILENAME_LINE,"Test end");

  1054     std_log(LOG_FILENAME_LINE,"Test start");

  1055     TEST (T,  -123L,       dec | left, 0, 10, '*', "", "-123******");

  1056     std_log(LOG_FILENAME_LINE,"Test end");

  1057     std_log(LOG_FILENAME_LINE,"Test start");

  1058     TEST (T,  -1234L,      dec | left, 0, 10, '=', "", "-1234=====");

  1059     std_log(LOG_FILENAME_LINE,"Test end");

  1060     std_log(LOG_FILENAME_LINE,"Test start");

  1061     TEST (T,  -12345L,     dec | left, 0, 10, '.', "", "-12345....");

  1062     std_log(LOG_FILENAME_LINE,"Test end");

  1063     std_log(LOG_FILENAME_LINE,"Test start");

  1064     TEST (T,  -123456L,    dec | left, 0, 10, ',', "", "-123456,,,");

  1065     std_log(LOG_FILENAME_LINE,"Test end");

  1066     std_log(LOG_FILENAME_LINE,"Test start");

  1067     TEST (T,  -1234567L,   dec | left, 0, 10, '-', "", "-1234567--");

  1068     std_log(LOG_FILENAME_LINE,"Test end");

  1069     std_log(LOG_FILENAME_LINE,"Test start");

  1070     TEST (T,  -12345678L,  dec | left, 0, 10, '+', "", "-12345678+");

  1071     std_log(LOG_FILENAME_LINE,"Test end");

  1072     std_log(LOG_FILENAME_LINE,"Test start");

  1073     TEST (T,  -123456789L, dec | left, 0, 10, ';', "", "-123456789");

  1074     std_log(LOG_FILENAME_LINE,"Test end");

  1075     std_log(LOG_FILENAME_LINE,"Test start");

  1076 

  1077     // left justfication with grouping

  1078     TEST (T,  1L,         dec | left, 0, 14, ' ', "\2", "1             ");

  1079     std_log(LOG_FILENAME_LINE,"Test end");

  1080     std_log(LOG_FILENAME_LINE,"Test start");

  1081     TEST (T,  12L,        dec | left, 0, 14, ' ', "\2", "12            ");

  1082     std_log(LOG_FILENAME_LINE,"Test end");

  1083     std_log(LOG_FILENAME_LINE,"Test start");

  1084     TEST (T,  123L,       dec | left, 0, 14, ' ', "\2", "1,23          ");

  1085     std_log(LOG_FILENAME_LINE,"Test end");

  1086     std_log(LOG_FILENAME_LINE,"Test start");

  1087     TEST (T,  1234L,      dec | left, 0, 14, ' ', "\2", "12,34         ");

  1088     std_log(LOG_FILENAME_LINE,"Test end");

  1089     std_log(LOG_FILENAME_LINE,"Test start");

  1090     TEST (T,  12345L,     dec | left, 0, 14, ' ', "\2", "1,23,45       ");

  1091     std_log(LOG_FILENAME_LINE,"Test end");

  1092     std_log(LOG_FILENAME_LINE,"Test start");

  1093     TEST (T,  123456L,    dec | left, 0, 14, ' ', "\2", "12,34,56      ");

  1094     std_log(LOG_FILENAME_LINE,"Test end");

  1095     std_log(LOG_FILENAME_LINE,"Test start");

  1096     TEST (T,  1234567L,   dec | left, 0, 14, ' ', "\2", "1,23,45,67    ");

  1097     std_log(LOG_FILENAME_LINE,"Test end");

  1098     std_log(LOG_FILENAME_LINE,"Test start");

  1099     TEST (T,  12345678L,  dec | left, 0, 14, ' ', "\2", "12,34,56,78   ");

  1100     std_log(LOG_FILENAME_LINE,"Test end");

  1101     std_log(LOG_FILENAME_LINE,"Test start");

  1102     TEST (T,  123456789L, dec | left, 0, 14, ' ', "\2", "1,23,45,67,89 ");

  1103     std_log(LOG_FILENAME_LINE,"Test end");

  1104     std_log(LOG_FILENAME_LINE,"Test start");

  1105     TEST (T,  123456789L, dec | left, 0, 14, ',', "\2", "1,23,45,67,89,");

  1106     std_log(LOG_FILENAME_LINE,"Test end");

  1107     std_log(LOG_FILENAME_LINE,"Test start");

  1108 

  1109     TEST (T,  1L,         dec | left, 0, 14, ' ', "\2\1\3", "1             ");

  1110     std_log(LOG_FILENAME_LINE,"Test end");

  1111     std_log(LOG_FILENAME_LINE,"Test start");

  1112     TEST (T,  12L,        dec | left, 0, 14, ' ', "\2\1\3", "12            ");

  1113     std_log(LOG_FILENAME_LINE,"Test end");

  1114     std_log(LOG_FILENAME_LINE,"Test start");

  1115     TEST (T,  123L,       dec | left, 0, 14, ' ', "\2\1\3", "1,23          ");

  1116     std_log(LOG_FILENAME_LINE,"Test end");

  1117     std_log(LOG_FILENAME_LINE,"Test start");

  1118     TEST (T,  1234L,      dec | left, 0, 14, ' ', "\2\1\3", "1,2,34        ");

  1119     std_log(LOG_FILENAME_LINE,"Test end");

  1120     std_log(LOG_FILENAME_LINE,"Test start");

  1121     TEST (T,  12345L,     dec | left, 0, 14, ' ', "\2\1\3", "12,3,45       ");

  1122     std_log(LOG_FILENAME_LINE,"Test end");

  1123     std_log(LOG_FILENAME_LINE,"Test start");

  1124     TEST (T,  123456L,    dec | left, 0, 14, ' ', "\2\1\3", "123,4,56      ");

  1125     std_log(LOG_FILENAME_LINE,"Test end");

  1126     std_log(LOG_FILENAME_LINE,"Test start");

  1127     TEST (T,  1234567L,   dec | left, 0, 14, ' ', "\2\1\3", "1,234,5,67    ");

  1128     std_log(LOG_FILENAME_LINE,"Test end");

  1129     std_log(LOG_FILENAME_LINE,"Test start");

  1130     TEST (T,  12345678L,  dec | left, 0, 14, ' ', "\2\1\3", "12,345,6,78   ");

  1131     std_log(LOG_FILENAME_LINE,"Test end");

  1132     std_log(LOG_FILENAME_LINE,"Test start");

  1133     TEST (T,  123456789L, dec | left, 0, 14, ' ', "\2\1\3", "123,456,7,89  ");

  1134     std_log(LOG_FILENAME_LINE,"Test end");