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
29typedef std::money_put<char, output_iterator<char*> > Fn;
30
31class my_facet
32    : public Fn
33{
34public:
35    explicit my_facet(std::size_t refs = 0)
36        : Fn(refs) {}
37};
38
39typedef std::money_put<wchar_t, output_iterator<wchar_t*> > Fw;
40
41class my_facetw
42    : public Fw
43{
44public:
45    explicit my_facetw(std::size_t refs = 0)
46        : Fw(refs) {}
47};
48
49int 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