Home | History | Annotate | Download | only in locale.money.put.members
      1 //===----------------------------------------------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is dual licensed under the MIT and the University of Illinois Open
      6 // Source Licenses. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // XFAIL: apple-darwin
     11 
     12 // REQUIRES: locale.fr_FR.UTF-8
     13 
     14 // <locale>
     15 
     16 // class money_put<charT, OutputIterator>
     17 
     18 // iter_type put(iter_type s, bool intl, ios_base& f, char_type fill,
     19 //               long double units) const;
     20 
     21 #include <locale>
     22 #include <ios>
     23 #include <streambuf>
     24 #include <cassert>
     25 #include "test_iterators.h"
     26 
     27 #include "platform_support.h" // locale name macros
     28 
     29 typedef std::money_put<char, output_iterator<char*> > Fn;
     30 
     31 class my_facet
     32     : public Fn
     33 {
     34 public:
     35     explicit my_facet(std::size_t refs = 0)
     36         : Fn(refs) {}
     37 };
     38 
     39 typedef std::money_put<wchar_t, output_iterator<wchar_t*> > Fw;
     40 
     41 class my_facetw
     42     : public Fw
     43 {
     44 public:
     45     explicit my_facetw(std::size_t refs = 0)
     46         : Fw(refs) {}
     47 };
     48 
     49 int main()
     50 {
     51     std::ios ios(0);
     52     std::string loc_name(LOCALE_fr_FR_UTF_8);
     53     ios.imbue(std::locale(ios.getloc(),
     54                           new std::moneypunct_byname<char, false>(loc_name)));
     55     ios.imbue(std::locale(ios.getloc(),
     56                           new std::moneypunct_byname<char, true>(loc_name)));
     57     ios.imbue(std::locale(ios.getloc(),
     58                           new std::moneypunct_byname<wchar_t, false>(loc_name)));
     59     ios.imbue(std::locale(ios.getloc(),
     60                           new std::moneypunct_byname<wchar_t, true>(loc_name)));
     61 {
     62     const my_facet f(1);
     63     // char, national
     64     {   // zero
     65         long double v = 0;
     66         char str[100];
     67         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
     68                                             false, ios, '*', v);
     69         std::string ex(str, iter.base());
     70         assert(ex == "0,00");
     71     }
     72     {   // negative one
     73         long double v = -1;
     74         char str[100];
     75         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
     76                                             false, ios, '*', v);
     77         std::string ex(str, iter.base());
     78         assert(ex == "-0,01");
     79     }
     80     {   // positive
     81         long double v = 123456789;
     82         char str[100];
     83         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
     84                                             false, ios, '*', v);
     85         std::string ex(str, iter.base());
     86         assert(ex == "1 234 567,89");
     87     }
     88     {   // negative
     89         long double v = -123456789;
     90         char str[100];
     91         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
     92                                             false, ios, '*', v);
     93         std::string ex(str, iter.base());
     94         assert(ex == "-1 234 567,89");
     95     }
     96     {   // zero, showbase
     97         long double v = 0;
     98         showbase(ios);
     99         char str[100];
    100         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    101                                             false, ios, '*', v);
    102         std::string ex(str, iter.base());
    103         assert(ex == "0,00 \u20ac");
    104     }
    105     {   // negative one, showbase
    106         long double v = -1;
    107         showbase(ios);
    108         char str[100];
    109         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    110                                             false, ios, '*', v);
    111         std::string ex(str, iter.base());
    112         assert(ex == "-0,01 \u20ac");
    113     }
    114     {   // positive, showbase
    115         long double v = 123456789;
    116         showbase(ios);
    117         char str[100];
    118         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    119                                             false, ios, '*', v);
    120         std::string ex(str, iter.base());
    121         assert(ex == "1 234 567,89 \u20ac");
    122     }
    123     {   // negative, showbase
    124         long double v = -123456789;
    125         showbase(ios);
    126         char str[100];
    127         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    128                                             false, ios, '*', v);
    129         std::string ex(str, iter.base());
    130         assert(ex == "-1 234 567,89 \u20ac");
    131     }
    132     {   // negative, showbase, left
    133         long double v = -123456789;
    134         showbase(ios);
    135         ios.width(20);
    136         left(ios);
    137         char str[100];
    138         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    139                                             false, ios, ' ', v);
    140         std::string ex(str, iter.base());
    141         assert(ex == "-1 234 567,89 \u20ac   ");
    142         assert(ios.width() == 0);
    143     }
    144     {   // negative, showbase, internal
    145         long double v = -123456789;
    146         showbase(ios);
    147         ios.width(20);
    148         internal(ios);
    149         char str[100];
    150         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    151                                             false, ios, ' ', v);
    152         std::string ex(str, iter.base());
    153         assert(ex == "-1 234 567,89    \u20ac");
    154         assert(ios.width() == 0);
    155     }
    156     {   // negative, showbase, right
    157         long double v = -123456789;
    158         showbase(ios);
    159         ios.width(20);
    160         right(ios);
    161         char str[100];
    162         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    163                                             false, ios, ' ', v);
    164         std::string ex(str, iter.base());
    165         assert(ex == "   -1 234 567,89 \u20ac");
    166         assert(ios.width() == 0);
    167     }
    168 
    169     // char, international
    170     noshowbase(ios);
    171     ios.unsetf(std::ios_base::adjustfield);
    172     {   // zero
    173         long double v = 0;
    174         char str[100];
    175         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    176                                             true, ios, '*', v);
    177         std::string ex(str, iter.base());
    178         assert(ex == "0,00");
    179     }
    180     {   // negative one
    181         long double v = -1;
    182         char str[100];
    183         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    184                                             true, ios, '*', v);
    185         std::string ex(str, iter.base());
    186         assert(ex == "-0,01");
    187     }
    188     {   // positive
    189         long double v = 123456789;
    190         char str[100];
    191         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    192                                             true, ios, '*', v);
    193         std::string ex(str, iter.base());
    194         assert(ex == "1 234 567,89");
    195     }
    196     {   // negative
    197         long double v = -123456789;
    198         char str[100];
    199         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    200                                             true, ios, '*', v);
    201         std::string ex(str, iter.base());
    202         assert(ex == "-1 234 567,89");
    203     }
    204     {   // zero, showbase
    205         long double v = 0;
    206         showbase(ios);
    207         char str[100];
    208         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    209                                             true, ios, '*', v);
    210         std::string ex(str, iter.base());
    211         assert(ex == "0,00 EUR");
    212     }
    213     {   // negative one, showbase
    214         long double v = -1;
    215         showbase(ios);
    216         char str[100];
    217         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    218                                             true, ios, '*', v);
    219         std::string ex(str, iter.base());
    220         assert(ex == "-0,01 EUR");
    221     }
    222     {   // positive, showbase
    223         long double v = 123456789;
    224         showbase(ios);
    225         char str[100];
    226         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    227                                             true, ios, '*', v);
    228         std::string ex(str, iter.base());
    229         assert(ex == "1 234 567,89 EUR");
    230     }
    231     {   // negative, showbase
    232         long double v = -123456789;
    233         showbase(ios);
    234         char str[100];
    235         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    236                                             true, ios, '*', v);
    237         std::string ex(str, iter.base());
    238         assert(ex == "-1 234 567,89 EUR");
    239     }
    240     {   // negative, showbase, left
    241         long double v = -123456789;
    242         showbase(ios);
    243         ios.width(20);
    244         left(ios);
    245         char str[100];
    246         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    247                                             true, ios, ' ', v);
    248         std::string ex(str, iter.base());
    249         assert(ex == "-1 234 567,89 EUR   ");
    250         assert(ios.width() == 0);
    251     }
    252     {   // negative, showbase, internal
    253         long double v = -123456789;
    254         showbase(ios);
    255         ios.width(20);
    256         internal(ios);
    257         char str[100];
    258         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    259                                             true, ios, ' ', v);
    260         std::string ex(str, iter.base());
    261         assert(ex == "-1 234 567,89    EUR");
    262         assert(ios.width() == 0);
    263     }
    264     {   // negative, showbase, right
    265         long double v = -123456789;
    266         showbase(ios);
    267         ios.width(20);
    268         right(ios);
    269         char str[100];
    270         output_iterator<char*> iter = f.put(output_iterator<char*>(str),
    271                                             true, ios, ' ', v);
    272         std::string ex(str, iter.base());
    273         assert(ex == "   -1 234 567,89 EUR");
    274         assert(ios.width() == 0);
    275     }
    276 }
    277 {
    278     const my_facetw f(1);
    279     // wchar_t, national
    280     noshowbase(ios);
    281     ios.unsetf(std::ios_base::adjustfield);
    282     {   // zero
    283         long double v = 0;
    284         wchar_t str[100];
    285         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    286                                             false, ios, '*', v);
    287         std::wstring ex(str, iter.base());
    288         assert(ex == L"0,00");
    289     }
    290     {   // negative one
    291         long double v = -1;
    292         wchar_t str[100];
    293         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    294                                             false, ios, '*', v);
    295         std::wstring ex(str, iter.base());
    296         assert(ex == L"-0,01");
    297     }
    298     {   // positive
    299         long double v = 123456789;
    300         wchar_t str[100];
    301         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    302                                             false, ios, '*', v);
    303         std::wstring ex(str, iter.base());
    304         assert(ex == L"1 234 567,89");
    305     }
    306     {   // negative
    307         long double v = -123456789;
    308         wchar_t str[100];
    309         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    310                                             false, ios, '*', v);
    311         std::wstring ex(str, iter.base());
    312         assert(ex == L"-1 234 567,89");
    313     }
    314     {   // zero, showbase
    315         long double v = 0;
    316         showbase(ios);
    317         wchar_t str[100];
    318         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    319                                             false, ios, '*', v);
    320         std::wstring ex(str, iter.base());
    321         assert(ex == L"0,00 \u20ac");
    322     }
    323     {   // negative one, showbase
    324         long double v = -1;
    325         showbase(ios);
    326         wchar_t str[100];
    327         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    328                                             false, ios, '*', v);
    329         std::wstring ex(str, iter.base());
    330         assert(ex == L"-0,01 \u20ac");
    331     }
    332     {   // positive, showbase
    333         long double v = 123456789;
    334         showbase(ios);
    335         wchar_t str[100];
    336         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    337                                             false, ios, '*', v);
    338         std::wstring ex(str, iter.base());
    339         assert(ex == L"1 234 567,89 \u20ac");
    340     }
    341     {   // negative, showbase
    342         long double v = -123456789;
    343         showbase(ios);
    344         wchar_t str[100];
    345         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    346                                             false, ios, '*', v);
    347         std::wstring ex(str, iter.base());
    348         assert(ex == L"-1 234 567,89 \u20ac");
    349     }
    350     {   // negative, showbase, left
    351         long double v = -123456789;
    352         showbase(ios);
    353         ios.width(20);
    354         left(ios);
    355         wchar_t str[100];
    356         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    357                                             false, ios, ' ', v);
    358         std::wstring ex(str, iter.base());
    359         assert(ex == L"-1 234 567,89 \u20ac     ");
    360         assert(ios.width() == 0);
    361     }
    362     {   // negative, showbase, internal
    363         long double v = -123456789;
    364         showbase(ios);
    365         ios.width(20);
    366         internal(ios);
    367         wchar_t str[100];
    368         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    369                                             false, ios, ' ', v);
    370         std::wstring ex(str, iter.base());
    371         assert(ex == L"-1 234 567,89      \u20ac");
    372         assert(ios.width() == 0);
    373     }
    374     {   // negative, showbase, right
    375         long double v = -123456789;
    376         showbase(ios);
    377         ios.width(20);
    378         right(ios);
    379         wchar_t str[100];
    380         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    381                                             false, ios, ' ', v);
    382         std::wstring ex(str, iter.base());
    383         assert(ex == L"     -1 234 567,89 \u20ac");
    384         assert(ios.width() == 0);
    385     }
    386 
    387     // wchar_t, international
    388     noshowbase(ios);
    389     ios.unsetf(std::ios_base::adjustfield);
    390     {   // zero
    391         long double v = 0;
    392         wchar_t str[100];
    393         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    394                                             true, ios, '*', v);
    395         std::wstring ex(str, iter.base());
    396         assert(ex == L"0,00");
    397     }
    398     {   // negative one
    399         long double v = -1;
    400         wchar_t str[100];
    401         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    402                                             true, ios, '*', v);
    403         std::wstring ex(str, iter.base());
    404         assert(ex == L"-0,01");
    405     }
    406     {   // positive
    407         long double v = 123456789;
    408         wchar_t str[100];
    409         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    410                                             true, ios, '*', v);
    411         std::wstring ex(str, iter.base());
    412         assert(ex == L"1 234 567,89");
    413     }
    414     {   // negative
    415         long double v = -123456789;
    416         wchar_t str[100];
    417         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    418                                             true, ios, '*', v);
    419         std::wstring ex(str, iter.base());
    420         assert(ex == L"-1 234 567,89");
    421     }
    422     {   // zero, showbase
    423         long double v = 0;
    424         showbase(ios);
    425         wchar_t str[100];
    426         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    427                                             true, ios, '*', v);
    428         std::wstring ex(str, iter.base());
    429         assert(ex == L"0,00 EUR");
    430     }
    431     {   // negative one, showbase
    432         long double v = -1;
    433         showbase(ios);
    434         wchar_t str[100];
    435         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    436                                             true, ios, '*', v);
    437         std::wstring ex(str, iter.base());
    438         assert(ex == L"-0,01 EUR");
    439     }
    440     {   // positive, showbase
    441         long double v = 123456789;
    442         showbase(ios);
    443         wchar_t str[100];
    444         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    445                                             true, ios, '*', v);
    446         std::wstring ex(str, iter.base());
    447         assert(ex == L"1 234 567,89 EUR");
    448     }
    449     {   // negative, showbase
    450         long double v = -123456789;
    451         showbase(ios);
    452         wchar_t str[100];
    453         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    454                                             true, ios, '*', v);
    455         std::wstring ex(str, iter.base());
    456         assert(ex == L"-1 234 567,89 EUR");
    457     }
    458     {   // negative, showbase, left
    459         long double v = -123456789;
    460         showbase(ios);
    461         ios.width(20);
    462         left(ios);
    463         wchar_t str[100];
    464         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    465                                             true, ios, ' ', v);
    466         std::wstring ex(str, iter.base());
    467         assert(ex == L"-1 234 567,89 EUR   ");
    468         assert(ios.width() == 0);
    469     }
    470     {   // negative, showbase, internal
    471         long double v = -123456789;
    472         showbase(ios);
    473         ios.width(20);
    474         internal(ios);
    475         wchar_t str[100];
    476         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    477                                             true, ios, ' ', v);
    478         std::wstring ex(str, iter.base());
    479         assert(ex == L"-1 234 567,89    EUR");
    480         assert(ios.width() == 0);
    481     }
    482     {   // negative, showbase, right
    483         long double v = -123456789;
    484         showbase(ios);
    485         ios.width(20);
    486         right(ios);
    487         wchar_t str[100];
    488         output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
    489                                             true, ios, ' ', v);
    490         std::wstring ex(str, iter.base());
    491         assert(ex == L"   -1 234 567,89 EUR");
    492         assert(ios.width() == 0);
    493     }
    494 }
    495 }
    496