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