libstdc++-v3/testsuite/22_locale/money_put_members_char.cc

   1 // 2001-08-27 Benjamin Kosnik  <bkoz@redhat.com>
   2
   3 // Copyright (C) 2001-2002 Free Software Foundation
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 2, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19 // USA.
  20
  21 // 22.2.6.2.1 money_put members
  22
  23 #include <locale>
  24 #include <sstream>
  25 #include <testsuite_hooks.h>
  26
  27 // XXX This test is not working for non-glibc locale models.
  28 // { dg-do run { xfail *-*-* } }
  29
  30 // test string version
  31 void test01()
  32 {
  33   using namespace std;
  34   typedef money_base::part part;
  35   typedef money_base::pattern pattern;
  36   typedef ostreambuf_iterator<char> iterator_type;
  37
  38   bool test = true;
  39
  40   // basic construction
  41   locale loc_c = locale::classic();
  42   locale loc_hk("en_HK");
  43   locale loc_fr("fr_FR@euro");
  44   locale loc_de("de_DE");
  45   VERIFY( loc_c != loc_de );
  46   VERIFY( loc_hk != loc_fr );
  47   VERIFY( loc_hk != loc_de );
  48   VERIFY( loc_de != loc_fr );
  49
  50   // cache the moneypunct facets
  51   typedef moneypunct<char, true> __money_true;
  52   typedef moneypunct<char, false> __money_false;
  53   const __money_true& monpunct_c_t = use_facet<__money_true>(loc_c);
  54   const __money_true& monpunct_de_t = use_facet<__money_true>(loc_de);
  55   const __money_false& monpunct_c_f = use_facet<__money_false>(loc_c);
  56   const __money_false& monpunct_de_f = use_facet<__money_false>(loc_de);
  57   const __money_true& monpunct_hk_t = use_facet<__money_true>(loc_hk);
  58   const __money_false& monpunct_hk_f = use_facet<__money_false>(loc_hk);
  59
  60   // sanity check the data is correct.
  61   const string empty;
  62
  63   // total EPA budget FY 2002
  64   const string digits1("720000000000");
  65
  66   // est. cost, national missile "defense", expressed as a loss in USD 2001
  67   const string digits2("-10000000000000");
  68
  69   // not valid input
  70   const string digits3("-A");
  71
  72   // input less than frac_digits
  73   const string digits4("-1");
  74
  75
  76   ostringstream oss;
  77   oss.imbue(loc_de);
  78   // cache the money_put facet
  79   const money_put<char>& mon_put = use_facet<money_put<char> >(oss.getloc());
  80
  81
  82   iterator_type os_it01 = mon_put.put(oss.rdbuf(), true, oss, '*', digits1);
  83   string result1 = oss.str();
  84   VERIFY( result1 == "7.200.000.000,00 ");
  85
  86   oss.str(empty);
  87   iterator_type os_it02 = mon_put.put(oss.rdbuf(), false, oss, '*', digits1);
  88   string result2 = oss.str();
  89   VERIFY( result2 == "7.200.000.000,00 ");
  90
  91   // intl and non-intl versions should be the same.
  92   VERIFY( result1 == result2 );
  93
  94   // now try with showbase, to get currency symbol in format
  95   oss.setf(ios_base::showbase);
  96
  97   oss.str(empty);
  98   iterator_type os_it03 = mon_put.put(oss.rdbuf(), true, oss, '*', digits1);
  99   string result3 = oss.str();
 100   VERIFY( result3 == "7.200.000.000,00 DEM ");
 101
 102   oss.str(empty);
 103   iterator_type os_it04 = mon_put.put(oss.rdbuf(), false, oss, '*', digits1);
 104   string result4 = oss.str();
 105   VERIFY( result4 == "7.200.000.000,00 DM");
 106
 107   // intl and non-intl versions should be different.
 108   VERIFY( result3 != result4 );
 109   VERIFY( result3 != result1 );
 110   VERIFY( result4 != result2 );
 111
 112   // test sign of more than one digit, say hong kong.
 113   oss.imbue(loc_hk);
 114   oss.str(empty);
 115   iterator_type os_it05 = mon_put.put(oss.rdbuf(), false, oss, '*', digits1);
 116   string result5 = oss.str();
 117   VERIFY( result5 == "HK$7,200,000,000.00");
 118
 119   oss.str(empty);
 120   iterator_type os_it06 = mon_put.put(oss.rdbuf(), true, oss, '*', digits2);
 121   string result6 = oss.str();
 122   VERIFY( result6 == "(HKD 100,000,000,000.00)");
 123
 124   // test one-digit formats without zero padding
 125   oss.imbue(loc_c);
 126   oss.str(empty);
 127   iterator_type os_it07 = mon_put.put(oss.rdbuf(), true, oss, '*', digits4);
 128   string result7 = oss.str();
 129   VERIFY( result7 == "1");
 130
 131   // test one-digit formats with zero padding, zero frac widths
 132   oss.imbue(loc_hk);
 133   oss.str(empty);
 134   iterator_type os_it08 = mon_put.put(oss.rdbuf(), true, oss, '*', digits4);
 135   string result8 = oss.str();
 136   VERIFY( result8 == "(HKD .01)");
 137
 138   oss.unsetf(ios_base::showbase);
 139
 140   // test bunk input
 141   oss.str(empty);
 142   iterator_type os_it09 = mon_put.put(oss.rdbuf(), true, oss, '*', digits3);
 143   string result9 = oss.str();
 144   VERIFY( result9 == "");
 145
 146   // test io.width() > length
 147   // test various fill strategies
 148   oss.imbue(loc_de);
 149
 150   oss.str(empty);
 151   oss.width(20);
 152   iterator_type os_it10 = mon_put.put(oss.rdbuf(), true, oss, '*', digits4);
 153   string result10 = oss.str();
 154   VERIFY( result10 == "***************-,01 ");
 155
 156   oss.str(empty);
 157   oss.width(20);
 158   oss.setf(ios_base::internal);
 159   iterator_type os_it11 = mon_put.put(oss.rdbuf(), true, oss, '*', digits4);
 160   string result11 = oss.str();
 161   VERIFY( result11 == "-,01****************");
 162 }
 163
 164 // test double version
 165 void test02()
 166 {
 167   using namespace std;
 168   typedef money_base::part part;
 169   typedef money_base::pattern pattern;
 170   typedef ostreambuf_iterator<char> iterator_type;
 171
 172   bool test = true;
 173
 174   // basic construction
 175   locale loc_c = locale::classic();
 176   locale loc_hk("en_HK");
 177   locale loc_fr("fr_FR@euro");
 178   locale loc_de("de_DE");
 179   VERIFY( loc_c != loc_de );
 180   VERIFY( loc_hk != loc_fr );
 181   VERIFY( loc_hk != loc_de );
 182   VERIFY( loc_de != loc_fr );
 183
 184   // cache the moneypunct facets
 185   typedef moneypunct<char, true> __money_true;
 186   typedef moneypunct<char, false> __money_false;
 187   const __money_true& monpunct_c_t = use_facet<__money_true>(loc_c);
 188   const __money_true& monpunct_de_t = use_facet<__money_true>(loc_de);
 189   const __money_false& monpunct_c_f = use_facet<__money_false>(loc_c);
 190   const __money_false& monpunct_de_f = use_facet<__money_false>(loc_de);
 191   const __money_true& monpunct_hk_t = use_facet<__money_true>(loc_hk);
 192   const __money_false& monpunct_hk_f = use_facet<__money_false>(loc_hk);
 193
 194   // sanity check the data is correct.
 195   const string empty;
 196
 197   // total EPA budget FY 2002
 198   const long double  digits1 = 720000000000;
 199
 200   // est. cost, national missile "defense", expressed as a loss in USD 2001
 201   const long double digits2 = -10000000000000;
 202
 203   // input less than frac_digits
 204   const long double digits4 = -1;
 205
 206
 207   ostringstream oss;
 208   oss.imbue(loc_de);
 209   // cache the money_put facet
 210   const money_put<char>& mon_put = use_facet<money_put<char> >(oss.getloc());
 211
 212
 213   iterator_type os_it01 = mon_put.put(oss.rdbuf(), true, oss, '*', digits1);
 214   string result1 = oss.str();
 215   VERIFY( result1 == "7.200.000.000,00 ");
 216
 217   oss.str(empty);
 218   iterator_type os_it02 = mon_put.put(oss.rdbuf(), false, oss, '*', digits1);
 219   string result2 = oss.str();
 220   VERIFY( result2 == "7.200.000.000,00 ");
 221
 222   // intl and non-intl versions should be the same.
 223   VERIFY( result1 == result2 );
 224
 225   // now try with showbase, to get currency symbol in format
 226   oss.setf(ios_base::showbase);
 227
 228   oss.str(empty);
 229  iterator_type os_it03 = mon_put.put(oss.rdbuf(), true, oss, '*', digits1);
 230   string result3 = oss.str();
 231   VERIFY( result3 == "7.200.000.000,00 DEM ");
 232
 233   oss.str(empty);
 234   iterator_type os_it04 = mon_put.put(oss.rdbuf(), false, oss, '*', digits1);
 235   string result4 = oss.str();
 236   VERIFY( result4 == "7.200.000.000,00 DM");
 237
 238   // intl and non-intl versions should be different.
 239   VERIFY( result3 != result4 );
 240   VERIFY( result3 != result1 );
 241   VERIFY( result4 != result2 );
 242 }
 243
 244 void test03()
 245 {
 246   using namespace std;
 247   bool test = true;
 248
 249   // Check money_put works with other iterators besides streambuf
 250   // output iterators. (As long as output_iterator requirements are met.)
 251   typedef string::iterator iter_type;
 252   typedef money_put<char, iter_type> mon_put_type;
 253   const ios_base::iostate goodbit = ios_base::goodbit;
 254   const ios_base::iostate eofbit = ios_base::eofbit;
 255   ios_base::iostate err = goodbit;
 256   const locale loc_c = locale::classic();
 257   // woman, art, thief (stole the blues)
 258   const string str("1943 Janis Joplin");
 259   const long double ld = 1943;
 260   const string x(str.size(), 'x'); // have to have allocated string!
 261   string res;
 262
 263   ostringstream oss;
 264   oss.imbue(locale(loc_c, new mon_put_type));
 265
 266   // Iterator advanced, state, output.
 267   const mon_put_type& mp = use_facet<mon_put_type>(oss.getloc());
 268
 269   // 01 string
 270   res = x;
 271   iter_type ret1 = mp.put(res.begin(), false, oss, ' ', str);
 272   string sanity1(res.begin(), ret1);
 273   VERIFY( err == goodbit );
 274   VERIFY( res == "1943xxxxxxxxxxxxx" );
 275   VERIFY( sanity1 == "1943" );
 276
 277   // 02 long double
 278   res = x;
 279   iter_type ret2 = mp.put(res.begin(), false, oss, ' ', ld);
 280   string sanity2(res.begin(), ret2);
 281   VERIFY( err == goodbit );
 282   VERIFY( res == "1943xxxxxxxxxxxxx" );
 283   VERIFY( sanity2 == "1943" );
 284 }
 285
 286 int main()
 287 {
 288   test01();
 289   test02();
 290   test03();
 291   return 0;
 292 }