1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 // <locale>
10
11 // class num_put<charT, OutputIterator>
12
13 // iter_type put(iter_type s, ios_base& iob, char_type fill, double v) const;
14
15 // XFAIL: LIBCXX-WINDOWS-FIXME
16
17 #include <locale>
18 #include <ios>
19 #include <cassert>
20 #include <streambuf>
21 #include <cmath>
22 #include "test_macros.h"
23 #include "test_iterators.h"
24
25 typedef std::num_put<char, output_iterator<char*> > F;
26
27 class my_facet
28 : public F
29 {
30 public:
my_facet(std::size_t refs=0)31 explicit my_facet(std::size_t refs = 0)
32 : F(refs) {}
33 };
34
35 class my_numpunct
36 : public std::numpunct<char>
37 {
38 public:
my_numpunct()39 my_numpunct() : std::numpunct<char>() {}
40
41 protected:
do_decimal_point() const42 virtual char_type do_decimal_point() const {return ';';}
do_thousands_sep() const43 virtual char_type do_thousands_sep() const {return '_';}
do_grouping() const44 virtual std::string do_grouping() const {return std::string("\1\2\3");}
45 };
46
test1()47 void test1()
48 {
49 char str[200];
50 output_iterator<char*> iter;
51 std::locale lc = std::locale::classic();
52 std::locale lg(lc, new my_numpunct);
53 const my_facet f(1);
54 {
55 double v = +0.;
56 std::ios ios(0);
57 // %g
58 {
59 ios.precision(0);
60 {
61 nouppercase(ios);
62 {
63 noshowpos(ios);
64 {
65 noshowpoint(ios);
66 {
67 ios.imbue(lc);
68 {
69 ios.width(0);
70 {
71 iter = f.put(output_iterator<char*>(str), ios, '*', v);
72 std::string ex(str, iter.base());
73 assert(ex == "0");
74 assert(ios.width() == 0);
75 }
76 ios.width(25);
77 left(ios);
78 {
79 iter = f.put(output_iterator<char*>(str), ios, '*', v);
80 std::string ex(str, iter.base());
81 assert(ex == "0************************");
82 assert(ios.width() == 0);
83 }
84 ios.width(25);
85 right(ios);
86 {
87 iter = f.put(output_iterator<char*>(str), ios, '*', v);
88 std::string ex(str, iter.base());
89 assert(ex == "************************0");
90 assert(ios.width() == 0);
91 }
92 ios.width(25);
93 internal(ios);
94 {
95 iter = f.put(output_iterator<char*>(str), ios, '*', v);
96 std::string ex(str, iter.base());
97 assert(ex == "************************0");
98 assert(ios.width() == 0);
99 }
100 }
101 ios.imbue(lg);
102 {
103 ios.width(0);
104 {
105 iter = f.put(output_iterator<char*>(str), ios, '*', v);
106 std::string ex(str, iter.base());
107 assert(ex == "0");
108 assert(ios.width() == 0);
109 }
110 ios.width(25);
111 left(ios);
112 {
113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
114 std::string ex(str, iter.base());
115 assert(ex == "0************************");
116 assert(ios.width() == 0);
117 }
118 ios.width(25);
119 right(ios);
120 {
121 iter = f.put(output_iterator<char*>(str), ios, '*', v);
122 std::string ex(str, iter.base());
123 assert(ex == "************************0");
124 assert(ios.width() == 0);
125 }
126 ios.width(25);
127 internal(ios);
128 {
129 iter = f.put(output_iterator<char*>(str), ios, '*', v);
130 std::string ex(str, iter.base());
131 assert(ex == "************************0");
132 assert(ios.width() == 0);
133 }
134 }
135 }
136 showpoint(ios);
137 {
138 ios.imbue(lc);
139 {
140 ios.width(0);
141 {
142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
143 std::string ex(str, iter.base());
144 assert(ex == "0.");
145 assert(ios.width() == 0);
146 }
147 ios.width(25);
148 left(ios);
149 {
150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
151 std::string ex(str, iter.base());
152 assert(ex == "0.***********************");
153 assert(ios.width() == 0);
154 }
155 ios.width(25);
156 right(ios);
157 {
158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
159 std::string ex(str, iter.base());
160 assert(ex == "***********************0.");
161 assert(ios.width() == 0);
162 }
163 ios.width(25);
164 internal(ios);
165 {
166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
167 std::string ex(str, iter.base());
168 assert(ex == "***********************0.");
169 assert(ios.width() == 0);
170 }
171 }
172 ios.imbue(lg);
173 {
174 ios.width(0);
175 {
176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
177 std::string ex(str, iter.base());
178 assert(ex == "0;");
179 assert(ios.width() == 0);
180 }
181 ios.width(25);
182 left(ios);
183 {
184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
185 std::string ex(str, iter.base());
186 assert(ex == "0;***********************");
187 assert(ios.width() == 0);
188 }
189 ios.width(25);
190 right(ios);
191 {
192 iter = f.put(output_iterator<char*>(str), ios, '*', v);
193 std::string ex(str, iter.base());
194 assert(ex == "***********************0;");
195 assert(ios.width() == 0);
196 }
197 ios.width(25);
198 internal(ios);
199 {
200 iter = f.put(output_iterator<char*>(str), ios, '*', v);
201 std::string ex(str, iter.base());
202 assert(ex == "***********************0;");
203 assert(ios.width() == 0);
204 }
205 }
206 }
207 }
208 showpos(ios);
209 {
210 noshowpoint(ios);
211 {
212 ios.imbue(lc);
213 {
214 ios.width(0);
215 {
216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
217 std::string ex(str, iter.base());
218 assert(ex == "+0");
219 assert(ios.width() == 0);
220 }
221 ios.width(25);
222 left(ios);
223 {
224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
225 std::string ex(str, iter.base());
226 assert(ex == "+0***********************");
227 assert(ios.width() == 0);
228 }
229 ios.width(25);
230 right(ios);
231 {
232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
233 std::string ex(str, iter.base());
234 assert(ex == "***********************+0");
235 assert(ios.width() == 0);
236 }
237 ios.width(25);
238 internal(ios);
239 {
240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
241 std::string ex(str, iter.base());
242 assert(ex == "+***********************0");
243 assert(ios.width() == 0);
244 }
245 }
246 ios.imbue(lg);
247 {
248 ios.width(0);
249 {
250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
251 std::string ex(str, iter.base());
252 assert(ex == "+0");
253 assert(ios.width() == 0);
254 }
255 ios.width(25);
256 left(ios);
257 {
258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
259 std::string ex(str, iter.base());
260 assert(ex == "+0***********************");
261 assert(ios.width() == 0);
262 }
263 ios.width(25);
264 right(ios);
265 {
266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
267 std::string ex(str, iter.base());
268 assert(ex == "***********************+0");
269 assert(ios.width() == 0);
270 }
271 ios.width(25);
272 internal(ios);
273 {
274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
275 std::string ex(str, iter.base());
276 assert(ex == "+***********************0");
277 assert(ios.width() == 0);
278 }
279 }
280 }
281 showpoint(ios);
282 {
283 ios.imbue(lc);
284 {
285 ios.width(0);
286 {
287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
288 std::string ex(str, iter.base());
289 assert(ex == "+0.");
290 assert(ios.width() == 0);
291 }
292 ios.width(25);
293 left(ios);
294 {
295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
296 std::string ex(str, iter.base());
297 assert(ex == "+0.**********************");
298 assert(ios.width() == 0);
299 }
300 ios.width(25);
301 right(ios);
302 {
303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
304 std::string ex(str, iter.base());
305 assert(ex == "**********************+0.");
306 assert(ios.width() == 0);
307 }
308 ios.width(25);
309 internal(ios);
310 {
311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
312 std::string ex(str, iter.base());
313 assert(ex == "+**********************0.");
314 assert(ios.width() == 0);
315 }
316 }
317 ios.imbue(lg);
318 {
319 ios.width(0);
320 {
321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
322 std::string ex(str, iter.base());
323 assert(ex == "+0;");
324 assert(ios.width() == 0);
325 }
326 ios.width(25);
327 left(ios);
328 {
329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
330 std::string ex(str, iter.base());
331 assert(ex == "+0;**********************");
332 assert(ios.width() == 0);
333 }
334 ios.width(25);
335 right(ios);
336 {
337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
338 std::string ex(str, iter.base());
339 assert(ex == "**********************+0;");
340 assert(ios.width() == 0);
341 }
342 ios.width(25);
343 internal(ios);
344 {
345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
346 std::string ex(str, iter.base());
347 assert(ex == "+**********************0;");
348 assert(ios.width() == 0);
349 }
350 }
351 }
352 }
353 }
354 uppercase(ios);
355 {
356 noshowpos(ios);
357 {
358 noshowpoint(ios);
359 {
360 ios.imbue(lc);
361 {
362 ios.width(0);
363 {
364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
365 std::string ex(str, iter.base());
366 assert(ex == "0");
367 assert(ios.width() == 0);
368 }
369 ios.width(25);
370 left(ios);
371 {
372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
373 std::string ex(str, iter.base());
374 assert(ex == "0************************");
375 assert(ios.width() == 0);
376 }
377 ios.width(25);
378 right(ios);
379 {
380 iter = f.put(output_iterator<char*>(str), ios, '*', v);
381 std::string ex(str, iter.base());
382 assert(ex == "************************0");
383 assert(ios.width() == 0);
384 }
385 ios.width(25);
386 internal(ios);
387 {
388 iter = f.put(output_iterator<char*>(str), ios, '*', v);
389 std::string ex(str, iter.base());
390 assert(ex == "************************0");
391 assert(ios.width() == 0);
392 }
393 }
394 ios.imbue(lg);
395 {
396 ios.width(0);
397 {
398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
399 std::string ex(str, iter.base());
400 assert(ex == "0");
401 assert(ios.width() == 0);
402 }
403 ios.width(25);
404 left(ios);
405 {
406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
407 std::string ex(str, iter.base());
408 assert(ex == "0************************");
409 assert(ios.width() == 0);
410 }
411 ios.width(25);
412 right(ios);
413 {
414 iter = f.put(output_iterator<char*>(str), ios, '*', v);
415 std::string ex(str, iter.base());
416 assert(ex == "************************0");
417 assert(ios.width() == 0);
418 }
419 ios.width(25);
420 internal(ios);
421 {
422 iter = f.put(output_iterator<char*>(str), ios, '*', v);
423 std::string ex(str, iter.base());
424 assert(ex == "************************0");
425 assert(ios.width() == 0);
426 }
427 }
428 }
429 showpoint(ios);
430 {
431 ios.imbue(lc);
432 {
433 ios.width(0);
434 {
435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
436 std::string ex(str, iter.base());
437 assert(ex == "0.");
438 assert(ios.width() == 0);
439 }
440 ios.width(25);
441 left(ios);
442 {
443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
444 std::string ex(str, iter.base());
445 assert(ex == "0.***********************");
446 assert(ios.width() == 0);
447 }
448 ios.width(25);
449 right(ios);
450 {
451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
452 std::string ex(str, iter.base());
453 assert(ex == "***********************0.");
454 assert(ios.width() == 0);
455 }
456 ios.width(25);
457 internal(ios);
458 {
459 iter = f.put(output_iterator<char*>(str), ios, '*', v);
460 std::string ex(str, iter.base());
461 assert(ex == "***********************0.");
462 assert(ios.width() == 0);
463 }
464 }
465 ios.imbue(lg);
466 {
467 ios.width(0);
468 {
469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
470 std::string ex(str, iter.base());
471 assert(ex == "0;");
472 assert(ios.width() == 0);
473 }
474 ios.width(25);
475 left(ios);
476 {
477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
478 std::string ex(str, iter.base());
479 assert(ex == "0;***********************");
480 assert(ios.width() == 0);
481 }
482 ios.width(25);
483 right(ios);
484 {
485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
486 std::string ex(str, iter.base());
487 assert(ex == "***********************0;");
488 assert(ios.width() == 0);
489 }
490 ios.width(25);
491 internal(ios);
492 {
493 iter = f.put(output_iterator<char*>(str), ios, '*', v);
494 std::string ex(str, iter.base());
495 assert(ex == "***********************0;");
496 assert(ios.width() == 0);
497 }
498 }
499 }
500 }
501 showpos(ios);
502 {
503 noshowpoint(ios);
504 {
505 ios.imbue(lc);
506 {
507 ios.width(0);
508 {
509 iter = f.put(output_iterator<char*>(str), ios, '*', v);
510 std::string ex(str, iter.base());
511 assert(ex == "+0");
512 assert(ios.width() == 0);
513 }
514 ios.width(25);
515 left(ios);
516 {
517 iter = f.put(output_iterator<char*>(str), ios, '*', v);
518 std::string ex(str, iter.base());
519 assert(ex == "+0***********************");
520 assert(ios.width() == 0);
521 }
522 ios.width(25);
523 right(ios);
524 {
525 iter = f.put(output_iterator<char*>(str), ios, '*', v);
526 std::string ex(str, iter.base());
527 assert(ex == "***********************+0");
528 assert(ios.width() == 0);
529 }
530 ios.width(25);
531 internal(ios);
532 {
533 iter = f.put(output_iterator<char*>(str), ios, '*', v);
534 std::string ex(str, iter.base());
535 assert(ex == "+***********************0");
536 assert(ios.width() == 0);
537 }
538 }
539 ios.imbue(lg);
540 {
541 ios.width(0);
542 {
543 iter = f.put(output_iterator<char*>(str), ios, '*', v);
544 std::string ex(str, iter.base());
545 assert(ex == "+0");
546 assert(ios.width() == 0);
547 }
548 ios.width(25);
549 left(ios);
550 {
551 iter = f.put(output_iterator<char*>(str), ios, '*', v);
552 std::string ex(str, iter.base());
553 assert(ex == "+0***********************");
554 assert(ios.width() == 0);
555 }
556 ios.width(25);
557 right(ios);
558 {
559 iter = f.put(output_iterator<char*>(str), ios, '*', v);
560 std::string ex(str, iter.base());
561 assert(ex == "***********************+0");
562 assert(ios.width() == 0);
563 }
564 ios.width(25);
565 internal(ios);
566 {
567 iter = f.put(output_iterator<char*>(str), ios, '*', v);
568 std::string ex(str, iter.base());
569 assert(ex == "+***********************0");
570 assert(ios.width() == 0);
571 }
572 }
573 }
574 showpoint(ios);
575 {
576 ios.imbue(lc);
577 {
578 ios.width(0);
579 {
580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
581 std::string ex(str, iter.base());
582 assert(ex == "+0.");
583 assert(ios.width() == 0);
584 }
585 ios.width(25);
586 left(ios);
587 {
588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
589 std::string ex(str, iter.base());
590 assert(ex == "+0.**********************");
591 assert(ios.width() == 0);
592 }
593 ios.width(25);
594 right(ios);
595 {
596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
597 std::string ex(str, iter.base());
598 assert(ex == "**********************+0.");
599 assert(ios.width() == 0);
600 }
601 ios.width(25);
602 internal(ios);
603 {
604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
605 std::string ex(str, iter.base());
606 assert(ex == "+**********************0.");
607 assert(ios.width() == 0);
608 }
609 }
610 ios.imbue(lg);
611 {
612 ios.width(0);
613 {
614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
615 std::string ex(str, iter.base());
616 assert(ex == "+0;");
617 assert(ios.width() == 0);
618 }
619 ios.width(25);
620 left(ios);
621 {
622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
623 std::string ex(str, iter.base());
624 assert(ex == "+0;**********************");
625 assert(ios.width() == 0);
626 }
627 ios.width(25);
628 right(ios);
629 {
630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
631 std::string ex(str, iter.base());
632 assert(ex == "**********************+0;");
633 assert(ios.width() == 0);
634 }
635 ios.width(25);
636 internal(ios);
637 {
638 iter = f.put(output_iterator<char*>(str), ios, '*', v);
639 std::string ex(str, iter.base());
640 assert(ex == "+**********************0;");
641 assert(ios.width() == 0);
642 }
643 }
644 }
645 }
646 }
647 }
648 ios.precision(1);
649 {
650 nouppercase(ios);
651 {
652 noshowpos(ios);
653 {
654 noshowpoint(ios);
655 {
656 ios.imbue(lc);
657 {
658 ios.width(0);
659 {
660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
661 std::string ex(str, iter.base());
662 assert(ex == "0");
663 assert(ios.width() == 0);
664 }
665 ios.width(25);
666 left(ios);
667 {
668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
669 std::string ex(str, iter.base());
670 assert(ex == "0************************");
671 assert(ios.width() == 0);
672 }
673 ios.width(25);
674 right(ios);
675 {
676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
677 std::string ex(str, iter.base());
678 assert(ex == "************************0");
679 assert(ios.width() == 0);
680 }
681 ios.width(25);
682 internal(ios);
683 {
684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
685 std::string ex(str, iter.base());
686 assert(ex == "************************0");
687 assert(ios.width() == 0);
688 }
689 }
690 ios.imbue(lg);
691 {
692 ios.width(0);
693 {
694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
695 std::string ex(str, iter.base());
696 assert(ex == "0");
697 assert(ios.width() == 0);
698 }
699 ios.width(25);
700 left(ios);
701 {
702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
703 std::string ex(str, iter.base());
704 assert(ex == "0************************");
705 assert(ios.width() == 0);
706 }
707 ios.width(25);
708 right(ios);
709 {
710 iter = f.put(output_iterator<char*>(str), ios, '*', v);
711 std::string ex(str, iter.base());
712 assert(ex == "************************0");
713 assert(ios.width() == 0);
714 }
715 ios.width(25);
716 internal(ios);
717 {
718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
719 std::string ex(str, iter.base());
720 assert(ex == "************************0");
721 assert(ios.width() == 0);
722 }
723 }
724 }
725 showpoint(ios);
726 {
727 ios.imbue(lc);
728 {
729 ios.width(0);
730 {
731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
732 std::string ex(str, iter.base());
733 assert(ex == "0.");
734 assert(ios.width() == 0);
735 }
736 ios.width(25);
737 left(ios);
738 {
739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
740 std::string ex(str, iter.base());
741 assert(ex == "0.***********************");
742 assert(ios.width() == 0);
743 }
744 ios.width(25);
745 right(ios);
746 {
747 iter = f.put(output_iterator<char*>(str), ios, '*', v);
748 std::string ex(str, iter.base());
749 assert(ex == "***********************0.");
750 assert(ios.width() == 0);
751 }
752 ios.width(25);
753 internal(ios);
754 {
755 iter = f.put(output_iterator<char*>(str), ios, '*', v);
756 std::string ex(str, iter.base());
757 assert(ex == "***********************0.");
758 assert(ios.width() == 0);
759 }
760 }
761 ios.imbue(lg);
762 {
763 ios.width(0);
764 {
765 iter = f.put(output_iterator<char*>(str), ios, '*', v);
766 std::string ex(str, iter.base());
767 assert(ex == "0;");
768 assert(ios.width() == 0);
769 }
770 ios.width(25);
771 left(ios);
772 {
773 iter = f.put(output_iterator<char*>(str), ios, '*', v);
774 std::string ex(str, iter.base());
775 assert(ex == "0;***********************");
776 assert(ios.width() == 0);
777 }
778 ios.width(25);
779 right(ios);
780 {
781 iter = f.put(output_iterator<char*>(str), ios, '*', v);
782 std::string ex(str, iter.base());
783 assert(ex == "***********************0;");
784 assert(ios.width() == 0);
785 }
786 ios.width(25);
787 internal(ios);
788 {
789 iter = f.put(output_iterator<char*>(str), ios, '*', v);
790 std::string ex(str, iter.base());
791 assert(ex == "***********************0;");
792 assert(ios.width() == 0);
793 }
794 }
795 }
796 }
797 showpos(ios);
798 {
799 noshowpoint(ios);
800 {
801 ios.imbue(lc);
802 {
803 ios.width(0);
804 {
805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
806 std::string ex(str, iter.base());
807 assert(ex == "+0");
808 assert(ios.width() == 0);
809 }
810 ios.width(25);
811 left(ios);
812 {
813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
814 std::string ex(str, iter.base());
815 assert(ex == "+0***********************");
816 assert(ios.width() == 0);
817 }
818 ios.width(25);
819 right(ios);
820 {
821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
822 std::string ex(str, iter.base());
823 assert(ex == "***********************+0");
824 assert(ios.width() == 0);
825 }
826 ios.width(25);
827 internal(ios);
828 {
829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
830 std::string ex(str, iter.base());
831 assert(ex == "+***********************0");
832 assert(ios.width() == 0);
833 }
834 }
835 ios.imbue(lg);
836 {
837 ios.width(0);
838 {
839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
840 std::string ex(str, iter.base());
841 assert(ex == "+0");
842 assert(ios.width() == 0);
843 }
844 ios.width(25);
845 left(ios);
846 {
847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
848 std::string ex(str, iter.base());
849 assert(ex == "+0***********************");
850 assert(ios.width() == 0);
851 }
852 ios.width(25);
853 right(ios);
854 {
855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
856 std::string ex(str, iter.base());
857 assert(ex == "***********************+0");
858 assert(ios.width() == 0);
859 }
860 ios.width(25);
861 internal(ios);
862 {
863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
864 std::string ex(str, iter.base());
865 assert(ex == "+***********************0");
866 assert(ios.width() == 0);
867 }
868 }
869 }
870 showpoint(ios);
871 {
872 ios.imbue(lc);
873 {
874 ios.width(0);
875 {
876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
877 std::string ex(str, iter.base());
878 assert(ex == "+0.");
879 assert(ios.width() == 0);
880 }
881 ios.width(25);
882 left(ios);
883 {
884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
885 std::string ex(str, iter.base());
886 assert(ex == "+0.**********************");
887 assert(ios.width() == 0);
888 }
889 ios.width(25);
890 right(ios);
891 {
892 iter = f.put(output_iterator<char*>(str), ios, '*', v);
893 std::string ex(str, iter.base());
894 assert(ex == "**********************+0.");
895 assert(ios.width() == 0);
896 }
897 ios.width(25);
898 internal(ios);
899 {
900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
901 std::string ex(str, iter.base());
902 assert(ex == "+**********************0.");
903 assert(ios.width() == 0);
904 }
905 }
906 ios.imbue(lg);
907 {
908 ios.width(0);
909 {
910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
911 std::string ex(str, iter.base());
912 assert(ex == "+0;");
913 assert(ios.width() == 0);
914 }
915 ios.width(25);
916 left(ios);
917 {
918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
919 std::string ex(str, iter.base());
920 assert(ex == "+0;**********************");
921 assert(ios.width() == 0);
922 }
923 ios.width(25);
924 right(ios);
925 {
926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
927 std::string ex(str, iter.base());
928 assert(ex == "**********************+0;");
929 assert(ios.width() == 0);
930 }
931 ios.width(25);
932 internal(ios);
933 {
934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
935 std::string ex(str, iter.base());
936 assert(ex == "+**********************0;");
937 assert(ios.width() == 0);
938 }
939 }
940 }
941 }
942 }
943 uppercase(ios);
944 {
945 noshowpos(ios);
946 {
947 noshowpoint(ios);
948 {
949 ios.imbue(lc);
950 {
951 ios.width(0);
952 {
953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
954 std::string ex(str, iter.base());
955 assert(ex == "0");
956 assert(ios.width() == 0);
957 }
958 ios.width(25);
959 left(ios);
960 {
961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
962 std::string ex(str, iter.base());
963 assert(ex == "0************************");
964 assert(ios.width() == 0);
965 }
966 ios.width(25);
967 right(ios);
968 {
969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
970 std::string ex(str, iter.base());
971 assert(ex == "************************0");
972 assert(ios.width() == 0);
973 }
974 ios.width(25);
975 internal(ios);
976 {
977 iter = f.put(output_iterator<char*>(str), ios, '*', v);
978 std::string ex(str, iter.base());
979 assert(ex == "************************0");
980 assert(ios.width() == 0);
981 }
982 }
983 ios.imbue(lg);
984 {
985 ios.width(0);
986 {
987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
988 std::string ex(str, iter.base());
989 assert(ex == "0");
990 assert(ios.width() == 0);
991 }
992 ios.width(25);
993 left(ios);
994 {
995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
996 std::string ex(str, iter.base());
997 assert(ex == "0************************");
998 assert(ios.width() == 0);
999 }
1000 ios.width(25);
1001 right(ios);
1002 {
1003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1004 std::string ex(str, iter.base());
1005 assert(ex == "************************0");
1006 assert(ios.width() == 0);
1007 }
1008 ios.width(25);
1009 internal(ios);
1010 {
1011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1012 std::string ex(str, iter.base());
1013 assert(ex == "************************0");
1014 assert(ios.width() == 0);
1015 }
1016 }
1017 }
1018 showpoint(ios);
1019 {
1020 ios.imbue(lc);
1021 {
1022 ios.width(0);
1023 {
1024 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1025 std::string ex(str, iter.base());
1026 assert(ex == "0.");
1027 assert(ios.width() == 0);
1028 }
1029 ios.width(25);
1030 left(ios);
1031 {
1032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1033 std::string ex(str, iter.base());
1034 assert(ex == "0.***********************");
1035 assert(ios.width() == 0);
1036 }
1037 ios.width(25);
1038 right(ios);
1039 {
1040 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1041 std::string ex(str, iter.base());
1042 assert(ex == "***********************0.");
1043 assert(ios.width() == 0);
1044 }
1045 ios.width(25);
1046 internal(ios);
1047 {
1048 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1049 std::string ex(str, iter.base());
1050 assert(ex == "***********************0.");
1051 assert(ios.width() == 0);
1052 }
1053 }
1054 ios.imbue(lg);
1055 {
1056 ios.width(0);
1057 {
1058 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1059 std::string ex(str, iter.base());
1060 assert(ex == "0;");
1061 assert(ios.width() == 0);
1062 }
1063 ios.width(25);
1064 left(ios);
1065 {
1066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1067 std::string ex(str, iter.base());
1068 assert(ex == "0;***********************");
1069 assert(ios.width() == 0);
1070 }
1071 ios.width(25);
1072 right(ios);
1073 {
1074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1075 std::string ex(str, iter.base());
1076 assert(ex == "***********************0;");
1077 assert(ios.width() == 0);
1078 }
1079 ios.width(25);
1080 internal(ios);
1081 {
1082 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1083 std::string ex(str, iter.base());
1084 assert(ex == "***********************0;");
1085 assert(ios.width() == 0);
1086 }
1087 }
1088 }
1089 }
1090 showpos(ios);
1091 {
1092 noshowpoint(ios);
1093 {
1094 ios.imbue(lc);
1095 {
1096 ios.width(0);
1097 {
1098 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1099 std::string ex(str, iter.base());
1100 assert(ex == "+0");
1101 assert(ios.width() == 0);
1102 }
1103 ios.width(25);
1104 left(ios);
1105 {
1106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1107 std::string ex(str, iter.base());
1108 assert(ex == "+0***********************");
1109 assert(ios.width() == 0);
1110 }
1111 ios.width(25);
1112 right(ios);
1113 {
1114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1115 std::string ex(str, iter.base());
1116 assert(ex == "***********************+0");
1117 assert(ios.width() == 0);
1118 }
1119 ios.width(25);
1120 internal(ios);
1121 {
1122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1123 std::string ex(str, iter.base());
1124 assert(ex == "+***********************0");
1125 assert(ios.width() == 0);
1126 }
1127 }
1128 ios.imbue(lg);
1129 {
1130 ios.width(0);
1131 {
1132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1133 std::string ex(str, iter.base());
1134 assert(ex == "+0");
1135 assert(ios.width() == 0);
1136 }
1137 ios.width(25);
1138 left(ios);
1139 {
1140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1141 std::string ex(str, iter.base());
1142 assert(ex == "+0***********************");
1143 assert(ios.width() == 0);
1144 }
1145 ios.width(25);
1146 right(ios);
1147 {
1148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1149 std::string ex(str, iter.base());
1150 assert(ex == "***********************+0");
1151 assert(ios.width() == 0);
1152 }
1153 ios.width(25);
1154 internal(ios);
1155 {
1156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1157 std::string ex(str, iter.base());
1158 assert(ex == "+***********************0");
1159 assert(ios.width() == 0);
1160 }
1161 }
1162 }
1163 showpoint(ios);
1164 {
1165 ios.imbue(lc);
1166 {
1167 ios.width(0);
1168 {
1169 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1170 std::string ex(str, iter.base());
1171 assert(ex == "+0.");
1172 assert(ios.width() == 0);
1173 }
1174 ios.width(25);
1175 left(ios);
1176 {
1177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1178 std::string ex(str, iter.base());
1179 assert(ex == "+0.**********************");
1180 assert(ios.width() == 0);
1181 }
1182 ios.width(25);
1183 right(ios);
1184 {
1185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1186 std::string ex(str, iter.base());
1187 assert(ex == "**********************+0.");
1188 assert(ios.width() == 0);
1189 }
1190 ios.width(25);
1191 internal(ios);
1192 {
1193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1194 std::string ex(str, iter.base());
1195 assert(ex == "+**********************0.");
1196 assert(ios.width() == 0);
1197 }
1198 }
1199 ios.imbue(lg);
1200 {
1201 ios.width(0);
1202 {
1203 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1204 std::string ex(str, iter.base());
1205 assert(ex == "+0;");
1206 assert(ios.width() == 0);
1207 }
1208 ios.width(25);
1209 left(ios);
1210 {
1211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1212 std::string ex(str, iter.base());
1213 assert(ex == "+0;**********************");
1214 assert(ios.width() == 0);
1215 }
1216 ios.width(25);
1217 right(ios);
1218 {
1219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1220 std::string ex(str, iter.base());
1221 assert(ex == "**********************+0;");
1222 assert(ios.width() == 0);
1223 }
1224 ios.width(25);
1225 internal(ios);
1226 {
1227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1228 std::string ex(str, iter.base());
1229 assert(ex == "+**********************0;");
1230 assert(ios.width() == 0);
1231 }
1232 }
1233 }
1234 }
1235 }
1236 }
1237 ios.precision(6);
1238 {
1239 nouppercase(ios);
1240 {
1241 noshowpos(ios);
1242 {
1243 noshowpoint(ios);
1244 {
1245 ios.imbue(lc);
1246 {
1247 ios.width(0);
1248 {
1249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1250 std::string ex(str, iter.base());
1251 assert(ex == "0");
1252 assert(ios.width() == 0);
1253 }
1254 ios.width(25);
1255 left(ios);
1256 {
1257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1258 std::string ex(str, iter.base());
1259 assert(ex == "0************************");
1260 assert(ios.width() == 0);
1261 }
1262 ios.width(25);
1263 right(ios);
1264 {
1265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1266 std::string ex(str, iter.base());
1267 assert(ex == "************************0");
1268 assert(ios.width() == 0);
1269 }
1270 ios.width(25);
1271 internal(ios);
1272 {
1273 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1274 std::string ex(str, iter.base());
1275 assert(ex == "************************0");
1276 assert(ios.width() == 0);
1277 }
1278 }
1279 ios.imbue(lg);
1280 {
1281 ios.width(0);
1282 {
1283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1284 std::string ex(str, iter.base());
1285 assert(ex == "0");
1286 assert(ios.width() == 0);
1287 }
1288 ios.width(25);
1289 left(ios);
1290 {
1291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1292 std::string ex(str, iter.base());
1293 assert(ex == "0************************");
1294 assert(ios.width() == 0);
1295 }
1296 ios.width(25);
1297 right(ios);
1298 {
1299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1300 std::string ex(str, iter.base());
1301 assert(ex == "************************0");
1302 assert(ios.width() == 0);
1303 }
1304 ios.width(25);
1305 internal(ios);
1306 {
1307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1308 std::string ex(str, iter.base());
1309 assert(ex == "************************0");
1310 assert(ios.width() == 0);
1311 }
1312 }
1313 }
1314 showpoint(ios);
1315 {
1316 ios.imbue(lc);
1317 {
1318 ios.width(0);
1319 {
1320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1321 std::string ex(str, iter.base());
1322 assert(ex == "0.00000");
1323 assert(ios.width() == 0);
1324 }
1325 ios.width(25);
1326 left(ios);
1327 {
1328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1329 std::string ex(str, iter.base());
1330 assert(ex == "0.00000******************");
1331 assert(ios.width() == 0);
1332 }
1333 ios.width(25);
1334 right(ios);
1335 {
1336 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1337 std::string ex(str, iter.base());
1338 assert(ex == "******************0.00000");
1339 assert(ios.width() == 0);
1340 }
1341 ios.width(25);
1342 internal(ios);
1343 {
1344 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1345 std::string ex(str, iter.base());
1346 assert(ex == "******************0.00000");
1347 assert(ios.width() == 0);
1348 }
1349 }
1350 ios.imbue(lg);
1351 {
1352 ios.width(0);
1353 {
1354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1355 std::string ex(str, iter.base());
1356 assert(ex == "0;00000");
1357 assert(ios.width() == 0);
1358 }
1359 ios.width(25);
1360 left(ios);
1361 {
1362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1363 std::string ex(str, iter.base());
1364 assert(ex == "0;00000******************");
1365 assert(ios.width() == 0);
1366 }
1367 ios.width(25);
1368 right(ios);
1369 {
1370 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1371 std::string ex(str, iter.base());
1372 assert(ex == "******************0;00000");
1373 assert(ios.width() == 0);
1374 }
1375 ios.width(25);
1376 internal(ios);
1377 {
1378 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1379 std::string ex(str, iter.base());
1380 assert(ex == "******************0;00000");
1381 assert(ios.width() == 0);
1382 }
1383 }
1384 }
1385 }
1386 showpos(ios);
1387 {
1388 noshowpoint(ios);
1389 {
1390 ios.imbue(lc);
1391 {
1392 ios.width(0);
1393 {
1394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1395 std::string ex(str, iter.base());
1396 assert(ex == "+0");
1397 assert(ios.width() == 0);
1398 }
1399 ios.width(25);
1400 left(ios);
1401 {
1402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1403 std::string ex(str, iter.base());
1404 assert(ex == "+0***********************");
1405 assert(ios.width() == 0);
1406 }
1407 ios.width(25);
1408 right(ios);
1409 {
1410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1411 std::string ex(str, iter.base());
1412 assert(ex == "***********************+0");
1413 assert(ios.width() == 0);
1414 }
1415 ios.width(25);
1416 internal(ios);
1417 {
1418 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1419 std::string ex(str, iter.base());
1420 assert(ex == "+***********************0");
1421 assert(ios.width() == 0);
1422 }
1423 }
1424 ios.imbue(lg);
1425 {
1426 ios.width(0);
1427 {
1428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1429 std::string ex(str, iter.base());
1430 assert(ex == "+0");
1431 assert(ios.width() == 0);
1432 }
1433 ios.width(25);
1434 left(ios);
1435 {
1436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1437 std::string ex(str, iter.base());
1438 assert(ex == "+0***********************");
1439 assert(ios.width() == 0);
1440 }
1441 ios.width(25);
1442 right(ios);
1443 {
1444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1445 std::string ex(str, iter.base());
1446 assert(ex == "***********************+0");
1447 assert(ios.width() == 0);
1448 }
1449 ios.width(25);
1450 internal(ios);
1451 {
1452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1453 std::string ex(str, iter.base());
1454 assert(ex == "+***********************0");
1455 assert(ios.width() == 0);
1456 }
1457 }
1458 }
1459 showpoint(ios);
1460 {
1461 ios.imbue(lc);
1462 {
1463 ios.width(0);
1464 {
1465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1466 std::string ex(str, iter.base());
1467 assert(ex == "+0.00000");
1468 assert(ios.width() == 0);
1469 }
1470 ios.width(25);
1471 left(ios);
1472 {
1473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1474 std::string ex(str, iter.base());
1475 assert(ex == "+0.00000*****************");
1476 assert(ios.width() == 0);
1477 }
1478 ios.width(25);
1479 right(ios);
1480 {
1481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1482 std::string ex(str, iter.base());
1483 assert(ex == "*****************+0.00000");
1484 assert(ios.width() == 0);
1485 }
1486 ios.width(25);
1487 internal(ios);
1488 {
1489 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1490 std::string ex(str, iter.base());
1491 assert(ex == "+*****************0.00000");
1492 assert(ios.width() == 0);
1493 }
1494 }
1495 ios.imbue(lg);
1496 {
1497 ios.width(0);
1498 {
1499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1500 std::string ex(str, iter.base());
1501 assert(ex == "+0;00000");
1502 assert(ios.width() == 0);
1503 }
1504 ios.width(25);
1505 left(ios);
1506 {
1507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1508 std::string ex(str, iter.base());
1509 assert(ex == "+0;00000*****************");
1510 assert(ios.width() == 0);
1511 }
1512 ios.width(25);
1513 right(ios);
1514 {
1515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1516 std::string ex(str, iter.base());
1517 assert(ex == "*****************+0;00000");
1518 assert(ios.width() == 0);
1519 }
1520 ios.width(25);
1521 internal(ios);
1522 {
1523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1524 std::string ex(str, iter.base());
1525 assert(ex == "+*****************0;00000");
1526 assert(ios.width() == 0);
1527 }
1528 }
1529 }
1530 }
1531 }
1532 uppercase(ios);
1533 {
1534 noshowpos(ios);
1535 {
1536 noshowpoint(ios);
1537 {
1538 ios.imbue(lc);
1539 {
1540 ios.width(0);
1541 {
1542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1543 std::string ex(str, iter.base());
1544 assert(ex == "0");
1545 assert(ios.width() == 0);
1546 }
1547 ios.width(25);
1548 left(ios);
1549 {
1550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1551 std::string ex(str, iter.base());
1552 assert(ex == "0************************");
1553 assert(ios.width() == 0);
1554 }
1555 ios.width(25);
1556 right(ios);
1557 {
1558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1559 std::string ex(str, iter.base());
1560 assert(ex == "************************0");
1561 assert(ios.width() == 0);
1562 }
1563 ios.width(25);
1564 internal(ios);
1565 {
1566 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1567 std::string ex(str, iter.base());
1568 assert(ex == "************************0");
1569 assert(ios.width() == 0);
1570 }
1571 }
1572 ios.imbue(lg);
1573 {
1574 ios.width(0);
1575 {
1576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1577 std::string ex(str, iter.base());
1578 assert(ex == "0");
1579 assert(ios.width() == 0);
1580 }
1581 ios.width(25);
1582 left(ios);
1583 {
1584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1585 std::string ex(str, iter.base());
1586 assert(ex == "0************************");
1587 assert(ios.width() == 0);
1588 }
1589 ios.width(25);
1590 right(ios);
1591 {
1592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1593 std::string ex(str, iter.base());
1594 assert(ex == "************************0");
1595 assert(ios.width() == 0);
1596 }
1597 ios.width(25);
1598 internal(ios);
1599 {
1600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1601 std::string ex(str, iter.base());
1602 assert(ex == "************************0");
1603 assert(ios.width() == 0);
1604 }
1605 }
1606 }
1607 showpoint(ios);
1608 {
1609 ios.imbue(lc);
1610 {
1611 ios.width(0);
1612 {
1613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1614 std::string ex(str, iter.base());
1615 assert(ex == "0.00000");
1616 assert(ios.width() == 0);
1617 }
1618 ios.width(25);
1619 left(ios);
1620 {
1621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1622 std::string ex(str, iter.base());
1623 assert(ex == "0.00000******************");
1624 assert(ios.width() == 0);
1625 }
1626 ios.width(25);
1627 right(ios);
1628 {
1629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1630 std::string ex(str, iter.base());
1631 assert(ex == "******************0.00000");
1632 assert(ios.width() == 0);
1633 }
1634 ios.width(25);
1635 internal(ios);
1636 {
1637 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1638 std::string ex(str, iter.base());
1639 assert(ex == "******************0.00000");
1640 assert(ios.width() == 0);
1641 }
1642 }
1643 ios.imbue(lg);
1644 {
1645 ios.width(0);
1646 {
1647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1648 std::string ex(str, iter.base());
1649 assert(ex == "0;00000");
1650 assert(ios.width() == 0);
1651 }
1652 ios.width(25);
1653 left(ios);
1654 {
1655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1656 std::string ex(str, iter.base());
1657 assert(ex == "0;00000******************");
1658 assert(ios.width() == 0);
1659 }
1660 ios.width(25);
1661 right(ios);
1662 {
1663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1664 std::string ex(str, iter.base());
1665 assert(ex == "******************0;00000");
1666 assert(ios.width() == 0);
1667 }
1668 ios.width(25);
1669 internal(ios);
1670 {
1671 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1672 std::string ex(str, iter.base());
1673 assert(ex == "******************0;00000");
1674 assert(ios.width() == 0);
1675 }
1676 }
1677 }
1678 }
1679 showpos(ios);
1680 {
1681 noshowpoint(ios);
1682 {
1683 ios.imbue(lc);
1684 {
1685 ios.width(0);
1686 {
1687 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1688 std::string ex(str, iter.base());
1689 assert(ex == "+0");
1690 assert(ios.width() == 0);
1691 }
1692 ios.width(25);
1693 left(ios);
1694 {
1695 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1696 std::string ex(str, iter.base());
1697 assert(ex == "+0***********************");
1698 assert(ios.width() == 0);
1699 }
1700 ios.width(25);
1701 right(ios);
1702 {
1703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1704 std::string ex(str, iter.base());
1705 assert(ex == "***********************+0");
1706 assert(ios.width() == 0);
1707 }
1708 ios.width(25);
1709 internal(ios);
1710 {
1711 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1712 std::string ex(str, iter.base());
1713 assert(ex == "+***********************0");
1714 assert(ios.width() == 0);
1715 }
1716 }
1717 ios.imbue(lg);
1718 {
1719 ios.width(0);
1720 {
1721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1722 std::string ex(str, iter.base());
1723 assert(ex == "+0");
1724 assert(ios.width() == 0);
1725 }
1726 ios.width(25);
1727 left(ios);
1728 {
1729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1730 std::string ex(str, iter.base());
1731 assert(ex == "+0***********************");
1732 assert(ios.width() == 0);
1733 }
1734 ios.width(25);
1735 right(ios);
1736 {
1737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1738 std::string ex(str, iter.base());
1739 assert(ex == "***********************+0");
1740 assert(ios.width() == 0);
1741 }
1742 ios.width(25);
1743 internal(ios);
1744 {
1745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1746 std::string ex(str, iter.base());
1747 assert(ex == "+***********************0");
1748 assert(ios.width() == 0);
1749 }
1750 }
1751 }
1752 showpoint(ios);
1753 {
1754 ios.imbue(lc);
1755 {
1756 ios.width(0);
1757 {
1758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1759 std::string ex(str, iter.base());
1760 assert(ex == "+0.00000");
1761 assert(ios.width() == 0);
1762 }
1763 ios.width(25);
1764 left(ios);
1765 {
1766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1767 std::string ex(str, iter.base());
1768 assert(ex == "+0.00000*****************");
1769 assert(ios.width() == 0);
1770 }
1771 ios.width(25);
1772 right(ios);
1773 {
1774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1775 std::string ex(str, iter.base());
1776 assert(ex == "*****************+0.00000");
1777 assert(ios.width() == 0);
1778 }
1779 ios.width(25);
1780 internal(ios);
1781 {
1782 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1783 std::string ex(str, iter.base());
1784 assert(ex == "+*****************0.00000");
1785 assert(ios.width() == 0);
1786 }
1787 }
1788 ios.imbue(lg);
1789 {
1790 ios.width(0);
1791 {
1792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1793 std::string ex(str, iter.base());
1794 assert(ex == "+0;00000");
1795 assert(ios.width() == 0);
1796 }
1797 ios.width(25);
1798 left(ios);
1799 {
1800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1801 std::string ex(str, iter.base());
1802 assert(ex == "+0;00000*****************");
1803 assert(ios.width() == 0);
1804 }
1805 ios.width(25);
1806 right(ios);
1807 {
1808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1809 std::string ex(str, iter.base());
1810 assert(ex == "*****************+0;00000");
1811 assert(ios.width() == 0);
1812 }
1813 ios.width(25);
1814 internal(ios);
1815 {
1816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1817 std::string ex(str, iter.base());
1818 assert(ex == "+*****************0;00000");
1819 assert(ios.width() == 0);
1820 }
1821 }
1822 }
1823 }
1824 }
1825 }
1826 ios.precision(16);
1827 {
1828 nouppercase(ios);
1829 {
1830 noshowpos(ios);
1831 {
1832 noshowpoint(ios);
1833 {
1834 ios.imbue(lc);
1835 {
1836 ios.width(0);
1837 {
1838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1839 std::string ex(str, iter.base());
1840 assert(ex == "0");
1841 assert(ios.width() == 0);
1842 }
1843 ios.width(25);
1844 left(ios);
1845 {
1846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1847 std::string ex(str, iter.base());
1848 assert(ex == "0************************");
1849 assert(ios.width() == 0);
1850 }
1851 ios.width(25);
1852 right(ios);
1853 {
1854 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1855 std::string ex(str, iter.base());
1856 assert(ex == "************************0");
1857 assert(ios.width() == 0);
1858 }
1859 ios.width(25);
1860 internal(ios);
1861 {
1862 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1863 std::string ex(str, iter.base());
1864 assert(ex == "************************0");
1865 assert(ios.width() == 0);
1866 }
1867 }
1868 ios.imbue(lg);
1869 {
1870 ios.width(0);
1871 {
1872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1873 std::string ex(str, iter.base());
1874 assert(ex == "0");
1875 assert(ios.width() == 0);
1876 }
1877 ios.width(25);
1878 left(ios);
1879 {
1880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1881 std::string ex(str, iter.base());
1882 assert(ex == "0************************");
1883 assert(ios.width() == 0);
1884 }
1885 ios.width(25);
1886 right(ios);
1887 {
1888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1889 std::string ex(str, iter.base());
1890 assert(ex == "************************0");
1891 assert(ios.width() == 0);
1892 }
1893 ios.width(25);
1894 internal(ios);
1895 {
1896 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1897 std::string ex(str, iter.base());
1898 assert(ex == "************************0");
1899 assert(ios.width() == 0);
1900 }
1901 }
1902 }
1903 showpoint(ios);
1904 {
1905 ios.imbue(lc);
1906 {
1907 ios.width(0);
1908 {
1909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1910 std::string ex(str, iter.base());
1911 assert(ex == "0.000000000000000");
1912 assert(ios.width() == 0);
1913 }
1914 ios.width(25);
1915 left(ios);
1916 {
1917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1918 std::string ex(str, iter.base());
1919 assert(ex == "0.000000000000000********");
1920 assert(ios.width() == 0);
1921 }
1922 ios.width(25);
1923 right(ios);
1924 {
1925 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1926 std::string ex(str, iter.base());
1927 assert(ex == "********0.000000000000000");
1928 assert(ios.width() == 0);
1929 }
1930 ios.width(25);
1931 internal(ios);
1932 {
1933 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1934 std::string ex(str, iter.base());
1935 assert(ex == "********0.000000000000000");
1936 assert(ios.width() == 0);
1937 }
1938 }
1939 ios.imbue(lg);
1940 {
1941 ios.width(0);
1942 {
1943 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1944 std::string ex(str, iter.base());
1945 assert(ex == "0;000000000000000");
1946 assert(ios.width() == 0);
1947 }
1948 ios.width(25);
1949 left(ios);
1950 {
1951 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1952 std::string ex(str, iter.base());
1953 assert(ex == "0;000000000000000********");
1954 assert(ios.width() == 0);
1955 }
1956 ios.width(25);
1957 right(ios);
1958 {
1959 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1960 std::string ex(str, iter.base());
1961 assert(ex == "********0;000000000000000");
1962 assert(ios.width() == 0);
1963 }
1964 ios.width(25);
1965 internal(ios);
1966 {
1967 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1968 std::string ex(str, iter.base());
1969 assert(ex == "********0;000000000000000");
1970 assert(ios.width() == 0);
1971 }
1972 }
1973 }
1974 }
1975 showpos(ios);
1976 {
1977 noshowpoint(ios);
1978 {
1979 ios.imbue(lc);
1980 {
1981 ios.width(0);
1982 {
1983 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1984 std::string ex(str, iter.base());
1985 assert(ex == "+0");
1986 assert(ios.width() == 0);
1987 }
1988 ios.width(25);
1989 left(ios);
1990 {
1991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1992 std::string ex(str, iter.base());
1993 assert(ex == "+0***********************");
1994 assert(ios.width() == 0);
1995 }
1996 ios.width(25);
1997 right(ios);
1998 {
1999 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2000 std::string ex(str, iter.base());
2001 assert(ex == "***********************+0");
2002 assert(ios.width() == 0);
2003 }
2004 ios.width(25);
2005 internal(ios);
2006 {
2007 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2008 std::string ex(str, iter.base());
2009 assert(ex == "+***********************0");
2010 assert(ios.width() == 0);
2011 }
2012 }
2013 ios.imbue(lg);
2014 {
2015 ios.width(0);
2016 {
2017 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2018 std::string ex(str, iter.base());
2019 assert(ex == "+0");
2020 assert(ios.width() == 0);
2021 }
2022 ios.width(25);
2023 left(ios);
2024 {
2025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2026 std::string ex(str, iter.base());
2027 assert(ex == "+0***********************");
2028 assert(ios.width() == 0);
2029 }
2030 ios.width(25);
2031 right(ios);
2032 {
2033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2034 std::string ex(str, iter.base());
2035 assert(ex == "***********************+0");
2036 assert(ios.width() == 0);
2037 }
2038 ios.width(25);
2039 internal(ios);
2040 {
2041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2042 std::string ex(str, iter.base());
2043 assert(ex == "+***********************0");
2044 assert(ios.width() == 0);
2045 }
2046 }
2047 }
2048 showpoint(ios);
2049 {
2050 ios.imbue(lc);
2051 {
2052 ios.width(0);
2053 {
2054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2055 std::string ex(str, iter.base());
2056 assert(ex == "+0.000000000000000");
2057 assert(ios.width() == 0);
2058 }
2059 ios.width(25);
2060 left(ios);
2061 {
2062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2063 std::string ex(str, iter.base());
2064 assert(ex == "+0.000000000000000*******");
2065 assert(ios.width() == 0);
2066 }
2067 ios.width(25);
2068 right(ios);
2069 {
2070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2071 std::string ex(str, iter.base());
2072 assert(ex == "*******+0.000000000000000");
2073 assert(ios.width() == 0);
2074 }
2075 ios.width(25);
2076 internal(ios);
2077 {
2078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2079 std::string ex(str, iter.base());
2080 assert(ex == "+*******0.000000000000000");
2081 assert(ios.width() == 0);
2082 }
2083 }
2084 ios.imbue(lg);
2085 {
2086 ios.width(0);
2087 {
2088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2089 std::string ex(str, iter.base());
2090 assert(ex == "+0;000000000000000");
2091 assert(ios.width() == 0);
2092 }
2093 ios.width(25);
2094 left(ios);
2095 {
2096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2097 std::string ex(str, iter.base());
2098 assert(ex == "+0;000000000000000*******");
2099 assert(ios.width() == 0);
2100 }
2101 ios.width(25);
2102 right(ios);
2103 {
2104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2105 std::string ex(str, iter.base());
2106 assert(ex == "*******+0;000000000000000");
2107 assert(ios.width() == 0);
2108 }
2109 ios.width(25);
2110 internal(ios);
2111 {
2112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2113 std::string ex(str, iter.base());
2114 assert(ex == "+*******0;000000000000000");
2115 assert(ios.width() == 0);
2116 }
2117 }
2118 }
2119 }
2120 }
2121 uppercase(ios);
2122 {
2123 noshowpos(ios);
2124 {
2125 noshowpoint(ios);
2126 {
2127 ios.imbue(lc);
2128 {
2129 ios.width(0);
2130 {
2131 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2132 std::string ex(str, iter.base());
2133 assert(ex == "0");
2134 assert(ios.width() == 0);
2135 }
2136 ios.width(25);
2137 left(ios);
2138 {
2139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2140 std::string ex(str, iter.base());
2141 assert(ex == "0************************");
2142 assert(ios.width() == 0);
2143 }
2144 ios.width(25);
2145 right(ios);
2146 {
2147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2148 std::string ex(str, iter.base());
2149 assert(ex == "************************0");
2150 assert(ios.width() == 0);
2151 }
2152 ios.width(25);
2153 internal(ios);
2154 {
2155 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2156 std::string ex(str, iter.base());
2157 assert(ex == "************************0");
2158 assert(ios.width() == 0);
2159 }
2160 }
2161 ios.imbue(lg);
2162 {
2163 ios.width(0);
2164 {
2165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2166 std::string ex(str, iter.base());
2167 assert(ex == "0");
2168 assert(ios.width() == 0);
2169 }
2170 ios.width(25);
2171 left(ios);
2172 {
2173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2174 std::string ex(str, iter.base());
2175 assert(ex == "0************************");
2176 assert(ios.width() == 0);
2177 }
2178 ios.width(25);
2179 right(ios);
2180 {
2181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2182 std::string ex(str, iter.base());
2183 assert(ex == "************************0");
2184 assert(ios.width() == 0);
2185 }
2186 ios.width(25);
2187 internal(ios);
2188 {
2189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2190 std::string ex(str, iter.base());
2191 assert(ex == "************************0");
2192 assert(ios.width() == 0);
2193 }
2194 }
2195 }
2196 showpoint(ios);
2197 {
2198 ios.imbue(lc);
2199 {
2200 ios.width(0);
2201 {
2202 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2203 std::string ex(str, iter.base());
2204 assert(ex == "0.000000000000000");
2205 assert(ios.width() == 0);
2206 }
2207 ios.width(25);
2208 left(ios);
2209 {
2210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2211 std::string ex(str, iter.base());
2212 assert(ex == "0.000000000000000********");
2213 assert(ios.width() == 0);
2214 }
2215 ios.width(25);
2216 right(ios);
2217 {
2218 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2219 std::string ex(str, iter.base());
2220 assert(ex == "********0.000000000000000");
2221 assert(ios.width() == 0);
2222 }
2223 ios.width(25);
2224 internal(ios);
2225 {
2226 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2227 std::string ex(str, iter.base());
2228 assert(ex == "********0.000000000000000");
2229 assert(ios.width() == 0);
2230 }
2231 }
2232 ios.imbue(lg);
2233 {
2234 ios.width(0);
2235 {
2236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2237 std::string ex(str, iter.base());
2238 assert(ex == "0;000000000000000");
2239 assert(ios.width() == 0);
2240 }
2241 ios.width(25);
2242 left(ios);
2243 {
2244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2245 std::string ex(str, iter.base());
2246 assert(ex == "0;000000000000000********");
2247 assert(ios.width() == 0);
2248 }
2249 ios.width(25);
2250 right(ios);
2251 {
2252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2253 std::string ex(str, iter.base());
2254 assert(ex == "********0;000000000000000");
2255 assert(ios.width() == 0);
2256 }
2257 ios.width(25);
2258 internal(ios);
2259 {
2260 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2261 std::string ex(str, iter.base());
2262 assert(ex == "********0;000000000000000");
2263 assert(ios.width() == 0);
2264 }
2265 }
2266 }
2267 }
2268 showpos(ios);
2269 {
2270 noshowpoint(ios);
2271 {
2272 ios.imbue(lc);
2273 {
2274 ios.width(0);
2275 {
2276 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2277 std::string ex(str, iter.base());
2278 assert(ex == "+0");
2279 assert(ios.width() == 0);
2280 }
2281 ios.width(25);
2282 left(ios);
2283 {
2284 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2285 std::string ex(str, iter.base());
2286 assert(ex == "+0***********************");
2287 assert(ios.width() == 0);
2288 }
2289 ios.width(25);
2290 right(ios);
2291 {
2292 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2293 std::string ex(str, iter.base());
2294 assert(ex == "***********************+0");
2295 assert(ios.width() == 0);
2296 }
2297 ios.width(25);
2298 internal(ios);
2299 {
2300 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2301 std::string ex(str, iter.base());
2302 assert(ex == "+***********************0");
2303 assert(ios.width() == 0);
2304 }
2305 }
2306 ios.imbue(lg);
2307 {
2308 ios.width(0);
2309 {
2310 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2311 std::string ex(str, iter.base());
2312 assert(ex == "+0");
2313 assert(ios.width() == 0);
2314 }
2315 ios.width(25);
2316 left(ios);
2317 {
2318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2319 std::string ex(str, iter.base());
2320 assert(ex == "+0***********************");
2321 assert(ios.width() == 0);
2322 }
2323 ios.width(25);
2324 right(ios);
2325 {
2326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2327 std::string ex(str, iter.base());
2328 assert(ex == "***********************+0");
2329 assert(ios.width() == 0);
2330 }
2331 ios.width(25);
2332 internal(ios);
2333 {
2334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2335 std::string ex(str, iter.base());
2336 assert(ex == "+***********************0");
2337 assert(ios.width() == 0);
2338 }
2339 }
2340 }
2341 showpoint(ios);
2342 {
2343 ios.imbue(lc);
2344 {
2345 ios.width(0);
2346 {
2347 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2348 std::string ex(str, iter.base());
2349 assert(ex == "+0.000000000000000");
2350 assert(ios.width() == 0);
2351 }
2352 ios.width(25);
2353 left(ios);
2354 {
2355 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2356 std::string ex(str, iter.base());
2357 assert(ex == "+0.000000000000000*******");
2358 assert(ios.width() == 0);
2359 }
2360 ios.width(25);
2361 right(ios);
2362 {
2363 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2364 std::string ex(str, iter.base());
2365 assert(ex == "*******+0.000000000000000");
2366 assert(ios.width() == 0);
2367 }
2368 ios.width(25);
2369 internal(ios);
2370 {
2371 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2372 std::string ex(str, iter.base());
2373 assert(ex == "+*******0.000000000000000");
2374 assert(ios.width() == 0);
2375 }
2376 }
2377 ios.imbue(lg);
2378 {
2379 ios.width(0);
2380 {
2381 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2382 std::string ex(str, iter.base());
2383 assert(ex == "+0;000000000000000");
2384 assert(ios.width() == 0);
2385 }
2386 ios.width(25);
2387 left(ios);
2388 {
2389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2390 std::string ex(str, iter.base());
2391 assert(ex == "+0;000000000000000*******");
2392 assert(ios.width() == 0);
2393 }
2394 ios.width(25);
2395 right(ios);
2396 {
2397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2398 std::string ex(str, iter.base());
2399 assert(ex == "*******+0;000000000000000");
2400 assert(ios.width() == 0);
2401 }
2402 ios.width(25);
2403 internal(ios);
2404 {
2405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2406 std::string ex(str, iter.base());
2407 assert(ex == "+*******0;000000000000000");
2408 assert(ios.width() == 0);
2409 }
2410 }
2411 }
2412 }
2413 }
2414 }
2415 ios.precision(60);
2416 {
2417 nouppercase(ios);
2418 {
2419 noshowpos(ios);
2420 {
2421 noshowpoint(ios);
2422 {
2423 ios.imbue(lc);
2424 {
2425 ios.width(0);
2426 {
2427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2428 std::string ex(str, iter.base());
2429 assert(ex == "0");
2430 assert(ios.width() == 0);
2431 }
2432 ios.width(25);
2433 left(ios);
2434 {
2435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2436 std::string ex(str, iter.base());
2437 assert(ex == "0************************");
2438 assert(ios.width() == 0);
2439 }
2440 ios.width(25);
2441 right(ios);
2442 {
2443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2444 std::string ex(str, iter.base());
2445 assert(ex == "************************0");
2446 assert(ios.width() == 0);
2447 }
2448 ios.width(25);
2449 internal(ios);
2450 {
2451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2452 std::string ex(str, iter.base());
2453 assert(ex == "************************0");
2454 assert(ios.width() == 0);
2455 }
2456 }
2457 ios.imbue(lg);
2458 {
2459 ios.width(0);
2460 {
2461 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2462 std::string ex(str, iter.base());
2463 assert(ex == "0");
2464 assert(ios.width() == 0);
2465 }
2466 ios.width(25);
2467 left(ios);
2468 {
2469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2470 std::string ex(str, iter.base());
2471 assert(ex == "0************************");
2472 assert(ios.width() == 0);
2473 }
2474 ios.width(25);
2475 right(ios);
2476 {
2477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2478 std::string ex(str, iter.base());
2479 assert(ex == "************************0");
2480 assert(ios.width() == 0);
2481 }
2482 ios.width(25);
2483 internal(ios);
2484 {
2485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2486 std::string ex(str, iter.base());
2487 assert(ex == "************************0");
2488 assert(ios.width() == 0);
2489 }
2490 }
2491 }
2492 showpoint(ios);
2493 {
2494 ios.imbue(lc);
2495 {
2496 ios.width(0);
2497 {
2498 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2499 std::string ex(str, iter.base());
2500 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2501 assert(ios.width() == 0);
2502 }
2503 ios.width(25);
2504 left(ios);
2505 {
2506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2507 std::string ex(str, iter.base());
2508 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2509 assert(ios.width() == 0);
2510 }
2511 ios.width(25);
2512 right(ios);
2513 {
2514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2515 std::string ex(str, iter.base());
2516 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2517 assert(ios.width() == 0);
2518 }
2519 ios.width(25);
2520 internal(ios);
2521 {
2522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2523 std::string ex(str, iter.base());
2524 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2525 assert(ios.width() == 0);
2526 }
2527 }
2528 ios.imbue(lg);
2529 {
2530 ios.width(0);
2531 {
2532 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2533 std::string ex(str, iter.base());
2534 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2535 assert(ios.width() == 0);
2536 }
2537 ios.width(25);
2538 left(ios);
2539 {
2540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2541 std::string ex(str, iter.base());
2542 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2543 assert(ios.width() == 0);
2544 }
2545 ios.width(25);
2546 right(ios);
2547 {
2548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2549 std::string ex(str, iter.base());
2550 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2551 assert(ios.width() == 0);
2552 }
2553 ios.width(25);
2554 internal(ios);
2555 {
2556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2557 std::string ex(str, iter.base());
2558 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2559 assert(ios.width() == 0);
2560 }
2561 }
2562 }
2563 }
2564 showpos(ios);
2565 {
2566 noshowpoint(ios);
2567 {
2568 ios.imbue(lc);
2569 {
2570 ios.width(0);
2571 {
2572 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2573 std::string ex(str, iter.base());
2574 assert(ex == "+0");
2575 assert(ios.width() == 0);
2576 }
2577 ios.width(25);
2578 left(ios);
2579 {
2580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2581 std::string ex(str, iter.base());
2582 assert(ex == "+0***********************");
2583 assert(ios.width() == 0);
2584 }
2585 ios.width(25);
2586 right(ios);
2587 {
2588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2589 std::string ex(str, iter.base());
2590 assert(ex == "***********************+0");
2591 assert(ios.width() == 0);
2592 }
2593 ios.width(25);
2594 internal(ios);
2595 {
2596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2597 std::string ex(str, iter.base());
2598 assert(ex == "+***********************0");
2599 assert(ios.width() == 0);
2600 }
2601 }
2602 ios.imbue(lg);
2603 {
2604 ios.width(0);
2605 {
2606 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2607 std::string ex(str, iter.base());
2608 assert(ex == "+0");
2609 assert(ios.width() == 0);
2610 }
2611 ios.width(25);
2612 left(ios);
2613 {
2614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2615 std::string ex(str, iter.base());
2616 assert(ex == "+0***********************");
2617 assert(ios.width() == 0);
2618 }
2619 ios.width(25);
2620 right(ios);
2621 {
2622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2623 std::string ex(str, iter.base());
2624 assert(ex == "***********************+0");
2625 assert(ios.width() == 0);
2626 }
2627 ios.width(25);
2628 internal(ios);
2629 {
2630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2631 std::string ex(str, iter.base());
2632 assert(ex == "+***********************0");
2633 assert(ios.width() == 0);
2634 }
2635 }
2636 }
2637 showpoint(ios);
2638 {
2639 ios.imbue(lc);
2640 {
2641 ios.width(0);
2642 {
2643 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2644 std::string ex(str, iter.base());
2645 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2646 assert(ios.width() == 0);
2647 }
2648 ios.width(25);
2649 left(ios);
2650 {
2651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2652 std::string ex(str, iter.base());
2653 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2654 assert(ios.width() == 0);
2655 }
2656 ios.width(25);
2657 right(ios);
2658 {
2659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2660 std::string ex(str, iter.base());
2661 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2662 assert(ios.width() == 0);
2663 }
2664 ios.width(25);
2665 internal(ios);
2666 {
2667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2668 std::string ex(str, iter.base());
2669 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2670 assert(ios.width() == 0);
2671 }
2672 }
2673 ios.imbue(lg);
2674 {
2675 ios.width(0);
2676 {
2677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2678 std::string ex(str, iter.base());
2679 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2680 assert(ios.width() == 0);
2681 }
2682 ios.width(25);
2683 left(ios);
2684 {
2685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2686 std::string ex(str, iter.base());
2687 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2688 assert(ios.width() == 0);
2689 }
2690 ios.width(25);
2691 right(ios);
2692 {
2693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2694 std::string ex(str, iter.base());
2695 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2696 assert(ios.width() == 0);
2697 }
2698 ios.width(25);
2699 internal(ios);
2700 {
2701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2702 std::string ex(str, iter.base());
2703 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2704 assert(ios.width() == 0);
2705 }
2706 }
2707 }
2708 }
2709 }
2710 uppercase(ios);
2711 {
2712 noshowpos(ios);
2713 {
2714 noshowpoint(ios);
2715 {
2716 ios.imbue(lc);
2717 {
2718 ios.width(0);
2719 {
2720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2721 std::string ex(str, iter.base());
2722 assert(ex == "0");
2723 assert(ios.width() == 0);
2724 }
2725 ios.width(25);
2726 left(ios);
2727 {
2728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2729 std::string ex(str, iter.base());
2730 assert(ex == "0************************");
2731 assert(ios.width() == 0);
2732 }
2733 ios.width(25);
2734 right(ios);
2735 {
2736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2737 std::string ex(str, iter.base());
2738 assert(ex == "************************0");
2739 assert(ios.width() == 0);
2740 }
2741 ios.width(25);
2742 internal(ios);
2743 {
2744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2745 std::string ex(str, iter.base());
2746 assert(ex == "************************0");
2747 assert(ios.width() == 0);
2748 }
2749 }
2750 ios.imbue(lg);
2751 {
2752 ios.width(0);
2753 {
2754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2755 std::string ex(str, iter.base());
2756 assert(ex == "0");
2757 assert(ios.width() == 0);
2758 }
2759 ios.width(25);
2760 left(ios);
2761 {
2762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2763 std::string ex(str, iter.base());
2764 assert(ex == "0************************");
2765 assert(ios.width() == 0);
2766 }
2767 ios.width(25);
2768 right(ios);
2769 {
2770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2771 std::string ex(str, iter.base());
2772 assert(ex == "************************0");
2773 assert(ios.width() == 0);
2774 }
2775 ios.width(25);
2776 internal(ios);
2777 {
2778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2779 std::string ex(str, iter.base());
2780 assert(ex == "************************0");
2781 assert(ios.width() == 0);
2782 }
2783 }
2784 }
2785 showpoint(ios);
2786 {
2787 ios.imbue(lc);
2788 {
2789 ios.width(0);
2790 {
2791 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2792 std::string ex(str, iter.base());
2793 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2794 assert(ios.width() == 0);
2795 }
2796 ios.width(25);
2797 left(ios);
2798 {
2799 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2800 std::string ex(str, iter.base());
2801 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2802 assert(ios.width() == 0);
2803 }
2804 ios.width(25);
2805 right(ios);
2806 {
2807 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2808 std::string ex(str, iter.base());
2809 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2810 assert(ios.width() == 0);
2811 }
2812 ios.width(25);
2813 internal(ios);
2814 {
2815 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2816 std::string ex(str, iter.base());
2817 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2818 assert(ios.width() == 0);
2819 }
2820 }
2821 ios.imbue(lg);
2822 {
2823 ios.width(0);
2824 {
2825 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2826 std::string ex(str, iter.base());
2827 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2828 assert(ios.width() == 0);
2829 }
2830 ios.width(25);
2831 left(ios);
2832 {
2833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2834 std::string ex(str, iter.base());
2835 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2836 assert(ios.width() == 0);
2837 }
2838 ios.width(25);
2839 right(ios);
2840 {
2841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2842 std::string ex(str, iter.base());
2843 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2844 assert(ios.width() == 0);
2845 }
2846 ios.width(25);
2847 internal(ios);
2848 {
2849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2850 std::string ex(str, iter.base());
2851 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2852 assert(ios.width() == 0);
2853 }
2854 }
2855 }
2856 }
2857 showpos(ios);
2858 {
2859 noshowpoint(ios);
2860 {
2861 ios.imbue(lc);
2862 {
2863 ios.width(0);
2864 {
2865 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2866 std::string ex(str, iter.base());
2867 assert(ex == "+0");
2868 assert(ios.width() == 0);
2869 }
2870 ios.width(25);
2871 left(ios);
2872 {
2873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2874 std::string ex(str, iter.base());
2875 assert(ex == "+0***********************");
2876 assert(ios.width() == 0);
2877 }
2878 ios.width(25);
2879 right(ios);
2880 {
2881 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2882 std::string ex(str, iter.base());
2883 assert(ex == "***********************+0");
2884 assert(ios.width() == 0);
2885 }
2886 ios.width(25);
2887 internal(ios);
2888 {
2889 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2890 std::string ex(str, iter.base());
2891 assert(ex == "+***********************0");
2892 assert(ios.width() == 0);
2893 }
2894 }
2895 ios.imbue(lg);
2896 {
2897 ios.width(0);
2898 {
2899 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2900 std::string ex(str, iter.base());
2901 assert(ex == "+0");
2902 assert(ios.width() == 0);
2903 }
2904 ios.width(25);
2905 left(ios);
2906 {
2907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2908 std::string ex(str, iter.base());
2909 assert(ex == "+0***********************");
2910 assert(ios.width() == 0);
2911 }
2912 ios.width(25);
2913 right(ios);
2914 {
2915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2916 std::string ex(str, iter.base());
2917 assert(ex == "***********************+0");
2918 assert(ios.width() == 0);
2919 }
2920 ios.width(25);
2921 internal(ios);
2922 {
2923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2924 std::string ex(str, iter.base());
2925 assert(ex == "+***********************0");
2926 assert(ios.width() == 0);
2927 }
2928 }
2929 }
2930 showpoint(ios);
2931 {
2932 ios.imbue(lc);
2933 {
2934 ios.width(0);
2935 {
2936 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2937 std::string ex(str, iter.base());
2938 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2939 assert(ios.width() == 0);
2940 }
2941 ios.width(25);
2942 left(ios);
2943 {
2944 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2945 std::string ex(str, iter.base());
2946 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2947 assert(ios.width() == 0);
2948 }
2949 ios.width(25);
2950 right(ios);
2951 {
2952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2953 std::string ex(str, iter.base());
2954 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2955 assert(ios.width() == 0);
2956 }
2957 ios.width(25);
2958 internal(ios);
2959 {
2960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2961 std::string ex(str, iter.base());
2962 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2963 assert(ios.width() == 0);
2964 }
2965 }
2966 ios.imbue(lg);
2967 {
2968 ios.width(0);
2969 {
2970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2971 std::string ex(str, iter.base());
2972 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2973 assert(ios.width() == 0);
2974 }
2975 ios.width(25);
2976 left(ios);
2977 {
2978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2979 std::string ex(str, iter.base());
2980 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2981 assert(ios.width() == 0);
2982 }
2983 ios.width(25);
2984 right(ios);
2985 {
2986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2987 std::string ex(str, iter.base());
2988 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2989 assert(ios.width() == 0);
2990 }
2991 ios.width(25);
2992 internal(ios);
2993 {
2994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2995 std::string ex(str, iter.base());
2996 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2997 assert(ios.width() == 0);
2998 }
2999 }
3000 }
3001 }
3002 }
3003 }
3004 }
3005 }
3006 }
3007
test2()3008 void test2()
3009 {
3010 char str[200];
3011 output_iterator<char*> iter;
3012 std::locale lc = std::locale::classic();
3013 std::locale lg(lc, new my_numpunct);
3014 const my_facet f(1);
3015 {
3016 double v = 1234567890.125;
3017 std::ios ios(0);
3018 // %g
3019 {
3020 ios.precision(0);
3021 {
3022 nouppercase(ios);
3023 {
3024 noshowpos(ios);
3025 {
3026 noshowpoint(ios);
3027 {
3028 ios.imbue(lc);
3029 {
3030 ios.width(0);
3031 {
3032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3033 std::string ex(str, iter.base());
3034 assert(ex == "1e+09");
3035 assert(ios.width() == 0);
3036 }
3037 ios.width(25);
3038 left(ios);
3039 {
3040 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3041 std::string ex(str, iter.base());
3042 assert(ex == "1e+09********************");
3043 assert(ios.width() == 0);
3044 }
3045 ios.width(25);
3046 right(ios);
3047 {
3048 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3049 std::string ex(str, iter.base());
3050 assert(ex == "********************1e+09");
3051 assert(ios.width() == 0);
3052 }
3053 ios.width(25);
3054 internal(ios);
3055 {
3056 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3057 std::string ex(str, iter.base());
3058 assert(ex == "********************1e+09");
3059 assert(ios.width() == 0);
3060 }
3061 }
3062 ios.imbue(lg);
3063 {
3064 ios.width(0);
3065 {
3066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3067 std::string ex(str, iter.base());
3068 assert(ex == "1e+09");
3069 assert(ios.width() == 0);
3070 }
3071 ios.width(25);
3072 left(ios);
3073 {
3074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3075 std::string ex(str, iter.base());
3076 assert(ex == "1e+09********************");
3077 assert(ios.width() == 0);
3078 }
3079 ios.width(25);
3080 right(ios);
3081 {
3082 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3083 std::string ex(str, iter.base());
3084 assert(ex == "********************1e+09");
3085 assert(ios.width() == 0);
3086 }
3087 ios.width(25);
3088 internal(ios);
3089 {
3090 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3091 std::string ex(str, iter.base());
3092 assert(ex == "********************1e+09");
3093 assert(ios.width() == 0);
3094 }
3095 }
3096 }
3097 showpoint(ios);
3098 {
3099 ios.imbue(lc);
3100 {
3101 ios.width(0);
3102 {
3103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3104 std::string ex(str, iter.base());
3105 assert(ex == "1.e+09");
3106 assert(ios.width() == 0);
3107 }
3108 ios.width(25);
3109 left(ios);
3110 {
3111 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3112 std::string ex(str, iter.base());
3113 assert(ex == "1.e+09*******************");
3114 assert(ios.width() == 0);
3115 }
3116 ios.width(25);
3117 right(ios);
3118 {
3119 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3120 std::string ex(str, iter.base());
3121 assert(ex == "*******************1.e+09");
3122 assert(ios.width() == 0);
3123 }
3124 ios.width(25);
3125 internal(ios);
3126 {
3127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3128 std::string ex(str, iter.base());
3129 assert(ex == "*******************1.e+09");
3130 assert(ios.width() == 0);
3131 }
3132 }
3133 ios.imbue(lg);
3134 {
3135 ios.width(0);
3136 {
3137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3138 std::string ex(str, iter.base());
3139 assert(ex == "1;e+09");
3140 assert(ios.width() == 0);
3141 }
3142 ios.width(25);
3143 left(ios);
3144 {
3145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3146 std::string ex(str, iter.base());
3147 assert(ex == "1;e+09*******************");
3148 assert(ios.width() == 0);
3149 }
3150 ios.width(25);
3151 right(ios);
3152 {
3153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3154 std::string ex(str, iter.base());
3155 assert(ex == "*******************1;e+09");
3156 assert(ios.width() == 0);
3157 }
3158 ios.width(25);
3159 internal(ios);
3160 {
3161 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3162 std::string ex(str, iter.base());
3163 assert(ex == "*******************1;e+09");
3164 assert(ios.width() == 0);
3165 }
3166 }
3167 }
3168 }
3169 showpos(ios);
3170 {
3171 noshowpoint(ios);
3172 {
3173 ios.imbue(lc);
3174 {
3175 ios.width(0);
3176 {
3177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3178 std::string ex(str, iter.base());
3179 assert(ex == "+1e+09");
3180 assert(ios.width() == 0);
3181 }
3182 ios.width(25);
3183 left(ios);
3184 {
3185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3186 std::string ex(str, iter.base());
3187 assert(ex == "+1e+09*******************");
3188 assert(ios.width() == 0);
3189 }
3190 ios.width(25);
3191 right(ios);
3192 {
3193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3194 std::string ex(str, iter.base());
3195 assert(ex == "*******************+1e+09");
3196 assert(ios.width() == 0);
3197 }
3198 ios.width(25);
3199 internal(ios);
3200 {
3201 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3202 std::string ex(str, iter.base());
3203 assert(ex == "+*******************1e+09");
3204 assert(ios.width() == 0);
3205 }
3206 }
3207 ios.imbue(lg);
3208 {
3209 ios.width(0);
3210 {
3211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3212 std::string ex(str, iter.base());
3213 assert(ex == "+1e+09");
3214 assert(ios.width() == 0);
3215 }
3216 ios.width(25);
3217 left(ios);
3218 {
3219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3220 std::string ex(str, iter.base());
3221 assert(ex == "+1e+09*******************");
3222 assert(ios.width() == 0);
3223 }
3224 ios.width(25);
3225 right(ios);
3226 {
3227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3228 std::string ex(str, iter.base());
3229 assert(ex == "*******************+1e+09");
3230 assert(ios.width() == 0);
3231 }
3232 ios.width(25);
3233 internal(ios);
3234 {
3235 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3236 std::string ex(str, iter.base());
3237 assert(ex == "+*******************1e+09");
3238 assert(ios.width() == 0);
3239 }
3240 }
3241 }
3242 showpoint(ios);
3243 {
3244 ios.imbue(lc);
3245 {
3246 ios.width(0);
3247 {
3248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3249 std::string ex(str, iter.base());
3250 assert(ex == "+1.e+09");
3251 assert(ios.width() == 0);
3252 }
3253 ios.width(25);
3254 left(ios);
3255 {
3256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3257 std::string ex(str, iter.base());
3258 assert(ex == "+1.e+09******************");
3259 assert(ios.width() == 0);
3260 }
3261 ios.width(25);
3262 right(ios);
3263 {
3264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3265 std::string ex(str, iter.base());
3266 assert(ex == "******************+1.e+09");
3267 assert(ios.width() == 0);
3268 }
3269 ios.width(25);
3270 internal(ios);
3271 {
3272 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3273 std::string ex(str, iter.base());
3274 assert(ex == "+******************1.e+09");
3275 assert(ios.width() == 0);
3276 }
3277 }
3278 ios.imbue(lg);
3279 {
3280 ios.width(0);
3281 {
3282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3283 std::string ex(str, iter.base());
3284 assert(ex == "+1;e+09");
3285 assert(ios.width() == 0);
3286 }
3287 ios.width(25);
3288 left(ios);
3289 {
3290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3291 std::string ex(str, iter.base());
3292 assert(ex == "+1;e+09******************");
3293 assert(ios.width() == 0);
3294 }
3295 ios.width(25);
3296 right(ios);
3297 {
3298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3299 std::string ex(str, iter.base());
3300 assert(ex == "******************+1;e+09");
3301 assert(ios.width() == 0);
3302 }
3303 ios.width(25);
3304 internal(ios);
3305 {
3306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3307 std::string ex(str, iter.base());
3308 assert(ex == "+******************1;e+09");
3309 assert(ios.width() == 0);
3310 }
3311 }
3312 }
3313 }
3314 }
3315 uppercase(ios);
3316 {
3317 noshowpos(ios);
3318 {
3319 noshowpoint(ios);
3320 {
3321 ios.imbue(lc);
3322 {
3323 ios.width(0);
3324 {
3325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3326 std::string ex(str, iter.base());
3327 assert(ex == "1E+09");
3328 assert(ios.width() == 0);
3329 }
3330 ios.width(25);
3331 left(ios);
3332 {
3333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3334 std::string ex(str, iter.base());
3335 assert(ex == "1E+09********************");
3336 assert(ios.width() == 0);
3337 }
3338 ios.width(25);
3339 right(ios);
3340 {
3341 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3342 std::string ex(str, iter.base());
3343 assert(ex == "********************1E+09");
3344 assert(ios.width() == 0);
3345 }
3346 ios.width(25);
3347 internal(ios);
3348 {
3349 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3350 std::string ex(str, iter.base());
3351 assert(ex == "********************1E+09");
3352 assert(ios.width() == 0);
3353 }
3354 }
3355 ios.imbue(lg);
3356 {
3357 ios.width(0);
3358 {
3359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3360 std::string ex(str, iter.base());
3361 assert(ex == "1E+09");
3362 assert(ios.width() == 0);
3363 }
3364 ios.width(25);
3365 left(ios);
3366 {
3367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3368 std::string ex(str, iter.base());
3369 assert(ex == "1E+09********************");
3370 assert(ios.width() == 0);
3371 }
3372 ios.width(25);
3373 right(ios);
3374 {
3375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3376 std::string ex(str, iter.base());
3377 assert(ex == "********************1E+09");
3378 assert(ios.width() == 0);
3379 }
3380 ios.width(25);
3381 internal(ios);
3382 {
3383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3384 std::string ex(str, iter.base());
3385 assert(ex == "********************1E+09");
3386 assert(ios.width() == 0);
3387 }
3388 }
3389 }
3390 showpoint(ios);
3391 {
3392 ios.imbue(lc);
3393 {
3394 ios.width(0);
3395 {
3396 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3397 std::string ex(str, iter.base());
3398 assert(ex == "1.E+09");
3399 assert(ios.width() == 0);
3400 }
3401 ios.width(25);
3402 left(ios);
3403 {
3404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3405 std::string ex(str, iter.base());
3406 assert(ex == "1.E+09*******************");
3407 assert(ios.width() == 0);
3408 }
3409 ios.width(25);
3410 right(ios);
3411 {
3412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3413 std::string ex(str, iter.base());
3414 assert(ex == "*******************1.E+09");
3415 assert(ios.width() == 0);
3416 }
3417 ios.width(25);
3418 internal(ios);
3419 {
3420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3421 std::string ex(str, iter.base());
3422 assert(ex == "*******************1.E+09");
3423 assert(ios.width() == 0);
3424 }
3425 }
3426 ios.imbue(lg);
3427 {
3428 ios.width(0);
3429 {
3430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3431 std::string ex(str, iter.base());
3432 assert(ex == "1;E+09");
3433 assert(ios.width() == 0);
3434 }
3435 ios.width(25);
3436 left(ios);
3437 {
3438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3439 std::string ex(str, iter.base());
3440 assert(ex == "1;E+09*******************");
3441 assert(ios.width() == 0);
3442 }
3443 ios.width(25);
3444 right(ios);
3445 {
3446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3447 std::string ex(str, iter.base());
3448 assert(ex == "*******************1;E+09");
3449 assert(ios.width() == 0);
3450 }
3451 ios.width(25);
3452 internal(ios);
3453 {
3454 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3455 std::string ex(str, iter.base());
3456 assert(ex == "*******************1;E+09");
3457 assert(ios.width() == 0);
3458 }
3459 }
3460 }
3461 }
3462 showpos(ios);
3463 {
3464 noshowpoint(ios);
3465 {
3466 ios.imbue(lc);
3467 {
3468 ios.width(0);
3469 {
3470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3471 std::string ex(str, iter.base());
3472 assert(ex == "+1E+09");
3473 assert(ios.width() == 0);
3474 }
3475 ios.width(25);
3476 left(ios);
3477 {
3478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3479 std::string ex(str, iter.base());
3480 assert(ex == "+1E+09*******************");
3481 assert(ios.width() == 0);
3482 }
3483 ios.width(25);
3484 right(ios);
3485 {
3486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3487 std::string ex(str, iter.base());
3488 assert(ex == "*******************+1E+09");
3489 assert(ios.width() == 0);
3490 }
3491 ios.width(25);
3492 internal(ios);
3493 {
3494 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3495 std::string ex(str, iter.base());
3496 assert(ex == "+*******************1E+09");
3497 assert(ios.width() == 0);
3498 }
3499 }
3500 ios.imbue(lg);
3501 {
3502 ios.width(0);
3503 {
3504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3505 std::string ex(str, iter.base());
3506 assert(ex == "+1E+09");
3507 assert(ios.width() == 0);
3508 }
3509 ios.width(25);
3510 left(ios);
3511 {
3512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3513 std::string ex(str, iter.base());
3514 assert(ex == "+1E+09*******************");
3515 assert(ios.width() == 0);
3516 }
3517 ios.width(25);
3518 right(ios);
3519 {
3520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3521 std::string ex(str, iter.base());
3522 assert(ex == "*******************+1E+09");
3523 assert(ios.width() == 0);
3524 }
3525 ios.width(25);
3526 internal(ios);
3527 {
3528 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3529 std::string ex(str, iter.base());
3530 assert(ex == "+*******************1E+09");
3531 assert(ios.width() == 0);
3532 }
3533 }
3534 }
3535 showpoint(ios);
3536 {
3537 ios.imbue(lc);
3538 {
3539 ios.width(0);
3540 {
3541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3542 std::string ex(str, iter.base());
3543 assert(ex == "+1.E+09");
3544 assert(ios.width() == 0);
3545 }
3546 ios.width(25);
3547 left(ios);
3548 {
3549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3550 std::string ex(str, iter.base());
3551 assert(ex == "+1.E+09******************");
3552 assert(ios.width() == 0);
3553 }
3554 ios.width(25);
3555 right(ios);
3556 {
3557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3558 std::string ex(str, iter.base());
3559 assert(ex == "******************+1.E+09");
3560 assert(ios.width() == 0);
3561 }
3562 ios.width(25);
3563 internal(ios);
3564 {
3565 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3566 std::string ex(str, iter.base());
3567 assert(ex == "+******************1.E+09");
3568 assert(ios.width() == 0);
3569 }
3570 }
3571 ios.imbue(lg);
3572 {
3573 ios.width(0);
3574 {
3575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3576 std::string ex(str, iter.base());
3577 assert(ex == "+1;E+09");
3578 assert(ios.width() == 0);
3579 }
3580 ios.width(25);
3581 left(ios);
3582 {
3583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3584 std::string ex(str, iter.base());
3585 assert(ex == "+1;E+09******************");
3586 assert(ios.width() == 0);
3587 }
3588 ios.width(25);
3589 right(ios);
3590 {
3591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3592 std::string ex(str, iter.base());
3593 assert(ex == "******************+1;E+09");
3594 assert(ios.width() == 0);
3595 }
3596 ios.width(25);
3597 internal(ios);
3598 {
3599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3600 std::string ex(str, iter.base());
3601 assert(ex == "+******************1;E+09");
3602 assert(ios.width() == 0);
3603 }
3604 }
3605 }
3606 }
3607 }
3608 }
3609 ios.precision(1);
3610 {
3611 nouppercase(ios);
3612 {
3613 noshowpos(ios);
3614 {
3615 noshowpoint(ios);
3616 {
3617 ios.imbue(lc);
3618 {
3619 ios.width(0);
3620 {
3621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3622 std::string ex(str, iter.base());
3623 assert(ex == "1e+09");
3624 assert(ios.width() == 0);
3625 }
3626 ios.width(25);
3627 left(ios);
3628 {
3629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3630 std::string ex(str, iter.base());
3631 assert(ex == "1e+09********************");
3632 assert(ios.width() == 0);
3633 }
3634 ios.width(25);
3635 right(ios);
3636 {
3637 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3638 std::string ex(str, iter.base());
3639 assert(ex == "********************1e+09");
3640 assert(ios.width() == 0);
3641 }
3642 ios.width(25);
3643 internal(ios);
3644 {
3645 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3646 std::string ex(str, iter.base());
3647 assert(ex == "********************1e+09");
3648 assert(ios.width() == 0);
3649 }
3650 }
3651 ios.imbue(lg);
3652 {
3653 ios.width(0);
3654 {
3655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3656 std::string ex(str, iter.base());
3657 assert(ex == "1e+09");
3658 assert(ios.width() == 0);
3659 }
3660 ios.width(25);
3661 left(ios);
3662 {
3663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3664 std::string ex(str, iter.base());
3665 assert(ex == "1e+09********************");
3666 assert(ios.width() == 0);
3667 }
3668 ios.width(25);
3669 right(ios);
3670 {
3671 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3672 std::string ex(str, iter.base());
3673 assert(ex == "********************1e+09");
3674 assert(ios.width() == 0);
3675 }
3676 ios.width(25);
3677 internal(ios);
3678 {
3679 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3680 std::string ex(str, iter.base());
3681 assert(ex == "********************1e+09");
3682 assert(ios.width() == 0);
3683 }
3684 }
3685 }
3686 showpoint(ios);
3687 {
3688 ios.imbue(lc);
3689 {
3690 ios.width(0);
3691 {
3692 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3693 std::string ex(str, iter.base());
3694 assert(ex == "1.e+09");
3695 assert(ios.width() == 0);
3696 }
3697 ios.width(25);
3698 left(ios);
3699 {
3700 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3701 std::string ex(str, iter.base());
3702 assert(ex == "1.e+09*******************");
3703 assert(ios.width() == 0);
3704 }
3705 ios.width(25);
3706 right(ios);
3707 {
3708 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3709 std::string ex(str, iter.base());
3710 assert(ex == "*******************1.e+09");
3711 assert(ios.width() == 0);
3712 }
3713 ios.width(25);
3714 internal(ios);
3715 {
3716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3717 std::string ex(str, iter.base());
3718 assert(ex == "*******************1.e+09");
3719 assert(ios.width() == 0);
3720 }
3721 }
3722 ios.imbue(lg);
3723 {
3724 ios.width(0);
3725 {
3726 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3727 std::string ex(str, iter.base());
3728 assert(ex == "1;e+09");
3729 assert(ios.width() == 0);
3730 }
3731 ios.width(25);
3732 left(ios);
3733 {
3734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3735 std::string ex(str, iter.base());
3736 assert(ex == "1;e+09*******************");
3737 assert(ios.width() == 0);
3738 }
3739 ios.width(25);
3740 right(ios);
3741 {
3742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3743 std::string ex(str, iter.base());
3744 assert(ex == "*******************1;e+09");
3745 assert(ios.width() == 0);
3746 }
3747 ios.width(25);
3748 internal(ios);
3749 {
3750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3751 std::string ex(str, iter.base());
3752 assert(ex == "*******************1;e+09");
3753 assert(ios.width() == 0);
3754 }
3755 }
3756 }
3757 }
3758 showpos(ios);
3759 {
3760 noshowpoint(ios);
3761 {
3762 ios.imbue(lc);
3763 {
3764 ios.width(0);
3765 {
3766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3767 std::string ex(str, iter.base());
3768 assert(ex == "+1e+09");
3769 assert(ios.width() == 0);
3770 }
3771 ios.width(25);
3772 left(ios);
3773 {
3774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3775 std::string ex(str, iter.base());
3776 assert(ex == "+1e+09*******************");
3777 assert(ios.width() == 0);
3778 }
3779 ios.width(25);
3780 right(ios);
3781 {
3782 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3783 std::string ex(str, iter.base());
3784 assert(ex == "*******************+1e+09");
3785 assert(ios.width() == 0);
3786 }
3787 ios.width(25);
3788 internal(ios);
3789 {
3790 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3791 std::string ex(str, iter.base());
3792 assert(ex == "+*******************1e+09");
3793 assert(ios.width() == 0);
3794 }
3795 }
3796 ios.imbue(lg);
3797 {
3798 ios.width(0);
3799 {
3800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3801 std::string ex(str, iter.base());
3802 assert(ex == "+1e+09");
3803 assert(ios.width() == 0);
3804 }
3805 ios.width(25);
3806 left(ios);
3807 {
3808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3809 std::string ex(str, iter.base());
3810 assert(ex == "+1e+09*******************");
3811 assert(ios.width() == 0);
3812 }
3813 ios.width(25);
3814 right(ios);
3815 {
3816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3817 std::string ex(str, iter.base());
3818 assert(ex == "*******************+1e+09");
3819 assert(ios.width() == 0);
3820 }
3821 ios.width(25);
3822 internal(ios);
3823 {
3824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3825 std::string ex(str, iter.base());
3826 assert(ex == "+*******************1e+09");
3827 assert(ios.width() == 0);
3828 }
3829 }
3830 }
3831 showpoint(ios);
3832 {
3833 ios.imbue(lc);
3834 {
3835 ios.width(0);
3836 {
3837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3838 std::string ex(str, iter.base());
3839 assert(ex == "+1.e+09");
3840 assert(ios.width() == 0);
3841 }
3842 ios.width(25);
3843 left(ios);
3844 {
3845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3846 std::string ex(str, iter.base());
3847 assert(ex == "+1.e+09******************");
3848 assert(ios.width() == 0);
3849 }
3850 ios.width(25);
3851 right(ios);
3852 {
3853 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3854 std::string ex(str, iter.base());
3855 assert(ex == "******************+1.e+09");
3856 assert(ios.width() == 0);
3857 }
3858 ios.width(25);
3859 internal(ios);
3860 {
3861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3862 std::string ex(str, iter.base());
3863 assert(ex == "+******************1.e+09");
3864 assert(ios.width() == 0);
3865 }
3866 }
3867 ios.imbue(lg);
3868 {
3869 ios.width(0);
3870 {
3871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3872 std::string ex(str, iter.base());
3873 assert(ex == "+1;e+09");
3874 assert(ios.width() == 0);
3875 }
3876 ios.width(25);
3877 left(ios);
3878 {
3879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3880 std::string ex(str, iter.base());
3881 assert(ex == "+1;e+09******************");
3882 assert(ios.width() == 0);
3883 }
3884 ios.width(25);
3885 right(ios);
3886 {
3887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3888 std::string ex(str, iter.base());
3889 assert(ex == "******************+1;e+09");
3890 assert(ios.width() == 0);
3891 }
3892 ios.width(25);
3893 internal(ios);
3894 {
3895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3896 std::string ex(str, iter.base());
3897 assert(ex == "+******************1;e+09");
3898 assert(ios.width() == 0);
3899 }
3900 }
3901 }
3902 }
3903 }
3904 uppercase(ios);
3905 {
3906 noshowpos(ios);
3907 {
3908 noshowpoint(ios);
3909 {
3910 ios.imbue(lc);
3911 {
3912 ios.width(0);
3913 {
3914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3915 std::string ex(str, iter.base());
3916 assert(ex == "1E+09");
3917 assert(ios.width() == 0);
3918 }
3919 ios.width(25);
3920 left(ios);
3921 {
3922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3923 std::string ex(str, iter.base());
3924 assert(ex == "1E+09********************");
3925 assert(ios.width() == 0);
3926 }
3927 ios.width(25);
3928 right(ios);
3929 {
3930 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3931 std::string ex(str, iter.base());
3932 assert(ex == "********************1E+09");
3933 assert(ios.width() == 0);
3934 }
3935 ios.width(25);
3936 internal(ios);
3937 {
3938 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3939 std::string ex(str, iter.base());
3940 assert(ex == "********************1E+09");
3941 assert(ios.width() == 0);
3942 }
3943 }
3944 ios.imbue(lg);
3945 {
3946 ios.width(0);
3947 {
3948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3949 std::string ex(str, iter.base());
3950 assert(ex == "1E+09");
3951 assert(ios.width() == 0);
3952 }
3953 ios.width(25);
3954 left(ios);
3955 {
3956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3957 std::string ex(str, iter.base());
3958 assert(ex == "1E+09********************");
3959 assert(ios.width() == 0);
3960 }
3961 ios.width(25);
3962 right(ios);
3963 {
3964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3965 std::string ex(str, iter.base());
3966 assert(ex == "********************1E+09");
3967 assert(ios.width() == 0);
3968 }
3969 ios.width(25);
3970 internal(ios);
3971 {
3972 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3973 std::string ex(str, iter.base());
3974 assert(ex == "********************1E+09");
3975 assert(ios.width() == 0);
3976 }
3977 }
3978 }
3979 showpoint(ios);
3980 {
3981 ios.imbue(lc);
3982 {
3983 ios.width(0);
3984 {
3985 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3986 std::string ex(str, iter.base());
3987 assert(ex == "1.E+09");
3988 assert(ios.width() == 0);
3989 }
3990 ios.width(25);
3991 left(ios);
3992 {
3993 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3994 std::string ex(str, iter.base());
3995 assert(ex == "1.E+09*******************");
3996 assert(ios.width() == 0);
3997 }
3998 ios.width(25);
3999 right(ios);
4000 {
4001 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4002 std::string ex(str, iter.base());
4003 assert(ex == "*******************1.E+09");
4004 assert(ios.width() == 0);
4005 }
4006 ios.width(25);
4007 internal(ios);
4008 {
4009 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4010 std::string ex(str, iter.base());
4011 assert(ex == "*******************1.E+09");
4012 assert(ios.width() == 0);
4013 }
4014 }
4015 ios.imbue(lg);
4016 {
4017 ios.width(0);
4018 {
4019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4020 std::string ex(str, iter.base());
4021 assert(ex == "1;E+09");
4022 assert(ios.width() == 0);
4023 }
4024 ios.width(25);
4025 left(ios);
4026 {
4027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4028 std::string ex(str, iter.base());
4029 assert(ex == "1;E+09*******************");
4030 assert(ios.width() == 0);
4031 }
4032 ios.width(25);
4033 right(ios);
4034 {
4035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4036 std::string ex(str, iter.base());
4037 assert(ex == "*******************1;E+09");
4038 assert(ios.width() == 0);
4039 }
4040 ios.width(25);
4041 internal(ios);
4042 {
4043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4044 std::string ex(str, iter.base());
4045 assert(ex == "*******************1;E+09");
4046 assert(ios.width() == 0);
4047 }
4048 }
4049 }
4050 }
4051 showpos(ios);
4052 {
4053 noshowpoint(ios);
4054 {
4055 ios.imbue(lc);
4056 {
4057 ios.width(0);
4058 {
4059 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4060 std::string ex(str, iter.base());
4061 assert(ex == "+1E+09");
4062 assert(ios.width() == 0);
4063 }
4064 ios.width(25);
4065 left(ios);
4066 {
4067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4068 std::string ex(str, iter.base());
4069 assert(ex == "+1E+09*******************");
4070 assert(ios.width() == 0);
4071 }
4072 ios.width(25);
4073 right(ios);
4074 {
4075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4076 std::string ex(str, iter.base());
4077 assert(ex == "*******************+1E+09");
4078 assert(ios.width() == 0);
4079 }
4080 ios.width(25);
4081 internal(ios);
4082 {
4083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4084 std::string ex(str, iter.base());
4085 assert(ex == "+*******************1E+09");
4086 assert(ios.width() == 0);
4087 }
4088 }
4089 ios.imbue(lg);
4090 {
4091 ios.width(0);
4092 {
4093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4094 std::string ex(str, iter.base());
4095 assert(ex == "+1E+09");
4096 assert(ios.width() == 0);
4097 }
4098 ios.width(25);
4099 left(ios);
4100 {
4101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4102 std::string ex(str, iter.base());
4103 assert(ex == "+1E+09*******************");
4104 assert(ios.width() == 0);
4105 }
4106 ios.width(25);
4107 right(ios);
4108 {
4109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4110 std::string ex(str, iter.base());
4111 assert(ex == "*******************+1E+09");
4112 assert(ios.width() == 0);
4113 }
4114 ios.width(25);
4115 internal(ios);
4116 {
4117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4118 std::string ex(str, iter.base());
4119 assert(ex == "+*******************1E+09");
4120 assert(ios.width() == 0);
4121 }
4122 }
4123 }
4124 showpoint(ios);
4125 {
4126 ios.imbue(lc);
4127 {
4128 ios.width(0);
4129 {
4130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4131 std::string ex(str, iter.base());
4132 assert(ex == "+1.E+09");
4133 assert(ios.width() == 0);
4134 }
4135 ios.width(25);
4136 left(ios);
4137 {
4138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4139 std::string ex(str, iter.base());
4140 assert(ex == "+1.E+09******************");
4141 assert(ios.width() == 0);
4142 }
4143 ios.width(25);
4144 right(ios);
4145 {
4146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4147 std::string ex(str, iter.base());
4148 assert(ex == "******************+1.E+09");
4149 assert(ios.width() == 0);
4150 }
4151 ios.width(25);
4152 internal(ios);
4153 {
4154 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4155 std::string ex(str, iter.base());
4156 assert(ex == "+******************1.E+09");
4157 assert(ios.width() == 0);
4158 }
4159 }
4160 ios.imbue(lg);
4161 {
4162 ios.width(0);
4163 {
4164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4165 std::string ex(str, iter.base());
4166 assert(ex == "+1;E+09");
4167 assert(ios.width() == 0);
4168 }
4169 ios.width(25);
4170 left(ios);
4171 {
4172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4173 std::string ex(str, iter.base());
4174 assert(ex == "+1;E+09******************");
4175 assert(ios.width() == 0);
4176 }
4177 ios.width(25);
4178 right(ios);
4179 {
4180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4181 std::string ex(str, iter.base());
4182 assert(ex == "******************+1;E+09");
4183 assert(ios.width() == 0);
4184 }
4185 ios.width(25);
4186 internal(ios);
4187 {
4188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4189 std::string ex(str, iter.base());
4190 assert(ex == "+******************1;E+09");
4191 assert(ios.width() == 0);
4192 }
4193 }
4194 }
4195 }
4196 }
4197 }
4198 ios.precision(6);
4199 {
4200 nouppercase(ios);
4201 {
4202 noshowpos(ios);
4203 {
4204 noshowpoint(ios);
4205 {
4206 ios.imbue(lc);
4207 {
4208 ios.width(0);
4209 {
4210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4211 std::string ex(str, iter.base());
4212 assert(ex == "1.23457e+09");
4213 assert(ios.width() == 0);
4214 }
4215 ios.width(25);
4216 left(ios);
4217 {
4218 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4219 std::string ex(str, iter.base());
4220 assert(ex == "1.23457e+09**************");
4221 assert(ios.width() == 0);
4222 }
4223 ios.width(25);
4224 right(ios);
4225 {
4226 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4227 std::string ex(str, iter.base());
4228 assert(ex == "**************1.23457e+09");
4229 assert(ios.width() == 0);
4230 }
4231 ios.width(25);
4232 internal(ios);
4233 {
4234 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4235 std::string ex(str, iter.base());
4236 assert(ex == "**************1.23457e+09");
4237 assert(ios.width() == 0);
4238 }
4239 }
4240 ios.imbue(lg);
4241 {
4242 ios.width(0);
4243 {
4244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4245 std::string ex(str, iter.base());
4246 assert(ex == "1;23457e+09");
4247 assert(ios.width() == 0);
4248 }
4249 ios.width(25);
4250 left(ios);
4251 {
4252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4253 std::string ex(str, iter.base());
4254 assert(ex == "1;23457e+09**************");
4255 assert(ios.width() == 0);
4256 }
4257 ios.width(25);
4258 right(ios);
4259 {
4260 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4261 std::string ex(str, iter.base());
4262 assert(ex == "**************1;23457e+09");
4263 assert(ios.width() == 0);
4264 }
4265 ios.width(25);
4266 internal(ios);
4267 {
4268 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4269 std::string ex(str, iter.base());
4270 assert(ex == "**************1;23457e+09");
4271 assert(ios.width() == 0);
4272 }
4273 }
4274 }
4275 showpoint(ios);
4276 {
4277 ios.imbue(lc);
4278 {
4279 ios.width(0);
4280 {
4281 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4282 std::string ex(str, iter.base());
4283 assert(ex == "1.23457e+09");
4284 assert(ios.width() == 0);
4285 }
4286 ios.width(25);
4287 left(ios);
4288 {
4289 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4290 std::string ex(str, iter.base());
4291 assert(ex == "1.23457e+09**************");
4292 assert(ios.width() == 0);
4293 }
4294 ios.width(25);
4295 right(ios);
4296 {
4297 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4298 std::string ex(str, iter.base());
4299 assert(ex == "**************1.23457e+09");
4300 assert(ios.width() == 0);
4301 }
4302 ios.width(25);
4303 internal(ios);
4304 {
4305 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4306 std::string ex(str, iter.base());
4307 assert(ex == "**************1.23457e+09");
4308 assert(ios.width() == 0);
4309 }
4310 }
4311 ios.imbue(lg);
4312 {
4313 ios.width(0);
4314 {
4315 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4316 std::string ex(str, iter.base());
4317 assert(ex == "1;23457e+09");
4318 assert(ios.width() == 0);
4319 }
4320 ios.width(25);
4321 left(ios);
4322 {
4323 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4324 std::string ex(str, iter.base());
4325 assert(ex == "1;23457e+09**************");
4326 assert(ios.width() == 0);
4327 }
4328 ios.width(25);
4329 right(ios);
4330 {
4331 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4332 std::string ex(str, iter.base());
4333 assert(ex == "**************1;23457e+09");
4334 assert(ios.width() == 0);
4335 }
4336 ios.width(25);
4337 internal(ios);
4338 {
4339 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4340 std::string ex(str, iter.base());
4341 assert(ex == "**************1;23457e+09");
4342 assert(ios.width() == 0);
4343 }
4344 }
4345 }
4346 }
4347 showpos(ios);
4348 {
4349 noshowpoint(ios);
4350 {
4351 ios.imbue(lc);
4352 {
4353 ios.width(0);
4354 {
4355 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4356 std::string ex(str, iter.base());
4357 assert(ex == "+1.23457e+09");
4358 assert(ios.width() == 0);
4359 }
4360 ios.width(25);
4361 left(ios);
4362 {
4363 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4364 std::string ex(str, iter.base());
4365 assert(ex == "+1.23457e+09*************");
4366 assert(ios.width() == 0);
4367 }
4368 ios.width(25);
4369 right(ios);
4370 {
4371 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4372 std::string ex(str, iter.base());
4373 assert(ex == "*************+1.23457e+09");
4374 assert(ios.width() == 0);
4375 }
4376 ios.width(25);
4377 internal(ios);
4378 {
4379 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4380 std::string ex(str, iter.base());
4381 assert(ex == "+*************1.23457e+09");
4382 assert(ios.width() == 0);
4383 }
4384 }
4385 ios.imbue(lg);
4386 {
4387 ios.width(0);
4388 {
4389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4390 std::string ex(str, iter.base());
4391 assert(ex == "+1;23457e+09");
4392 assert(ios.width() == 0);
4393 }
4394 ios.width(25);
4395 left(ios);
4396 {
4397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4398 std::string ex(str, iter.base());
4399 assert(ex == "+1;23457e+09*************");
4400 assert(ios.width() == 0);
4401 }
4402 ios.width(25);
4403 right(ios);
4404 {
4405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4406 std::string ex(str, iter.base());
4407 assert(ex == "*************+1;23457e+09");
4408 assert(ios.width() == 0);
4409 }
4410 ios.width(25);
4411 internal(ios);
4412 {
4413 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4414 std::string ex(str, iter.base());
4415 assert(ex == "+*************1;23457e+09");
4416 assert(ios.width() == 0);
4417 }
4418 }
4419 }
4420 showpoint(ios);
4421 {
4422 ios.imbue(lc);
4423 {
4424 ios.width(0);
4425 {
4426 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4427 std::string ex(str, iter.base());
4428 assert(ex == "+1.23457e+09");
4429 assert(ios.width() == 0);
4430 }
4431 ios.width(25);
4432 left(ios);
4433 {
4434 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4435 std::string ex(str, iter.base());
4436 assert(ex == "+1.23457e+09*************");
4437 assert(ios.width() == 0);
4438 }
4439 ios.width(25);
4440 right(ios);
4441 {
4442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4443 std::string ex(str, iter.base());
4444 assert(ex == "*************+1.23457e+09");
4445 assert(ios.width() == 0);
4446 }
4447 ios.width(25);
4448 internal(ios);
4449 {
4450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4451 std::string ex(str, iter.base());
4452 assert(ex == "+*************1.23457e+09");
4453 assert(ios.width() == 0);
4454 }
4455 }
4456 ios.imbue(lg);
4457 {
4458 ios.width(0);
4459 {
4460 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4461 std::string ex(str, iter.base());
4462 assert(ex == "+1;23457e+09");
4463 assert(ios.width() == 0);
4464 }
4465 ios.width(25);
4466 left(ios);
4467 {
4468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4469 std::string ex(str, iter.base());
4470 assert(ex == "+1;23457e+09*************");
4471 assert(ios.width() == 0);
4472 }
4473 ios.width(25);
4474 right(ios);
4475 {
4476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4477 std::string ex(str, iter.base());
4478 assert(ex == "*************+1;23457e+09");
4479 assert(ios.width() == 0);
4480 }
4481 ios.width(25);
4482 internal(ios);
4483 {
4484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4485 std::string ex(str, iter.base());
4486 assert(ex == "+*************1;23457e+09");
4487 assert(ios.width() == 0);
4488 }
4489 }
4490 }
4491 }
4492 }
4493 uppercase(ios);
4494 {
4495 noshowpos(ios);
4496 {
4497 noshowpoint(ios);
4498 {
4499 ios.imbue(lc);
4500 {
4501 ios.width(0);
4502 {
4503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4504 std::string ex(str, iter.base());
4505 assert(ex == "1.23457E+09");
4506 assert(ios.width() == 0);
4507 }
4508 ios.width(25);
4509 left(ios);
4510 {
4511 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4512 std::string ex(str, iter.base());
4513 assert(ex == "1.23457E+09**************");
4514 assert(ios.width() == 0);
4515 }
4516 ios.width(25);
4517 right(ios);
4518 {
4519 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4520 std::string ex(str, iter.base());
4521 assert(ex == "**************1.23457E+09");
4522 assert(ios.width() == 0);
4523 }
4524 ios.width(25);
4525 internal(ios);
4526 {
4527 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4528 std::string ex(str, iter.base());
4529 assert(ex == "**************1.23457E+09");
4530 assert(ios.width() == 0);
4531 }
4532 }
4533 ios.imbue(lg);
4534 {
4535 ios.width(0);
4536 {
4537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4538 std::string ex(str, iter.base());
4539 assert(ex == "1;23457E+09");
4540 assert(ios.width() == 0);
4541 }
4542 ios.width(25);
4543 left(ios);
4544 {
4545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4546 std::string ex(str, iter.base());
4547 assert(ex == "1;23457E+09**************");
4548 assert(ios.width() == 0);
4549 }
4550 ios.width(25);
4551 right(ios);
4552 {
4553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4554 std::string ex(str, iter.base());
4555 assert(ex == "**************1;23457E+09");
4556 assert(ios.width() == 0);
4557 }
4558 ios.width(25);
4559 internal(ios);
4560 {
4561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4562 std::string ex(str, iter.base());
4563 assert(ex == "**************1;23457E+09");
4564 assert(ios.width() == 0);
4565 }
4566 }
4567 }
4568 showpoint(ios);
4569 {
4570 ios.imbue(lc);
4571 {
4572 ios.width(0);
4573 {
4574 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4575 std::string ex(str, iter.base());
4576 assert(ex == "1.23457E+09");
4577 assert(ios.width() == 0);
4578 }
4579 ios.width(25);
4580 left(ios);
4581 {
4582 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4583 std::string ex(str, iter.base());
4584 assert(ex == "1.23457E+09**************");
4585 assert(ios.width() == 0);
4586 }
4587 ios.width(25);
4588 right(ios);
4589 {
4590 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4591 std::string ex(str, iter.base());
4592 assert(ex == "**************1.23457E+09");
4593 assert(ios.width() == 0);
4594 }
4595 ios.width(25);
4596 internal(ios);
4597 {
4598 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4599 std::string ex(str, iter.base());
4600 assert(ex == "**************1.23457E+09");
4601 assert(ios.width() == 0);
4602 }
4603 }
4604 ios.imbue(lg);
4605 {
4606 ios.width(0);
4607 {
4608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4609 std::string ex(str, iter.base());
4610 assert(ex == "1;23457E+09");
4611 assert(ios.width() == 0);
4612 }
4613 ios.width(25);
4614 left(ios);
4615 {
4616 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4617 std::string ex(str, iter.base());
4618 assert(ex == "1;23457E+09**************");
4619 assert(ios.width() == 0);
4620 }
4621 ios.width(25);
4622 right(ios);
4623 {
4624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4625 std::string ex(str, iter.base());
4626 assert(ex == "**************1;23457E+09");
4627 assert(ios.width() == 0);
4628 }
4629 ios.width(25);
4630 internal(ios);
4631 {
4632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4633 std::string ex(str, iter.base());
4634 assert(ex == "**************1;23457E+09");
4635 assert(ios.width() == 0);
4636 }
4637 }
4638 }
4639 }
4640 showpos(ios);
4641 {
4642 noshowpoint(ios);
4643 {
4644 ios.imbue(lc);
4645 {
4646 ios.width(0);
4647 {
4648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4649 std::string ex(str, iter.base());
4650 assert(ex == "+1.23457E+09");
4651 assert(ios.width() == 0);
4652 }
4653 ios.width(25);
4654 left(ios);
4655 {
4656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4657 std::string ex(str, iter.base());
4658 assert(ex == "+1.23457E+09*************");
4659 assert(ios.width() == 0);
4660 }
4661 ios.width(25);
4662 right(ios);
4663 {
4664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4665 std::string ex(str, iter.base());
4666 assert(ex == "*************+1.23457E+09");
4667 assert(ios.width() == 0);
4668 }
4669 ios.width(25);
4670 internal(ios);
4671 {
4672 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4673 std::string ex(str, iter.base());
4674 assert(ex == "+*************1.23457E+09");
4675 assert(ios.width() == 0);
4676 }
4677 }
4678 ios.imbue(lg);
4679 {
4680 ios.width(0);
4681 {
4682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4683 std::string ex(str, iter.base());
4684 assert(ex == "+1;23457E+09");
4685 assert(ios.width() == 0);
4686 }
4687 ios.width(25);
4688 left(ios);
4689 {
4690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4691 std::string ex(str, iter.base());
4692 assert(ex == "+1;23457E+09*************");
4693 assert(ios.width() == 0);
4694 }
4695 ios.width(25);
4696 right(ios);
4697 {
4698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4699 std::string ex(str, iter.base());
4700 assert(ex == "*************+1;23457E+09");
4701 assert(ios.width() == 0);
4702 }
4703 ios.width(25);
4704 internal(ios);
4705 {
4706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4707 std::string ex(str, iter.base());
4708 assert(ex == "+*************1;23457E+09");
4709 assert(ios.width() == 0);
4710 }
4711 }
4712 }
4713 showpoint(ios);
4714 {
4715 ios.imbue(lc);
4716 {
4717 ios.width(0);
4718 {
4719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4720 std::string ex(str, iter.base());
4721 assert(ex == "+1.23457E+09");
4722 assert(ios.width() == 0);
4723 }
4724 ios.width(25);
4725 left(ios);
4726 {
4727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4728 std::string ex(str, iter.base());
4729 assert(ex == "+1.23457E+09*************");
4730 assert(ios.width() == 0);
4731 }
4732 ios.width(25);
4733 right(ios);
4734 {
4735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4736 std::string ex(str, iter.base());
4737 assert(ex == "*************+1.23457E+09");
4738 assert(ios.width() == 0);
4739 }
4740 ios.width(25);
4741 internal(ios);
4742 {
4743 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4744 std::string ex(str, iter.base());
4745 assert(ex == "+*************1.23457E+09");
4746 assert(ios.width() == 0);
4747 }
4748 }
4749 ios.imbue(lg);
4750 {
4751 ios.width(0);
4752 {
4753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4754 std::string ex(str, iter.base());
4755 assert(ex == "+1;23457E+09");
4756 assert(ios.width() == 0);
4757 }
4758 ios.width(25);
4759 left(ios);
4760 {
4761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4762 std::string ex(str, iter.base());
4763 assert(ex == "+1;23457E+09*************");
4764 assert(ios.width() == 0);
4765 }
4766 ios.width(25);
4767 right(ios);
4768 {
4769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4770 std::string ex(str, iter.base());
4771 assert(ex == "*************+1;23457E+09");
4772 assert(ios.width() == 0);
4773 }
4774 ios.width(25);
4775 internal(ios);
4776 {
4777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4778 std::string ex(str, iter.base());
4779 assert(ex == "+*************1;23457E+09");
4780 assert(ios.width() == 0);
4781 }
4782 }
4783 }
4784 }
4785 }
4786 }
4787 ios.precision(16);
4788 {
4789 nouppercase(ios);
4790 {
4791 noshowpos(ios);
4792 {
4793 noshowpoint(ios);
4794 {
4795 ios.imbue(lc);
4796 {
4797 ios.width(0);
4798 {
4799 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4800 std::string ex(str, iter.base());
4801 assert(ex == "1234567890.125");
4802 assert(ios.width() == 0);
4803 }
4804 ios.width(25);
4805 left(ios);
4806 {
4807 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4808 std::string ex(str, iter.base());
4809 assert(ex == "1234567890.125***********");
4810 assert(ios.width() == 0);
4811 }
4812 ios.width(25);
4813 right(ios);
4814 {
4815 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4816 std::string ex(str, iter.base());
4817 assert(ex == "***********1234567890.125");
4818 assert(ios.width() == 0);
4819 }
4820 ios.width(25);
4821 internal(ios);
4822 {
4823 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4824 std::string ex(str, iter.base());
4825 assert(ex == "***********1234567890.125");
4826 assert(ios.width() == 0);
4827 }
4828 }
4829 ios.imbue(lg);
4830 {
4831 ios.width(0);
4832 {
4833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4834 std::string ex(str, iter.base());
4835 assert(ex == "1_234_567_89_0;125");
4836 assert(ios.width() == 0);
4837 }
4838 ios.width(25);
4839 left(ios);
4840 {
4841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4842 std::string ex(str, iter.base());
4843 assert(ex == "1_234_567_89_0;125*******");
4844 assert(ios.width() == 0);
4845 }
4846 ios.width(25);
4847 right(ios);
4848 {
4849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4850 std::string ex(str, iter.base());
4851 assert(ex == "*******1_234_567_89_0;125");
4852 assert(ios.width() == 0);
4853 }
4854 ios.width(25);
4855 internal(ios);
4856 {
4857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4858 std::string ex(str, iter.base());
4859 assert(ex == "*******1_234_567_89_0;125");
4860 assert(ios.width() == 0);
4861 }
4862 }
4863 }
4864 showpoint(ios);
4865 {
4866 ios.imbue(lc);
4867 {
4868 ios.width(0);
4869 {
4870 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4871 std::string ex(str, iter.base());
4872 assert(ex == "1234567890.125000");
4873 assert(ios.width() == 0);
4874 }
4875 ios.width(25);
4876 left(ios);
4877 {
4878 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4879 std::string ex(str, iter.base());
4880 assert(ex == "1234567890.125000********");
4881 assert(ios.width() == 0);
4882 }
4883 ios.width(25);
4884 right(ios);
4885 {
4886 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4887 std::string ex(str, iter.base());
4888 assert(ex == "********1234567890.125000");
4889 assert(ios.width() == 0);
4890 }
4891 ios.width(25);
4892 internal(ios);
4893 {
4894 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4895 std::string ex(str, iter.base());
4896 assert(ex == "********1234567890.125000");
4897 assert(ios.width() == 0);
4898 }
4899 }
4900 ios.imbue(lg);
4901 {
4902 ios.width(0);
4903 {
4904 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4905 std::string ex(str, iter.base());
4906 assert(ex == "1_234_567_89_0;125000");
4907 assert(ios.width() == 0);
4908 }
4909 ios.width(25);
4910 left(ios);
4911 {
4912 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4913 std::string ex(str, iter.base());
4914 assert(ex == "1_234_567_89_0;125000****");
4915 assert(ios.width() == 0);
4916 }
4917 ios.width(25);
4918 right(ios);
4919 {
4920 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4921 std::string ex(str, iter.base());
4922 assert(ex == "****1_234_567_89_0;125000");
4923 assert(ios.width() == 0);
4924 }
4925 ios.width(25);
4926 internal(ios);
4927 {
4928 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4929 std::string ex(str, iter.base());
4930 assert(ex == "****1_234_567_89_0;125000");
4931 assert(ios.width() == 0);
4932 }
4933 }
4934 }
4935 }
4936 showpos(ios);
4937 {
4938 noshowpoint(ios);
4939 {
4940 ios.imbue(lc);
4941 {
4942 ios.width(0);
4943 {
4944 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4945 std::string ex(str, iter.base());
4946 assert(ex == "+1234567890.125");
4947 assert(ios.width() == 0);
4948 }
4949 ios.width(25);
4950 left(ios);
4951 {
4952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4953 std::string ex(str, iter.base());
4954 assert(ex == "+1234567890.125**********");
4955 assert(ios.width() == 0);
4956 }
4957 ios.width(25);
4958 right(ios);
4959 {
4960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4961 std::string ex(str, iter.base());
4962 assert(ex == "**********+1234567890.125");
4963 assert(ios.width() == 0);
4964 }
4965 ios.width(25);
4966 internal(ios);
4967 {
4968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4969 std::string ex(str, iter.base());
4970 assert(ex == "+**********1234567890.125");
4971 assert(ios.width() == 0);
4972 }
4973 }
4974 ios.imbue(lg);
4975 {
4976 ios.width(0);
4977 {
4978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4979 std::string ex(str, iter.base());
4980 assert(ex == "+1_234_567_89_0;125");
4981 assert(ios.width() == 0);
4982 }
4983 ios.width(25);
4984 left(ios);
4985 {
4986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4987 std::string ex(str, iter.base());
4988 assert(ex == "+1_234_567_89_0;125******");
4989 assert(ios.width() == 0);
4990 }
4991 ios.width(25);
4992 right(ios);
4993 {
4994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4995 std::string ex(str, iter.base());
4996 assert(ex == "******+1_234_567_89_0;125");
4997 assert(ios.width() == 0);
4998 }
4999 ios.width(25);
5000 internal(ios);
5001 {
5002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5003 std::string ex(str, iter.base());
5004 assert(ex == "+******1_234_567_89_0;125");
5005 assert(ios.width() == 0);
5006 }
5007 }
5008 }
5009 showpoint(ios);
5010 {
5011 ios.imbue(lc);
5012 {
5013 ios.width(0);
5014 {
5015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5016 std::string ex(str, iter.base());
5017 assert(ex == "+1234567890.125000");
5018 assert(ios.width() == 0);
5019 }
5020 ios.width(25);
5021 left(ios);
5022 {
5023 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5024 std::string ex(str, iter.base());
5025 assert(ex == "+1234567890.125000*******");
5026 assert(ios.width() == 0);
5027 }
5028 ios.width(25);
5029 right(ios);
5030 {
5031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5032 std::string ex(str, iter.base());
5033 assert(ex == "*******+1234567890.125000");
5034 assert(ios.width() == 0);
5035 }
5036 ios.width(25);
5037 internal(ios);
5038 {
5039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5040 std::string ex(str, iter.base());
5041 assert(ex == "+*******1234567890.125000");
5042 assert(ios.width() == 0);
5043 }
5044 }
5045 ios.imbue(lg);
5046 {
5047 ios.width(0);
5048 {
5049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5050 std::string ex(str, iter.base());
5051 assert(ex == "+1_234_567_89_0;125000");
5052 assert(ios.width() == 0);
5053 }
5054 ios.width(25);
5055 left(ios);
5056 {
5057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5058 std::string ex(str, iter.base());
5059 assert(ex == "+1_234_567_89_0;125000***");
5060 assert(ios.width() == 0);
5061 }
5062 ios.width(25);
5063 right(ios);
5064 {
5065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5066 std::string ex(str, iter.base());
5067 assert(ex == "***+1_234_567_89_0;125000");
5068 assert(ios.width() == 0);
5069 }
5070 ios.width(25);
5071 internal(ios);
5072 {
5073 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5074 std::string ex(str, iter.base());
5075 assert(ex == "+***1_234_567_89_0;125000");
5076 assert(ios.width() == 0);
5077 }
5078 }
5079 }
5080 }
5081 }
5082 uppercase(ios);
5083 {
5084 noshowpos(ios);
5085 {
5086 noshowpoint(ios);
5087 {
5088 ios.imbue(lc);
5089 {
5090 ios.width(0);
5091 {
5092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5093 std::string ex(str, iter.base());
5094 assert(ex == "1234567890.125");
5095 assert(ios.width() == 0);
5096 }
5097 ios.width(25);
5098 left(ios);
5099 {
5100 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5101 std::string ex(str, iter.base());
5102 assert(ex == "1234567890.125***********");
5103 assert(ios.width() == 0);
5104 }
5105 ios.width(25);
5106 right(ios);
5107 {
5108 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5109 std::string ex(str, iter.base());
5110 assert(ex == "***********1234567890.125");
5111 assert(ios.width() == 0);
5112 }
5113 ios.width(25);
5114 internal(ios);
5115 {
5116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5117 std::string ex(str, iter.base());
5118 assert(ex == "***********1234567890.125");
5119 assert(ios.width() == 0);
5120 }
5121 }
5122 ios.imbue(lg);
5123 {
5124 ios.width(0);
5125 {
5126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5127 std::string ex(str, iter.base());
5128 assert(ex == "1_234_567_89_0;125");
5129 assert(ios.width() == 0);
5130 }
5131 ios.width(25);
5132 left(ios);
5133 {
5134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5135 std::string ex(str, iter.base());
5136 assert(ex == "1_234_567_89_0;125*******");
5137 assert(ios.width() == 0);
5138 }
5139 ios.width(25);
5140 right(ios);
5141 {
5142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5143 std::string ex(str, iter.base());
5144 assert(ex == "*******1_234_567_89_0;125");
5145 assert(ios.width() == 0);
5146 }
5147 ios.width(25);
5148 internal(ios);
5149 {
5150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5151 std::string ex(str, iter.base());
5152 assert(ex == "*******1_234_567_89_0;125");
5153 assert(ios.width() == 0);
5154 }
5155 }
5156 }
5157 showpoint(ios);
5158 {
5159 ios.imbue(lc);
5160 {
5161 ios.width(0);
5162 {
5163 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5164 std::string ex(str, iter.base());
5165 assert(ex == "1234567890.125000");
5166 assert(ios.width() == 0);
5167 }
5168 ios.width(25);
5169 left(ios);
5170 {
5171 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5172 std::string ex(str, iter.base());
5173 assert(ex == "1234567890.125000********");
5174 assert(ios.width() == 0);
5175 }
5176 ios.width(25);
5177 right(ios);
5178 {
5179 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5180 std::string ex(str, iter.base());
5181 assert(ex == "********1234567890.125000");
5182 assert(ios.width() == 0);
5183 }
5184 ios.width(25);
5185 internal(ios);
5186 {
5187 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5188 std::string ex(str, iter.base());
5189 assert(ex == "********1234567890.125000");
5190 assert(ios.width() == 0);
5191 }
5192 }
5193 ios.imbue(lg);
5194 {
5195 ios.width(0);
5196 {
5197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5198 std::string ex(str, iter.base());
5199 assert(ex == "1_234_567_89_0;125000");
5200 assert(ios.width() == 0);
5201 }
5202 ios.width(25);
5203 left(ios);
5204 {
5205 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5206 std::string ex(str, iter.base());
5207 assert(ex == "1_234_567_89_0;125000****");
5208 assert(ios.width() == 0);
5209 }
5210 ios.width(25);
5211 right(ios);
5212 {
5213 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5214 std::string ex(str, iter.base());
5215 assert(ex == "****1_234_567_89_0;125000");
5216 assert(ios.width() == 0);
5217 }
5218 ios.width(25);
5219 internal(ios);
5220 {
5221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5222 std::string ex(str, iter.base());
5223 assert(ex == "****1_234_567_89_0;125000");
5224 assert(ios.width() == 0);
5225 }
5226 }
5227 }
5228 }
5229 showpos(ios);
5230 {
5231 noshowpoint(ios);
5232 {
5233 ios.imbue(lc);
5234 {
5235 ios.width(0);
5236 {
5237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5238 std::string ex(str, iter.base());
5239 assert(ex == "+1234567890.125");
5240 assert(ios.width() == 0);
5241 }
5242 ios.width(25);
5243 left(ios);
5244 {
5245 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5246 std::string ex(str, iter.base());
5247 assert(ex == "+1234567890.125**********");
5248 assert(ios.width() == 0);
5249 }
5250 ios.width(25);
5251 right(ios);
5252 {
5253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5254 std::string ex(str, iter.base());
5255 assert(ex == "**********+1234567890.125");
5256 assert(ios.width() == 0);
5257 }
5258 ios.width(25);
5259 internal(ios);
5260 {
5261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5262 std::string ex(str, iter.base());
5263 assert(ex == "+**********1234567890.125");
5264 assert(ios.width() == 0);
5265 }
5266 }
5267 ios.imbue(lg);
5268 {
5269 ios.width(0);
5270 {
5271 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5272 std::string ex(str, iter.base());
5273 assert(ex == "+1_234_567_89_0;125");
5274 assert(ios.width() == 0);
5275 }
5276 ios.width(25);
5277 left(ios);
5278 {
5279 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5280 std::string ex(str, iter.base());
5281 assert(ex == "+1_234_567_89_0;125******");
5282 assert(ios.width() == 0);
5283 }
5284 ios.width(25);
5285 right(ios);
5286 {
5287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5288 std::string ex(str, iter.base());
5289 assert(ex == "******+1_234_567_89_0;125");
5290 assert(ios.width() == 0);
5291 }
5292 ios.width(25);
5293 internal(ios);
5294 {
5295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5296 std::string ex(str, iter.base());
5297 assert(ex == "+******1_234_567_89_0;125");
5298 assert(ios.width() == 0);
5299 }
5300 }
5301 }
5302 showpoint(ios);
5303 {
5304 ios.imbue(lc);
5305 {
5306 ios.width(0);
5307 {
5308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5309 std::string ex(str, iter.base());
5310 assert(ex == "+1234567890.125000");
5311 assert(ios.width() == 0);
5312 }
5313 ios.width(25);
5314 left(ios);
5315 {
5316 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5317 std::string ex(str, iter.base());
5318 assert(ex == "+1234567890.125000*******");
5319 assert(ios.width() == 0);
5320 }
5321 ios.width(25);
5322 right(ios);
5323 {
5324 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5325 std::string ex(str, iter.base());
5326 assert(ex == "*******+1234567890.125000");
5327 assert(ios.width() == 0);
5328 }
5329 ios.width(25);
5330 internal(ios);
5331 {
5332 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5333 std::string ex(str, iter.base());
5334 assert(ex == "+*******1234567890.125000");
5335 assert(ios.width() == 0);
5336 }
5337 }
5338 ios.imbue(lg);
5339 {
5340 ios.width(0);
5341 {
5342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5343 std::string ex(str, iter.base());
5344 assert(ex == "+1_234_567_89_0;125000");
5345 assert(ios.width() == 0);
5346 }
5347 ios.width(25);
5348 left(ios);
5349 {
5350 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5351 std::string ex(str, iter.base());
5352 assert(ex == "+1_234_567_89_0;125000***");
5353 assert(ios.width() == 0);
5354 }
5355 ios.width(25);
5356 right(ios);
5357 {
5358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5359 std::string ex(str, iter.base());
5360 assert(ex == "***+1_234_567_89_0;125000");
5361 assert(ios.width() == 0);
5362 }
5363 ios.width(25);
5364 internal(ios);
5365 {
5366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5367 std::string ex(str, iter.base());
5368 assert(ex == "+***1_234_567_89_0;125000");
5369 assert(ios.width() == 0);
5370 }
5371 }
5372 }
5373 }
5374 }
5375 }
5376 ios.precision(60);
5377 {
5378 nouppercase(ios);
5379 {
5380 noshowpos(ios);
5381 {
5382 noshowpoint(ios);
5383 {
5384 ios.imbue(lc);
5385 {
5386 ios.width(0);
5387 {
5388 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5389 std::string ex(str, iter.base());
5390 assert(ex == "1234567890.125");
5391 assert(ios.width() == 0);
5392 }
5393 ios.width(25);
5394 left(ios);
5395 {
5396 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5397 std::string ex(str, iter.base());
5398 assert(ex == "1234567890.125***********");
5399 assert(ios.width() == 0);
5400 }
5401 ios.width(25);
5402 right(ios);
5403 {
5404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5405 std::string ex(str, iter.base());
5406 assert(ex == "***********1234567890.125");
5407 assert(ios.width() == 0);
5408 }
5409 ios.width(25);
5410 internal(ios);
5411 {
5412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5413 std::string ex(str, iter.base());
5414 assert(ex == "***********1234567890.125");
5415 assert(ios.width() == 0);
5416 }
5417 }
5418 ios.imbue(lg);
5419 {
5420 ios.width(0);
5421 {
5422 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5423 std::string ex(str, iter.base());
5424 assert(ex == "1_234_567_89_0;125");
5425 assert(ios.width() == 0);
5426 }
5427 ios.width(25);
5428 left(ios);
5429 {
5430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5431 std::string ex(str, iter.base());
5432 assert(ex == "1_234_567_89_0;125*******");
5433 assert(ios.width() == 0);
5434 }
5435 ios.width(25);
5436 right(ios);
5437 {
5438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5439 std::string ex(str, iter.base());
5440 assert(ex == "*******1_234_567_89_0;125");
5441 assert(ios.width() == 0);
5442 }
5443 ios.width(25);
5444 internal(ios);
5445 {
5446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5447 std::string ex(str, iter.base());
5448 assert(ex == "*******1_234_567_89_0;125");
5449 assert(ios.width() == 0);
5450 }
5451 }
5452 }
5453 showpoint(ios);
5454 {
5455 ios.imbue(lc);
5456 {
5457 ios.width(0);
5458 {
5459 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5460 std::string ex(str, iter.base());
5461 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5462 assert(ios.width() == 0);
5463 }
5464 ios.width(25);
5465 left(ios);
5466 {
5467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5468 std::string ex(str, iter.base());
5469 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5470 assert(ios.width() == 0);
5471 }
5472 ios.width(25);
5473 right(ios);
5474 {
5475 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5476 std::string ex(str, iter.base());
5477 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5478 assert(ios.width() == 0);
5479 }
5480 ios.width(25);
5481 internal(ios);
5482 {
5483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5484 std::string ex(str, iter.base());
5485 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5486 assert(ios.width() == 0);
5487 }
5488 }
5489 ios.imbue(lg);
5490 {
5491 ios.width(0);
5492 {
5493 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5494 std::string ex(str, iter.base());
5495 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5496 assert(ios.width() == 0);
5497 }
5498 ios.width(25);
5499 left(ios);
5500 {
5501 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5502 std::string ex(str, iter.base());
5503 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5504 assert(ios.width() == 0);
5505 }
5506 ios.width(25);
5507 right(ios);
5508 {
5509 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5510 std::string ex(str, iter.base());
5511 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5512 assert(ios.width() == 0);
5513 }
5514 ios.width(25);
5515 internal(ios);
5516 {
5517 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5518 std::string ex(str, iter.base());
5519 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5520 assert(ios.width() == 0);
5521 }
5522 }
5523 }
5524 }
5525 showpos(ios);
5526 {
5527 noshowpoint(ios);
5528 {
5529 ios.imbue(lc);
5530 {
5531 ios.width(0);
5532 {
5533 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5534 std::string ex(str, iter.base());
5535 assert(ex == "+1234567890.125");
5536 assert(ios.width() == 0);
5537 }
5538 ios.width(25);
5539 left(ios);
5540 {
5541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5542 std::string ex(str, iter.base());
5543 assert(ex == "+1234567890.125**********");
5544 assert(ios.width() == 0);
5545 }
5546 ios.width(25);
5547 right(ios);
5548 {
5549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5550 std::string ex(str, iter.base());
5551 assert(ex == "**********+1234567890.125");
5552 assert(ios.width() == 0);
5553 }
5554 ios.width(25);
5555 internal(ios);
5556 {
5557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5558 std::string ex(str, iter.base());
5559 assert(ex == "+**********1234567890.125");
5560 assert(ios.width() == 0);
5561 }
5562 }
5563 ios.imbue(lg);
5564 {
5565 ios.width(0);
5566 {
5567 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5568 std::string ex(str, iter.base());
5569 assert(ex == "+1_234_567_89_0;125");
5570 assert(ios.width() == 0);
5571 }
5572 ios.width(25);
5573 left(ios);
5574 {
5575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5576 std::string ex(str, iter.base());
5577 assert(ex == "+1_234_567_89_0;125******");
5578 assert(ios.width() == 0);
5579 }
5580 ios.width(25);
5581 right(ios);
5582 {
5583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5584 std::string ex(str, iter.base());
5585 assert(ex == "******+1_234_567_89_0;125");
5586 assert(ios.width() == 0);
5587 }
5588 ios.width(25);
5589 internal(ios);
5590 {
5591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5592 std::string ex(str, iter.base());
5593 assert(ex == "+******1_234_567_89_0;125");
5594 assert(ios.width() == 0);
5595 }
5596 }
5597 }
5598 showpoint(ios);
5599 {
5600 ios.imbue(lc);
5601 {
5602 ios.width(0);
5603 {
5604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5605 std::string ex(str, iter.base());
5606 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5607 assert(ios.width() == 0);
5608 }
5609 ios.width(25);
5610 left(ios);
5611 {
5612 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5613 std::string ex(str, iter.base());
5614 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5615 assert(ios.width() == 0);
5616 }
5617 ios.width(25);
5618 right(ios);
5619 {
5620 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5621 std::string ex(str, iter.base());
5622 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5623 assert(ios.width() == 0);
5624 }
5625 ios.width(25);
5626 internal(ios);
5627 {
5628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5629 std::string ex(str, iter.base());
5630 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5631 assert(ios.width() == 0);
5632 }
5633 }
5634 ios.imbue(lg);
5635 {
5636 ios.width(0);
5637 {
5638 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5639 std::string ex(str, iter.base());
5640 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5641 assert(ios.width() == 0);
5642 }
5643 ios.width(25);
5644 left(ios);
5645 {
5646 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5647 std::string ex(str, iter.base());
5648 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5649 assert(ios.width() == 0);
5650 }
5651 ios.width(25);
5652 right(ios);
5653 {
5654 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5655 std::string ex(str, iter.base());
5656 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5657 assert(ios.width() == 0);
5658 }
5659 ios.width(25);
5660 internal(ios);
5661 {
5662 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5663 std::string ex(str, iter.base());
5664 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5665 assert(ios.width() == 0);
5666 }
5667 }
5668 }
5669 }
5670 }
5671 uppercase(ios);
5672 {
5673 noshowpos(ios);
5674 {
5675 noshowpoint(ios);
5676 {
5677 ios.imbue(lc);
5678 {
5679 ios.width(0);
5680 {
5681 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5682 std::string ex(str, iter.base());
5683 assert(ex == "1234567890.125");
5684 assert(ios.width() == 0);
5685 }
5686 ios.width(25);
5687 left(ios);
5688 {
5689 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5690 std::string ex(str, iter.base());
5691 assert(ex == "1234567890.125***********");
5692 assert(ios.width() == 0);
5693 }
5694 ios.width(25);
5695 right(ios);
5696 {
5697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5698 std::string ex(str, iter.base());
5699 assert(ex == "***********1234567890.125");
5700 assert(ios.width() == 0);
5701 }
5702 ios.width(25);
5703 internal(ios);
5704 {
5705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5706 std::string ex(str, iter.base());
5707 assert(ex == "***********1234567890.125");
5708 assert(ios.width() == 0);
5709 }
5710 }
5711 ios.imbue(lg);
5712 {
5713 ios.width(0);
5714 {
5715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5716 std::string ex(str, iter.base());
5717 assert(ex == "1_234_567_89_0;125");
5718 assert(ios.width() == 0);
5719 }
5720 ios.width(25);
5721 left(ios);
5722 {
5723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5724 std::string ex(str, iter.base());
5725 assert(ex == "1_234_567_89_0;125*******");
5726 assert(ios.width() == 0);
5727 }
5728 ios.width(25);
5729 right(ios);
5730 {
5731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5732 std::string ex(str, iter.base());
5733 assert(ex == "*******1_234_567_89_0;125");
5734 assert(ios.width() == 0);
5735 }
5736 ios.width(25);
5737 internal(ios);
5738 {
5739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5740 std::string ex(str, iter.base());
5741 assert(ex == "*******1_234_567_89_0;125");
5742 assert(ios.width() == 0);
5743 }
5744 }
5745 }
5746 showpoint(ios);
5747 {
5748 ios.imbue(lc);
5749 {
5750 ios.width(0);
5751 {
5752 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5753 std::string ex(str, iter.base());
5754 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5755 assert(ios.width() == 0);
5756 }
5757 ios.width(25);
5758 left(ios);
5759 {
5760 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5761 std::string ex(str, iter.base());
5762 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5763 assert(ios.width() == 0);
5764 }
5765 ios.width(25);
5766 right(ios);
5767 {
5768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5769 std::string ex(str, iter.base());
5770 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5771 assert(ios.width() == 0);
5772 }
5773 ios.width(25);
5774 internal(ios);
5775 {
5776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5777 std::string ex(str, iter.base());
5778 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5779 assert(ios.width() == 0);
5780 }
5781 }
5782 ios.imbue(lg);
5783 {
5784 ios.width(0);
5785 {
5786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5787 std::string ex(str, iter.base());
5788 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5789 assert(ios.width() == 0);
5790 }
5791 ios.width(25);
5792 left(ios);
5793 {
5794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5795 std::string ex(str, iter.base());
5796 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5797 assert(ios.width() == 0);
5798 }
5799 ios.width(25);
5800 right(ios);
5801 {
5802 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5803 std::string ex(str, iter.base());
5804 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5805 assert(ios.width() == 0);
5806 }
5807 ios.width(25);
5808 internal(ios);
5809 {
5810 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5811 std::string ex(str, iter.base());
5812 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5813 assert(ios.width() == 0);
5814 }
5815 }
5816 }
5817 }
5818 showpos(ios);
5819 {
5820 noshowpoint(ios);
5821 {
5822 ios.imbue(lc);
5823 {
5824 ios.width(0);
5825 {
5826 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5827 std::string ex(str, iter.base());
5828 assert(ex == "+1234567890.125");
5829 assert(ios.width() == 0);
5830 }
5831 ios.width(25);
5832 left(ios);
5833 {
5834 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5835 std::string ex(str, iter.base());
5836 assert(ex == "+1234567890.125**********");
5837 assert(ios.width() == 0);
5838 }
5839 ios.width(25);
5840 right(ios);
5841 {
5842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5843 std::string ex(str, iter.base());
5844 assert(ex == "**********+1234567890.125");
5845 assert(ios.width() == 0);
5846 }
5847 ios.width(25);
5848 internal(ios);
5849 {
5850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5851 std::string ex(str, iter.base());
5852 assert(ex == "+**********1234567890.125");
5853 assert(ios.width() == 0);
5854 }
5855 }
5856 ios.imbue(lg);
5857 {
5858 ios.width(0);
5859 {
5860 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5861 std::string ex(str, iter.base());
5862 assert(ex == "+1_234_567_89_0;125");
5863 assert(ios.width() == 0);
5864 }
5865 ios.width(25);
5866 left(ios);
5867 {
5868 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5869 std::string ex(str, iter.base());
5870 assert(ex == "+1_234_567_89_0;125******");
5871 assert(ios.width() == 0);
5872 }
5873 ios.width(25);
5874 right(ios);
5875 {
5876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5877 std::string ex(str, iter.base());
5878 assert(ex == "******+1_234_567_89_0;125");
5879 assert(ios.width() == 0);
5880 }
5881 ios.width(25);
5882 internal(ios);
5883 {
5884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5885 std::string ex(str, iter.base());
5886 assert(ex == "+******1_234_567_89_0;125");
5887 assert(ios.width() == 0);
5888 }
5889 }
5890 }
5891 showpoint(ios);
5892 {
5893 ios.imbue(lc);
5894 {
5895 ios.width(0);
5896 {
5897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5898 std::string ex(str, iter.base());
5899 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5900 assert(ios.width() == 0);
5901 }
5902 ios.width(25);
5903 left(ios);
5904 {
5905 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5906 std::string ex(str, iter.base());
5907 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5908 assert(ios.width() == 0);
5909 }
5910 ios.width(25);
5911 right(ios);
5912 {
5913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5914 std::string ex(str, iter.base());
5915 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5916 assert(ios.width() == 0);
5917 }
5918 ios.width(25);
5919 internal(ios);
5920 {
5921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5922 std::string ex(str, iter.base());
5923 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5924 assert(ios.width() == 0);
5925 }
5926 }
5927 ios.imbue(lg);
5928 {
5929 ios.width(0);
5930 {
5931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5932 std::string ex(str, iter.base());
5933 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5934 assert(ios.width() == 0);
5935 }
5936 ios.width(25);
5937 left(ios);
5938 {
5939 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5940 std::string ex(str, iter.base());
5941 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5942 assert(ios.width() == 0);
5943 }
5944 ios.width(25);
5945 right(ios);
5946 {
5947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5948 std::string ex(str, iter.base());
5949 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5950 assert(ios.width() == 0);
5951 }
5952 ios.width(25);
5953 internal(ios);
5954 {
5955 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5956 std::string ex(str, iter.base());
5957 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5958 assert(ios.width() == 0);
5959 }
5960 }
5961 }
5962 }
5963 }
5964 }
5965 }
5966 }
5967 }
5968
test3()5969 void test3()
5970 {
5971 char str[200];
5972 output_iterator<char*> iter;
5973 std::locale lc = std::locale::classic();
5974 std::locale lg(lc, new my_numpunct);
5975 const my_facet f(1);
5976 {
5977 double v = +0.;
5978 std::ios ios(0);
5979 fixed(ios);
5980 // %f
5981 {
5982 ios.precision(0);
5983 {
5984 nouppercase(ios);
5985 {
5986 noshowpos(ios);
5987 {
5988 noshowpoint(ios);
5989 {
5990 ios.imbue(lc);
5991 {
5992 ios.width(0);
5993 {
5994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5995 std::string ex(str, iter.base());
5996 assert(ex == "0");
5997 assert(ios.width() == 0);
5998 }
5999 ios.width(25);
6000 left(ios);
6001 {
6002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6003 std::string ex(str, iter.base());
6004 assert(ex == "0************************");
6005 assert(ios.width() == 0);
6006 }
6007 ios.width(25);
6008 right(ios);
6009 {
6010 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6011 std::string ex(str, iter.base());
6012 assert(ex == "************************0");
6013 assert(ios.width() == 0);
6014 }
6015 ios.width(25);
6016 internal(ios);
6017 {
6018 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6019 std::string ex(str, iter.base());
6020 assert(ex == "************************0");
6021 assert(ios.width() == 0);
6022 }
6023 }
6024 ios.imbue(lg);
6025 {
6026 ios.width(0);
6027 {
6028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6029 std::string ex(str, iter.base());
6030 assert(ex == "0");
6031 assert(ios.width() == 0);
6032 }
6033 ios.width(25);
6034 left(ios);
6035 {
6036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6037 std::string ex(str, iter.base());
6038 assert(ex == "0************************");
6039 assert(ios.width() == 0);
6040 }
6041 ios.width(25);
6042 right(ios);
6043 {
6044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6045 std::string ex(str, iter.base());
6046 assert(ex == "************************0");
6047 assert(ios.width() == 0);
6048 }
6049 ios.width(25);
6050 internal(ios);
6051 {
6052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6053 std::string ex(str, iter.base());
6054 assert(ex == "************************0");
6055 assert(ios.width() == 0);
6056 }
6057 }
6058 }
6059 showpoint(ios);
6060 {
6061 ios.imbue(lc);
6062 {
6063 ios.width(0);
6064 {
6065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6066 std::string ex(str, iter.base());
6067 assert(ex == "0.");
6068 assert(ios.width() == 0);
6069 }
6070 ios.width(25);
6071 left(ios);
6072 {
6073 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6074 std::string ex(str, iter.base());
6075 assert(ex == "0.***********************");
6076 assert(ios.width() == 0);
6077 }
6078 ios.width(25);
6079 right(ios);
6080 {
6081 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6082 std::string ex(str, iter.base());
6083 assert(ex == "***********************0.");
6084 assert(ios.width() == 0);
6085 }
6086 ios.width(25);
6087 internal(ios);
6088 {
6089 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6090 std::string ex(str, iter.base());
6091 assert(ex == "***********************0.");
6092 assert(ios.width() == 0);
6093 }
6094 }
6095 ios.imbue(lg);
6096 {
6097 ios.width(0);
6098 {
6099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6100 std::string ex(str, iter.base());
6101 assert(ex == "0;");
6102 assert(ios.width() == 0);
6103 }
6104 ios.width(25);
6105 left(ios);
6106 {
6107 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6108 std::string ex(str, iter.base());
6109 assert(ex == "0;***********************");
6110 assert(ios.width() == 0);
6111 }
6112 ios.width(25);
6113 right(ios);
6114 {
6115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6116 std::string ex(str, iter.base());
6117 assert(ex == "***********************0;");
6118 assert(ios.width() == 0);
6119 }
6120 ios.width(25);
6121 internal(ios);
6122 {
6123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6124 std::string ex(str, iter.base());
6125 assert(ex == "***********************0;");
6126 assert(ios.width() == 0);
6127 }
6128 }
6129 }
6130 }
6131 showpos(ios);
6132 {
6133 noshowpoint(ios);
6134 {
6135 ios.imbue(lc);
6136 {
6137 ios.width(0);
6138 {
6139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6140 std::string ex(str, iter.base());
6141 assert(ex == "+0");
6142 assert(ios.width() == 0);
6143 }
6144 ios.width(25);
6145 left(ios);
6146 {
6147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6148 std::string ex(str, iter.base());
6149 assert(ex == "+0***********************");
6150 assert(ios.width() == 0);
6151 }
6152 ios.width(25);
6153 right(ios);
6154 {
6155 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6156 std::string ex(str, iter.base());
6157 assert(ex == "***********************+0");
6158 assert(ios.width() == 0);
6159 }
6160 ios.width(25);
6161 internal(ios);
6162 {
6163 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6164 std::string ex(str, iter.base());
6165 assert(ex == "+***********************0");
6166 assert(ios.width() == 0);
6167 }
6168 }
6169 ios.imbue(lg);
6170 {
6171 ios.width(0);
6172 {
6173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6174 std::string ex(str, iter.base());
6175 assert(ex == "+0");
6176 assert(ios.width() == 0);
6177 }
6178 ios.width(25);
6179 left(ios);
6180 {
6181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6182 std::string ex(str, iter.base());
6183 assert(ex == "+0***********************");
6184 assert(ios.width() == 0);
6185 }
6186 ios.width(25);
6187 right(ios);
6188 {
6189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6190 std::string ex(str, iter.base());
6191 assert(ex == "***********************+0");
6192 assert(ios.width() == 0);
6193 }
6194 ios.width(25);
6195 internal(ios);
6196 {
6197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6198 std::string ex(str, iter.base());
6199 assert(ex == "+***********************0");
6200 assert(ios.width() == 0);
6201 }
6202 }
6203 }
6204 showpoint(ios);
6205 {
6206 ios.imbue(lc);
6207 {
6208 ios.width(0);
6209 {
6210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6211 std::string ex(str, iter.base());
6212 assert(ex == "+0.");
6213 assert(ios.width() == 0);
6214 }
6215 ios.width(25);
6216 left(ios);
6217 {
6218 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6219 std::string ex(str, iter.base());
6220 assert(ex == "+0.**********************");
6221 assert(ios.width() == 0);
6222 }
6223 ios.width(25);
6224 right(ios);
6225 {
6226 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6227 std::string ex(str, iter.base());
6228 assert(ex == "**********************+0.");
6229 assert(ios.width() == 0);
6230 }
6231 ios.width(25);
6232 internal(ios);
6233 {
6234 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6235 std::string ex(str, iter.base());
6236 assert(ex == "+**********************0.");
6237 assert(ios.width() == 0);
6238 }
6239 }
6240 ios.imbue(lg);
6241 {
6242 ios.width(0);
6243 {
6244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6245 std::string ex(str, iter.base());
6246 assert(ex == "+0;");
6247 assert(ios.width() == 0);
6248 }
6249 ios.width(25);
6250 left(ios);
6251 {
6252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6253 std::string ex(str, iter.base());
6254 assert(ex == "+0;**********************");
6255 assert(ios.width() == 0);
6256 }
6257 ios.width(25);
6258 right(ios);
6259 {
6260 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6261 std::string ex(str, iter.base());
6262 assert(ex == "**********************+0;");
6263 assert(ios.width() == 0);
6264 }
6265 ios.width(25);
6266 internal(ios);
6267 {
6268 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6269 std::string ex(str, iter.base());
6270 assert(ex == "+**********************0;");
6271 assert(ios.width() == 0);
6272 }
6273 }
6274 }
6275 }
6276 }
6277 uppercase(ios);
6278 {
6279 noshowpos(ios);
6280 {
6281 noshowpoint(ios);
6282 {
6283 ios.imbue(lc);
6284 {
6285 ios.width(0);
6286 {
6287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6288 std::string ex(str, iter.base());
6289 assert(ex == "0");
6290 assert(ios.width() == 0);
6291 }
6292 ios.width(25);
6293 left(ios);
6294 {
6295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6296 std::string ex(str, iter.base());
6297 assert(ex == "0************************");
6298 assert(ios.width() == 0);
6299 }
6300 ios.width(25);
6301 right(ios);
6302 {
6303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6304 std::string ex(str, iter.base());
6305 assert(ex == "************************0");
6306 assert(ios.width() == 0);
6307 }
6308 ios.width(25);
6309 internal(ios);
6310 {
6311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6312 std::string ex(str, iter.base());
6313 assert(ex == "************************0");
6314 assert(ios.width() == 0);
6315 }
6316 }
6317 ios.imbue(lg);
6318 {
6319 ios.width(0);
6320 {
6321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6322 std::string ex(str, iter.base());
6323 assert(ex == "0");
6324 assert(ios.width() == 0);
6325 }
6326 ios.width(25);
6327 left(ios);
6328 {
6329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6330 std::string ex(str, iter.base());
6331 assert(ex == "0************************");
6332 assert(ios.width() == 0);
6333 }
6334 ios.width(25);
6335 right(ios);
6336 {
6337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6338 std::string ex(str, iter.base());
6339 assert(ex == "************************0");
6340 assert(ios.width() == 0);
6341 }
6342 ios.width(25);
6343 internal(ios);
6344 {
6345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6346 std::string ex(str, iter.base());
6347 assert(ex == "************************0");
6348 assert(ios.width() == 0);
6349 }
6350 }
6351 }
6352 showpoint(ios);
6353 {
6354 ios.imbue(lc);
6355 {
6356 ios.width(0);
6357 {
6358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6359 std::string ex(str, iter.base());
6360 assert(ex == "0.");
6361 assert(ios.width() == 0);
6362 }
6363 ios.width(25);
6364 left(ios);
6365 {
6366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6367 std::string ex(str, iter.base());
6368 assert(ex == "0.***********************");
6369 assert(ios.width() == 0);
6370 }
6371 ios.width(25);
6372 right(ios);
6373 {
6374 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6375 std::string ex(str, iter.base());
6376 assert(ex == "***********************0.");
6377 assert(ios.width() == 0);
6378 }
6379 ios.width(25);
6380 internal(ios);
6381 {
6382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6383 std::string ex(str, iter.base());
6384 assert(ex == "***********************0.");
6385 assert(ios.width() == 0);
6386 }
6387 }
6388 ios.imbue(lg);
6389 {
6390 ios.width(0);
6391 {
6392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6393 std::string ex(str, iter.base());
6394 assert(ex == "0;");
6395 assert(ios.width() == 0);
6396 }
6397 ios.width(25);
6398 left(ios);
6399 {
6400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6401 std::string ex(str, iter.base());
6402 assert(ex == "0;***********************");
6403 assert(ios.width() == 0);
6404 }
6405 ios.width(25);
6406 right(ios);
6407 {
6408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6409 std::string ex(str, iter.base());
6410 assert(ex == "***********************0;");
6411 assert(ios.width() == 0);
6412 }
6413 ios.width(25);
6414 internal(ios);
6415 {
6416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6417 std::string ex(str, iter.base());
6418 assert(ex == "***********************0;");
6419 assert(ios.width() == 0);
6420 }
6421 }
6422 }
6423 }
6424 showpos(ios);
6425 {
6426 noshowpoint(ios);
6427 {
6428 ios.imbue(lc);
6429 {
6430 ios.width(0);
6431 {
6432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6433 std::string ex(str, iter.base());
6434 assert(ex == "+0");
6435 assert(ios.width() == 0);
6436 }
6437 ios.width(25);
6438 left(ios);
6439 {
6440 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6441 std::string ex(str, iter.base());
6442 assert(ex == "+0***********************");
6443 assert(ios.width() == 0);
6444 }
6445 ios.width(25);
6446 right(ios);
6447 {
6448 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6449 std::string ex(str, iter.base());
6450 assert(ex == "***********************+0");
6451 assert(ios.width() == 0);
6452 }
6453 ios.width(25);
6454 internal(ios);
6455 {
6456 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6457 std::string ex(str, iter.base());
6458 assert(ex == "+***********************0");
6459 assert(ios.width() == 0);
6460 }
6461 }
6462 ios.imbue(lg);
6463 {
6464 ios.width(0);
6465 {
6466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6467 std::string ex(str, iter.base());
6468 assert(ex == "+0");
6469 assert(ios.width() == 0);
6470 }
6471 ios.width(25);
6472 left(ios);
6473 {
6474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6475 std::string ex(str, iter.base());
6476 assert(ex == "+0***********************");
6477 assert(ios.width() == 0);
6478 }
6479 ios.width(25);
6480 right(ios);
6481 {
6482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6483 std::string ex(str, iter.base());
6484 assert(ex == "***********************+0");
6485 assert(ios.width() == 0);
6486 }
6487 ios.width(25);
6488 internal(ios);
6489 {
6490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6491 std::string ex(str, iter.base());
6492 assert(ex == "+***********************0");
6493 assert(ios.width() == 0);
6494 }
6495 }
6496 }
6497 showpoint(ios);
6498 {
6499 ios.imbue(lc);
6500 {
6501 ios.width(0);
6502 {
6503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6504 std::string ex(str, iter.base());
6505 assert(ex == "+0.");
6506 assert(ios.width() == 0);
6507 }
6508 ios.width(25);
6509 left(ios);
6510 {
6511 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6512 std::string ex(str, iter.base());
6513 assert(ex == "+0.**********************");
6514 assert(ios.width() == 0);
6515 }
6516 ios.width(25);
6517 right(ios);
6518 {
6519 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6520 std::string ex(str, iter.base());
6521 assert(ex == "**********************+0.");
6522 assert(ios.width() == 0);
6523 }
6524 ios.width(25);
6525 internal(ios);
6526 {
6527 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6528 std::string ex(str, iter.base());
6529 assert(ex == "+**********************0.");
6530 assert(ios.width() == 0);
6531 }
6532 }
6533 ios.imbue(lg);
6534 {
6535 ios.width(0);
6536 {
6537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6538 std::string ex(str, iter.base());
6539 assert(ex == "+0;");
6540 assert(ios.width() == 0);
6541 }
6542 ios.width(25);
6543 left(ios);
6544 {
6545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6546 std::string ex(str, iter.base());
6547 assert(ex == "+0;**********************");
6548 assert(ios.width() == 0);
6549 }
6550 ios.width(25);
6551 right(ios);
6552 {
6553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6554 std::string ex(str, iter.base());
6555 assert(ex == "**********************+0;");
6556 assert(ios.width() == 0);
6557 }
6558 ios.width(25);
6559 internal(ios);
6560 {
6561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6562 std::string ex(str, iter.base());
6563 assert(ex == "+**********************0;");
6564 assert(ios.width() == 0);
6565 }
6566 }
6567 }
6568 }
6569 }
6570 }
6571 ios.precision(1);
6572 {
6573 nouppercase(ios);
6574 {
6575 noshowpos(ios);
6576 {
6577 noshowpoint(ios);
6578 {
6579 ios.imbue(lc);
6580 {
6581 ios.width(0);
6582 {
6583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6584 std::string ex(str, iter.base());
6585 assert(ex == "0.0");
6586 assert(ios.width() == 0);
6587 }
6588 ios.width(25);
6589 left(ios);
6590 {
6591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6592 std::string ex(str, iter.base());
6593 assert(ex == "0.0**********************");
6594 assert(ios.width() == 0);
6595 }
6596 ios.width(25);
6597 right(ios);
6598 {
6599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6600 std::string ex(str, iter.base());
6601 assert(ex == "**********************0.0");
6602 assert(ios.width() == 0);
6603 }
6604 ios.width(25);
6605 internal(ios);
6606 {
6607 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6608 std::string ex(str, iter.base());
6609 assert(ex == "**********************0.0");
6610 assert(ios.width() == 0);
6611 }
6612 }
6613 ios.imbue(lg);
6614 {
6615 ios.width(0);
6616 {
6617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6618 std::string ex(str, iter.base());
6619 assert(ex == "0;0");
6620 assert(ios.width() == 0);
6621 }
6622 ios.width(25);
6623 left(ios);
6624 {
6625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6626 std::string ex(str, iter.base());
6627 assert(ex == "0;0**********************");
6628 assert(ios.width() == 0);
6629 }
6630 ios.width(25);
6631 right(ios);
6632 {
6633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6634 std::string ex(str, iter.base());
6635 assert(ex == "**********************0;0");
6636 assert(ios.width() == 0);
6637 }
6638 ios.width(25);
6639 internal(ios);
6640 {
6641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6642 std::string ex(str, iter.base());
6643 assert(ex == "**********************0;0");
6644 assert(ios.width() == 0);
6645 }
6646 }
6647 }
6648 showpoint(ios);
6649 {
6650 ios.imbue(lc);
6651 {
6652 ios.width(0);
6653 {
6654 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6655 std::string ex(str, iter.base());
6656 assert(ex == "0.0");
6657 assert(ios.width() == 0);
6658 }
6659 ios.width(25);
6660 left(ios);
6661 {
6662 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6663 std::string ex(str, iter.base());
6664 assert(ex == "0.0**********************");
6665 assert(ios.width() == 0);
6666 }
6667 ios.width(25);
6668 right(ios);
6669 {
6670 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6671 std::string ex(str, iter.base());
6672 assert(ex == "**********************0.0");
6673 assert(ios.width() == 0);
6674 }
6675 ios.width(25);
6676 internal(ios);
6677 {
6678 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6679 std::string ex(str, iter.base());
6680 assert(ex == "**********************0.0");
6681 assert(ios.width() == 0);
6682 }
6683 }
6684 ios.imbue(lg);
6685 {
6686 ios.width(0);
6687 {
6688 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6689 std::string ex(str, iter.base());
6690 assert(ex == "0;0");
6691 assert(ios.width() == 0);
6692 }
6693 ios.width(25);
6694 left(ios);
6695 {
6696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6697 std::string ex(str, iter.base());
6698 assert(ex == "0;0**********************");
6699 assert(ios.width() == 0);
6700 }
6701 ios.width(25);
6702 right(ios);
6703 {
6704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6705 std::string ex(str, iter.base());
6706 assert(ex == "**********************0;0");
6707 assert(ios.width() == 0);
6708 }
6709 ios.width(25);
6710 internal(ios);
6711 {
6712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6713 std::string ex(str, iter.base());
6714 assert(ex == "**********************0;0");
6715 assert(ios.width() == 0);
6716 }
6717 }
6718 }
6719 }
6720 showpos(ios);
6721 {
6722 noshowpoint(ios);
6723 {
6724 ios.imbue(lc);
6725 {
6726 ios.width(0);
6727 {
6728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6729 std::string ex(str, iter.base());
6730 assert(ex == "+0.0");
6731 assert(ios.width() == 0);
6732 }
6733 ios.width(25);
6734 left(ios);
6735 {
6736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6737 std::string ex(str, iter.base());
6738 assert(ex == "+0.0*********************");
6739 assert(ios.width() == 0);
6740 }
6741 ios.width(25);
6742 right(ios);
6743 {
6744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6745 std::string ex(str, iter.base());
6746 assert(ex == "*********************+0.0");
6747 assert(ios.width() == 0);
6748 }
6749 ios.width(25);
6750 internal(ios);
6751 {
6752 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6753 std::string ex(str, iter.base());
6754 assert(ex == "+*********************0.0");
6755 assert(ios.width() == 0);
6756 }
6757 }
6758 ios.imbue(lg);
6759 {
6760 ios.width(0);
6761 {
6762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6763 std::string ex(str, iter.base());
6764 assert(ex == "+0;0");
6765 assert(ios.width() == 0);
6766 }
6767 ios.width(25);
6768 left(ios);
6769 {
6770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6771 std::string ex(str, iter.base());
6772 assert(ex == "+0;0*********************");
6773 assert(ios.width() == 0);
6774 }
6775 ios.width(25);
6776 right(ios);
6777 {
6778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6779 std::string ex(str, iter.base());
6780 assert(ex == "*********************+0;0");
6781 assert(ios.width() == 0);
6782 }
6783 ios.width(25);
6784 internal(ios);
6785 {
6786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6787 std::string ex(str, iter.base());
6788 assert(ex == "+*********************0;0");
6789 assert(ios.width() == 0);
6790 }
6791 }
6792 }
6793 showpoint(ios);
6794 {
6795 ios.imbue(lc);
6796 {
6797 ios.width(0);
6798 {
6799 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6800 std::string ex(str, iter.base());
6801 assert(ex == "+0.0");
6802 assert(ios.width() == 0);
6803 }
6804 ios.width(25);
6805 left(ios);
6806 {
6807 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6808 std::string ex(str, iter.base());
6809 assert(ex == "+0.0*********************");
6810 assert(ios.width() == 0);
6811 }
6812 ios.width(25);
6813 right(ios);
6814 {
6815 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6816 std::string ex(str, iter.base());
6817 assert(ex == "*********************+0.0");
6818 assert(ios.width() == 0);
6819 }
6820 ios.width(25);
6821 internal(ios);
6822 {
6823 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6824 std::string ex(str, iter.base());
6825 assert(ex == "+*********************0.0");
6826 assert(ios.width() == 0);
6827 }
6828 }
6829 ios.imbue(lg);
6830 {
6831 ios.width(0);
6832 {
6833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6834 std::string ex(str, iter.base());
6835 assert(ex == "+0;0");
6836 assert(ios.width() == 0);
6837 }
6838 ios.width(25);
6839 left(ios);
6840 {
6841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6842 std::string ex(str, iter.base());
6843 assert(ex == "+0;0*********************");
6844 assert(ios.width() == 0);
6845 }
6846 ios.width(25);
6847 right(ios);
6848 {
6849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6850 std::string ex(str, iter.base());
6851 assert(ex == "*********************+0;0");
6852 assert(ios.width() == 0);
6853 }
6854 ios.width(25);
6855 internal(ios);
6856 {
6857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6858 std::string ex(str, iter.base());
6859 assert(ex == "+*********************0;0");
6860 assert(ios.width() == 0);
6861 }
6862 }
6863 }
6864 }
6865 }
6866 uppercase(ios);
6867 {
6868 noshowpos(ios);
6869 {
6870 noshowpoint(ios);
6871 {
6872 ios.imbue(lc);
6873 {
6874 ios.width(0);
6875 {
6876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6877 std::string ex(str, iter.base());
6878 assert(ex == "0.0");
6879 assert(ios.width() == 0);
6880 }
6881 ios.width(25);
6882 left(ios);
6883 {
6884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6885 std::string ex(str, iter.base());
6886 assert(ex == "0.0**********************");
6887 assert(ios.width() == 0);
6888 }
6889 ios.width(25);
6890 right(ios);
6891 {
6892 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6893 std::string ex(str, iter.base());
6894 assert(ex == "**********************0.0");
6895 assert(ios.width() == 0);
6896 }
6897 ios.width(25);
6898 internal(ios);
6899 {
6900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6901 std::string ex(str, iter.base());
6902 assert(ex == "**********************0.0");
6903 assert(ios.width() == 0);
6904 }
6905 }
6906 ios.imbue(lg);
6907 {
6908 ios.width(0);
6909 {
6910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6911 std::string ex(str, iter.base());
6912 assert(ex == "0;0");
6913 assert(ios.width() == 0);
6914 }
6915 ios.width(25);
6916 left(ios);
6917 {
6918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6919 std::string ex(str, iter.base());
6920 assert(ex == "0;0**********************");
6921 assert(ios.width() == 0);
6922 }
6923 ios.width(25);
6924 right(ios);
6925 {
6926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6927 std::string ex(str, iter.base());
6928 assert(ex == "**********************0;0");
6929 assert(ios.width() == 0);
6930 }
6931 ios.width(25);
6932 internal(ios);
6933 {
6934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6935 std::string ex(str, iter.base());
6936 assert(ex == "**********************0;0");
6937 assert(ios.width() == 0);
6938 }
6939 }
6940 }
6941 showpoint(ios);
6942 {
6943 ios.imbue(lc);
6944 {
6945 ios.width(0);
6946 {
6947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6948 std::string ex(str, iter.base());
6949 assert(ex == "0.0");
6950 assert(ios.width() == 0);
6951 }
6952 ios.width(25);
6953 left(ios);
6954 {
6955 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6956 std::string ex(str, iter.base());
6957 assert(ex == "0.0**********************");
6958 assert(ios.width() == 0);
6959 }
6960 ios.width(25);
6961 right(ios);
6962 {
6963 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6964 std::string ex(str, iter.base());
6965 assert(ex == "**********************0.0");
6966 assert(ios.width() == 0);
6967 }
6968 ios.width(25);
6969 internal(ios);
6970 {
6971 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6972 std::string ex(str, iter.base());
6973 assert(ex == "**********************0.0");
6974 assert(ios.width() == 0);
6975 }
6976 }
6977 ios.imbue(lg);
6978 {
6979 ios.width(0);
6980 {
6981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6982 std::string ex(str, iter.base());
6983 assert(ex == "0;0");
6984 assert(ios.width() == 0);
6985 }
6986 ios.width(25);
6987 left(ios);
6988 {
6989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6990 std::string ex(str, iter.base());
6991 assert(ex == "0;0**********************");
6992 assert(ios.width() == 0);
6993 }
6994 ios.width(25);
6995 right(ios);
6996 {
6997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6998 std::string ex(str, iter.base());
6999 assert(ex == "**********************0;0");
7000 assert(ios.width() == 0);
7001 }
7002 ios.width(25);
7003 internal(ios);
7004 {
7005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7006 std::string ex(str, iter.base());
7007 assert(ex == "**********************0;0");
7008 assert(ios.width() == 0);
7009 }
7010 }
7011 }
7012 }
7013 showpos(ios);
7014 {
7015 noshowpoint(ios);
7016 {
7017 ios.imbue(lc);
7018 {
7019 ios.width(0);
7020 {
7021 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7022 std::string ex(str, iter.base());
7023 assert(ex == "+0.0");
7024 assert(ios.width() == 0);
7025 }
7026 ios.width(25);
7027 left(ios);
7028 {
7029 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7030 std::string ex(str, iter.base());
7031 assert(ex == "+0.0*********************");
7032 assert(ios.width() == 0);
7033 }
7034 ios.width(25);
7035 right(ios);
7036 {
7037 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7038 std::string ex(str, iter.base());
7039 assert(ex == "*********************+0.0");
7040 assert(ios.width() == 0);
7041 }
7042 ios.width(25);
7043 internal(ios);
7044 {
7045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7046 std::string ex(str, iter.base());
7047 assert(ex == "+*********************0.0");
7048 assert(ios.width() == 0);
7049 }
7050 }
7051 ios.imbue(lg);
7052 {
7053 ios.width(0);
7054 {
7055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7056 std::string ex(str, iter.base());
7057 assert(ex == "+0;0");
7058 assert(ios.width() == 0);
7059 }
7060 ios.width(25);
7061 left(ios);
7062 {
7063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7064 std::string ex(str, iter.base());
7065 assert(ex == "+0;0*********************");
7066 assert(ios.width() == 0);
7067 }
7068 ios.width(25);
7069 right(ios);
7070 {
7071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7072 std::string ex(str, iter.base());
7073 assert(ex == "*********************+0;0");
7074 assert(ios.width() == 0);
7075 }
7076 ios.width(25);
7077 internal(ios);
7078 {
7079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7080 std::string ex(str, iter.base());
7081 assert(ex == "+*********************0;0");
7082 assert(ios.width() == 0);
7083 }
7084 }
7085 }
7086 showpoint(ios);
7087 {
7088 ios.imbue(lc);
7089 {
7090 ios.width(0);
7091 {
7092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7093 std::string ex(str, iter.base());
7094 assert(ex == "+0.0");
7095 assert(ios.width() == 0);
7096 }
7097 ios.width(25);
7098 left(ios);
7099 {
7100 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7101 std::string ex(str, iter.base());
7102 assert(ex == "+0.0*********************");
7103 assert(ios.width() == 0);
7104 }
7105 ios.width(25);
7106 right(ios);
7107 {
7108 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7109 std::string ex(str, iter.base());
7110 assert(ex == "*********************+0.0");
7111 assert(ios.width() == 0);
7112 }
7113 ios.width(25);
7114 internal(ios);
7115 {
7116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7117 std::string ex(str, iter.base());
7118 assert(ex == "+*********************0.0");
7119 assert(ios.width() == 0);
7120 }
7121 }
7122 ios.imbue(lg);
7123 {
7124 ios.width(0);
7125 {
7126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7127 std::string ex(str, iter.base());
7128 assert(ex == "+0;0");
7129 assert(ios.width() == 0);
7130 }
7131 ios.width(25);
7132 left(ios);
7133 {
7134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7135 std::string ex(str, iter.base());
7136 assert(ex == "+0;0*********************");
7137 assert(ios.width() == 0);
7138 }
7139 ios.width(25);
7140 right(ios);
7141 {
7142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7143 std::string ex(str, iter.base());
7144 assert(ex == "*********************+0;0");
7145 assert(ios.width() == 0);
7146 }
7147 ios.width(25);
7148 internal(ios);
7149 {
7150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7151 std::string ex(str, iter.base());
7152 assert(ex == "+*********************0;0");
7153 assert(ios.width() == 0);
7154 }
7155 }
7156 }
7157 }
7158 }
7159 }
7160 ios.precision(6);
7161 {
7162 nouppercase(ios);
7163 {
7164 noshowpos(ios);
7165 {
7166 noshowpoint(ios);
7167 {
7168 ios.imbue(lc);
7169 {
7170 ios.width(0);
7171 {
7172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7173 std::string ex(str, iter.base());
7174 assert(ex == "0.000000");
7175 assert(ios.width() == 0);
7176 }
7177 ios.width(25);
7178 left(ios);
7179 {
7180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7181 std::string ex(str, iter.base());
7182 assert(ex == "0.000000*****************");
7183 assert(ios.width() == 0);
7184 }
7185 ios.width(25);
7186 right(ios);
7187 {
7188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7189 std::string ex(str, iter.base());
7190 assert(ex == "*****************0.000000");
7191 assert(ios.width() == 0);
7192 }
7193 ios.width(25);
7194 internal(ios);
7195 {
7196 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7197 std::string ex(str, iter.base());
7198 assert(ex == "*****************0.000000");
7199 assert(ios.width() == 0);
7200 }
7201 }
7202 ios.imbue(lg);
7203 {
7204 ios.width(0);
7205 {
7206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7207 std::string ex(str, iter.base());
7208 assert(ex == "0;000000");
7209 assert(ios.width() == 0);
7210 }
7211 ios.width(25);
7212 left(ios);
7213 {
7214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7215 std::string ex(str, iter.base());
7216 assert(ex == "0;000000*****************");
7217 assert(ios.width() == 0);
7218 }
7219 ios.width(25);
7220 right(ios);
7221 {
7222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7223 std::string ex(str, iter.base());
7224 assert(ex == "*****************0;000000");
7225 assert(ios.width() == 0);
7226 }
7227 ios.width(25);
7228 internal(ios);
7229 {
7230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7231 std::string ex(str, iter.base());
7232 assert(ex == "*****************0;000000");
7233 assert(ios.width() == 0);
7234 }
7235 }
7236 }
7237 showpoint(ios);
7238 {
7239 ios.imbue(lc);
7240 {
7241 ios.width(0);
7242 {
7243 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7244 std::string ex(str, iter.base());
7245 assert(ex == "0.000000");
7246 assert(ios.width() == 0);
7247 }
7248 ios.width(25);
7249 left(ios);
7250 {
7251 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7252 std::string ex(str, iter.base());
7253 assert(ex == "0.000000*****************");
7254 assert(ios.width() == 0);
7255 }
7256 ios.width(25);
7257 right(ios);
7258 {
7259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7260 std::string ex(str, iter.base());
7261 assert(ex == "*****************0.000000");
7262 assert(ios.width() == 0);
7263 }
7264 ios.width(25);
7265 internal(ios);
7266 {
7267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7268 std::string ex(str, iter.base());
7269 assert(ex == "*****************0.000000");
7270 assert(ios.width() == 0);
7271 }
7272 }
7273 ios.imbue(lg);
7274 {
7275 ios.width(0);
7276 {
7277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7278 std::string ex(str, iter.base());
7279 assert(ex == "0;000000");
7280 assert(ios.width() == 0);
7281 }
7282 ios.width(25);
7283 left(ios);
7284 {
7285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7286 std::string ex(str, iter.base());
7287 assert(ex == "0;000000*****************");
7288 assert(ios.width() == 0);
7289 }
7290 ios.width(25);
7291 right(ios);
7292 {
7293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7294 std::string ex(str, iter.base());
7295 assert(ex == "*****************0;000000");
7296 assert(ios.width() == 0);
7297 }
7298 ios.width(25);
7299 internal(ios);
7300 {
7301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7302 std::string ex(str, iter.base());
7303 assert(ex == "*****************0;000000");
7304 assert(ios.width() == 0);
7305 }
7306 }
7307 }
7308 }
7309 showpos(ios);
7310 {
7311 noshowpoint(ios);
7312 {
7313 ios.imbue(lc);
7314 {
7315 ios.width(0);
7316 {
7317 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7318 std::string ex(str, iter.base());
7319 assert(ex == "+0.000000");
7320 assert(ios.width() == 0);
7321 }
7322 ios.width(25);
7323 left(ios);
7324 {
7325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7326 std::string ex(str, iter.base());
7327 assert(ex == "+0.000000****************");
7328 assert(ios.width() == 0);
7329 }
7330 ios.width(25);
7331 right(ios);
7332 {
7333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7334 std::string ex(str, iter.base());
7335 assert(ex == "****************+0.000000");
7336 assert(ios.width() == 0);
7337 }
7338 ios.width(25);
7339 internal(ios);
7340 {
7341 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7342 std::string ex(str, iter.base());
7343 assert(ex == "+****************0.000000");
7344 assert(ios.width() == 0);
7345 }
7346 }
7347 ios.imbue(lg);
7348 {
7349 ios.width(0);
7350 {
7351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7352 std::string ex(str, iter.base());
7353 assert(ex == "+0;000000");
7354 assert(ios.width() == 0);
7355 }
7356 ios.width(25);
7357 left(ios);
7358 {
7359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7360 std::string ex(str, iter.base());
7361 assert(ex == "+0;000000****************");
7362 assert(ios.width() == 0);
7363 }
7364 ios.width(25);
7365 right(ios);
7366 {
7367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7368 std::string ex(str, iter.base());
7369 assert(ex == "****************+0;000000");
7370 assert(ios.width() == 0);
7371 }
7372 ios.width(25);
7373 internal(ios);
7374 {
7375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7376 std::string ex(str, iter.base());
7377 assert(ex == "+****************0;000000");
7378 assert(ios.width() == 0);
7379 }
7380 }
7381 }
7382 showpoint(ios);
7383 {
7384 ios.imbue(lc);
7385 {
7386 ios.width(0);
7387 {
7388 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7389 std::string ex(str, iter.base());
7390 assert(ex == "+0.000000");
7391 assert(ios.width() == 0);
7392 }
7393 ios.width(25);
7394 left(ios);
7395 {
7396 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7397 std::string ex(str, iter.base());
7398 assert(ex == "+0.000000****************");
7399 assert(ios.width() == 0);
7400 }
7401 ios.width(25);
7402 right(ios);
7403 {
7404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7405 std::string ex(str, iter.base());
7406 assert(ex == "****************+0.000000");
7407 assert(ios.width() == 0);
7408 }
7409 ios.width(25);
7410 internal(ios);
7411 {
7412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7413 std::string ex(str, iter.base());
7414 assert(ex == "+****************0.000000");
7415 assert(ios.width() == 0);
7416 }
7417 }
7418 ios.imbue(lg);
7419 {
7420 ios.width(0);
7421 {
7422 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7423 std::string ex(str, iter.base());
7424 assert(ex == "+0;000000");
7425 assert(ios.width() == 0);
7426 }
7427 ios.width(25);
7428 left(ios);
7429 {
7430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7431 std::string ex(str, iter.base());
7432 assert(ex == "+0;000000****************");
7433 assert(ios.width() == 0);
7434 }
7435 ios.width(25);
7436 right(ios);
7437 {
7438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7439 std::string ex(str, iter.base());
7440 assert(ex == "****************+0;000000");
7441 assert(ios.width() == 0);
7442 }
7443 ios.width(25);
7444 internal(ios);
7445 {
7446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7447 std::string ex(str, iter.base());
7448 assert(ex == "+****************0;000000");
7449 assert(ios.width() == 0);
7450 }
7451 }
7452 }
7453 }
7454 }
7455 uppercase(ios);
7456 {
7457 noshowpos(ios);
7458 {
7459 noshowpoint(ios);
7460 {
7461 ios.imbue(lc);
7462 {
7463 ios.width(0);
7464 {
7465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7466 std::string ex(str, iter.base());
7467 assert(ex == "0.000000");
7468 assert(ios.width() == 0);
7469 }
7470 ios.width(25);
7471 left(ios);
7472 {
7473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7474 std::string ex(str, iter.base());
7475 assert(ex == "0.000000*****************");
7476 assert(ios.width() == 0);
7477 }
7478 ios.width(25);
7479 right(ios);
7480 {
7481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7482 std::string ex(str, iter.base());
7483 assert(ex == "*****************0.000000");
7484 assert(ios.width() == 0);
7485 }
7486 ios.width(25);
7487 internal(ios);
7488 {
7489 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7490 std::string ex(str, iter.base());
7491 assert(ex == "*****************0.000000");
7492 assert(ios.width() == 0);
7493 }
7494 }
7495 ios.imbue(lg);
7496 {
7497 ios.width(0);
7498 {
7499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7500 std::string ex(str, iter.base());
7501 assert(ex == "0;000000");
7502 assert(ios.width() == 0);
7503 }
7504 ios.width(25);
7505 left(ios);
7506 {
7507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7508 std::string ex(str, iter.base());
7509 assert(ex == "0;000000*****************");
7510 assert(ios.width() == 0);
7511 }
7512 ios.width(25);
7513 right(ios);
7514 {
7515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7516 std::string ex(str, iter.base());
7517 assert(ex == "*****************0;000000");
7518 assert(ios.width() == 0);
7519 }
7520 ios.width(25);
7521 internal(ios);
7522 {
7523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7524 std::string ex(str, iter.base());
7525 assert(ex == "*****************0;000000");
7526 assert(ios.width() == 0);
7527 }
7528 }
7529 }
7530 showpoint(ios);
7531 {
7532 ios.imbue(lc);
7533 {
7534 ios.width(0);
7535 {
7536 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7537 std::string ex(str, iter.base());
7538 assert(ex == "0.000000");
7539 assert(ios.width() == 0);
7540 }
7541 ios.width(25);
7542 left(ios);
7543 {
7544 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7545 std::string ex(str, iter.base());
7546 assert(ex == "0.000000*****************");
7547 assert(ios.width() == 0);
7548 }
7549 ios.width(25);
7550 right(ios);
7551 {
7552 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7553 std::string ex(str, iter.base());
7554 assert(ex == "*****************0.000000");
7555 assert(ios.width() == 0);
7556 }
7557 ios.width(25);
7558 internal(ios);
7559 {
7560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7561 std::string ex(str, iter.base());
7562 assert(ex == "*****************0.000000");
7563 assert(ios.width() == 0);
7564 }
7565 }
7566 ios.imbue(lg);
7567 {
7568 ios.width(0);
7569 {
7570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7571 std::string ex(str, iter.base());
7572 assert(ex == "0;000000");
7573 assert(ios.width() == 0);
7574 }
7575 ios.width(25);
7576 left(ios);
7577 {
7578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7579 std::string ex(str, iter.base());
7580 assert(ex == "0;000000*****************");
7581 assert(ios.width() == 0);
7582 }
7583 ios.width(25);
7584 right(ios);
7585 {
7586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7587 std::string ex(str, iter.base());
7588 assert(ex == "*****************0;000000");
7589 assert(ios.width() == 0);
7590 }
7591 ios.width(25);
7592 internal(ios);
7593 {
7594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7595 std::string ex(str, iter.base());
7596 assert(ex == "*****************0;000000");
7597 assert(ios.width() == 0);
7598 }
7599 }
7600 }
7601 }
7602 showpos(ios);
7603 {
7604 noshowpoint(ios);
7605 {
7606 ios.imbue(lc);
7607 {
7608 ios.width(0);
7609 {
7610 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7611 std::string ex(str, iter.base());
7612 assert(ex == "+0.000000");
7613 assert(ios.width() == 0);
7614 }
7615 ios.width(25);
7616 left(ios);
7617 {
7618 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7619 std::string ex(str, iter.base());
7620 assert(ex == "+0.000000****************");
7621 assert(ios.width() == 0);
7622 }
7623 ios.width(25);
7624 right(ios);
7625 {
7626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7627 std::string ex(str, iter.base());
7628 assert(ex == "****************+0.000000");
7629 assert(ios.width() == 0);
7630 }
7631 ios.width(25);
7632 internal(ios);
7633 {
7634 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7635 std::string ex(str, iter.base());
7636 assert(ex == "+****************0.000000");
7637 assert(ios.width() == 0);
7638 }
7639 }
7640 ios.imbue(lg);
7641 {
7642 ios.width(0);
7643 {
7644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7645 std::string ex(str, iter.base());
7646 assert(ex == "+0;000000");
7647 assert(ios.width() == 0);
7648 }
7649 ios.width(25);
7650 left(ios);
7651 {
7652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7653 std::string ex(str, iter.base());
7654 assert(ex == "+0;000000****************");
7655 assert(ios.width() == 0);
7656 }
7657 ios.width(25);
7658 right(ios);
7659 {
7660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7661 std::string ex(str, iter.base());
7662 assert(ex == "****************+0;000000");
7663 assert(ios.width() == 0);
7664 }
7665 ios.width(25);
7666 internal(ios);
7667 {
7668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7669 std::string ex(str, iter.base());
7670 assert(ex == "+****************0;000000");
7671 assert(ios.width() == 0);
7672 }
7673 }
7674 }
7675 showpoint(ios);
7676 {
7677 ios.imbue(lc);
7678 {
7679 ios.width(0);
7680 {
7681 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7682 std::string ex(str, iter.base());
7683 assert(ex == "+0.000000");
7684 assert(ios.width() == 0);
7685 }
7686 ios.width(25);
7687 left(ios);
7688 {
7689 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7690 std::string ex(str, iter.base());
7691 assert(ex == "+0.000000****************");
7692 assert(ios.width() == 0);
7693 }
7694 ios.width(25);
7695 right(ios);
7696 {
7697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7698 std::string ex(str, iter.base());
7699 assert(ex == "****************+0.000000");
7700 assert(ios.width() == 0);
7701 }
7702 ios.width(25);
7703 internal(ios);
7704 {
7705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7706 std::string ex(str, iter.base());
7707 assert(ex == "+****************0.000000");
7708 assert(ios.width() == 0);
7709 }
7710 }
7711 ios.imbue(lg);
7712 {
7713 ios.width(0);
7714 {
7715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7716 std::string ex(str, iter.base());
7717 assert(ex == "+0;000000");
7718 assert(ios.width() == 0);
7719 }
7720 ios.width(25);
7721 left(ios);
7722 {
7723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7724 std::string ex(str, iter.base());
7725 assert(ex == "+0;000000****************");
7726 assert(ios.width() == 0);
7727 }
7728 ios.width(25);
7729 right(ios);
7730 {
7731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7732 std::string ex(str, iter.base());
7733 assert(ex == "****************+0;000000");
7734 assert(ios.width() == 0);
7735 }
7736 ios.width(25);
7737 internal(ios);
7738 {
7739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7740 std::string ex(str, iter.base());
7741 assert(ex == "+****************0;000000");
7742 assert(ios.width() == 0);
7743 }
7744 }
7745 }
7746 }
7747 }
7748 }
7749 ios.precision(16);
7750 {
7751 nouppercase(ios);
7752 {
7753 noshowpos(ios);
7754 {
7755 noshowpoint(ios);
7756 {
7757 ios.imbue(lc);
7758 {
7759 ios.width(0);
7760 {
7761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7762 std::string ex(str, iter.base());
7763 assert(ex == "0.0000000000000000");
7764 assert(ios.width() == 0);
7765 }
7766 ios.width(25);
7767 left(ios);
7768 {
7769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7770 std::string ex(str, iter.base());
7771 assert(ex == "0.0000000000000000*******");
7772 assert(ios.width() == 0);
7773 }
7774 ios.width(25);
7775 right(ios);
7776 {
7777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7778 std::string ex(str, iter.base());
7779 assert(ex == "*******0.0000000000000000");
7780 assert(ios.width() == 0);
7781 }
7782 ios.width(25);
7783 internal(ios);
7784 {
7785 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7786 std::string ex(str, iter.base());
7787 assert(ex == "*******0.0000000000000000");
7788 assert(ios.width() == 0);
7789 }
7790 }
7791 ios.imbue(lg);
7792 {
7793 ios.width(0);
7794 {
7795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7796 std::string ex(str, iter.base());
7797 assert(ex == "0;0000000000000000");
7798 assert(ios.width() == 0);
7799 }
7800 ios.width(25);
7801 left(ios);
7802 {
7803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7804 std::string ex(str, iter.base());
7805 assert(ex == "0;0000000000000000*******");
7806 assert(ios.width() == 0);
7807 }
7808 ios.width(25);
7809 right(ios);
7810 {
7811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7812 std::string ex(str, iter.base());
7813 assert(ex == "*******0;0000000000000000");
7814 assert(ios.width() == 0);
7815 }
7816 ios.width(25);
7817 internal(ios);
7818 {
7819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7820 std::string ex(str, iter.base());
7821 assert(ex == "*******0;0000000000000000");
7822 assert(ios.width() == 0);
7823 }
7824 }
7825 }
7826 showpoint(ios);
7827 {
7828 ios.imbue(lc);
7829 {
7830 ios.width(0);
7831 {
7832 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7833 std::string ex(str, iter.base());
7834 assert(ex == "0.0000000000000000");
7835 assert(ios.width() == 0);
7836 }
7837 ios.width(25);
7838 left(ios);
7839 {
7840 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7841 std::string ex(str, iter.base());
7842 assert(ex == "0.0000000000000000*******");
7843 assert(ios.width() == 0);
7844 }
7845 ios.width(25);
7846 right(ios);
7847 {
7848 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7849 std::string ex(str, iter.base());
7850 assert(ex == "*******0.0000000000000000");
7851 assert(ios.width() == 0);
7852 }
7853 ios.width(25);
7854 internal(ios);
7855 {
7856 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7857 std::string ex(str, iter.base());
7858 assert(ex == "*******0.0000000000000000");
7859 assert(ios.width() == 0);
7860 }
7861 }
7862 ios.imbue(lg);
7863 {
7864 ios.width(0);
7865 {
7866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7867 std::string ex(str, iter.base());
7868 assert(ex == "0;0000000000000000");
7869 assert(ios.width() == 0);
7870 }
7871 ios.width(25);
7872 left(ios);
7873 {
7874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7875 std::string ex(str, iter.base());
7876 assert(ex == "0;0000000000000000*******");
7877 assert(ios.width() == 0);
7878 }
7879 ios.width(25);
7880 right(ios);
7881 {
7882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7883 std::string ex(str, iter.base());
7884 assert(ex == "*******0;0000000000000000");
7885 assert(ios.width() == 0);
7886 }
7887 ios.width(25);
7888 internal(ios);
7889 {
7890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7891 std::string ex(str, iter.base());
7892 assert(ex == "*******0;0000000000000000");
7893 assert(ios.width() == 0);
7894 }
7895 }
7896 }
7897 }
7898 showpos(ios);
7899 {
7900 noshowpoint(ios);
7901 {
7902 ios.imbue(lc);
7903 {
7904 ios.width(0);
7905 {
7906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7907 std::string ex(str, iter.base());
7908 assert(ex == "+0.0000000000000000");
7909 assert(ios.width() == 0);
7910 }
7911 ios.width(25);
7912 left(ios);
7913 {
7914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7915 std::string ex(str, iter.base());
7916 assert(ex == "+0.0000000000000000******");
7917 assert(ios.width() == 0);
7918 }
7919 ios.width(25);
7920 right(ios);
7921 {
7922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7923 std::string ex(str, iter.base());
7924 assert(ex == "******+0.0000000000000000");
7925 assert(ios.width() == 0);
7926 }
7927 ios.width(25);
7928 internal(ios);
7929 {
7930 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7931 std::string ex(str, iter.base());
7932 assert(ex == "+******0.0000000000000000");
7933 assert(ios.width() == 0);
7934 }
7935 }
7936 ios.imbue(lg);
7937 {
7938 ios.width(0);
7939 {
7940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7941 std::string ex(str, iter.base());
7942 assert(ex == "+0;0000000000000000");
7943 assert(ios.width() == 0);
7944 }
7945 ios.width(25);
7946 left(ios);
7947 {
7948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7949 std::string ex(str, iter.base());
7950 assert(ex == "+0;0000000000000000******");
7951 assert(ios.width() == 0);
7952 }
7953 ios.width(25);
7954 right(ios);
7955 {
7956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7957 std::string ex(str, iter.base());
7958 assert(ex == "******+0;0000000000000000");
7959 assert(ios.width() == 0);
7960 }
7961 ios.width(25);
7962 internal(ios);
7963 {
7964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7965 std::string ex(str, iter.base());
7966 assert(ex == "+******0;0000000000000000");
7967 assert(ios.width() == 0);
7968 }
7969 }
7970 }
7971 showpoint(ios);
7972 {
7973 ios.imbue(lc);
7974 {
7975 ios.width(0);
7976 {
7977 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7978 std::string ex(str, iter.base());
7979 assert(ex == "+0.0000000000000000");
7980 assert(ios.width() == 0);
7981 }
7982 ios.width(25);
7983 left(ios);
7984 {
7985 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7986 std::string ex(str, iter.base());
7987 assert(ex == "+0.0000000000000000******");
7988 assert(ios.width() == 0);
7989 }
7990 ios.width(25);
7991 right(ios);
7992 {
7993 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7994 std::string ex(str, iter.base());
7995 assert(ex == "******+0.0000000000000000");
7996 assert(ios.width() == 0);
7997 }
7998 ios.width(25);
7999 internal(ios);
8000 {
8001 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8002 std::string ex(str, iter.base());
8003 assert(ex == "+******0.0000000000000000");
8004 assert(ios.width() == 0);
8005 }
8006 }
8007 ios.imbue(lg);
8008 {
8009 ios.width(0);
8010 {
8011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8012 std::string ex(str, iter.base());
8013 assert(ex == "+0;0000000000000000");
8014 assert(ios.width() == 0);
8015 }
8016 ios.width(25);
8017 left(ios);
8018 {
8019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8020 std::string ex(str, iter.base());
8021 assert(ex == "+0;0000000000000000******");
8022 assert(ios.width() == 0);
8023 }
8024 ios.width(25);
8025 right(ios);
8026 {
8027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8028 std::string ex(str, iter.base());
8029 assert(ex == "******+0;0000000000000000");
8030 assert(ios.width() == 0);
8031 }
8032 ios.width(25);
8033 internal(ios);
8034 {
8035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8036 std::string ex(str, iter.base());
8037 assert(ex == "+******0;0000000000000000");
8038 assert(ios.width() == 0);
8039 }
8040 }
8041 }
8042 }
8043 }
8044 uppercase(ios);
8045 {
8046 noshowpos(ios);
8047 {
8048 noshowpoint(ios);
8049 {
8050 ios.imbue(lc);
8051 {
8052 ios.width(0);
8053 {
8054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8055 std::string ex(str, iter.base());
8056 assert(ex == "0.0000000000000000");
8057 assert(ios.width() == 0);
8058 }
8059 ios.width(25);
8060 left(ios);
8061 {
8062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8063 std::string ex(str, iter.base());
8064 assert(ex == "0.0000000000000000*******");
8065 assert(ios.width() == 0);
8066 }
8067 ios.width(25);
8068 right(ios);
8069 {
8070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8071 std::string ex(str, iter.base());
8072 assert(ex == "*******0.0000000000000000");
8073 assert(ios.width() == 0);
8074 }
8075 ios.width(25);
8076 internal(ios);
8077 {
8078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8079 std::string ex(str, iter.base());
8080 assert(ex == "*******0.0000000000000000");
8081 assert(ios.width() == 0);
8082 }
8083 }
8084 ios.imbue(lg);
8085 {
8086 ios.width(0);
8087 {
8088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8089 std::string ex(str, iter.base());
8090 assert(ex == "0;0000000000000000");
8091 assert(ios.width() == 0);
8092 }
8093 ios.width(25);
8094 left(ios);
8095 {
8096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8097 std::string ex(str, iter.base());
8098 assert(ex == "0;0000000000000000*******");
8099 assert(ios.width() == 0);
8100 }
8101 ios.width(25);
8102 right(ios);
8103 {
8104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8105 std::string ex(str, iter.base());
8106 assert(ex == "*******0;0000000000000000");
8107 assert(ios.width() == 0);
8108 }
8109 ios.width(25);
8110 internal(ios);
8111 {
8112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8113 std::string ex(str, iter.base());
8114 assert(ex == "*******0;0000000000000000");
8115 assert(ios.width() == 0);
8116 }
8117 }
8118 }
8119 showpoint(ios);
8120 {
8121 ios.imbue(lc);
8122 {
8123 ios.width(0);
8124 {
8125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8126 std::string ex(str, iter.base());
8127 assert(ex == "0.0000000000000000");
8128 assert(ios.width() == 0);
8129 }
8130 ios.width(25);
8131 left(ios);
8132 {
8133 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8134 std::string ex(str, iter.base());
8135 assert(ex == "0.0000000000000000*******");
8136 assert(ios.width() == 0);
8137 }
8138 ios.width(25);
8139 right(ios);
8140 {
8141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8142 std::string ex(str, iter.base());
8143 assert(ex == "*******0.0000000000000000");
8144 assert(ios.width() == 0);
8145 }
8146 ios.width(25);
8147 internal(ios);
8148 {
8149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8150 std::string ex(str, iter.base());
8151 assert(ex == "*******0.0000000000000000");
8152 assert(ios.width() == 0);
8153 }
8154 }
8155 ios.imbue(lg);
8156 {
8157 ios.width(0);
8158 {
8159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8160 std::string ex(str, iter.base());
8161 assert(ex == "0;0000000000000000");
8162 assert(ios.width() == 0);
8163 }
8164 ios.width(25);
8165 left(ios);
8166 {
8167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8168 std::string ex(str, iter.base());
8169 assert(ex == "0;0000000000000000*******");
8170 assert(ios.width() == 0);
8171 }
8172 ios.width(25);
8173 right(ios);
8174 {
8175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8176 std::string ex(str, iter.base());
8177 assert(ex == "*******0;0000000000000000");
8178 assert(ios.width() == 0);
8179 }
8180 ios.width(25);
8181 internal(ios);
8182 {
8183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8184 std::string ex(str, iter.base());
8185 assert(ex == "*******0;0000000000000000");
8186 assert(ios.width() == 0);
8187 }
8188 }
8189 }
8190 }
8191 showpos(ios);
8192 {
8193 noshowpoint(ios);
8194 {
8195 ios.imbue(lc);
8196 {
8197 ios.width(0);
8198 {
8199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8200 std::string ex(str, iter.base());
8201 assert(ex == "+0.0000000000000000");
8202 assert(ios.width() == 0);
8203 }
8204 ios.width(25);
8205 left(ios);
8206 {
8207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8208 std::string ex(str, iter.base());
8209 assert(ex == "+0.0000000000000000******");
8210 assert(ios.width() == 0);
8211 }
8212 ios.width(25);
8213 right(ios);
8214 {
8215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8216 std::string ex(str, iter.base());
8217 assert(ex == "******+0.0000000000000000");
8218 assert(ios.width() == 0);
8219 }
8220 ios.width(25);
8221 internal(ios);
8222 {
8223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8224 std::string ex(str, iter.base());
8225 assert(ex == "+******0.0000000000000000");
8226 assert(ios.width() == 0);
8227 }
8228 }
8229 ios.imbue(lg);
8230 {
8231 ios.width(0);
8232 {
8233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8234 std::string ex(str, iter.base());
8235 assert(ex == "+0;0000000000000000");
8236 assert(ios.width() == 0);
8237 }
8238 ios.width(25);
8239 left(ios);
8240 {
8241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8242 std::string ex(str, iter.base());
8243 assert(ex == "+0;0000000000000000******");
8244 assert(ios.width() == 0);
8245 }
8246 ios.width(25);
8247 right(ios);
8248 {
8249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8250 std::string ex(str, iter.base());
8251 assert(ex == "******+0;0000000000000000");
8252 assert(ios.width() == 0);
8253 }
8254 ios.width(25);
8255 internal(ios);
8256 {
8257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8258 std::string ex(str, iter.base());
8259 assert(ex == "+******0;0000000000000000");
8260 assert(ios.width() == 0);
8261 }
8262 }
8263 }
8264 showpoint(ios);
8265 {
8266 ios.imbue(lc);
8267 {
8268 ios.width(0);
8269 {
8270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8271 std::string ex(str, iter.base());
8272 assert(ex == "+0.0000000000000000");
8273 assert(ios.width() == 0);
8274 }
8275 ios.width(25);
8276 left(ios);
8277 {
8278 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8279 std::string ex(str, iter.base());
8280 assert(ex == "+0.0000000000000000******");
8281 assert(ios.width() == 0);
8282 }
8283 ios.width(25);
8284 right(ios);
8285 {
8286 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8287 std::string ex(str, iter.base());
8288 assert(ex == "******+0.0000000000000000");
8289 assert(ios.width() == 0);
8290 }
8291 ios.width(25);
8292 internal(ios);
8293 {
8294 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8295 std::string ex(str, iter.base());
8296 assert(ex == "+******0.0000000000000000");
8297 assert(ios.width() == 0);
8298 }
8299 }
8300 ios.imbue(lg);
8301 {
8302 ios.width(0);
8303 {
8304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8305 std::string ex(str, iter.base());
8306 assert(ex == "+0;0000000000000000");
8307 assert(ios.width() == 0);
8308 }
8309 ios.width(25);
8310 left(ios);
8311 {
8312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8313 std::string ex(str, iter.base());
8314 assert(ex == "+0;0000000000000000******");
8315 assert(ios.width() == 0);
8316 }
8317 ios.width(25);
8318 right(ios);
8319 {
8320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8321 std::string ex(str, iter.base());
8322 assert(ex == "******+0;0000000000000000");
8323 assert(ios.width() == 0);
8324 }
8325 ios.width(25);
8326 internal(ios);
8327 {
8328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8329 std::string ex(str, iter.base());
8330 assert(ex == "+******0;0000000000000000");
8331 assert(ios.width() == 0);
8332 }
8333 }
8334 }
8335 }
8336 }
8337 }
8338 ios.precision(60);
8339 {
8340 nouppercase(ios);
8341 {
8342 noshowpos(ios);
8343 {
8344 noshowpoint(ios);
8345 {
8346 ios.imbue(lc);
8347 {
8348 ios.width(0);
8349 {
8350 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8351 std::string ex(str, iter.base());
8352 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8353 assert(ios.width() == 0);
8354 }
8355 ios.width(25);
8356 left(ios);
8357 {
8358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8359 std::string ex(str, iter.base());
8360 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8361 assert(ios.width() == 0);
8362 }
8363 ios.width(25);
8364 right(ios);
8365 {
8366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8367 std::string ex(str, iter.base());
8368 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8369 assert(ios.width() == 0);
8370 }
8371 ios.width(25);
8372 internal(ios);
8373 {
8374 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8375 std::string ex(str, iter.base());
8376 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8377 assert(ios.width() == 0);
8378 }
8379 }
8380 ios.imbue(lg);
8381 {
8382 ios.width(0);
8383 {
8384 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8385 std::string ex(str, iter.base());
8386 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8387 assert(ios.width() == 0);
8388 }
8389 ios.width(25);
8390 left(ios);
8391 {
8392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8393 std::string ex(str, iter.base());
8394 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8395 assert(ios.width() == 0);
8396 }
8397 ios.width(25);
8398 right(ios);
8399 {
8400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8401 std::string ex(str, iter.base());
8402 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8403 assert(ios.width() == 0);
8404 }
8405 ios.width(25);
8406 internal(ios);
8407 {
8408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8409 std::string ex(str, iter.base());
8410 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8411 assert(ios.width() == 0);
8412 }
8413 }
8414 }
8415 showpoint(ios);
8416 {
8417 ios.imbue(lc);
8418 {
8419 ios.width(0);
8420 {
8421 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8422 std::string ex(str, iter.base());
8423 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8424 assert(ios.width() == 0);
8425 }
8426 ios.width(25);
8427 left(ios);
8428 {
8429 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8430 std::string ex(str, iter.base());
8431 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8432 assert(ios.width() == 0);
8433 }
8434 ios.width(25);
8435 right(ios);
8436 {
8437 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8438 std::string ex(str, iter.base());
8439 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8440 assert(ios.width() == 0);
8441 }
8442 ios.width(25);
8443 internal(ios);
8444 {
8445 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8446 std::string ex(str, iter.base());
8447 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8448 assert(ios.width() == 0);
8449 }
8450 }
8451 ios.imbue(lg);
8452 {
8453 ios.width(0);
8454 {
8455 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8456 std::string ex(str, iter.base());
8457 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8458 assert(ios.width() == 0);
8459 }
8460 ios.width(25);
8461 left(ios);
8462 {
8463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8464 std::string ex(str, iter.base());
8465 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8466 assert(ios.width() == 0);
8467 }
8468 ios.width(25);
8469 right(ios);
8470 {
8471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8472 std::string ex(str, iter.base());
8473 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8474 assert(ios.width() == 0);
8475 }
8476 ios.width(25);
8477 internal(ios);
8478 {
8479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8480 std::string ex(str, iter.base());
8481 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8482 assert(ios.width() == 0);
8483 }
8484 }
8485 }
8486 }
8487 showpos(ios);
8488 {
8489 noshowpoint(ios);
8490 {
8491 ios.imbue(lc);
8492 {
8493 ios.width(0);
8494 {
8495 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8496 std::string ex(str, iter.base());
8497 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8498 assert(ios.width() == 0);
8499 }
8500 ios.width(25);
8501 left(ios);
8502 {
8503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8504 std::string ex(str, iter.base());
8505 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8506 assert(ios.width() == 0);
8507 }
8508 ios.width(25);
8509 right(ios);
8510 {
8511 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8512 std::string ex(str, iter.base());
8513 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8514 assert(ios.width() == 0);
8515 }
8516 ios.width(25);
8517 internal(ios);
8518 {
8519 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8520 std::string ex(str, iter.base());
8521 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8522 assert(ios.width() == 0);
8523 }
8524 }
8525 ios.imbue(lg);
8526 {
8527 ios.width(0);
8528 {
8529 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8530 std::string ex(str, iter.base());
8531 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8532 assert(ios.width() == 0);
8533 }
8534 ios.width(25);
8535 left(ios);
8536 {
8537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8538 std::string ex(str, iter.base());
8539 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8540 assert(ios.width() == 0);
8541 }
8542 ios.width(25);
8543 right(ios);
8544 {
8545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8546 std::string ex(str, iter.base());
8547 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8548 assert(ios.width() == 0);
8549 }
8550 ios.width(25);
8551 internal(ios);
8552 {
8553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8554 std::string ex(str, iter.base());
8555 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8556 assert(ios.width() == 0);
8557 }
8558 }
8559 }
8560 showpoint(ios);
8561 {
8562 ios.imbue(lc);
8563 {
8564 ios.width(0);
8565 {
8566 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8567 std::string ex(str, iter.base());
8568 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8569 assert(ios.width() == 0);
8570 }
8571 ios.width(25);
8572 left(ios);
8573 {
8574 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8575 std::string ex(str, iter.base());
8576 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8577 assert(ios.width() == 0);
8578 }
8579 ios.width(25);
8580 right(ios);
8581 {
8582 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8583 std::string ex(str, iter.base());
8584 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8585 assert(ios.width() == 0);
8586 }
8587 ios.width(25);
8588 internal(ios);
8589 {
8590 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8591 std::string ex(str, iter.base());
8592 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8593 assert(ios.width() == 0);
8594 }
8595 }
8596 ios.imbue(lg);
8597 {
8598 ios.width(0);
8599 {
8600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8601 std::string ex(str, iter.base());
8602 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8603 assert(ios.width() == 0);
8604 }
8605 ios.width(25);
8606 left(ios);
8607 {
8608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8609 std::string ex(str, iter.base());
8610 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8611 assert(ios.width() == 0);
8612 }
8613 ios.width(25);
8614 right(ios);
8615 {
8616 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8617 std::string ex(str, iter.base());
8618 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8619 assert(ios.width() == 0);
8620 }
8621 ios.width(25);
8622 internal(ios);
8623 {
8624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8625 std::string ex(str, iter.base());
8626 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8627 assert(ios.width() == 0);
8628 }
8629 }
8630 }
8631 }
8632 }
8633 uppercase(ios);
8634 {
8635 noshowpos(ios);
8636 {
8637 noshowpoint(ios);
8638 {
8639 ios.imbue(lc);
8640 {
8641 ios.width(0);
8642 {
8643 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8644 std::string ex(str, iter.base());
8645 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8646 assert(ios.width() == 0);
8647 }
8648 ios.width(25);
8649 left(ios);
8650 {
8651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8652 std::string ex(str, iter.base());
8653 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8654 assert(ios.width() == 0);
8655 }
8656 ios.width(25);
8657 right(ios);
8658 {
8659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8660 std::string ex(str, iter.base());
8661 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8662 assert(ios.width() == 0);
8663 }
8664 ios.width(25);
8665 internal(ios);
8666 {
8667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8668 std::string ex(str, iter.base());
8669 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8670 assert(ios.width() == 0);
8671 }
8672 }
8673 ios.imbue(lg);
8674 {
8675 ios.width(0);
8676 {
8677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8678 std::string ex(str, iter.base());
8679 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8680 assert(ios.width() == 0);
8681 }
8682 ios.width(25);
8683 left(ios);
8684 {
8685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8686 std::string ex(str, iter.base());
8687 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8688 assert(ios.width() == 0);
8689 }
8690 ios.width(25);
8691 right(ios);
8692 {
8693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8694 std::string ex(str, iter.base());
8695 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8696 assert(ios.width() == 0);
8697 }
8698 ios.width(25);
8699 internal(ios);
8700 {
8701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8702 std::string ex(str, iter.base());
8703 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8704 assert(ios.width() == 0);
8705 }
8706 }
8707 }
8708 showpoint(ios);
8709 {
8710 ios.imbue(lc);
8711 {
8712 ios.width(0);
8713 {
8714 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8715 std::string ex(str, iter.base());
8716 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8717 assert(ios.width() == 0);
8718 }
8719 ios.width(25);
8720 left(ios);
8721 {
8722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8723 std::string ex(str, iter.base());
8724 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8725 assert(ios.width() == 0);
8726 }
8727 ios.width(25);
8728 right(ios);
8729 {
8730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8731 std::string ex(str, iter.base());
8732 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8733 assert(ios.width() == 0);
8734 }
8735 ios.width(25);
8736 internal(ios);
8737 {
8738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8739 std::string ex(str, iter.base());
8740 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8741 assert(ios.width() == 0);
8742 }
8743 }
8744 ios.imbue(lg);
8745 {
8746 ios.width(0);
8747 {
8748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8749 std::string ex(str, iter.base());
8750 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8751 assert(ios.width() == 0);
8752 }
8753 ios.width(25);
8754 left(ios);
8755 {
8756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8757 std::string ex(str, iter.base());
8758 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8759 assert(ios.width() == 0);
8760 }
8761 ios.width(25);
8762 right(ios);
8763 {
8764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8765 std::string ex(str, iter.base());
8766 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8767 assert(ios.width() == 0);
8768 }
8769 ios.width(25);
8770 internal(ios);
8771 {
8772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8773 std::string ex(str, iter.base());
8774 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8775 assert(ios.width() == 0);
8776 }
8777 }
8778 }
8779 }
8780 showpos(ios);
8781 {
8782 noshowpoint(ios);
8783 {
8784 ios.imbue(lc);
8785 {
8786 ios.width(0);
8787 {
8788 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8789 std::string ex(str, iter.base());
8790 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8791 assert(ios.width() == 0);
8792 }
8793 ios.width(25);
8794 left(ios);
8795 {
8796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8797 std::string ex(str, iter.base());
8798 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8799 assert(ios.width() == 0);
8800 }
8801 ios.width(25);
8802 right(ios);
8803 {
8804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8805 std::string ex(str, iter.base());
8806 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8807 assert(ios.width() == 0);
8808 }
8809 ios.width(25);
8810 internal(ios);
8811 {
8812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8813 std::string ex(str, iter.base());
8814 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8815 assert(ios.width() == 0);
8816 }
8817 }
8818 ios.imbue(lg);
8819 {
8820 ios.width(0);
8821 {
8822 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8823 std::string ex(str, iter.base());
8824 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8825 assert(ios.width() == 0);
8826 }
8827 ios.width(25);
8828 left(ios);
8829 {
8830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8831 std::string ex(str, iter.base());
8832 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8833 assert(ios.width() == 0);
8834 }
8835 ios.width(25);
8836 right(ios);
8837 {
8838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8839 std::string ex(str, iter.base());
8840 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8841 assert(ios.width() == 0);
8842 }
8843 ios.width(25);
8844 internal(ios);
8845 {
8846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8847 std::string ex(str, iter.base());
8848 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8849 assert(ios.width() == 0);
8850 }
8851 }
8852 }
8853 showpoint(ios);
8854 {
8855 ios.imbue(lc);
8856 {
8857 ios.width(0);
8858 {
8859 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8860 std::string ex(str, iter.base());
8861 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8862 assert(ios.width() == 0);
8863 }
8864 ios.width(25);
8865 left(ios);
8866 {
8867 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8868 std::string ex(str, iter.base());
8869 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8870 assert(ios.width() == 0);
8871 }
8872 ios.width(25);
8873 right(ios);
8874 {
8875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8876 std::string ex(str, iter.base());
8877 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8878 assert(ios.width() == 0);
8879 }
8880 ios.width(25);
8881 internal(ios);
8882 {
8883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8884 std::string ex(str, iter.base());
8885 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8886 assert(ios.width() == 0);
8887 }
8888 }
8889 ios.imbue(lg);
8890 {
8891 ios.width(0);
8892 {
8893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8894 std::string ex(str, iter.base());
8895 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8896 assert(ios.width() == 0);
8897 }
8898 ios.width(25);
8899 left(ios);
8900 {
8901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8902 std::string ex(str, iter.base());
8903 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8904 assert(ios.width() == 0);
8905 }
8906 ios.width(25);
8907 right(ios);
8908 {
8909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8910 std::string ex(str, iter.base());
8911 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8912 assert(ios.width() == 0);
8913 }
8914 ios.width(25);
8915 internal(ios);
8916 {
8917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8918 std::string ex(str, iter.base());
8919 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8920 assert(ios.width() == 0);
8921 }
8922 }
8923 }
8924 }
8925 }
8926 }
8927 }
8928 }
8929 }
8930
test4()8931 void test4()
8932 {
8933 char str[200];
8934 output_iterator<char*> iter;
8935 std::locale lc = std::locale::classic();
8936 std::locale lg(lc, new my_numpunct);
8937 const my_facet f(1);
8938 {
8939 double v = 1234567890.125;
8940 std::ios ios(0);
8941 fixed(ios);
8942 // %f
8943 {
8944 ios.precision(0);
8945 {
8946 nouppercase(ios);
8947 {
8948 noshowpos(ios);
8949 {
8950 noshowpoint(ios);
8951 {
8952 ios.imbue(lc);
8953 {
8954 ios.width(0);
8955 {
8956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8957 std::string ex(str, iter.base());
8958 assert(ex == "1234567890");
8959 assert(ios.width() == 0);
8960 }
8961 ios.width(25);
8962 left(ios);
8963 {
8964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8965 std::string ex(str, iter.base());
8966 assert(ex == "1234567890***************");
8967 assert(ios.width() == 0);
8968 }
8969 ios.width(25);
8970 right(ios);
8971 {
8972 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8973 std::string ex(str, iter.base());
8974 assert(ex == "***************1234567890");
8975 assert(ios.width() == 0);
8976 }
8977 ios.width(25);
8978 internal(ios);
8979 {
8980 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8981 std::string ex(str, iter.base());
8982 assert(ex == "***************1234567890");
8983 assert(ios.width() == 0);
8984 }
8985 }
8986 ios.imbue(lg);
8987 {
8988 ios.width(0);
8989 {
8990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8991 std::string ex(str, iter.base());
8992 assert(ex == "1_234_567_89_0");
8993 assert(ios.width() == 0);
8994 }
8995 ios.width(25);
8996 left(ios);
8997 {
8998 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8999 std::string ex(str, iter.base());
9000 assert(ex == "1_234_567_89_0***********");
9001 assert(ios.width() == 0);
9002 }
9003 ios.width(25);
9004 right(ios);
9005 {
9006 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9007 std::string ex(str, iter.base());
9008 assert(ex == "***********1_234_567_89_0");
9009 assert(ios.width() == 0);
9010 }
9011 ios.width(25);
9012 internal(ios);
9013 {
9014 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9015 std::string ex(str, iter.base());
9016 assert(ex == "***********1_234_567_89_0");
9017 assert(ios.width() == 0);
9018 }
9019 }
9020 }
9021 showpoint(ios);
9022 {
9023 ios.imbue(lc);
9024 {
9025 ios.width(0);
9026 {
9027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9028 std::string ex(str, iter.base());
9029 assert(ex == "1234567890.");
9030 assert(ios.width() == 0);
9031 }
9032 ios.width(25);
9033 left(ios);
9034 {
9035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9036 std::string ex(str, iter.base());
9037 assert(ex == "1234567890.**************");
9038 assert(ios.width() == 0);
9039 }
9040 ios.width(25);
9041 right(ios);
9042 {
9043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9044 std::string ex(str, iter.base());
9045 assert(ex == "**************1234567890.");
9046 assert(ios.width() == 0);
9047 }
9048 ios.width(25);
9049 internal(ios);
9050 {
9051 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9052 std::string ex(str, iter.base());
9053 assert(ex == "**************1234567890.");
9054 assert(ios.width() == 0);
9055 }
9056 }
9057 ios.imbue(lg);
9058 {
9059 ios.width(0);
9060 {
9061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9062 std::string ex(str, iter.base());
9063 assert(ex == "1_234_567_89_0;");
9064 assert(ios.width() == 0);
9065 }
9066 ios.width(25);
9067 left(ios);
9068 {
9069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9070 std::string ex(str, iter.base());
9071 assert(ex == "1_234_567_89_0;**********");
9072 assert(ios.width() == 0);
9073 }
9074 ios.width(25);
9075 right(ios);
9076 {
9077 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9078 std::string ex(str, iter.base());
9079 assert(ex == "**********1_234_567_89_0;");
9080 assert(ios.width() == 0);
9081 }
9082 ios.width(25);
9083 internal(ios);
9084 {
9085 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9086 std::string ex(str, iter.base());
9087 assert(ex == "**********1_234_567_89_0;");
9088 assert(ios.width() == 0);
9089 }
9090 }
9091 }
9092 }
9093 showpos(ios);
9094 {
9095 noshowpoint(ios);
9096 {
9097 ios.imbue(lc);
9098 {
9099 ios.width(0);
9100 {
9101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9102 std::string ex(str, iter.base());
9103 assert(ex == "+1234567890");
9104 assert(ios.width() == 0);
9105 }
9106 ios.width(25);
9107 left(ios);
9108 {
9109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9110 std::string ex(str, iter.base());
9111 assert(ex == "+1234567890**************");
9112 assert(ios.width() == 0);
9113 }
9114 ios.width(25);
9115 right(ios);
9116 {
9117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9118 std::string ex(str, iter.base());
9119 assert(ex == "**************+1234567890");
9120 assert(ios.width() == 0);
9121 }
9122 ios.width(25);
9123 internal(ios);
9124 {
9125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9126 std::string ex(str, iter.base());
9127 assert(ex == "+**************1234567890");
9128 assert(ios.width() == 0);
9129 }
9130 }
9131 ios.imbue(lg);
9132 {
9133 ios.width(0);
9134 {
9135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9136 std::string ex(str, iter.base());
9137 assert(ex == "+1_234_567_89_0");
9138 assert(ios.width() == 0);
9139 }
9140 ios.width(25);
9141 left(ios);
9142 {
9143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9144 std::string ex(str, iter.base());
9145 assert(ex == "+1_234_567_89_0**********");
9146 assert(ios.width() == 0);
9147 }
9148 ios.width(25);
9149 right(ios);
9150 {
9151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9152 std::string ex(str, iter.base());
9153 assert(ex == "**********+1_234_567_89_0");
9154 assert(ios.width() == 0);
9155 }
9156 ios.width(25);
9157 internal(ios);
9158 {
9159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9160 std::string ex(str, iter.base());
9161 assert(ex == "+**********1_234_567_89_0");
9162 assert(ios.width() == 0);
9163 }
9164 }
9165 }
9166 showpoint(ios);
9167 {
9168 ios.imbue(lc);
9169 {
9170 ios.width(0);
9171 {
9172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9173 std::string ex(str, iter.base());
9174 assert(ex == "+1234567890.");
9175 assert(ios.width() == 0);
9176 }
9177 ios.width(25);
9178 left(ios);
9179 {
9180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9181 std::string ex(str, iter.base());
9182 assert(ex == "+1234567890.*************");
9183 assert(ios.width() == 0);
9184 }
9185 ios.width(25);
9186 right(ios);
9187 {
9188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9189 std::string ex(str, iter.base());
9190 assert(ex == "*************+1234567890.");
9191 assert(ios.width() == 0);
9192 }
9193 ios.width(25);
9194 internal(ios);
9195 {
9196 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9197 std::string ex(str, iter.base());
9198 assert(ex == "+*************1234567890.");
9199 assert(ios.width() == 0);
9200 }
9201 }
9202 ios.imbue(lg);
9203 {
9204 ios.width(0);
9205 {
9206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9207 std::string ex(str, iter.base());
9208 assert(ex == "+1_234_567_89_0;");
9209 assert(ios.width() == 0);
9210 }
9211 ios.width(25);
9212 left(ios);
9213 {
9214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9215 std::string ex(str, iter.base());
9216 assert(ex == "+1_234_567_89_0;*********");
9217 assert(ios.width() == 0);
9218 }
9219 ios.width(25);
9220 right(ios);
9221 {
9222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9223 std::string ex(str, iter.base());
9224 assert(ex == "*********+1_234_567_89_0;");
9225 assert(ios.width() == 0);
9226 }
9227 ios.width(25);
9228 internal(ios);
9229 {
9230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9231 std::string ex(str, iter.base());
9232 assert(ex == "+*********1_234_567_89_0;");
9233 assert(ios.width() == 0);
9234 }
9235 }
9236 }
9237 }
9238 }
9239 uppercase(ios);
9240 {
9241 noshowpos(ios);
9242 {
9243 noshowpoint(ios);
9244 {
9245 ios.imbue(lc);
9246 {
9247 ios.width(0);
9248 {
9249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9250 std::string ex(str, iter.base());
9251 assert(ex == "1234567890");
9252 assert(ios.width() == 0);
9253 }
9254 ios.width(25);
9255 left(ios);
9256 {
9257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9258 std::string ex(str, iter.base());
9259 assert(ex == "1234567890***************");
9260 assert(ios.width() == 0);
9261 }
9262 ios.width(25);
9263 right(ios);
9264 {
9265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9266 std::string ex(str, iter.base());
9267 assert(ex == "***************1234567890");
9268 assert(ios.width() == 0);
9269 }
9270 ios.width(25);
9271 internal(ios);
9272 {
9273 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9274 std::string ex(str, iter.base());
9275 assert(ex == "***************1234567890");
9276 assert(ios.width() == 0);
9277 }
9278 }
9279 ios.imbue(lg);
9280 {
9281 ios.width(0);
9282 {
9283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9284 std::string ex(str, iter.base());
9285 assert(ex == "1_234_567_89_0");
9286 assert(ios.width() == 0);
9287 }
9288 ios.width(25);
9289 left(ios);
9290 {
9291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9292 std::string ex(str, iter.base());
9293 assert(ex == "1_234_567_89_0***********");
9294 assert(ios.width() == 0);
9295 }
9296 ios.width(25);
9297 right(ios);
9298 {
9299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9300 std::string ex(str, iter.base());
9301 assert(ex == "***********1_234_567_89_0");
9302 assert(ios.width() == 0);
9303 }
9304 ios.width(25);
9305 internal(ios);
9306 {
9307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9308 std::string ex(str, iter.base());
9309 assert(ex == "***********1_234_567_89_0");
9310 assert(ios.width() == 0);
9311 }
9312 }
9313 }
9314 showpoint(ios);
9315 {
9316 ios.imbue(lc);
9317 {
9318 ios.width(0);
9319 {
9320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9321 std::string ex(str, iter.base());
9322 assert(ex == "1234567890.");
9323 assert(ios.width() == 0);
9324 }
9325 ios.width(25);
9326 left(ios);
9327 {
9328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9329 std::string ex(str, iter.base());
9330 assert(ex == "1234567890.**************");
9331 assert(ios.width() == 0);
9332 }
9333 ios.width(25);
9334 right(ios);
9335 {
9336 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9337 std::string ex(str, iter.base());
9338 assert(ex == "**************1234567890.");
9339 assert(ios.width() == 0);
9340 }
9341 ios.width(25);
9342 internal(ios);
9343 {
9344 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9345 std::string ex(str, iter.base());
9346 assert(ex == "**************1234567890.");
9347 assert(ios.width() == 0);
9348 }
9349 }
9350 ios.imbue(lg);
9351 {
9352 ios.width(0);
9353 {
9354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9355 std::string ex(str, iter.base());
9356 assert(ex == "1_234_567_89_0;");
9357 assert(ios.width() == 0);
9358 }
9359 ios.width(25);
9360 left(ios);
9361 {
9362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9363 std::string ex(str, iter.base());
9364 assert(ex == "1_234_567_89_0;**********");
9365 assert(ios.width() == 0);
9366 }
9367 ios.width(25);
9368 right(ios);
9369 {
9370 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9371 std::string ex(str, iter.base());
9372 assert(ex == "**********1_234_567_89_0;");
9373 assert(ios.width() == 0);
9374 }
9375 ios.width(25);
9376 internal(ios);
9377 {
9378 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9379 std::string ex(str, iter.base());
9380 assert(ex == "**********1_234_567_89_0;");
9381 assert(ios.width() == 0);
9382 }
9383 }
9384 }
9385 }
9386 showpos(ios);
9387 {
9388 noshowpoint(ios);
9389 {
9390 ios.imbue(lc);
9391 {
9392 ios.width(0);
9393 {
9394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9395 std::string ex(str, iter.base());
9396 assert(ex == "+1234567890");
9397 assert(ios.width() == 0);
9398 }
9399 ios.width(25);
9400 left(ios);
9401 {
9402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9403 std::string ex(str, iter.base());
9404 assert(ex == "+1234567890**************");
9405 assert(ios.width() == 0);
9406 }
9407 ios.width(25);
9408 right(ios);
9409 {
9410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9411 std::string ex(str, iter.base());
9412 assert(ex == "**************+1234567890");
9413 assert(ios.width() == 0);
9414 }
9415 ios.width(25);
9416 internal(ios);
9417 {
9418 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9419 std::string ex(str, iter.base());
9420 assert(ex == "+**************1234567890");
9421 assert(ios.width() == 0);
9422 }
9423 }
9424 ios.imbue(lg);
9425 {
9426 ios.width(0);
9427 {
9428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9429 std::string ex(str, iter.base());
9430 assert(ex == "+1_234_567_89_0");
9431 assert(ios.width() == 0);
9432 }
9433 ios.width(25);
9434 left(ios);
9435 {
9436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9437 std::string ex(str, iter.base());
9438 assert(ex == "+1_234_567_89_0**********");
9439 assert(ios.width() == 0);
9440 }
9441 ios.width(25);
9442 right(ios);
9443 {
9444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9445 std::string ex(str, iter.base());
9446 assert(ex == "**********+1_234_567_89_0");
9447 assert(ios.width() == 0);
9448 }
9449 ios.width(25);
9450 internal(ios);
9451 {
9452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9453 std::string ex(str, iter.base());
9454 assert(ex == "+**********1_234_567_89_0");
9455 assert(ios.width() == 0);
9456 }
9457 }
9458 }
9459 showpoint(ios);
9460 {
9461 ios.imbue(lc);
9462 {
9463 ios.width(0);
9464 {
9465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9466 std::string ex(str, iter.base());
9467 assert(ex == "+1234567890.");
9468 assert(ios.width() == 0);
9469 }
9470 ios.width(25);
9471 left(ios);
9472 {
9473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9474 std::string ex(str, iter.base());
9475 assert(ex == "+1234567890.*************");
9476 assert(ios.width() == 0);
9477 }
9478 ios.width(25);
9479 right(ios);
9480 {
9481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9482 std::string ex(str, iter.base());
9483 assert(ex == "*************+1234567890.");
9484 assert(ios.width() == 0);
9485 }
9486 ios.width(25);
9487 internal(ios);
9488 {
9489 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9490 std::string ex(str, iter.base());
9491 assert(ex == "+*************1234567890.");
9492 assert(ios.width() == 0);
9493 }
9494 }
9495 ios.imbue(lg);
9496 {
9497 ios.width(0);
9498 {
9499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9500 std::string ex(str, iter.base());
9501 assert(ex == "+1_234_567_89_0;");
9502 assert(ios.width() == 0);
9503 }
9504 ios.width(25);
9505 left(ios);
9506 {
9507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9508 std::string ex(str, iter.base());
9509 assert(ex == "+1_234_567_89_0;*********");
9510 assert(ios.width() == 0);
9511 }
9512 ios.width(25);
9513 right(ios);
9514 {
9515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9516 std::string ex(str, iter.base());
9517 assert(ex == "*********+1_234_567_89_0;");
9518 assert(ios.width() == 0);
9519 }
9520 ios.width(25);
9521 internal(ios);
9522 {
9523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9524 std::string ex(str, iter.base());
9525 assert(ex == "+*********1_234_567_89_0;");
9526 assert(ios.width() == 0);
9527 }
9528 }
9529 }
9530 }
9531 }
9532 }
9533 ios.precision(1);
9534 {
9535 nouppercase(ios);
9536 {
9537 noshowpos(ios);
9538 {
9539 noshowpoint(ios);
9540 {
9541 ios.imbue(lc);
9542 {
9543 ios.width(0);
9544 {
9545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9546 std::string ex(str, iter.base());
9547 assert(ex == "1234567890.1");
9548 assert(ios.width() == 0);
9549 }
9550 ios.width(25);
9551 left(ios);
9552 {
9553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9554 std::string ex(str, iter.base());
9555 assert(ex == "1234567890.1*************");
9556 assert(ios.width() == 0);
9557 }
9558 ios.width(25);
9559 right(ios);
9560 {
9561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9562 std::string ex(str, iter.base());
9563 assert(ex == "*************1234567890.1");
9564 assert(ios.width() == 0);
9565 }
9566 ios.width(25);
9567 internal(ios);
9568 {
9569 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9570 std::string ex(str, iter.base());
9571 assert(ex == "*************1234567890.1");
9572 assert(ios.width() == 0);
9573 }
9574 }
9575 ios.imbue(lg);
9576 {
9577 ios.width(0);
9578 {
9579 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9580 std::string ex(str, iter.base());
9581 assert(ex == "1_234_567_89_0;1");
9582 assert(ios.width() == 0);
9583 }
9584 ios.width(25);
9585 left(ios);
9586 {
9587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9588 std::string ex(str, iter.base());
9589 assert(ex == "1_234_567_89_0;1*********");
9590 assert(ios.width() == 0);
9591 }
9592 ios.width(25);
9593 right(ios);
9594 {
9595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9596 std::string ex(str, iter.base());
9597 assert(ex == "*********1_234_567_89_0;1");
9598 assert(ios.width() == 0);
9599 }
9600 ios.width(25);
9601 internal(ios);
9602 {
9603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9604 std::string ex(str, iter.base());
9605 assert(ex == "*********1_234_567_89_0;1");
9606 assert(ios.width() == 0);
9607 }
9608 }
9609 }
9610 showpoint(ios);
9611 {
9612 ios.imbue(lc);
9613 {
9614 ios.width(0);
9615 {
9616 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9617 std::string ex(str, iter.base());
9618 assert(ex == "1234567890.1");
9619 assert(ios.width() == 0);
9620 }
9621 ios.width(25);
9622 left(ios);
9623 {
9624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9625 std::string ex(str, iter.base());
9626 assert(ex == "1234567890.1*************");
9627 assert(ios.width() == 0);
9628 }
9629 ios.width(25);
9630 right(ios);
9631 {
9632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9633 std::string ex(str, iter.base());
9634 assert(ex == "*************1234567890.1");
9635 assert(ios.width() == 0);
9636 }
9637 ios.width(25);
9638 internal(ios);
9639 {
9640 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9641 std::string ex(str, iter.base());
9642 assert(ex == "*************1234567890.1");
9643 assert(ios.width() == 0);
9644 }
9645 }
9646 ios.imbue(lg);
9647 {
9648 ios.width(0);
9649 {
9650 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9651 std::string ex(str, iter.base());
9652 assert(ex == "1_234_567_89_0;1");
9653 assert(ios.width() == 0);
9654 }
9655 ios.width(25);
9656 left(ios);
9657 {
9658 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9659 std::string ex(str, iter.base());
9660 assert(ex == "1_234_567_89_0;1*********");
9661 assert(ios.width() == 0);
9662 }
9663 ios.width(25);
9664 right(ios);
9665 {
9666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9667 std::string ex(str, iter.base());
9668 assert(ex == "*********1_234_567_89_0;1");
9669 assert(ios.width() == 0);
9670 }
9671 ios.width(25);
9672 internal(ios);
9673 {
9674 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9675 std::string ex(str, iter.base());
9676 assert(ex == "*********1_234_567_89_0;1");
9677 assert(ios.width() == 0);
9678 }
9679 }
9680 }
9681 }
9682 showpos(ios);
9683 {
9684 noshowpoint(ios);
9685 {
9686 ios.imbue(lc);
9687 {
9688 ios.width(0);
9689 {
9690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9691 std::string ex(str, iter.base());
9692 assert(ex == "+1234567890.1");
9693 assert(ios.width() == 0);
9694 }
9695 ios.width(25);
9696 left(ios);
9697 {
9698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9699 std::string ex(str, iter.base());
9700 assert(ex == "+1234567890.1************");
9701 assert(ios.width() == 0);
9702 }
9703 ios.width(25);
9704 right(ios);
9705 {
9706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9707 std::string ex(str, iter.base());
9708 assert(ex == "************+1234567890.1");
9709 assert(ios.width() == 0);
9710 }
9711 ios.width(25);
9712 internal(ios);
9713 {
9714 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9715 std::string ex(str, iter.base());
9716 assert(ex == "+************1234567890.1");
9717 assert(ios.width() == 0);
9718 }
9719 }
9720 ios.imbue(lg);
9721 {
9722 ios.width(0);
9723 {
9724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9725 std::string ex(str, iter.base());
9726 assert(ex == "+1_234_567_89_0;1");
9727 assert(ios.width() == 0);
9728 }
9729 ios.width(25);
9730 left(ios);
9731 {
9732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9733 std::string ex(str, iter.base());
9734 assert(ex == "+1_234_567_89_0;1********");
9735 assert(ios.width() == 0);
9736 }
9737 ios.width(25);
9738 right(ios);
9739 {
9740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9741 std::string ex(str, iter.base());
9742 assert(ex == "********+1_234_567_89_0;1");
9743 assert(ios.width() == 0);
9744 }
9745 ios.width(25);
9746 internal(ios);
9747 {
9748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9749 std::string ex(str, iter.base());
9750 assert(ex == "+********1_234_567_89_0;1");
9751 assert(ios.width() == 0);
9752 }
9753 }
9754 }
9755 showpoint(ios);
9756 {
9757 ios.imbue(lc);
9758 {
9759 ios.width(0);
9760 {
9761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9762 std::string ex(str, iter.base());
9763 assert(ex == "+1234567890.1");
9764 assert(ios.width() == 0);
9765 }
9766 ios.width(25);
9767 left(ios);
9768 {
9769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9770 std::string ex(str, iter.base());
9771 assert(ex == "+1234567890.1************");
9772 assert(ios.width() == 0);
9773 }
9774 ios.width(25);
9775 right(ios);
9776 {
9777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9778 std::string ex(str, iter.base());
9779 assert(ex == "************+1234567890.1");
9780 assert(ios.width() == 0);
9781 }
9782 ios.width(25);
9783 internal(ios);
9784 {
9785 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9786 std::string ex(str, iter.base());
9787 assert(ex == "+************1234567890.1");
9788 assert(ios.width() == 0);
9789 }
9790 }
9791 ios.imbue(lg);
9792 {
9793 ios.width(0);
9794 {
9795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9796 std::string ex(str, iter.base());
9797 assert(ex == "+1_234_567_89_0;1");
9798 assert(ios.width() == 0);
9799 }
9800 ios.width(25);
9801 left(ios);
9802 {
9803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9804 std::string ex(str, iter.base());
9805 assert(ex == "+1_234_567_89_0;1********");
9806 assert(ios.width() == 0);
9807 }
9808 ios.width(25);
9809 right(ios);
9810 {
9811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9812 std::string ex(str, iter.base());
9813 assert(ex == "********+1_234_567_89_0;1");
9814 assert(ios.width() == 0);
9815 }
9816 ios.width(25);
9817 internal(ios);
9818 {
9819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9820 std::string ex(str, iter.base());
9821 assert(ex == "+********1_234_567_89_0;1");
9822 assert(ios.width() == 0);
9823 }
9824 }
9825 }
9826 }
9827 }
9828 uppercase(ios);
9829 {
9830 noshowpos(ios);
9831 {
9832 noshowpoint(ios);
9833 {
9834 ios.imbue(lc);
9835 {
9836 ios.width(0);
9837 {
9838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9839 std::string ex(str, iter.base());
9840 assert(ex == "1234567890.1");
9841 assert(ios.width() == 0);
9842 }
9843 ios.width(25);
9844 left(ios);
9845 {
9846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9847 std::string ex(str, iter.base());
9848 assert(ex == "1234567890.1*************");
9849 assert(ios.width() == 0);
9850 }
9851 ios.width(25);
9852 right(ios);
9853 {
9854 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9855 std::string ex(str, iter.base());
9856 assert(ex == "*************1234567890.1");
9857 assert(ios.width() == 0);
9858 }
9859 ios.width(25);
9860 internal(ios);
9861 {
9862 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9863 std::string ex(str, iter.base());
9864 assert(ex == "*************1234567890.1");
9865 assert(ios.width() == 0);
9866 }
9867 }
9868 ios.imbue(lg);
9869 {
9870 ios.width(0);
9871 {
9872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9873 std::string ex(str, iter.base());
9874 assert(ex == "1_234_567_89_0;1");
9875 assert(ios.width() == 0);
9876 }
9877 ios.width(25);
9878 left(ios);
9879 {
9880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9881 std::string ex(str, iter.base());
9882 assert(ex == "1_234_567_89_0;1*********");
9883 assert(ios.width() == 0);
9884 }
9885 ios.width(25);
9886 right(ios);
9887 {
9888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9889 std::string ex(str, iter.base());
9890 assert(ex == "*********1_234_567_89_0;1");
9891 assert(ios.width() == 0);
9892 }
9893 ios.width(25);
9894 internal(ios);
9895 {
9896 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9897 std::string ex(str, iter.base());
9898 assert(ex == "*********1_234_567_89_0;1");
9899 assert(ios.width() == 0);
9900 }
9901 }
9902 }
9903 showpoint(ios);
9904 {
9905 ios.imbue(lc);
9906 {
9907 ios.width(0);
9908 {
9909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9910 std::string ex(str, iter.base());
9911 assert(ex == "1234567890.1");
9912 assert(ios.width() == 0);
9913 }
9914 ios.width(25);
9915 left(ios);
9916 {
9917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9918 std::string ex(str, iter.base());
9919 assert(ex == "1234567890.1*************");
9920 assert(ios.width() == 0);
9921 }
9922 ios.width(25);
9923 right(ios);
9924 {
9925 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9926 std::string ex(str, iter.base());
9927 assert(ex == "*************1234567890.1");
9928 assert(ios.width() == 0);
9929 }
9930 ios.width(25);
9931 internal(ios);
9932 {
9933 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9934 std::string ex(str, iter.base());
9935 assert(ex == "*************1234567890.1");
9936 assert(ios.width() == 0);
9937 }
9938 }
9939 ios.imbue(lg);
9940 {
9941 ios.width(0);
9942 {
9943 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9944 std::string ex(str, iter.base());
9945 assert(ex == "1_234_567_89_0;1");
9946 assert(ios.width() == 0);
9947 }
9948 ios.width(25);
9949 left(ios);
9950 {
9951 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9952 std::string ex(str, iter.base());
9953 assert(ex == "1_234_567_89_0;1*********");
9954 assert(ios.width() == 0);
9955 }
9956 ios.width(25);
9957 right(ios);
9958 {
9959 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9960 std::string ex(str, iter.base());
9961 assert(ex == "*********1_234_567_89_0;1");
9962 assert(ios.width() == 0);
9963 }
9964 ios.width(25);
9965 internal(ios);
9966 {
9967 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9968 std::string ex(str, iter.base());
9969 assert(ex == "*********1_234_567_89_0;1");
9970 assert(ios.width() == 0);
9971 }
9972 }
9973 }
9974 }
9975 showpos(ios);
9976 {
9977 noshowpoint(ios);
9978 {
9979 ios.imbue(lc);
9980 {
9981 ios.width(0);
9982 {
9983 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9984 std::string ex(str, iter.base());
9985 assert(ex == "+1234567890.1");
9986 assert(ios.width() == 0);
9987 }
9988 ios.width(25);
9989 left(ios);
9990 {
9991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9992 std::string ex(str, iter.base());
9993 assert(ex == "+1234567890.1************");
9994 assert(ios.width() == 0);
9995 }
9996 ios.width(25);
9997 right(ios);
9998 {
9999 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10000 std::string ex(str, iter.base());
10001 assert(ex == "************+1234567890.1");
10002 assert(ios.width() == 0);
10003 }
10004 ios.width(25);
10005 internal(ios);
10006 {
10007 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10008 std::string ex(str, iter.base());
10009 assert(ex == "+************1234567890.1");
10010 assert(ios.width() == 0);
10011 }
10012 }
10013 ios.imbue(lg);
10014 {
10015 ios.width(0);
10016 {
10017 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10018 std::string ex(str, iter.base());
10019 assert(ex == "+1_234_567_89_0;1");
10020 assert(ios.width() == 0);
10021 }
10022 ios.width(25);
10023 left(ios);
10024 {
10025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10026 std::string ex(str, iter.base());
10027 assert(ex == "+1_234_567_89_0;1********");
10028 assert(ios.width() == 0);
10029 }
10030 ios.width(25);
10031 right(ios);
10032 {
10033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10034 std::string ex(str, iter.base());
10035 assert(ex == "********+1_234_567_89_0;1");
10036 assert(ios.width() == 0);
10037 }
10038 ios.width(25);
10039 internal(ios);
10040 {
10041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10042 std::string ex(str, iter.base());
10043 assert(ex == "+********1_234_567_89_0;1");
10044 assert(ios.width() == 0);
10045 }
10046 }
10047 }
10048 showpoint(ios);
10049 {
10050 ios.imbue(lc);
10051 {
10052 ios.width(0);
10053 {
10054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10055 std::string ex(str, iter.base());
10056 assert(ex == "+1234567890.1");
10057 assert(ios.width() == 0);
10058 }
10059 ios.width(25);
10060 left(ios);
10061 {
10062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10063 std::string ex(str, iter.base());
10064 assert(ex == "+1234567890.1************");
10065 assert(ios.width() == 0);
10066 }
10067 ios.width(25);
10068 right(ios);
10069 {
10070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10071 std::string ex(str, iter.base());
10072 assert(ex == "************+1234567890.1");
10073 assert(ios.width() == 0);
10074 }
10075 ios.width(25);
10076 internal(ios);
10077 {
10078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10079 std::string ex(str, iter.base());
10080 assert(ex == "+************1234567890.1");
10081 assert(ios.width() == 0);
10082 }
10083 }
10084 ios.imbue(lg);
10085 {
10086 ios.width(0);
10087 {
10088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10089 std::string ex(str, iter.base());
10090 assert(ex == "+1_234_567_89_0;1");
10091 assert(ios.width() == 0);
10092 }
10093 ios.width(25);
10094 left(ios);
10095 {
10096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10097 std::string ex(str, iter.base());
10098 assert(ex == "+1_234_567_89_0;1********");
10099 assert(ios.width() == 0);
10100 }
10101 ios.width(25);
10102 right(ios);
10103 {
10104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10105 std::string ex(str, iter.base());
10106 assert(ex == "********+1_234_567_89_0;1");
10107 assert(ios.width() == 0);
10108 }
10109 ios.width(25);
10110 internal(ios);
10111 {
10112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10113 std::string ex(str, iter.base());
10114 assert(ex == "+********1_234_567_89_0;1");
10115 assert(ios.width() == 0);
10116 }
10117 }
10118 }
10119 }
10120 }
10121 }
10122 ios.precision(6);
10123 {
10124 nouppercase(ios);
10125 {
10126 noshowpos(ios);
10127 {
10128 noshowpoint(ios);
10129 {
10130 ios.imbue(lc);
10131 {
10132 ios.width(0);
10133 {
10134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10135 std::string ex(str, iter.base());
10136 assert(ex == "1234567890.125000");
10137 assert(ios.width() == 0);
10138 }
10139 ios.width(25);
10140 left(ios);
10141 {
10142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10143 std::string ex(str, iter.base());
10144 assert(ex == "1234567890.125000********");
10145 assert(ios.width() == 0);
10146 }
10147 ios.width(25);
10148 right(ios);
10149 {
10150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10151 std::string ex(str, iter.base());
10152 assert(ex == "********1234567890.125000");
10153 assert(ios.width() == 0);
10154 }
10155 ios.width(25);
10156 internal(ios);
10157 {
10158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10159 std::string ex(str, iter.base());
10160 assert(ex == "********1234567890.125000");
10161 assert(ios.width() == 0);
10162 }
10163 }
10164 ios.imbue(lg);
10165 {
10166 ios.width(0);
10167 {
10168 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10169 std::string ex(str, iter.base());
10170 assert(ex == "1_234_567_89_0;125000");
10171 assert(ios.width() == 0);
10172 }
10173 ios.width(25);
10174 left(ios);
10175 {
10176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10177 std::string ex(str, iter.base());
10178 assert(ex == "1_234_567_89_0;125000****");
10179 assert(ios.width() == 0);
10180 }
10181 ios.width(25);
10182 right(ios);
10183 {
10184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10185 std::string ex(str, iter.base());
10186 assert(ex == "****1_234_567_89_0;125000");
10187 assert(ios.width() == 0);
10188 }
10189 ios.width(25);
10190 internal(ios);
10191 {
10192 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10193 std::string ex(str, iter.base());
10194 assert(ex == "****1_234_567_89_0;125000");
10195 assert(ios.width() == 0);
10196 }
10197 }
10198 }
10199 showpoint(ios);
10200 {
10201 ios.imbue(lc);
10202 {
10203 ios.width(0);
10204 {
10205 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10206 std::string ex(str, iter.base());
10207 assert(ex == "1234567890.125000");
10208 assert(ios.width() == 0);
10209 }
10210 ios.width(25);
10211 left(ios);
10212 {
10213 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10214 std::string ex(str, iter.base());
10215 assert(ex == "1234567890.125000********");
10216 assert(ios.width() == 0);
10217 }
10218 ios.width(25);
10219 right(ios);
10220 {
10221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10222 std::string ex(str, iter.base());
10223 assert(ex == "********1234567890.125000");
10224 assert(ios.width() == 0);
10225 }
10226 ios.width(25);
10227 internal(ios);
10228 {
10229 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10230 std::string ex(str, iter.base());
10231 assert(ex == "********1234567890.125000");
10232 assert(ios.width() == 0);
10233 }
10234 }
10235 ios.imbue(lg);
10236 {
10237 ios.width(0);
10238 {
10239 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10240 std::string ex(str, iter.base());
10241 assert(ex == "1_234_567_89_0;125000");
10242 assert(ios.width() == 0);
10243 }
10244 ios.width(25);
10245 left(ios);
10246 {
10247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10248 std::string ex(str, iter.base());
10249 assert(ex == "1_234_567_89_0;125000****");
10250 assert(ios.width() == 0);
10251 }
10252 ios.width(25);
10253 right(ios);
10254 {
10255 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10256 std::string ex(str, iter.base());
10257 assert(ex == "****1_234_567_89_0;125000");
10258 assert(ios.width() == 0);
10259 }
10260 ios.width(25);
10261 internal(ios);
10262 {
10263 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10264 std::string ex(str, iter.base());
10265 assert(ex == "****1_234_567_89_0;125000");
10266 assert(ios.width() == 0);
10267 }
10268 }
10269 }
10270 }
10271 showpos(ios);
10272 {
10273 noshowpoint(ios);
10274 {
10275 ios.imbue(lc);
10276 {
10277 ios.width(0);
10278 {
10279 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10280 std::string ex(str, iter.base());
10281 assert(ex == "+1234567890.125000");
10282 assert(ios.width() == 0);
10283 }
10284 ios.width(25);
10285 left(ios);
10286 {
10287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10288 std::string ex(str, iter.base());
10289 assert(ex == "+1234567890.125000*******");
10290 assert(ios.width() == 0);
10291 }
10292 ios.width(25);
10293 right(ios);
10294 {
10295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10296 std::string ex(str, iter.base());
10297 assert(ex == "*******+1234567890.125000");
10298 assert(ios.width() == 0);
10299 }
10300 ios.width(25);
10301 internal(ios);
10302 {
10303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10304 std::string ex(str, iter.base());
10305 assert(ex == "+*******1234567890.125000");
10306 assert(ios.width() == 0);
10307 }
10308 }
10309 ios.imbue(lg);
10310 {
10311 ios.width(0);
10312 {
10313 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10314 std::string ex(str, iter.base());
10315 assert(ex == "+1_234_567_89_0;125000");
10316 assert(ios.width() == 0);
10317 }
10318 ios.width(25);
10319 left(ios);
10320 {
10321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10322 std::string ex(str, iter.base());
10323 assert(ex == "+1_234_567_89_0;125000***");
10324 assert(ios.width() == 0);
10325 }
10326 ios.width(25);
10327 right(ios);
10328 {
10329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10330 std::string ex(str, iter.base());
10331 assert(ex == "***+1_234_567_89_0;125000");
10332 assert(ios.width() == 0);
10333 }
10334 ios.width(25);
10335 internal(ios);
10336 {
10337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10338 std::string ex(str, iter.base());
10339 assert(ex == "+***1_234_567_89_0;125000");
10340 assert(ios.width() == 0);
10341 }
10342 }
10343 }
10344 showpoint(ios);
10345 {
10346 ios.imbue(lc);
10347 {
10348 ios.width(0);
10349 {
10350 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10351 std::string ex(str, iter.base());
10352 assert(ex == "+1234567890.125000");
10353 assert(ios.width() == 0);
10354 }
10355 ios.width(25);
10356 left(ios);
10357 {
10358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10359 std::string ex(str, iter.base());
10360 assert(ex == "+1234567890.125000*******");
10361 assert(ios.width() == 0);
10362 }
10363 ios.width(25);
10364 right(ios);
10365 {
10366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10367 std::string ex(str, iter.base());
10368 assert(ex == "*******+1234567890.125000");
10369 assert(ios.width() == 0);
10370 }
10371 ios.width(25);
10372 internal(ios);
10373 {
10374 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10375 std::string ex(str, iter.base());
10376 assert(ex == "+*******1234567890.125000");
10377 assert(ios.width() == 0);
10378 }
10379 }
10380 ios.imbue(lg);
10381 {
10382 ios.width(0);
10383 {
10384 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10385 std::string ex(str, iter.base());
10386 assert(ex == "+1_234_567_89_0;125000");
10387 assert(ios.width() == 0);
10388 }
10389 ios.width(25);
10390 left(ios);
10391 {
10392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10393 std::string ex(str, iter.base());
10394 assert(ex == "+1_234_567_89_0;125000***");
10395 assert(ios.width() == 0);
10396 }
10397 ios.width(25);
10398 right(ios);
10399 {
10400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10401 std::string ex(str, iter.base());
10402 assert(ex == "***+1_234_567_89_0;125000");
10403 assert(ios.width() == 0);
10404 }
10405 ios.width(25);
10406 internal(ios);
10407 {
10408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10409 std::string ex(str, iter.base());
10410 assert(ex == "+***1_234_567_89_0;125000");
10411 assert(ios.width() == 0);
10412 }
10413 }
10414 }
10415 }
10416 }
10417 uppercase(ios);
10418 {
10419 noshowpos(ios);
10420 {
10421 noshowpoint(ios);
10422 {
10423 ios.imbue(lc);
10424 {
10425 ios.width(0);
10426 {
10427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10428 std::string ex(str, iter.base());
10429 assert(ex == "1234567890.125000");
10430 assert(ios.width() == 0);
10431 }
10432 ios.width(25);
10433 left(ios);
10434 {
10435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10436 std::string ex(str, iter.base());
10437 assert(ex == "1234567890.125000********");
10438 assert(ios.width() == 0);
10439 }
10440 ios.width(25);
10441 right(ios);
10442 {
10443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10444 std::string ex(str, iter.base());
10445 assert(ex == "********1234567890.125000");
10446 assert(ios.width() == 0);
10447 }
10448 ios.width(25);
10449 internal(ios);
10450 {
10451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10452 std::string ex(str, iter.base());
10453 assert(ex == "********1234567890.125000");
10454 assert(ios.width() == 0);
10455 }
10456 }
10457 ios.imbue(lg);
10458 {
10459 ios.width(0);
10460 {
10461 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10462 std::string ex(str, iter.base());
10463 assert(ex == "1_234_567_89_0;125000");
10464 assert(ios.width() == 0);
10465 }
10466 ios.width(25);
10467 left(ios);
10468 {
10469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10470 std::string ex(str, iter.base());
10471 assert(ex == "1_234_567_89_0;125000****");
10472 assert(ios.width() == 0);
10473 }
10474 ios.width(25);
10475 right(ios);
10476 {
10477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10478 std::string ex(str, iter.base());
10479 assert(ex == "****1_234_567_89_0;125000");
10480 assert(ios.width() == 0);
10481 }
10482 ios.width(25);
10483 internal(ios);
10484 {
10485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10486 std::string ex(str, iter.base());
10487 assert(ex == "****1_234_567_89_0;125000");
10488 assert(ios.width() == 0);
10489 }
10490 }
10491 }
10492 showpoint(ios);
10493 {
10494 ios.imbue(lc);
10495 {
10496 ios.width(0);
10497 {
10498 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10499 std::string ex(str, iter.base());
10500 assert(ex == "1234567890.125000");
10501 assert(ios.width() == 0);
10502 }
10503 ios.width(25);
10504 left(ios);
10505 {
10506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10507 std::string ex(str, iter.base());
10508 assert(ex == "1234567890.125000********");
10509 assert(ios.width() == 0);
10510 }
10511 ios.width(25);
10512 right(ios);
10513 {
10514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10515 std::string ex(str, iter.base());
10516 assert(ex == "********1234567890.125000");
10517 assert(ios.width() == 0);
10518 }
10519 ios.width(25);
10520 internal(ios);
10521 {
10522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10523 std::string ex(str, iter.base());
10524 assert(ex == "********1234567890.125000");
10525 assert(ios.width() == 0);
10526 }
10527 }
10528 ios.imbue(lg);
10529 {
10530 ios.width(0);
10531 {
10532 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10533 std::string ex(str, iter.base());
10534 assert(ex == "1_234_567_89_0;125000");
10535 assert(ios.width() == 0);
10536 }
10537 ios.width(25);
10538 left(ios);
10539 {
10540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10541 std::string ex(str, iter.base());
10542 assert(ex == "1_234_567_89_0;125000****");
10543 assert(ios.width() == 0);
10544 }
10545 ios.width(25);
10546 right(ios);
10547 {
10548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10549 std::string ex(str, iter.base());
10550 assert(ex == "****1_234_567_89_0;125000");
10551 assert(ios.width() == 0);
10552 }
10553 ios.width(25);
10554 internal(ios);
10555 {
10556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10557 std::string ex(str, iter.base());
10558 assert(ex == "****1_234_567_89_0;125000");
10559 assert(ios.width() == 0);
10560 }
10561 }
10562 }
10563 }
10564 showpos(ios);
10565 {
10566 noshowpoint(ios);
10567 {
10568 ios.imbue(lc);
10569 {
10570 ios.width(0);
10571 {
10572 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10573 std::string ex(str, iter.base());
10574 assert(ex == "+1234567890.125000");
10575 assert(ios.width() == 0);
10576 }
10577 ios.width(25);
10578 left(ios);
10579 {
10580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10581 std::string ex(str, iter.base());
10582 assert(ex == "+1234567890.125000*******");
10583 assert(ios.width() == 0);
10584 }
10585 ios.width(25);
10586 right(ios);
10587 {
10588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10589 std::string ex(str, iter.base());
10590 assert(ex == "*******+1234567890.125000");
10591 assert(ios.width() == 0);
10592 }
10593 ios.width(25);
10594 internal(ios);
10595 {
10596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10597 std::string ex(str, iter.base());
10598 assert(ex == "+*******1234567890.125000");
10599 assert(ios.width() == 0);
10600 }
10601 }
10602 ios.imbue(lg);
10603 {
10604 ios.width(0);
10605 {
10606 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10607 std::string ex(str, iter.base());
10608 assert(ex == "+1_234_567_89_0;125000");
10609 assert(ios.width() == 0);
10610 }
10611 ios.width(25);
10612 left(ios);
10613 {
10614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10615 std::string ex(str, iter.base());
10616 assert(ex == "+1_234_567_89_0;125000***");
10617 assert(ios.width() == 0);
10618 }
10619 ios.width(25);
10620 right(ios);
10621 {
10622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10623 std::string ex(str, iter.base());
10624 assert(ex == "***+1_234_567_89_0;125000");
10625 assert(ios.width() == 0);
10626 }
10627 ios.width(25);
10628 internal(ios);
10629 {
10630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10631 std::string ex(str, iter.base());
10632 assert(ex == "+***1_234_567_89_0;125000");
10633 assert(ios.width() == 0);
10634 }
10635 }
10636 }
10637 showpoint(ios);
10638 {
10639 ios.imbue(lc);
10640 {
10641 ios.width(0);
10642 {
10643 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10644 std::string ex(str, iter.base());
10645 assert(ex == "+1234567890.125000");
10646 assert(ios.width() == 0);
10647 }
10648 ios.width(25);
10649 left(ios);
10650 {
10651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10652 std::string ex(str, iter.base());
10653 assert(ex == "+1234567890.125000*******");
10654 assert(ios.width() == 0);
10655 }
10656 ios.width(25);
10657 right(ios);
10658 {
10659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10660 std::string ex(str, iter.base());
10661 assert(ex == "*******+1234567890.125000");
10662 assert(ios.width() == 0);
10663 }
10664 ios.width(25);
10665 internal(ios);
10666 {
10667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10668 std::string ex(str, iter.base());
10669 assert(ex == "+*******1234567890.125000");
10670 assert(ios.width() == 0);
10671 }
10672 }
10673 ios.imbue(lg);
10674 {
10675 ios.width(0);
10676 {
10677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10678 std::string ex(str, iter.base());
10679 assert(ex == "+1_234_567_89_0;125000");
10680 assert(ios.width() == 0);
10681 }
10682 ios.width(25);
10683 left(ios);
10684 {
10685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10686 std::string ex(str, iter.base());
10687 assert(ex == "+1_234_567_89_0;125000***");
10688 assert(ios.width() == 0);
10689 }
10690 ios.width(25);
10691 right(ios);
10692 {
10693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10694 std::string ex(str, iter.base());
10695 assert(ex == "***+1_234_567_89_0;125000");
10696 assert(ios.width() == 0);
10697 }
10698 ios.width(25);
10699 internal(ios);
10700 {
10701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10702 std::string ex(str, iter.base());
10703 assert(ex == "+***1_234_567_89_0;125000");
10704 assert(ios.width() == 0);
10705 }
10706 }
10707 }
10708 }
10709 }
10710 }
10711 ios.precision(16);
10712 {}
10713 ios.precision(60);
10714 {}
10715 }
10716 }
10717 }
10718
test5()10719 void test5()
10720 {
10721 char str[200];
10722 output_iterator<char*> iter;
10723 std::locale lc = std::locale::classic();
10724 std::locale lg(lc, new my_numpunct);
10725 const my_facet f(1);
10726 {
10727 double v = -0.;
10728 std::ios ios(0);
10729 scientific(ios);
10730 // %e
10731 {
10732 ios.precision(0);
10733 {
10734 nouppercase(ios);
10735 {
10736 noshowpos(ios);
10737 {
10738 noshowpoint(ios);
10739 {
10740 ios.imbue(lc);
10741 {
10742 ios.width(0);
10743 {
10744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10745 std::string ex(str, iter.base());
10746 assert(ex == "-0e+00");
10747 assert(ios.width() == 0);
10748 }
10749 ios.width(25);
10750 left(ios);
10751 {
10752 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10753 std::string ex(str, iter.base());
10754 assert(ex == "-0e+00*******************");
10755 assert(ios.width() == 0);
10756 }
10757 ios.width(25);
10758 right(ios);
10759 {
10760 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10761 std::string ex(str, iter.base());
10762 assert(ex == "*******************-0e+00");
10763 assert(ios.width() == 0);
10764 }
10765 ios.width(25);
10766 internal(ios);
10767 {
10768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10769 std::string ex(str, iter.base());
10770 assert(ex == "-*******************0e+00");
10771 assert(ios.width() == 0);
10772 }
10773 }
10774 ios.imbue(lg);
10775 {
10776 ios.width(0);
10777 {
10778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10779 std::string ex(str, iter.base());
10780 assert(ex == "-0e+00");
10781 assert(ios.width() == 0);
10782 }
10783 ios.width(25);
10784 left(ios);
10785 {
10786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10787 std::string ex(str, iter.base());
10788 assert(ex == "-0e+00*******************");
10789 assert(ios.width() == 0);
10790 }
10791 ios.width(25);
10792 right(ios);
10793 {
10794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10795 std::string ex(str, iter.base());
10796 assert(ex == "*******************-0e+00");
10797 assert(ios.width() == 0);
10798 }
10799 ios.width(25);
10800 internal(ios);
10801 {
10802 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10803 std::string ex(str, iter.base());
10804 assert(ex == "-*******************0e+00");
10805 assert(ios.width() == 0);
10806 }
10807 }
10808 }
10809 showpoint(ios);
10810 {
10811 ios.imbue(lc);
10812 {
10813 ios.width(0);
10814 {
10815 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10816 std::string ex(str, iter.base());
10817 assert(ex == "-0.e+00");
10818 assert(ios.width() == 0);
10819 }
10820 ios.width(25);
10821 left(ios);
10822 {
10823 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10824 std::string ex(str, iter.base());
10825 assert(ex == "-0.e+00******************");
10826 assert(ios.width() == 0);
10827 }
10828 ios.width(25);
10829 right(ios);
10830 {
10831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10832 std::string ex(str, iter.base());
10833 assert(ex == "******************-0.e+00");
10834 assert(ios.width() == 0);
10835 }
10836 ios.width(25);
10837 internal(ios);
10838 {
10839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10840 std::string ex(str, iter.base());
10841 assert(ex == "-******************0.e+00");
10842 assert(ios.width() == 0);
10843 }
10844 }
10845 ios.imbue(lg);
10846 {
10847 ios.width(0);
10848 {
10849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10850 std::string ex(str, iter.base());
10851 assert(ex == "-0;e+00");
10852 assert(ios.width() == 0);
10853 }
10854 ios.width(25);
10855 left(ios);
10856 {
10857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10858 std::string ex(str, iter.base());
10859 assert(ex == "-0;e+00******************");
10860 assert(ios.width() == 0);
10861 }
10862 ios.width(25);
10863 right(ios);
10864 {
10865 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10866 std::string ex(str, iter.base());
10867 assert(ex == "******************-0;e+00");
10868 assert(ios.width() == 0);
10869 }
10870 ios.width(25);
10871 internal(ios);
10872 {
10873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10874 std::string ex(str, iter.base());
10875 assert(ex == "-******************0;e+00");
10876 assert(ios.width() == 0);
10877 }
10878 }
10879 }
10880 }
10881 showpos(ios);
10882 {
10883 noshowpoint(ios);
10884 {
10885 ios.imbue(lc);
10886 {
10887 ios.width(0);
10888 {
10889 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10890 std::string ex(str, iter.base());
10891 assert(ex == "-0e+00");
10892 assert(ios.width() == 0);
10893 }
10894 ios.width(25);
10895 left(ios);
10896 {
10897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10898 std::string ex(str, iter.base());
10899 assert(ex == "-0e+00*******************");
10900 assert(ios.width() == 0);
10901 }
10902 ios.width(25);
10903 right(ios);
10904 {
10905 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10906 std::string ex(str, iter.base());
10907 assert(ex == "*******************-0e+00");
10908 assert(ios.width() == 0);
10909 }
10910 ios.width(25);
10911 internal(ios);
10912 {
10913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10914 std::string ex(str, iter.base());
10915 assert(ex == "-*******************0e+00");
10916 assert(ios.width() == 0);
10917 }
10918 }
10919 ios.imbue(lg);
10920 {
10921 ios.width(0);
10922 {
10923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10924 std::string ex(str, iter.base());
10925 assert(ex == "-0e+00");
10926 assert(ios.width() == 0);
10927 }
10928 ios.width(25);
10929 left(ios);
10930 {
10931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10932 std::string ex(str, iter.base());
10933 assert(ex == "-0e+00*******************");
10934 assert(ios.width() == 0);
10935 }
10936 ios.width(25);
10937 right(ios);
10938 {
10939 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10940 std::string ex(str, iter.base());
10941 assert(ex == "*******************-0e+00");
10942 assert(ios.width() == 0);
10943 }
10944 ios.width(25);
10945 internal(ios);
10946 {
10947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10948 std::string ex(str, iter.base());
10949 assert(ex == "-*******************0e+00");
10950 assert(ios.width() == 0);
10951 }
10952 }
10953 }
10954 showpoint(ios);
10955 {
10956 ios.imbue(lc);
10957 {
10958 ios.width(0);
10959 {
10960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10961 std::string ex(str, iter.base());
10962 assert(ex == "-0.e+00");
10963 assert(ios.width() == 0);
10964 }
10965 ios.width(25);
10966 left(ios);
10967 {
10968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10969 std::string ex(str, iter.base());
10970 assert(ex == "-0.e+00******************");
10971 assert(ios.width() == 0);
10972 }
10973 ios.width(25);
10974 right(ios);
10975 {
10976 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10977 std::string ex(str, iter.base());
10978 assert(ex == "******************-0.e+00");
10979 assert(ios.width() == 0);
10980 }
10981 ios.width(25);
10982 internal(ios);
10983 {
10984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10985 std::string ex(str, iter.base());
10986 assert(ex == "-******************0.e+00");
10987 assert(ios.width() == 0);
10988 }
10989 }
10990 ios.imbue(lg);
10991 {
10992 ios.width(0);
10993 {
10994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10995 std::string ex(str, iter.base());
10996 assert(ex == "-0;e+00");
10997 assert(ios.width() == 0);
10998 }
10999 ios.width(25);
11000 left(ios);
11001 {
11002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11003 std::string ex(str, iter.base());
11004 assert(ex == "-0;e+00******************");
11005 assert(ios.width() == 0);
11006 }
11007 ios.width(25);
11008 right(ios);
11009 {
11010 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11011 std::string ex(str, iter.base());
11012 assert(ex == "******************-0;e+00");
11013 assert(ios.width() == 0);
11014 }
11015 ios.width(25);
11016 internal(ios);
11017 {
11018 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11019 std::string ex(str, iter.base());
11020 assert(ex == "-******************0;e+00");
11021 assert(ios.width() == 0);
11022 }
11023 }
11024 }
11025 }
11026 }
11027 uppercase(ios);
11028 {
11029 noshowpos(ios);
11030 {
11031 noshowpoint(ios);
11032 {
11033 ios.imbue(lc);
11034 {
11035 ios.width(0);
11036 {
11037 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11038 std::string ex(str, iter.base());
11039 assert(ex == "-0E+00");
11040 assert(ios.width() == 0);
11041 }
11042 ios.width(25);
11043 left(ios);
11044 {
11045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11046 std::string ex(str, iter.base());
11047 assert(ex == "-0E+00*******************");
11048 assert(ios.width() == 0);
11049 }
11050 ios.width(25);
11051 right(ios);
11052 {
11053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11054 std::string ex(str, iter.base());
11055 assert(ex == "*******************-0E+00");
11056 assert(ios.width() == 0);
11057 }
11058 ios.width(25);
11059 internal(ios);
11060 {
11061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11062 std::string ex(str, iter.base());
11063 assert(ex == "-*******************0E+00");
11064 assert(ios.width() == 0);
11065 }
11066 }
11067 ios.imbue(lg);
11068 {
11069 ios.width(0);
11070 {
11071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11072 std::string ex(str, iter.base());
11073 assert(ex == "-0E+00");
11074 assert(ios.width() == 0);
11075 }
11076 ios.width(25);
11077 left(ios);
11078 {
11079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11080 std::string ex(str, iter.base());
11081 assert(ex == "-0E+00*******************");
11082 assert(ios.width() == 0);
11083 }
11084 ios.width(25);
11085 right(ios);
11086 {
11087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11088 std::string ex(str, iter.base());
11089 assert(ex == "*******************-0E+00");
11090 assert(ios.width() == 0);
11091 }
11092 ios.width(25);
11093 internal(ios);
11094 {
11095 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11096 std::string ex(str, iter.base());
11097 assert(ex == "-*******************0E+00");
11098 assert(ios.width() == 0);
11099 }
11100 }
11101 }
11102 showpoint(ios);
11103 {
11104 ios.imbue(lc);
11105 {
11106 ios.width(0);
11107 {
11108 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11109 std::string ex(str, iter.base());
11110 assert(ex == "-0.E+00");
11111 assert(ios.width() == 0);
11112 }
11113 ios.width(25);
11114 left(ios);
11115 {
11116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11117 std::string ex(str, iter.base());
11118 assert(ex == "-0.E+00******************");
11119 assert(ios.width() == 0);
11120 }
11121 ios.width(25);
11122 right(ios);
11123 {
11124 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11125 std::string ex(str, iter.base());
11126 assert(ex == "******************-0.E+00");
11127 assert(ios.width() == 0);
11128 }
11129 ios.width(25);
11130 internal(ios);
11131 {
11132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11133 std::string ex(str, iter.base());
11134 assert(ex == "-******************0.E+00");
11135 assert(ios.width() == 0);
11136 }
11137 }
11138 ios.imbue(lg);
11139 {
11140 ios.width(0);
11141 {
11142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11143 std::string ex(str, iter.base());
11144 assert(ex == "-0;E+00");
11145 assert(ios.width() == 0);
11146 }
11147 ios.width(25);
11148 left(ios);
11149 {
11150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11151 std::string ex(str, iter.base());
11152 assert(ex == "-0;E+00******************");
11153 assert(ios.width() == 0);
11154 }
11155 ios.width(25);
11156 right(ios);
11157 {
11158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11159 std::string ex(str, iter.base());
11160 assert(ex == "******************-0;E+00");
11161 assert(ios.width() == 0);
11162 }
11163 ios.width(25);
11164 internal(ios);
11165 {
11166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11167 std::string ex(str, iter.base());
11168 assert(ex == "-******************0;E+00");
11169 assert(ios.width() == 0);
11170 }
11171 }
11172 }
11173 }
11174 showpos(ios);
11175 {
11176 noshowpoint(ios);
11177 {
11178 ios.imbue(lc);
11179 {
11180 ios.width(0);
11181 {
11182 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11183 std::string ex(str, iter.base());
11184 assert(ex == "-0E+00");
11185 assert(ios.width() == 0);
11186 }
11187 ios.width(25);
11188 left(ios);
11189 {
11190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11191 std::string ex(str, iter.base());
11192 assert(ex == "-0E+00*******************");
11193 assert(ios.width() == 0);
11194 }
11195 ios.width(25);
11196 right(ios);
11197 {
11198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11199 std::string ex(str, iter.base());
11200 assert(ex == "*******************-0E+00");
11201 assert(ios.width() == 0);
11202 }
11203 ios.width(25);
11204 internal(ios);
11205 {
11206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11207 std::string ex(str, iter.base());
11208 assert(ex == "-*******************0E+00");
11209 assert(ios.width() == 0);
11210 }
11211 }
11212 ios.imbue(lg);
11213 {
11214 ios.width(0);
11215 {
11216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11217 std::string ex(str, iter.base());
11218 assert(ex == "-0E+00");
11219 assert(ios.width() == 0);
11220 }
11221 ios.width(25);
11222 left(ios);
11223 {
11224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11225 std::string ex(str, iter.base());
11226 assert(ex == "-0E+00*******************");
11227 assert(ios.width() == 0);
11228 }
11229 ios.width(25);
11230 right(ios);
11231 {
11232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11233 std::string ex(str, iter.base());
11234 assert(ex == "*******************-0E+00");
11235 assert(ios.width() == 0);
11236 }
11237 ios.width(25);
11238 internal(ios);
11239 {
11240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11241 std::string ex(str, iter.base());
11242 assert(ex == "-*******************0E+00");
11243 assert(ios.width() == 0);
11244 }
11245 }
11246 }
11247 showpoint(ios);
11248 {
11249 ios.imbue(lc);
11250 {
11251 ios.width(0);
11252 {
11253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11254 std::string ex(str, iter.base());
11255 assert(ex == "-0.E+00");
11256 assert(ios.width() == 0);
11257 }
11258 ios.width(25);
11259 left(ios);
11260 {
11261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11262 std::string ex(str, iter.base());
11263 assert(ex == "-0.E+00******************");
11264 assert(ios.width() == 0);
11265 }
11266 ios.width(25);
11267 right(ios);
11268 {
11269 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11270 std::string ex(str, iter.base());
11271 assert(ex == "******************-0.E+00");
11272 assert(ios.width() == 0);
11273 }
11274 ios.width(25);
11275 internal(ios);
11276 {
11277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11278 std::string ex(str, iter.base());
11279 assert(ex == "-******************0.E+00");
11280 assert(ios.width() == 0);
11281 }
11282 }
11283 ios.imbue(lg);
11284 {
11285 ios.width(0);
11286 {
11287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11288 std::string ex(str, iter.base());
11289 assert(ex == "-0;E+00");
11290 assert(ios.width() == 0);
11291 }
11292 ios.width(25);
11293 left(ios);
11294 {
11295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11296 std::string ex(str, iter.base());
11297 assert(ex == "-0;E+00******************");
11298 assert(ios.width() == 0);
11299 }
11300 ios.width(25);
11301 right(ios);
11302 {
11303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11304 std::string ex(str, iter.base());
11305 assert(ex == "******************-0;E+00");
11306 assert(ios.width() == 0);
11307 }
11308 ios.width(25);
11309 internal(ios);
11310 {
11311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11312 std::string ex(str, iter.base());
11313 assert(ex == "-******************0;E+00");
11314 assert(ios.width() == 0);
11315 }
11316 }
11317 }
11318 }
11319 }
11320 }
11321 ios.precision(1);
11322 {
11323 nouppercase(ios);
11324 {
11325 noshowpos(ios);
11326 {
11327 noshowpoint(ios);
11328 {
11329 ios.imbue(lc);
11330 {
11331 ios.width(0);
11332 {
11333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11334 std::string ex(str, iter.base());
11335 assert(ex == "-0.0e+00");
11336 assert(ios.width() == 0);
11337 }
11338 ios.width(25);
11339 left(ios);
11340 {
11341 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11342 std::string ex(str, iter.base());
11343 assert(ex == "-0.0e+00*****************");
11344 assert(ios.width() == 0);
11345 }
11346 ios.width(25);
11347 right(ios);
11348 {
11349 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11350 std::string ex(str, iter.base());
11351 assert(ex == "*****************-0.0e+00");
11352 assert(ios.width() == 0);
11353 }
11354 ios.width(25);
11355 internal(ios);
11356 {
11357 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11358 std::string ex(str, iter.base());
11359 assert(ex == "-*****************0.0e+00");
11360 assert(ios.width() == 0);
11361 }
11362 }
11363 ios.imbue(lg);
11364 {
11365 ios.width(0);
11366 {
11367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11368 std::string ex(str, iter.base());
11369 assert(ex == "-0;0e+00");
11370 assert(ios.width() == 0);
11371 }
11372 ios.width(25);
11373 left(ios);
11374 {
11375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11376 std::string ex(str, iter.base());
11377 assert(ex == "-0;0e+00*****************");
11378 assert(ios.width() == 0);
11379 }
11380 ios.width(25);
11381 right(ios);
11382 {
11383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11384 std::string ex(str, iter.base());
11385 assert(ex == "*****************-0;0e+00");
11386 assert(ios.width() == 0);
11387 }
11388 ios.width(25);
11389 internal(ios);
11390 {
11391 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11392 std::string ex(str, iter.base());
11393 assert(ex == "-*****************0;0e+00");
11394 assert(ios.width() == 0);
11395 }
11396 }
11397 }
11398 showpoint(ios);
11399 {
11400 ios.imbue(lc);
11401 {
11402 ios.width(0);
11403 {
11404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11405 std::string ex(str, iter.base());
11406 assert(ex == "-0.0e+00");
11407 assert(ios.width() == 0);
11408 }
11409 ios.width(25);
11410 left(ios);
11411 {
11412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11413 std::string ex(str, iter.base());
11414 assert(ex == "-0.0e+00*****************");
11415 assert(ios.width() == 0);
11416 }
11417 ios.width(25);
11418 right(ios);
11419 {
11420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11421 std::string ex(str, iter.base());
11422 assert(ex == "*****************-0.0e+00");
11423 assert(ios.width() == 0);
11424 }
11425 ios.width(25);
11426 internal(ios);
11427 {
11428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11429 std::string ex(str, iter.base());
11430 assert(ex == "-*****************0.0e+00");
11431 assert(ios.width() == 0);
11432 }
11433 }
11434 ios.imbue(lg);
11435 {
11436 ios.width(0);
11437 {
11438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11439 std::string ex(str, iter.base());
11440 assert(ex == "-0;0e+00");
11441 assert(ios.width() == 0);
11442 }
11443 ios.width(25);
11444 left(ios);
11445 {
11446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11447 std::string ex(str, iter.base());
11448 assert(ex == "-0;0e+00*****************");
11449 assert(ios.width() == 0);
11450 }
11451 ios.width(25);
11452 right(ios);
11453 {
11454 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11455 std::string ex(str, iter.base());
11456 assert(ex == "*****************-0;0e+00");
11457 assert(ios.width() == 0);
11458 }
11459 ios.width(25);
11460 internal(ios);
11461 {
11462 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11463 std::string ex(str, iter.base());
11464 assert(ex == "-*****************0;0e+00");
11465 assert(ios.width() == 0);
11466 }
11467 }
11468 }
11469 }
11470 showpos(ios);
11471 {
11472 noshowpoint(ios);
11473 {
11474 ios.imbue(lc);
11475 {
11476 ios.width(0);
11477 {
11478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11479 std::string ex(str, iter.base());
11480 assert(ex == "-0.0e+00");
11481 assert(ios.width() == 0);
11482 }
11483 ios.width(25);
11484 left(ios);
11485 {
11486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11487 std::string ex(str, iter.base());
11488 assert(ex == "-0.0e+00*****************");
11489 assert(ios.width() == 0);
11490 }
11491 ios.width(25);
11492 right(ios);
11493 {
11494 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11495 std::string ex(str, iter.base());
11496 assert(ex == "*****************-0.0e+00");
11497 assert(ios.width() == 0);
11498 }
11499 ios.width(25);
11500 internal(ios);
11501 {
11502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11503 std::string ex(str, iter.base());
11504 assert(ex == "-*****************0.0e+00");
11505 assert(ios.width() == 0);
11506 }
11507 }
11508 ios.imbue(lg);
11509 {
11510 ios.width(0);
11511 {
11512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11513 std::string ex(str, iter.base());
11514 assert(ex == "-0;0e+00");
11515 assert(ios.width() == 0);
11516 }
11517 ios.width(25);
11518 left(ios);
11519 {
11520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11521 std::string ex(str, iter.base());
11522 assert(ex == "-0;0e+00*****************");
11523 assert(ios.width() == 0);
11524 }
11525 ios.width(25);
11526 right(ios);
11527 {
11528 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11529 std::string ex(str, iter.base());
11530 assert(ex == "*****************-0;0e+00");
11531 assert(ios.width() == 0);
11532 }
11533 ios.width(25);
11534 internal(ios);
11535 {
11536 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11537 std::string ex(str, iter.base());
11538 assert(ex == "-*****************0;0e+00");
11539 assert(ios.width() == 0);
11540 }
11541 }
11542 }
11543 showpoint(ios);
11544 {
11545 ios.imbue(lc);
11546 {
11547 ios.width(0);
11548 {
11549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11550 std::string ex(str, iter.base());
11551 assert(ex == "-0.0e+00");
11552 assert(ios.width() == 0);
11553 }
11554 ios.width(25);
11555 left(ios);
11556 {
11557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11558 std::string ex(str, iter.base());
11559 assert(ex == "-0.0e+00*****************");
11560 assert(ios.width() == 0);
11561 }
11562 ios.width(25);
11563 right(ios);
11564 {
11565 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11566 std::string ex(str, iter.base());
11567 assert(ex == "*****************-0.0e+00");
11568 assert(ios.width() == 0);
11569 }
11570 ios.width(25);
11571 internal(ios);
11572 {
11573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11574 std::string ex(str, iter.base());
11575 assert(ex == "-*****************0.0e+00");
11576 assert(ios.width() == 0);
11577 }
11578 }
11579 ios.imbue(lg);
11580 {
11581 ios.width(0);
11582 {
11583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11584 std::string ex(str, iter.base());
11585 assert(ex == "-0;0e+00");
11586 assert(ios.width() == 0);
11587 }
11588 ios.width(25);
11589 left(ios);
11590 {
11591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11592 std::string ex(str, iter.base());
11593 assert(ex == "-0;0e+00*****************");
11594 assert(ios.width() == 0);
11595 }
11596 ios.width(25);
11597 right(ios);
11598 {
11599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11600 std::string ex(str, iter.base());
11601 assert(ex == "*****************-0;0e+00");
11602 assert(ios.width() == 0);
11603 }
11604 ios.width(25);
11605 internal(ios);
11606 {
11607 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11608 std::string ex(str, iter.base());
11609 assert(ex == "-*****************0;0e+00");
11610 assert(ios.width() == 0);
11611 }
11612 }
11613 }
11614 }
11615 }
11616 uppercase(ios);
11617 {
11618 noshowpos(ios);
11619 {
11620 noshowpoint(ios);
11621 {
11622 ios.imbue(lc);
11623 {
11624 ios.width(0);
11625 {
11626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11627 std::string ex(str, iter.base());
11628 assert(ex == "-0.0E+00");
11629 assert(ios.width() == 0);
11630 }
11631 ios.width(25);
11632 left(ios);
11633 {
11634 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11635 std::string ex(str, iter.base());
11636 assert(ex == "-0.0E+00*****************");
11637 assert(ios.width() == 0);
11638 }
11639 ios.width(25);
11640 right(ios);
11641 {
11642 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11643 std::string ex(str, iter.base());
11644 assert(ex == "*****************-0.0E+00");
11645 assert(ios.width() == 0);
11646 }
11647 ios.width(25);
11648 internal(ios);
11649 {
11650 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11651 std::string ex(str, iter.base());
11652 assert(ex == "-*****************0.0E+00");
11653 assert(ios.width() == 0);
11654 }
11655 }
11656 ios.imbue(lg);
11657 {
11658 ios.width(0);
11659 {
11660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11661 std::string ex(str, iter.base());
11662 assert(ex == "-0;0E+00");
11663 assert(ios.width() == 0);
11664 }
11665 ios.width(25);
11666 left(ios);
11667 {
11668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11669 std::string ex(str, iter.base());
11670 assert(ex == "-0;0E+00*****************");
11671 assert(ios.width() == 0);
11672 }
11673 ios.width(25);
11674 right(ios);
11675 {
11676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11677 std::string ex(str, iter.base());
11678 assert(ex == "*****************-0;0E+00");
11679 assert(ios.width() == 0);
11680 }
11681 ios.width(25);
11682 internal(ios);
11683 {
11684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11685 std::string ex(str, iter.base());
11686 assert(ex == "-*****************0;0E+00");
11687 assert(ios.width() == 0);
11688 }
11689 }
11690 }
11691 showpoint(ios);
11692 {
11693 ios.imbue(lc);
11694 {
11695 ios.width(0);
11696 {
11697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11698 std::string ex(str, iter.base());
11699 assert(ex == "-0.0E+00");
11700 assert(ios.width() == 0);
11701 }
11702 ios.width(25);
11703 left(ios);
11704 {
11705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11706 std::string ex(str, iter.base());
11707 assert(ex == "-0.0E+00*****************");
11708 assert(ios.width() == 0);
11709 }
11710 ios.width(25);
11711 right(ios);
11712 {
11713 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11714 std::string ex(str, iter.base());
11715 assert(ex == "*****************-0.0E+00");
11716 assert(ios.width() == 0);
11717 }
11718 ios.width(25);
11719 internal(ios);
11720 {
11721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11722 std::string ex(str, iter.base());
11723 assert(ex == "-*****************0.0E+00");
11724 assert(ios.width() == 0);
11725 }
11726 }
11727 ios.imbue(lg);
11728 {
11729 ios.width(0);
11730 {
11731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11732 std::string ex(str, iter.base());
11733 assert(ex == "-0;0E+00");
11734 assert(ios.width() == 0);
11735 }
11736 ios.width(25);
11737 left(ios);
11738 {
11739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11740 std::string ex(str, iter.base());
11741 assert(ex == "-0;0E+00*****************");
11742 assert(ios.width() == 0);
11743 }
11744 ios.width(25);
11745 right(ios);
11746 {
11747 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11748 std::string ex(str, iter.base());
11749 assert(ex == "*****************-0;0E+00");
11750 assert(ios.width() == 0);
11751 }
11752 ios.width(25);
11753 internal(ios);
11754 {
11755 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11756 std::string ex(str, iter.base());
11757 assert(ex == "-*****************0;0E+00");
11758 assert(ios.width() == 0);
11759 }
11760 }
11761 }
11762 }
11763 showpos(ios);
11764 {
11765 noshowpoint(ios);
11766 {
11767 ios.imbue(lc);
11768 {
11769 ios.width(0);
11770 {
11771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11772 std::string ex(str, iter.base());
11773 assert(ex == "-0.0E+00");
11774 assert(ios.width() == 0);
11775 }
11776 ios.width(25);
11777 left(ios);
11778 {
11779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11780 std::string ex(str, iter.base());
11781 assert(ex == "-0.0E+00*****************");
11782 assert(ios.width() == 0);
11783 }
11784 ios.width(25);
11785 right(ios);
11786 {
11787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11788 std::string ex(str, iter.base());
11789 assert(ex == "*****************-0.0E+00");
11790 assert(ios.width() == 0);
11791 }
11792 ios.width(25);
11793 internal(ios);
11794 {
11795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11796 std::string ex(str, iter.base());
11797 assert(ex == "-*****************0.0E+00");
11798 assert(ios.width() == 0);
11799 }
11800 }
11801 ios.imbue(lg);
11802 {
11803 ios.width(0);
11804 {
11805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11806 std::string ex(str, iter.base());
11807 assert(ex == "-0;0E+00");
11808 assert(ios.width() == 0);
11809 }
11810 ios.width(25);
11811 left(ios);
11812 {
11813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11814 std::string ex(str, iter.base());
11815 assert(ex == "-0;0E+00*****************");
11816 assert(ios.width() == 0);
11817 }
11818 ios.width(25);
11819 right(ios);
11820 {
11821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11822 std::string ex(str, iter.base());
11823 assert(ex == "*****************-0;0E+00");
11824 assert(ios.width() == 0);
11825 }
11826 ios.width(25);
11827 internal(ios);
11828 {
11829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11830 std::string ex(str, iter.base());
11831 assert(ex == "-*****************0;0E+00");
11832 assert(ios.width() == 0);
11833 }
11834 }
11835 }
11836 showpoint(ios);
11837 {
11838 ios.imbue(lc);
11839 {
11840 ios.width(0);
11841 {
11842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11843 std::string ex(str, iter.base());
11844 assert(ex == "-0.0E+00");
11845 assert(ios.width() == 0);
11846 }
11847 ios.width(25);
11848 left(ios);
11849 {
11850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11851 std::string ex(str, iter.base());
11852 assert(ex == "-0.0E+00*****************");
11853 assert(ios.width() == 0);
11854 }
11855 ios.width(25);
11856 right(ios);
11857 {
11858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11859 std::string ex(str, iter.base());
11860 assert(ex == "*****************-0.0E+00");
11861 assert(ios.width() == 0);
11862 }
11863 ios.width(25);
11864 internal(ios);
11865 {
11866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11867 std::string ex(str, iter.base());
11868 assert(ex == "-*****************0.0E+00");
11869 assert(ios.width() == 0);
11870 }
11871 }
11872 ios.imbue(lg);
11873 {
11874 ios.width(0);
11875 {
11876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11877 std::string ex(str, iter.base());
11878 assert(ex == "-0;0E+00");
11879 assert(ios.width() == 0);
11880 }
11881 ios.width(25);
11882 left(ios);
11883 {
11884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11885 std::string ex(str, iter.base());
11886 assert(ex == "-0;0E+00*****************");
11887 assert(ios.width() == 0);
11888 }
11889 ios.width(25);
11890 right(ios);
11891 {
11892 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11893 std::string ex(str, iter.base());
11894 assert(ex == "*****************-0;0E+00");
11895 assert(ios.width() == 0);
11896 }
11897 ios.width(25);
11898 internal(ios);
11899 {
11900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11901 std::string ex(str, iter.base());
11902 assert(ex == "-*****************0;0E+00");
11903 assert(ios.width() == 0);
11904 }
11905 }
11906 }
11907 }
11908 }
11909 }
11910 ios.precision(6);
11911 {
11912 nouppercase(ios);
11913 {
11914 noshowpos(ios);
11915 {
11916 noshowpoint(ios);
11917 {
11918 ios.imbue(lc);
11919 {
11920 ios.width(0);
11921 {
11922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11923 std::string ex(str, iter.base());
11924 assert(ex == "-0.000000e+00");
11925 assert(ios.width() == 0);
11926 }
11927 ios.width(25);
11928 left(ios);
11929 {
11930 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11931 std::string ex(str, iter.base());
11932 assert(ex == "-0.000000e+00************");
11933 assert(ios.width() == 0);
11934 }
11935 ios.width(25);
11936 right(ios);
11937 {
11938 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11939 std::string ex(str, iter.base());
11940 assert(ex == "************-0.000000e+00");
11941 assert(ios.width() == 0);
11942 }
11943 ios.width(25);
11944 internal(ios);
11945 {
11946 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11947 std::string ex(str, iter.base());
11948 assert(ex == "-************0.000000e+00");
11949 assert(ios.width() == 0);
11950 }
11951 }
11952 ios.imbue(lg);
11953 {
11954 ios.width(0);
11955 {
11956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11957 std::string ex(str, iter.base());
11958 assert(ex == "-0;000000e+00");
11959 assert(ios.width() == 0);
11960 }
11961 ios.width(25);
11962 left(ios);
11963 {
11964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11965 std::string ex(str, iter.base());
11966 assert(ex == "-0;000000e+00************");
11967 assert(ios.width() == 0);
11968 }
11969 ios.width(25);
11970 right(ios);
11971 {
11972 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11973 std::string ex(str, iter.base());
11974 assert(ex == "************-0;000000e+00");
11975 assert(ios.width() == 0);
11976 }
11977 ios.width(25);
11978 internal(ios);
11979 {
11980 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11981 std::string ex(str, iter.base());
11982 assert(ex == "-************0;000000e+00");
11983 assert(ios.width() == 0);
11984 }
11985 }
11986 }
11987 showpoint(ios);
11988 {
11989 ios.imbue(lc);
11990 {
11991 ios.width(0);
11992 {
11993 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11994 std::string ex(str, iter.base());
11995 assert(ex == "-0.000000e+00");
11996 assert(ios.width() == 0);
11997 }
11998 ios.width(25);
11999 left(ios);
12000 {
12001 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12002 std::string ex(str, iter.base());
12003 assert(ex == "-0.000000e+00************");
12004 assert(ios.width() == 0);
12005 }
12006 ios.width(25);
12007 right(ios);
12008 {
12009 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12010 std::string ex(str, iter.base());
12011 assert(ex == "************-0.000000e+00");
12012 assert(ios.width() == 0);
12013 }
12014 ios.width(25);
12015 internal(ios);
12016 {
12017 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12018 std::string ex(str, iter.base());
12019 assert(ex == "-************0.000000e+00");
12020 assert(ios.width() == 0);
12021 }
12022 }
12023 ios.imbue(lg);
12024 {
12025 ios.width(0);
12026 {
12027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12028 std::string ex(str, iter.base());
12029 assert(ex == "-0;000000e+00");
12030 assert(ios.width() == 0);
12031 }
12032 ios.width(25);
12033 left(ios);
12034 {
12035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12036 std::string ex(str, iter.base());
12037 assert(ex == "-0;000000e+00************");
12038 assert(ios.width() == 0);
12039 }
12040 ios.width(25);
12041 right(ios);
12042 {
12043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12044 std::string ex(str, iter.base());
12045 assert(ex == "************-0;000000e+00");
12046 assert(ios.width() == 0);
12047 }
12048 ios.width(25);
12049 internal(ios);
12050 {
12051 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12052 std::string ex(str, iter.base());
12053 assert(ex == "-************0;000000e+00");
12054 assert(ios.width() == 0);
12055 }
12056 }
12057 }
12058 }
12059 showpos(ios);
12060 {
12061 noshowpoint(ios);
12062 {
12063 ios.imbue(lc);
12064 {
12065 ios.width(0);
12066 {
12067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12068 std::string ex(str, iter.base());
12069 assert(ex == "-0.000000e+00");
12070 assert(ios.width() == 0);
12071 }
12072 ios.width(25);
12073 left(ios);
12074 {
12075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12076 std::string ex(str, iter.base());
12077 assert(ex == "-0.000000e+00************");
12078 assert(ios.width() == 0);
12079 }
12080 ios.width(25);
12081 right(ios);
12082 {
12083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12084 std::string ex(str, iter.base());
12085 assert(ex == "************-0.000000e+00");
12086 assert(ios.width() == 0);
12087 }
12088 ios.width(25);
12089 internal(ios);
12090 {
12091 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12092 std::string ex(str, iter.base());
12093 assert(ex == "-************0.000000e+00");
12094 assert(ios.width() == 0);
12095 }
12096 }
12097 ios.imbue(lg);
12098 {
12099 ios.width(0);
12100 {
12101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12102 std::string ex(str, iter.base());
12103 assert(ex == "-0;000000e+00");
12104 assert(ios.width() == 0);
12105 }
12106 ios.width(25);
12107 left(ios);
12108 {
12109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12110 std::string ex(str, iter.base());
12111 assert(ex == "-0;000000e+00************");
12112 assert(ios.width() == 0);
12113 }
12114 ios.width(25);
12115 right(ios);
12116 {
12117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12118 std::string ex(str, iter.base());
12119 assert(ex == "************-0;000000e+00");
12120 assert(ios.width() == 0);
12121 }
12122 ios.width(25);
12123 internal(ios);
12124 {
12125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12126 std::string ex(str, iter.base());
12127 assert(ex == "-************0;000000e+00");
12128 assert(ios.width() == 0);
12129 }
12130 }
12131 }
12132 showpoint(ios);
12133 {
12134 ios.imbue(lc);
12135 {
12136 ios.width(0);
12137 {
12138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12139 std::string ex(str, iter.base());
12140 assert(ex == "-0.000000e+00");
12141 assert(ios.width() == 0);
12142 }
12143 ios.width(25);
12144 left(ios);
12145 {
12146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12147 std::string ex(str, iter.base());
12148 assert(ex == "-0.000000e+00************");
12149 assert(ios.width() == 0);
12150 }
12151 ios.width(25);
12152 right(ios);
12153 {
12154 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12155 std::string ex(str, iter.base());
12156 assert(ex == "************-0.000000e+00");
12157 assert(ios.width() == 0);
12158 }
12159 ios.width(25);
12160 internal(ios);
12161 {
12162 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12163 std::string ex(str, iter.base());
12164 assert(ex == "-************0.000000e+00");
12165 assert(ios.width() == 0);
12166 }
12167 }
12168 ios.imbue(lg);
12169 {
12170 ios.width(0);
12171 {
12172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12173 std::string ex(str, iter.base());
12174 assert(ex == "-0;000000e+00");
12175 assert(ios.width() == 0);
12176 }
12177 ios.width(25);
12178 left(ios);
12179 {
12180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12181 std::string ex(str, iter.base());
12182 assert(ex == "-0;000000e+00************");
12183 assert(ios.width() == 0);
12184 }
12185 ios.width(25);
12186 right(ios);
12187 {
12188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12189 std::string ex(str, iter.base());
12190 assert(ex == "************-0;000000e+00");
12191 assert(ios.width() == 0);
12192 }
12193 ios.width(25);
12194 internal(ios);
12195 {
12196 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12197 std::string ex(str, iter.base());
12198 assert(ex == "-************0;000000e+00");
12199 assert(ios.width() == 0);
12200 }
12201 }
12202 }
12203 }
12204 }
12205 uppercase(ios);
12206 {
12207 noshowpos(ios);
12208 {
12209 noshowpoint(ios);
12210 {
12211 ios.imbue(lc);
12212 {
12213 ios.width(0);
12214 {
12215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12216 std::string ex(str, iter.base());
12217 assert(ex == "-0.000000E+00");
12218 assert(ios.width() == 0);
12219 }
12220 ios.width(25);
12221 left(ios);
12222 {
12223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12224 std::string ex(str, iter.base());
12225 assert(ex == "-0.000000E+00************");
12226 assert(ios.width() == 0);
12227 }
12228 ios.width(25);
12229 right(ios);
12230 {
12231 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12232 std::string ex(str, iter.base());
12233 assert(ex == "************-0.000000E+00");
12234 assert(ios.width() == 0);
12235 }
12236 ios.width(25);
12237 internal(ios);
12238 {
12239 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12240 std::string ex(str, iter.base());
12241 assert(ex == "-************0.000000E+00");
12242 assert(ios.width() == 0);
12243 }
12244 }
12245 ios.imbue(lg);
12246 {
12247 ios.width(0);
12248 {
12249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12250 std::string ex(str, iter.base());
12251 assert(ex == "-0;000000E+00");
12252 assert(ios.width() == 0);
12253 }
12254 ios.width(25);
12255 left(ios);
12256 {
12257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12258 std::string ex(str, iter.base());
12259 assert(ex == "-0;000000E+00************");
12260 assert(ios.width() == 0);
12261 }
12262 ios.width(25);
12263 right(ios);
12264 {
12265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12266 std::string ex(str, iter.base());
12267 assert(ex == "************-0;000000E+00");
12268 assert(ios.width() == 0);
12269 }
12270 ios.width(25);
12271 internal(ios);
12272 {
12273 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12274 std::string ex(str, iter.base());
12275 assert(ex == "-************0;000000E+00");
12276 assert(ios.width() == 0);
12277 }
12278 }
12279 }
12280 showpoint(ios);
12281 {
12282 ios.imbue(lc);
12283 {
12284 ios.width(0);
12285 {
12286 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12287 std::string ex(str, iter.base());
12288 assert(ex == "-0.000000E+00");
12289 assert(ios.width() == 0);
12290 }
12291 ios.width(25);
12292 left(ios);
12293 {
12294 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12295 std::string ex(str, iter.base());
12296 assert(ex == "-0.000000E+00************");
12297 assert(ios.width() == 0);
12298 }
12299 ios.width(25);
12300 right(ios);
12301 {
12302 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12303 std::string ex(str, iter.base());
12304 assert(ex == "************-0.000000E+00");
12305 assert(ios.width() == 0);
12306 }
12307 ios.width(25);
12308 internal(ios);
12309 {
12310 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12311 std::string ex(str, iter.base());
12312 assert(ex == "-************0.000000E+00");
12313 assert(ios.width() == 0);
12314 }
12315 }
12316 ios.imbue(lg);
12317 {
12318 ios.width(0);
12319 {
12320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12321 std::string ex(str, iter.base());
12322 assert(ex == "-0;000000E+00");
12323 assert(ios.width() == 0);
12324 }
12325 ios.width(25);
12326 left(ios);
12327 {
12328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12329 std::string ex(str, iter.base());
12330 assert(ex == "-0;000000E+00************");
12331 assert(ios.width() == 0);
12332 }
12333 ios.width(25);
12334 right(ios);
12335 {
12336 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12337 std::string ex(str, iter.base());
12338 assert(ex == "************-0;000000E+00");
12339 assert(ios.width() == 0);
12340 }
12341 ios.width(25);
12342 internal(ios);
12343 {
12344 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12345 std::string ex(str, iter.base());
12346 assert(ex == "-************0;000000E+00");
12347 assert(ios.width() == 0);
12348 }
12349 }
12350 }
12351 }
12352 showpos(ios);
12353 {
12354 noshowpoint(ios);
12355 {
12356 ios.imbue(lc);
12357 {
12358 ios.width(0);
12359 {
12360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12361 std::string ex(str, iter.base());
12362 assert(ex == "-0.000000E+00");
12363 assert(ios.width() == 0);
12364 }
12365 ios.width(25);
12366 left(ios);
12367 {
12368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12369 std::string ex(str, iter.base());
12370 assert(ex == "-0.000000E+00************");
12371 assert(ios.width() == 0);
12372 }
12373 ios.width(25);
12374 right(ios);
12375 {
12376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12377 std::string ex(str, iter.base());
12378 assert(ex == "************-0.000000E+00");
12379 assert(ios.width() == 0);
12380 }
12381 ios.width(25);
12382 internal(ios);
12383 {
12384 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12385 std::string ex(str, iter.base());
12386 assert(ex == "-************0.000000E+00");
12387 assert(ios.width() == 0);
12388 }
12389 }
12390 ios.imbue(lg);
12391 {
12392 ios.width(0);
12393 {
12394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12395 std::string ex(str, iter.base());
12396 assert(ex == "-0;000000E+00");
12397 assert(ios.width() == 0);
12398 }
12399 ios.width(25);
12400 left(ios);
12401 {
12402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12403 std::string ex(str, iter.base());
12404 assert(ex == "-0;000000E+00************");
12405 assert(ios.width() == 0);
12406 }
12407 ios.width(25);
12408 right(ios);
12409 {
12410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12411 std::string ex(str, iter.base());
12412 assert(ex == "************-0;000000E+00");
12413 assert(ios.width() == 0);
12414 }
12415 ios.width(25);
12416 internal(ios);
12417 {
12418 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12419 std::string ex(str, iter.base());
12420 assert(ex == "-************0;000000E+00");
12421 assert(ios.width() == 0);
12422 }
12423 }
12424 }
12425 showpoint(ios);
12426 {
12427 ios.imbue(lc);
12428 {
12429 ios.width(0);
12430 {
12431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12432 std::string ex(str, iter.base());
12433 assert(ex == "-0.000000E+00");
12434 assert(ios.width() == 0);
12435 }
12436 ios.width(25);
12437 left(ios);
12438 {
12439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12440 std::string ex(str, iter.base());
12441 assert(ex == "-0.000000E+00************");
12442 assert(ios.width() == 0);
12443 }
12444 ios.width(25);
12445 right(ios);
12446 {
12447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12448 std::string ex(str, iter.base());
12449 assert(ex == "************-0.000000E+00");
12450 assert(ios.width() == 0);
12451 }
12452 ios.width(25);
12453 internal(ios);
12454 {
12455 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12456 std::string ex(str, iter.base());
12457 assert(ex == "-************0.000000E+00");
12458 assert(ios.width() == 0);
12459 }
12460 }
12461 ios.imbue(lg);
12462 {
12463 ios.width(0);
12464 {
12465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12466 std::string ex(str, iter.base());
12467 assert(ex == "-0;000000E+00");
12468 assert(ios.width() == 0);
12469 }
12470 ios.width(25);
12471 left(ios);
12472 {
12473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12474 std::string ex(str, iter.base());
12475 assert(ex == "-0;000000E+00************");
12476 assert(ios.width() == 0);
12477 }
12478 ios.width(25);
12479 right(ios);
12480 {
12481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12482 std::string ex(str, iter.base());
12483 assert(ex == "************-0;000000E+00");
12484 assert(ios.width() == 0);
12485 }
12486 ios.width(25);
12487 internal(ios);
12488 {
12489 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12490 std::string ex(str, iter.base());
12491 assert(ex == "-************0;000000E+00");
12492 assert(ios.width() == 0);
12493 }
12494 }
12495 }
12496 }
12497 }
12498 }
12499 ios.precision(16);
12500 {
12501 }
12502 ios.precision(60);
12503 {
12504 }
12505 }
12506 }
12507 }
12508
test6()12509 void test6()
12510 {
12511 char str[200];
12512 output_iterator<char*> iter;
12513 std::locale lc = std::locale::classic();
12514 std::locale lg(lc, new my_numpunct);
12515 const my_facet f(1);
12516 {
12517 double v = 1234567890.125;
12518 std::ios ios(0);
12519 scientific(ios);
12520 // %e
12521 {
12522 ios.precision(0);
12523 {
12524 nouppercase(ios);
12525 {
12526 noshowpos(ios);
12527 {
12528 noshowpoint(ios);
12529 {
12530 ios.imbue(lc);
12531 {
12532 ios.width(0);
12533 {
12534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12535 std::string ex(str, iter.base());
12536 assert(ex == "1e+09");
12537 assert(ios.width() == 0);
12538 }
12539 ios.width(25);
12540 left(ios);
12541 {
12542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12543 std::string ex(str, iter.base());
12544 assert(ex == "1e+09********************");
12545 assert(ios.width() == 0);
12546 }
12547 ios.width(25);
12548 right(ios);
12549 {
12550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12551 std::string ex(str, iter.base());
12552 assert(ex == "********************1e+09");
12553 assert(ios.width() == 0);
12554 }
12555 ios.width(25);
12556 internal(ios);
12557 {
12558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12559 std::string ex(str, iter.base());
12560 assert(ex == "********************1e+09");
12561 assert(ios.width() == 0);
12562 }
12563 }
12564 ios.imbue(lg);
12565 {
12566 ios.width(0);
12567 {
12568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12569 std::string ex(str, iter.base());
12570 assert(ex == "1e+09");
12571 assert(ios.width() == 0);
12572 }
12573 ios.width(25);
12574 left(ios);
12575 {
12576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12577 std::string ex(str, iter.base());
12578 assert(ex == "1e+09********************");
12579 assert(ios.width() == 0);
12580 }
12581 ios.width(25);
12582 right(ios);
12583 {
12584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12585 std::string ex(str, iter.base());
12586 assert(ex == "********************1e+09");
12587 assert(ios.width() == 0);
12588 }
12589 ios.width(25);
12590 internal(ios);
12591 {
12592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12593 std::string ex(str, iter.base());
12594 assert(ex == "********************1e+09");
12595 assert(ios.width() == 0);
12596 }
12597 }
12598 }
12599 showpoint(ios);
12600 {
12601 ios.imbue(lc);
12602 {
12603 ios.width(0);
12604 {
12605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12606 std::string ex(str, iter.base());
12607 assert(ex == "1.e+09");
12608 assert(ios.width() == 0);
12609 }
12610 ios.width(25);
12611 left(ios);
12612 {
12613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12614 std::string ex(str, iter.base());
12615 assert(ex == "1.e+09*******************");
12616 assert(ios.width() == 0);
12617 }
12618 ios.width(25);
12619 right(ios);
12620 {
12621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12622 std::string ex(str, iter.base());
12623 assert(ex == "*******************1.e+09");
12624 assert(ios.width() == 0);
12625 }
12626 ios.width(25);
12627 internal(ios);
12628 {
12629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12630 std::string ex(str, iter.base());
12631 assert(ex == "*******************1.e+09");
12632 assert(ios.width() == 0);
12633 }
12634 }
12635 ios.imbue(lg);
12636 {
12637 ios.width(0);
12638 {
12639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12640 std::string ex(str, iter.base());
12641 assert(ex == "1;e+09");
12642 assert(ios.width() == 0);
12643 }
12644 ios.width(25);
12645 left(ios);
12646 {
12647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12648 std::string ex(str, iter.base());
12649 assert(ex == "1;e+09*******************");
12650 assert(ios.width() == 0);
12651 }
12652 ios.width(25);
12653 right(ios);
12654 {
12655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12656 std::string ex(str, iter.base());
12657 assert(ex == "*******************1;e+09");
12658 assert(ios.width() == 0);
12659 }
12660 ios.width(25);
12661 internal(ios);
12662 {
12663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12664 std::string ex(str, iter.base());
12665 assert(ex == "*******************1;e+09");
12666 assert(ios.width() == 0);
12667 }
12668 }
12669 }
12670 }
12671 showpos(ios);
12672 {
12673 noshowpoint(ios);
12674 {
12675 ios.imbue(lc);
12676 {
12677 ios.width(0);
12678 {
12679 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12680 std::string ex(str, iter.base());
12681 assert(ex == "+1e+09");
12682 assert(ios.width() == 0);
12683 }
12684 ios.width(25);
12685 left(ios);
12686 {
12687 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12688 std::string ex(str, iter.base());
12689 assert(ex == "+1e+09*******************");
12690 assert(ios.width() == 0);
12691 }
12692 ios.width(25);
12693 right(ios);
12694 {
12695 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12696 std::string ex(str, iter.base());
12697 assert(ex == "*******************+1e+09");
12698 assert(ios.width() == 0);
12699 }
12700 ios.width(25);
12701 internal(ios);
12702 {
12703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12704 std::string ex(str, iter.base());
12705 assert(ex == "+*******************1e+09");
12706 assert(ios.width() == 0);
12707 }
12708 }
12709 ios.imbue(lg);
12710 {
12711 ios.width(0);
12712 {
12713 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12714 std::string ex(str, iter.base());
12715 assert(ex == "+1e+09");
12716 assert(ios.width() == 0);
12717 }
12718 ios.width(25);
12719 left(ios);
12720 {
12721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12722 std::string ex(str, iter.base());
12723 assert(ex == "+1e+09*******************");
12724 assert(ios.width() == 0);
12725 }
12726 ios.width(25);
12727 right(ios);
12728 {
12729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12730 std::string ex(str, iter.base());
12731 assert(ex == "*******************+1e+09");
12732 assert(ios.width() == 0);
12733 }
12734 ios.width(25);
12735 internal(ios);
12736 {
12737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12738 std::string ex(str, iter.base());
12739 assert(ex == "+*******************1e+09");
12740 assert(ios.width() == 0);
12741 }
12742 }
12743 }
12744 showpoint(ios);
12745 {
12746 ios.imbue(lc);
12747 {
12748 ios.width(0);
12749 {
12750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12751 std::string ex(str, iter.base());
12752 assert(ex == "+1.e+09");
12753 assert(ios.width() == 0);
12754 }
12755 ios.width(25);
12756 left(ios);
12757 {
12758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12759 std::string ex(str, iter.base());
12760 assert(ex == "+1.e+09******************");
12761 assert(ios.width() == 0);
12762 }
12763 ios.width(25);
12764 right(ios);
12765 {
12766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12767 std::string ex(str, iter.base());
12768 assert(ex == "******************+1.e+09");
12769 assert(ios.width() == 0);
12770 }
12771 ios.width(25);
12772 internal(ios);
12773 {
12774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12775 std::string ex(str, iter.base());
12776 assert(ex == "+******************1.e+09");
12777 assert(ios.width() == 0);
12778 }
12779 }
12780 ios.imbue(lg);
12781 {
12782 ios.width(0);
12783 {
12784 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12785 std::string ex(str, iter.base());
12786 assert(ex == "+1;e+09");
12787 assert(ios.width() == 0);
12788 }
12789 ios.width(25);
12790 left(ios);
12791 {
12792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12793 std::string ex(str, iter.base());
12794 assert(ex == "+1;e+09******************");
12795 assert(ios.width() == 0);
12796 }
12797 ios.width(25);
12798 right(ios);
12799 {
12800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12801 std::string ex(str, iter.base());
12802 assert(ex == "******************+1;e+09");
12803 assert(ios.width() == 0);
12804 }
12805 ios.width(25);
12806 internal(ios);
12807 {
12808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12809 std::string ex(str, iter.base());
12810 assert(ex == "+******************1;e+09");
12811 assert(ios.width() == 0);
12812 }
12813 }
12814 }
12815 }
12816 }
12817 uppercase(ios);
12818 {
12819 noshowpos(ios);
12820 {
12821 noshowpoint(ios);
12822 {
12823 ios.imbue(lc);
12824 {
12825 ios.width(0);
12826 {
12827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12828 std::string ex(str, iter.base());
12829 assert(ex == "1E+09");
12830 assert(ios.width() == 0);
12831 }
12832 ios.width(25);
12833 left(ios);
12834 {
12835 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12836 std::string ex(str, iter.base());
12837 assert(ex == "1E+09********************");
12838 assert(ios.width() == 0);
12839 }
12840 ios.width(25);
12841 right(ios);
12842 {
12843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12844 std::string ex(str, iter.base());
12845 assert(ex == "********************1E+09");
12846 assert(ios.width() == 0);
12847 }
12848 ios.width(25);
12849 internal(ios);
12850 {
12851 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12852 std::string ex(str, iter.base());
12853 assert(ex == "********************1E+09");
12854 assert(ios.width() == 0);
12855 }
12856 }
12857 ios.imbue(lg);
12858 {
12859 ios.width(0);
12860 {
12861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12862 std::string ex(str, iter.base());
12863 assert(ex == "1E+09");
12864 assert(ios.width() == 0);
12865 }
12866 ios.width(25);
12867 left(ios);
12868 {
12869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12870 std::string ex(str, iter.base());
12871 assert(ex == "1E+09********************");
12872 assert(ios.width() == 0);
12873 }
12874 ios.width(25);
12875 right(ios);
12876 {
12877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12878 std::string ex(str, iter.base());
12879 assert(ex == "********************1E+09");
12880 assert(ios.width() == 0);
12881 }
12882 ios.width(25);
12883 internal(ios);
12884 {
12885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12886 std::string ex(str, iter.base());
12887 assert(ex == "********************1E+09");
12888 assert(ios.width() == 0);
12889 }
12890 }
12891 }
12892 showpoint(ios);
12893 {
12894 ios.imbue(lc);
12895 {
12896 ios.width(0);
12897 {
12898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12899 std::string ex(str, iter.base());
12900 assert(ex == "1.E+09");
12901 assert(ios.width() == 0);
12902 }
12903 ios.width(25);
12904 left(ios);
12905 {
12906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12907 std::string ex(str, iter.base());
12908 assert(ex == "1.E+09*******************");
12909 assert(ios.width() == 0);
12910 }
12911 ios.width(25);
12912 right(ios);
12913 {
12914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12915 std::string ex(str, iter.base());
12916 assert(ex == "*******************1.E+09");
12917 assert(ios.width() == 0);
12918 }
12919 ios.width(25);
12920 internal(ios);
12921 {
12922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12923 std::string ex(str, iter.base());
12924 assert(ex == "*******************1.E+09");
12925 assert(ios.width() == 0);
12926 }
12927 }
12928 ios.imbue(lg);
12929 {
12930 ios.width(0);
12931 {
12932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12933 std::string ex(str, iter.base());
12934 assert(ex == "1;E+09");
12935 assert(ios.width() == 0);
12936 }
12937 ios.width(25);
12938 left(ios);
12939 {
12940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12941 std::string ex(str, iter.base());
12942 assert(ex == "1;E+09*******************");
12943 assert(ios.width() == 0);
12944 }
12945 ios.width(25);
12946 right(ios);
12947 {
12948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12949 std::string ex(str, iter.base());
12950 assert(ex == "*******************1;E+09");
12951 assert(ios.width() == 0);
12952 }
12953 ios.width(25);
12954 internal(ios);
12955 {
12956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12957 std::string ex(str, iter.base());
12958 assert(ex == "*******************1;E+09");
12959 assert(ios.width() == 0);
12960 }
12961 }
12962 }
12963 }
12964 showpos(ios);
12965 {
12966 noshowpoint(ios);
12967 {
12968 ios.imbue(lc);
12969 {
12970 ios.width(0);
12971 {
12972 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12973 std::string ex(str, iter.base());
12974 assert(ex == "+1E+09");
12975 assert(ios.width() == 0);
12976 }
12977 ios.width(25);
12978 left(ios);
12979 {
12980 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12981 std::string ex(str, iter.base());
12982 assert(ex == "+1E+09*******************");
12983 assert(ios.width() == 0);
12984 }
12985 ios.width(25);
12986 right(ios);
12987 {
12988 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12989 std::string ex(str, iter.base());
12990 assert(ex == "*******************+1E+09");
12991 assert(ios.width() == 0);
12992 }
12993 ios.width(25);
12994 internal(ios);
12995 {
12996 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12997 std::string ex(str, iter.base());
12998 assert(ex == "+*******************1E+09");
12999 assert(ios.width() == 0);
13000 }
13001 }
13002 ios.imbue(lg);
13003 {
13004 ios.width(0);
13005 {
13006 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13007 std::string ex(str, iter.base());
13008 assert(ex == "+1E+09");
13009 assert(ios.width() == 0);
13010 }
13011 ios.width(25);
13012 left(ios);
13013 {
13014 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13015 std::string ex(str, iter.base());
13016 assert(ex == "+1E+09*******************");
13017 assert(ios.width() == 0);
13018 }
13019 ios.width(25);
13020 right(ios);
13021 {
13022 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13023 std::string ex(str, iter.base());
13024 assert(ex == "*******************+1E+09");
13025 assert(ios.width() == 0);
13026 }
13027 ios.width(25);
13028 internal(ios);
13029 {
13030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13031 std::string ex(str, iter.base());
13032 assert(ex == "+*******************1E+09");
13033 assert(ios.width() == 0);
13034 }
13035 }
13036 }
13037 showpoint(ios);
13038 {
13039 ios.imbue(lc);
13040 {
13041 ios.width(0);
13042 {
13043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13044 std::string ex(str, iter.base());
13045 assert(ex == "+1.E+09");
13046 assert(ios.width() == 0);
13047 }
13048 ios.width(25);
13049 left(ios);
13050 {
13051 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13052 std::string ex(str, iter.base());
13053 assert(ex == "+1.E+09******************");
13054 assert(ios.width() == 0);
13055 }
13056 ios.width(25);
13057 right(ios);
13058 {
13059 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13060 std::string ex(str, iter.base());
13061 assert(ex == "******************+1.E+09");
13062 assert(ios.width() == 0);
13063 }
13064 ios.width(25);
13065 internal(ios);
13066 {
13067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13068 std::string ex(str, iter.base());
13069 assert(ex == "+******************1.E+09");
13070 assert(ios.width() == 0);
13071 }
13072 }
13073 ios.imbue(lg);
13074 {
13075 ios.width(0);
13076 {
13077 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13078 std::string ex(str, iter.base());
13079 assert(ex == "+1;E+09");
13080 assert(ios.width() == 0);
13081 }
13082 ios.width(25);
13083 left(ios);
13084 {
13085 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13086 std::string ex(str, iter.base());
13087 assert(ex == "+1;E+09******************");
13088 assert(ios.width() == 0);
13089 }
13090 ios.width(25);
13091 right(ios);
13092 {
13093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13094 std::string ex(str, iter.base());
13095 assert(ex == "******************+1;E+09");
13096 assert(ios.width() == 0);
13097 }
13098 ios.width(25);
13099 internal(ios);
13100 {
13101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13102 std::string ex(str, iter.base());
13103 assert(ex == "+******************1;E+09");
13104 assert(ios.width() == 0);
13105 }
13106 }
13107 }
13108 }
13109 }
13110 }
13111 ios.precision(1);
13112 {
13113 nouppercase(ios);
13114 {
13115 noshowpos(ios);
13116 {
13117 noshowpoint(ios);
13118 {
13119 ios.imbue(lc);
13120 {
13121 ios.width(0);
13122 {
13123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13124 std::string ex(str, iter.base());
13125 assert(ex == "1.2e+09");
13126 assert(ios.width() == 0);
13127 }
13128 ios.width(25);
13129 left(ios);
13130 {
13131 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13132 std::string ex(str, iter.base());
13133 assert(ex == "1.2e+09******************");
13134 assert(ios.width() == 0);
13135 }
13136 ios.width(25);
13137 right(ios);
13138 {
13139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13140 std::string ex(str, iter.base());
13141 assert(ex == "******************1.2e+09");
13142 assert(ios.width() == 0);
13143 }
13144 ios.width(25);
13145 internal(ios);
13146 {
13147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13148 std::string ex(str, iter.base());
13149 assert(ex == "******************1.2e+09");
13150 assert(ios.width() == 0);
13151 }
13152 }
13153 ios.imbue(lg);
13154 {
13155 ios.width(0);
13156 {
13157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13158 std::string ex(str, iter.base());
13159 assert(ex == "1;2e+09");
13160 assert(ios.width() == 0);
13161 }
13162 ios.width(25);
13163 left(ios);
13164 {
13165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13166 std::string ex(str, iter.base());
13167 assert(ex == "1;2e+09******************");
13168 assert(ios.width() == 0);
13169 }
13170 ios.width(25);
13171 right(ios);
13172 {
13173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13174 std::string ex(str, iter.base());
13175 assert(ex == "******************1;2e+09");
13176 assert(ios.width() == 0);
13177 }
13178 ios.width(25);
13179 internal(ios);
13180 {
13181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13182 std::string ex(str, iter.base());
13183 assert(ex == "******************1;2e+09");
13184 assert(ios.width() == 0);
13185 }
13186 }
13187 }
13188 showpoint(ios);
13189 {
13190 ios.imbue(lc);
13191 {
13192 ios.width(0);
13193 {
13194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13195 std::string ex(str, iter.base());
13196 assert(ex == "1.2e+09");
13197 assert(ios.width() == 0);
13198 }
13199 ios.width(25);
13200 left(ios);
13201 {
13202 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13203 std::string ex(str, iter.base());
13204 assert(ex == "1.2e+09******************");
13205 assert(ios.width() == 0);
13206 }
13207 ios.width(25);
13208 right(ios);
13209 {
13210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13211 std::string ex(str, iter.base());
13212 assert(ex == "******************1.2e+09");
13213 assert(ios.width() == 0);
13214 }
13215 ios.width(25);
13216 internal(ios);
13217 {
13218 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13219 std::string ex(str, iter.base());
13220 assert(ex == "******************1.2e+09");
13221 assert(ios.width() == 0);
13222 }
13223 }
13224 ios.imbue(lg);
13225 {
13226 ios.width(0);
13227 {
13228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13229 std::string ex(str, iter.base());
13230 assert(ex == "1;2e+09");
13231 assert(ios.width() == 0);
13232 }
13233 ios.width(25);
13234 left(ios);
13235 {
13236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13237 std::string ex(str, iter.base());
13238 assert(ex == "1;2e+09******************");
13239 assert(ios.width() == 0);
13240 }
13241 ios.width(25);
13242 right(ios);
13243 {
13244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13245 std::string ex(str, iter.base());
13246 assert(ex == "******************1;2e+09");
13247 assert(ios.width() == 0);
13248 }
13249 ios.width(25);
13250 internal(ios);
13251 {
13252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13253 std::string ex(str, iter.base());
13254 assert(ex == "******************1;2e+09");
13255 assert(ios.width() == 0);
13256 }
13257 }
13258 }
13259 }
13260 showpos(ios);
13261 {
13262 noshowpoint(ios);
13263 {
13264 ios.imbue(lc);
13265 {
13266 ios.width(0);
13267 {
13268 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13269 std::string ex(str, iter.base());
13270 assert(ex == "+1.2e+09");
13271 assert(ios.width() == 0);
13272 }
13273 ios.width(25);
13274 left(ios);
13275 {
13276 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13277 std::string ex(str, iter.base());
13278 assert(ex == "+1.2e+09*****************");
13279 assert(ios.width() == 0);
13280 }
13281 ios.width(25);
13282 right(ios);
13283 {
13284 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13285 std::string ex(str, iter.base());
13286 assert(ex == "*****************+1.2e+09");
13287 assert(ios.width() == 0);
13288 }
13289 ios.width(25);
13290 internal(ios);
13291 {
13292 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13293 std::string ex(str, iter.base());
13294 assert(ex == "+*****************1.2e+09");
13295 assert(ios.width() == 0);
13296 }
13297 }
13298 ios.imbue(lg);
13299 {
13300 ios.width(0);
13301 {
13302 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13303 std::string ex(str, iter.base());
13304 assert(ex == "+1;2e+09");
13305 assert(ios.width() == 0);
13306 }
13307 ios.width(25);
13308 left(ios);
13309 {
13310 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13311 std::string ex(str, iter.base());
13312 assert(ex == "+1;2e+09*****************");
13313 assert(ios.width() == 0);
13314 }
13315 ios.width(25);
13316 right(ios);
13317 {
13318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13319 std::string ex(str, iter.base());
13320 assert(ex == "*****************+1;2e+09");
13321 assert(ios.width() == 0);
13322 }
13323 ios.width(25);
13324 internal(ios);
13325 {
13326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13327 std::string ex(str, iter.base());
13328 assert(ex == "+*****************1;2e+09");
13329 assert(ios.width() == 0);
13330 }
13331 }
13332 }
13333 showpoint(ios);
13334 {
13335 ios.imbue(lc);
13336 {
13337 ios.width(0);
13338 {
13339 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13340 std::string ex(str, iter.base());
13341 assert(ex == "+1.2e+09");
13342 assert(ios.width() == 0);
13343 }
13344 ios.width(25);
13345 left(ios);
13346 {
13347 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13348 std::string ex(str, iter.base());
13349 assert(ex == "+1.2e+09*****************");
13350 assert(ios.width() == 0);
13351 }
13352 ios.width(25);
13353 right(ios);
13354 {
13355 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13356 std::string ex(str, iter.base());
13357 assert(ex == "*****************+1.2e+09");
13358 assert(ios.width() == 0);
13359 }
13360 ios.width(25);
13361 internal(ios);
13362 {
13363 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13364 std::string ex(str, iter.base());
13365 assert(ex == "+*****************1.2e+09");
13366 assert(ios.width() == 0);
13367 }
13368 }
13369 ios.imbue(lg);
13370 {
13371 ios.width(0);
13372 {
13373 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13374 std::string ex(str, iter.base());
13375 assert(ex == "+1;2e+09");
13376 assert(ios.width() == 0);
13377 }
13378 ios.width(25);
13379 left(ios);
13380 {
13381 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13382 std::string ex(str, iter.base());
13383 assert(ex == "+1;2e+09*****************");
13384 assert(ios.width() == 0);
13385 }
13386 ios.width(25);
13387 right(ios);
13388 {
13389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13390 std::string ex(str, iter.base());
13391 assert(ex == "*****************+1;2e+09");
13392 assert(ios.width() == 0);
13393 }
13394 ios.width(25);
13395 internal(ios);
13396 {
13397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13398 std::string ex(str, iter.base());
13399 assert(ex == "+*****************1;2e+09");
13400 assert(ios.width() == 0);
13401 }
13402 }
13403 }
13404 }
13405 }
13406 uppercase(ios);
13407 {
13408 noshowpos(ios);
13409 {
13410 noshowpoint(ios);
13411 {
13412 ios.imbue(lc);
13413 {
13414 ios.width(0);
13415 {
13416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13417 std::string ex(str, iter.base());
13418 assert(ex == "1.2E+09");
13419 assert(ios.width() == 0);
13420 }
13421 ios.width(25);
13422 left(ios);
13423 {
13424 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13425 std::string ex(str, iter.base());
13426 assert(ex == "1.2E+09******************");
13427 assert(ios.width() == 0);
13428 }
13429 ios.width(25);
13430 right(ios);
13431 {
13432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13433 std::string ex(str, iter.base());
13434 assert(ex == "******************1.2E+09");
13435 assert(ios.width() == 0);
13436 }
13437 ios.width(25);
13438 internal(ios);
13439 {
13440 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13441 std::string ex(str, iter.base());
13442 assert(ex == "******************1.2E+09");
13443 assert(ios.width() == 0);
13444 }
13445 }
13446 ios.imbue(lg);
13447 {
13448 ios.width(0);
13449 {
13450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13451 std::string ex(str, iter.base());
13452 assert(ex == "1;2E+09");
13453 assert(ios.width() == 0);
13454 }
13455 ios.width(25);
13456 left(ios);
13457 {
13458 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13459 std::string ex(str, iter.base());
13460 assert(ex == "1;2E+09******************");
13461 assert(ios.width() == 0);
13462 }
13463 ios.width(25);
13464 right(ios);
13465 {
13466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13467 std::string ex(str, iter.base());
13468 assert(ex == "******************1;2E+09");
13469 assert(ios.width() == 0);
13470 }
13471 ios.width(25);
13472 internal(ios);
13473 {
13474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13475 std::string ex(str, iter.base());
13476 assert(ex == "******************1;2E+09");
13477 assert(ios.width() == 0);
13478 }
13479 }
13480 }
13481 showpoint(ios);
13482 {
13483 ios.imbue(lc);
13484 {
13485 ios.width(0);
13486 {
13487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13488 std::string ex(str, iter.base());
13489 assert(ex == "1.2E+09");
13490 assert(ios.width() == 0);
13491 }
13492 ios.width(25);
13493 left(ios);
13494 {
13495 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13496 std::string ex(str, iter.base());
13497 assert(ex == "1.2E+09******************");
13498 assert(ios.width() == 0);
13499 }
13500 ios.width(25);
13501 right(ios);
13502 {
13503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13504 std::string ex(str, iter.base());
13505 assert(ex == "******************1.2E+09");
13506 assert(ios.width() == 0);
13507 }
13508 ios.width(25);
13509 internal(ios);
13510 {
13511 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13512 std::string ex(str, iter.base());
13513 assert(ex == "******************1.2E+09");
13514 assert(ios.width() == 0);
13515 }
13516 }
13517 ios.imbue(lg);
13518 {
13519 ios.width(0);
13520 {
13521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13522 std::string ex(str, iter.base());
13523 assert(ex == "1;2E+09");
13524 assert(ios.width() == 0);
13525 }
13526 ios.width(25);
13527 left(ios);
13528 {
13529 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13530 std::string ex(str, iter.base());
13531 assert(ex == "1;2E+09******************");
13532 assert(ios.width() == 0);
13533 }
13534 ios.width(25);
13535 right(ios);
13536 {
13537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13538 std::string ex(str, iter.base());
13539 assert(ex == "******************1;2E+09");
13540 assert(ios.width() == 0);
13541 }
13542 ios.width(25);
13543 internal(ios);
13544 {
13545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13546 std::string ex(str, iter.base());
13547 assert(ex == "******************1;2E+09");
13548 assert(ios.width() == 0);
13549 }
13550 }
13551 }
13552 }
13553 showpos(ios);
13554 {
13555 noshowpoint(ios);
13556 {
13557 ios.imbue(lc);
13558 {
13559 ios.width(0);
13560 {
13561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13562 std::string ex(str, iter.base());
13563 assert(ex == "+1.2E+09");
13564 assert(ios.width() == 0);
13565 }
13566 ios.width(25);
13567 left(ios);
13568 {
13569 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13570 std::string ex(str, iter.base());
13571 assert(ex == "+1.2E+09*****************");
13572 assert(ios.width() == 0);
13573 }
13574 ios.width(25);
13575 right(ios);
13576 {
13577 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13578 std::string ex(str, iter.base());
13579 assert(ex == "*****************+1.2E+09");
13580 assert(ios.width() == 0);
13581 }
13582 ios.width(25);
13583 internal(ios);
13584 {
13585 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13586 std::string ex(str, iter.base());
13587 assert(ex == "+*****************1.2E+09");
13588 assert(ios.width() == 0);
13589 }
13590 }
13591 ios.imbue(lg);
13592 {
13593 ios.width(0);
13594 {
13595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13596 std::string ex(str, iter.base());
13597 assert(ex == "+1;2E+09");
13598 assert(ios.width() == 0);
13599 }
13600 ios.width(25);
13601 left(ios);
13602 {
13603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13604 std::string ex(str, iter.base());
13605 assert(ex == "+1;2E+09*****************");
13606 assert(ios.width() == 0);
13607 }
13608 ios.width(25);
13609 right(ios);
13610 {
13611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13612 std::string ex(str, iter.base());
13613 assert(ex == "*****************+1;2E+09");
13614 assert(ios.width() == 0);
13615 }
13616 ios.width(25);
13617 internal(ios);
13618 {
13619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13620 std::string ex(str, iter.base());
13621 assert(ex == "+*****************1;2E+09");
13622 assert(ios.width() == 0);
13623 }
13624 }
13625 }
13626 showpoint(ios);
13627 {
13628 ios.imbue(lc);
13629 {
13630 ios.width(0);
13631 {
13632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13633 std::string ex(str, iter.base());
13634 assert(ex == "+1.2E+09");
13635 assert(ios.width() == 0);
13636 }
13637 ios.width(25);
13638 left(ios);
13639 {
13640 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13641 std::string ex(str, iter.base());
13642 assert(ex == "+1.2E+09*****************");
13643 assert(ios.width() == 0);
13644 }
13645 ios.width(25);
13646 right(ios);
13647 {
13648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13649 std::string ex(str, iter.base());
13650 assert(ex == "*****************+1.2E+09");
13651 assert(ios.width() == 0);
13652 }
13653 ios.width(25);
13654 internal(ios);
13655 {
13656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13657 std::string ex(str, iter.base());
13658 assert(ex == "+*****************1.2E+09");
13659 assert(ios.width() == 0);
13660 }
13661 }
13662 ios.imbue(lg);
13663 {
13664 ios.width(0);
13665 {
13666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13667 std::string ex(str, iter.base());
13668 assert(ex == "+1;2E+09");
13669 assert(ios.width() == 0);
13670 }
13671 ios.width(25);
13672 left(ios);
13673 {
13674 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13675 std::string ex(str, iter.base());
13676 assert(ex == "+1;2E+09*****************");
13677 assert(ios.width() == 0);
13678 }
13679 ios.width(25);
13680 right(ios);
13681 {
13682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13683 std::string ex(str, iter.base());
13684 assert(ex == "*****************+1;2E+09");
13685 assert(ios.width() == 0);
13686 }
13687 ios.width(25);
13688 internal(ios);
13689 {
13690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13691 std::string ex(str, iter.base());
13692 assert(ex == "+*****************1;2E+09");
13693 assert(ios.width() == 0);
13694 }
13695 }
13696 }
13697 }
13698 }
13699 }
13700 ios.precision(6);
13701 {
13702 }
13703 ios.precision(16);
13704 {
13705 }
13706 ios.precision(60);
13707 {
13708 nouppercase(ios);
13709 {
13710 noshowpos(ios);
13711 {
13712 noshowpoint(ios);
13713 {
13714 ios.imbue(lc);
13715 {
13716 ios.width(0);
13717 {
13718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13719 std::string ex(str, iter.base());
13720 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13721 assert(ios.width() == 0);
13722 }
13723 ios.width(25);
13724 left(ios);
13725 {
13726 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13727 std::string ex(str, iter.base());
13728 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13729 assert(ios.width() == 0);
13730 }
13731 ios.width(25);
13732 right(ios);
13733 {
13734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13735 std::string ex(str, iter.base());
13736 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13737 assert(ios.width() == 0);
13738 }
13739 ios.width(25);
13740 internal(ios);
13741 {
13742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13743 std::string ex(str, iter.base());
13744 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13745 assert(ios.width() == 0);
13746 }
13747 }
13748 ios.imbue(lg);
13749 {
13750 ios.width(0);
13751 {
13752 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13753 std::string ex(str, iter.base());
13754 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13755 assert(ios.width() == 0);
13756 }
13757 ios.width(25);
13758 left(ios);
13759 {
13760 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13761 std::string ex(str, iter.base());
13762 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13763 assert(ios.width() == 0);
13764 }
13765 ios.width(25);
13766 right(ios);
13767 {
13768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13769 std::string ex(str, iter.base());
13770 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13771 assert(ios.width() == 0);
13772 }
13773 ios.width(25);
13774 internal(ios);
13775 {
13776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13777 std::string ex(str, iter.base());
13778 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13779 assert(ios.width() == 0);
13780 }
13781 }
13782 }
13783 showpoint(ios);
13784 {
13785 ios.imbue(lc);
13786 {
13787 ios.width(0);
13788 {
13789 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13790 std::string ex(str, iter.base());
13791 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13792 assert(ios.width() == 0);
13793 }
13794 ios.width(25);
13795 left(ios);
13796 {
13797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13798 std::string ex(str, iter.base());
13799 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13800 assert(ios.width() == 0);
13801 }
13802 ios.width(25);
13803 right(ios);
13804 {
13805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13806 std::string ex(str, iter.base());
13807 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13808 assert(ios.width() == 0);
13809 }
13810 ios.width(25);
13811 internal(ios);
13812 {
13813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13814 std::string ex(str, iter.base());
13815 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13816 assert(ios.width() == 0);
13817 }
13818 }
13819 ios.imbue(lg);
13820 {
13821 ios.width(0);
13822 {
13823 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13824 std::string ex(str, iter.base());
13825 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13826 assert(ios.width() == 0);
13827 }
13828 ios.width(25);
13829 left(ios);
13830 {
13831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13832 std::string ex(str, iter.base());
13833 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13834 assert(ios.width() == 0);
13835 }
13836 ios.width(25);
13837 right(ios);
13838 {
13839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13840 std::string ex(str, iter.base());
13841 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13842 assert(ios.width() == 0);
13843 }
13844 ios.width(25);
13845 internal(ios);
13846 {
13847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13848 std::string ex(str, iter.base());
13849 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13850 assert(ios.width() == 0);
13851 }
13852 }
13853 }
13854 }
13855 showpos(ios);
13856 {
13857 noshowpoint(ios);
13858 {
13859 ios.imbue(lc);
13860 {
13861 ios.width(0);
13862 {
13863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13864 std::string ex(str, iter.base());
13865 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13866 assert(ios.width() == 0);
13867 }
13868 ios.width(25);
13869 left(ios);
13870 {
13871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13872 std::string ex(str, iter.base());
13873 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13874 assert(ios.width() == 0);
13875 }
13876 ios.width(25);
13877 right(ios);
13878 {
13879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13880 std::string ex(str, iter.base());
13881 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13882 assert(ios.width() == 0);
13883 }
13884 ios.width(25);
13885 internal(ios);
13886 {
13887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13888 std::string ex(str, iter.base());
13889 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13890 assert(ios.width() == 0);
13891 }
13892 }
13893 ios.imbue(lg);
13894 {
13895 ios.width(0);
13896 {
13897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13898 std::string ex(str, iter.base());
13899 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13900 assert(ios.width() == 0);
13901 }
13902 ios.width(25);
13903 left(ios);
13904 {
13905 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13906 std::string ex(str, iter.base());
13907 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13908 assert(ios.width() == 0);
13909 }
13910 ios.width(25);
13911 right(ios);
13912 {
13913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13914 std::string ex(str, iter.base());
13915 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13916 assert(ios.width() == 0);
13917 }
13918 ios.width(25);
13919 internal(ios);
13920 {
13921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13922 std::string ex(str, iter.base());
13923 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13924 assert(ios.width() == 0);
13925 }
13926 }
13927 }
13928 showpoint(ios);
13929 {
13930 ios.imbue(lc);
13931 {
13932 ios.width(0);
13933 {
13934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13935 std::string ex(str, iter.base());
13936 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13937 assert(ios.width() == 0);
13938 }
13939 ios.width(25);
13940 left(ios);
13941 {
13942 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13943 std::string ex(str, iter.base());
13944 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13945 assert(ios.width() == 0);
13946 }
13947 ios.width(25);
13948 right(ios);
13949 {
13950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13951 std::string ex(str, iter.base());
13952 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13953 assert(ios.width() == 0);
13954 }
13955 ios.width(25);
13956 internal(ios);
13957 {
13958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13959 std::string ex(str, iter.base());
13960 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13961 assert(ios.width() == 0);
13962 }
13963 }
13964 ios.imbue(lg);
13965 {
13966 ios.width(0);
13967 {
13968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13969 std::string ex(str, iter.base());
13970 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13971 assert(ios.width() == 0);
13972 }
13973 ios.width(25);
13974 left(ios);
13975 {
13976 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13977 std::string ex(str, iter.base());
13978 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13979 assert(ios.width() == 0);
13980 }
13981 ios.width(25);
13982 right(ios);
13983 {
13984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13985 std::string ex(str, iter.base());
13986 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13987 assert(ios.width() == 0);
13988 }
13989 ios.width(25);
13990 internal(ios);
13991 {
13992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13993 std::string ex(str, iter.base());
13994 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13995 assert(ios.width() == 0);
13996 }
13997 }
13998 }
13999 }
14000 }
14001 uppercase(ios);
14002 {
14003 noshowpos(ios);
14004 {
14005 noshowpoint(ios);
14006 {
14007 ios.imbue(lc);
14008 {
14009 ios.width(0);
14010 {
14011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14012 std::string ex(str, iter.base());
14013 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14014 assert(ios.width() == 0);
14015 }
14016 ios.width(25);
14017 left(ios);
14018 {
14019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14020 std::string ex(str, iter.base());
14021 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14022 assert(ios.width() == 0);
14023 }
14024 ios.width(25);
14025 right(ios);
14026 {
14027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14028 std::string ex(str, iter.base());
14029 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14030 assert(ios.width() == 0);
14031 }
14032 ios.width(25);
14033 internal(ios);
14034 {
14035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14036 std::string ex(str, iter.base());
14037 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14038 assert(ios.width() == 0);
14039 }
14040 }
14041 ios.imbue(lg);
14042 {
14043 ios.width(0);
14044 {
14045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14046 std::string ex(str, iter.base());
14047 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14048 assert(ios.width() == 0);
14049 }
14050 ios.width(25);
14051 left(ios);
14052 {
14053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14054 std::string ex(str, iter.base());
14055 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14056 assert(ios.width() == 0);
14057 }
14058 ios.width(25);
14059 right(ios);
14060 {
14061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14062 std::string ex(str, iter.base());
14063 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14064 assert(ios.width() == 0);
14065 }
14066 ios.width(25);
14067 internal(ios);
14068 {
14069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14070 std::string ex(str, iter.base());
14071 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14072 assert(ios.width() == 0);
14073 }
14074 }
14075 }
14076 showpoint(ios);
14077 {
14078 ios.imbue(lc);
14079 {
14080 ios.width(0);
14081 {
14082 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14083 std::string ex(str, iter.base());
14084 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14085 assert(ios.width() == 0);
14086 }
14087 ios.width(25);
14088 left(ios);
14089 {
14090 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14091 std::string ex(str, iter.base());
14092 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14093 assert(ios.width() == 0);
14094 }
14095 ios.width(25);
14096 right(ios);
14097 {
14098 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14099 std::string ex(str, iter.base());
14100 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14101 assert(ios.width() == 0);
14102 }
14103 ios.width(25);
14104 internal(ios);
14105 {
14106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14107 std::string ex(str, iter.base());
14108 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14109 assert(ios.width() == 0);
14110 }
14111 }
14112 ios.imbue(lg);
14113 {
14114 ios.width(0);
14115 {
14116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14117 std::string ex(str, iter.base());
14118 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14119 assert(ios.width() == 0);
14120 }
14121 ios.width(25);
14122 left(ios);
14123 {
14124 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14125 std::string ex(str, iter.base());
14126 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14127 assert(ios.width() == 0);
14128 }
14129 ios.width(25);
14130 right(ios);
14131 {
14132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14133 std::string ex(str, iter.base());
14134 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14135 assert(ios.width() == 0);
14136 }
14137 ios.width(25);
14138 internal(ios);
14139 {
14140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14141 std::string ex(str, iter.base());
14142 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14143 assert(ios.width() == 0);
14144 }
14145 }
14146 }
14147 }
14148 showpos(ios);
14149 {
14150 noshowpoint(ios);
14151 {
14152 ios.imbue(lc);
14153 {
14154 ios.width(0);
14155 {
14156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14157 std::string ex(str, iter.base());
14158 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14159 assert(ios.width() == 0);
14160 }
14161 ios.width(25);
14162 left(ios);
14163 {
14164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14165 std::string ex(str, iter.base());
14166 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14167 assert(ios.width() == 0);
14168 }
14169 ios.width(25);
14170 right(ios);
14171 {
14172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14173 std::string ex(str, iter.base());
14174 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14175 assert(ios.width() == 0);
14176 }
14177 ios.width(25);
14178 internal(ios);
14179 {
14180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14181 std::string ex(str, iter.base());
14182 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14183 assert(ios.width() == 0);
14184 }
14185 }
14186 ios.imbue(lg);
14187 {
14188 ios.width(0);
14189 {
14190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14191 std::string ex(str, iter.base());
14192 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14193 assert(ios.width() == 0);
14194 }
14195 ios.width(25);
14196 left(ios);
14197 {
14198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14199 std::string ex(str, iter.base());
14200 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14201 assert(ios.width() == 0);
14202 }
14203 ios.width(25);
14204 right(ios);
14205 {
14206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14207 std::string ex(str, iter.base());
14208 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14209 assert(ios.width() == 0);
14210 }
14211 ios.width(25);
14212 internal(ios);
14213 {
14214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14215 std::string ex(str, iter.base());
14216 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14217 assert(ios.width() == 0);
14218 }
14219 }
14220 }
14221 showpoint(ios);
14222 {
14223 ios.imbue(lc);
14224 {
14225 ios.width(0);
14226 {
14227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14228 std::string ex(str, iter.base());
14229 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14230 assert(ios.width() == 0);
14231 }
14232 ios.width(25);
14233 left(ios);
14234 {
14235 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14236 std::string ex(str, iter.base());
14237 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14238 assert(ios.width() == 0);
14239 }
14240 ios.width(25);
14241 right(ios);
14242 {
14243 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14244 std::string ex(str, iter.base());
14245 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14246 assert(ios.width() == 0);
14247 }
14248 ios.width(25);
14249 internal(ios);
14250 {
14251 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14252 std::string ex(str, iter.base());
14253 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14254 assert(ios.width() == 0);
14255 }
14256 }
14257 ios.imbue(lg);
14258 {
14259 ios.width(0);
14260 {
14261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14262 std::string ex(str, iter.base());
14263 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14264 assert(ios.width() == 0);
14265 }
14266 ios.width(25);
14267 left(ios);
14268 {
14269 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14270 std::string ex(str, iter.base());
14271 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14272 assert(ios.width() == 0);
14273 }
14274 ios.width(25);
14275 right(ios);
14276 {
14277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14278 std::string ex(str, iter.base());
14279 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14280 assert(ios.width() == 0);
14281 }
14282 ios.width(25);
14283 internal(ios);
14284 {
14285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14286 std::string ex(str, iter.base());
14287 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14288 assert(ios.width() == 0);
14289 }
14290 }
14291 }
14292 }
14293 }
14294 }
14295 }
14296 }
14297 }
14298
test7()14299 void test7()
14300 {
14301 char str[200];
14302 output_iterator<char*> iter;
14303 std::locale lc = std::locale::classic();
14304 std::locale lg(lc, new my_numpunct);
14305 const my_facet f(1);
14306 {
14307 double v = -0.;
14308 std::ios ios(0);
14309 hexfloat(ios);
14310 // %a
14311 {
14312 ios.precision(0);
14313 {
14314 nouppercase(ios);
14315 {
14316 noshowpos(ios);
14317 {
14318 noshowpoint(ios);
14319 {
14320 ios.imbue(lc);
14321 {
14322 ios.width(0);
14323 {
14324 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14325 std::string ex(str, iter.base());
14326 assert(ex == "-0x0p+0");
14327 assert(ios.width() == 0);
14328 }
14329 ios.width(25);
14330 left(ios);
14331 {
14332 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14333 std::string ex(str, iter.base());
14334 assert(ex == "-0x0p+0******************");
14335 assert(ios.width() == 0);
14336 }
14337 ios.width(25);
14338 right(ios);
14339 {
14340 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14341 std::string ex(str, iter.base());
14342 assert(ex == "******************-0x0p+0");
14343 assert(ios.width() == 0);
14344 }
14345 ios.width(25);
14346 internal(ios);
14347 {
14348 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14349 std::string ex(str, iter.base());
14350 assert(ex == "-******************0x0p+0");
14351 assert(ios.width() == 0);
14352 }
14353 }
14354 ios.imbue(lg);
14355 {
14356 ios.width(0);
14357 {
14358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14359 std::string ex(str, iter.base());
14360 assert(ex == "-0x0p+0");
14361 assert(ios.width() == 0);
14362 }
14363 ios.width(25);
14364 left(ios);
14365 {
14366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14367 std::string ex(str, iter.base());
14368 assert(ex == "-0x0p+0******************");
14369 assert(ios.width() == 0);
14370 }
14371 ios.width(25);
14372 right(ios);
14373 {
14374 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14375 std::string ex(str, iter.base());
14376 assert(ex == "******************-0x0p+0");
14377 assert(ios.width() == 0);
14378 }
14379 ios.width(25);
14380 internal(ios);
14381 {
14382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14383 std::string ex(str, iter.base());
14384 assert(ex == "-******************0x0p+0");
14385 assert(ios.width() == 0);
14386 }
14387 }
14388 }
14389 showpoint(ios);
14390 {
14391 ios.imbue(lc);
14392 {
14393 ios.width(0);
14394 {
14395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14396 std::string ex(str, iter.base());
14397 assert(ex == "-0x0.p+0");
14398 assert(ios.width() == 0);
14399 }
14400 ios.width(25);
14401 left(ios);
14402 {
14403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14404 std::string ex(str, iter.base());
14405 assert(ex == "-0x0.p+0*****************");
14406 assert(ios.width() == 0);
14407 }
14408 ios.width(25);
14409 right(ios);
14410 {
14411 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14412 std::string ex(str, iter.base());
14413 assert(ex == "*****************-0x0.p+0");
14414 assert(ios.width() == 0);
14415 }
14416 ios.width(25);
14417 internal(ios);
14418 {
14419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14420 std::string ex(str, iter.base());
14421 assert(ex == "-*****************0x0.p+0");
14422 assert(ios.width() == 0);
14423 }
14424 }
14425 ios.imbue(lg);
14426 {
14427 ios.width(0);
14428 {
14429 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14430 std::string ex(str, iter.base());
14431 assert(ex == "-0x0;p+0");
14432 assert(ios.width() == 0);
14433 }
14434 ios.width(25);
14435 left(ios);
14436 {
14437 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14438 std::string ex(str, iter.base());
14439 assert(ex == "-0x0;p+0*****************");
14440 assert(ios.width() == 0);
14441 }
14442 ios.width(25);
14443 right(ios);
14444 {
14445 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14446 std::string ex(str, iter.base());
14447 assert(ex == "*****************-0x0;p+0");
14448 assert(ios.width() == 0);
14449 }
14450 ios.width(25);
14451 internal(ios);
14452 {
14453 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14454 std::string ex(str, iter.base());
14455 assert(ex == "-*****************0x0;p+0");
14456 assert(ios.width() == 0);
14457 }
14458 }
14459 }
14460 }
14461 showpos(ios);
14462 {
14463 noshowpoint(ios);
14464 {
14465 ios.imbue(lc);
14466 {
14467 ios.width(0);
14468 {
14469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14470 std::string ex(str, iter.base());
14471 assert(ex == "-0x0p+0");
14472 assert(ios.width() == 0);
14473 }
14474 ios.width(25);
14475 left(ios);
14476 {
14477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14478 std::string ex(str, iter.base());
14479 assert(ex == "-0x0p+0******************");
14480 assert(ios.width() == 0);
14481 }
14482 ios.width(25);
14483 right(ios);
14484 {
14485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14486 std::string ex(str, iter.base());
14487 assert(ex == "******************-0x0p+0");
14488 assert(ios.width() == 0);
14489 }
14490 ios.width(25);
14491 internal(ios);
14492 {
14493 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14494 std::string ex(str, iter.base());
14495 assert(ex == "-******************0x0p+0");
14496 assert(ios.width() == 0);
14497 }
14498 }
14499 ios.imbue(lg);
14500 {
14501 ios.width(0);
14502 {
14503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14504 std::string ex(str, iter.base());
14505 assert(ex == "-0x0p+0");
14506 assert(ios.width() == 0);
14507 }
14508 ios.width(25);
14509 left(ios);
14510 {
14511 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14512 std::string ex(str, iter.base());
14513 assert(ex == "-0x0p+0******************");
14514 assert(ios.width() == 0);
14515 }
14516 ios.width(25);
14517 right(ios);
14518 {
14519 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14520 std::string ex(str, iter.base());
14521 assert(ex == "******************-0x0p+0");
14522 assert(ios.width() == 0);
14523 }
14524 ios.width(25);
14525 internal(ios);
14526 {
14527 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14528 std::string ex(str, iter.base());
14529 assert(ex == "-******************0x0p+0");
14530 assert(ios.width() == 0);
14531 }
14532 }
14533 }
14534 showpoint(ios);
14535 {
14536 ios.imbue(lc);
14537 {
14538 ios.width(0);
14539 {
14540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14541 std::string ex(str, iter.base());
14542 assert(ex == "-0x0.p+0");
14543 assert(ios.width() == 0);
14544 }
14545 ios.width(25);
14546 left(ios);
14547 {
14548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14549 std::string ex(str, iter.base());
14550 assert(ex == "-0x0.p+0*****************");
14551 assert(ios.width() == 0);
14552 }
14553 ios.width(25);
14554 right(ios);
14555 {
14556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14557 std::string ex(str, iter.base());
14558 assert(ex == "*****************-0x0.p+0");
14559 assert(ios.width() == 0);
14560 }
14561 ios.width(25);
14562 internal(ios);
14563 {
14564 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14565 std::string ex(str, iter.base());
14566 assert(ex == "-*****************0x0.p+0");
14567 assert(ios.width() == 0);
14568 }
14569 }
14570 ios.imbue(lg);
14571 {
14572 ios.width(0);
14573 {
14574 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14575 std::string ex(str, iter.base());
14576 assert(ex == "-0x0;p+0");
14577 assert(ios.width() == 0);
14578 }
14579 ios.width(25);
14580 left(ios);
14581 {
14582 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14583 std::string ex(str, iter.base());
14584 assert(ex == "-0x0;p+0*****************");
14585 assert(ios.width() == 0);
14586 }
14587 ios.width(25);
14588 right(ios);
14589 {
14590 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14591 std::string ex(str, iter.base());
14592 assert(ex == "*****************-0x0;p+0");
14593 assert(ios.width() == 0);
14594 }
14595 ios.width(25);
14596 internal(ios);
14597 {
14598 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14599 std::string ex(str, iter.base());
14600 assert(ex == "-*****************0x0;p+0");
14601 assert(ios.width() == 0);
14602 }
14603 }
14604 }
14605 }
14606 }
14607 uppercase(ios);
14608 {
14609 noshowpos(ios);
14610 {
14611 noshowpoint(ios);
14612 {
14613 ios.imbue(lc);
14614 {
14615 ios.width(0);
14616 {
14617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14618 std::string ex(str, iter.base());
14619 assert(ex == "-0X0P+0");
14620 assert(ios.width() == 0);
14621 }
14622 ios.width(25);
14623 left(ios);
14624 {
14625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14626 std::string ex(str, iter.base());
14627 assert(ex == "-0X0P+0******************");
14628 assert(ios.width() == 0);
14629 }
14630 ios.width(25);
14631 right(ios);
14632 {
14633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14634 std::string ex(str, iter.base());
14635 assert(ex == "******************-0X0P+0");
14636 assert(ios.width() == 0);
14637 }
14638 ios.width(25);
14639 internal(ios);
14640 {
14641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14642 std::string ex(str, iter.base());
14643 assert(ex == "-******************0X0P+0");
14644 assert(ios.width() == 0);
14645 }
14646 }
14647 ios.imbue(lg);
14648 {
14649 ios.width(0);
14650 {
14651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14652 std::string ex(str, iter.base());
14653 assert(ex == "-0X0P+0");
14654 assert(ios.width() == 0);
14655 }
14656 ios.width(25);
14657 left(ios);
14658 {
14659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14660 std::string ex(str, iter.base());
14661 assert(ex == "-0X0P+0******************");
14662 assert(ios.width() == 0);
14663 }
14664 ios.width(25);
14665 right(ios);
14666 {
14667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14668 std::string ex(str, iter.base());
14669 assert(ex == "******************-0X0P+0");
14670 assert(ios.width() == 0);
14671 }
14672 ios.width(25);
14673 internal(ios);
14674 {
14675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14676 std::string ex(str, iter.base());
14677 assert(ex == "-******************0X0P+0");
14678 assert(ios.width() == 0);
14679 }
14680 }
14681 }
14682 showpoint(ios);
14683 {
14684 ios.imbue(lc);
14685 {
14686 ios.width(0);
14687 {
14688 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14689 std::string ex(str, iter.base());
14690 assert(ex == "-0X0.P+0");
14691 assert(ios.width() == 0);
14692 }
14693 ios.width(25);
14694 left(ios);
14695 {
14696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14697 std::string ex(str, iter.base());
14698 assert(ex == "-0X0.P+0*****************");
14699 assert(ios.width() == 0);
14700 }
14701 ios.width(25);
14702 right(ios);
14703 {
14704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14705 std::string ex(str, iter.base());
14706 assert(ex == "*****************-0X0.P+0");
14707 assert(ios.width() == 0);
14708 }
14709 ios.width(25);
14710 internal(ios);
14711 {
14712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14713 std::string ex(str, iter.base());
14714 assert(ex == "-*****************0X0.P+0");
14715 assert(ios.width() == 0);
14716 }
14717 }
14718 ios.imbue(lg);
14719 {
14720 ios.width(0);
14721 {
14722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14723 std::string ex(str, iter.base());
14724 assert(ex == "-0X0;P+0");
14725 assert(ios.width() == 0);
14726 }
14727 ios.width(25);
14728 left(ios);
14729 {
14730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14731 std::string ex(str, iter.base());
14732 assert(ex == "-0X0;P+0*****************");
14733 assert(ios.width() == 0);
14734 }
14735 ios.width(25);
14736 right(ios);
14737 {
14738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14739 std::string ex(str, iter.base());
14740 assert(ex == "*****************-0X0;P+0");
14741 assert(ios.width() == 0);
14742 }
14743 ios.width(25);
14744 internal(ios);
14745 {
14746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14747 std::string ex(str, iter.base());
14748 assert(ex == "-*****************0X0;P+0");
14749 assert(ios.width() == 0);
14750 }
14751 }
14752 }
14753 }
14754 showpos(ios);
14755 {
14756 noshowpoint(ios);
14757 {
14758 ios.imbue(lc);
14759 {
14760 ios.width(0);
14761 {
14762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14763 std::string ex(str, iter.base());
14764 assert(ex == "-0X0P+0");
14765 assert(ios.width() == 0);
14766 }
14767 ios.width(25);
14768 left(ios);
14769 {
14770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14771 std::string ex(str, iter.base());
14772 assert(ex == "-0X0P+0******************");
14773 assert(ios.width() == 0);
14774 }
14775 ios.width(25);
14776 right(ios);
14777 {
14778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14779 std::string ex(str, iter.base());
14780 assert(ex == "******************-0X0P+0");
14781 assert(ios.width() == 0);
14782 }
14783 ios.width(25);
14784 internal(ios);
14785 {
14786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14787 std::string ex(str, iter.base());
14788 assert(ex == "-******************0X0P+0");
14789 assert(ios.width() == 0);
14790 }
14791 }
14792 ios.imbue(lg);
14793 {
14794 ios.width(0);
14795 {
14796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14797 std::string ex(str, iter.base());
14798 assert(ex == "-0X0P+0");
14799 assert(ios.width() == 0);
14800 }
14801 ios.width(25);
14802 left(ios);
14803 {
14804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14805 std::string ex(str, iter.base());
14806 assert(ex == "-0X0P+0******************");
14807 assert(ios.width() == 0);
14808 }
14809 ios.width(25);
14810 right(ios);
14811 {
14812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14813 std::string ex(str, iter.base());
14814 assert(ex == "******************-0X0P+0");
14815 assert(ios.width() == 0);
14816 }
14817 ios.width(25);
14818 internal(ios);
14819 {
14820 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14821 std::string ex(str, iter.base());
14822 assert(ex == "-******************0X0P+0");
14823 assert(ios.width() == 0);
14824 }
14825 }
14826 }
14827 showpoint(ios);
14828 {
14829 ios.imbue(lc);
14830 {
14831 ios.width(0);
14832 {
14833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14834 std::string ex(str, iter.base());
14835 assert(ex == "-0X0.P+0");
14836 assert(ios.width() == 0);
14837 }
14838 ios.width(25);
14839 left(ios);
14840 {
14841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14842 std::string ex(str, iter.base());
14843 assert(ex == "-0X0.P+0*****************");
14844 assert(ios.width() == 0);
14845 }
14846 ios.width(25);
14847 right(ios);
14848 {
14849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14850 std::string ex(str, iter.base());
14851 assert(ex == "*****************-0X0.P+0");
14852 assert(ios.width() == 0);
14853 }
14854 ios.width(25);
14855 internal(ios);
14856 {
14857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14858 std::string ex(str, iter.base());
14859 assert(ex == "-*****************0X0.P+0");
14860 assert(ios.width() == 0);
14861 }
14862 }
14863 ios.imbue(lg);
14864 {
14865 ios.width(0);
14866 {
14867 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14868 std::string ex(str, iter.base());
14869 assert(ex == "-0X0;P+0");
14870 assert(ios.width() == 0);
14871 }
14872 ios.width(25);
14873 left(ios);
14874 {
14875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14876 std::string ex(str, iter.base());
14877 assert(ex == "-0X0;P+0*****************");
14878 assert(ios.width() == 0);
14879 }
14880 ios.width(25);
14881 right(ios);
14882 {
14883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14884 std::string ex(str, iter.base());
14885 assert(ex == "*****************-0X0;P+0");
14886 assert(ios.width() == 0);
14887 }
14888 ios.width(25);
14889 internal(ios);
14890 {
14891 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14892 std::string ex(str, iter.base());
14893 assert(ex == "-*****************0X0;P+0");
14894 assert(ios.width() == 0);
14895 }
14896 }
14897 }
14898 }
14899 }
14900 }
14901 ios.precision(1);
14902 {
14903 nouppercase(ios);
14904 {
14905 noshowpos(ios);
14906 {
14907 noshowpoint(ios);
14908 {
14909 ios.imbue(lc);
14910 {
14911 ios.width(0);
14912 {
14913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14914 std::string ex(str, iter.base());
14915 assert(ex == "-0x0p+0");
14916 assert(ios.width() == 0);
14917 }
14918 ios.width(25);
14919 left(ios);
14920 {
14921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14922 std::string ex(str, iter.base());
14923 assert(ex == "-0x0p+0******************");
14924 assert(ios.width() == 0);
14925 }
14926 ios.width(25);
14927 right(ios);
14928 {
14929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14930 std::string ex(str, iter.base());
14931 assert(ex == "******************-0x0p+0");
14932 assert(ios.width() == 0);
14933 }
14934 ios.width(25);
14935 internal(ios);
14936 {
14937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14938 std::string ex(str, iter.base());
14939 assert(ex == "-******************0x0p+0");
14940 assert(ios.width() == 0);
14941 }
14942 }
14943 ios.imbue(lg);
14944 {
14945 ios.width(0);
14946 {
14947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14948 std::string ex(str, iter.base());
14949 assert(ex == "-0x0p+0");
14950 assert(ios.width() == 0);
14951 }
14952 ios.width(25);
14953 left(ios);
14954 {
14955 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14956 std::string ex(str, iter.base());
14957 assert(ex == "-0x0p+0******************");
14958 assert(ios.width() == 0);
14959 }
14960 ios.width(25);
14961 right(ios);
14962 {
14963 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14964 std::string ex(str, iter.base());
14965 assert(ex == "******************-0x0p+0");
14966 assert(ios.width() == 0);
14967 }
14968 ios.width(25);
14969 internal(ios);
14970 {
14971 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14972 std::string ex(str, iter.base());
14973 assert(ex == "-******************0x0p+0");
14974 assert(ios.width() == 0);
14975 }
14976 }
14977 }
14978 showpoint(ios);
14979 {
14980 ios.imbue(lc);
14981 {
14982 ios.width(0);
14983 {
14984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14985 std::string ex(str, iter.base());
14986 assert(ex == "-0x0.p+0");
14987 assert(ios.width() == 0);
14988 }
14989 ios.width(25);
14990 left(ios);
14991 {
14992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14993 std::string ex(str, iter.base());
14994 assert(ex == "-0x0.p+0*****************");
14995 assert(ios.width() == 0);
14996 }
14997 ios.width(25);
14998 right(ios);
14999 {
15000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15001 std::string ex(str, iter.base());
15002 assert(ex == "*****************-0x0.p+0");
15003 assert(ios.width() == 0);
15004 }
15005 ios.width(25);
15006 internal(ios);
15007 {
15008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15009 std::string ex(str, iter.base());
15010 assert(ex == "-*****************0x0.p+0");
15011 assert(ios.width() == 0);
15012 }
15013 }
15014 ios.imbue(lg);
15015 {
15016 ios.width(0);
15017 {
15018 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15019 std::string ex(str, iter.base());
15020 assert(ex == "-0x0;p+0");
15021 assert(ios.width() == 0);
15022 }
15023 ios.width(25);
15024 left(ios);
15025 {
15026 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15027 std::string ex(str, iter.base());
15028 assert(ex == "-0x0;p+0*****************");
15029 assert(ios.width() == 0);
15030 }
15031 ios.width(25);
15032 right(ios);
15033 {
15034 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15035 std::string ex(str, iter.base());
15036 assert(ex == "*****************-0x0;p+0");
15037 assert(ios.width() == 0);
15038 }
15039 ios.width(25);
15040 internal(ios);
15041 {
15042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15043 std::string ex(str, iter.base());
15044 assert(ex == "-*****************0x0;p+0");
15045 assert(ios.width() == 0);
15046 }
15047 }
15048 }
15049 }
15050 showpos(ios);
15051 {
15052 noshowpoint(ios);
15053 {
15054 ios.imbue(lc);
15055 {
15056 ios.width(0);
15057 {
15058 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15059 std::string ex(str, iter.base());
15060 assert(ex == "-0x0p+0");
15061 assert(ios.width() == 0);
15062 }
15063 ios.width(25);
15064 left(ios);
15065 {
15066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15067 std::string ex(str, iter.base());
15068 assert(ex == "-0x0p+0******************");
15069 assert(ios.width() == 0);
15070 }
15071 ios.width(25);
15072 right(ios);
15073 {
15074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15075 std::string ex(str, iter.base());
15076 assert(ex == "******************-0x0p+0");
15077 assert(ios.width() == 0);
15078 }
15079 ios.width(25);
15080 internal(ios);
15081 {
15082 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15083 std::string ex(str, iter.base());
15084 assert(ex == "-******************0x0p+0");
15085 assert(ios.width() == 0);
15086 }
15087 }
15088 ios.imbue(lg);
15089 {
15090 ios.width(0);
15091 {
15092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15093 std::string ex(str, iter.base());
15094 assert(ex == "-0x0p+0");
15095 assert(ios.width() == 0);
15096 }
15097 ios.width(25);
15098 left(ios);
15099 {
15100 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15101 std::string ex(str, iter.base());
15102 assert(ex == "-0x0p+0******************");
15103 assert(ios.width() == 0);
15104 }
15105 ios.width(25);
15106 right(ios);
15107 {
15108 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15109 std::string ex(str, iter.base());
15110 assert(ex == "******************-0x0p+0");
15111 assert(ios.width() == 0);
15112 }
15113 ios.width(25);
15114 internal(ios);
15115 {
15116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15117 std::string ex(str, iter.base());
15118 assert(ex == "-******************0x0p+0");
15119 assert(ios.width() == 0);
15120 }
15121 }
15122 }
15123 showpoint(ios);
15124 {
15125 ios.imbue(lc);
15126 {
15127 ios.width(0);
15128 {
15129 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15130 std::string ex(str, iter.base());
15131 assert(ex == "-0x0.p+0");
15132 assert(ios.width() == 0);
15133 }
15134 ios.width(25);
15135 left(ios);
15136 {
15137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15138 std::string ex(str, iter.base());
15139 assert(ex == "-0x0.p+0*****************");
15140 assert(ios.width() == 0);
15141 }
15142 ios.width(25);
15143 right(ios);
15144 {
15145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15146 std::string ex(str, iter.base());
15147 assert(ex == "*****************-0x0.p+0");
15148 assert(ios.width() == 0);
15149 }
15150 ios.width(25);
15151 internal(ios);
15152 {
15153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15154 std::string ex(str, iter.base());
15155 assert(ex == "-*****************0x0.p+0");
15156 assert(ios.width() == 0);
15157 }
15158 }
15159 ios.imbue(lg);
15160 {
15161 ios.width(0);
15162 {
15163 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15164 std::string ex(str, iter.base());
15165 assert(ex == "-0x0;p+0");
15166 assert(ios.width() == 0);
15167 }
15168 ios.width(25);
15169 left(ios);
15170 {
15171 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15172 std::string ex(str, iter.base());
15173 assert(ex == "-0x0;p+0*****************");
15174 assert(ios.width() == 0);
15175 }
15176 ios.width(25);
15177 right(ios);
15178 {
15179 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15180 std::string ex(str, iter.base());
15181 assert(ex == "*****************-0x0;p+0");
15182 assert(ios.width() == 0);
15183 }
15184 ios.width(25);
15185 internal(ios);
15186 {
15187 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15188 std::string ex(str, iter.base());
15189 assert(ex == "-*****************0x0;p+0");
15190 assert(ios.width() == 0);
15191 }
15192 }
15193 }
15194 }
15195 }
15196 uppercase(ios);
15197 {
15198 noshowpos(ios);
15199 {
15200 noshowpoint(ios);
15201 {
15202 ios.imbue(lc);
15203 {
15204 ios.width(0);
15205 {
15206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15207 std::string ex(str, iter.base());
15208 assert(ex == "-0X0P+0");
15209 assert(ios.width() == 0);
15210 }
15211 ios.width(25);
15212 left(ios);
15213 {
15214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15215 std::string ex(str, iter.base());
15216 assert(ex == "-0X0P+0******************");
15217 assert(ios.width() == 0);
15218 }
15219 ios.width(25);
15220 right(ios);
15221 {
15222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15223 std::string ex(str, iter.base());
15224 assert(ex == "******************-0X0P+0");
15225 assert(ios.width() == 0);
15226 }
15227 ios.width(25);
15228 internal(ios);
15229 {
15230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15231 std::string ex(str, iter.base());
15232 assert(ex == "-******************0X0P+0");
15233 assert(ios.width() == 0);
15234 }
15235 }
15236 ios.imbue(lg);
15237 {
15238 ios.width(0);
15239 {
15240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15241 std::string ex(str, iter.base());
15242 assert(ex == "-0X0P+0");
15243 assert(ios.width() == 0);
15244 }
15245 ios.width(25);
15246 left(ios);
15247 {
15248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15249 std::string ex(str, iter.base());
15250 assert(ex == "-0X0P+0******************");
15251 assert(ios.width() == 0);
15252 }
15253 ios.width(25);
15254 right(ios);
15255 {
15256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15257 std::string ex(str, iter.base());
15258 assert(ex == "******************-0X0P+0");
15259 assert(ios.width() == 0);
15260 }
15261 ios.width(25);
15262 internal(ios);
15263 {
15264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15265 std::string ex(str, iter.base());
15266 assert(ex == "-******************0X0P+0");
15267 assert(ios.width() == 0);
15268 }
15269 }
15270 }
15271 showpoint(ios);
15272 {
15273 ios.imbue(lc);
15274 {
15275 ios.width(0);
15276 {
15277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15278 std::string ex(str, iter.base());
15279 assert(ex == "-0X0.P+0");
15280 assert(ios.width() == 0);
15281 }
15282 ios.width(25);
15283 left(ios);
15284 {
15285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15286 std::string ex(str, iter.base());
15287 assert(ex == "-0X0.P+0*****************");
15288 assert(ios.width() == 0);
15289 }
15290 ios.width(25);
15291 right(ios);
15292 {
15293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15294 std::string ex(str, iter.base());
15295 assert(ex == "*****************-0X0.P+0");
15296 assert(ios.width() == 0);
15297 }
15298 ios.width(25);
15299 internal(ios);
15300 {
15301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15302 std::string ex(str, iter.base());
15303 assert(ex == "-*****************0X0.P+0");
15304 assert(ios.width() == 0);
15305 }
15306 }
15307 ios.imbue(lg);
15308 {
15309 ios.width(0);
15310 {
15311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15312 std::string ex(str, iter.base());
15313 assert(ex == "-0X0;P+0");
15314 assert(ios.width() == 0);
15315 }
15316 ios.width(25);
15317 left(ios);
15318 {
15319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15320 std::string ex(str, iter.base());
15321 assert(ex == "-0X0;P+0*****************");
15322 assert(ios.width() == 0);
15323 }
15324 ios.width(25);
15325 right(ios);
15326 {
15327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15328 std::string ex(str, iter.base());
15329 assert(ex == "*****************-0X0;P+0");
15330 assert(ios.width() == 0);
15331 }
15332 ios.width(25);
15333 internal(ios);
15334 {
15335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15336 std::string ex(str, iter.base());
15337 assert(ex == "-*****************0X0;P+0");
15338 assert(ios.width() == 0);
15339 }
15340 }
15341 }
15342 }
15343 showpos(ios);
15344 {
15345 noshowpoint(ios);
15346 {
15347 ios.imbue(lc);
15348 {
15349 ios.width(0);
15350 {
15351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15352 std::string ex(str, iter.base());
15353 assert(ex == "-0X0P+0");
15354 assert(ios.width() == 0);
15355 }
15356 ios.width(25);
15357 left(ios);
15358 {
15359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15360 std::string ex(str, iter.base());
15361 assert(ex == "-0X0P+0******************");
15362 assert(ios.width() == 0);
15363 }
15364 ios.width(25);
15365 right(ios);
15366 {
15367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15368 std::string ex(str, iter.base());
15369 assert(ex == "******************-0X0P+0");
15370 assert(ios.width() == 0);
15371 }
15372 ios.width(25);
15373 internal(ios);
15374 {
15375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15376 std::string ex(str, iter.base());
15377 assert(ex == "-******************0X0P+0");
15378 assert(ios.width() == 0);
15379 }
15380 }
15381 ios.imbue(lg);
15382 {
15383 ios.width(0);
15384 {
15385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15386 std::string ex(str, iter.base());
15387 assert(ex == "-0X0P+0");
15388 assert(ios.width() == 0);
15389 }
15390 ios.width(25);
15391 left(ios);
15392 {
15393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15394 std::string ex(str, iter.base());
15395 assert(ex == "-0X0P+0******************");
15396 assert(ios.width() == 0);
15397 }
15398 ios.width(25);
15399 right(ios);
15400 {
15401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15402 std::string ex(str, iter.base());
15403 assert(ex == "******************-0X0P+0");
15404 assert(ios.width() == 0);
15405 }
15406 ios.width(25);
15407 internal(ios);
15408 {
15409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15410 std::string ex(str, iter.base());
15411 assert(ex == "-******************0X0P+0");
15412 assert(ios.width() == 0);
15413 }
15414 }
15415 }
15416 showpoint(ios);
15417 {
15418 ios.imbue(lc);
15419 {
15420 ios.width(0);
15421 {
15422 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15423 std::string ex(str, iter.base());
15424 assert(ex == "-0X0.P+0");
15425 assert(ios.width() == 0);
15426 }
15427 ios.width(25);
15428 left(ios);
15429 {
15430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15431 std::string ex(str, iter.base());
15432 assert(ex == "-0X0.P+0*****************");
15433 assert(ios.width() == 0);
15434 }
15435 ios.width(25);
15436 right(ios);
15437 {
15438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15439 std::string ex(str, iter.base());
15440 assert(ex == "*****************-0X0.P+0");
15441 assert(ios.width() == 0);
15442 }
15443 ios.width(25);
15444 internal(ios);
15445 {
15446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15447 std::string ex(str, iter.base());
15448 assert(ex == "-*****************0X0.P+0");
15449 assert(ios.width() == 0);
15450 }
15451 }
15452 ios.imbue(lg);
15453 {
15454 ios.width(0);
15455 {
15456 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15457 std::string ex(str, iter.base());
15458 assert(ex == "-0X0;P+0");
15459 assert(ios.width() == 0);
15460 }
15461 ios.width(25);
15462 left(ios);
15463 {
15464 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15465 std::string ex(str, iter.base());
15466 assert(ex == "-0X0;P+0*****************");
15467 assert(ios.width() == 0);
15468 }
15469 ios.width(25);
15470 right(ios);
15471 {
15472 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15473 std::string ex(str, iter.base());
15474 assert(ex == "*****************-0X0;P+0");
15475 assert(ios.width() == 0);
15476 }
15477 ios.width(25);
15478 internal(ios);
15479 {
15480 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15481 std::string ex(str, iter.base());
15482 assert(ex == "-*****************0X0;P+0");
15483 assert(ios.width() == 0);
15484 }
15485 }
15486 }
15487 }
15488 }
15489 }
15490 ios.precision(6);
15491 {
15492 nouppercase(ios);
15493 {
15494 noshowpos(ios);
15495 {
15496 noshowpoint(ios);
15497 {
15498 ios.imbue(lc);
15499 {
15500 ios.width(0);
15501 {
15502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15503 std::string ex(str, iter.base());
15504 assert(ex == "-0x0p+0");
15505 assert(ios.width() == 0);
15506 }
15507 ios.width(25);
15508 left(ios);
15509 {
15510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15511 std::string ex(str, iter.base());
15512 assert(ex == "-0x0p+0******************");
15513 assert(ios.width() == 0);
15514 }
15515 ios.width(25);
15516 right(ios);
15517 {
15518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15519 std::string ex(str, iter.base());
15520 assert(ex == "******************-0x0p+0");
15521 assert(ios.width() == 0);
15522 }
15523 ios.width(25);
15524 internal(ios);
15525 {
15526 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15527 std::string ex(str, iter.base());
15528 assert(ex == "-******************0x0p+0");
15529 assert(ios.width() == 0);
15530 }
15531 }
15532 ios.imbue(lg);
15533 {
15534 ios.width(0);
15535 {
15536 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15537 std::string ex(str, iter.base());
15538 assert(ex == "-0x0p+0");
15539 assert(ios.width() == 0);
15540 }
15541 ios.width(25);
15542 left(ios);
15543 {
15544 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15545 std::string ex(str, iter.base());
15546 assert(ex == "-0x0p+0******************");
15547 assert(ios.width() == 0);
15548 }
15549 ios.width(25);
15550 right(ios);
15551 {
15552 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15553 std::string ex(str, iter.base());
15554 assert(ex == "******************-0x0p+0");
15555 assert(ios.width() == 0);
15556 }
15557 ios.width(25);
15558 internal(ios);
15559 {
15560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15561 std::string ex(str, iter.base());
15562 assert(ex == "-******************0x0p+0");
15563 assert(ios.width() == 0);
15564 }
15565 }
15566 }
15567 showpoint(ios);
15568 {
15569 ios.imbue(lc);
15570 {
15571 ios.width(0);
15572 {
15573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15574 std::string ex(str, iter.base());
15575 assert(ex == "-0x0.p+0");
15576 assert(ios.width() == 0);
15577 }
15578 ios.width(25);
15579 left(ios);
15580 {
15581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15582 std::string ex(str, iter.base());
15583 assert(ex == "-0x0.p+0*****************");
15584 assert(ios.width() == 0);
15585 }
15586 ios.width(25);
15587 right(ios);
15588 {
15589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15590 std::string ex(str, iter.base());
15591 assert(ex == "*****************-0x0.p+0");
15592 assert(ios.width() == 0);
15593 }
15594 ios.width(25);
15595 internal(ios);
15596 {
15597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15598 std::string ex(str, iter.base());
15599 assert(ex == "-*****************0x0.p+0");
15600 assert(ios.width() == 0);
15601 }
15602 }
15603 ios.imbue(lg);
15604 {
15605 ios.width(0);
15606 {
15607 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15608 std::string ex(str, iter.base());
15609 assert(ex == "-0x0;p+0");
15610 assert(ios.width() == 0);
15611 }
15612 ios.width(25);
15613 left(ios);
15614 {
15615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15616 std::string ex(str, iter.base());
15617 assert(ex == "-0x0;p+0*****************");
15618 assert(ios.width() == 0);
15619 }
15620 ios.width(25);
15621 right(ios);
15622 {
15623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15624 std::string ex(str, iter.base());
15625 assert(ex == "*****************-0x0;p+0");
15626 assert(ios.width() == 0);
15627 }
15628 ios.width(25);
15629 internal(ios);
15630 {
15631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15632 std::string ex(str, iter.base());
15633 assert(ex == "-*****************0x0;p+0");
15634 assert(ios.width() == 0);
15635 }
15636 }
15637 }
15638 }
15639 showpos(ios);
15640 {
15641 noshowpoint(ios);
15642 {
15643 ios.imbue(lc);
15644 {
15645 ios.width(0);
15646 {
15647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15648 std::string ex(str, iter.base());
15649 assert(ex == "-0x0p+0");
15650 assert(ios.width() == 0);
15651 }
15652 ios.width(25);
15653 left(ios);
15654 {
15655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15656 std::string ex(str, iter.base());
15657 assert(ex == "-0x0p+0******************");
15658 assert(ios.width() == 0);
15659 }
15660 ios.width(25);
15661 right(ios);
15662 {
15663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15664 std::string ex(str, iter.base());
15665 assert(ex == "******************-0x0p+0");
15666 assert(ios.width() == 0);
15667 }
15668 ios.width(25);
15669 internal(ios);
15670 {
15671 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15672 std::string ex(str, iter.base());
15673 assert(ex == "-******************0x0p+0");
15674 assert(ios.width() == 0);
15675 }
15676 }
15677 ios.imbue(lg);
15678 {
15679 ios.width(0);
15680 {
15681 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15682 std::string ex(str, iter.base());
15683 assert(ex == "-0x0p+0");
15684 assert(ios.width() == 0);
15685 }
15686 ios.width(25);
15687 left(ios);
15688 {
15689 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15690 std::string ex(str, iter.base());
15691 assert(ex == "-0x0p+0******************");
15692 assert(ios.width() == 0);
15693 }
15694 ios.width(25);
15695 right(ios);
15696 {
15697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15698 std::string ex(str, iter.base());
15699 assert(ex == "******************-0x0p+0");
15700 assert(ios.width() == 0);
15701 }
15702 ios.width(25);
15703 internal(ios);
15704 {
15705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15706 std::string ex(str, iter.base());
15707 assert(ex == "-******************0x0p+0");
15708 assert(ios.width() == 0);
15709 }
15710 }
15711 }
15712 showpoint(ios);
15713 {
15714 ios.imbue(lc);
15715 {
15716 ios.width(0);
15717 {
15718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15719 std::string ex(str, iter.base());
15720 assert(ex == "-0x0.p+0");
15721 assert(ios.width() == 0);
15722 }
15723 ios.width(25);
15724 left(ios);
15725 {
15726 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15727 std::string ex(str, iter.base());
15728 assert(ex == "-0x0.p+0*****************");
15729 assert(ios.width() == 0);
15730 }
15731 ios.width(25);
15732 right(ios);
15733 {
15734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15735 std::string ex(str, iter.base());
15736 assert(ex == "*****************-0x0.p+0");
15737 assert(ios.width() == 0);
15738 }
15739 ios.width(25);
15740 internal(ios);
15741 {
15742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15743 std::string ex(str, iter.base());
15744 assert(ex == "-*****************0x0.p+0");
15745 assert(ios.width() == 0);
15746 }
15747 }
15748 ios.imbue(lg);
15749 {
15750 ios.width(0);
15751 {
15752 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15753 std::string ex(str, iter.base());
15754 assert(ex == "-0x0;p+0");
15755 assert(ios.width() == 0);
15756 }
15757 ios.width(25);
15758 left(ios);
15759 {
15760 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15761 std::string ex(str, iter.base());
15762 assert(ex == "-0x0;p+0*****************");
15763 assert(ios.width() == 0);
15764 }
15765 ios.width(25);
15766 right(ios);
15767 {
15768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15769 std::string ex(str, iter.base());
15770 assert(ex == "*****************-0x0;p+0");
15771 assert(ios.width() == 0);
15772 }
15773 ios.width(25);
15774 internal(ios);
15775 {
15776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15777 std::string ex(str, iter.base());
15778 assert(ex == "-*****************0x0;p+0");
15779 assert(ios.width() == 0);
15780 }
15781 }
15782 }
15783 }
15784 }
15785 uppercase(ios);
15786 {
15787 noshowpos(ios);
15788 {
15789 noshowpoint(ios);
15790 {
15791 ios.imbue(lc);
15792 {
15793 ios.width(0);
15794 {
15795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15796 std::string ex(str, iter.base());
15797 assert(ex == "-0X0P+0");
15798 assert(ios.width() == 0);
15799 }
15800 ios.width(25);
15801 left(ios);
15802 {
15803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15804 std::string ex(str, iter.base());
15805 assert(ex == "-0X0P+0******************");
15806 assert(ios.width() == 0);
15807 }
15808 ios.width(25);
15809 right(ios);
15810 {
15811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15812 std::string ex(str, iter.base());
15813 assert(ex == "******************-0X0P+0");
15814 assert(ios.width() == 0);
15815 }
15816 ios.width(25);
15817 internal(ios);
15818 {
15819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15820 std::string ex(str, iter.base());
15821 assert(ex == "-******************0X0P+0");
15822 assert(ios.width() == 0);
15823 }
15824 }
15825 ios.imbue(lg);
15826 {
15827 ios.width(0);
15828 {
15829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15830 std::string ex(str, iter.base());
15831 assert(ex == "-0X0P+0");
15832 assert(ios.width() == 0);
15833 }
15834 ios.width(25);
15835 left(ios);
15836 {
15837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15838 std::string ex(str, iter.base());
15839 assert(ex == "-0X0P+0******************");
15840 assert(ios.width() == 0);
15841 }
15842 ios.width(25);
15843 right(ios);
15844 {
15845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15846 std::string ex(str, iter.base());
15847 assert(ex == "******************-0X0P+0");
15848 assert(ios.width() == 0);
15849 }
15850 ios.width(25);
15851 internal(ios);
15852 {
15853 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15854 std::string ex(str, iter.base());
15855 assert(ex == "-******************0X0P+0");
15856 assert(ios.width() == 0);
15857 }
15858 }
15859 }
15860 showpoint(ios);
15861 {
15862 ios.imbue(lc);
15863 {
15864 ios.width(0);
15865 {
15866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15867 std::string ex(str, iter.base());
15868 assert(ex == "-0X0.P+0");
15869 assert(ios.width() == 0);
15870 }
15871 ios.width(25);
15872 left(ios);
15873 {
15874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15875 std::string ex(str, iter.base());
15876 assert(ex == "-0X0.P+0*****************");
15877 assert(ios.width() == 0);
15878 }
15879 ios.width(25);
15880 right(ios);
15881 {
15882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15883 std::string ex(str, iter.base());
15884 assert(ex == "*****************-0X0.P+0");
15885 assert(ios.width() == 0);
15886 }
15887 ios.width(25);
15888 internal(ios);
15889 {
15890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15891 std::string ex(str, iter.base());
15892 assert(ex == "-*****************0X0.P+0");
15893 assert(ios.width() == 0);
15894 }
15895 }
15896 ios.imbue(lg);
15897 {
15898 ios.width(0);
15899 {
15900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15901 std::string ex(str, iter.base());
15902 assert(ex == "-0X0;P+0");
15903 assert(ios.width() == 0);
15904 }
15905 ios.width(25);
15906 left(ios);
15907 {
15908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15909 std::string ex(str, iter.base());
15910 assert(ex == "-0X0;P+0*****************");
15911 assert(ios.width() == 0);
15912 }
15913 ios.width(25);
15914 right(ios);
15915 {
15916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15917 std::string ex(str, iter.base());
15918 assert(ex == "*****************-0X0;P+0");
15919 assert(ios.width() == 0);
15920 }
15921 ios.width(25);
15922 internal(ios);
15923 {
15924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15925 std::string ex(str, iter.base());
15926 assert(ex == "-*****************0X0;P+0");
15927 assert(ios.width() == 0);
15928 }
15929 }
15930 }
15931 }
15932 showpos(ios);
15933 {
15934 noshowpoint(ios);
15935 {
15936 ios.imbue(lc);
15937 {
15938 ios.width(0);
15939 {
15940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15941 std::string ex(str, iter.base());
15942 assert(ex == "-0X0P+0");
15943 assert(ios.width() == 0);
15944 }
15945 ios.width(25);
15946 left(ios);
15947 {
15948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15949 std::string ex(str, iter.base());
15950 assert(ex == "-0X0P+0******************");
15951 assert(ios.width() == 0);
15952 }
15953 ios.width(25);
15954 right(ios);
15955 {
15956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15957 std::string ex(str, iter.base());
15958 assert(ex == "******************-0X0P+0");
15959 assert(ios.width() == 0);
15960 }
15961 ios.width(25);
15962 internal(ios);
15963 {
15964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15965 std::string ex(str, iter.base());
15966 assert(ex == "-******************0X0P+0");
15967 assert(ios.width() == 0);
15968 }
15969 }
15970 ios.imbue(lg);
15971 {
15972 ios.width(0);
15973 {
15974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15975 std::string ex(str, iter.base());
15976 assert(ex == "-0X0P+0");
15977 assert(ios.width() == 0);
15978 }
15979 ios.width(25);
15980 left(ios);
15981 {
15982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15983 std::string ex(str, iter.base());
15984 assert(ex == "-0X0P+0******************");
15985 assert(ios.width() == 0);
15986 }
15987 ios.width(25);
15988 right(ios);
15989 {
15990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15991 std::string ex(str, iter.base());
15992 assert(ex == "******************-0X0P+0");
15993 assert(ios.width() == 0);
15994 }
15995 ios.width(25);
15996 internal(ios);
15997 {
15998 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15999 std::string ex(str, iter.base());
16000 assert(ex == "-******************0X0P+0");
16001 assert(ios.width() == 0);
16002 }
16003 }
16004 }
16005 showpoint(ios);
16006 {
16007 ios.imbue(lc);
16008 {
16009 ios.width(0);
16010 {
16011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16012 std::string ex(str, iter.base());
16013 assert(ex == "-0X0.P+0");
16014 assert(ios.width() == 0);
16015 }
16016 ios.width(25);
16017 left(ios);
16018 {
16019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16020 std::string ex(str, iter.base());
16021 assert(ex == "-0X0.P+0*****************");
16022 assert(ios.width() == 0);
16023 }
16024 ios.width(25);
16025 right(ios);
16026 {
16027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16028 std::string ex(str, iter.base());
16029 assert(ex == "*****************-0X0.P+0");
16030 assert(ios.width() == 0);
16031 }
16032 ios.width(25);
16033 internal(ios);
16034 {
16035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16036 std::string ex(str, iter.base());
16037 assert(ex == "-*****************0X0.P+0");
16038 assert(ios.width() == 0);
16039 }
16040 }
16041 ios.imbue(lg);
16042 {
16043 ios.width(0);
16044 {
16045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16046 std::string ex(str, iter.base());
16047 assert(ex == "-0X0;P+0");
16048 assert(ios.width() == 0);
16049 }
16050 ios.width(25);
16051 left(ios);
16052 {
16053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16054 std::string ex(str, iter.base());
16055 assert(ex == "-0X0;P+0*****************");
16056 assert(ios.width() == 0);
16057 }
16058 ios.width(25);
16059 right(ios);
16060 {
16061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16062 std::string ex(str, iter.base());
16063 assert(ex == "*****************-0X0;P+0");
16064 assert(ios.width() == 0);
16065 }
16066 ios.width(25);
16067 internal(ios);
16068 {
16069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16070 std::string ex(str, iter.base());
16071 assert(ex == "-*****************0X0;P+0");
16072 assert(ios.width() == 0);
16073 }
16074 }
16075 }
16076 }
16077 }
16078 }
16079 ios.precision(16);
16080 {
16081 }
16082 ios.precision(60);
16083 {
16084 }
16085 }
16086 }
16087 }
16088
test8()16089 void test8()
16090 {
16091 char str[200];
16092 output_iterator<char*> iter;
16093 std::locale lc = std::locale::classic();
16094 std::locale lg(lc, new my_numpunct);
16095 const my_facet f(1);
16096 {
16097 double v = 1234567890.125;
16098 std::ios ios(0);
16099 hexfloat(ios);
16100 // %a
16101 {
16102 ios.precision(0);
16103 {
16104 nouppercase(ios);
16105 {
16106 noshowpos(ios);
16107 {
16108 noshowpoint(ios);
16109 {
16110 ios.imbue(lc);
16111 {
16112 ios.width(0);
16113 {
16114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16115 std::string ex(str, iter.base());
16116 assert(ex == "0x1.26580b488p+30");
16117 assert(ios.width() == 0);
16118 }
16119 ios.width(25);
16120 left(ios);
16121 {
16122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16123 std::string ex(str, iter.base());
16124 assert(ex == "0x1.26580b488p+30********");
16125 assert(ios.width() == 0);
16126 }
16127 ios.width(25);
16128 right(ios);
16129 {
16130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16131 std::string ex(str, iter.base());
16132 assert(ex == "********0x1.26580b488p+30");
16133 assert(ios.width() == 0);
16134 }
16135 ios.width(25);
16136 internal(ios);
16137 {
16138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16139 std::string ex(str, iter.base());
16140 assert(ex == "0x********1.26580b488p+30");
16141 assert(ios.width() == 0);
16142 }
16143 }
16144 ios.imbue(lg);
16145 {
16146 ios.width(0);
16147 {
16148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16149 std::string ex(str, iter.base());
16150 assert(ex == "0x1;26580b488p+30");
16151 assert(ios.width() == 0);
16152 }
16153 ios.width(25);
16154 left(ios);
16155 {
16156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16157 std::string ex(str, iter.base());
16158 assert(ex == "0x1;26580b488p+30********");
16159 assert(ios.width() == 0);
16160 }
16161 ios.width(25);
16162 right(ios);
16163 {
16164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16165 std::string ex(str, iter.base());
16166 assert(ex == "********0x1;26580b488p+30");
16167 assert(ios.width() == 0);
16168 }
16169 ios.width(25);
16170 internal(ios);
16171 {
16172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16173 std::string ex(str, iter.base());
16174 assert(ex == "0x********1;26580b488p+30");
16175 assert(ios.width() == 0);
16176 }
16177 }
16178 }
16179 showpoint(ios);
16180 {
16181 ios.imbue(lc);
16182 {
16183 ios.width(0);
16184 {
16185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16186 std::string ex(str, iter.base());
16187 assert(ex == "0x1.26580b488p+30");
16188 assert(ios.width() == 0);
16189 }
16190 ios.width(25);
16191 left(ios);
16192 {
16193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16194 std::string ex(str, iter.base());
16195 assert(ex == "0x1.26580b488p+30********");
16196 assert(ios.width() == 0);
16197 }
16198 ios.width(25);
16199 right(ios);
16200 {
16201 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16202 std::string ex(str, iter.base());
16203 assert(ex == "********0x1.26580b488p+30");
16204 assert(ios.width() == 0);
16205 }
16206 ios.width(25);
16207 internal(ios);
16208 {
16209 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16210 std::string ex(str, iter.base());
16211 assert(ex == "0x********1.26580b488p+30");
16212 assert(ios.width() == 0);
16213 }
16214 }
16215 ios.imbue(lg);
16216 {
16217 ios.width(0);
16218 {
16219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16220 std::string ex(str, iter.base());
16221 assert(ex == "0x1;26580b488p+30");
16222 assert(ios.width() == 0);
16223 }
16224 ios.width(25);
16225 left(ios);
16226 {
16227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16228 std::string ex(str, iter.base());
16229 assert(ex == "0x1;26580b488p+30********");
16230 assert(ios.width() == 0);
16231 }
16232 ios.width(25);
16233 right(ios);
16234 {
16235 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16236 std::string ex(str, iter.base());
16237 assert(ex == "********0x1;26580b488p+30");
16238 assert(ios.width() == 0);
16239 }
16240 ios.width(25);
16241 internal(ios);
16242 {
16243 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16244 std::string ex(str, iter.base());
16245 assert(ex == "0x********1;26580b488p+30");
16246 assert(ios.width() == 0);
16247 }
16248 }
16249 }
16250 }
16251 showpos(ios);
16252 {
16253 noshowpoint(ios);
16254 {
16255 ios.imbue(lc);
16256 {
16257 ios.width(0);
16258 {
16259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16260 std::string ex(str, iter.base());
16261 assert(ex == "+0x1.26580b488p+30");
16262 assert(ios.width() == 0);
16263 }
16264 ios.width(25);
16265 left(ios);
16266 {
16267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16268 std::string ex(str, iter.base());
16269 assert(ex == "+0x1.26580b488p+30*******");
16270 assert(ios.width() == 0);
16271 }
16272 ios.width(25);
16273 right(ios);
16274 {
16275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16276 std::string ex(str, iter.base());
16277 assert(ex == "*******+0x1.26580b488p+30");
16278 assert(ios.width() == 0);
16279 }
16280 ios.width(25);
16281 internal(ios);
16282 {
16283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16284 std::string ex(str, iter.base());
16285 assert(ex == "+*******0x1.26580b488p+30");
16286 assert(ios.width() == 0);
16287 }
16288 }
16289 ios.imbue(lg);
16290 {
16291 ios.width(0);
16292 {
16293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16294 std::string ex(str, iter.base());
16295 assert(ex == "+0x1;26580b488p+30");
16296 assert(ios.width() == 0);
16297 }
16298 ios.width(25);
16299 left(ios);
16300 {
16301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16302 std::string ex(str, iter.base());
16303 assert(ex == "+0x1;26580b488p+30*******");
16304 assert(ios.width() == 0);
16305 }
16306 ios.width(25);
16307 right(ios);
16308 {
16309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16310 std::string ex(str, iter.base());
16311 assert(ex == "*******+0x1;26580b488p+30");
16312 assert(ios.width() == 0);
16313 }
16314 ios.width(25);
16315 internal(ios);
16316 {
16317 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16318 std::string ex(str, iter.base());
16319 assert(ex == "+*******0x1;26580b488p+30");
16320 assert(ios.width() == 0);
16321 }
16322 }
16323 }
16324 showpoint(ios);
16325 {
16326 ios.imbue(lc);
16327 {
16328 ios.width(0);
16329 {
16330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16331 std::string ex(str, iter.base());
16332 assert(ex == "+0x1.26580b488p+30");
16333 assert(ios.width() == 0);
16334 }
16335 ios.width(25);
16336 left(ios);
16337 {
16338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16339 std::string ex(str, iter.base());
16340 assert(ex == "+0x1.26580b488p+30*******");
16341 assert(ios.width() == 0);
16342 }
16343 ios.width(25);
16344 right(ios);
16345 {
16346 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16347 std::string ex(str, iter.base());
16348 assert(ex == "*******+0x1.26580b488p+30");
16349 assert(ios.width() == 0);
16350 }
16351 ios.width(25);
16352 internal(ios);
16353 {
16354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16355 std::string ex(str, iter.base());
16356 assert(ex == "+*******0x1.26580b488p+30");
16357 assert(ios.width() == 0);
16358 }
16359 }
16360 ios.imbue(lg);
16361 {
16362 ios.width(0);
16363 {
16364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16365 std::string ex(str, iter.base());
16366 assert(ex == "+0x1;26580b488p+30");
16367 assert(ios.width() == 0);
16368 }
16369 ios.width(25);
16370 left(ios);
16371 {
16372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16373 std::string ex(str, iter.base());
16374 assert(ex == "+0x1;26580b488p+30*******");
16375 assert(ios.width() == 0);
16376 }
16377 ios.width(25);
16378 right(ios);
16379 {
16380 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16381 std::string ex(str, iter.base());
16382 assert(ex == "*******+0x1;26580b488p+30");
16383 assert(ios.width() == 0);
16384 }
16385 ios.width(25);
16386 internal(ios);
16387 {
16388 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16389 std::string ex(str, iter.base());
16390 assert(ex == "+*******0x1;26580b488p+30");
16391 assert(ios.width() == 0);
16392 }
16393 }
16394 }
16395 }
16396 }
16397 uppercase(ios);
16398 {
16399 noshowpos(ios);
16400 {
16401 noshowpoint(ios);
16402 {
16403 ios.imbue(lc);
16404 {
16405 ios.width(0);
16406 {
16407 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16408 std::string ex(str, iter.base());
16409 assert(ex == "0X1.26580B488P+30");
16410 assert(ios.width() == 0);
16411 }
16412 ios.width(25);
16413 left(ios);
16414 {
16415 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16416 std::string ex(str, iter.base());
16417 assert(ex == "0X1.26580B488P+30********");
16418 assert(ios.width() == 0);
16419 }
16420 ios.width(25);
16421 right(ios);
16422 {
16423 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16424 std::string ex(str, iter.base());
16425 assert(ex == "********0X1.26580B488P+30");
16426 assert(ios.width() == 0);
16427 }
16428 ios.width(25);
16429 internal(ios);
16430 {
16431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16432 std::string ex(str, iter.base());
16433 assert(ex == "0X********1.26580B488P+30");
16434 assert(ios.width() == 0);
16435 }
16436 }
16437 ios.imbue(lg);
16438 {
16439 ios.width(0);
16440 {
16441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16442 std::string ex(str, iter.base());
16443 assert(ex == "0X1;26580B488P+30");
16444 assert(ios.width() == 0);
16445 }
16446 ios.width(25);
16447 left(ios);
16448 {
16449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16450 std::string ex(str, iter.base());
16451 assert(ex == "0X1;26580B488P+30********");
16452 assert(ios.width() == 0);
16453 }
16454 ios.width(25);
16455 right(ios);
16456 {
16457 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16458 std::string ex(str, iter.base());
16459 assert(ex == "********0X1;26580B488P+30");
16460 assert(ios.width() == 0);
16461 }
16462 ios.width(25);
16463 internal(ios);
16464 {
16465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16466 std::string ex(str, iter.base());
16467 assert(ex == "0X********1;26580B488P+30");
16468 assert(ios.width() == 0);
16469 }
16470 }
16471 }
16472 showpoint(ios);
16473 {
16474 ios.imbue(lc);
16475 {
16476 ios.width(0);
16477 {
16478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16479 std::string ex(str, iter.base());
16480 assert(ex == "0X1.26580B488P+30");
16481 assert(ios.width() == 0);
16482 }
16483 ios.width(25);
16484 left(ios);
16485 {
16486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16487 std::string ex(str, iter.base());
16488 assert(ex == "0X1.26580B488P+30********");
16489 assert(ios.width() == 0);
16490 }
16491 ios.width(25);
16492 right(ios);
16493 {
16494 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16495 std::string ex(str, iter.base());
16496 assert(ex == "********0X1.26580B488P+30");
16497 assert(ios.width() == 0);
16498 }
16499 ios.width(25);
16500 internal(ios);
16501 {
16502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16503 std::string ex(str, iter.base());
16504 assert(ex == "0X********1.26580B488P+30");
16505 assert(ios.width() == 0);
16506 }
16507 }
16508 ios.imbue(lg);
16509 {
16510 ios.width(0);
16511 {
16512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16513 std::string ex(str, iter.base());
16514 assert(ex == "0X1;26580B488P+30");
16515 assert(ios.width() == 0);
16516 }
16517 ios.width(25);
16518 left(ios);
16519 {
16520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16521 std::string ex(str, iter.base());
16522 assert(ex == "0X1;26580B488P+30********");
16523 assert(ios.width() == 0);
16524 }
16525 ios.width(25);
16526 right(ios);
16527 {
16528 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16529 std::string ex(str, iter.base());
16530 assert(ex == "********0X1;26580B488P+30");
16531 assert(ios.width() == 0);
16532 }
16533 ios.width(25);
16534 internal(ios);
16535 {
16536 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16537 std::string ex(str, iter.base());
16538 assert(ex == "0X********1;26580B488P+30");
16539 assert(ios.width() == 0);
16540 }
16541 }
16542 }
16543 }
16544 showpos(ios);
16545 {
16546 noshowpoint(ios);
16547 {
16548 ios.imbue(lc);
16549 {
16550 ios.width(0);
16551 {
16552 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16553 std::string ex(str, iter.base());
16554 assert(ex == "+0X1.26580B488P+30");
16555 assert(ios.width() == 0);
16556 }
16557 ios.width(25);
16558 left(ios);
16559 {
16560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16561 std::string ex(str, iter.base());
16562 assert(ex == "+0X1.26580B488P+30*******");
16563 assert(ios.width() == 0);
16564 }
16565 ios.width(25);
16566 right(ios);
16567 {
16568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16569 std::string ex(str, iter.base());
16570 assert(ex == "*******+0X1.26580B488P+30");
16571 assert(ios.width() == 0);
16572 }
16573 ios.width(25);
16574 internal(ios);
16575 {
16576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16577 std::string ex(str, iter.base());
16578 assert(ex == "+*******0X1.26580B488P+30");
16579 assert(ios.width() == 0);
16580 }
16581 }
16582 ios.imbue(lg);
16583 {
16584 ios.width(0);
16585 {
16586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16587 std::string ex(str, iter.base());
16588 assert(ex == "+0X1;26580B488P+30");
16589 assert(ios.width() == 0);
16590 }
16591 ios.width(25);
16592 left(ios);
16593 {
16594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16595 std::string ex(str, iter.base());
16596 assert(ex == "+0X1;26580B488P+30*******");
16597 assert(ios.width() == 0);
16598 }
16599 ios.width(25);
16600 right(ios);
16601 {
16602 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16603 std::string ex(str, iter.base());
16604 assert(ex == "*******+0X1;26580B488P+30");
16605 assert(ios.width() == 0);
16606 }
16607 ios.width(25);
16608 internal(ios);
16609 {
16610 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16611 std::string ex(str, iter.base());
16612 assert(ex == "+*******0X1;26580B488P+30");
16613 assert(ios.width() == 0);
16614 }
16615 }
16616 }
16617 showpoint(ios);
16618 {
16619 ios.imbue(lc);
16620 {
16621 ios.width(0);
16622 {
16623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16624 std::string ex(str, iter.base());
16625 assert(ex == "+0X1.26580B488P+30");
16626 assert(ios.width() == 0);
16627 }
16628 ios.width(25);
16629 left(ios);
16630 {
16631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16632 std::string ex(str, iter.base());
16633 assert(ex == "+0X1.26580B488P+30*******");
16634 assert(ios.width() == 0);
16635 }
16636 ios.width(25);
16637 right(ios);
16638 {
16639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16640 std::string ex(str, iter.base());
16641 assert(ex == "*******+0X1.26580B488P+30");
16642 assert(ios.width() == 0);
16643 }
16644 ios.width(25);
16645 internal(ios);
16646 {
16647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16648 std::string ex(str, iter.base());
16649 assert(ex == "+*******0X1.26580B488P+30");
16650 assert(ios.width() == 0);
16651 }
16652 }
16653 ios.imbue(lg);
16654 {
16655 ios.width(0);
16656 {
16657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16658 std::string ex(str, iter.base());
16659 assert(ex == "+0X1;26580B488P+30");
16660 assert(ios.width() == 0);
16661 }
16662 ios.width(25);
16663 left(ios);
16664 {
16665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16666 std::string ex(str, iter.base());
16667 assert(ex == "+0X1;26580B488P+30*******");
16668 assert(ios.width() == 0);
16669 }
16670 ios.width(25);
16671 right(ios);
16672 {
16673 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16674 std::string ex(str, iter.base());
16675 assert(ex == "*******+0X1;26580B488P+30");
16676 assert(ios.width() == 0);
16677 }
16678 ios.width(25);
16679 internal(ios);
16680 {
16681 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16682 std::string ex(str, iter.base());
16683 assert(ex == "+*******0X1;26580B488P+30");
16684 assert(ios.width() == 0);
16685 }
16686 }
16687 }
16688 }
16689 }
16690 }
16691 ios.precision(1);
16692 {
16693 nouppercase(ios);
16694 {
16695 noshowpos(ios);
16696 {
16697 noshowpoint(ios);
16698 {
16699 ios.imbue(lc);
16700 {
16701 ios.width(0);
16702 {
16703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16704 std::string ex(str, iter.base());
16705 assert(ex == "0x1.26580b488p+30");
16706 assert(ios.width() == 0);
16707 }
16708 ios.width(25);
16709 left(ios);
16710 {
16711 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16712 std::string ex(str, iter.base());
16713 assert(ex == "0x1.26580b488p+30********");
16714 assert(ios.width() == 0);
16715 }
16716 ios.width(25);
16717 right(ios);
16718 {
16719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16720 std::string ex(str, iter.base());
16721 assert(ex == "********0x1.26580b488p+30");
16722 assert(ios.width() == 0);
16723 }
16724 ios.width(25);
16725 internal(ios);
16726 {
16727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16728 std::string ex(str, iter.base());
16729 assert(ex == "0x********1.26580b488p+30");
16730 assert(ios.width() == 0);
16731 }
16732 }
16733 ios.imbue(lg);
16734 {
16735 ios.width(0);
16736 {
16737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16738 std::string ex(str, iter.base());
16739 assert(ex == "0x1;26580b488p+30");
16740 assert(ios.width() == 0);
16741 }
16742 ios.width(25);
16743 left(ios);
16744 {
16745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16746 std::string ex(str, iter.base());
16747 assert(ex == "0x1;26580b488p+30********");
16748 assert(ios.width() == 0);
16749 }
16750 ios.width(25);
16751 right(ios);
16752 {
16753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16754 std::string ex(str, iter.base());
16755 assert(ex == "********0x1;26580b488p+30");
16756 assert(ios.width() == 0);
16757 }
16758 ios.width(25);
16759 internal(ios);
16760 {
16761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16762 std::string ex(str, iter.base());
16763 assert(ex == "0x********1;26580b488p+30");
16764 assert(ios.width() == 0);
16765 }
16766 }
16767 }
16768 showpoint(ios);
16769 {
16770 ios.imbue(lc);
16771 {
16772 ios.width(0);
16773 {
16774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16775 std::string ex(str, iter.base());
16776 assert(ex == "0x1.26580b488p+30");
16777 assert(ios.width() == 0);
16778 }
16779 ios.width(25);
16780 left(ios);
16781 {
16782 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16783 std::string ex(str, iter.base());
16784 assert(ex == "0x1.26580b488p+30********");
16785 assert(ios.width() == 0);
16786 }
16787 ios.width(25);
16788 right(ios);
16789 {
16790 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16791 std::string ex(str, iter.base());
16792 assert(ex == "********0x1.26580b488p+30");
16793 assert(ios.width() == 0);
16794 }
16795 ios.width(25);
16796 internal(ios);
16797 {
16798 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16799 std::string ex(str, iter.base());
16800 assert(ex == "0x********1.26580b488p+30");
16801 assert(ios.width() == 0);
16802 }
16803 }
16804 ios.imbue(lg);
16805 {
16806 ios.width(0);
16807 {
16808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16809 std::string ex(str, iter.base());
16810 assert(ex == "0x1;26580b488p+30");
16811 assert(ios.width() == 0);
16812 }
16813 ios.width(25);
16814 left(ios);
16815 {
16816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16817 std::string ex(str, iter.base());
16818 assert(ex == "0x1;26580b488p+30********");
16819 assert(ios.width() == 0);
16820 }
16821 ios.width(25);
16822 right(ios);
16823 {
16824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16825 std::string ex(str, iter.base());
16826 assert(ex == "********0x1;26580b488p+30");
16827 assert(ios.width() == 0);
16828 }
16829 ios.width(25);
16830 internal(ios);
16831 {
16832 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16833 std::string ex(str, iter.base());
16834 assert(ex == "0x********1;26580b488p+30");
16835 assert(ios.width() == 0);
16836 }
16837 }
16838 }
16839 }
16840 showpos(ios);
16841 {
16842 noshowpoint(ios);
16843 {
16844 ios.imbue(lc);
16845 {
16846 ios.width(0);
16847 {
16848 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16849 std::string ex(str, iter.base());
16850 assert(ex == "+0x1.26580b488p+30");
16851 assert(ios.width() == 0);
16852 }
16853 ios.width(25);
16854 left(ios);
16855 {
16856 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16857 std::string ex(str, iter.base());
16858 assert(ex == "+0x1.26580b488p+30*******");
16859 assert(ios.width() == 0);
16860 }
16861 ios.width(25);
16862 right(ios);
16863 {
16864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16865 std::string ex(str, iter.base());
16866 assert(ex == "*******+0x1.26580b488p+30");
16867 assert(ios.width() == 0);
16868 }
16869 ios.width(25);
16870 internal(ios);
16871 {
16872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16873 std::string ex(str, iter.base());
16874 assert(ex == "+*******0x1.26580b488p+30");
16875 assert(ios.width() == 0);
16876 }
16877 }
16878 ios.imbue(lg);
16879 {
16880 ios.width(0);
16881 {
16882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16883 std::string ex(str, iter.base());
16884 assert(ex == "+0x1;26580b488p+30");
16885 assert(ios.width() == 0);
16886 }
16887 ios.width(25);
16888 left(ios);
16889 {
16890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16891 std::string ex(str, iter.base());
16892 assert(ex == "+0x1;26580b488p+30*******");
16893 assert(ios.width() == 0);
16894 }
16895 ios.width(25);
16896 right(ios);
16897 {
16898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16899 std::string ex(str, iter.base());
16900 assert(ex == "*******+0x1;26580b488p+30");
16901 assert(ios.width() == 0);
16902 }
16903 ios.width(25);
16904 internal(ios);
16905 {
16906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16907 std::string ex(str, iter.base());
16908 assert(ex == "+*******0x1;26580b488p+30");
16909 assert(ios.width() == 0);
16910 }
16911 }
16912 }
16913 showpoint(ios);
16914 {
16915 ios.imbue(lc);
16916 {
16917 ios.width(0);
16918 {
16919 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16920 std::string ex(str, iter.base());
16921 assert(ex == "+0x1.26580b488p+30");
16922 assert(ios.width() == 0);
16923 }
16924 ios.width(25);
16925 left(ios);
16926 {
16927 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16928 std::string ex(str, iter.base());
16929 assert(ex == "+0x1.26580b488p+30*******");
16930 assert(ios.width() == 0);
16931 }
16932 ios.width(25);
16933 right(ios);
16934 {
16935 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16936 std::string ex(str, iter.base());
16937 assert(ex == "*******+0x1.26580b488p+30");
16938 assert(ios.width() == 0);
16939 }
16940 ios.width(25);
16941 internal(ios);
16942 {
16943 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16944 std::string ex(str, iter.base());
16945 assert(ex == "+*******0x1.26580b488p+30");
16946 assert(ios.width() == 0);
16947 }
16948 }
16949 ios.imbue(lg);
16950 {
16951 ios.width(0);
16952 {
16953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16954 std::string ex(str, iter.base());
16955 assert(ex == "+0x1;26580b488p+30");
16956 assert(ios.width() == 0);
16957 }
16958 ios.width(25);
16959 left(ios);
16960 {
16961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16962 std::string ex(str, iter.base());
16963 assert(ex == "+0x1;26580b488p+30*******");
16964 assert(ios.width() == 0);
16965 }
16966 ios.width(25);
16967 right(ios);
16968 {
16969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16970 std::string ex(str, iter.base());
16971 assert(ex == "*******+0x1;26580b488p+30");
16972 assert(ios.width() == 0);
16973 }
16974 ios.width(25);
16975 internal(ios);
16976 {
16977 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16978 std::string ex(str, iter.base());
16979 assert(ex == "+*******0x1;26580b488p+30");
16980 assert(ios.width() == 0);
16981 }
16982 }
16983 }
16984 }
16985 }
16986 uppercase(ios);
16987 {
16988 noshowpos(ios);
16989 {
16990 noshowpoint(ios);
16991 {
16992 ios.imbue(lc);
16993 {
16994 ios.width(0);
16995 {
16996 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16997 std::string ex(str, iter.base());
16998 assert(ex == "0X1.26580B488P+30");
16999 assert(ios.width() == 0);
17000 }
17001 ios.width(25);
17002 left(ios);
17003 {
17004 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17005 std::string ex(str, iter.base());
17006 assert(ex == "0X1.26580B488P+30********");
17007 assert(ios.width() == 0);
17008 }
17009 ios.width(25);
17010 right(ios);
17011 {
17012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17013 std::string ex(str, iter.base());
17014 assert(ex == "********0X1.26580B488P+30");
17015 assert(ios.width() == 0);
17016 }
17017 ios.width(25);
17018 internal(ios);
17019 {
17020 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17021 std::string ex(str, iter.base());
17022 assert(ex == "0X********1.26580B488P+30");
17023 assert(ios.width() == 0);
17024 }
17025 }
17026 ios.imbue(lg);
17027 {
17028 ios.width(0);
17029 {
17030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17031 std::string ex(str, iter.base());
17032 assert(ex == "0X1;26580B488P+30");
17033 assert(ios.width() == 0);
17034 }
17035 ios.width(25);
17036 left(ios);
17037 {
17038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17039 std::string ex(str, iter.base());
17040 assert(ex == "0X1;26580B488P+30********");
17041 assert(ios.width() == 0);
17042 }
17043 ios.width(25);
17044 right(ios);
17045 {
17046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17047 std::string ex(str, iter.base());
17048 assert(ex == "********0X1;26580B488P+30");
17049 assert(ios.width() == 0);
17050 }
17051 ios.width(25);
17052 internal(ios);
17053 {
17054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17055 std::string ex(str, iter.base());
17056 assert(ex == "0X********1;26580B488P+30");
17057 assert(ios.width() == 0);
17058 }
17059 }
17060 }
17061 showpoint(ios);
17062 {
17063 ios.imbue(lc);
17064 {
17065 ios.width(0);
17066 {
17067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17068 std::string ex(str, iter.base());
17069 assert(ex == "0X1.26580B488P+30");
17070 assert(ios.width() == 0);
17071 }
17072 ios.width(25);
17073 left(ios);
17074 {
17075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17076 std::string ex(str, iter.base());
17077 assert(ex == "0X1.26580B488P+30********");
17078 assert(ios.width() == 0);
17079 }
17080 ios.width(25);
17081 right(ios);
17082 {
17083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17084 std::string ex(str, iter.base());
17085 assert(ex == "********0X1.26580B488P+30");
17086 assert(ios.width() == 0);
17087 }
17088 ios.width(25);
17089 internal(ios);
17090 {
17091 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17092 std::string ex(str, iter.base());
17093 assert(ex == "0X********1.26580B488P+30");
17094 assert(ios.width() == 0);
17095 }
17096 }
17097 ios.imbue(lg);
17098 {
17099 ios.width(0);
17100 {
17101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17102 std::string ex(str, iter.base());
17103 assert(ex == "0X1;26580B488P+30");
17104 assert(ios.width() == 0);
17105 }
17106 ios.width(25);
17107 left(ios);
17108 {
17109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17110 std::string ex(str, iter.base());
17111 assert(ex == "0X1;26580B488P+30********");
17112 assert(ios.width() == 0);
17113 }
17114 ios.width(25);
17115 right(ios);
17116 {
17117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17118 std::string ex(str, iter.base());
17119 assert(ex == "********0X1;26580B488P+30");
17120 assert(ios.width() == 0);
17121 }
17122 ios.width(25);
17123 internal(ios);
17124 {
17125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17126 std::string ex(str, iter.base());
17127 assert(ex == "0X********1;26580B488P+30");
17128 assert(ios.width() == 0);
17129 }
17130 }
17131 }
17132 }
17133 showpos(ios);
17134 {
17135 noshowpoint(ios);
17136 {
17137 ios.imbue(lc);
17138 {
17139 ios.width(0);
17140 {
17141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17142 std::string ex(str, iter.base());
17143 assert(ex == "+0X1.26580B488P+30");
17144 assert(ios.width() == 0);
17145 }
17146 ios.width(25);
17147 left(ios);
17148 {
17149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17150 std::string ex(str, iter.base());
17151 assert(ex == "+0X1.26580B488P+30*******");
17152 assert(ios.width() == 0);
17153 }
17154 ios.width(25);
17155 right(ios);
17156 {
17157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17158 std::string ex(str, iter.base());
17159 assert(ex == "*******+0X1.26580B488P+30");
17160 assert(ios.width() == 0);
17161 }
17162 ios.width(25);
17163 internal(ios);
17164 {
17165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17166 std::string ex(str, iter.base());
17167 assert(ex == "+*******0X1.26580B488P+30");
17168 assert(ios.width() == 0);
17169 }
17170 }
17171 ios.imbue(lg);
17172 {
17173 ios.width(0);
17174 {
17175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17176 std::string ex(str, iter.base());
17177 assert(ex == "+0X1;26580B488P+30");
17178 assert(ios.width() == 0);
17179 }
17180 ios.width(25);
17181 left(ios);
17182 {
17183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17184 std::string ex(str, iter.base());
17185 assert(ex == "+0X1;26580B488P+30*******");
17186 assert(ios.width() == 0);
17187 }
17188 ios.width(25);
17189 right(ios);
17190 {
17191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17192 std::string ex(str, iter.base());
17193 assert(ex == "*******+0X1;26580B488P+30");
17194 assert(ios.width() == 0);
17195 }
17196 ios.width(25);
17197 internal(ios);
17198 {
17199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17200 std::string ex(str, iter.base());
17201 assert(ex == "+*******0X1;26580B488P+30");
17202 assert(ios.width() == 0);
17203 }
17204 }
17205 }
17206 showpoint(ios);
17207 {
17208 ios.imbue(lc);
17209 {
17210 ios.width(0);
17211 {
17212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17213 std::string ex(str, iter.base());
17214 assert(ex == "+0X1.26580B488P+30");
17215 assert(ios.width() == 0);
17216 }
17217 ios.width(25);
17218 left(ios);
17219 {
17220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17221 std::string ex(str, iter.base());
17222 assert(ex == "+0X1.26580B488P+30*******");
17223 assert(ios.width() == 0);
17224 }
17225 ios.width(25);
17226 right(ios);
17227 {
17228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17229 std::string ex(str, iter.base());
17230 assert(ex == "*******+0X1.26580B488P+30");
17231 assert(ios.width() == 0);
17232 }
17233 ios.width(25);
17234 internal(ios);
17235 {
17236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17237 std::string ex(str, iter.base());
17238 assert(ex == "+*******0X1.26580B488P+30");
17239 assert(ios.width() == 0);
17240 }
17241 }
17242 ios.imbue(lg);
17243 {
17244 ios.width(0);
17245 {
17246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17247 std::string ex(str, iter.base());
17248 assert(ex == "+0X1;26580B488P+30");
17249 assert(ios.width() == 0);
17250 }
17251 ios.width(25);
17252 left(ios);
17253 {
17254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17255 std::string ex(str, iter.base());
17256 assert(ex == "+0X1;26580B488P+30*******");
17257 assert(ios.width() == 0);
17258 }
17259 ios.width(25);
17260 right(ios);
17261 {
17262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17263 std::string ex(str, iter.base());
17264 assert(ex == "*******+0X1;26580B488P+30");
17265 assert(ios.width() == 0);
17266 }
17267 ios.width(25);
17268 internal(ios);
17269 {
17270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17271 std::string ex(str, iter.base());
17272 assert(ex == "+*******0X1;26580B488P+30");
17273 assert(ios.width() == 0);
17274 }
17275 }
17276 }
17277 }
17278 }
17279 }
17280 ios.precision(6);
17281 {
17282 }
17283 ios.precision(16);
17284 {
17285 }
17286 ios.precision(60);
17287 {
17288 nouppercase(ios);
17289 {
17290 noshowpos(ios);
17291 {
17292 noshowpoint(ios);
17293 {
17294 ios.imbue(lc);
17295 {
17296 ios.width(0);
17297 {
17298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17299 std::string ex(str, iter.base());
17300 assert(ex == "0x1.26580b488p+30");
17301 assert(ios.width() == 0);
17302 }
17303 ios.width(25);
17304 left(ios);
17305 {
17306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17307 std::string ex(str, iter.base());
17308 assert(ex == "0x1.26580b488p+30********");
17309 assert(ios.width() == 0);
17310 }
17311 ios.width(25);
17312 right(ios);
17313 {
17314 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17315 std::string ex(str, iter.base());
17316 assert(ex == "********0x1.26580b488p+30");
17317 assert(ios.width() == 0);
17318 }
17319 ios.width(25);
17320 internal(ios);
17321 {
17322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17323 std::string ex(str, iter.base());
17324 assert(ex == "0x********1.26580b488p+30");
17325 assert(ios.width() == 0);
17326 }
17327 }
17328 ios.imbue(lg);
17329 {
17330 ios.width(0);
17331 {
17332 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17333 std::string ex(str, iter.base());
17334 assert(ex == "0x1;26580b488p+30");
17335 assert(ios.width() == 0);
17336 }
17337 ios.width(25);
17338 left(ios);
17339 {
17340 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17341 std::string ex(str, iter.base());
17342 assert(ex == "0x1;26580b488p+30********");
17343 assert(ios.width() == 0);
17344 }
17345 ios.width(25);
17346 right(ios);
17347 {
17348 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17349 std::string ex(str, iter.base());
17350 assert(ex == "********0x1;26580b488p+30");
17351 assert(ios.width() == 0);
17352 }
17353 ios.width(25);
17354 internal(ios);
17355 {
17356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17357 std::string ex(str, iter.base());
17358 assert(ex == "0x********1;26580b488p+30");
17359 assert(ios.width() == 0);
17360 }
17361 }
17362 }
17363 showpoint(ios);
17364 {
17365 ios.imbue(lc);
17366 {
17367 ios.width(0);
17368 {
17369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17370 std::string ex(str, iter.base());
17371 assert(ex == "0x1.26580b488p+30");
17372 assert(ios.width() == 0);
17373 }
17374 ios.width(25);
17375 left(ios);
17376 {
17377 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17378 std::string ex(str, iter.base());
17379 assert(ex == "0x1.26580b488p+30********");
17380 assert(ios.width() == 0);
17381 }
17382 ios.width(25);
17383 right(ios);
17384 {
17385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17386 std::string ex(str, iter.base());
17387 assert(ex == "********0x1.26580b488p+30");
17388 assert(ios.width() == 0);
17389 }
17390 ios.width(25);
17391 internal(ios);
17392 {
17393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17394 std::string ex(str, iter.base());
17395 assert(ex == "0x********1.26580b488p+30");
17396 assert(ios.width() == 0);
17397 }
17398 }
17399 ios.imbue(lg);
17400 {
17401 ios.width(0);
17402 {
17403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17404 std::string ex(str, iter.base());
17405 assert(ex == "0x1;26580b488p+30");
17406 assert(ios.width() == 0);
17407 }
17408 ios.width(25);
17409 left(ios);
17410 {
17411 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17412 std::string ex(str, iter.base());
17413 assert(ex == "0x1;26580b488p+30********");
17414 assert(ios.width() == 0);
17415 }
17416 ios.width(25);
17417 right(ios);
17418 {
17419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17420 std::string ex(str, iter.base());
17421 assert(ex == "********0x1;26580b488p+30");
17422 assert(ios.width() == 0);
17423 }
17424 ios.width(25);
17425 internal(ios);
17426 {
17427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17428 std::string ex(str, iter.base());
17429 assert(ex == "0x********1;26580b488p+30");
17430 assert(ios.width() == 0);
17431 }
17432 }
17433 }
17434 }
17435 showpos(ios);
17436 {
17437 noshowpoint(ios);
17438 {
17439 ios.imbue(lc);
17440 {
17441 ios.width(0);
17442 {
17443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17444 std::string ex(str, iter.base());
17445 assert(ex == "+0x1.26580b488p+30");
17446 assert(ios.width() == 0);
17447 }
17448 ios.width(25);
17449 left(ios);
17450 {
17451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17452 std::string ex(str, iter.base());
17453 assert(ex == "+0x1.26580b488p+30*******");
17454 assert(ios.width() == 0);
17455 }
17456 ios.width(25);
17457 right(ios);
17458 {
17459 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17460 std::string ex(str, iter.base());
17461 assert(ex == "*******+0x1.26580b488p+30");
17462 assert(ios.width() == 0);
17463 }
17464 ios.width(25);
17465 internal(ios);
17466 {
17467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17468 std::string ex(str, iter.base());
17469 assert(ex == "+*******0x1.26580b488p+30");
17470 assert(ios.width() == 0);
17471 }
17472 }
17473 ios.imbue(lg);
17474 {
17475 ios.width(0);
17476 {
17477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17478 std::string ex(str, iter.base());
17479 assert(ex == "+0x1;26580b488p+30");
17480 assert(ios.width() == 0);
17481 }
17482 ios.width(25);
17483 left(ios);
17484 {
17485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17486 std::string ex(str, iter.base());
17487 assert(ex == "+0x1;26580b488p+30*******");
17488 assert(ios.width() == 0);
17489 }
17490 ios.width(25);
17491 right(ios);
17492 {
17493 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17494 std::string ex(str, iter.base());
17495 assert(ex == "*******+0x1;26580b488p+30");
17496 assert(ios.width() == 0);
17497 }
17498 ios.width(25);
17499 internal(ios);
17500 {
17501 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17502 std::string ex(str, iter.base());
17503 assert(ex == "+*******0x1;26580b488p+30");
17504 assert(ios.width() == 0);
17505 }
17506 }
17507 }
17508 showpoint(ios);
17509 {
17510 ios.imbue(lc);
17511 {
17512 ios.width(0);
17513 {
17514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17515 std::string ex(str, iter.base());
17516 assert(ex == "+0x1.26580b488p+30");
17517 assert(ios.width() == 0);
17518 }
17519 ios.width(25);
17520 left(ios);
17521 {
17522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17523 std::string ex(str, iter.base());
17524 assert(ex == "+0x1.26580b488p+30*******");
17525 assert(ios.width() == 0);
17526 }
17527 ios.width(25);
17528 right(ios);
17529 {
17530 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17531 std::string ex(str, iter.base());
17532 assert(ex == "*******+0x1.26580b488p+30");
17533 assert(ios.width() == 0);
17534 }
17535 ios.width(25);
17536 internal(ios);
17537 {
17538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17539 std::string ex(str, iter.base());
17540 assert(ex == "+*******0x1.26580b488p+30");
17541 assert(ios.width() == 0);
17542 }
17543 }
17544 ios.imbue(lg);
17545 {
17546 ios.width(0);
17547 {
17548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17549 std::string ex(str, iter.base());
17550 assert(ex == "+0x1;26580b488p+30");
17551 assert(ios.width() == 0);
17552 }
17553 ios.width(25);
17554 left(ios);
17555 {
17556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17557 std::string ex(str, iter.base());
17558 assert(ex == "+0x1;26580b488p+30*******");
17559 assert(ios.width() == 0);
17560 }
17561 ios.width(25);
17562 right(ios);
17563 {
17564 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17565 std::string ex(str, iter.base());
17566 assert(ex == "*******+0x1;26580b488p+30");
17567 assert(ios.width() == 0);
17568 }
17569 ios.width(25);
17570 internal(ios);
17571 {
17572 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17573 std::string ex(str, iter.base());
17574 assert(ex == "+*******0x1;26580b488p+30");
17575 assert(ios.width() == 0);
17576 }
17577 }
17578 }
17579 }
17580 }
17581 uppercase(ios);
17582 {
17583 noshowpos(ios);
17584 {
17585 noshowpoint(ios);
17586 {
17587 ios.imbue(lc);
17588 {
17589 ios.width(0);
17590 {
17591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17592 std::string ex(str, iter.base());
17593 assert(ex == "0X1.26580B488P+30");
17594 assert(ios.width() == 0);
17595 }
17596 ios.width(25);
17597 left(ios);
17598 {
17599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17600 std::string ex(str, iter.base());
17601 assert(ex == "0X1.26580B488P+30********");
17602 assert(ios.width() == 0);
17603 }
17604 ios.width(25);
17605 right(ios);
17606 {
17607 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17608 std::string ex(str, iter.base());
17609 assert(ex == "********0X1.26580B488P+30");
17610 assert(ios.width() == 0);
17611 }
17612 ios.width(25);
17613 internal(ios);
17614 {
17615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17616 std::string ex(str, iter.base());
17617 assert(ex == "0X********1.26580B488P+30");
17618 assert(ios.width() == 0);
17619 }
17620 }
17621 ios.imbue(lg);
17622 {
17623 ios.width(0);
17624 {
17625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17626 std::string ex(str, iter.base());
17627 assert(ex == "0X1;26580B488P+30");
17628 assert(ios.width() == 0);
17629 }
17630 ios.width(25);
17631 left(ios);
17632 {
17633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17634 std::string ex(str, iter.base());
17635 assert(ex == "0X1;26580B488P+30********");
17636 assert(ios.width() == 0);
17637 }
17638 ios.width(25);
17639 right(ios);
17640 {
17641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17642 std::string ex(str, iter.base());
17643 assert(ex == "********0X1;26580B488P+30");
17644 assert(ios.width() == 0);
17645 }
17646 ios.width(25);
17647 internal(ios);
17648 {
17649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17650 std::string ex(str, iter.base());
17651 assert(ex == "0X********1;26580B488P+30");
17652 assert(ios.width() == 0);
17653 }
17654 }
17655 }
17656 showpoint(ios);
17657 {
17658 ios.imbue(lc);
17659 {
17660 ios.width(0);
17661 {
17662 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17663 std::string ex(str, iter.base());
17664 assert(ex == "0X1.26580B488P+30");
17665 assert(ios.width() == 0);
17666 }
17667 ios.width(25);
17668 left(ios);
17669 {
17670 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17671 std::string ex(str, iter.base());
17672 assert(ex == "0X1.26580B488P+30********");
17673 assert(ios.width() == 0);
17674 }
17675 ios.width(25);
17676 right(ios);
17677 {
17678 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17679 std::string ex(str, iter.base());
17680 assert(ex == "********0X1.26580B488P+30");
17681 assert(ios.width() == 0);
17682 }
17683 ios.width(25);
17684 internal(ios);
17685 {
17686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17687 std::string ex(str, iter.base());
17688 assert(ex == "0X********1.26580B488P+30");
17689 assert(ios.width() == 0);
17690 }
17691 }
17692 ios.imbue(lg);
17693 {
17694 ios.width(0);
17695 {
17696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17697 std::string ex(str, iter.base());
17698 assert(ex == "0X1;26580B488P+30");
17699 assert(ios.width() == 0);
17700 }
17701 ios.width(25);
17702 left(ios);
17703 {
17704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17705 std::string ex(str, iter.base());
17706 assert(ex == "0X1;26580B488P+30********");
17707 assert(ios.width() == 0);
17708 }
17709 ios.width(25);
17710 right(ios);
17711 {
17712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17713 std::string ex(str, iter.base());
17714 assert(ex == "********0X1;26580B488P+30");
17715 assert(ios.width() == 0);
17716 }
17717 ios.width(25);
17718 internal(ios);
17719 {
17720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17721 std::string ex(str, iter.base());
17722 assert(ex == "0X********1;26580B488P+30");
17723 assert(ios.width() == 0);
17724 }
17725 }
17726 }
17727 }
17728 showpos(ios);
17729 {
17730 noshowpoint(ios);
17731 {
17732 ios.imbue(lc);
17733 {
17734 ios.width(0);
17735 {
17736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17737 std::string ex(str, iter.base());
17738 assert(ex == "+0X1.26580B488P+30");
17739 assert(ios.width() == 0);
17740 }
17741 ios.width(25);
17742 left(ios);
17743 {
17744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17745 std::string ex(str, iter.base());
17746 assert(ex == "+0X1.26580B488P+30*******");
17747 assert(ios.width() == 0);
17748 }
17749 ios.width(25);
17750 right(ios);
17751 {
17752 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17753 std::string ex(str, iter.base());
17754 assert(ex == "*******+0X1.26580B488P+30");
17755 assert(ios.width() == 0);
17756 }
17757 ios.width(25);
17758 internal(ios);
17759 {
17760 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17761 std::string ex(str, iter.base());
17762 assert(ex == "+*******0X1.26580B488P+30");
17763 assert(ios.width() == 0);
17764 }
17765 }
17766 ios.imbue(lg);
17767 {
17768 ios.width(0);
17769 {
17770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17771 std::string ex(str, iter.base());
17772 assert(ex == "+0X1;26580B488P+30");
17773 assert(ios.width() == 0);
17774 }
17775 ios.width(25);
17776 left(ios);
17777 {
17778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17779 std::string ex(str, iter.base());
17780 assert(ex == "+0X1;26580B488P+30*******");
17781 assert(ios.width() == 0);
17782 }
17783 ios.width(25);
17784 right(ios);
17785 {
17786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17787 std::string ex(str, iter.base());
17788 assert(ex == "*******+0X1;26580B488P+30");
17789 assert(ios.width() == 0);
17790 }
17791 ios.width(25);
17792 internal(ios);
17793 {
17794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17795 std::string ex(str, iter.base());
17796 assert(ex == "+*******0X1;26580B488P+30");
17797 assert(ios.width() == 0);
17798 }
17799 }
17800 }
17801 showpoint(ios);
17802 {
17803 ios.imbue(lc);
17804 {
17805 ios.width(0);
17806 {
17807 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17808 std::string ex(str, iter.base());
17809 assert(ex == "+0X1.26580B488P+30");
17810 assert(ios.width() == 0);
17811 }
17812 ios.width(25);
17813 left(ios);
17814 {
17815 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17816 std::string ex(str, iter.base());
17817 assert(ex == "+0X1.26580B488P+30*******");
17818 assert(ios.width() == 0);
17819 }
17820 ios.width(25);
17821 right(ios);
17822 {
17823 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17824 std::string ex(str, iter.base());
17825 assert(ex == "*******+0X1.26580B488P+30");
17826 assert(ios.width() == 0);
17827 }
17828 ios.width(25);
17829 internal(ios);
17830 {
17831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17832 std::string ex(str, iter.base());
17833 assert(ex == "+*******0X1.26580B488P+30");
17834 assert(ios.width() == 0);
17835 }
17836 }
17837 ios.imbue(lg);
17838 {
17839 ios.width(0);
17840 {
17841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17842 std::string ex(str, iter.base());
17843 assert(ex == "+0X1;26580B488P+30");
17844 assert(ios.width() == 0);
17845 }
17846 ios.width(25);
17847 left(ios);
17848 {
17849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17850 std::string ex(str, iter.base());
17851 assert(ex == "+0X1;26580B488P+30*******");
17852 assert(ios.width() == 0);
17853 }
17854 ios.width(25);
17855 right(ios);
17856 {
17857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17858 std::string ex(str, iter.base());
17859 assert(ex == "*******+0X1;26580B488P+30");
17860 assert(ios.width() == 0);
17861 }
17862 ios.width(25);
17863 internal(ios);
17864 {
17865 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17866 std::string ex(str, iter.base());
17867 assert(ex == "+*******0X1;26580B488P+30");
17868 assert(ios.width() == 0);
17869 }
17870 }
17871 }
17872 }
17873 }
17874 }
17875 }
17876 }
17877 }
17878
main(int,char **)17879 int main(int, char**)
17880 {
17881 test1();
17882 test2();
17883 test3();
17884 test4();
17885 test5();
17886 test6();
17887 test7();
17888 test8();
17889
17890 return 0;
17891 }
17892