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