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 //#if 0

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

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

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

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

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

    61 

    62 /**************************************************************************/

    63 

    64 // replacement ctype facet

    65 template <class charT>

    66 struct Ctype: std::ctype<charT>

    67 {

    68     typedef std::ctype<charT> Base;

    69 

    70     typedef typename Base::char_type char_type;

    71 

    72     static int n_widen_;

    73 

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

    75 

    76     virtual char_type do_widen (char c) const {

    77         ++n_widen_;

    78 

    79         switch (c) {

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

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

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

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

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

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

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

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

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

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

    90         default: break;

    91         }

    92 

    93         return char_type (c);

    94     }

    95 

    96     virtual const char_type*

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

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

    99     }

   100 };

   101 

   102 template <class charT>

   103 int Ctype<charT>::n_widen_;

   104 

   105 

   106 /**************************************************************************/

   107 

   108 // replacement numpunct facet

   109 

   110 template <class charT>

   111 struct Punct: std::numpunct<charT>

   112 {

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

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

   115 

   116     static char_type        decimal_point_;

   117     static char_type        thousands_sep_;

   118     static const char      *grouping_;

   119     static const char_type *truename_;

   120     static const char_type *falsename_;

   121 

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

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

   124 

   125     Punct (std::size_t ref = 0)

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

   127         ++n_objs_;

   128     }

   129 

   130     ~Punct () {

   131         --n_objs_;

   132     }

   133 

   134     virtual char_type do_decimal_point () const {

   135         return decimal_point_;

   136     }

   137 

   138     virtual std::string do_grouping () const {

   139         return grouping_;

   140     }

   141 

   142     virtual char_type do_thousands_sep () const {

   143         ++n_thousands_sep_;

   144         return thousands_sep_;

   145     }

   146 

   147     virtual string_type do_truename () const {

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

   149     }

   150 

   151     virtual string_type do_falsename () const {

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

   153     }

   154 };

   155 

   156 template <class charT>

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

   158 

   159 template <class charT>

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

   161 

   162 template <class charT>

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

   164 

   165 template <class charT>

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

   167 

   168 template <class charT>

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

   170 

   171 template <class charT>

   172 int Punct<charT>::n_thousands_sep_;

   173 

   174 template <class charT>

   175 int Punct<charT>::n_objs_;

   176 

   177 

   178 /**************************************************************************/

   179 

   180 template <class charT>

   181 struct Ios: std::basic_ios<charT>

   182 {

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

   184 };

   185 

   186 

   187 template <class charT>

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

   189 

   190 

   191 template <class charT>

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

   193 {

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

   195     typedef typename Base::char_type    char_type;

   196     typedef typename Base::iter_type    iter_type;

   197 

   198     enum {

   199         test_bool, test_short, test_ushort, test_int, test_uint,

   200         test_long, test_ulong, test_llong, test_ullong,

   201         test_pvoid, test_float, test_double, test_ldouble

   202     };

   203         

   204     static int ncalls_ [13];

   205 

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

   207 

   208 #ifndef _RWSTD_NO_BOOL

   209 

   210     virtual iter_type

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

   212         ++ncalls_ [test_bool];

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

   214     }

   215 

   216 #endif   // _RWSTD_NO_BOOL

   217 

   218     virtual iter_type

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

   220         ++ncalls_ [test_long];

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

   222     }

   223 

   224     virtual iter_type

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

   226             unsigned long v) const {

   227         ++ncalls_ [test_ulong];

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

   229     }

   230 

   231 #ifdef _RWSTD_LONG_LONG

   232 

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

   234     virtual iter_type

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

   236             unsigned _RWSTD_LONG_LONG v) const {

   237         ++ncalls_ [test_ullong];

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

   239     }

   240 

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

   242     virtual iter_type

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

   244             _RWSTD_LONG_LONG v) const {

   245         ++ncalls_ [test_llong];

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

   247     }

   248 

   249 #endif   // _RWSTD_LONG_LONG

   250 

   251     virtual iter_type

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

   253         ++ncalls_ [test_double];

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

   255     }

   256 

   257 #ifndef __SYMBIAN32__

   258 #ifndef _RWSTD_NO_LONG_DOUBLE

   259 

   260     virtual iter_type

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

   262             long double v) const {

   263         ++ncalls_ [test_ldouble];

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

   265     }

   266 #endif 

   267 #endif   // _RWSTD_NO_LONG_DOUBLE

   268 

   269     virtual iter_type

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

   271             const void *v) const {

   272         ++ncalls_ [test_pvoid];

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

   274     }

   275 };

   276 

   277 

   278 // explicit initialization of the static array below used

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

   280 template <class charT>

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

   282 

   283 /**************************************************************************/

   284 

   285 template <class charT, class T>

   286 void do_test (charT           /* dummy */,

   287               const char     *cname,    // charT name

   288               const char     *tname,    // T name

   289               int             lineno,   // line number

   290               T               val,      // value to format

   291               int             flags,    // ios flags

   292               std::streamsize prec,     // precision

   293               std::streamsize width,    // field width

   294               char            fill,     // fill character

   295               const char     *grouping, // grouping string

   296               const char     *str,      // expected output

   297               int             err_expect = -1,   // expected iostate

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

   299 {

   300     if (!rw_enabled (lineno)) {

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

   302         return;

   303     }

   304     

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

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

   307     // member functions are flushed

   308     const Punct<charT> pun (1);

   309 

   310     Ios<charT> ios;

   311     NumPut<charT> np;

   312 

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

   314 

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

   316     ios.precision (prec);

   317     ios.width (width);

   318     pun.grouping_ = grouping;

   319 

   320 //#if defined (_RWSTD_LDBL_MAX_10_EXP)

   321 

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

   323 

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

   325 

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

   327     charT buf [512] = { 0 };

   328 

   329 //#endif   // _RWSTD_LDBL_MAX_10_EXP

   330 

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

   332 

   333     // verify 22.2.2.2.2, p21

   334     if (ios.width ()) {

   335 

   336         static int width_fail = 0;

   337 

   338         // fail at most once for each specialization

   339         #ifndef __SYMBIAN32__

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

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

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

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

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

   345        #else

   346         {

   347           

   348            if(width_fail++)

   349            {

   350              

   351             failures++;

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

   353              

   354              }

   355         }

   356                     

   357         #endif           

   358     }

   359 

   360     /******************************************************************/

   361 

   362     if (str) {

   363 

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

   365 

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

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

   368             str = cbuf;

   369 

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

   371 

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

   373 

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

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

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

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

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

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

   380             }

   381 

   382 #endif   // _WIN{32,64}

   383         }

   384 

   385         #ifndef __SYMBIAN32__

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

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

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

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

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

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

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

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

   394                    flags, prec,

   395                    grouping && *grouping, grouping);

   396         #else

   397          {

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

   399           failures++;

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

   401                      

   402          } 

   403          #endif  // __SYMBIAN32__    

   404     }

   405 

   406     /******************************************************************/

   407 

   408 #ifndef NO_NUM_GET

   409 

   410     if (!rw_opt_enable_num_get)

   411         return;

   412 

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

   414     if (prec < 0)

   415         return;

   416 

   417     const charT *next = buf;

   418 

   419     // skip leading fill characters (if any)

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

   421 

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

   423     const charT *last = next;

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

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

   426 

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

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

   429     // up the input sequence)

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

   431         return;

   432 

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

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

   435     // or a digit

   436     if (   '-' == fill

   437         || '+' == fill

   438         || pun.thousands_sep_ == fill

   439         || pun.decimal_point_ == fill

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

   441         return;

   442 

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

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

   445     if (!*next && str)

   446         return;

   447 

   448     NumGet<charT> ng;

   449 

   450     T x = T ();

   451 

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

   453 

   454     if (-1 == err_expect) {

   455 

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

   457 

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

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

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

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

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

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

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

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

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

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

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

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

   470         // --end example]

   471 

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

   473             ? std::ios::goodbit

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

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

   476 

   477         val_expect = val;

   478     }

   479 

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

   481 #ifndef __SYMBIAN32__

   482     // verify the state

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

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

   485                "flags = %{If}, "

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

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

   488                __LINE__, cname,

   489                TOSTR (next), tname,

   490                flags,

   491                grouping && *grouping, grouping,

   492                err, err_expect);

   493 

   494     // verify the parsed value

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

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

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

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

   499                __LINE__, cname,

   500                TOSTR (next), tname,

   501                TOSTR (x), TOSTR (val_expect),

   502                flags,

   503                grouping && *grouping, grouping);

   504   #else

   505    {

   506    

   507    if(err != err_expect)

   508      {

   509      failures++;

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

   511      }

   512    if(!rw_equal (x, val_expect))

   513      {

   514      failures++;

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

   516      }

   517    

   518    

   519    

   520    }             

   521 #endif//__SYMBIAN32__

   522 #else

   523 

   524     _RWSTD_UNUSED (bufend);

   525     _RWSTD_UNUSED (err_expect);

   526     _RWSTD_UNUSED (val_expect);

   527 

   528 #endif   // NO_NUM_GET

   529 

   530 }

   531 

   532 /**************************************************************************/

   533 

   534 template <class charT>

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

   536 #if 0 //FIX

   537 template <class charT>

   538 void direct_use_test (charT, const char *cname)

   539 {

   540     _RWSTD_UNUSED (cname);

   541 

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

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

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

   545 

   546     Ios<charT> ios;

   547 

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

   549 

   550     Streambuf<charT> sb;

   551 

   552 #define DIRECT_USE_TEST(T) \

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

   554 

   555 #ifndef _RWSTD_NO_BOOL

   556 

   557     DIRECT_USE_TEST (bool);

   558 

   559 #endif   // _RWSTD_NO_BOOL

   560 

   561     DIRECT_USE_TEST (unsigned long);

   562     DIRECT_USE_TEST (long);

   563     DIRECT_USE_TEST (double);

   564 

   565 #ifndef _RWSTD_NO_LONG_DOUBLE

   566 

   567     DIRECT_USE_TEST (long double);

   568 

   569 #endif

   570 

   571     DIRECT_USE_TEST (void*);

   572 }

   573 #endif 

   574 /**************************************************************************/

   575 

   576 

   577 // for convenience

   578 #define boolalpha   std::ios_base::boolalpha

   579 #define dec         std::ios_base::dec

   580 #define fixed       std::ios_base::fixed

   581 #define hex         std::ios_base::hex

   582 #define internal    std::ios_base::internal

   583 #define left        std::ios_base::left

   584 #define oct         std::ios_base::oct

   585 #define right       std::ios_base::right

   586 #define scientific  std::ios_base::scientific

   587 #define showbase    std::ios_base::showbase

   588 #define showpoint   std::ios_base::showpoint

   589 #define showpos     std::ios_base::showpos

   590 #define skipws      std::ios_base::skipws

   591 #define unitbuf     std::ios_base::unitbuf

   592 #define uppercase   std::ios_base::uppercase

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

   594 #define bin         std::ios_base::binary

   595 #define adjustfield std::ios_base::adjustfield

   596 #define basefield   std::ios_base::basefield

   597 #define floatfield  std::ios_base::floatfield

   598 #define nolock      std::ios_base::nolock

   599 #define nolockbuf   std::ios_base::nolockbuf

   600 

   601 #define Bad         std::ios_base::badbit

   602 #define Eof         std::ios_base::eofbit

   603 #define Fail        std::ios_base::failbit

   604 #define Good        std::ios_base::goodbit

   605 

   606 

   607 template <class charT>

   608 void bool_test (charT, const char *cname)

   609 {

   610 #ifndef _RWSTD_NO_BOOL

   611 

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

   613 

   614     const char* const tname = "bool";

   615 

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

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

   618 

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

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

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

   622         { '\001', '\0' },        { '\0' }

   623     };

   624 

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

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

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

   628 

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

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

   631 #define TEST  do_test

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

   633 

   634     std_log(LOG_FILENAME_LINE,"Test start");

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

   636     std_log(LOG_FILENAME_LINE,"Test end");

   637     std_log(LOG_FILENAME_LINE,"Test start");

   638     

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

   640     std_log(LOG_FILENAME_LINE,"Test end");

   641     std_log(LOG_FILENAME_LINE,"Test start");

   642 

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

   644     std_log(LOG_FILENAME_LINE,"Test end");

   645     std_log(LOG_FILENAME_LINE,"Test start");

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

   647     std_log(LOG_FILENAME_LINE,"Test end");

   648     std_log(LOG_FILENAME_LINE,"Test start");

   649 

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

   651     std_log(LOG_FILENAME_LINE,"Test end");

   652     std_log(LOG_FILENAME_LINE,"Test start");

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

   654     std_log(LOG_FILENAME_LINE,"Test end");

   655     std_log(LOG_FILENAME_LINE,"Test start");

   656 

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

   658     std_log(LOG_FILENAME_LINE,"Test end");

   659     std_log(LOG_FILENAME_LINE,"Test start");

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

   661     std_log(LOG_FILENAME_LINE,"Test end");

   662     std_log(LOG_FILENAME_LINE,"Test start");

   663 

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

   665     std_log(LOG_FILENAME_LINE,"Test end");

   666     std_log(LOG_FILENAME_LINE,"Test start");

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

   668     std_log(LOG_FILENAME_LINE,"Test end");

   669     std_log(LOG_FILENAME_LINE,"Test start");

   670 

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

   672     std_log(LOG_FILENAME_LINE,"Test end");

   673     std_log(LOG_FILENAME_LINE,"Test start");

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

   675     std_log(LOG_FILENAME_LINE,"Test end");

   676     std_log(LOG_FILENAME_LINE,"Test start");

   677 

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

   679 

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

   681     std_log(LOG_FILENAME_LINE,"Test end");

   682     std_log(LOG_FILENAME_LINE,"Test start");

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

   684     std_log(LOG_FILENAME_LINE,"Test end");

   685     std_log(LOG_FILENAME_LINE,"Test start");

   686 

   687     // left justified boolalpha

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

   689     std_log(LOG_FILENAME_LINE,"Test end");

   690     std_log(LOG_FILENAME_LINE,"Test start");

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

   692     std_log(LOG_FILENAME_LINE,"Test end");

   693     std_log(LOG_FILENAME_LINE,"Test start");

   694 

   695     // right justified boolalpha

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

   697     std_log(LOG_FILENAME_LINE,"Test end");

   698     std_log(LOG_FILENAME_LINE,"Test start");

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

   700     std_log(LOG_FILENAME_LINE,"Test end");

   701     std_log(LOG_FILENAME_LINE,"Test start");

   702 

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

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

   705     std_log(LOG_FILENAME_LINE,"Test end");

   706     std_log(LOG_FILENAME_LINE,"Test start");

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

   708     std_log(LOG_FILENAME_LINE,"Test end");

   709 

   710 

   711 

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

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

   714 

   715     std_log(LOG_FILENAME_LINE,"Test start");

   716 

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

   718     std_log(LOG_FILENAME_LINE,"Test end");

   719     std_log(LOG_FILENAME_LINE,"Test start");

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

   721     std_log(LOG_FILENAME_LINE,"Test end");

   722     std_log(LOG_FILENAME_LINE,"Test start");

   723 

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

   725     std_log(LOG_FILENAME_LINE,"Test end");

   726     std_log(LOG_FILENAME_LINE,"Test start");

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

   728     std_log(LOG_FILENAME_LINE,"Test end");

   729 

   730 

   731 

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

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

   734 

   735     std_log(LOG_FILENAME_LINE,"Test start");

   736 

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

   738     std_log(LOG_FILENAME_LINE,"Test end");

   739     std_log(LOG_FILENAME_LINE,"Test start");

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

   741     std_log(LOG_FILENAME_LINE,"Test end");

   742     std_log(LOG_FILENAME_LINE,"Test start");

   743 

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

   745     std_log(LOG_FILENAME_LINE,"Test end");

   746     std_log(LOG_FILENAME_LINE,"Test start");

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

   748     std_log(LOG_FILENAME_LINE,"Test end");

   749 

   750 

   751 

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

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

   754 

   755     std_log(LOG_FILENAME_LINE,"Test start");

   756 

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

   758     std_log(LOG_FILENAME_LINE,"Test end");

   759     std_log(LOG_FILENAME_LINE,"Test start");

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

   761     std_log(LOG_FILENAME_LINE,"Test end");

   762     std_log(LOG_FILENAME_LINE,"Test start");

   763 

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

   765     std_log(LOG_FILENAME_LINE,"Test end");

   766     std_log(LOG_FILENAME_LINE,"Test start");

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

   768     std_log(LOG_FILENAME_LINE,"Test end");

   769     std_log(LOG_FILENAME_LINE,"Test start");

   770 

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

   772     std_log(LOG_FILENAME_LINE,"Test end");

   773     std_log(LOG_FILENAME_LINE,"Test start");

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

   775     std_log(LOG_FILENAME_LINE,"Test end");

   776     std_log(LOG_FILENAME_LINE,"Test start");

   777 

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

   779     std_log(LOG_FILENAME_LINE,"Test end");

   780     std_log(LOG_FILENAME_LINE,"Test start");

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

   782     std_log(LOG_FILENAME_LINE,"Test end");

   783 

   784 

   785 #endif   // _RWSTD_NO_BOOL

   786 

   787 }

   788 

   789 /**************************************************************************/

   790 

   791 template <class charT>

   792 void long_test (charT, const char *cname)

   793 {

   794     const char* const tname = "long";

   795 

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

   797 

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

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

   800 #ifndef	LONG_MIN 

   801 #undef LONG_MIN

   802 #define LONG_MIN _RWSTD_LONG_MIN

   803 #endif

   804 

   805 #ifndef	LONG_MAX

   806 #undef LONG_MAX

   807 #define LONG_MAX _RWSTD_LONG_MAX

   808 #endif

   809 

   810 #undef GET_FAIL

   811 #define GET_FAIL (Eof | Fail), LONG_MAX

   812 

   813     //////////////////////////////////////////////////////////////////

   814     // implicit decimal output

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

   816 

   817     std_log(LOG_FILENAME_LINE,"Test start");

   818 

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

   820     std_log(LOG_FILENAME_LINE,"Test end");

   821     std_log(LOG_FILENAME_LINE,"Test start");

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

   823     std_log(LOG_FILENAME_LINE,"Test end");

   824     std_log(LOG_FILENAME_LINE,"Test start");

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

   826     std_log(LOG_FILENAME_LINE,"Test end");

   827     std_log(LOG_FILENAME_LINE,"Test start");

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

   829     std_log(LOG_FILENAME_LINE,"Test end");

   830     std_log(LOG_FILENAME_LINE,"Test start");

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

   832     std_log(LOG_FILENAME_LINE,"Test end");

   833     std_log(LOG_FILENAME_LINE,"Test start");

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

   835     std_log(LOG_FILENAME_LINE,"Test end");

   836     std_log(LOG_FILENAME_LINE,"Test start");

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

   838     std_log(LOG_FILENAME_LINE,"Test end");

   839     std_log(LOG_FILENAME_LINE,"Test start");

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

   841     std_log(LOG_FILENAME_LINE,"Test end");

   842     std_log(LOG_FILENAME_LINE,"Test start");

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

   844     std_log(LOG_FILENAME_LINE,"Test end");

   845     std_log(LOG_FILENAME_LINE,"Test start");

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

   847     std_log(LOG_FILENAME_LINE,"Test end");

   848     std_log(LOG_FILENAME_LINE,"Test start");

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

   850     std_log(LOG_FILENAME_LINE,"Test end");

   851     std_log(LOG_FILENAME_LINE,"Test start");

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

   853     std_log(LOG_FILENAME_LINE,"Test end");

   854     std_log(LOG_FILENAME_LINE,"Test start");

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

   856     std_log(LOG_FILENAME_LINE,"Test end");

   857     std_log(LOG_FILENAME_LINE,"Test start");

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

   859     std_log(LOG_FILENAME_LINE,"Test end");

   860 

   861 

   862     //////////////////////////////////////////////////////////////////

   863     // explicit decimal ouptut

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

   865 

   866     std_log(LOG_FILENAME_LINE,"Test start");

   867 

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

   869     std_log(LOG_FILENAME_LINE,"Test end");

   870     std_log(LOG_FILENAME_LINE,"Test start");

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

   872     std_log(LOG_FILENAME_LINE,"Test end");

   873     std_log(LOG_FILENAME_LINE,"Test start");

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

   875     std_log(LOG_FILENAME_LINE,"Test end");

   876     std_log(LOG_FILENAME_LINE,"Test start");

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

   878     std_log(LOG_FILENAME_LINE,"Test end");

   879     std_log(LOG_FILENAME_LINE,"Test start");

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

   881     std_log(LOG_FILENAME_LINE,"Test end");

   882     std_log(LOG_FILENAME_LINE,"Test start");

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

   884     std_log(LOG_FILENAME_LINE,"Test end");

   885     std_log(LOG_FILENAME_LINE,"Test start");

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

   887     std_log(LOG_FILENAME_LINE,"Test end");

   888     std_log(LOG_FILENAME_LINE,"Test start");

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

   890     std_log(LOG_FILENAME_LINE,"Test end");

   891     std_log(LOG_FILENAME_LINE,"Test start");

   892 

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

   894     std_log(LOG_FILENAME_LINE,"Test end");

   895     std_log(LOG_FILENAME_LINE,"Test start");

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

   897     std_log(LOG_FILENAME_LINE,"Test end");

   898     std_log(LOG_FILENAME_LINE,"Test start");

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

   900     std_log(LOG_FILENAME_LINE,"Test end");

   901     std_log(LOG_FILENAME_LINE,"Test start");

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

   903     std_log(LOG_FILENAME_LINE,"Test end");

   904     std_log(LOG_FILENAME_LINE,"Test start");

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

   906     std_log(LOG_FILENAME_LINE,"Test end");

   907     std_log(LOG_FILENAME_LINE,"Test start");

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

   909     std_log(LOG_FILENAME_LINE,"Test end");

   910     std_log(LOG_FILENAME_LINE,"Test start");

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

   912     std_log(LOG_FILENAME_LINE,"Test end");

   913     std_log(LOG_FILENAME_LINE,"Test start");

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

   915     std_log(LOG_FILENAME_LINE,"Test end");

   916 

   917 

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

   919     std_log(LOG_FILENAME_LINE,"Test end");

   920     std_log(LOG_FILENAME_LINE,"Test start");

   921 

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

   923     std_log(LOG_FILENAME_LINE,"Test end");

   924     std_log(LOG_FILENAME_LINE,"Test start");

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

   926     std_log(LOG_FILENAME_LINE,"Test end");

   927     std_log(LOG_FILENAME_LINE,"Test start");

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

   929     std_log(LOG_FILENAME_LINE,"Test end");

   930     std_log(LOG_FILENAME_LINE,"Test start");

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

   932     std_log(LOG_FILENAME_LINE,"Test end");

   933     std_log(LOG_FILENAME_LINE,"Test start");

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

   935     std_log(LOG_FILENAME_LINE,"Test end");

   936 

   937 

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

   939 

   940     std_log(LOG_FILENAME_LINE,"Test start");

   941 

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

   943     std_log(LOG_FILENAME_LINE,"Test end");

   944     std_log(LOG_FILENAME_LINE,"Test start");

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

   946     std_log(LOG_FILENAME_LINE,"Test end");

   947     std_log(LOG_FILENAME_LINE,"Test start");

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

   949     std_log(LOG_FILENAME_LINE,"Test end");

   950     std_log(LOG_FILENAME_LINE,"Test start");

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

   952     std_log(LOG_FILENAME_LINE,"Test end");

   953     std_log(LOG_FILENAME_LINE,"Test start");

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

   955     std_log(LOG_FILENAME_LINE,"Test end");

   956 

   957 

   958     rw_info (0, 0, __LINE__,

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

   960 

   961     std_log(LOG_FILENAME_LINE,"Test start");

   962 

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

   964     std_log(LOG_FILENAME_LINE,"Test end");

   965     std_log(LOG_FILENAME_LINE,"Test start");

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

   967     std_log(LOG_FILENAME_LINE,"Test end");

   968     std_log(LOG_FILENAME_LINE,"Test start");

   969     TEST (T,   -1239L, 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, LONG_MAX, 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, LONG_MIN, dec | showbase | showpos, 0, 0, ' ', "", "%#+ld");

   976     std_log(LOG_FILENAME_LINE,"Test end");

   977     std_log(LOG_FILENAME_LINE,"Test start");

   978 

   979     // left justfication

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

   981 

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

   983     std_log(LOG_FILENAME_LINE,"Test end");

   984     std_log(LOG_FILENAME_LINE,"Test start");

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

   986     std_log(LOG_FILENAME_LINE,"Test end");

   987     std_log(LOG_FILENAME_LINE,"Test start");

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

   989     std_log(LOG_FILENAME_LINE,"Test end");

   990     std_log(LOG_FILENAME_LINE,"Test start");

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

   992     std_log(LOG_FILENAME_LINE,"Test end");

   993     std_log(LOG_FILENAME_LINE,"Test start");

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

   995     std_log(LOG_FILENAME_LINE,"Test end");

   996     std_log(LOG_FILENAME_LINE,"Test start");

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

   998     std_log(LOG_FILENAME_LINE,"Test end");

   999     std_log(LOG_FILENAME_LINE,"Test start");

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

  1001     std_log(LOG_FILENAME_LINE,"Test end");

  1002     std_log(LOG_FILENAME_LINE,"Test start");

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

  1004     std_log(LOG_FILENAME_LINE,"Test end");

  1005     std_log(LOG_FILENAME_LINE,"Test start");

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

  1007     std_log(LOG_FILENAME_LINE,"Test end");

  1008     std_log(LOG_FILENAME_LINE,"Test start");

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

  1010     std_log(LOG_FILENAME_LINE,"Test end");

  1011     std_log(LOG_FILENAME_LINE,"Test start");

  1012 

  1013     // left justfication, signed dec

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

  1015     std_log(LOG_FILENAME_LINE,"Test end");

  1016     std_log(LOG_FILENAME_LINE,"Test start");

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

  1018     std_log(LOG_FILENAME_LINE,"Test end");

  1019     std_log(LOG_FILENAME_LINE,"Test start");

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

  1021     std_log(LOG_FILENAME_LINE,"Test end");

  1022     std_log(LOG_FILENAME_LINE,"Test start");

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

  1024     std_log(LOG_FILENAME_LINE,"Test end");

  1025     std_log(LOG_FILENAME_LINE,"Test start");

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

  1027     std_log(LOG_FILENAME_LINE,"Test end");

  1028     std_log(LOG_FILENAME_LINE,"Test start");

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

  1030     std_log(LOG_FILENAME_LINE,"Test end");

  1031     std_log(LOG_FILENAME_LINE,"Test start");

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

  1033     std_log(LOG_FILENAME_LINE,"Test end");

  1034     std_log(LOG_FILENAME_LINE,"Test start");

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

  1036     std_log(LOG_FILENAME_LINE,"Test end");

  1037     std_log(LOG_FILENAME_LINE,"Test start");

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

  1039     std_log(LOG_FILENAME_LINE,"Test end");

  1040     std_log(LOG_FILENAME_LINE,"Test start");

  1041 

  1042     // left justification with fill char

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

  1044     std_log(LOG_FILENAME_LINE,"Test end");

  1045     std_log(LOG_FILENAME_LINE,"Test start");

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

  1047     std_log(LOG_FILENAME_LINE,"Test end");

  1048     std_log(LOG_FILENAME_LINE,"Test start");

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

  1050     std_log(LOG_FILENAME_LINE,"Test end");

  1051     std_log(LOG_FILENAME_LINE,"Test start");

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

  1053     std_log(LOG_FILENAME_LINE,"Test end");

  1054     std_log(LOG_FILENAME_LINE,"Test start");

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

  1056     std_log(LOG_FILENAME_LINE,"Test end");

  1057     std_log(LOG_FILENAME_LINE,"Test start");

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

  1059     std_log(LOG_FILENAME_LINE,"Test end");

  1060     std_log(LOG_FILENAME_LINE,"Test start");

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

  1062     std_log(LOG_FILENAME_LINE,"Test end");

  1063     std_log(LOG_FILENAME_LINE,"Test start");

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

  1065     std_log(LOG_FILENAME_LINE,"Test end");

  1066     std_log(LOG_FILENAME_LINE,"Test start");

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

  1068     std_log(LOG_FILENAME_LINE,"Test end");

  1069     std_log(LOG_FILENAME_LINE,"Test start");

  1070 

  1071     // left justfication with grouping

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

  1073     std_log(LOG_FILENAME_LINE,"Test end");

  1074     std_log(LOG_FILENAME_LINE,"Test start");

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

  1076     std_log(LOG_FILENAME_LINE,"Test end");

  1077     std_log(LOG_FILENAME_LINE,"Test start");

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

  1079     std_log(LOG_FILENAME_LINE,"Test end");

  1080     std_log(LOG_FILENAME_LINE,"Test start");

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

  1082     std_log(LOG_FILENAME_LINE,"Test end");

  1083     std_log(LOG_FILENAME_LINE,"Test start");

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

  1085     std_log(LOG_FILENAME_LINE,"Test end");

  1086     std_log(LOG_FILENAME_LINE,"Test start");

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

  1088     std_log(LOG_FILENAME_LINE,"Test end");

  1089     std_log(LOG_FILENAME_LINE,"Test start");

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

  1091     std_log(LOG_FILENAME_LINE,"Test end");

  1092     std_log(LOG_FILENAME_LINE,"Test start");

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

  1094     std_log(LOG_FILENAME_LINE,"Test end");

  1095     std_log(LOG_FILENAME_LINE,"Test start");

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

  1097     std_log(LOG_FILENAME_LINE,"Test end");

  1098     std_log(LOG_FILENAME_LINE,"Test start");

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

  1100     std_log(LOG_FILENAME_LINE,"Test end");

  1101     std_log(LOG_FILENAME_LINE,"Test start");

  1102 

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

  1104     std_log(LOG_FILENAME_LINE,"Test end");

  1105     std_log(LOG_FILENAME_LINE,"Test start");

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

  1107     std_log(LOG_FILENAME_LINE,"Test end");

  1108     std_log(LOG_FILENAME_LINE,"Test start");

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

  1110     std_log(LOG_FILENAME_LINE,"Test end");

  1111     std_log(LOG_FILENAME_LINE,"Test start");

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

  1113     std_log(LOG_FILENAME_LINE,"Test end");

  1114     std_log(LOG_FILENAME_LINE,"Test start");

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

  1116     std_log(LOG_FILENAME_LINE,"Test end");

  1117     std_log(LOG_FILENAME_LINE,"Test start");

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

  1119     std_log(LOG_FILENAME_LINE,"Test end");

  1120     std_log(LOG_FILENAME_LINE,"Test start");

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

  1122     std_log(LOG_FILENAME_LINE,"Test end");

  1123     std_log(LOG_FILENAME_LINE,"Test start");

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

  1125     std_log(LOG_FILENAME_LINE,"Test end");

  1126     std_log(LOG_FILENAME_LINE,"Test start");

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

  1128     std_log(LOG_FILENAME_LINE,"Test end");

  1129     std_log(LOG_FILENAME_LINE,"Test start");

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

  1131     std_log(LOG_FILENAME_LINE,"Test end");

  1132     std_log(LOG_FILENAME_LINE,"Test start");

  1133 

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