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 // TODO(EricWF): This test takes 40+ minutes to build with Clang 3.8 under ASAN or MSAN.
16 // UNSUPPORTED: asan, msan
17
18 #include <locale>
19 #include <ios>
20 #include <cassert>
21 #include <streambuf>
22 #include <cmath>
23 #include "test_macros.h"
24 #include "test_iterators.h"
25
26 typedef std::num_put<char, output_iterator<char*> > F;
27
28 class my_facet
29 : public F
30 {
31 public:
my_facet(std::size_t refs=0)32 explicit my_facet(std::size_t refs = 0)
33 : F(refs) {}
34 };
35
36 class my_numpunct
37 : public std::numpunct<char>
38 {
39 public:
my_numpunct()40 my_numpunct() : std::numpunct<char>() {}
41
42 protected:
do_decimal_point() const43 virtual char_type do_decimal_point() const {return ';';}
do_thousands_sep() const44 virtual char_type do_thousands_sep() const {return '_';}
do_grouping() const45 virtual std::string do_grouping() const {return std::string("\1\2\3");}
46 };
47
test1()48 void test1()
49 {
50 char str[200];
51 output_iterator<char*> iter;
52 std::locale lc = std::locale::classic();
53 std::locale lg(lc, new my_numpunct);
54 const my_facet f(1);
55 {
56 double v = +0.;
57 std::ios ios(0);
58 // %g
59 {
60 ios.precision(0);
61 {
62 nouppercase(ios);
63 {
64 noshowpos(ios);
65 {
66 noshowpoint(ios);
67 {
68 ios.imbue(lc);
69 {
70 ios.width(0);
71 {
72 iter = f.put(output_iterator<char*>(str), ios, '*', v);
73 std::string ex(str, iter.base());
74 assert(ex == "0");
75 assert(ios.width() == 0);
76 }
77 ios.width(25);
78 left(ios);
79 {
80 iter = f.put(output_iterator<char*>(str), ios, '*', v);
81 std::string ex(str, iter.base());
82 assert(ex == "0************************");
83 assert(ios.width() == 0);
84 }
85 ios.width(25);
86 right(ios);
87 {
88 iter = f.put(output_iterator<char*>(str), ios, '*', v);
89 std::string ex(str, iter.base());
90 assert(ex == "************************0");
91 assert(ios.width() == 0);
92 }
93 ios.width(25);
94 internal(ios);
95 {
96 iter = f.put(output_iterator<char*>(str), ios, '*', v);
97 std::string ex(str, iter.base());
98 assert(ex == "************************0");
99 assert(ios.width() == 0);
100 }
101 }
102 ios.imbue(lg);
103 {
104 ios.width(0);
105 {
106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
107 std::string ex(str, iter.base());
108 assert(ex == "0");
109 assert(ios.width() == 0);
110 }
111 ios.width(25);
112 left(ios);
113 {
114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
115 std::string ex(str, iter.base());
116 assert(ex == "0************************");
117 assert(ios.width() == 0);
118 }
119 ios.width(25);
120 right(ios);
121 {
122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
123 std::string ex(str, iter.base());
124 assert(ex == "************************0");
125 assert(ios.width() == 0);
126 }
127 ios.width(25);
128 internal(ios);
129 {
130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
131 std::string ex(str, iter.base());
132 assert(ex == "************************0");
133 assert(ios.width() == 0);
134 }
135 }
136 }
137 showpoint(ios);
138 {
139 ios.imbue(lc);
140 {
141 ios.width(0);
142 {
143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
144 std::string ex(str, iter.base());
145 assert(ex == "0.");
146 assert(ios.width() == 0);
147 }
148 ios.width(25);
149 left(ios);
150 {
151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
152 std::string ex(str, iter.base());
153 assert(ex == "0.***********************");
154 assert(ios.width() == 0);
155 }
156 ios.width(25);
157 right(ios);
158 {
159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
160 std::string ex(str, iter.base());
161 assert(ex == "***********************0.");
162 assert(ios.width() == 0);
163 }
164 ios.width(25);
165 internal(ios);
166 {
167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
168 std::string ex(str, iter.base());
169 assert(ex == "***********************0.");
170 assert(ios.width() == 0);
171 }
172 }
173 ios.imbue(lg);
174 {
175 ios.width(0);
176 {
177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
178 std::string ex(str, iter.base());
179 assert(ex == "0;");
180 assert(ios.width() == 0);
181 }
182 ios.width(25);
183 left(ios);
184 {
185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
186 std::string ex(str, iter.base());
187 assert(ex == "0;***********************");
188 assert(ios.width() == 0);
189 }
190 ios.width(25);
191 right(ios);
192 {
193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
194 std::string ex(str, iter.base());
195 assert(ex == "***********************0;");
196 assert(ios.width() == 0);
197 }
198 ios.width(25);
199 internal(ios);
200 {
201 iter = f.put(output_iterator<char*>(str), ios, '*', v);
202 std::string ex(str, iter.base());
203 assert(ex == "***********************0;");
204 assert(ios.width() == 0);
205 }
206 }
207 }
208 }
209 showpos(ios);
210 {
211 noshowpoint(ios);
212 {
213 ios.imbue(lc);
214 {
215 ios.width(0);
216 {
217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
218 std::string ex(str, iter.base());
219 assert(ex == "+0");
220 assert(ios.width() == 0);
221 }
222 ios.width(25);
223 left(ios);
224 {
225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
226 std::string ex(str, iter.base());
227 assert(ex == "+0***********************");
228 assert(ios.width() == 0);
229 }
230 ios.width(25);
231 right(ios);
232 {
233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
234 std::string ex(str, iter.base());
235 assert(ex == "***********************+0");
236 assert(ios.width() == 0);
237 }
238 ios.width(25);
239 internal(ios);
240 {
241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
242 std::string ex(str, iter.base());
243 assert(ex == "+***********************0");
244 assert(ios.width() == 0);
245 }
246 }
247 ios.imbue(lg);
248 {
249 ios.width(0);
250 {
251 iter = f.put(output_iterator<char*>(str), ios, '*', v);
252 std::string ex(str, iter.base());
253 assert(ex == "+0");
254 assert(ios.width() == 0);
255 }
256 ios.width(25);
257 left(ios);
258 {
259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
260 std::string ex(str, iter.base());
261 assert(ex == "+0***********************");
262 assert(ios.width() == 0);
263 }
264 ios.width(25);
265 right(ios);
266 {
267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
268 std::string ex(str, iter.base());
269 assert(ex == "***********************+0");
270 assert(ios.width() == 0);
271 }
272 ios.width(25);
273 internal(ios);
274 {
275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
276 std::string ex(str, iter.base());
277 assert(ex == "+***********************0");
278 assert(ios.width() == 0);
279 }
280 }
281 }
282 showpoint(ios);
283 {
284 ios.imbue(lc);
285 {
286 ios.width(0);
287 {
288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
289 std::string ex(str, iter.base());
290 assert(ex == "+0.");
291 assert(ios.width() == 0);
292 }
293 ios.width(25);
294 left(ios);
295 {
296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
297 std::string ex(str, iter.base());
298 assert(ex == "+0.**********************");
299 assert(ios.width() == 0);
300 }
301 ios.width(25);
302 right(ios);
303 {
304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
305 std::string ex(str, iter.base());
306 assert(ex == "**********************+0.");
307 assert(ios.width() == 0);
308 }
309 ios.width(25);
310 internal(ios);
311 {
312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
313 std::string ex(str, iter.base());
314 assert(ex == "+**********************0.");
315 assert(ios.width() == 0);
316 }
317 }
318 ios.imbue(lg);
319 {
320 ios.width(0);
321 {
322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
323 std::string ex(str, iter.base());
324 assert(ex == "+0;");
325 assert(ios.width() == 0);
326 }
327 ios.width(25);
328 left(ios);
329 {
330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
331 std::string ex(str, iter.base());
332 assert(ex == "+0;**********************");
333 assert(ios.width() == 0);
334 }
335 ios.width(25);
336 right(ios);
337 {
338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
339 std::string ex(str, iter.base());
340 assert(ex == "**********************+0;");
341 assert(ios.width() == 0);
342 }
343 ios.width(25);
344 internal(ios);
345 {
346 iter = f.put(output_iterator<char*>(str), ios, '*', v);
347 std::string ex(str, iter.base());
348 assert(ex == "+**********************0;");
349 assert(ios.width() == 0);
350 }
351 }
352 }
353 }
354 }
355 uppercase(ios);
356 {
357 noshowpos(ios);
358 {
359 noshowpoint(ios);
360 {
361 ios.imbue(lc);
362 {
363 ios.width(0);
364 {
365 iter = f.put(output_iterator<char*>(str), ios, '*', v);
366 std::string ex(str, iter.base());
367 assert(ex == "0");
368 assert(ios.width() == 0);
369 }
370 ios.width(25);
371 left(ios);
372 {
373 iter = f.put(output_iterator<char*>(str), ios, '*', v);
374 std::string ex(str, iter.base());
375 assert(ex == "0************************");
376 assert(ios.width() == 0);
377 }
378 ios.width(25);
379 right(ios);
380 {
381 iter = f.put(output_iterator<char*>(str), ios, '*', v);
382 std::string ex(str, iter.base());
383 assert(ex == "************************0");
384 assert(ios.width() == 0);
385 }
386 ios.width(25);
387 internal(ios);
388 {
389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
390 std::string ex(str, iter.base());
391 assert(ex == "************************0");
392 assert(ios.width() == 0);
393 }
394 }
395 ios.imbue(lg);
396 {
397 ios.width(0);
398 {
399 iter = f.put(output_iterator<char*>(str), ios, '*', v);
400 std::string ex(str, iter.base());
401 assert(ex == "0");
402 assert(ios.width() == 0);
403 }
404 ios.width(25);
405 left(ios);
406 {
407 iter = f.put(output_iterator<char*>(str), ios, '*', v);
408 std::string ex(str, iter.base());
409 assert(ex == "0************************");
410 assert(ios.width() == 0);
411 }
412 ios.width(25);
413 right(ios);
414 {
415 iter = f.put(output_iterator<char*>(str), ios, '*', v);
416 std::string ex(str, iter.base());
417 assert(ex == "************************0");
418 assert(ios.width() == 0);
419 }
420 ios.width(25);
421 internal(ios);
422 {
423 iter = f.put(output_iterator<char*>(str), ios, '*', v);
424 std::string ex(str, iter.base());
425 assert(ex == "************************0");
426 assert(ios.width() == 0);
427 }
428 }
429 }
430 showpoint(ios);
431 {
432 ios.imbue(lc);
433 {
434 ios.width(0);
435 {
436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
437 std::string ex(str, iter.base());
438 assert(ex == "0.");
439 assert(ios.width() == 0);
440 }
441 ios.width(25);
442 left(ios);
443 {
444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
445 std::string ex(str, iter.base());
446 assert(ex == "0.***********************");
447 assert(ios.width() == 0);
448 }
449 ios.width(25);
450 right(ios);
451 {
452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
453 std::string ex(str, iter.base());
454 assert(ex == "***********************0.");
455 assert(ios.width() == 0);
456 }
457 ios.width(25);
458 internal(ios);
459 {
460 iter = f.put(output_iterator<char*>(str), ios, '*', v);
461 std::string ex(str, iter.base());
462 assert(ex == "***********************0.");
463 assert(ios.width() == 0);
464 }
465 }
466 ios.imbue(lg);
467 {
468 ios.width(0);
469 {
470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
471 std::string ex(str, iter.base());
472 assert(ex == "0;");
473 assert(ios.width() == 0);
474 }
475 ios.width(25);
476 left(ios);
477 {
478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
479 std::string ex(str, iter.base());
480 assert(ex == "0;***********************");
481 assert(ios.width() == 0);
482 }
483 ios.width(25);
484 right(ios);
485 {
486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
487 std::string ex(str, iter.base());
488 assert(ex == "***********************0;");
489 assert(ios.width() == 0);
490 }
491 ios.width(25);
492 internal(ios);
493 {
494 iter = f.put(output_iterator<char*>(str), ios, '*', v);
495 std::string ex(str, iter.base());
496 assert(ex == "***********************0;");
497 assert(ios.width() == 0);
498 }
499 }
500 }
501 }
502 showpos(ios);
503 {
504 noshowpoint(ios);
505 {
506 ios.imbue(lc);
507 {
508 ios.width(0);
509 {
510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
511 std::string ex(str, iter.base());
512 assert(ex == "+0");
513 assert(ios.width() == 0);
514 }
515 ios.width(25);
516 left(ios);
517 {
518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
519 std::string ex(str, iter.base());
520 assert(ex == "+0***********************");
521 assert(ios.width() == 0);
522 }
523 ios.width(25);
524 right(ios);
525 {
526 iter = f.put(output_iterator<char*>(str), ios, '*', v);
527 std::string ex(str, iter.base());
528 assert(ex == "***********************+0");
529 assert(ios.width() == 0);
530 }
531 ios.width(25);
532 internal(ios);
533 {
534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
535 std::string ex(str, iter.base());
536 assert(ex == "+***********************0");
537 assert(ios.width() == 0);
538 }
539 }
540 ios.imbue(lg);
541 {
542 ios.width(0);
543 {
544 iter = f.put(output_iterator<char*>(str), ios, '*', v);
545 std::string ex(str, iter.base());
546 assert(ex == "+0");
547 assert(ios.width() == 0);
548 }
549 ios.width(25);
550 left(ios);
551 {
552 iter = f.put(output_iterator<char*>(str), ios, '*', v);
553 std::string ex(str, iter.base());
554 assert(ex == "+0***********************");
555 assert(ios.width() == 0);
556 }
557 ios.width(25);
558 right(ios);
559 {
560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
561 std::string ex(str, iter.base());
562 assert(ex == "***********************+0");
563 assert(ios.width() == 0);
564 }
565 ios.width(25);
566 internal(ios);
567 {
568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
569 std::string ex(str, iter.base());
570 assert(ex == "+***********************0");
571 assert(ios.width() == 0);
572 }
573 }
574 }
575 showpoint(ios);
576 {
577 ios.imbue(lc);
578 {
579 ios.width(0);
580 {
581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
582 std::string ex(str, iter.base());
583 assert(ex == "+0.");
584 assert(ios.width() == 0);
585 }
586 ios.width(25);
587 left(ios);
588 {
589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
590 std::string ex(str, iter.base());
591 assert(ex == "+0.**********************");
592 assert(ios.width() == 0);
593 }
594 ios.width(25);
595 right(ios);
596 {
597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
598 std::string ex(str, iter.base());
599 assert(ex == "**********************+0.");
600 assert(ios.width() == 0);
601 }
602 ios.width(25);
603 internal(ios);
604 {
605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
606 std::string ex(str, iter.base());
607 assert(ex == "+**********************0.");
608 assert(ios.width() == 0);
609 }
610 }
611 ios.imbue(lg);
612 {
613 ios.width(0);
614 {
615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
616 std::string ex(str, iter.base());
617 assert(ex == "+0;");
618 assert(ios.width() == 0);
619 }
620 ios.width(25);
621 left(ios);
622 {
623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
624 std::string ex(str, iter.base());
625 assert(ex == "+0;**********************");
626 assert(ios.width() == 0);
627 }
628 ios.width(25);
629 right(ios);
630 {
631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
632 std::string ex(str, iter.base());
633 assert(ex == "**********************+0;");
634 assert(ios.width() == 0);
635 }
636 ios.width(25);
637 internal(ios);
638 {
639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
640 std::string ex(str, iter.base());
641 assert(ex == "+**********************0;");
642 assert(ios.width() == 0);
643 }
644 }
645 }
646 }
647 }
648 }
649 ios.precision(1);
650 {
651 nouppercase(ios);
652 {
653 noshowpos(ios);
654 {
655 noshowpoint(ios);
656 {
657 ios.imbue(lc);
658 {
659 ios.width(0);
660 {
661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
662 std::string ex(str, iter.base());
663 assert(ex == "0");
664 assert(ios.width() == 0);
665 }
666 ios.width(25);
667 left(ios);
668 {
669 iter = f.put(output_iterator<char*>(str), ios, '*', v);
670 std::string ex(str, iter.base());
671 assert(ex == "0************************");
672 assert(ios.width() == 0);
673 }
674 ios.width(25);
675 right(ios);
676 {
677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
678 std::string ex(str, iter.base());
679 assert(ex == "************************0");
680 assert(ios.width() == 0);
681 }
682 ios.width(25);
683 internal(ios);
684 {
685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
686 std::string ex(str, iter.base());
687 assert(ex == "************************0");
688 assert(ios.width() == 0);
689 }
690 }
691 ios.imbue(lg);
692 {
693 ios.width(0);
694 {
695 iter = f.put(output_iterator<char*>(str), ios, '*', v);
696 std::string ex(str, iter.base());
697 assert(ex == "0");
698 assert(ios.width() == 0);
699 }
700 ios.width(25);
701 left(ios);
702 {
703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
704 std::string ex(str, iter.base());
705 assert(ex == "0************************");
706 assert(ios.width() == 0);
707 }
708 ios.width(25);
709 right(ios);
710 {
711 iter = f.put(output_iterator<char*>(str), ios, '*', v);
712 std::string ex(str, iter.base());
713 assert(ex == "************************0");
714 assert(ios.width() == 0);
715 }
716 ios.width(25);
717 internal(ios);
718 {
719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
720 std::string ex(str, iter.base());
721 assert(ex == "************************0");
722 assert(ios.width() == 0);
723 }
724 }
725 }
726 showpoint(ios);
727 {
728 ios.imbue(lc);
729 {
730 ios.width(0);
731 {
732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
733 std::string ex(str, iter.base());
734 assert(ex == "0.");
735 assert(ios.width() == 0);
736 }
737 ios.width(25);
738 left(ios);
739 {
740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
741 std::string ex(str, iter.base());
742 assert(ex == "0.***********************");
743 assert(ios.width() == 0);
744 }
745 ios.width(25);
746 right(ios);
747 {
748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
749 std::string ex(str, iter.base());
750 assert(ex == "***********************0.");
751 assert(ios.width() == 0);
752 }
753 ios.width(25);
754 internal(ios);
755 {
756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
757 std::string ex(str, iter.base());
758 assert(ex == "***********************0.");
759 assert(ios.width() == 0);
760 }
761 }
762 ios.imbue(lg);
763 {
764 ios.width(0);
765 {
766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
767 std::string ex(str, iter.base());
768 assert(ex == "0;");
769 assert(ios.width() == 0);
770 }
771 ios.width(25);
772 left(ios);
773 {
774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
775 std::string ex(str, iter.base());
776 assert(ex == "0;***********************");
777 assert(ios.width() == 0);
778 }
779 ios.width(25);
780 right(ios);
781 {
782 iter = f.put(output_iterator<char*>(str), ios, '*', v);
783 std::string ex(str, iter.base());
784 assert(ex == "***********************0;");
785 assert(ios.width() == 0);
786 }
787 ios.width(25);
788 internal(ios);
789 {
790 iter = f.put(output_iterator<char*>(str), ios, '*', v);
791 std::string ex(str, iter.base());
792 assert(ex == "***********************0;");
793 assert(ios.width() == 0);
794 }
795 }
796 }
797 }
798 showpos(ios);
799 {
800 noshowpoint(ios);
801 {
802 ios.imbue(lc);
803 {
804 ios.width(0);
805 {
806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
807 std::string ex(str, iter.base());
808 assert(ex == "+0");
809 assert(ios.width() == 0);
810 }
811 ios.width(25);
812 left(ios);
813 {
814 iter = f.put(output_iterator<char*>(str), ios, '*', v);
815 std::string ex(str, iter.base());
816 assert(ex == "+0***********************");
817 assert(ios.width() == 0);
818 }
819 ios.width(25);
820 right(ios);
821 {
822 iter = f.put(output_iterator<char*>(str), ios, '*', v);
823 std::string ex(str, iter.base());
824 assert(ex == "***********************+0");
825 assert(ios.width() == 0);
826 }
827 ios.width(25);
828 internal(ios);
829 {
830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
831 std::string ex(str, iter.base());
832 assert(ex == "+***********************0");
833 assert(ios.width() == 0);
834 }
835 }
836 ios.imbue(lg);
837 {
838 ios.width(0);
839 {
840 iter = f.put(output_iterator<char*>(str), ios, '*', v);
841 std::string ex(str, iter.base());
842 assert(ex == "+0");
843 assert(ios.width() == 0);
844 }
845 ios.width(25);
846 left(ios);
847 {
848 iter = f.put(output_iterator<char*>(str), ios, '*', v);
849 std::string ex(str, iter.base());
850 assert(ex == "+0***********************");
851 assert(ios.width() == 0);
852 }
853 ios.width(25);
854 right(ios);
855 {
856 iter = f.put(output_iterator<char*>(str), ios, '*', v);
857 std::string ex(str, iter.base());
858 assert(ex == "***********************+0");
859 assert(ios.width() == 0);
860 }
861 ios.width(25);
862 internal(ios);
863 {
864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
865 std::string ex(str, iter.base());
866 assert(ex == "+***********************0");
867 assert(ios.width() == 0);
868 }
869 }
870 }
871 showpoint(ios);
872 {
873 ios.imbue(lc);
874 {
875 ios.width(0);
876 {
877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
878 std::string ex(str, iter.base());
879 assert(ex == "+0.");
880 assert(ios.width() == 0);
881 }
882 ios.width(25);
883 left(ios);
884 {
885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
886 std::string ex(str, iter.base());
887 assert(ex == "+0.**********************");
888 assert(ios.width() == 0);
889 }
890 ios.width(25);
891 right(ios);
892 {
893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
894 std::string ex(str, iter.base());
895 assert(ex == "**********************+0.");
896 assert(ios.width() == 0);
897 }
898 ios.width(25);
899 internal(ios);
900 {
901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
902 std::string ex(str, iter.base());
903 assert(ex == "+**********************0.");
904 assert(ios.width() == 0);
905 }
906 }
907 ios.imbue(lg);
908 {
909 ios.width(0);
910 {
911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
912 std::string ex(str, iter.base());
913 assert(ex == "+0;");
914 assert(ios.width() == 0);
915 }
916 ios.width(25);
917 left(ios);
918 {
919 iter = f.put(output_iterator<char*>(str), ios, '*', v);
920 std::string ex(str, iter.base());
921 assert(ex == "+0;**********************");
922 assert(ios.width() == 0);
923 }
924 ios.width(25);
925 right(ios);
926 {
927 iter = f.put(output_iterator<char*>(str), ios, '*', v);
928 std::string ex(str, iter.base());
929 assert(ex == "**********************+0;");
930 assert(ios.width() == 0);
931 }
932 ios.width(25);
933 internal(ios);
934 {
935 iter = f.put(output_iterator<char*>(str), ios, '*', v);
936 std::string ex(str, iter.base());
937 assert(ex == "+**********************0;");
938 assert(ios.width() == 0);
939 }
940 }
941 }
942 }
943 }
944 uppercase(ios);
945 {
946 noshowpos(ios);
947 {
948 noshowpoint(ios);
949 {
950 ios.imbue(lc);
951 {
952 ios.width(0);
953 {
954 iter = f.put(output_iterator<char*>(str), ios, '*', v);
955 std::string ex(str, iter.base());
956 assert(ex == "0");
957 assert(ios.width() == 0);
958 }
959 ios.width(25);
960 left(ios);
961 {
962 iter = f.put(output_iterator<char*>(str), ios, '*', v);
963 std::string ex(str, iter.base());
964 assert(ex == "0************************");
965 assert(ios.width() == 0);
966 }
967 ios.width(25);
968 right(ios);
969 {
970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
971 std::string ex(str, iter.base());
972 assert(ex == "************************0");
973 assert(ios.width() == 0);
974 }
975 ios.width(25);
976 internal(ios);
977 {
978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
979 std::string ex(str, iter.base());
980 assert(ex == "************************0");
981 assert(ios.width() == 0);
982 }
983 }
984 ios.imbue(lg);
985 {
986 ios.width(0);
987 {
988 iter = f.put(output_iterator<char*>(str), ios, '*', v);
989 std::string ex(str, iter.base());
990 assert(ex == "0");
991 assert(ios.width() == 0);
992 }
993 ios.width(25);
994 left(ios);
995 {
996 iter = f.put(output_iterator<char*>(str), ios, '*', v);
997 std::string ex(str, iter.base());
998 assert(ex == "0************************");
999 assert(ios.width() == 0);
1000 }
1001 ios.width(25);
1002 right(ios);
1003 {
1004 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1005 std::string ex(str, iter.base());
1006 assert(ex == "************************0");
1007 assert(ios.width() == 0);
1008 }
1009 ios.width(25);
1010 internal(ios);
1011 {
1012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1013 std::string ex(str, iter.base());
1014 assert(ex == "************************0");
1015 assert(ios.width() == 0);
1016 }
1017 }
1018 }
1019 showpoint(ios);
1020 {
1021 ios.imbue(lc);
1022 {
1023 ios.width(0);
1024 {
1025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1026 std::string ex(str, iter.base());
1027 assert(ex == "0.");
1028 assert(ios.width() == 0);
1029 }
1030 ios.width(25);
1031 left(ios);
1032 {
1033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1034 std::string ex(str, iter.base());
1035 assert(ex == "0.***********************");
1036 assert(ios.width() == 0);
1037 }
1038 ios.width(25);
1039 right(ios);
1040 {
1041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1042 std::string ex(str, iter.base());
1043 assert(ex == "***********************0.");
1044 assert(ios.width() == 0);
1045 }
1046 ios.width(25);
1047 internal(ios);
1048 {
1049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1050 std::string ex(str, iter.base());
1051 assert(ex == "***********************0.");
1052 assert(ios.width() == 0);
1053 }
1054 }
1055 ios.imbue(lg);
1056 {
1057 ios.width(0);
1058 {
1059 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1060 std::string ex(str, iter.base());
1061 assert(ex == "0;");
1062 assert(ios.width() == 0);
1063 }
1064 ios.width(25);
1065 left(ios);
1066 {
1067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1068 std::string ex(str, iter.base());
1069 assert(ex == "0;***********************");
1070 assert(ios.width() == 0);
1071 }
1072 ios.width(25);
1073 right(ios);
1074 {
1075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1076 std::string ex(str, iter.base());
1077 assert(ex == "***********************0;");
1078 assert(ios.width() == 0);
1079 }
1080 ios.width(25);
1081 internal(ios);
1082 {
1083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1084 std::string ex(str, iter.base());
1085 assert(ex == "***********************0;");
1086 assert(ios.width() == 0);
1087 }
1088 }
1089 }
1090 }
1091 showpos(ios);
1092 {
1093 noshowpoint(ios);
1094 {
1095 ios.imbue(lc);
1096 {
1097 ios.width(0);
1098 {
1099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1100 std::string ex(str, iter.base());
1101 assert(ex == "+0");
1102 assert(ios.width() == 0);
1103 }
1104 ios.width(25);
1105 left(ios);
1106 {
1107 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1108 std::string ex(str, iter.base());
1109 assert(ex == "+0***********************");
1110 assert(ios.width() == 0);
1111 }
1112 ios.width(25);
1113 right(ios);
1114 {
1115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1116 std::string ex(str, iter.base());
1117 assert(ex == "***********************+0");
1118 assert(ios.width() == 0);
1119 }
1120 ios.width(25);
1121 internal(ios);
1122 {
1123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1124 std::string ex(str, iter.base());
1125 assert(ex == "+***********************0");
1126 assert(ios.width() == 0);
1127 }
1128 }
1129 ios.imbue(lg);
1130 {
1131 ios.width(0);
1132 {
1133 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1134 std::string ex(str, iter.base());
1135 assert(ex == "+0");
1136 assert(ios.width() == 0);
1137 }
1138 ios.width(25);
1139 left(ios);
1140 {
1141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1142 std::string ex(str, iter.base());
1143 assert(ex == "+0***********************");
1144 assert(ios.width() == 0);
1145 }
1146 ios.width(25);
1147 right(ios);
1148 {
1149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1150 std::string ex(str, iter.base());
1151 assert(ex == "***********************+0");
1152 assert(ios.width() == 0);
1153 }
1154 ios.width(25);
1155 internal(ios);
1156 {
1157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1158 std::string ex(str, iter.base());
1159 assert(ex == "+***********************0");
1160 assert(ios.width() == 0);
1161 }
1162 }
1163 }
1164 showpoint(ios);
1165 {
1166 ios.imbue(lc);
1167 {
1168 ios.width(0);
1169 {
1170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1171 std::string ex(str, iter.base());
1172 assert(ex == "+0.");
1173 assert(ios.width() == 0);
1174 }
1175 ios.width(25);
1176 left(ios);
1177 {
1178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1179 std::string ex(str, iter.base());
1180 assert(ex == "+0.**********************");
1181 assert(ios.width() == 0);
1182 }
1183 ios.width(25);
1184 right(ios);
1185 {
1186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1187 std::string ex(str, iter.base());
1188 assert(ex == "**********************+0.");
1189 assert(ios.width() == 0);
1190 }
1191 ios.width(25);
1192 internal(ios);
1193 {
1194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1195 std::string ex(str, iter.base());
1196 assert(ex == "+**********************0.");
1197 assert(ios.width() == 0);
1198 }
1199 }
1200 ios.imbue(lg);
1201 {
1202 ios.width(0);
1203 {
1204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1205 std::string ex(str, iter.base());
1206 assert(ex == "+0;");
1207 assert(ios.width() == 0);
1208 }
1209 ios.width(25);
1210 left(ios);
1211 {
1212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1213 std::string ex(str, iter.base());
1214 assert(ex == "+0;**********************");
1215 assert(ios.width() == 0);
1216 }
1217 ios.width(25);
1218 right(ios);
1219 {
1220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1221 std::string ex(str, iter.base());
1222 assert(ex == "**********************+0;");
1223 assert(ios.width() == 0);
1224 }
1225 ios.width(25);
1226 internal(ios);
1227 {
1228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1229 std::string ex(str, iter.base());
1230 assert(ex == "+**********************0;");
1231 assert(ios.width() == 0);
1232 }
1233 }
1234 }
1235 }
1236 }
1237 }
1238 ios.precision(6);
1239 {
1240 nouppercase(ios);
1241 {
1242 noshowpos(ios);
1243 {
1244 noshowpoint(ios);
1245 {
1246 ios.imbue(lc);
1247 {
1248 ios.width(0);
1249 {
1250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1251 std::string ex(str, iter.base());
1252 assert(ex == "0");
1253 assert(ios.width() == 0);
1254 }
1255 ios.width(25);
1256 left(ios);
1257 {
1258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1259 std::string ex(str, iter.base());
1260 assert(ex == "0************************");
1261 assert(ios.width() == 0);
1262 }
1263 ios.width(25);
1264 right(ios);
1265 {
1266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1267 std::string ex(str, iter.base());
1268 assert(ex == "************************0");
1269 assert(ios.width() == 0);
1270 }
1271 ios.width(25);
1272 internal(ios);
1273 {
1274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1275 std::string ex(str, iter.base());
1276 assert(ex == "************************0");
1277 assert(ios.width() == 0);
1278 }
1279 }
1280 ios.imbue(lg);
1281 {
1282 ios.width(0);
1283 {
1284 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1285 std::string ex(str, iter.base());
1286 assert(ex == "0");
1287 assert(ios.width() == 0);
1288 }
1289 ios.width(25);
1290 left(ios);
1291 {
1292 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1293 std::string ex(str, iter.base());
1294 assert(ex == "0************************");
1295 assert(ios.width() == 0);
1296 }
1297 ios.width(25);
1298 right(ios);
1299 {
1300 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1301 std::string ex(str, iter.base());
1302 assert(ex == "************************0");
1303 assert(ios.width() == 0);
1304 }
1305 ios.width(25);
1306 internal(ios);
1307 {
1308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1309 std::string ex(str, iter.base());
1310 assert(ex == "************************0");
1311 assert(ios.width() == 0);
1312 }
1313 }
1314 }
1315 showpoint(ios);
1316 {
1317 ios.imbue(lc);
1318 {
1319 ios.width(0);
1320 {
1321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1322 std::string ex(str, iter.base());
1323 assert(ex == "0.00000");
1324 assert(ios.width() == 0);
1325 }
1326 ios.width(25);
1327 left(ios);
1328 {
1329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1330 std::string ex(str, iter.base());
1331 assert(ex == "0.00000******************");
1332 assert(ios.width() == 0);
1333 }
1334 ios.width(25);
1335 right(ios);
1336 {
1337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1338 std::string ex(str, iter.base());
1339 assert(ex == "******************0.00000");
1340 assert(ios.width() == 0);
1341 }
1342 ios.width(25);
1343 internal(ios);
1344 {
1345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1346 std::string ex(str, iter.base());
1347 assert(ex == "******************0.00000");
1348 assert(ios.width() == 0);
1349 }
1350 }
1351 ios.imbue(lg);
1352 {
1353 ios.width(0);
1354 {
1355 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1356 std::string ex(str, iter.base());
1357 assert(ex == "0;00000");
1358 assert(ios.width() == 0);
1359 }
1360 ios.width(25);
1361 left(ios);
1362 {
1363 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1364 std::string ex(str, iter.base());
1365 assert(ex == "0;00000******************");
1366 assert(ios.width() == 0);
1367 }
1368 ios.width(25);
1369 right(ios);
1370 {
1371 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1372 std::string ex(str, iter.base());
1373 assert(ex == "******************0;00000");
1374 assert(ios.width() == 0);
1375 }
1376 ios.width(25);
1377 internal(ios);
1378 {
1379 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1380 std::string ex(str, iter.base());
1381 assert(ex == "******************0;00000");
1382 assert(ios.width() == 0);
1383 }
1384 }
1385 }
1386 }
1387 showpos(ios);
1388 {
1389 noshowpoint(ios);
1390 {
1391 ios.imbue(lc);
1392 {
1393 ios.width(0);
1394 {
1395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1396 std::string ex(str, iter.base());
1397 assert(ex == "+0");
1398 assert(ios.width() == 0);
1399 }
1400 ios.width(25);
1401 left(ios);
1402 {
1403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1404 std::string ex(str, iter.base());
1405 assert(ex == "+0***********************");
1406 assert(ios.width() == 0);
1407 }
1408 ios.width(25);
1409 right(ios);
1410 {
1411 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1412 std::string ex(str, iter.base());
1413 assert(ex == "***********************+0");
1414 assert(ios.width() == 0);
1415 }
1416 ios.width(25);
1417 internal(ios);
1418 {
1419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1420 std::string ex(str, iter.base());
1421 assert(ex == "+***********************0");
1422 assert(ios.width() == 0);
1423 }
1424 }
1425 ios.imbue(lg);
1426 {
1427 ios.width(0);
1428 {
1429 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1430 std::string ex(str, iter.base());
1431 assert(ex == "+0");
1432 assert(ios.width() == 0);
1433 }
1434 ios.width(25);
1435 left(ios);
1436 {
1437 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1438 std::string ex(str, iter.base());
1439 assert(ex == "+0***********************");
1440 assert(ios.width() == 0);
1441 }
1442 ios.width(25);
1443 right(ios);
1444 {
1445 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1446 std::string ex(str, iter.base());
1447 assert(ex == "***********************+0");
1448 assert(ios.width() == 0);
1449 }
1450 ios.width(25);
1451 internal(ios);
1452 {
1453 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1454 std::string ex(str, iter.base());
1455 assert(ex == "+***********************0");
1456 assert(ios.width() == 0);
1457 }
1458 }
1459 }
1460 showpoint(ios);
1461 {
1462 ios.imbue(lc);
1463 {
1464 ios.width(0);
1465 {
1466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1467 std::string ex(str, iter.base());
1468 assert(ex == "+0.00000");
1469 assert(ios.width() == 0);
1470 }
1471 ios.width(25);
1472 left(ios);
1473 {
1474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1475 std::string ex(str, iter.base());
1476 assert(ex == "+0.00000*****************");
1477 assert(ios.width() == 0);
1478 }
1479 ios.width(25);
1480 right(ios);
1481 {
1482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1483 std::string ex(str, iter.base());
1484 assert(ex == "*****************+0.00000");
1485 assert(ios.width() == 0);
1486 }
1487 ios.width(25);
1488 internal(ios);
1489 {
1490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1491 std::string ex(str, iter.base());
1492 assert(ex == "+*****************0.00000");
1493 assert(ios.width() == 0);
1494 }
1495 }
1496 ios.imbue(lg);
1497 {
1498 ios.width(0);
1499 {
1500 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1501 std::string ex(str, iter.base());
1502 assert(ex == "+0;00000");
1503 assert(ios.width() == 0);
1504 }
1505 ios.width(25);
1506 left(ios);
1507 {
1508 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1509 std::string ex(str, iter.base());
1510 assert(ex == "+0;00000*****************");
1511 assert(ios.width() == 0);
1512 }
1513 ios.width(25);
1514 right(ios);
1515 {
1516 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1517 std::string ex(str, iter.base());
1518 assert(ex == "*****************+0;00000");
1519 assert(ios.width() == 0);
1520 }
1521 ios.width(25);
1522 internal(ios);
1523 {
1524 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1525 std::string ex(str, iter.base());
1526 assert(ex == "+*****************0;00000");
1527 assert(ios.width() == 0);
1528 }
1529 }
1530 }
1531 }
1532 }
1533 uppercase(ios);
1534 {
1535 noshowpos(ios);
1536 {
1537 noshowpoint(ios);
1538 {
1539 ios.imbue(lc);
1540 {
1541 ios.width(0);
1542 {
1543 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1544 std::string ex(str, iter.base());
1545 assert(ex == "0");
1546 assert(ios.width() == 0);
1547 }
1548 ios.width(25);
1549 left(ios);
1550 {
1551 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1552 std::string ex(str, iter.base());
1553 assert(ex == "0************************");
1554 assert(ios.width() == 0);
1555 }
1556 ios.width(25);
1557 right(ios);
1558 {
1559 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1560 std::string ex(str, iter.base());
1561 assert(ex == "************************0");
1562 assert(ios.width() == 0);
1563 }
1564 ios.width(25);
1565 internal(ios);
1566 {
1567 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1568 std::string ex(str, iter.base());
1569 assert(ex == "************************0");
1570 assert(ios.width() == 0);
1571 }
1572 }
1573 ios.imbue(lg);
1574 {
1575 ios.width(0);
1576 {
1577 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1578 std::string ex(str, iter.base());
1579 assert(ex == "0");
1580 assert(ios.width() == 0);
1581 }
1582 ios.width(25);
1583 left(ios);
1584 {
1585 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1586 std::string ex(str, iter.base());
1587 assert(ex == "0************************");
1588 assert(ios.width() == 0);
1589 }
1590 ios.width(25);
1591 right(ios);
1592 {
1593 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1594 std::string ex(str, iter.base());
1595 assert(ex == "************************0");
1596 assert(ios.width() == 0);
1597 }
1598 ios.width(25);
1599 internal(ios);
1600 {
1601 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1602 std::string ex(str, iter.base());
1603 assert(ex == "************************0");
1604 assert(ios.width() == 0);
1605 }
1606 }
1607 }
1608 showpoint(ios);
1609 {
1610 ios.imbue(lc);
1611 {
1612 ios.width(0);
1613 {
1614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1615 std::string ex(str, iter.base());
1616 assert(ex == "0.00000");
1617 assert(ios.width() == 0);
1618 }
1619 ios.width(25);
1620 left(ios);
1621 {
1622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1623 std::string ex(str, iter.base());
1624 assert(ex == "0.00000******************");
1625 assert(ios.width() == 0);
1626 }
1627 ios.width(25);
1628 right(ios);
1629 {
1630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1631 std::string ex(str, iter.base());
1632 assert(ex == "******************0.00000");
1633 assert(ios.width() == 0);
1634 }
1635 ios.width(25);
1636 internal(ios);
1637 {
1638 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1639 std::string ex(str, iter.base());
1640 assert(ex == "******************0.00000");
1641 assert(ios.width() == 0);
1642 }
1643 }
1644 ios.imbue(lg);
1645 {
1646 ios.width(0);
1647 {
1648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1649 std::string ex(str, iter.base());
1650 assert(ex == "0;00000");
1651 assert(ios.width() == 0);
1652 }
1653 ios.width(25);
1654 left(ios);
1655 {
1656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1657 std::string ex(str, iter.base());
1658 assert(ex == "0;00000******************");
1659 assert(ios.width() == 0);
1660 }
1661 ios.width(25);
1662 right(ios);
1663 {
1664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1665 std::string ex(str, iter.base());
1666 assert(ex == "******************0;00000");
1667 assert(ios.width() == 0);
1668 }
1669 ios.width(25);
1670 internal(ios);
1671 {
1672 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1673 std::string ex(str, iter.base());
1674 assert(ex == "******************0;00000");
1675 assert(ios.width() == 0);
1676 }
1677 }
1678 }
1679 }
1680 showpos(ios);
1681 {
1682 noshowpoint(ios);
1683 {
1684 ios.imbue(lc);
1685 {
1686 ios.width(0);
1687 {
1688 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1689 std::string ex(str, iter.base());
1690 assert(ex == "+0");
1691 assert(ios.width() == 0);
1692 }
1693 ios.width(25);
1694 left(ios);
1695 {
1696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1697 std::string ex(str, iter.base());
1698 assert(ex == "+0***********************");
1699 assert(ios.width() == 0);
1700 }
1701 ios.width(25);
1702 right(ios);
1703 {
1704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1705 std::string ex(str, iter.base());
1706 assert(ex == "***********************+0");
1707 assert(ios.width() == 0);
1708 }
1709 ios.width(25);
1710 internal(ios);
1711 {
1712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1713 std::string ex(str, iter.base());
1714 assert(ex == "+***********************0");
1715 assert(ios.width() == 0);
1716 }
1717 }
1718 ios.imbue(lg);
1719 {
1720 ios.width(0);
1721 {
1722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1723 std::string ex(str, iter.base());
1724 assert(ex == "+0");
1725 assert(ios.width() == 0);
1726 }
1727 ios.width(25);
1728 left(ios);
1729 {
1730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1731 std::string ex(str, iter.base());
1732 assert(ex == "+0***********************");
1733 assert(ios.width() == 0);
1734 }
1735 ios.width(25);
1736 right(ios);
1737 {
1738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1739 std::string ex(str, iter.base());
1740 assert(ex == "***********************+0");
1741 assert(ios.width() == 0);
1742 }
1743 ios.width(25);
1744 internal(ios);
1745 {
1746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1747 std::string ex(str, iter.base());
1748 assert(ex == "+***********************0");
1749 assert(ios.width() == 0);
1750 }
1751 }
1752 }
1753 showpoint(ios);
1754 {
1755 ios.imbue(lc);
1756 {
1757 ios.width(0);
1758 {
1759 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1760 std::string ex(str, iter.base());
1761 assert(ex == "+0.00000");
1762 assert(ios.width() == 0);
1763 }
1764 ios.width(25);
1765 left(ios);
1766 {
1767 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1768 std::string ex(str, iter.base());
1769 assert(ex == "+0.00000*****************");
1770 assert(ios.width() == 0);
1771 }
1772 ios.width(25);
1773 right(ios);
1774 {
1775 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1776 std::string ex(str, iter.base());
1777 assert(ex == "*****************+0.00000");
1778 assert(ios.width() == 0);
1779 }
1780 ios.width(25);
1781 internal(ios);
1782 {
1783 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1784 std::string ex(str, iter.base());
1785 assert(ex == "+*****************0.00000");
1786 assert(ios.width() == 0);
1787 }
1788 }
1789 ios.imbue(lg);
1790 {
1791 ios.width(0);
1792 {
1793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1794 std::string ex(str, iter.base());
1795 assert(ex == "+0;00000");
1796 assert(ios.width() == 0);
1797 }
1798 ios.width(25);
1799 left(ios);
1800 {
1801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1802 std::string ex(str, iter.base());
1803 assert(ex == "+0;00000*****************");
1804 assert(ios.width() == 0);
1805 }
1806 ios.width(25);
1807 right(ios);
1808 {
1809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1810 std::string ex(str, iter.base());
1811 assert(ex == "*****************+0;00000");
1812 assert(ios.width() == 0);
1813 }
1814 ios.width(25);
1815 internal(ios);
1816 {
1817 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1818 std::string ex(str, iter.base());
1819 assert(ex == "+*****************0;00000");
1820 assert(ios.width() == 0);
1821 }
1822 }
1823 }
1824 }
1825 }
1826 }
1827 ios.precision(16);
1828 {
1829 nouppercase(ios);
1830 {
1831 noshowpos(ios);
1832 {
1833 noshowpoint(ios);
1834 {
1835 ios.imbue(lc);
1836 {
1837 ios.width(0);
1838 {
1839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1840 std::string ex(str, iter.base());
1841 assert(ex == "0");
1842 assert(ios.width() == 0);
1843 }
1844 ios.width(25);
1845 left(ios);
1846 {
1847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1848 std::string ex(str, iter.base());
1849 assert(ex == "0************************");
1850 assert(ios.width() == 0);
1851 }
1852 ios.width(25);
1853 right(ios);
1854 {
1855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1856 std::string ex(str, iter.base());
1857 assert(ex == "************************0");
1858 assert(ios.width() == 0);
1859 }
1860 ios.width(25);
1861 internal(ios);
1862 {
1863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1864 std::string ex(str, iter.base());
1865 assert(ex == "************************0");
1866 assert(ios.width() == 0);
1867 }
1868 }
1869 ios.imbue(lg);
1870 {
1871 ios.width(0);
1872 {
1873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1874 std::string ex(str, iter.base());
1875 assert(ex == "0");
1876 assert(ios.width() == 0);
1877 }
1878 ios.width(25);
1879 left(ios);
1880 {
1881 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1882 std::string ex(str, iter.base());
1883 assert(ex == "0************************");
1884 assert(ios.width() == 0);
1885 }
1886 ios.width(25);
1887 right(ios);
1888 {
1889 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1890 std::string ex(str, iter.base());
1891 assert(ex == "************************0");
1892 assert(ios.width() == 0);
1893 }
1894 ios.width(25);
1895 internal(ios);
1896 {
1897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1898 std::string ex(str, iter.base());
1899 assert(ex == "************************0");
1900 assert(ios.width() == 0);
1901 }
1902 }
1903 }
1904 showpoint(ios);
1905 {
1906 ios.imbue(lc);
1907 {
1908 ios.width(0);
1909 {
1910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1911 std::string ex(str, iter.base());
1912 assert(ex == "0.000000000000000");
1913 assert(ios.width() == 0);
1914 }
1915 ios.width(25);
1916 left(ios);
1917 {
1918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1919 std::string ex(str, iter.base());
1920 assert(ex == "0.000000000000000********");
1921 assert(ios.width() == 0);
1922 }
1923 ios.width(25);
1924 right(ios);
1925 {
1926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1927 std::string ex(str, iter.base());
1928 assert(ex == "********0.000000000000000");
1929 assert(ios.width() == 0);
1930 }
1931 ios.width(25);
1932 internal(ios);
1933 {
1934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1935 std::string ex(str, iter.base());
1936 assert(ex == "********0.000000000000000");
1937 assert(ios.width() == 0);
1938 }
1939 }
1940 ios.imbue(lg);
1941 {
1942 ios.width(0);
1943 {
1944 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1945 std::string ex(str, iter.base());
1946 assert(ex == "0;000000000000000");
1947 assert(ios.width() == 0);
1948 }
1949 ios.width(25);
1950 left(ios);
1951 {
1952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1953 std::string ex(str, iter.base());
1954 assert(ex == "0;000000000000000********");
1955 assert(ios.width() == 0);
1956 }
1957 ios.width(25);
1958 right(ios);
1959 {
1960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1961 std::string ex(str, iter.base());
1962 assert(ex == "********0;000000000000000");
1963 assert(ios.width() == 0);
1964 }
1965 ios.width(25);
1966 internal(ios);
1967 {
1968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1969 std::string ex(str, iter.base());
1970 assert(ex == "********0;000000000000000");
1971 assert(ios.width() == 0);
1972 }
1973 }
1974 }
1975 }
1976 showpos(ios);
1977 {
1978 noshowpoint(ios);
1979 {
1980 ios.imbue(lc);
1981 {
1982 ios.width(0);
1983 {
1984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1985 std::string ex(str, iter.base());
1986 assert(ex == "+0");
1987 assert(ios.width() == 0);
1988 }
1989 ios.width(25);
1990 left(ios);
1991 {
1992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1993 std::string ex(str, iter.base());
1994 assert(ex == "+0***********************");
1995 assert(ios.width() == 0);
1996 }
1997 ios.width(25);
1998 right(ios);
1999 {
2000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2001 std::string ex(str, iter.base());
2002 assert(ex == "***********************+0");
2003 assert(ios.width() == 0);
2004 }
2005 ios.width(25);
2006 internal(ios);
2007 {
2008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2009 std::string ex(str, iter.base());
2010 assert(ex == "+***********************0");
2011 assert(ios.width() == 0);
2012 }
2013 }
2014 ios.imbue(lg);
2015 {
2016 ios.width(0);
2017 {
2018 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2019 std::string ex(str, iter.base());
2020 assert(ex == "+0");
2021 assert(ios.width() == 0);
2022 }
2023 ios.width(25);
2024 left(ios);
2025 {
2026 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2027 std::string ex(str, iter.base());
2028 assert(ex == "+0***********************");
2029 assert(ios.width() == 0);
2030 }
2031 ios.width(25);
2032 right(ios);
2033 {
2034 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2035 std::string ex(str, iter.base());
2036 assert(ex == "***********************+0");
2037 assert(ios.width() == 0);
2038 }
2039 ios.width(25);
2040 internal(ios);
2041 {
2042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2043 std::string ex(str, iter.base());
2044 assert(ex == "+***********************0");
2045 assert(ios.width() == 0);
2046 }
2047 }
2048 }
2049 showpoint(ios);
2050 {
2051 ios.imbue(lc);
2052 {
2053 ios.width(0);
2054 {
2055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2056 std::string ex(str, iter.base());
2057 assert(ex == "+0.000000000000000");
2058 assert(ios.width() == 0);
2059 }
2060 ios.width(25);
2061 left(ios);
2062 {
2063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2064 std::string ex(str, iter.base());
2065 assert(ex == "+0.000000000000000*******");
2066 assert(ios.width() == 0);
2067 }
2068 ios.width(25);
2069 right(ios);
2070 {
2071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2072 std::string ex(str, iter.base());
2073 assert(ex == "*******+0.000000000000000");
2074 assert(ios.width() == 0);
2075 }
2076 ios.width(25);
2077 internal(ios);
2078 {
2079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2080 std::string ex(str, iter.base());
2081 assert(ex == "+*******0.000000000000000");
2082 assert(ios.width() == 0);
2083 }
2084 }
2085 ios.imbue(lg);
2086 {
2087 ios.width(0);
2088 {
2089 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2090 std::string ex(str, iter.base());
2091 assert(ex == "+0;000000000000000");
2092 assert(ios.width() == 0);
2093 }
2094 ios.width(25);
2095 left(ios);
2096 {
2097 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2098 std::string ex(str, iter.base());
2099 assert(ex == "+0;000000000000000*******");
2100 assert(ios.width() == 0);
2101 }
2102 ios.width(25);
2103 right(ios);
2104 {
2105 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2106 std::string ex(str, iter.base());
2107 assert(ex == "*******+0;000000000000000");
2108 assert(ios.width() == 0);
2109 }
2110 ios.width(25);
2111 internal(ios);
2112 {
2113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2114 std::string ex(str, iter.base());
2115 assert(ex == "+*******0;000000000000000");
2116 assert(ios.width() == 0);
2117 }
2118 }
2119 }
2120 }
2121 }
2122 uppercase(ios);
2123 {
2124 noshowpos(ios);
2125 {
2126 noshowpoint(ios);
2127 {
2128 ios.imbue(lc);
2129 {
2130 ios.width(0);
2131 {
2132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2133 std::string ex(str, iter.base());
2134 assert(ex == "0");
2135 assert(ios.width() == 0);
2136 }
2137 ios.width(25);
2138 left(ios);
2139 {
2140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2141 std::string ex(str, iter.base());
2142 assert(ex == "0************************");
2143 assert(ios.width() == 0);
2144 }
2145 ios.width(25);
2146 right(ios);
2147 {
2148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2149 std::string ex(str, iter.base());
2150 assert(ex == "************************0");
2151 assert(ios.width() == 0);
2152 }
2153 ios.width(25);
2154 internal(ios);
2155 {
2156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2157 std::string ex(str, iter.base());
2158 assert(ex == "************************0");
2159 assert(ios.width() == 0);
2160 }
2161 }
2162 ios.imbue(lg);
2163 {
2164 ios.width(0);
2165 {
2166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2167 std::string ex(str, iter.base());
2168 assert(ex == "0");
2169 assert(ios.width() == 0);
2170 }
2171 ios.width(25);
2172 left(ios);
2173 {
2174 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2175 std::string ex(str, iter.base());
2176 assert(ex == "0************************");
2177 assert(ios.width() == 0);
2178 }
2179 ios.width(25);
2180 right(ios);
2181 {
2182 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2183 std::string ex(str, iter.base());
2184 assert(ex == "************************0");
2185 assert(ios.width() == 0);
2186 }
2187 ios.width(25);
2188 internal(ios);
2189 {
2190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2191 std::string ex(str, iter.base());
2192 assert(ex == "************************0");
2193 assert(ios.width() == 0);
2194 }
2195 }
2196 }
2197 showpoint(ios);
2198 {
2199 ios.imbue(lc);
2200 {
2201 ios.width(0);
2202 {
2203 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2204 std::string ex(str, iter.base());
2205 assert(ex == "0.000000000000000");
2206 assert(ios.width() == 0);
2207 }
2208 ios.width(25);
2209 left(ios);
2210 {
2211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2212 std::string ex(str, iter.base());
2213 assert(ex == "0.000000000000000********");
2214 assert(ios.width() == 0);
2215 }
2216 ios.width(25);
2217 right(ios);
2218 {
2219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2220 std::string ex(str, iter.base());
2221 assert(ex == "********0.000000000000000");
2222 assert(ios.width() == 0);
2223 }
2224 ios.width(25);
2225 internal(ios);
2226 {
2227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2228 std::string ex(str, iter.base());
2229 assert(ex == "********0.000000000000000");
2230 assert(ios.width() == 0);
2231 }
2232 }
2233 ios.imbue(lg);
2234 {
2235 ios.width(0);
2236 {
2237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2238 std::string ex(str, iter.base());
2239 assert(ex == "0;000000000000000");
2240 assert(ios.width() == 0);
2241 }
2242 ios.width(25);
2243 left(ios);
2244 {
2245 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2246 std::string ex(str, iter.base());
2247 assert(ex == "0;000000000000000********");
2248 assert(ios.width() == 0);
2249 }
2250 ios.width(25);
2251 right(ios);
2252 {
2253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2254 std::string ex(str, iter.base());
2255 assert(ex == "********0;000000000000000");
2256 assert(ios.width() == 0);
2257 }
2258 ios.width(25);
2259 internal(ios);
2260 {
2261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2262 std::string ex(str, iter.base());
2263 assert(ex == "********0;000000000000000");
2264 assert(ios.width() == 0);
2265 }
2266 }
2267 }
2268 }
2269 showpos(ios);
2270 {
2271 noshowpoint(ios);
2272 {
2273 ios.imbue(lc);
2274 {
2275 ios.width(0);
2276 {
2277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2278 std::string ex(str, iter.base());
2279 assert(ex == "+0");
2280 assert(ios.width() == 0);
2281 }
2282 ios.width(25);
2283 left(ios);
2284 {
2285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2286 std::string ex(str, iter.base());
2287 assert(ex == "+0***********************");
2288 assert(ios.width() == 0);
2289 }
2290 ios.width(25);
2291 right(ios);
2292 {
2293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2294 std::string ex(str, iter.base());
2295 assert(ex == "***********************+0");
2296 assert(ios.width() == 0);
2297 }
2298 ios.width(25);
2299 internal(ios);
2300 {
2301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2302 std::string ex(str, iter.base());
2303 assert(ex == "+***********************0");
2304 assert(ios.width() == 0);
2305 }
2306 }
2307 ios.imbue(lg);
2308 {
2309 ios.width(0);
2310 {
2311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2312 std::string ex(str, iter.base());
2313 assert(ex == "+0");
2314 assert(ios.width() == 0);
2315 }
2316 ios.width(25);
2317 left(ios);
2318 {
2319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2320 std::string ex(str, iter.base());
2321 assert(ex == "+0***********************");
2322 assert(ios.width() == 0);
2323 }
2324 ios.width(25);
2325 right(ios);
2326 {
2327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2328 std::string ex(str, iter.base());
2329 assert(ex == "***********************+0");
2330 assert(ios.width() == 0);
2331 }
2332 ios.width(25);
2333 internal(ios);
2334 {
2335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2336 std::string ex(str, iter.base());
2337 assert(ex == "+***********************0");
2338 assert(ios.width() == 0);
2339 }
2340 }
2341 }
2342 showpoint(ios);
2343 {
2344 ios.imbue(lc);
2345 {
2346 ios.width(0);
2347 {
2348 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2349 std::string ex(str, iter.base());
2350 assert(ex == "+0.000000000000000");
2351 assert(ios.width() == 0);
2352 }
2353 ios.width(25);
2354 left(ios);
2355 {
2356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2357 std::string ex(str, iter.base());
2358 assert(ex == "+0.000000000000000*******");
2359 assert(ios.width() == 0);
2360 }
2361 ios.width(25);
2362 right(ios);
2363 {
2364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2365 std::string ex(str, iter.base());
2366 assert(ex == "*******+0.000000000000000");
2367 assert(ios.width() == 0);
2368 }
2369 ios.width(25);
2370 internal(ios);
2371 {
2372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2373 std::string ex(str, iter.base());
2374 assert(ex == "+*******0.000000000000000");
2375 assert(ios.width() == 0);
2376 }
2377 }
2378 ios.imbue(lg);
2379 {
2380 ios.width(0);
2381 {
2382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2383 std::string ex(str, iter.base());
2384 assert(ex == "+0;000000000000000");
2385 assert(ios.width() == 0);
2386 }
2387 ios.width(25);
2388 left(ios);
2389 {
2390 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2391 std::string ex(str, iter.base());
2392 assert(ex == "+0;000000000000000*******");
2393 assert(ios.width() == 0);
2394 }
2395 ios.width(25);
2396 right(ios);
2397 {
2398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2399 std::string ex(str, iter.base());
2400 assert(ex == "*******+0;000000000000000");
2401 assert(ios.width() == 0);
2402 }
2403 ios.width(25);
2404 internal(ios);
2405 {
2406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2407 std::string ex(str, iter.base());
2408 assert(ex == "+*******0;000000000000000");
2409 assert(ios.width() == 0);
2410 }
2411 }
2412 }
2413 }
2414 }
2415 }
2416 ios.precision(60);
2417 {
2418 nouppercase(ios);
2419 {
2420 noshowpos(ios);
2421 {
2422 noshowpoint(ios);
2423 {
2424 ios.imbue(lc);
2425 {
2426 ios.width(0);
2427 {
2428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2429 std::string ex(str, iter.base());
2430 assert(ex == "0");
2431 assert(ios.width() == 0);
2432 }
2433 ios.width(25);
2434 left(ios);
2435 {
2436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2437 std::string ex(str, iter.base());
2438 assert(ex == "0************************");
2439 assert(ios.width() == 0);
2440 }
2441 ios.width(25);
2442 right(ios);
2443 {
2444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2445 std::string ex(str, iter.base());
2446 assert(ex == "************************0");
2447 assert(ios.width() == 0);
2448 }
2449 ios.width(25);
2450 internal(ios);
2451 {
2452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2453 std::string ex(str, iter.base());
2454 assert(ex == "************************0");
2455 assert(ios.width() == 0);
2456 }
2457 }
2458 ios.imbue(lg);
2459 {
2460 ios.width(0);
2461 {
2462 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2463 std::string ex(str, iter.base());
2464 assert(ex == "0");
2465 assert(ios.width() == 0);
2466 }
2467 ios.width(25);
2468 left(ios);
2469 {
2470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2471 std::string ex(str, iter.base());
2472 assert(ex == "0************************");
2473 assert(ios.width() == 0);
2474 }
2475 ios.width(25);
2476 right(ios);
2477 {
2478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2479 std::string ex(str, iter.base());
2480 assert(ex == "************************0");
2481 assert(ios.width() == 0);
2482 }
2483 ios.width(25);
2484 internal(ios);
2485 {
2486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2487 std::string ex(str, iter.base());
2488 assert(ex == "************************0");
2489 assert(ios.width() == 0);
2490 }
2491 }
2492 }
2493 showpoint(ios);
2494 {
2495 ios.imbue(lc);
2496 {
2497 ios.width(0);
2498 {
2499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2500 std::string ex(str, iter.base());
2501 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2502 assert(ios.width() == 0);
2503 }
2504 ios.width(25);
2505 left(ios);
2506 {
2507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2508 std::string ex(str, iter.base());
2509 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2510 assert(ios.width() == 0);
2511 }
2512 ios.width(25);
2513 right(ios);
2514 {
2515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2516 std::string ex(str, iter.base());
2517 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2518 assert(ios.width() == 0);
2519 }
2520 ios.width(25);
2521 internal(ios);
2522 {
2523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2524 std::string ex(str, iter.base());
2525 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2526 assert(ios.width() == 0);
2527 }
2528 }
2529 ios.imbue(lg);
2530 {
2531 ios.width(0);
2532 {
2533 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2534 std::string ex(str, iter.base());
2535 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2536 assert(ios.width() == 0);
2537 }
2538 ios.width(25);
2539 left(ios);
2540 {
2541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2542 std::string ex(str, iter.base());
2543 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2544 assert(ios.width() == 0);
2545 }
2546 ios.width(25);
2547 right(ios);
2548 {
2549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2550 std::string ex(str, iter.base());
2551 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2552 assert(ios.width() == 0);
2553 }
2554 ios.width(25);
2555 internal(ios);
2556 {
2557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2558 std::string ex(str, iter.base());
2559 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2560 assert(ios.width() == 0);
2561 }
2562 }
2563 }
2564 }
2565 showpos(ios);
2566 {
2567 noshowpoint(ios);
2568 {
2569 ios.imbue(lc);
2570 {
2571 ios.width(0);
2572 {
2573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2574 std::string ex(str, iter.base());
2575 assert(ex == "+0");
2576 assert(ios.width() == 0);
2577 }
2578 ios.width(25);
2579 left(ios);
2580 {
2581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2582 std::string ex(str, iter.base());
2583 assert(ex == "+0***********************");
2584 assert(ios.width() == 0);
2585 }
2586 ios.width(25);
2587 right(ios);
2588 {
2589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2590 std::string ex(str, iter.base());
2591 assert(ex == "***********************+0");
2592 assert(ios.width() == 0);
2593 }
2594 ios.width(25);
2595 internal(ios);
2596 {
2597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2598 std::string ex(str, iter.base());
2599 assert(ex == "+***********************0");
2600 assert(ios.width() == 0);
2601 }
2602 }
2603 ios.imbue(lg);
2604 {
2605 ios.width(0);
2606 {
2607 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2608 std::string ex(str, iter.base());
2609 assert(ex == "+0");
2610 assert(ios.width() == 0);
2611 }
2612 ios.width(25);
2613 left(ios);
2614 {
2615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2616 std::string ex(str, iter.base());
2617 assert(ex == "+0***********************");
2618 assert(ios.width() == 0);
2619 }
2620 ios.width(25);
2621 right(ios);
2622 {
2623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2624 std::string ex(str, iter.base());
2625 assert(ex == "***********************+0");
2626 assert(ios.width() == 0);
2627 }
2628 ios.width(25);
2629 internal(ios);
2630 {
2631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2632 std::string ex(str, iter.base());
2633 assert(ex == "+***********************0");
2634 assert(ios.width() == 0);
2635 }
2636 }
2637 }
2638 showpoint(ios);
2639 {
2640 ios.imbue(lc);
2641 {
2642 ios.width(0);
2643 {
2644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2645 std::string ex(str, iter.base());
2646 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2647 assert(ios.width() == 0);
2648 }
2649 ios.width(25);
2650 left(ios);
2651 {
2652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2653 std::string ex(str, iter.base());
2654 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2655 assert(ios.width() == 0);
2656 }
2657 ios.width(25);
2658 right(ios);
2659 {
2660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2661 std::string ex(str, iter.base());
2662 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2663 assert(ios.width() == 0);
2664 }
2665 ios.width(25);
2666 internal(ios);
2667 {
2668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2669 std::string ex(str, iter.base());
2670 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2671 assert(ios.width() == 0);
2672 }
2673 }
2674 ios.imbue(lg);
2675 {
2676 ios.width(0);
2677 {
2678 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2679 std::string ex(str, iter.base());
2680 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2681 assert(ios.width() == 0);
2682 }
2683 ios.width(25);
2684 left(ios);
2685 {
2686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2687 std::string ex(str, iter.base());
2688 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2689 assert(ios.width() == 0);
2690 }
2691 ios.width(25);
2692 right(ios);
2693 {
2694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2695 std::string ex(str, iter.base());
2696 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2697 assert(ios.width() == 0);
2698 }
2699 ios.width(25);
2700 internal(ios);
2701 {
2702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2703 std::string ex(str, iter.base());
2704 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2705 assert(ios.width() == 0);
2706 }
2707 }
2708 }
2709 }
2710 }
2711 uppercase(ios);
2712 {
2713 noshowpos(ios);
2714 {
2715 noshowpoint(ios);
2716 {
2717 ios.imbue(lc);
2718 {
2719 ios.width(0);
2720 {
2721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2722 std::string ex(str, iter.base());
2723 assert(ex == "0");
2724 assert(ios.width() == 0);
2725 }
2726 ios.width(25);
2727 left(ios);
2728 {
2729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2730 std::string ex(str, iter.base());
2731 assert(ex == "0************************");
2732 assert(ios.width() == 0);
2733 }
2734 ios.width(25);
2735 right(ios);
2736 {
2737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2738 std::string ex(str, iter.base());
2739 assert(ex == "************************0");
2740 assert(ios.width() == 0);
2741 }
2742 ios.width(25);
2743 internal(ios);
2744 {
2745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2746 std::string ex(str, iter.base());
2747 assert(ex == "************************0");
2748 assert(ios.width() == 0);
2749 }
2750 }
2751 ios.imbue(lg);
2752 {
2753 ios.width(0);
2754 {
2755 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2756 std::string ex(str, iter.base());
2757 assert(ex == "0");
2758 assert(ios.width() == 0);
2759 }
2760 ios.width(25);
2761 left(ios);
2762 {
2763 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2764 std::string ex(str, iter.base());
2765 assert(ex == "0************************");
2766 assert(ios.width() == 0);
2767 }
2768 ios.width(25);
2769 right(ios);
2770 {
2771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2772 std::string ex(str, iter.base());
2773 assert(ex == "************************0");
2774 assert(ios.width() == 0);
2775 }
2776 ios.width(25);
2777 internal(ios);
2778 {
2779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2780 std::string ex(str, iter.base());
2781 assert(ex == "************************0");
2782 assert(ios.width() == 0);
2783 }
2784 }
2785 }
2786 showpoint(ios);
2787 {
2788 ios.imbue(lc);
2789 {
2790 ios.width(0);
2791 {
2792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2793 std::string ex(str, iter.base());
2794 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2795 assert(ios.width() == 0);
2796 }
2797 ios.width(25);
2798 left(ios);
2799 {
2800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2801 std::string ex(str, iter.base());
2802 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2803 assert(ios.width() == 0);
2804 }
2805 ios.width(25);
2806 right(ios);
2807 {
2808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2809 std::string ex(str, iter.base());
2810 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2811 assert(ios.width() == 0);
2812 }
2813 ios.width(25);
2814 internal(ios);
2815 {
2816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2817 std::string ex(str, iter.base());
2818 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2819 assert(ios.width() == 0);
2820 }
2821 }
2822 ios.imbue(lg);
2823 {
2824 ios.width(0);
2825 {
2826 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2827 std::string ex(str, iter.base());
2828 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2829 assert(ios.width() == 0);
2830 }
2831 ios.width(25);
2832 left(ios);
2833 {
2834 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2835 std::string ex(str, iter.base());
2836 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2837 assert(ios.width() == 0);
2838 }
2839 ios.width(25);
2840 right(ios);
2841 {
2842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2843 std::string ex(str, iter.base());
2844 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2845 assert(ios.width() == 0);
2846 }
2847 ios.width(25);
2848 internal(ios);
2849 {
2850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2851 std::string ex(str, iter.base());
2852 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2853 assert(ios.width() == 0);
2854 }
2855 }
2856 }
2857 }
2858 showpos(ios);
2859 {
2860 noshowpoint(ios);
2861 {
2862 ios.imbue(lc);
2863 {
2864 ios.width(0);
2865 {
2866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2867 std::string ex(str, iter.base());
2868 assert(ex == "+0");
2869 assert(ios.width() == 0);
2870 }
2871 ios.width(25);
2872 left(ios);
2873 {
2874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2875 std::string ex(str, iter.base());
2876 assert(ex == "+0***********************");
2877 assert(ios.width() == 0);
2878 }
2879 ios.width(25);
2880 right(ios);
2881 {
2882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2883 std::string ex(str, iter.base());
2884 assert(ex == "***********************+0");
2885 assert(ios.width() == 0);
2886 }
2887 ios.width(25);
2888 internal(ios);
2889 {
2890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2891 std::string ex(str, iter.base());
2892 assert(ex == "+***********************0");
2893 assert(ios.width() == 0);
2894 }
2895 }
2896 ios.imbue(lg);
2897 {
2898 ios.width(0);
2899 {
2900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2901 std::string ex(str, iter.base());
2902 assert(ex == "+0");
2903 assert(ios.width() == 0);
2904 }
2905 ios.width(25);
2906 left(ios);
2907 {
2908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2909 std::string ex(str, iter.base());
2910 assert(ex == "+0***********************");
2911 assert(ios.width() == 0);
2912 }
2913 ios.width(25);
2914 right(ios);
2915 {
2916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2917 std::string ex(str, iter.base());
2918 assert(ex == "***********************+0");
2919 assert(ios.width() == 0);
2920 }
2921 ios.width(25);
2922 internal(ios);
2923 {
2924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2925 std::string ex(str, iter.base());
2926 assert(ex == "+***********************0");
2927 assert(ios.width() == 0);
2928 }
2929 }
2930 }
2931 showpoint(ios);
2932 {
2933 ios.imbue(lc);
2934 {
2935 ios.width(0);
2936 {
2937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2938 std::string ex(str, iter.base());
2939 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2940 assert(ios.width() == 0);
2941 }
2942 ios.width(25);
2943 left(ios);
2944 {
2945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2946 std::string ex(str, iter.base());
2947 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2948 assert(ios.width() == 0);
2949 }
2950 ios.width(25);
2951 right(ios);
2952 {
2953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2954 std::string ex(str, iter.base());
2955 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2956 assert(ios.width() == 0);
2957 }
2958 ios.width(25);
2959 internal(ios);
2960 {
2961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2962 std::string ex(str, iter.base());
2963 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2964 assert(ios.width() == 0);
2965 }
2966 }
2967 ios.imbue(lg);
2968 {
2969 ios.width(0);
2970 {
2971 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2972 std::string ex(str, iter.base());
2973 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2974 assert(ios.width() == 0);
2975 }
2976 ios.width(25);
2977 left(ios);
2978 {
2979 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2980 std::string ex(str, iter.base());
2981 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2982 assert(ios.width() == 0);
2983 }
2984 ios.width(25);
2985 right(ios);
2986 {
2987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2988 std::string ex(str, iter.base());
2989 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2990 assert(ios.width() == 0);
2991 }
2992 ios.width(25);
2993 internal(ios);
2994 {
2995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2996 std::string ex(str, iter.base());
2997 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2998 assert(ios.width() == 0);
2999 }
3000 }
3001 }
3002 }
3003 }
3004 }
3005 }
3006 }
3007 }
3008
test2()3009 void test2()
3010 {
3011 char str[200];
3012 output_iterator<char*> iter;
3013 std::locale lc = std::locale::classic();
3014 std::locale lg(lc, new my_numpunct);
3015 const my_facet f(1);
3016 {
3017 double v = 1234567890.125;
3018 std::ios ios(0);
3019 // %g
3020 {
3021 ios.precision(0);
3022 {
3023 nouppercase(ios);
3024 {
3025 noshowpos(ios);
3026 {
3027 noshowpoint(ios);
3028 {
3029 ios.imbue(lc);
3030 {
3031 ios.width(0);
3032 {
3033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3034 std::string ex(str, iter.base());
3035 assert(ex == "1e+09");
3036 assert(ios.width() == 0);
3037 }
3038 ios.width(25);
3039 left(ios);
3040 {
3041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3042 std::string ex(str, iter.base());
3043 assert(ex == "1e+09********************");
3044 assert(ios.width() == 0);
3045 }
3046 ios.width(25);
3047 right(ios);
3048 {
3049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3050 std::string ex(str, iter.base());
3051 assert(ex == "********************1e+09");
3052 assert(ios.width() == 0);
3053 }
3054 ios.width(25);
3055 internal(ios);
3056 {
3057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3058 std::string ex(str, iter.base());
3059 assert(ex == "********************1e+09");
3060 assert(ios.width() == 0);
3061 }
3062 }
3063 ios.imbue(lg);
3064 {
3065 ios.width(0);
3066 {
3067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3068 std::string ex(str, iter.base());
3069 assert(ex == "1e+09");
3070 assert(ios.width() == 0);
3071 }
3072 ios.width(25);
3073 left(ios);
3074 {
3075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3076 std::string ex(str, iter.base());
3077 assert(ex == "1e+09********************");
3078 assert(ios.width() == 0);
3079 }
3080 ios.width(25);
3081 right(ios);
3082 {
3083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3084 std::string ex(str, iter.base());
3085 assert(ex == "********************1e+09");
3086 assert(ios.width() == 0);
3087 }
3088 ios.width(25);
3089 internal(ios);
3090 {
3091 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3092 std::string ex(str, iter.base());
3093 assert(ex == "********************1e+09");
3094 assert(ios.width() == 0);
3095 }
3096 }
3097 }
3098 showpoint(ios);
3099 {
3100 ios.imbue(lc);
3101 {
3102 ios.width(0);
3103 {
3104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3105 std::string ex(str, iter.base());
3106 assert(ex == "1.e+09");
3107 assert(ios.width() == 0);
3108 }
3109 ios.width(25);
3110 left(ios);
3111 {
3112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3113 std::string ex(str, iter.base());
3114 assert(ex == "1.e+09*******************");
3115 assert(ios.width() == 0);
3116 }
3117 ios.width(25);
3118 right(ios);
3119 {
3120 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3121 std::string ex(str, iter.base());
3122 assert(ex == "*******************1.e+09");
3123 assert(ios.width() == 0);
3124 }
3125 ios.width(25);
3126 internal(ios);
3127 {
3128 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3129 std::string ex(str, iter.base());
3130 assert(ex == "*******************1.e+09");
3131 assert(ios.width() == 0);
3132 }
3133 }
3134 ios.imbue(lg);
3135 {
3136 ios.width(0);
3137 {
3138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3139 std::string ex(str, iter.base());
3140 assert(ex == "1;e+09");
3141 assert(ios.width() == 0);
3142 }
3143 ios.width(25);
3144 left(ios);
3145 {
3146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3147 std::string ex(str, iter.base());
3148 assert(ex == "1;e+09*******************");
3149 assert(ios.width() == 0);
3150 }
3151 ios.width(25);
3152 right(ios);
3153 {
3154 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3155 std::string ex(str, iter.base());
3156 assert(ex == "*******************1;e+09");
3157 assert(ios.width() == 0);
3158 }
3159 ios.width(25);
3160 internal(ios);
3161 {
3162 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3163 std::string ex(str, iter.base());
3164 assert(ex == "*******************1;e+09");
3165 assert(ios.width() == 0);
3166 }
3167 }
3168 }
3169 }
3170 showpos(ios);
3171 {
3172 noshowpoint(ios);
3173 {
3174 ios.imbue(lc);
3175 {
3176 ios.width(0);
3177 {
3178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3179 std::string ex(str, iter.base());
3180 assert(ex == "+1e+09");
3181 assert(ios.width() == 0);
3182 }
3183 ios.width(25);
3184 left(ios);
3185 {
3186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3187 std::string ex(str, iter.base());
3188 assert(ex == "+1e+09*******************");
3189 assert(ios.width() == 0);
3190 }
3191 ios.width(25);
3192 right(ios);
3193 {
3194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3195 std::string ex(str, iter.base());
3196 assert(ex == "*******************+1e+09");
3197 assert(ios.width() == 0);
3198 }
3199 ios.width(25);
3200 internal(ios);
3201 {
3202 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3203 std::string ex(str, iter.base());
3204 assert(ex == "+*******************1e+09");
3205 assert(ios.width() == 0);
3206 }
3207 }
3208 ios.imbue(lg);
3209 {
3210 ios.width(0);
3211 {
3212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3213 std::string ex(str, iter.base());
3214 assert(ex == "+1e+09");
3215 assert(ios.width() == 0);
3216 }
3217 ios.width(25);
3218 left(ios);
3219 {
3220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3221 std::string ex(str, iter.base());
3222 assert(ex == "+1e+09*******************");
3223 assert(ios.width() == 0);
3224 }
3225 ios.width(25);
3226 right(ios);
3227 {
3228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3229 std::string ex(str, iter.base());
3230 assert(ex == "*******************+1e+09");
3231 assert(ios.width() == 0);
3232 }
3233 ios.width(25);
3234 internal(ios);
3235 {
3236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3237 std::string ex(str, iter.base());
3238 assert(ex == "+*******************1e+09");
3239 assert(ios.width() == 0);
3240 }
3241 }
3242 }
3243 showpoint(ios);
3244 {
3245 ios.imbue(lc);
3246 {
3247 ios.width(0);
3248 {
3249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3250 std::string ex(str, iter.base());
3251 assert(ex == "+1.e+09");
3252 assert(ios.width() == 0);
3253 }
3254 ios.width(25);
3255 left(ios);
3256 {
3257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3258 std::string ex(str, iter.base());
3259 assert(ex == "+1.e+09******************");
3260 assert(ios.width() == 0);
3261 }
3262 ios.width(25);
3263 right(ios);
3264 {
3265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3266 std::string ex(str, iter.base());
3267 assert(ex == "******************+1.e+09");
3268 assert(ios.width() == 0);
3269 }
3270 ios.width(25);
3271 internal(ios);
3272 {
3273 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3274 std::string ex(str, iter.base());
3275 assert(ex == "+******************1.e+09");
3276 assert(ios.width() == 0);
3277 }
3278 }
3279 ios.imbue(lg);
3280 {
3281 ios.width(0);
3282 {
3283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3284 std::string ex(str, iter.base());
3285 assert(ex == "+1;e+09");
3286 assert(ios.width() == 0);
3287 }
3288 ios.width(25);
3289 left(ios);
3290 {
3291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3292 std::string ex(str, iter.base());
3293 assert(ex == "+1;e+09******************");
3294 assert(ios.width() == 0);
3295 }
3296 ios.width(25);
3297 right(ios);
3298 {
3299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3300 std::string ex(str, iter.base());
3301 assert(ex == "******************+1;e+09");
3302 assert(ios.width() == 0);
3303 }
3304 ios.width(25);
3305 internal(ios);
3306 {
3307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3308 std::string ex(str, iter.base());
3309 assert(ex == "+******************1;e+09");
3310 assert(ios.width() == 0);
3311 }
3312 }
3313 }
3314 }
3315 }
3316 uppercase(ios);
3317 {
3318 noshowpos(ios);
3319 {
3320 noshowpoint(ios);
3321 {
3322 ios.imbue(lc);
3323 {
3324 ios.width(0);
3325 {
3326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3327 std::string ex(str, iter.base());
3328 assert(ex == "1E+09");
3329 assert(ios.width() == 0);
3330 }
3331 ios.width(25);
3332 left(ios);
3333 {
3334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3335 std::string ex(str, iter.base());
3336 assert(ex == "1E+09********************");
3337 assert(ios.width() == 0);
3338 }
3339 ios.width(25);
3340 right(ios);
3341 {
3342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3343 std::string ex(str, iter.base());
3344 assert(ex == "********************1E+09");
3345 assert(ios.width() == 0);
3346 }
3347 ios.width(25);
3348 internal(ios);
3349 {
3350 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3351 std::string ex(str, iter.base());
3352 assert(ex == "********************1E+09");
3353 assert(ios.width() == 0);
3354 }
3355 }
3356 ios.imbue(lg);
3357 {
3358 ios.width(0);
3359 {
3360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3361 std::string ex(str, iter.base());
3362 assert(ex == "1E+09");
3363 assert(ios.width() == 0);
3364 }
3365 ios.width(25);
3366 left(ios);
3367 {
3368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3369 std::string ex(str, iter.base());
3370 assert(ex == "1E+09********************");
3371 assert(ios.width() == 0);
3372 }
3373 ios.width(25);
3374 right(ios);
3375 {
3376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3377 std::string ex(str, iter.base());
3378 assert(ex == "********************1E+09");
3379 assert(ios.width() == 0);
3380 }
3381 ios.width(25);
3382 internal(ios);
3383 {
3384 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3385 std::string ex(str, iter.base());
3386 assert(ex == "********************1E+09");
3387 assert(ios.width() == 0);
3388 }
3389 }
3390 }
3391 showpoint(ios);
3392 {
3393 ios.imbue(lc);
3394 {
3395 ios.width(0);
3396 {
3397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3398 std::string ex(str, iter.base());
3399 assert(ex == "1.E+09");
3400 assert(ios.width() == 0);
3401 }
3402 ios.width(25);
3403 left(ios);
3404 {
3405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3406 std::string ex(str, iter.base());
3407 assert(ex == "1.E+09*******************");
3408 assert(ios.width() == 0);
3409 }
3410 ios.width(25);
3411 right(ios);
3412 {
3413 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3414 std::string ex(str, iter.base());
3415 assert(ex == "*******************1.E+09");
3416 assert(ios.width() == 0);
3417 }
3418 ios.width(25);
3419 internal(ios);
3420 {
3421 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3422 std::string ex(str, iter.base());
3423 assert(ex == "*******************1.E+09");
3424 assert(ios.width() == 0);
3425 }
3426 }
3427 ios.imbue(lg);
3428 {
3429 ios.width(0);
3430 {
3431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3432 std::string ex(str, iter.base());
3433 assert(ex == "1;E+09");
3434 assert(ios.width() == 0);
3435 }
3436 ios.width(25);
3437 left(ios);
3438 {
3439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3440 std::string ex(str, iter.base());
3441 assert(ex == "1;E+09*******************");
3442 assert(ios.width() == 0);
3443 }
3444 ios.width(25);
3445 right(ios);
3446 {
3447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3448 std::string ex(str, iter.base());
3449 assert(ex == "*******************1;E+09");
3450 assert(ios.width() == 0);
3451 }
3452 ios.width(25);
3453 internal(ios);
3454 {
3455 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3456 std::string ex(str, iter.base());
3457 assert(ex == "*******************1;E+09");
3458 assert(ios.width() == 0);
3459 }
3460 }
3461 }
3462 }
3463 showpos(ios);
3464 {
3465 noshowpoint(ios);
3466 {
3467 ios.imbue(lc);
3468 {
3469 ios.width(0);
3470 {
3471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3472 std::string ex(str, iter.base());
3473 assert(ex == "+1E+09");
3474 assert(ios.width() == 0);
3475 }
3476 ios.width(25);
3477 left(ios);
3478 {
3479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3480 std::string ex(str, iter.base());
3481 assert(ex == "+1E+09*******************");
3482 assert(ios.width() == 0);
3483 }
3484 ios.width(25);
3485 right(ios);
3486 {
3487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3488 std::string ex(str, iter.base());
3489 assert(ex == "*******************+1E+09");
3490 assert(ios.width() == 0);
3491 }
3492 ios.width(25);
3493 internal(ios);
3494 {
3495 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3496 std::string ex(str, iter.base());
3497 assert(ex == "+*******************1E+09");
3498 assert(ios.width() == 0);
3499 }
3500 }
3501 ios.imbue(lg);
3502 {
3503 ios.width(0);
3504 {
3505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3506 std::string ex(str, iter.base());
3507 assert(ex == "+1E+09");
3508 assert(ios.width() == 0);
3509 }
3510 ios.width(25);
3511 left(ios);
3512 {
3513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3514 std::string ex(str, iter.base());
3515 assert(ex == "+1E+09*******************");
3516 assert(ios.width() == 0);
3517 }
3518 ios.width(25);
3519 right(ios);
3520 {
3521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3522 std::string ex(str, iter.base());
3523 assert(ex == "*******************+1E+09");
3524 assert(ios.width() == 0);
3525 }
3526 ios.width(25);
3527 internal(ios);
3528 {
3529 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3530 std::string ex(str, iter.base());
3531 assert(ex == "+*******************1E+09");
3532 assert(ios.width() == 0);
3533 }
3534 }
3535 }
3536 showpoint(ios);
3537 {
3538 ios.imbue(lc);
3539 {
3540 ios.width(0);
3541 {
3542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3543 std::string ex(str, iter.base());
3544 assert(ex == "+1.E+09");
3545 assert(ios.width() == 0);
3546 }
3547 ios.width(25);
3548 left(ios);
3549 {
3550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3551 std::string ex(str, iter.base());
3552 assert(ex == "+1.E+09******************");
3553 assert(ios.width() == 0);
3554 }
3555 ios.width(25);
3556 right(ios);
3557 {
3558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3559 std::string ex(str, iter.base());
3560 assert(ex == "******************+1.E+09");
3561 assert(ios.width() == 0);
3562 }
3563 ios.width(25);
3564 internal(ios);
3565 {
3566 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3567 std::string ex(str, iter.base());
3568 assert(ex == "+******************1.E+09");
3569 assert(ios.width() == 0);
3570 }
3571 }
3572 ios.imbue(lg);
3573 {
3574 ios.width(0);
3575 {
3576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3577 std::string ex(str, iter.base());
3578 assert(ex == "+1;E+09");
3579 assert(ios.width() == 0);
3580 }
3581 ios.width(25);
3582 left(ios);
3583 {
3584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3585 std::string ex(str, iter.base());
3586 assert(ex == "+1;E+09******************");
3587 assert(ios.width() == 0);
3588 }
3589 ios.width(25);
3590 right(ios);
3591 {
3592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3593 std::string ex(str, iter.base());
3594 assert(ex == "******************+1;E+09");
3595 assert(ios.width() == 0);
3596 }
3597 ios.width(25);
3598 internal(ios);
3599 {
3600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3601 std::string ex(str, iter.base());
3602 assert(ex == "+******************1;E+09");
3603 assert(ios.width() == 0);
3604 }
3605 }
3606 }
3607 }
3608 }
3609 }
3610 ios.precision(1);
3611 {
3612 nouppercase(ios);
3613 {
3614 noshowpos(ios);
3615 {
3616 noshowpoint(ios);
3617 {
3618 ios.imbue(lc);
3619 {
3620 ios.width(0);
3621 {
3622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3623 std::string ex(str, iter.base());
3624 assert(ex == "1e+09");
3625 assert(ios.width() == 0);
3626 }
3627 ios.width(25);
3628 left(ios);
3629 {
3630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3631 std::string ex(str, iter.base());
3632 assert(ex == "1e+09********************");
3633 assert(ios.width() == 0);
3634 }
3635 ios.width(25);
3636 right(ios);
3637 {
3638 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3639 std::string ex(str, iter.base());
3640 assert(ex == "********************1e+09");
3641 assert(ios.width() == 0);
3642 }
3643 ios.width(25);
3644 internal(ios);
3645 {
3646 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3647 std::string ex(str, iter.base());
3648 assert(ex == "********************1e+09");
3649 assert(ios.width() == 0);
3650 }
3651 }
3652 ios.imbue(lg);
3653 {
3654 ios.width(0);
3655 {
3656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3657 std::string ex(str, iter.base());
3658 assert(ex == "1e+09");
3659 assert(ios.width() == 0);
3660 }
3661 ios.width(25);
3662 left(ios);
3663 {
3664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3665 std::string ex(str, iter.base());
3666 assert(ex == "1e+09********************");
3667 assert(ios.width() == 0);
3668 }
3669 ios.width(25);
3670 right(ios);
3671 {
3672 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3673 std::string ex(str, iter.base());
3674 assert(ex == "********************1e+09");
3675 assert(ios.width() == 0);
3676 }
3677 ios.width(25);
3678 internal(ios);
3679 {
3680 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3681 std::string ex(str, iter.base());
3682 assert(ex == "********************1e+09");
3683 assert(ios.width() == 0);
3684 }
3685 }
3686 }
3687 showpoint(ios);
3688 {
3689 ios.imbue(lc);
3690 {
3691 ios.width(0);
3692 {
3693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3694 std::string ex(str, iter.base());
3695 assert(ex == "1.e+09");
3696 assert(ios.width() == 0);
3697 }
3698 ios.width(25);
3699 left(ios);
3700 {
3701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3702 std::string ex(str, iter.base());
3703 assert(ex == "1.e+09*******************");
3704 assert(ios.width() == 0);
3705 }
3706 ios.width(25);
3707 right(ios);
3708 {
3709 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3710 std::string ex(str, iter.base());
3711 assert(ex == "*******************1.e+09");
3712 assert(ios.width() == 0);
3713 }
3714 ios.width(25);
3715 internal(ios);
3716 {
3717 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3718 std::string ex(str, iter.base());
3719 assert(ex == "*******************1.e+09");
3720 assert(ios.width() == 0);
3721 }
3722 }
3723 ios.imbue(lg);
3724 {
3725 ios.width(0);
3726 {
3727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3728 std::string ex(str, iter.base());
3729 assert(ex == "1;e+09");
3730 assert(ios.width() == 0);
3731 }
3732 ios.width(25);
3733 left(ios);
3734 {
3735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3736 std::string ex(str, iter.base());
3737 assert(ex == "1;e+09*******************");
3738 assert(ios.width() == 0);
3739 }
3740 ios.width(25);
3741 right(ios);
3742 {
3743 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3744 std::string ex(str, iter.base());
3745 assert(ex == "*******************1;e+09");
3746 assert(ios.width() == 0);
3747 }
3748 ios.width(25);
3749 internal(ios);
3750 {
3751 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3752 std::string ex(str, iter.base());
3753 assert(ex == "*******************1;e+09");
3754 assert(ios.width() == 0);
3755 }
3756 }
3757 }
3758 }
3759 showpos(ios);
3760 {
3761 noshowpoint(ios);
3762 {
3763 ios.imbue(lc);
3764 {
3765 ios.width(0);
3766 {
3767 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3768 std::string ex(str, iter.base());
3769 assert(ex == "+1e+09");
3770 assert(ios.width() == 0);
3771 }
3772 ios.width(25);
3773 left(ios);
3774 {
3775 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3776 std::string ex(str, iter.base());
3777 assert(ex == "+1e+09*******************");
3778 assert(ios.width() == 0);
3779 }
3780 ios.width(25);
3781 right(ios);
3782 {
3783 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3784 std::string ex(str, iter.base());
3785 assert(ex == "*******************+1e+09");
3786 assert(ios.width() == 0);
3787 }
3788 ios.width(25);
3789 internal(ios);
3790 {
3791 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3792 std::string ex(str, iter.base());
3793 assert(ex == "+*******************1e+09");
3794 assert(ios.width() == 0);
3795 }
3796 }
3797 ios.imbue(lg);
3798 {
3799 ios.width(0);
3800 {
3801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3802 std::string ex(str, iter.base());
3803 assert(ex == "+1e+09");
3804 assert(ios.width() == 0);
3805 }
3806 ios.width(25);
3807 left(ios);
3808 {
3809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3810 std::string ex(str, iter.base());
3811 assert(ex == "+1e+09*******************");
3812 assert(ios.width() == 0);
3813 }
3814 ios.width(25);
3815 right(ios);
3816 {
3817 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3818 std::string ex(str, iter.base());
3819 assert(ex == "*******************+1e+09");
3820 assert(ios.width() == 0);
3821 }
3822 ios.width(25);
3823 internal(ios);
3824 {
3825 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3826 std::string ex(str, iter.base());
3827 assert(ex == "+*******************1e+09");
3828 assert(ios.width() == 0);
3829 }
3830 }
3831 }
3832 showpoint(ios);
3833 {
3834 ios.imbue(lc);
3835 {
3836 ios.width(0);
3837 {
3838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3839 std::string ex(str, iter.base());
3840 assert(ex == "+1.e+09");
3841 assert(ios.width() == 0);
3842 }
3843 ios.width(25);
3844 left(ios);
3845 {
3846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3847 std::string ex(str, iter.base());
3848 assert(ex == "+1.e+09******************");
3849 assert(ios.width() == 0);
3850 }
3851 ios.width(25);
3852 right(ios);
3853 {
3854 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3855 std::string ex(str, iter.base());
3856 assert(ex == "******************+1.e+09");
3857 assert(ios.width() == 0);
3858 }
3859 ios.width(25);
3860 internal(ios);
3861 {
3862 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3863 std::string ex(str, iter.base());
3864 assert(ex == "+******************1.e+09");
3865 assert(ios.width() == 0);
3866 }
3867 }
3868 ios.imbue(lg);
3869 {
3870 ios.width(0);
3871 {
3872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3873 std::string ex(str, iter.base());
3874 assert(ex == "+1;e+09");
3875 assert(ios.width() == 0);
3876 }
3877 ios.width(25);
3878 left(ios);
3879 {
3880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3881 std::string ex(str, iter.base());
3882 assert(ex == "+1;e+09******************");
3883 assert(ios.width() == 0);
3884 }
3885 ios.width(25);
3886 right(ios);
3887 {
3888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3889 std::string ex(str, iter.base());
3890 assert(ex == "******************+1;e+09");
3891 assert(ios.width() == 0);
3892 }
3893 ios.width(25);
3894 internal(ios);
3895 {
3896 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3897 std::string ex(str, iter.base());
3898 assert(ex == "+******************1;e+09");
3899 assert(ios.width() == 0);
3900 }
3901 }
3902 }
3903 }
3904 }
3905 uppercase(ios);
3906 {
3907 noshowpos(ios);
3908 {
3909 noshowpoint(ios);
3910 {
3911 ios.imbue(lc);
3912 {
3913 ios.width(0);
3914 {
3915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3916 std::string ex(str, iter.base());
3917 assert(ex == "1E+09");
3918 assert(ios.width() == 0);
3919 }
3920 ios.width(25);
3921 left(ios);
3922 {
3923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3924 std::string ex(str, iter.base());
3925 assert(ex == "1E+09********************");
3926 assert(ios.width() == 0);
3927 }
3928 ios.width(25);
3929 right(ios);
3930 {
3931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3932 std::string ex(str, iter.base());
3933 assert(ex == "********************1E+09");
3934 assert(ios.width() == 0);
3935 }
3936 ios.width(25);
3937 internal(ios);
3938 {
3939 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3940 std::string ex(str, iter.base());
3941 assert(ex == "********************1E+09");
3942 assert(ios.width() == 0);
3943 }
3944 }
3945 ios.imbue(lg);
3946 {
3947 ios.width(0);
3948 {
3949 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3950 std::string ex(str, iter.base());
3951 assert(ex == "1E+09");
3952 assert(ios.width() == 0);
3953 }
3954 ios.width(25);
3955 left(ios);
3956 {
3957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3958 std::string ex(str, iter.base());
3959 assert(ex == "1E+09********************");
3960 assert(ios.width() == 0);
3961 }
3962 ios.width(25);
3963 right(ios);
3964 {
3965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3966 std::string ex(str, iter.base());
3967 assert(ex == "********************1E+09");
3968 assert(ios.width() == 0);
3969 }
3970 ios.width(25);
3971 internal(ios);
3972 {
3973 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3974 std::string ex(str, iter.base());
3975 assert(ex == "********************1E+09");
3976 assert(ios.width() == 0);
3977 }
3978 }
3979 }
3980 showpoint(ios);
3981 {
3982 ios.imbue(lc);
3983 {
3984 ios.width(0);
3985 {
3986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3987 std::string ex(str, iter.base());
3988 assert(ex == "1.E+09");
3989 assert(ios.width() == 0);
3990 }
3991 ios.width(25);
3992 left(ios);
3993 {
3994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3995 std::string ex(str, iter.base());
3996 assert(ex == "1.E+09*******************");
3997 assert(ios.width() == 0);
3998 }
3999 ios.width(25);
4000 right(ios);
4001 {
4002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4003 std::string ex(str, iter.base());
4004 assert(ex == "*******************1.E+09");
4005 assert(ios.width() == 0);
4006 }
4007 ios.width(25);
4008 internal(ios);
4009 {
4010 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4011 std::string ex(str, iter.base());
4012 assert(ex == "*******************1.E+09");
4013 assert(ios.width() == 0);
4014 }
4015 }
4016 ios.imbue(lg);
4017 {
4018 ios.width(0);
4019 {
4020 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4021 std::string ex(str, iter.base());
4022 assert(ex == "1;E+09");
4023 assert(ios.width() == 0);
4024 }
4025 ios.width(25);
4026 left(ios);
4027 {
4028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4029 std::string ex(str, iter.base());
4030 assert(ex == "1;E+09*******************");
4031 assert(ios.width() == 0);
4032 }
4033 ios.width(25);
4034 right(ios);
4035 {
4036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4037 std::string ex(str, iter.base());
4038 assert(ex == "*******************1;E+09");
4039 assert(ios.width() == 0);
4040 }
4041 ios.width(25);
4042 internal(ios);
4043 {
4044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4045 std::string ex(str, iter.base());
4046 assert(ex == "*******************1;E+09");
4047 assert(ios.width() == 0);
4048 }
4049 }
4050 }
4051 }
4052 showpos(ios);
4053 {
4054 noshowpoint(ios);
4055 {
4056 ios.imbue(lc);
4057 {
4058 ios.width(0);
4059 {
4060 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4061 std::string ex(str, iter.base());
4062 assert(ex == "+1E+09");
4063 assert(ios.width() == 0);
4064 }
4065 ios.width(25);
4066 left(ios);
4067 {
4068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4069 std::string ex(str, iter.base());
4070 assert(ex == "+1E+09*******************");
4071 assert(ios.width() == 0);
4072 }
4073 ios.width(25);
4074 right(ios);
4075 {
4076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4077 std::string ex(str, iter.base());
4078 assert(ex == "*******************+1E+09");
4079 assert(ios.width() == 0);
4080 }
4081 ios.width(25);
4082 internal(ios);
4083 {
4084 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4085 std::string ex(str, iter.base());
4086 assert(ex == "+*******************1E+09");
4087 assert(ios.width() == 0);
4088 }
4089 }
4090 ios.imbue(lg);
4091 {
4092 ios.width(0);
4093 {
4094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4095 std::string ex(str, iter.base());
4096 assert(ex == "+1E+09");
4097 assert(ios.width() == 0);
4098 }
4099 ios.width(25);
4100 left(ios);
4101 {
4102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4103 std::string ex(str, iter.base());
4104 assert(ex == "+1E+09*******************");
4105 assert(ios.width() == 0);
4106 }
4107 ios.width(25);
4108 right(ios);
4109 {
4110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4111 std::string ex(str, iter.base());
4112 assert(ex == "*******************+1E+09");
4113 assert(ios.width() == 0);
4114 }
4115 ios.width(25);
4116 internal(ios);
4117 {
4118 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4119 std::string ex(str, iter.base());
4120 assert(ex == "+*******************1E+09");
4121 assert(ios.width() == 0);
4122 }
4123 }
4124 }
4125 showpoint(ios);
4126 {
4127 ios.imbue(lc);
4128 {
4129 ios.width(0);
4130 {
4131 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4132 std::string ex(str, iter.base());
4133 assert(ex == "+1.E+09");
4134 assert(ios.width() == 0);
4135 }
4136 ios.width(25);
4137 left(ios);
4138 {
4139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4140 std::string ex(str, iter.base());
4141 assert(ex == "+1.E+09******************");
4142 assert(ios.width() == 0);
4143 }
4144 ios.width(25);
4145 right(ios);
4146 {
4147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4148 std::string ex(str, iter.base());
4149 assert(ex == "******************+1.E+09");
4150 assert(ios.width() == 0);
4151 }
4152 ios.width(25);
4153 internal(ios);
4154 {
4155 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4156 std::string ex(str, iter.base());
4157 assert(ex == "+******************1.E+09");
4158 assert(ios.width() == 0);
4159 }
4160 }
4161 ios.imbue(lg);
4162 {
4163 ios.width(0);
4164 {
4165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4166 std::string ex(str, iter.base());
4167 assert(ex == "+1;E+09");
4168 assert(ios.width() == 0);
4169 }
4170 ios.width(25);
4171 left(ios);
4172 {
4173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4174 std::string ex(str, iter.base());
4175 assert(ex == "+1;E+09******************");
4176 assert(ios.width() == 0);
4177 }
4178 ios.width(25);
4179 right(ios);
4180 {
4181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4182 std::string ex(str, iter.base());
4183 assert(ex == "******************+1;E+09");
4184 assert(ios.width() == 0);
4185 }
4186 ios.width(25);
4187 internal(ios);
4188 {
4189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4190 std::string ex(str, iter.base());
4191 assert(ex == "+******************1;E+09");
4192 assert(ios.width() == 0);
4193 }
4194 }
4195 }
4196 }
4197 }
4198 }
4199 ios.precision(6);
4200 {
4201 nouppercase(ios);
4202 {
4203 noshowpos(ios);
4204 {
4205 noshowpoint(ios);
4206 {
4207 ios.imbue(lc);
4208 {
4209 ios.width(0);
4210 {
4211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4212 std::string ex(str, iter.base());
4213 assert(ex == "1.23457e+09");
4214 assert(ios.width() == 0);
4215 }
4216 ios.width(25);
4217 left(ios);
4218 {
4219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4220 std::string ex(str, iter.base());
4221 assert(ex == "1.23457e+09**************");
4222 assert(ios.width() == 0);
4223 }
4224 ios.width(25);
4225 right(ios);
4226 {
4227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4228 std::string ex(str, iter.base());
4229 assert(ex == "**************1.23457e+09");
4230 assert(ios.width() == 0);
4231 }
4232 ios.width(25);
4233 internal(ios);
4234 {
4235 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4236 std::string ex(str, iter.base());
4237 assert(ex == "**************1.23457e+09");
4238 assert(ios.width() == 0);
4239 }
4240 }
4241 ios.imbue(lg);
4242 {
4243 ios.width(0);
4244 {
4245 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4246 std::string ex(str, iter.base());
4247 assert(ex == "1;23457e+09");
4248 assert(ios.width() == 0);
4249 }
4250 ios.width(25);
4251 left(ios);
4252 {
4253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4254 std::string ex(str, iter.base());
4255 assert(ex == "1;23457e+09**************");
4256 assert(ios.width() == 0);
4257 }
4258 ios.width(25);
4259 right(ios);
4260 {
4261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4262 std::string ex(str, iter.base());
4263 assert(ex == "**************1;23457e+09");
4264 assert(ios.width() == 0);
4265 }
4266 ios.width(25);
4267 internal(ios);
4268 {
4269 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4270 std::string ex(str, iter.base());
4271 assert(ex == "**************1;23457e+09");
4272 assert(ios.width() == 0);
4273 }
4274 }
4275 }
4276 showpoint(ios);
4277 {
4278 ios.imbue(lc);
4279 {
4280 ios.width(0);
4281 {
4282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4283 std::string ex(str, iter.base());
4284 assert(ex == "1.23457e+09");
4285 assert(ios.width() == 0);
4286 }
4287 ios.width(25);
4288 left(ios);
4289 {
4290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4291 std::string ex(str, iter.base());
4292 assert(ex == "1.23457e+09**************");
4293 assert(ios.width() == 0);
4294 }
4295 ios.width(25);
4296 right(ios);
4297 {
4298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4299 std::string ex(str, iter.base());
4300 assert(ex == "**************1.23457e+09");
4301 assert(ios.width() == 0);
4302 }
4303 ios.width(25);
4304 internal(ios);
4305 {
4306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4307 std::string ex(str, iter.base());
4308 assert(ex == "**************1.23457e+09");
4309 assert(ios.width() == 0);
4310 }
4311 }
4312 ios.imbue(lg);
4313 {
4314 ios.width(0);
4315 {
4316 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4317 std::string ex(str, iter.base());
4318 assert(ex == "1;23457e+09");
4319 assert(ios.width() == 0);
4320 }
4321 ios.width(25);
4322 left(ios);
4323 {
4324 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4325 std::string ex(str, iter.base());
4326 assert(ex == "1;23457e+09**************");
4327 assert(ios.width() == 0);
4328 }
4329 ios.width(25);
4330 right(ios);
4331 {
4332 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4333 std::string ex(str, iter.base());
4334 assert(ex == "**************1;23457e+09");
4335 assert(ios.width() == 0);
4336 }
4337 ios.width(25);
4338 internal(ios);
4339 {
4340 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4341 std::string ex(str, iter.base());
4342 assert(ex == "**************1;23457e+09");
4343 assert(ios.width() == 0);
4344 }
4345 }
4346 }
4347 }
4348 showpos(ios);
4349 {
4350 noshowpoint(ios);
4351 {
4352 ios.imbue(lc);
4353 {
4354 ios.width(0);
4355 {
4356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4357 std::string ex(str, iter.base());
4358 assert(ex == "+1.23457e+09");
4359 assert(ios.width() == 0);
4360 }
4361 ios.width(25);
4362 left(ios);
4363 {
4364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4365 std::string ex(str, iter.base());
4366 assert(ex == "+1.23457e+09*************");
4367 assert(ios.width() == 0);
4368 }
4369 ios.width(25);
4370 right(ios);
4371 {
4372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4373 std::string ex(str, iter.base());
4374 assert(ex == "*************+1.23457e+09");
4375 assert(ios.width() == 0);
4376 }
4377 ios.width(25);
4378 internal(ios);
4379 {
4380 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4381 std::string ex(str, iter.base());
4382 assert(ex == "+*************1.23457e+09");
4383 assert(ios.width() == 0);
4384 }
4385 }
4386 ios.imbue(lg);
4387 {
4388 ios.width(0);
4389 {
4390 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4391 std::string ex(str, iter.base());
4392 assert(ex == "+1;23457e+09");
4393 assert(ios.width() == 0);
4394 }
4395 ios.width(25);
4396 left(ios);
4397 {
4398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4399 std::string ex(str, iter.base());
4400 assert(ex == "+1;23457e+09*************");
4401 assert(ios.width() == 0);
4402 }
4403 ios.width(25);
4404 right(ios);
4405 {
4406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4407 std::string ex(str, iter.base());
4408 assert(ex == "*************+1;23457e+09");
4409 assert(ios.width() == 0);
4410 }
4411 ios.width(25);
4412 internal(ios);
4413 {
4414 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4415 std::string ex(str, iter.base());
4416 assert(ex == "+*************1;23457e+09");
4417 assert(ios.width() == 0);
4418 }
4419 }
4420 }
4421 showpoint(ios);
4422 {
4423 ios.imbue(lc);
4424 {
4425 ios.width(0);
4426 {
4427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4428 std::string ex(str, iter.base());
4429 assert(ex == "+1.23457e+09");
4430 assert(ios.width() == 0);
4431 }
4432 ios.width(25);
4433 left(ios);
4434 {
4435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4436 std::string ex(str, iter.base());
4437 assert(ex == "+1.23457e+09*************");
4438 assert(ios.width() == 0);
4439 }
4440 ios.width(25);
4441 right(ios);
4442 {
4443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4444 std::string ex(str, iter.base());
4445 assert(ex == "*************+1.23457e+09");
4446 assert(ios.width() == 0);
4447 }
4448 ios.width(25);
4449 internal(ios);
4450 {
4451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4452 std::string ex(str, iter.base());
4453 assert(ex == "+*************1.23457e+09");
4454 assert(ios.width() == 0);
4455 }
4456 }
4457 ios.imbue(lg);
4458 {
4459 ios.width(0);
4460 {
4461 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4462 std::string ex(str, iter.base());
4463 assert(ex == "+1;23457e+09");
4464 assert(ios.width() == 0);
4465 }
4466 ios.width(25);
4467 left(ios);
4468 {
4469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4470 std::string ex(str, iter.base());
4471 assert(ex == "+1;23457e+09*************");
4472 assert(ios.width() == 0);
4473 }
4474 ios.width(25);
4475 right(ios);
4476 {
4477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4478 std::string ex(str, iter.base());
4479 assert(ex == "*************+1;23457e+09");
4480 assert(ios.width() == 0);
4481 }
4482 ios.width(25);
4483 internal(ios);
4484 {
4485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4486 std::string ex(str, iter.base());
4487 assert(ex == "+*************1;23457e+09");
4488 assert(ios.width() == 0);
4489 }
4490 }
4491 }
4492 }
4493 }
4494 uppercase(ios);
4495 {
4496 noshowpos(ios);
4497 {
4498 noshowpoint(ios);
4499 {
4500 ios.imbue(lc);
4501 {
4502 ios.width(0);
4503 {
4504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4505 std::string ex(str, iter.base());
4506 assert(ex == "1.23457E+09");
4507 assert(ios.width() == 0);
4508 }
4509 ios.width(25);
4510 left(ios);
4511 {
4512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4513 std::string ex(str, iter.base());
4514 assert(ex == "1.23457E+09**************");
4515 assert(ios.width() == 0);
4516 }
4517 ios.width(25);
4518 right(ios);
4519 {
4520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4521 std::string ex(str, iter.base());
4522 assert(ex == "**************1.23457E+09");
4523 assert(ios.width() == 0);
4524 }
4525 ios.width(25);
4526 internal(ios);
4527 {
4528 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4529 std::string ex(str, iter.base());
4530 assert(ex == "**************1.23457E+09");
4531 assert(ios.width() == 0);
4532 }
4533 }
4534 ios.imbue(lg);
4535 {
4536 ios.width(0);
4537 {
4538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4539 std::string ex(str, iter.base());
4540 assert(ex == "1;23457E+09");
4541 assert(ios.width() == 0);
4542 }
4543 ios.width(25);
4544 left(ios);
4545 {
4546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4547 std::string ex(str, iter.base());
4548 assert(ex == "1;23457E+09**************");
4549 assert(ios.width() == 0);
4550 }
4551 ios.width(25);
4552 right(ios);
4553 {
4554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4555 std::string ex(str, iter.base());
4556 assert(ex == "**************1;23457E+09");
4557 assert(ios.width() == 0);
4558 }
4559 ios.width(25);
4560 internal(ios);
4561 {
4562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4563 std::string ex(str, iter.base());
4564 assert(ex == "**************1;23457E+09");
4565 assert(ios.width() == 0);
4566 }
4567 }
4568 }
4569 showpoint(ios);
4570 {
4571 ios.imbue(lc);
4572 {
4573 ios.width(0);
4574 {
4575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4576 std::string ex(str, iter.base());
4577 assert(ex == "1.23457E+09");
4578 assert(ios.width() == 0);
4579 }
4580 ios.width(25);
4581 left(ios);
4582 {
4583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4584 std::string ex(str, iter.base());
4585 assert(ex == "1.23457E+09**************");
4586 assert(ios.width() == 0);
4587 }
4588 ios.width(25);
4589 right(ios);
4590 {
4591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4592 std::string ex(str, iter.base());
4593 assert(ex == "**************1.23457E+09");
4594 assert(ios.width() == 0);
4595 }
4596 ios.width(25);
4597 internal(ios);
4598 {
4599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4600 std::string ex(str, iter.base());
4601 assert(ex == "**************1.23457E+09");
4602 assert(ios.width() == 0);
4603 }
4604 }
4605 ios.imbue(lg);
4606 {
4607 ios.width(0);
4608 {
4609 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4610 std::string ex(str, iter.base());
4611 assert(ex == "1;23457E+09");
4612 assert(ios.width() == 0);
4613 }
4614 ios.width(25);
4615 left(ios);
4616 {
4617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4618 std::string ex(str, iter.base());
4619 assert(ex == "1;23457E+09**************");
4620 assert(ios.width() == 0);
4621 }
4622 ios.width(25);
4623 right(ios);
4624 {
4625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4626 std::string ex(str, iter.base());
4627 assert(ex == "**************1;23457E+09");
4628 assert(ios.width() == 0);
4629 }
4630 ios.width(25);
4631 internal(ios);
4632 {
4633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4634 std::string ex(str, iter.base());
4635 assert(ex == "**************1;23457E+09");
4636 assert(ios.width() == 0);
4637 }
4638 }
4639 }
4640 }
4641 showpos(ios);
4642 {
4643 noshowpoint(ios);
4644 {
4645 ios.imbue(lc);
4646 {
4647 ios.width(0);
4648 {
4649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4650 std::string ex(str, iter.base());
4651 assert(ex == "+1.23457E+09");
4652 assert(ios.width() == 0);
4653 }
4654 ios.width(25);
4655 left(ios);
4656 {
4657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4658 std::string ex(str, iter.base());
4659 assert(ex == "+1.23457E+09*************");
4660 assert(ios.width() == 0);
4661 }
4662 ios.width(25);
4663 right(ios);
4664 {
4665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4666 std::string ex(str, iter.base());
4667 assert(ex == "*************+1.23457E+09");
4668 assert(ios.width() == 0);
4669 }
4670 ios.width(25);
4671 internal(ios);
4672 {
4673 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4674 std::string ex(str, iter.base());
4675 assert(ex == "+*************1.23457E+09");
4676 assert(ios.width() == 0);
4677 }
4678 }
4679 ios.imbue(lg);
4680 {
4681 ios.width(0);
4682 {
4683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4684 std::string ex(str, iter.base());
4685 assert(ex == "+1;23457E+09");
4686 assert(ios.width() == 0);
4687 }
4688 ios.width(25);
4689 left(ios);
4690 {
4691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4692 std::string ex(str, iter.base());
4693 assert(ex == "+1;23457E+09*************");
4694 assert(ios.width() == 0);
4695 }
4696 ios.width(25);
4697 right(ios);
4698 {
4699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4700 std::string ex(str, iter.base());
4701 assert(ex == "*************+1;23457E+09");
4702 assert(ios.width() == 0);
4703 }
4704 ios.width(25);
4705 internal(ios);
4706 {
4707 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4708 std::string ex(str, iter.base());
4709 assert(ex == "+*************1;23457E+09");
4710 assert(ios.width() == 0);
4711 }
4712 }
4713 }
4714 showpoint(ios);
4715 {
4716 ios.imbue(lc);
4717 {
4718 ios.width(0);
4719 {
4720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4721 std::string ex(str, iter.base());
4722 assert(ex == "+1.23457E+09");
4723 assert(ios.width() == 0);
4724 }
4725 ios.width(25);
4726 left(ios);
4727 {
4728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4729 std::string ex(str, iter.base());
4730 assert(ex == "+1.23457E+09*************");
4731 assert(ios.width() == 0);
4732 }
4733 ios.width(25);
4734 right(ios);
4735 {
4736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4737 std::string ex(str, iter.base());
4738 assert(ex == "*************+1.23457E+09");
4739 assert(ios.width() == 0);
4740 }
4741 ios.width(25);
4742 internal(ios);
4743 {
4744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4745 std::string ex(str, iter.base());
4746 assert(ex == "+*************1.23457E+09");
4747 assert(ios.width() == 0);
4748 }
4749 }
4750 ios.imbue(lg);
4751 {
4752 ios.width(0);
4753 {
4754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4755 std::string ex(str, iter.base());
4756 assert(ex == "+1;23457E+09");
4757 assert(ios.width() == 0);
4758 }
4759 ios.width(25);
4760 left(ios);
4761 {
4762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4763 std::string ex(str, iter.base());
4764 assert(ex == "+1;23457E+09*************");
4765 assert(ios.width() == 0);
4766 }
4767 ios.width(25);
4768 right(ios);
4769 {
4770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4771 std::string ex(str, iter.base());
4772 assert(ex == "*************+1;23457E+09");
4773 assert(ios.width() == 0);
4774 }
4775 ios.width(25);
4776 internal(ios);
4777 {
4778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4779 std::string ex(str, iter.base());
4780 assert(ex == "+*************1;23457E+09");
4781 assert(ios.width() == 0);
4782 }
4783 }
4784 }
4785 }
4786 }
4787 }
4788 ios.precision(16);
4789 {
4790 nouppercase(ios);
4791 {
4792 noshowpos(ios);
4793 {
4794 noshowpoint(ios);
4795 {
4796 ios.imbue(lc);
4797 {
4798 ios.width(0);
4799 {
4800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4801 std::string ex(str, iter.base());
4802 assert(ex == "1234567890.125");
4803 assert(ios.width() == 0);
4804 }
4805 ios.width(25);
4806 left(ios);
4807 {
4808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4809 std::string ex(str, iter.base());
4810 assert(ex == "1234567890.125***********");
4811 assert(ios.width() == 0);
4812 }
4813 ios.width(25);
4814 right(ios);
4815 {
4816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4817 std::string ex(str, iter.base());
4818 assert(ex == "***********1234567890.125");
4819 assert(ios.width() == 0);
4820 }
4821 ios.width(25);
4822 internal(ios);
4823 {
4824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4825 std::string ex(str, iter.base());
4826 assert(ex == "***********1234567890.125");
4827 assert(ios.width() == 0);
4828 }
4829 }
4830 ios.imbue(lg);
4831 {
4832 ios.width(0);
4833 {
4834 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4835 std::string ex(str, iter.base());
4836 assert(ex == "1_234_567_89_0;125");
4837 assert(ios.width() == 0);
4838 }
4839 ios.width(25);
4840 left(ios);
4841 {
4842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4843 std::string ex(str, iter.base());
4844 assert(ex == "1_234_567_89_0;125*******");
4845 assert(ios.width() == 0);
4846 }
4847 ios.width(25);
4848 right(ios);
4849 {
4850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4851 std::string ex(str, iter.base());
4852 assert(ex == "*******1_234_567_89_0;125");
4853 assert(ios.width() == 0);
4854 }
4855 ios.width(25);
4856 internal(ios);
4857 {
4858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4859 std::string ex(str, iter.base());
4860 assert(ex == "*******1_234_567_89_0;125");
4861 assert(ios.width() == 0);
4862 }
4863 }
4864 }
4865 showpoint(ios);
4866 {
4867 ios.imbue(lc);
4868 {
4869 ios.width(0);
4870 {
4871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4872 std::string ex(str, iter.base());
4873 assert(ex == "1234567890.125000");
4874 assert(ios.width() == 0);
4875 }
4876 ios.width(25);
4877 left(ios);
4878 {
4879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4880 std::string ex(str, iter.base());
4881 assert(ex == "1234567890.125000********");
4882 assert(ios.width() == 0);
4883 }
4884 ios.width(25);
4885 right(ios);
4886 {
4887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4888 std::string ex(str, iter.base());
4889 assert(ex == "********1234567890.125000");
4890 assert(ios.width() == 0);
4891 }
4892 ios.width(25);
4893 internal(ios);
4894 {
4895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4896 std::string ex(str, iter.base());
4897 assert(ex == "********1234567890.125000");
4898 assert(ios.width() == 0);
4899 }
4900 }
4901 ios.imbue(lg);
4902 {
4903 ios.width(0);
4904 {
4905 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4906 std::string ex(str, iter.base());
4907 assert(ex == "1_234_567_89_0;125000");
4908 assert(ios.width() == 0);
4909 }
4910 ios.width(25);
4911 left(ios);
4912 {
4913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4914 std::string ex(str, iter.base());
4915 assert(ex == "1_234_567_89_0;125000****");
4916 assert(ios.width() == 0);
4917 }
4918 ios.width(25);
4919 right(ios);
4920 {
4921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4922 std::string ex(str, iter.base());
4923 assert(ex == "****1_234_567_89_0;125000");
4924 assert(ios.width() == 0);
4925 }
4926 ios.width(25);
4927 internal(ios);
4928 {
4929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4930 std::string ex(str, iter.base());
4931 assert(ex == "****1_234_567_89_0;125000");
4932 assert(ios.width() == 0);
4933 }
4934 }
4935 }
4936 }
4937 showpos(ios);
4938 {
4939 noshowpoint(ios);
4940 {
4941 ios.imbue(lc);
4942 {
4943 ios.width(0);
4944 {
4945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4946 std::string ex(str, iter.base());
4947 assert(ex == "+1234567890.125");
4948 assert(ios.width() == 0);
4949 }
4950 ios.width(25);
4951 left(ios);
4952 {
4953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4954 std::string ex(str, iter.base());
4955 assert(ex == "+1234567890.125**********");
4956 assert(ios.width() == 0);
4957 }
4958 ios.width(25);
4959 right(ios);
4960 {
4961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4962 std::string ex(str, iter.base());
4963 assert(ex == "**********+1234567890.125");
4964 assert(ios.width() == 0);
4965 }
4966 ios.width(25);
4967 internal(ios);
4968 {
4969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4970 std::string ex(str, iter.base());
4971 assert(ex == "+**********1234567890.125");
4972 assert(ios.width() == 0);
4973 }
4974 }
4975 ios.imbue(lg);
4976 {
4977 ios.width(0);
4978 {
4979 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4980 std::string ex(str, iter.base());
4981 assert(ex == "+1_234_567_89_0;125");
4982 assert(ios.width() == 0);
4983 }
4984 ios.width(25);
4985 left(ios);
4986 {
4987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4988 std::string ex(str, iter.base());
4989 assert(ex == "+1_234_567_89_0;125******");
4990 assert(ios.width() == 0);
4991 }
4992 ios.width(25);
4993 right(ios);
4994 {
4995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4996 std::string ex(str, iter.base());
4997 assert(ex == "******+1_234_567_89_0;125");
4998 assert(ios.width() == 0);
4999 }
5000 ios.width(25);
5001 internal(ios);
5002 {
5003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5004 std::string ex(str, iter.base());
5005 assert(ex == "+******1_234_567_89_0;125");
5006 assert(ios.width() == 0);
5007 }
5008 }
5009 }
5010 showpoint(ios);
5011 {
5012 ios.imbue(lc);
5013 {
5014 ios.width(0);
5015 {
5016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5017 std::string ex(str, iter.base());
5018 assert(ex == "+1234567890.125000");
5019 assert(ios.width() == 0);
5020 }
5021 ios.width(25);
5022 left(ios);
5023 {
5024 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5025 std::string ex(str, iter.base());
5026 assert(ex == "+1234567890.125000*******");
5027 assert(ios.width() == 0);
5028 }
5029 ios.width(25);
5030 right(ios);
5031 {
5032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5033 std::string ex(str, iter.base());
5034 assert(ex == "*******+1234567890.125000");
5035 assert(ios.width() == 0);
5036 }
5037 ios.width(25);
5038 internal(ios);
5039 {
5040 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5041 std::string ex(str, iter.base());
5042 assert(ex == "+*******1234567890.125000");
5043 assert(ios.width() == 0);
5044 }
5045 }
5046 ios.imbue(lg);
5047 {
5048 ios.width(0);
5049 {
5050 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5051 std::string ex(str, iter.base());
5052 assert(ex == "+1_234_567_89_0;125000");
5053 assert(ios.width() == 0);
5054 }
5055 ios.width(25);
5056 left(ios);
5057 {
5058 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5059 std::string ex(str, iter.base());
5060 assert(ex == "+1_234_567_89_0;125000***");
5061 assert(ios.width() == 0);
5062 }
5063 ios.width(25);
5064 right(ios);
5065 {
5066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5067 std::string ex(str, iter.base());
5068 assert(ex == "***+1_234_567_89_0;125000");
5069 assert(ios.width() == 0);
5070 }
5071 ios.width(25);
5072 internal(ios);
5073 {
5074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5075 std::string ex(str, iter.base());
5076 assert(ex == "+***1_234_567_89_0;125000");
5077 assert(ios.width() == 0);
5078 }
5079 }
5080 }
5081 }
5082 }
5083 uppercase(ios);
5084 {
5085 noshowpos(ios);
5086 {
5087 noshowpoint(ios);
5088 {
5089 ios.imbue(lc);
5090 {
5091 ios.width(0);
5092 {
5093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5094 std::string ex(str, iter.base());
5095 assert(ex == "1234567890.125");
5096 assert(ios.width() == 0);
5097 }
5098 ios.width(25);
5099 left(ios);
5100 {
5101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5102 std::string ex(str, iter.base());
5103 assert(ex == "1234567890.125***********");
5104 assert(ios.width() == 0);
5105 }
5106 ios.width(25);
5107 right(ios);
5108 {
5109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5110 std::string ex(str, iter.base());
5111 assert(ex == "***********1234567890.125");
5112 assert(ios.width() == 0);
5113 }
5114 ios.width(25);
5115 internal(ios);
5116 {
5117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5118 std::string ex(str, iter.base());
5119 assert(ex == "***********1234567890.125");
5120 assert(ios.width() == 0);
5121 }
5122 }
5123 ios.imbue(lg);
5124 {
5125 ios.width(0);
5126 {
5127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5128 std::string ex(str, iter.base());
5129 assert(ex == "1_234_567_89_0;125");
5130 assert(ios.width() == 0);
5131 }
5132 ios.width(25);
5133 left(ios);
5134 {
5135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5136 std::string ex(str, iter.base());
5137 assert(ex == "1_234_567_89_0;125*******");
5138 assert(ios.width() == 0);
5139 }
5140 ios.width(25);
5141 right(ios);
5142 {
5143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5144 std::string ex(str, iter.base());
5145 assert(ex == "*******1_234_567_89_0;125");
5146 assert(ios.width() == 0);
5147 }
5148 ios.width(25);
5149 internal(ios);
5150 {
5151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5152 std::string ex(str, iter.base());
5153 assert(ex == "*******1_234_567_89_0;125");
5154 assert(ios.width() == 0);
5155 }
5156 }
5157 }
5158 showpoint(ios);
5159 {
5160 ios.imbue(lc);
5161 {
5162 ios.width(0);
5163 {
5164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5165 std::string ex(str, iter.base());
5166 assert(ex == "1234567890.125000");
5167 assert(ios.width() == 0);
5168 }
5169 ios.width(25);
5170 left(ios);
5171 {
5172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5173 std::string ex(str, iter.base());
5174 assert(ex == "1234567890.125000********");
5175 assert(ios.width() == 0);
5176 }
5177 ios.width(25);
5178 right(ios);
5179 {
5180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5181 std::string ex(str, iter.base());
5182 assert(ex == "********1234567890.125000");
5183 assert(ios.width() == 0);
5184 }
5185 ios.width(25);
5186 internal(ios);
5187 {
5188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5189 std::string ex(str, iter.base());
5190 assert(ex == "********1234567890.125000");
5191 assert(ios.width() == 0);
5192 }
5193 }
5194 ios.imbue(lg);
5195 {
5196 ios.width(0);
5197 {
5198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5199 std::string ex(str, iter.base());
5200 assert(ex == "1_234_567_89_0;125000");
5201 assert(ios.width() == 0);
5202 }
5203 ios.width(25);
5204 left(ios);
5205 {
5206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5207 std::string ex(str, iter.base());
5208 assert(ex == "1_234_567_89_0;125000****");
5209 assert(ios.width() == 0);
5210 }
5211 ios.width(25);
5212 right(ios);
5213 {
5214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5215 std::string ex(str, iter.base());
5216 assert(ex == "****1_234_567_89_0;125000");
5217 assert(ios.width() == 0);
5218 }
5219 ios.width(25);
5220 internal(ios);
5221 {
5222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5223 std::string ex(str, iter.base());
5224 assert(ex == "****1_234_567_89_0;125000");
5225 assert(ios.width() == 0);
5226 }
5227 }
5228 }
5229 }
5230 showpos(ios);
5231 {
5232 noshowpoint(ios);
5233 {
5234 ios.imbue(lc);
5235 {
5236 ios.width(0);
5237 {
5238 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5239 std::string ex(str, iter.base());
5240 assert(ex == "+1234567890.125");
5241 assert(ios.width() == 0);
5242 }
5243 ios.width(25);
5244 left(ios);
5245 {
5246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5247 std::string ex(str, iter.base());
5248 assert(ex == "+1234567890.125**********");
5249 assert(ios.width() == 0);
5250 }
5251 ios.width(25);
5252 right(ios);
5253 {
5254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5255 std::string ex(str, iter.base());
5256 assert(ex == "**********+1234567890.125");
5257 assert(ios.width() == 0);
5258 }
5259 ios.width(25);
5260 internal(ios);
5261 {
5262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5263 std::string ex(str, iter.base());
5264 assert(ex == "+**********1234567890.125");
5265 assert(ios.width() == 0);
5266 }
5267 }
5268 ios.imbue(lg);
5269 {
5270 ios.width(0);
5271 {
5272 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5273 std::string ex(str, iter.base());
5274 assert(ex == "+1_234_567_89_0;125");
5275 assert(ios.width() == 0);
5276 }
5277 ios.width(25);
5278 left(ios);
5279 {
5280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5281 std::string ex(str, iter.base());
5282 assert(ex == "+1_234_567_89_0;125******");
5283 assert(ios.width() == 0);
5284 }
5285 ios.width(25);
5286 right(ios);
5287 {
5288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5289 std::string ex(str, iter.base());
5290 assert(ex == "******+1_234_567_89_0;125");
5291 assert(ios.width() == 0);
5292 }
5293 ios.width(25);
5294 internal(ios);
5295 {
5296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5297 std::string ex(str, iter.base());
5298 assert(ex == "+******1_234_567_89_0;125");
5299 assert(ios.width() == 0);
5300 }
5301 }
5302 }
5303 showpoint(ios);
5304 {
5305 ios.imbue(lc);
5306 {
5307 ios.width(0);
5308 {
5309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5310 std::string ex(str, iter.base());
5311 assert(ex == "+1234567890.125000");
5312 assert(ios.width() == 0);
5313 }
5314 ios.width(25);
5315 left(ios);
5316 {
5317 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5318 std::string ex(str, iter.base());
5319 assert(ex == "+1234567890.125000*******");
5320 assert(ios.width() == 0);
5321 }
5322 ios.width(25);
5323 right(ios);
5324 {
5325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5326 std::string ex(str, iter.base());
5327 assert(ex == "*******+1234567890.125000");
5328 assert(ios.width() == 0);
5329 }
5330 ios.width(25);
5331 internal(ios);
5332 {
5333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5334 std::string ex(str, iter.base());
5335 assert(ex == "+*******1234567890.125000");
5336 assert(ios.width() == 0);
5337 }
5338 }
5339 ios.imbue(lg);
5340 {
5341 ios.width(0);
5342 {
5343 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5344 std::string ex(str, iter.base());
5345 assert(ex == "+1_234_567_89_0;125000");
5346 assert(ios.width() == 0);
5347 }
5348 ios.width(25);
5349 left(ios);
5350 {
5351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5352 std::string ex(str, iter.base());
5353 assert(ex == "+1_234_567_89_0;125000***");
5354 assert(ios.width() == 0);
5355 }
5356 ios.width(25);
5357 right(ios);
5358 {
5359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5360 std::string ex(str, iter.base());
5361 assert(ex == "***+1_234_567_89_0;125000");
5362 assert(ios.width() == 0);
5363 }
5364 ios.width(25);
5365 internal(ios);
5366 {
5367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5368 std::string ex(str, iter.base());
5369 assert(ex == "+***1_234_567_89_0;125000");
5370 assert(ios.width() == 0);
5371 }
5372 }
5373 }
5374 }
5375 }
5376 }
5377 ios.precision(60);
5378 {
5379 nouppercase(ios);
5380 {
5381 noshowpos(ios);
5382 {
5383 noshowpoint(ios);
5384 {
5385 ios.imbue(lc);
5386 {
5387 ios.width(0);
5388 {
5389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5390 std::string ex(str, iter.base());
5391 assert(ex == "1234567890.125");
5392 assert(ios.width() == 0);
5393 }
5394 ios.width(25);
5395 left(ios);
5396 {
5397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5398 std::string ex(str, iter.base());
5399 assert(ex == "1234567890.125***********");
5400 assert(ios.width() == 0);
5401 }
5402 ios.width(25);
5403 right(ios);
5404 {
5405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5406 std::string ex(str, iter.base());
5407 assert(ex == "***********1234567890.125");
5408 assert(ios.width() == 0);
5409 }
5410 ios.width(25);
5411 internal(ios);
5412 {
5413 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5414 std::string ex(str, iter.base());
5415 assert(ex == "***********1234567890.125");
5416 assert(ios.width() == 0);
5417 }
5418 }
5419 ios.imbue(lg);
5420 {
5421 ios.width(0);
5422 {
5423 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5424 std::string ex(str, iter.base());
5425 assert(ex == "1_234_567_89_0;125");
5426 assert(ios.width() == 0);
5427 }
5428 ios.width(25);
5429 left(ios);
5430 {
5431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5432 std::string ex(str, iter.base());
5433 assert(ex == "1_234_567_89_0;125*******");
5434 assert(ios.width() == 0);
5435 }
5436 ios.width(25);
5437 right(ios);
5438 {
5439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5440 std::string ex(str, iter.base());
5441 assert(ex == "*******1_234_567_89_0;125");
5442 assert(ios.width() == 0);
5443 }
5444 ios.width(25);
5445 internal(ios);
5446 {
5447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5448 std::string ex(str, iter.base());
5449 assert(ex == "*******1_234_567_89_0;125");
5450 assert(ios.width() == 0);
5451 }
5452 }
5453 }
5454 showpoint(ios);
5455 {
5456 ios.imbue(lc);
5457 {
5458 ios.width(0);
5459 {
5460 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5461 std::string ex(str, iter.base());
5462 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5463 assert(ios.width() == 0);
5464 }
5465 ios.width(25);
5466 left(ios);
5467 {
5468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5469 std::string ex(str, iter.base());
5470 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5471 assert(ios.width() == 0);
5472 }
5473 ios.width(25);
5474 right(ios);
5475 {
5476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5477 std::string ex(str, iter.base());
5478 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5479 assert(ios.width() == 0);
5480 }
5481 ios.width(25);
5482 internal(ios);
5483 {
5484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5485 std::string ex(str, iter.base());
5486 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5487 assert(ios.width() == 0);
5488 }
5489 }
5490 ios.imbue(lg);
5491 {
5492 ios.width(0);
5493 {
5494 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5495 std::string ex(str, iter.base());
5496 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5497 assert(ios.width() == 0);
5498 }
5499 ios.width(25);
5500 left(ios);
5501 {
5502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5503 std::string ex(str, iter.base());
5504 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5505 assert(ios.width() == 0);
5506 }
5507 ios.width(25);
5508 right(ios);
5509 {
5510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5511 std::string ex(str, iter.base());
5512 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5513 assert(ios.width() == 0);
5514 }
5515 ios.width(25);
5516 internal(ios);
5517 {
5518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5519 std::string ex(str, iter.base());
5520 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5521 assert(ios.width() == 0);
5522 }
5523 }
5524 }
5525 }
5526 showpos(ios);
5527 {
5528 noshowpoint(ios);
5529 {
5530 ios.imbue(lc);
5531 {
5532 ios.width(0);
5533 {
5534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5535 std::string ex(str, iter.base());
5536 assert(ex == "+1234567890.125");
5537 assert(ios.width() == 0);
5538 }
5539 ios.width(25);
5540 left(ios);
5541 {
5542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5543 std::string ex(str, iter.base());
5544 assert(ex == "+1234567890.125**********");
5545 assert(ios.width() == 0);
5546 }
5547 ios.width(25);
5548 right(ios);
5549 {
5550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5551 std::string ex(str, iter.base());
5552 assert(ex == "**********+1234567890.125");
5553 assert(ios.width() == 0);
5554 }
5555 ios.width(25);
5556 internal(ios);
5557 {
5558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5559 std::string ex(str, iter.base());
5560 assert(ex == "+**********1234567890.125");
5561 assert(ios.width() == 0);
5562 }
5563 }
5564 ios.imbue(lg);
5565 {
5566 ios.width(0);
5567 {
5568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5569 std::string ex(str, iter.base());
5570 assert(ex == "+1_234_567_89_0;125");
5571 assert(ios.width() == 0);
5572 }
5573 ios.width(25);
5574 left(ios);
5575 {
5576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5577 std::string ex(str, iter.base());
5578 assert(ex == "+1_234_567_89_0;125******");
5579 assert(ios.width() == 0);
5580 }
5581 ios.width(25);
5582 right(ios);
5583 {
5584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5585 std::string ex(str, iter.base());
5586 assert(ex == "******+1_234_567_89_0;125");
5587 assert(ios.width() == 0);
5588 }
5589 ios.width(25);
5590 internal(ios);
5591 {
5592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5593 std::string ex(str, iter.base());
5594 assert(ex == "+******1_234_567_89_0;125");
5595 assert(ios.width() == 0);
5596 }
5597 }
5598 }
5599 showpoint(ios);
5600 {
5601 ios.imbue(lc);
5602 {
5603 ios.width(0);
5604 {
5605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5606 std::string ex(str, iter.base());
5607 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5608 assert(ios.width() == 0);
5609 }
5610 ios.width(25);
5611 left(ios);
5612 {
5613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5614 std::string ex(str, iter.base());
5615 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5616 assert(ios.width() == 0);
5617 }
5618 ios.width(25);
5619 right(ios);
5620 {
5621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5622 std::string ex(str, iter.base());
5623 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5624 assert(ios.width() == 0);
5625 }
5626 ios.width(25);
5627 internal(ios);
5628 {
5629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5630 std::string ex(str, iter.base());
5631 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5632 assert(ios.width() == 0);
5633 }
5634 }
5635 ios.imbue(lg);
5636 {
5637 ios.width(0);
5638 {
5639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5640 std::string ex(str, iter.base());
5641 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5642 assert(ios.width() == 0);
5643 }
5644 ios.width(25);
5645 left(ios);
5646 {
5647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5648 std::string ex(str, iter.base());
5649 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5650 assert(ios.width() == 0);
5651 }
5652 ios.width(25);
5653 right(ios);
5654 {
5655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5656 std::string ex(str, iter.base());
5657 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5658 assert(ios.width() == 0);
5659 }
5660 ios.width(25);
5661 internal(ios);
5662 {
5663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5664 std::string ex(str, iter.base());
5665 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5666 assert(ios.width() == 0);
5667 }
5668 }
5669 }
5670 }
5671 }
5672 uppercase(ios);
5673 {
5674 noshowpos(ios);
5675 {
5676 noshowpoint(ios);
5677 {
5678 ios.imbue(lc);
5679 {
5680 ios.width(0);
5681 {
5682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5683 std::string ex(str, iter.base());
5684 assert(ex == "1234567890.125");
5685 assert(ios.width() == 0);
5686 }
5687 ios.width(25);
5688 left(ios);
5689 {
5690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5691 std::string ex(str, iter.base());
5692 assert(ex == "1234567890.125***********");
5693 assert(ios.width() == 0);
5694 }
5695 ios.width(25);
5696 right(ios);
5697 {
5698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5699 std::string ex(str, iter.base());
5700 assert(ex == "***********1234567890.125");
5701 assert(ios.width() == 0);
5702 }
5703 ios.width(25);
5704 internal(ios);
5705 {
5706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5707 std::string ex(str, iter.base());
5708 assert(ex == "***********1234567890.125");
5709 assert(ios.width() == 0);
5710 }
5711 }
5712 ios.imbue(lg);
5713 {
5714 ios.width(0);
5715 {
5716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5717 std::string ex(str, iter.base());
5718 assert(ex == "1_234_567_89_0;125");
5719 assert(ios.width() == 0);
5720 }
5721 ios.width(25);
5722 left(ios);
5723 {
5724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5725 std::string ex(str, iter.base());
5726 assert(ex == "1_234_567_89_0;125*******");
5727 assert(ios.width() == 0);
5728 }
5729 ios.width(25);
5730 right(ios);
5731 {
5732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5733 std::string ex(str, iter.base());
5734 assert(ex == "*******1_234_567_89_0;125");
5735 assert(ios.width() == 0);
5736 }
5737 ios.width(25);
5738 internal(ios);
5739 {
5740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5741 std::string ex(str, iter.base());
5742 assert(ex == "*******1_234_567_89_0;125");
5743 assert(ios.width() == 0);
5744 }
5745 }
5746 }
5747 showpoint(ios);
5748 {
5749 ios.imbue(lc);
5750 {
5751 ios.width(0);
5752 {
5753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5754 std::string ex(str, iter.base());
5755 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5756 assert(ios.width() == 0);
5757 }
5758 ios.width(25);
5759 left(ios);
5760 {
5761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5762 std::string ex(str, iter.base());
5763 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5764 assert(ios.width() == 0);
5765 }
5766 ios.width(25);
5767 right(ios);
5768 {
5769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5770 std::string ex(str, iter.base());
5771 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5772 assert(ios.width() == 0);
5773 }
5774 ios.width(25);
5775 internal(ios);
5776 {
5777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5778 std::string ex(str, iter.base());
5779 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5780 assert(ios.width() == 0);
5781 }
5782 }
5783 ios.imbue(lg);
5784 {
5785 ios.width(0);
5786 {
5787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5788 std::string ex(str, iter.base());
5789 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5790 assert(ios.width() == 0);
5791 }
5792 ios.width(25);
5793 left(ios);
5794 {
5795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5796 std::string ex(str, iter.base());
5797 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5798 assert(ios.width() == 0);
5799 }
5800 ios.width(25);
5801 right(ios);
5802 {
5803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5804 std::string ex(str, iter.base());
5805 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5806 assert(ios.width() == 0);
5807 }
5808 ios.width(25);
5809 internal(ios);
5810 {
5811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5812 std::string ex(str, iter.base());
5813 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5814 assert(ios.width() == 0);
5815 }
5816 }
5817 }
5818 }
5819 showpos(ios);
5820 {
5821 noshowpoint(ios);
5822 {
5823 ios.imbue(lc);
5824 {
5825 ios.width(0);
5826 {
5827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5828 std::string ex(str, iter.base());
5829 assert(ex == "+1234567890.125");
5830 assert(ios.width() == 0);
5831 }
5832 ios.width(25);
5833 left(ios);
5834 {
5835 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5836 std::string ex(str, iter.base());
5837 assert(ex == "+1234567890.125**********");
5838 assert(ios.width() == 0);
5839 }
5840 ios.width(25);
5841 right(ios);
5842 {
5843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5844 std::string ex(str, iter.base());
5845 assert(ex == "**********+1234567890.125");
5846 assert(ios.width() == 0);
5847 }
5848 ios.width(25);
5849 internal(ios);
5850 {
5851 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5852 std::string ex(str, iter.base());
5853 assert(ex == "+**********1234567890.125");
5854 assert(ios.width() == 0);
5855 }
5856 }
5857 ios.imbue(lg);
5858 {
5859 ios.width(0);
5860 {
5861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5862 std::string ex(str, iter.base());
5863 assert(ex == "+1_234_567_89_0;125");
5864 assert(ios.width() == 0);
5865 }
5866 ios.width(25);
5867 left(ios);
5868 {
5869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5870 std::string ex(str, iter.base());
5871 assert(ex == "+1_234_567_89_0;125******");
5872 assert(ios.width() == 0);
5873 }
5874 ios.width(25);
5875 right(ios);
5876 {
5877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5878 std::string ex(str, iter.base());
5879 assert(ex == "******+1_234_567_89_0;125");
5880 assert(ios.width() == 0);
5881 }
5882 ios.width(25);
5883 internal(ios);
5884 {
5885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5886 std::string ex(str, iter.base());
5887 assert(ex == "+******1_234_567_89_0;125");
5888 assert(ios.width() == 0);
5889 }
5890 }
5891 }
5892 showpoint(ios);
5893 {
5894 ios.imbue(lc);
5895 {
5896 ios.width(0);
5897 {
5898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5899 std::string ex(str, iter.base());
5900 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5901 assert(ios.width() == 0);
5902 }
5903 ios.width(25);
5904 left(ios);
5905 {
5906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5907 std::string ex(str, iter.base());
5908 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5909 assert(ios.width() == 0);
5910 }
5911 ios.width(25);
5912 right(ios);
5913 {
5914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5915 std::string ex(str, iter.base());
5916 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5917 assert(ios.width() == 0);
5918 }
5919 ios.width(25);
5920 internal(ios);
5921 {
5922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5923 std::string ex(str, iter.base());
5924 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5925 assert(ios.width() == 0);
5926 }
5927 }
5928 ios.imbue(lg);
5929 {
5930 ios.width(0);
5931 {
5932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5933 std::string ex(str, iter.base());
5934 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5935 assert(ios.width() == 0);
5936 }
5937 ios.width(25);
5938 left(ios);
5939 {
5940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5941 std::string ex(str, iter.base());
5942 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5943 assert(ios.width() == 0);
5944 }
5945 ios.width(25);
5946 right(ios);
5947 {
5948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5949 std::string ex(str, iter.base());
5950 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5951 assert(ios.width() == 0);
5952 }
5953 ios.width(25);
5954 internal(ios);
5955 {
5956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5957 std::string ex(str, iter.base());
5958 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5959 assert(ios.width() == 0);
5960 }
5961 }
5962 }
5963 }
5964 }
5965 }
5966 }
5967 }
5968 }
5969
test3()5970 void test3()
5971 {
5972 char str[200];
5973 output_iterator<char*> iter;
5974 std::locale lc = std::locale::classic();
5975 std::locale lg(lc, new my_numpunct);
5976 const my_facet f(1);
5977 {
5978 double v = +0.;
5979 std::ios ios(0);
5980 fixed(ios);
5981 // %f
5982 {
5983 ios.precision(0);
5984 {
5985 nouppercase(ios);
5986 {
5987 noshowpos(ios);
5988 {
5989 noshowpoint(ios);
5990 {
5991 ios.imbue(lc);
5992 {
5993 ios.width(0);
5994 {
5995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5996 std::string ex(str, iter.base());
5997 assert(ex == "0");
5998 assert(ios.width() == 0);
5999 }
6000 ios.width(25);
6001 left(ios);
6002 {
6003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6004 std::string ex(str, iter.base());
6005 assert(ex == "0************************");
6006 assert(ios.width() == 0);
6007 }
6008 ios.width(25);
6009 right(ios);
6010 {
6011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6012 std::string ex(str, iter.base());
6013 assert(ex == "************************0");
6014 assert(ios.width() == 0);
6015 }
6016 ios.width(25);
6017 internal(ios);
6018 {
6019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6020 std::string ex(str, iter.base());
6021 assert(ex == "************************0");
6022 assert(ios.width() == 0);
6023 }
6024 }
6025 ios.imbue(lg);
6026 {
6027 ios.width(0);
6028 {
6029 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6030 std::string ex(str, iter.base());
6031 assert(ex == "0");
6032 assert(ios.width() == 0);
6033 }
6034 ios.width(25);
6035 left(ios);
6036 {
6037 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6038 std::string ex(str, iter.base());
6039 assert(ex == "0************************");
6040 assert(ios.width() == 0);
6041 }
6042 ios.width(25);
6043 right(ios);
6044 {
6045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6046 std::string ex(str, iter.base());
6047 assert(ex == "************************0");
6048 assert(ios.width() == 0);
6049 }
6050 ios.width(25);
6051 internal(ios);
6052 {
6053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6054 std::string ex(str, iter.base());
6055 assert(ex == "************************0");
6056 assert(ios.width() == 0);
6057 }
6058 }
6059 }
6060 showpoint(ios);
6061 {
6062 ios.imbue(lc);
6063 {
6064 ios.width(0);
6065 {
6066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6067 std::string ex(str, iter.base());
6068 assert(ex == "0.");
6069 assert(ios.width() == 0);
6070 }
6071 ios.width(25);
6072 left(ios);
6073 {
6074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6075 std::string ex(str, iter.base());
6076 assert(ex == "0.***********************");
6077 assert(ios.width() == 0);
6078 }
6079 ios.width(25);
6080 right(ios);
6081 {
6082 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6083 std::string ex(str, iter.base());
6084 assert(ex == "***********************0.");
6085 assert(ios.width() == 0);
6086 }
6087 ios.width(25);
6088 internal(ios);
6089 {
6090 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6091 std::string ex(str, iter.base());
6092 assert(ex == "***********************0.");
6093 assert(ios.width() == 0);
6094 }
6095 }
6096 ios.imbue(lg);
6097 {
6098 ios.width(0);
6099 {
6100 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6101 std::string ex(str, iter.base());
6102 assert(ex == "0;");
6103 assert(ios.width() == 0);
6104 }
6105 ios.width(25);
6106 left(ios);
6107 {
6108 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6109 std::string ex(str, iter.base());
6110 assert(ex == "0;***********************");
6111 assert(ios.width() == 0);
6112 }
6113 ios.width(25);
6114 right(ios);
6115 {
6116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6117 std::string ex(str, iter.base());
6118 assert(ex == "***********************0;");
6119 assert(ios.width() == 0);
6120 }
6121 ios.width(25);
6122 internal(ios);
6123 {
6124 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6125 std::string ex(str, iter.base());
6126 assert(ex == "***********************0;");
6127 assert(ios.width() == 0);
6128 }
6129 }
6130 }
6131 }
6132 showpos(ios);
6133 {
6134 noshowpoint(ios);
6135 {
6136 ios.imbue(lc);
6137 {
6138 ios.width(0);
6139 {
6140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6141 std::string ex(str, iter.base());
6142 assert(ex == "+0");
6143 assert(ios.width() == 0);
6144 }
6145 ios.width(25);
6146 left(ios);
6147 {
6148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6149 std::string ex(str, iter.base());
6150 assert(ex == "+0***********************");
6151 assert(ios.width() == 0);
6152 }
6153 ios.width(25);
6154 right(ios);
6155 {
6156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6157 std::string ex(str, iter.base());
6158 assert(ex == "***********************+0");
6159 assert(ios.width() == 0);
6160 }
6161 ios.width(25);
6162 internal(ios);
6163 {
6164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6165 std::string ex(str, iter.base());
6166 assert(ex == "+***********************0");
6167 assert(ios.width() == 0);
6168 }
6169 }
6170 ios.imbue(lg);
6171 {
6172 ios.width(0);
6173 {
6174 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6175 std::string ex(str, iter.base());
6176 assert(ex == "+0");
6177 assert(ios.width() == 0);
6178 }
6179 ios.width(25);
6180 left(ios);
6181 {
6182 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6183 std::string ex(str, iter.base());
6184 assert(ex == "+0***********************");
6185 assert(ios.width() == 0);
6186 }
6187 ios.width(25);
6188 right(ios);
6189 {
6190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6191 std::string ex(str, iter.base());
6192 assert(ex == "***********************+0");
6193 assert(ios.width() == 0);
6194 }
6195 ios.width(25);
6196 internal(ios);
6197 {
6198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6199 std::string ex(str, iter.base());
6200 assert(ex == "+***********************0");
6201 assert(ios.width() == 0);
6202 }
6203 }
6204 }
6205 showpoint(ios);
6206 {
6207 ios.imbue(lc);
6208 {
6209 ios.width(0);
6210 {
6211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6212 std::string ex(str, iter.base());
6213 assert(ex == "+0.");
6214 assert(ios.width() == 0);
6215 }
6216 ios.width(25);
6217 left(ios);
6218 {
6219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6220 std::string ex(str, iter.base());
6221 assert(ex == "+0.**********************");
6222 assert(ios.width() == 0);
6223 }
6224 ios.width(25);
6225 right(ios);
6226 {
6227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6228 std::string ex(str, iter.base());
6229 assert(ex == "**********************+0.");
6230 assert(ios.width() == 0);
6231 }
6232 ios.width(25);
6233 internal(ios);
6234 {
6235 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6236 std::string ex(str, iter.base());
6237 assert(ex == "+**********************0.");
6238 assert(ios.width() == 0);
6239 }
6240 }
6241 ios.imbue(lg);
6242 {
6243 ios.width(0);
6244 {
6245 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6246 std::string ex(str, iter.base());
6247 assert(ex == "+0;");
6248 assert(ios.width() == 0);
6249 }
6250 ios.width(25);
6251 left(ios);
6252 {
6253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6254 std::string ex(str, iter.base());
6255 assert(ex == "+0;**********************");
6256 assert(ios.width() == 0);
6257 }
6258 ios.width(25);
6259 right(ios);
6260 {
6261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6262 std::string ex(str, iter.base());
6263 assert(ex == "**********************+0;");
6264 assert(ios.width() == 0);
6265 }
6266 ios.width(25);
6267 internal(ios);
6268 {
6269 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6270 std::string ex(str, iter.base());
6271 assert(ex == "+**********************0;");
6272 assert(ios.width() == 0);
6273 }
6274 }
6275 }
6276 }
6277 }
6278 uppercase(ios);
6279 {
6280 noshowpos(ios);
6281 {
6282 noshowpoint(ios);
6283 {
6284 ios.imbue(lc);
6285 {
6286 ios.width(0);
6287 {
6288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6289 std::string ex(str, iter.base());
6290 assert(ex == "0");
6291 assert(ios.width() == 0);
6292 }
6293 ios.width(25);
6294 left(ios);
6295 {
6296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6297 std::string ex(str, iter.base());
6298 assert(ex == "0************************");
6299 assert(ios.width() == 0);
6300 }
6301 ios.width(25);
6302 right(ios);
6303 {
6304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6305 std::string ex(str, iter.base());
6306 assert(ex == "************************0");
6307 assert(ios.width() == 0);
6308 }
6309 ios.width(25);
6310 internal(ios);
6311 {
6312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6313 std::string ex(str, iter.base());
6314 assert(ex == "************************0");
6315 assert(ios.width() == 0);
6316 }
6317 }
6318 ios.imbue(lg);
6319 {
6320 ios.width(0);
6321 {
6322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6323 std::string ex(str, iter.base());
6324 assert(ex == "0");
6325 assert(ios.width() == 0);
6326 }
6327 ios.width(25);
6328 left(ios);
6329 {
6330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6331 std::string ex(str, iter.base());
6332 assert(ex == "0************************");
6333 assert(ios.width() == 0);
6334 }
6335 ios.width(25);
6336 right(ios);
6337 {
6338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6339 std::string ex(str, iter.base());
6340 assert(ex == "************************0");
6341 assert(ios.width() == 0);
6342 }
6343 ios.width(25);
6344 internal(ios);
6345 {
6346 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6347 std::string ex(str, iter.base());
6348 assert(ex == "************************0");
6349 assert(ios.width() == 0);
6350 }
6351 }
6352 }
6353 showpoint(ios);
6354 {
6355 ios.imbue(lc);
6356 {
6357 ios.width(0);
6358 {
6359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6360 std::string ex(str, iter.base());
6361 assert(ex == "0.");
6362 assert(ios.width() == 0);
6363 }
6364 ios.width(25);
6365 left(ios);
6366 {
6367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6368 std::string ex(str, iter.base());
6369 assert(ex == "0.***********************");
6370 assert(ios.width() == 0);
6371 }
6372 ios.width(25);
6373 right(ios);
6374 {
6375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6376 std::string ex(str, iter.base());
6377 assert(ex == "***********************0.");
6378 assert(ios.width() == 0);
6379 }
6380 ios.width(25);
6381 internal(ios);
6382 {
6383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6384 std::string ex(str, iter.base());
6385 assert(ex == "***********************0.");
6386 assert(ios.width() == 0);
6387 }
6388 }
6389 ios.imbue(lg);
6390 {
6391 ios.width(0);
6392 {
6393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6394 std::string ex(str, iter.base());
6395 assert(ex == "0;");
6396 assert(ios.width() == 0);
6397 }
6398 ios.width(25);
6399 left(ios);
6400 {
6401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6402 std::string ex(str, iter.base());
6403 assert(ex == "0;***********************");
6404 assert(ios.width() == 0);
6405 }
6406 ios.width(25);
6407 right(ios);
6408 {
6409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6410 std::string ex(str, iter.base());
6411 assert(ex == "***********************0;");
6412 assert(ios.width() == 0);
6413 }
6414 ios.width(25);
6415 internal(ios);
6416 {
6417 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6418 std::string ex(str, iter.base());
6419 assert(ex == "***********************0;");
6420 assert(ios.width() == 0);
6421 }
6422 }
6423 }
6424 }
6425 showpos(ios);
6426 {
6427 noshowpoint(ios);
6428 {
6429 ios.imbue(lc);
6430 {
6431 ios.width(0);
6432 {
6433 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6434 std::string ex(str, iter.base());
6435 assert(ex == "+0");
6436 assert(ios.width() == 0);
6437 }
6438 ios.width(25);
6439 left(ios);
6440 {
6441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6442 std::string ex(str, iter.base());
6443 assert(ex == "+0***********************");
6444 assert(ios.width() == 0);
6445 }
6446 ios.width(25);
6447 right(ios);
6448 {
6449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6450 std::string ex(str, iter.base());
6451 assert(ex == "***********************+0");
6452 assert(ios.width() == 0);
6453 }
6454 ios.width(25);
6455 internal(ios);
6456 {
6457 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6458 std::string ex(str, iter.base());
6459 assert(ex == "+***********************0");
6460 assert(ios.width() == 0);
6461 }
6462 }
6463 ios.imbue(lg);
6464 {
6465 ios.width(0);
6466 {
6467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6468 std::string ex(str, iter.base());
6469 assert(ex == "+0");
6470 assert(ios.width() == 0);
6471 }
6472 ios.width(25);
6473 left(ios);
6474 {
6475 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6476 std::string ex(str, iter.base());
6477 assert(ex == "+0***********************");
6478 assert(ios.width() == 0);
6479 }
6480 ios.width(25);
6481 right(ios);
6482 {
6483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6484 std::string ex(str, iter.base());
6485 assert(ex == "***********************+0");
6486 assert(ios.width() == 0);
6487 }
6488 ios.width(25);
6489 internal(ios);
6490 {
6491 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6492 std::string ex(str, iter.base());
6493 assert(ex == "+***********************0");
6494 assert(ios.width() == 0);
6495 }
6496 }
6497 }
6498 showpoint(ios);
6499 {
6500 ios.imbue(lc);
6501 {
6502 ios.width(0);
6503 {
6504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6505 std::string ex(str, iter.base());
6506 assert(ex == "+0.");
6507 assert(ios.width() == 0);
6508 }
6509 ios.width(25);
6510 left(ios);
6511 {
6512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6513 std::string ex(str, iter.base());
6514 assert(ex == "+0.**********************");
6515 assert(ios.width() == 0);
6516 }
6517 ios.width(25);
6518 right(ios);
6519 {
6520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6521 std::string ex(str, iter.base());
6522 assert(ex == "**********************+0.");
6523 assert(ios.width() == 0);
6524 }
6525 ios.width(25);
6526 internal(ios);
6527 {
6528 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6529 std::string ex(str, iter.base());
6530 assert(ex == "+**********************0.");
6531 assert(ios.width() == 0);
6532 }
6533 }
6534 ios.imbue(lg);
6535 {
6536 ios.width(0);
6537 {
6538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6539 std::string ex(str, iter.base());
6540 assert(ex == "+0;");
6541 assert(ios.width() == 0);
6542 }
6543 ios.width(25);
6544 left(ios);
6545 {
6546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6547 std::string ex(str, iter.base());
6548 assert(ex == "+0;**********************");
6549 assert(ios.width() == 0);
6550 }
6551 ios.width(25);
6552 right(ios);
6553 {
6554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6555 std::string ex(str, iter.base());
6556 assert(ex == "**********************+0;");
6557 assert(ios.width() == 0);
6558 }
6559 ios.width(25);
6560 internal(ios);
6561 {
6562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6563 std::string ex(str, iter.base());
6564 assert(ex == "+**********************0;");
6565 assert(ios.width() == 0);
6566 }
6567 }
6568 }
6569 }
6570 }
6571 }
6572 ios.precision(1);
6573 {
6574 nouppercase(ios);
6575 {
6576 noshowpos(ios);
6577 {
6578 noshowpoint(ios);
6579 {
6580 ios.imbue(lc);
6581 {
6582 ios.width(0);
6583 {
6584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6585 std::string ex(str, iter.base());
6586 assert(ex == "0.0");
6587 assert(ios.width() == 0);
6588 }
6589 ios.width(25);
6590 left(ios);
6591 {
6592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6593 std::string ex(str, iter.base());
6594 assert(ex == "0.0**********************");
6595 assert(ios.width() == 0);
6596 }
6597 ios.width(25);
6598 right(ios);
6599 {
6600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6601 std::string ex(str, iter.base());
6602 assert(ex == "**********************0.0");
6603 assert(ios.width() == 0);
6604 }
6605 ios.width(25);
6606 internal(ios);
6607 {
6608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6609 std::string ex(str, iter.base());
6610 assert(ex == "**********************0.0");
6611 assert(ios.width() == 0);
6612 }
6613 }
6614 ios.imbue(lg);
6615 {
6616 ios.width(0);
6617 {
6618 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6619 std::string ex(str, iter.base());
6620 assert(ex == "0;0");
6621 assert(ios.width() == 0);
6622 }
6623 ios.width(25);
6624 left(ios);
6625 {
6626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6627 std::string ex(str, iter.base());
6628 assert(ex == "0;0**********************");
6629 assert(ios.width() == 0);
6630 }
6631 ios.width(25);
6632 right(ios);
6633 {
6634 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6635 std::string ex(str, iter.base());
6636 assert(ex == "**********************0;0");
6637 assert(ios.width() == 0);
6638 }
6639 ios.width(25);
6640 internal(ios);
6641 {
6642 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6643 std::string ex(str, iter.base());
6644 assert(ex == "**********************0;0");
6645 assert(ios.width() == 0);
6646 }
6647 }
6648 }
6649 showpoint(ios);
6650 {
6651 ios.imbue(lc);
6652 {
6653 ios.width(0);
6654 {
6655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6656 std::string ex(str, iter.base());
6657 assert(ex == "0.0");
6658 assert(ios.width() == 0);
6659 }
6660 ios.width(25);
6661 left(ios);
6662 {
6663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6664 std::string ex(str, iter.base());
6665 assert(ex == "0.0**********************");
6666 assert(ios.width() == 0);
6667 }
6668 ios.width(25);
6669 right(ios);
6670 {
6671 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6672 std::string ex(str, iter.base());
6673 assert(ex == "**********************0.0");
6674 assert(ios.width() == 0);
6675 }
6676 ios.width(25);
6677 internal(ios);
6678 {
6679 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6680 std::string ex(str, iter.base());
6681 assert(ex == "**********************0.0");
6682 assert(ios.width() == 0);
6683 }
6684 }
6685 ios.imbue(lg);
6686 {
6687 ios.width(0);
6688 {
6689 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6690 std::string ex(str, iter.base());
6691 assert(ex == "0;0");
6692 assert(ios.width() == 0);
6693 }
6694 ios.width(25);
6695 left(ios);
6696 {
6697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6698 std::string ex(str, iter.base());
6699 assert(ex == "0;0**********************");
6700 assert(ios.width() == 0);
6701 }
6702 ios.width(25);
6703 right(ios);
6704 {
6705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6706 std::string ex(str, iter.base());
6707 assert(ex == "**********************0;0");
6708 assert(ios.width() == 0);
6709 }
6710 ios.width(25);
6711 internal(ios);
6712 {
6713 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6714 std::string ex(str, iter.base());
6715 assert(ex == "**********************0;0");
6716 assert(ios.width() == 0);
6717 }
6718 }
6719 }
6720 }
6721 showpos(ios);
6722 {
6723 noshowpoint(ios);
6724 {
6725 ios.imbue(lc);
6726 {
6727 ios.width(0);
6728 {
6729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6730 std::string ex(str, iter.base());
6731 assert(ex == "+0.0");
6732 assert(ios.width() == 0);
6733 }
6734 ios.width(25);
6735 left(ios);
6736 {
6737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6738 std::string ex(str, iter.base());
6739 assert(ex == "+0.0*********************");
6740 assert(ios.width() == 0);
6741 }
6742 ios.width(25);
6743 right(ios);
6744 {
6745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6746 std::string ex(str, iter.base());
6747 assert(ex == "*********************+0.0");
6748 assert(ios.width() == 0);
6749 }
6750 ios.width(25);
6751 internal(ios);
6752 {
6753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6754 std::string ex(str, iter.base());
6755 assert(ex == "+*********************0.0");
6756 assert(ios.width() == 0);
6757 }
6758 }
6759 ios.imbue(lg);
6760 {
6761 ios.width(0);
6762 {
6763 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6764 std::string ex(str, iter.base());
6765 assert(ex == "+0;0");
6766 assert(ios.width() == 0);
6767 }
6768 ios.width(25);
6769 left(ios);
6770 {
6771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6772 std::string ex(str, iter.base());
6773 assert(ex == "+0;0*********************");
6774 assert(ios.width() == 0);
6775 }
6776 ios.width(25);
6777 right(ios);
6778 {
6779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6780 std::string ex(str, iter.base());
6781 assert(ex == "*********************+0;0");
6782 assert(ios.width() == 0);
6783 }
6784 ios.width(25);
6785 internal(ios);
6786 {
6787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6788 std::string ex(str, iter.base());
6789 assert(ex == "+*********************0;0");
6790 assert(ios.width() == 0);
6791 }
6792 }
6793 }
6794 showpoint(ios);
6795 {
6796 ios.imbue(lc);
6797 {
6798 ios.width(0);
6799 {
6800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6801 std::string ex(str, iter.base());
6802 assert(ex == "+0.0");
6803 assert(ios.width() == 0);
6804 }
6805 ios.width(25);
6806 left(ios);
6807 {
6808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6809 std::string ex(str, iter.base());
6810 assert(ex == "+0.0*********************");
6811 assert(ios.width() == 0);
6812 }
6813 ios.width(25);
6814 right(ios);
6815 {
6816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6817 std::string ex(str, iter.base());
6818 assert(ex == "*********************+0.0");
6819 assert(ios.width() == 0);
6820 }
6821 ios.width(25);
6822 internal(ios);
6823 {
6824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6825 std::string ex(str, iter.base());
6826 assert(ex == "+*********************0.0");
6827 assert(ios.width() == 0);
6828 }
6829 }
6830 ios.imbue(lg);
6831 {
6832 ios.width(0);
6833 {
6834 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6835 std::string ex(str, iter.base());
6836 assert(ex == "+0;0");
6837 assert(ios.width() == 0);
6838 }
6839 ios.width(25);
6840 left(ios);
6841 {
6842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6843 std::string ex(str, iter.base());
6844 assert(ex == "+0;0*********************");
6845 assert(ios.width() == 0);
6846 }
6847 ios.width(25);
6848 right(ios);
6849 {
6850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6851 std::string ex(str, iter.base());
6852 assert(ex == "*********************+0;0");
6853 assert(ios.width() == 0);
6854 }
6855 ios.width(25);
6856 internal(ios);
6857 {
6858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6859 std::string ex(str, iter.base());
6860 assert(ex == "+*********************0;0");
6861 assert(ios.width() == 0);
6862 }
6863 }
6864 }
6865 }
6866 }
6867 uppercase(ios);
6868 {
6869 noshowpos(ios);
6870 {
6871 noshowpoint(ios);
6872 {
6873 ios.imbue(lc);
6874 {
6875 ios.width(0);
6876 {
6877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6878 std::string ex(str, iter.base());
6879 assert(ex == "0.0");
6880 assert(ios.width() == 0);
6881 }
6882 ios.width(25);
6883 left(ios);
6884 {
6885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6886 std::string ex(str, iter.base());
6887 assert(ex == "0.0**********************");
6888 assert(ios.width() == 0);
6889 }
6890 ios.width(25);
6891 right(ios);
6892 {
6893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6894 std::string ex(str, iter.base());
6895 assert(ex == "**********************0.0");
6896 assert(ios.width() == 0);
6897 }
6898 ios.width(25);
6899 internal(ios);
6900 {
6901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6902 std::string ex(str, iter.base());
6903 assert(ex == "**********************0.0");
6904 assert(ios.width() == 0);
6905 }
6906 }
6907 ios.imbue(lg);
6908 {
6909 ios.width(0);
6910 {
6911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6912 std::string ex(str, iter.base());
6913 assert(ex == "0;0");
6914 assert(ios.width() == 0);
6915 }
6916 ios.width(25);
6917 left(ios);
6918 {
6919 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6920 std::string ex(str, iter.base());
6921 assert(ex == "0;0**********************");
6922 assert(ios.width() == 0);
6923 }
6924 ios.width(25);
6925 right(ios);
6926 {
6927 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6928 std::string ex(str, iter.base());
6929 assert(ex == "**********************0;0");
6930 assert(ios.width() == 0);
6931 }
6932 ios.width(25);
6933 internal(ios);
6934 {
6935 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6936 std::string ex(str, iter.base());
6937 assert(ex == "**********************0;0");
6938 assert(ios.width() == 0);
6939 }
6940 }
6941 }
6942 showpoint(ios);
6943 {
6944 ios.imbue(lc);
6945 {
6946 ios.width(0);
6947 {
6948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6949 std::string ex(str, iter.base());
6950 assert(ex == "0.0");
6951 assert(ios.width() == 0);
6952 }
6953 ios.width(25);
6954 left(ios);
6955 {
6956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6957 std::string ex(str, iter.base());
6958 assert(ex == "0.0**********************");
6959 assert(ios.width() == 0);
6960 }
6961 ios.width(25);
6962 right(ios);
6963 {
6964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6965 std::string ex(str, iter.base());
6966 assert(ex == "**********************0.0");
6967 assert(ios.width() == 0);
6968 }
6969 ios.width(25);
6970 internal(ios);
6971 {
6972 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6973 std::string ex(str, iter.base());
6974 assert(ex == "**********************0.0");
6975 assert(ios.width() == 0);
6976 }
6977 }
6978 ios.imbue(lg);
6979 {
6980 ios.width(0);
6981 {
6982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6983 std::string ex(str, iter.base());
6984 assert(ex == "0;0");
6985 assert(ios.width() == 0);
6986 }
6987 ios.width(25);
6988 left(ios);
6989 {
6990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6991 std::string ex(str, iter.base());
6992 assert(ex == "0;0**********************");
6993 assert(ios.width() == 0);
6994 }
6995 ios.width(25);
6996 right(ios);
6997 {
6998 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6999 std::string ex(str, iter.base());
7000 assert(ex == "**********************0;0");
7001 assert(ios.width() == 0);
7002 }
7003 ios.width(25);
7004 internal(ios);
7005 {
7006 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7007 std::string ex(str, iter.base());
7008 assert(ex == "**********************0;0");
7009 assert(ios.width() == 0);
7010 }
7011 }
7012 }
7013 }
7014 showpos(ios);
7015 {
7016 noshowpoint(ios);
7017 {
7018 ios.imbue(lc);
7019 {
7020 ios.width(0);
7021 {
7022 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7023 std::string ex(str, iter.base());
7024 assert(ex == "+0.0");
7025 assert(ios.width() == 0);
7026 }
7027 ios.width(25);
7028 left(ios);
7029 {
7030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7031 std::string ex(str, iter.base());
7032 assert(ex == "+0.0*********************");
7033 assert(ios.width() == 0);
7034 }
7035 ios.width(25);
7036 right(ios);
7037 {
7038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7039 std::string ex(str, iter.base());
7040 assert(ex == "*********************+0.0");
7041 assert(ios.width() == 0);
7042 }
7043 ios.width(25);
7044 internal(ios);
7045 {
7046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7047 std::string ex(str, iter.base());
7048 assert(ex == "+*********************0.0");
7049 assert(ios.width() == 0);
7050 }
7051 }
7052 ios.imbue(lg);
7053 {
7054 ios.width(0);
7055 {
7056 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7057 std::string ex(str, iter.base());
7058 assert(ex == "+0;0");
7059 assert(ios.width() == 0);
7060 }
7061 ios.width(25);
7062 left(ios);
7063 {
7064 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7065 std::string ex(str, iter.base());
7066 assert(ex == "+0;0*********************");
7067 assert(ios.width() == 0);
7068 }
7069 ios.width(25);
7070 right(ios);
7071 {
7072 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7073 std::string ex(str, iter.base());
7074 assert(ex == "*********************+0;0");
7075 assert(ios.width() == 0);
7076 }
7077 ios.width(25);
7078 internal(ios);
7079 {
7080 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7081 std::string ex(str, iter.base());
7082 assert(ex == "+*********************0;0");
7083 assert(ios.width() == 0);
7084 }
7085 }
7086 }
7087 showpoint(ios);
7088 {
7089 ios.imbue(lc);
7090 {
7091 ios.width(0);
7092 {
7093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7094 std::string ex(str, iter.base());
7095 assert(ex == "+0.0");
7096 assert(ios.width() == 0);
7097 }
7098 ios.width(25);
7099 left(ios);
7100 {
7101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7102 std::string ex(str, iter.base());
7103 assert(ex == "+0.0*********************");
7104 assert(ios.width() == 0);
7105 }
7106 ios.width(25);
7107 right(ios);
7108 {
7109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7110 std::string ex(str, iter.base());
7111 assert(ex == "*********************+0.0");
7112 assert(ios.width() == 0);
7113 }
7114 ios.width(25);
7115 internal(ios);
7116 {
7117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7118 std::string ex(str, iter.base());
7119 assert(ex == "+*********************0.0");
7120 assert(ios.width() == 0);
7121 }
7122 }
7123 ios.imbue(lg);
7124 {
7125 ios.width(0);
7126 {
7127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7128 std::string ex(str, iter.base());
7129 assert(ex == "+0;0");
7130 assert(ios.width() == 0);
7131 }
7132 ios.width(25);
7133 left(ios);
7134 {
7135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7136 std::string ex(str, iter.base());
7137 assert(ex == "+0;0*********************");
7138 assert(ios.width() == 0);
7139 }
7140 ios.width(25);
7141 right(ios);
7142 {
7143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7144 std::string ex(str, iter.base());
7145 assert(ex == "*********************+0;0");
7146 assert(ios.width() == 0);
7147 }
7148 ios.width(25);
7149 internal(ios);
7150 {
7151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7152 std::string ex(str, iter.base());
7153 assert(ex == "+*********************0;0");
7154 assert(ios.width() == 0);
7155 }
7156 }
7157 }
7158 }
7159 }
7160 }
7161 ios.precision(6);
7162 {
7163 nouppercase(ios);
7164 {
7165 noshowpos(ios);
7166 {
7167 noshowpoint(ios);
7168 {
7169 ios.imbue(lc);
7170 {
7171 ios.width(0);
7172 {
7173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7174 std::string ex(str, iter.base());
7175 assert(ex == "0.000000");
7176 assert(ios.width() == 0);
7177 }
7178 ios.width(25);
7179 left(ios);
7180 {
7181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7182 std::string ex(str, iter.base());
7183 assert(ex == "0.000000*****************");
7184 assert(ios.width() == 0);
7185 }
7186 ios.width(25);
7187 right(ios);
7188 {
7189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7190 std::string ex(str, iter.base());
7191 assert(ex == "*****************0.000000");
7192 assert(ios.width() == 0);
7193 }
7194 ios.width(25);
7195 internal(ios);
7196 {
7197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7198 std::string ex(str, iter.base());
7199 assert(ex == "*****************0.000000");
7200 assert(ios.width() == 0);
7201 }
7202 }
7203 ios.imbue(lg);
7204 {
7205 ios.width(0);
7206 {
7207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7208 std::string ex(str, iter.base());
7209 assert(ex == "0;000000");
7210 assert(ios.width() == 0);
7211 }
7212 ios.width(25);
7213 left(ios);
7214 {
7215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7216 std::string ex(str, iter.base());
7217 assert(ex == "0;000000*****************");
7218 assert(ios.width() == 0);
7219 }
7220 ios.width(25);
7221 right(ios);
7222 {
7223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7224 std::string ex(str, iter.base());
7225 assert(ex == "*****************0;000000");
7226 assert(ios.width() == 0);
7227 }
7228 ios.width(25);
7229 internal(ios);
7230 {
7231 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7232 std::string ex(str, iter.base());
7233 assert(ex == "*****************0;000000");
7234 assert(ios.width() == 0);
7235 }
7236 }
7237 }
7238 showpoint(ios);
7239 {
7240 ios.imbue(lc);
7241 {
7242 ios.width(0);
7243 {
7244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7245 std::string ex(str, iter.base());
7246 assert(ex == "0.000000");
7247 assert(ios.width() == 0);
7248 }
7249 ios.width(25);
7250 left(ios);
7251 {
7252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7253 std::string ex(str, iter.base());
7254 assert(ex == "0.000000*****************");
7255 assert(ios.width() == 0);
7256 }
7257 ios.width(25);
7258 right(ios);
7259 {
7260 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7261 std::string ex(str, iter.base());
7262 assert(ex == "*****************0.000000");
7263 assert(ios.width() == 0);
7264 }
7265 ios.width(25);
7266 internal(ios);
7267 {
7268 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7269 std::string ex(str, iter.base());
7270 assert(ex == "*****************0.000000");
7271 assert(ios.width() == 0);
7272 }
7273 }
7274 ios.imbue(lg);
7275 {
7276 ios.width(0);
7277 {
7278 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7279 std::string ex(str, iter.base());
7280 assert(ex == "0;000000");
7281 assert(ios.width() == 0);
7282 }
7283 ios.width(25);
7284 left(ios);
7285 {
7286 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7287 std::string ex(str, iter.base());
7288 assert(ex == "0;000000*****************");
7289 assert(ios.width() == 0);
7290 }
7291 ios.width(25);
7292 right(ios);
7293 {
7294 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7295 std::string ex(str, iter.base());
7296 assert(ex == "*****************0;000000");
7297 assert(ios.width() == 0);
7298 }
7299 ios.width(25);
7300 internal(ios);
7301 {
7302 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7303 std::string ex(str, iter.base());
7304 assert(ex == "*****************0;000000");
7305 assert(ios.width() == 0);
7306 }
7307 }
7308 }
7309 }
7310 showpos(ios);
7311 {
7312 noshowpoint(ios);
7313 {
7314 ios.imbue(lc);
7315 {
7316 ios.width(0);
7317 {
7318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7319 std::string ex(str, iter.base());
7320 assert(ex == "+0.000000");
7321 assert(ios.width() == 0);
7322 }
7323 ios.width(25);
7324 left(ios);
7325 {
7326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7327 std::string ex(str, iter.base());
7328 assert(ex == "+0.000000****************");
7329 assert(ios.width() == 0);
7330 }
7331 ios.width(25);
7332 right(ios);
7333 {
7334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7335 std::string ex(str, iter.base());
7336 assert(ex == "****************+0.000000");
7337 assert(ios.width() == 0);
7338 }
7339 ios.width(25);
7340 internal(ios);
7341 {
7342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7343 std::string ex(str, iter.base());
7344 assert(ex == "+****************0.000000");
7345 assert(ios.width() == 0);
7346 }
7347 }
7348 ios.imbue(lg);
7349 {
7350 ios.width(0);
7351 {
7352 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7353 std::string ex(str, iter.base());
7354 assert(ex == "+0;000000");
7355 assert(ios.width() == 0);
7356 }
7357 ios.width(25);
7358 left(ios);
7359 {
7360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7361 std::string ex(str, iter.base());
7362 assert(ex == "+0;000000****************");
7363 assert(ios.width() == 0);
7364 }
7365 ios.width(25);
7366 right(ios);
7367 {
7368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7369 std::string ex(str, iter.base());
7370 assert(ex == "****************+0;000000");
7371 assert(ios.width() == 0);
7372 }
7373 ios.width(25);
7374 internal(ios);
7375 {
7376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7377 std::string ex(str, iter.base());
7378 assert(ex == "+****************0;000000");
7379 assert(ios.width() == 0);
7380 }
7381 }
7382 }
7383 showpoint(ios);
7384 {
7385 ios.imbue(lc);
7386 {
7387 ios.width(0);
7388 {
7389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7390 std::string ex(str, iter.base());
7391 assert(ex == "+0.000000");
7392 assert(ios.width() == 0);
7393 }
7394 ios.width(25);
7395 left(ios);
7396 {
7397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7398 std::string ex(str, iter.base());
7399 assert(ex == "+0.000000****************");
7400 assert(ios.width() == 0);
7401 }
7402 ios.width(25);
7403 right(ios);
7404 {
7405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7406 std::string ex(str, iter.base());
7407 assert(ex == "****************+0.000000");
7408 assert(ios.width() == 0);
7409 }
7410 ios.width(25);
7411 internal(ios);
7412 {
7413 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7414 std::string ex(str, iter.base());
7415 assert(ex == "+****************0.000000");
7416 assert(ios.width() == 0);
7417 }
7418 }
7419 ios.imbue(lg);
7420 {
7421 ios.width(0);
7422 {
7423 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7424 std::string ex(str, iter.base());
7425 assert(ex == "+0;000000");
7426 assert(ios.width() == 0);
7427 }
7428 ios.width(25);
7429 left(ios);
7430 {
7431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7432 std::string ex(str, iter.base());
7433 assert(ex == "+0;000000****************");
7434 assert(ios.width() == 0);
7435 }
7436 ios.width(25);
7437 right(ios);
7438 {
7439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7440 std::string ex(str, iter.base());
7441 assert(ex == "****************+0;000000");
7442 assert(ios.width() == 0);
7443 }
7444 ios.width(25);
7445 internal(ios);
7446 {
7447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7448 std::string ex(str, iter.base());
7449 assert(ex == "+****************0;000000");
7450 assert(ios.width() == 0);
7451 }
7452 }
7453 }
7454 }
7455 }
7456 uppercase(ios);
7457 {
7458 noshowpos(ios);
7459 {
7460 noshowpoint(ios);
7461 {
7462 ios.imbue(lc);
7463 {
7464 ios.width(0);
7465 {
7466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7467 std::string ex(str, iter.base());
7468 assert(ex == "0.000000");
7469 assert(ios.width() == 0);
7470 }
7471 ios.width(25);
7472 left(ios);
7473 {
7474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7475 std::string ex(str, iter.base());
7476 assert(ex == "0.000000*****************");
7477 assert(ios.width() == 0);
7478 }
7479 ios.width(25);
7480 right(ios);
7481 {
7482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7483 std::string ex(str, iter.base());
7484 assert(ex == "*****************0.000000");
7485 assert(ios.width() == 0);
7486 }
7487 ios.width(25);
7488 internal(ios);
7489 {
7490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7491 std::string ex(str, iter.base());
7492 assert(ex == "*****************0.000000");
7493 assert(ios.width() == 0);
7494 }
7495 }
7496 ios.imbue(lg);
7497 {
7498 ios.width(0);
7499 {
7500 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7501 std::string ex(str, iter.base());
7502 assert(ex == "0;000000");
7503 assert(ios.width() == 0);
7504 }
7505 ios.width(25);
7506 left(ios);
7507 {
7508 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7509 std::string ex(str, iter.base());
7510 assert(ex == "0;000000*****************");
7511 assert(ios.width() == 0);
7512 }
7513 ios.width(25);
7514 right(ios);
7515 {
7516 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7517 std::string ex(str, iter.base());
7518 assert(ex == "*****************0;000000");
7519 assert(ios.width() == 0);
7520 }
7521 ios.width(25);
7522 internal(ios);
7523 {
7524 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7525 std::string ex(str, iter.base());
7526 assert(ex == "*****************0;000000");
7527 assert(ios.width() == 0);
7528 }
7529 }
7530 }
7531 showpoint(ios);
7532 {
7533 ios.imbue(lc);
7534 {
7535 ios.width(0);
7536 {
7537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7538 std::string ex(str, iter.base());
7539 assert(ex == "0.000000");
7540 assert(ios.width() == 0);
7541 }
7542 ios.width(25);
7543 left(ios);
7544 {
7545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7546 std::string ex(str, iter.base());
7547 assert(ex == "0.000000*****************");
7548 assert(ios.width() == 0);
7549 }
7550 ios.width(25);
7551 right(ios);
7552 {
7553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7554 std::string ex(str, iter.base());
7555 assert(ex == "*****************0.000000");
7556 assert(ios.width() == 0);
7557 }
7558 ios.width(25);
7559 internal(ios);
7560 {
7561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7562 std::string ex(str, iter.base());
7563 assert(ex == "*****************0.000000");
7564 assert(ios.width() == 0);
7565 }
7566 }
7567 ios.imbue(lg);
7568 {
7569 ios.width(0);
7570 {
7571 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7572 std::string ex(str, iter.base());
7573 assert(ex == "0;000000");
7574 assert(ios.width() == 0);
7575 }
7576 ios.width(25);
7577 left(ios);
7578 {
7579 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7580 std::string ex(str, iter.base());
7581 assert(ex == "0;000000*****************");
7582 assert(ios.width() == 0);
7583 }
7584 ios.width(25);
7585 right(ios);
7586 {
7587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7588 std::string ex(str, iter.base());
7589 assert(ex == "*****************0;000000");
7590 assert(ios.width() == 0);
7591 }
7592 ios.width(25);
7593 internal(ios);
7594 {
7595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7596 std::string ex(str, iter.base());
7597 assert(ex == "*****************0;000000");
7598 assert(ios.width() == 0);
7599 }
7600 }
7601 }
7602 }
7603 showpos(ios);
7604 {
7605 noshowpoint(ios);
7606 {
7607 ios.imbue(lc);
7608 {
7609 ios.width(0);
7610 {
7611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7612 std::string ex(str, iter.base());
7613 assert(ex == "+0.000000");
7614 assert(ios.width() == 0);
7615 }
7616 ios.width(25);
7617 left(ios);
7618 {
7619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7620 std::string ex(str, iter.base());
7621 assert(ex == "+0.000000****************");
7622 assert(ios.width() == 0);
7623 }
7624 ios.width(25);
7625 right(ios);
7626 {
7627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7628 std::string ex(str, iter.base());
7629 assert(ex == "****************+0.000000");
7630 assert(ios.width() == 0);
7631 }
7632 ios.width(25);
7633 internal(ios);
7634 {
7635 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7636 std::string ex(str, iter.base());
7637 assert(ex == "+****************0.000000");
7638 assert(ios.width() == 0);
7639 }
7640 }
7641 ios.imbue(lg);
7642 {
7643 ios.width(0);
7644 {
7645 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7646 std::string ex(str, iter.base());
7647 assert(ex == "+0;000000");
7648 assert(ios.width() == 0);
7649 }
7650 ios.width(25);
7651 left(ios);
7652 {
7653 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7654 std::string ex(str, iter.base());
7655 assert(ex == "+0;000000****************");
7656 assert(ios.width() == 0);
7657 }
7658 ios.width(25);
7659 right(ios);
7660 {
7661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7662 std::string ex(str, iter.base());
7663 assert(ex == "****************+0;000000");
7664 assert(ios.width() == 0);
7665 }
7666 ios.width(25);
7667 internal(ios);
7668 {
7669 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7670 std::string ex(str, iter.base());
7671 assert(ex == "+****************0;000000");
7672 assert(ios.width() == 0);
7673 }
7674 }
7675 }
7676 showpoint(ios);
7677 {
7678 ios.imbue(lc);
7679 {
7680 ios.width(0);
7681 {
7682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7683 std::string ex(str, iter.base());
7684 assert(ex == "+0.000000");
7685 assert(ios.width() == 0);
7686 }
7687 ios.width(25);
7688 left(ios);
7689 {
7690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7691 std::string ex(str, iter.base());
7692 assert(ex == "+0.000000****************");
7693 assert(ios.width() == 0);
7694 }
7695 ios.width(25);
7696 right(ios);
7697 {
7698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7699 std::string ex(str, iter.base());
7700 assert(ex == "****************+0.000000");
7701 assert(ios.width() == 0);
7702 }
7703 ios.width(25);
7704 internal(ios);
7705 {
7706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7707 std::string ex(str, iter.base());
7708 assert(ex == "+****************0.000000");
7709 assert(ios.width() == 0);
7710 }
7711 }
7712 ios.imbue(lg);
7713 {
7714 ios.width(0);
7715 {
7716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7717 std::string ex(str, iter.base());
7718 assert(ex == "+0;000000");
7719 assert(ios.width() == 0);
7720 }
7721 ios.width(25);
7722 left(ios);
7723 {
7724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7725 std::string ex(str, iter.base());
7726 assert(ex == "+0;000000****************");
7727 assert(ios.width() == 0);
7728 }
7729 ios.width(25);
7730 right(ios);
7731 {
7732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7733 std::string ex(str, iter.base());
7734 assert(ex == "****************+0;000000");
7735 assert(ios.width() == 0);
7736 }
7737 ios.width(25);
7738 internal(ios);
7739 {
7740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7741 std::string ex(str, iter.base());
7742 assert(ex == "+****************0;000000");
7743 assert(ios.width() == 0);
7744 }
7745 }
7746 }
7747 }
7748 }
7749 }
7750 ios.precision(16);
7751 {
7752 nouppercase(ios);
7753 {
7754 noshowpos(ios);
7755 {
7756 noshowpoint(ios);
7757 {
7758 ios.imbue(lc);
7759 {
7760 ios.width(0);
7761 {
7762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7763 std::string ex(str, iter.base());
7764 assert(ex == "0.0000000000000000");
7765 assert(ios.width() == 0);
7766 }
7767 ios.width(25);
7768 left(ios);
7769 {
7770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7771 std::string ex(str, iter.base());
7772 assert(ex == "0.0000000000000000*******");
7773 assert(ios.width() == 0);
7774 }
7775 ios.width(25);
7776 right(ios);
7777 {
7778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7779 std::string ex(str, iter.base());
7780 assert(ex == "*******0.0000000000000000");
7781 assert(ios.width() == 0);
7782 }
7783 ios.width(25);
7784 internal(ios);
7785 {
7786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7787 std::string ex(str, iter.base());
7788 assert(ex == "*******0.0000000000000000");
7789 assert(ios.width() == 0);
7790 }
7791 }
7792 ios.imbue(lg);
7793 {
7794 ios.width(0);
7795 {
7796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7797 std::string ex(str, iter.base());
7798 assert(ex == "0;0000000000000000");
7799 assert(ios.width() == 0);
7800 }
7801 ios.width(25);
7802 left(ios);
7803 {
7804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7805 std::string ex(str, iter.base());
7806 assert(ex == "0;0000000000000000*******");
7807 assert(ios.width() == 0);
7808 }
7809 ios.width(25);
7810 right(ios);
7811 {
7812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7813 std::string ex(str, iter.base());
7814 assert(ex == "*******0;0000000000000000");
7815 assert(ios.width() == 0);
7816 }
7817 ios.width(25);
7818 internal(ios);
7819 {
7820 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7821 std::string ex(str, iter.base());
7822 assert(ex == "*******0;0000000000000000");
7823 assert(ios.width() == 0);
7824 }
7825 }
7826 }
7827 showpoint(ios);
7828 {
7829 ios.imbue(lc);
7830 {
7831 ios.width(0);
7832 {
7833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7834 std::string ex(str, iter.base());
7835 assert(ex == "0.0000000000000000");
7836 assert(ios.width() == 0);
7837 }
7838 ios.width(25);
7839 left(ios);
7840 {
7841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7842 std::string ex(str, iter.base());
7843 assert(ex == "0.0000000000000000*******");
7844 assert(ios.width() == 0);
7845 }
7846 ios.width(25);
7847 right(ios);
7848 {
7849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7850 std::string ex(str, iter.base());
7851 assert(ex == "*******0.0000000000000000");
7852 assert(ios.width() == 0);
7853 }
7854 ios.width(25);
7855 internal(ios);
7856 {
7857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7858 std::string ex(str, iter.base());
7859 assert(ex == "*******0.0000000000000000");
7860 assert(ios.width() == 0);
7861 }
7862 }
7863 ios.imbue(lg);
7864 {
7865 ios.width(0);
7866 {
7867 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7868 std::string ex(str, iter.base());
7869 assert(ex == "0;0000000000000000");
7870 assert(ios.width() == 0);
7871 }
7872 ios.width(25);
7873 left(ios);
7874 {
7875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7876 std::string ex(str, iter.base());
7877 assert(ex == "0;0000000000000000*******");
7878 assert(ios.width() == 0);
7879 }
7880 ios.width(25);
7881 right(ios);
7882 {
7883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7884 std::string ex(str, iter.base());
7885 assert(ex == "*******0;0000000000000000");
7886 assert(ios.width() == 0);
7887 }
7888 ios.width(25);
7889 internal(ios);
7890 {
7891 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7892 std::string ex(str, iter.base());
7893 assert(ex == "*******0;0000000000000000");
7894 assert(ios.width() == 0);
7895 }
7896 }
7897 }
7898 }
7899 showpos(ios);
7900 {
7901 noshowpoint(ios);
7902 {
7903 ios.imbue(lc);
7904 {
7905 ios.width(0);
7906 {
7907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7908 std::string ex(str, iter.base());
7909 assert(ex == "+0.0000000000000000");
7910 assert(ios.width() == 0);
7911 }
7912 ios.width(25);
7913 left(ios);
7914 {
7915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7916 std::string ex(str, iter.base());
7917 assert(ex == "+0.0000000000000000******");
7918 assert(ios.width() == 0);
7919 }
7920 ios.width(25);
7921 right(ios);
7922 {
7923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7924 std::string ex(str, iter.base());
7925 assert(ex == "******+0.0000000000000000");
7926 assert(ios.width() == 0);
7927 }
7928 ios.width(25);
7929 internal(ios);
7930 {
7931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7932 std::string ex(str, iter.base());
7933 assert(ex == "+******0.0000000000000000");
7934 assert(ios.width() == 0);
7935 }
7936 }
7937 ios.imbue(lg);
7938 {
7939 ios.width(0);
7940 {
7941 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7942 std::string ex(str, iter.base());
7943 assert(ex == "+0;0000000000000000");
7944 assert(ios.width() == 0);
7945 }
7946 ios.width(25);
7947 left(ios);
7948 {
7949 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7950 std::string ex(str, iter.base());
7951 assert(ex == "+0;0000000000000000******");
7952 assert(ios.width() == 0);
7953 }
7954 ios.width(25);
7955 right(ios);
7956 {
7957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7958 std::string ex(str, iter.base());
7959 assert(ex == "******+0;0000000000000000");
7960 assert(ios.width() == 0);
7961 }
7962 ios.width(25);
7963 internal(ios);
7964 {
7965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7966 std::string ex(str, iter.base());
7967 assert(ex == "+******0;0000000000000000");
7968 assert(ios.width() == 0);
7969 }
7970 }
7971 }
7972 showpoint(ios);
7973 {
7974 ios.imbue(lc);
7975 {
7976 ios.width(0);
7977 {
7978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7979 std::string ex(str, iter.base());
7980 assert(ex == "+0.0000000000000000");
7981 assert(ios.width() == 0);
7982 }
7983 ios.width(25);
7984 left(ios);
7985 {
7986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7987 std::string ex(str, iter.base());
7988 assert(ex == "+0.0000000000000000******");
7989 assert(ios.width() == 0);
7990 }
7991 ios.width(25);
7992 right(ios);
7993 {
7994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7995 std::string ex(str, iter.base());
7996 assert(ex == "******+0.0000000000000000");
7997 assert(ios.width() == 0);
7998 }
7999 ios.width(25);
8000 internal(ios);
8001 {
8002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8003 std::string ex(str, iter.base());
8004 assert(ex == "+******0.0000000000000000");
8005 assert(ios.width() == 0);
8006 }
8007 }
8008 ios.imbue(lg);
8009 {
8010 ios.width(0);
8011 {
8012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8013 std::string ex(str, iter.base());
8014 assert(ex == "+0;0000000000000000");
8015 assert(ios.width() == 0);
8016 }
8017 ios.width(25);
8018 left(ios);
8019 {
8020 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8021 std::string ex(str, iter.base());
8022 assert(ex == "+0;0000000000000000******");
8023 assert(ios.width() == 0);
8024 }
8025 ios.width(25);
8026 right(ios);
8027 {
8028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8029 std::string ex(str, iter.base());
8030 assert(ex == "******+0;0000000000000000");
8031 assert(ios.width() == 0);
8032 }
8033 ios.width(25);
8034 internal(ios);
8035 {
8036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8037 std::string ex(str, iter.base());
8038 assert(ex == "+******0;0000000000000000");
8039 assert(ios.width() == 0);
8040 }
8041 }
8042 }
8043 }
8044 }
8045 uppercase(ios);
8046 {
8047 noshowpos(ios);
8048 {
8049 noshowpoint(ios);
8050 {
8051 ios.imbue(lc);
8052 {
8053 ios.width(0);
8054 {
8055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8056 std::string ex(str, iter.base());
8057 assert(ex == "0.0000000000000000");
8058 assert(ios.width() == 0);
8059 }
8060 ios.width(25);
8061 left(ios);
8062 {
8063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8064 std::string ex(str, iter.base());
8065 assert(ex == "0.0000000000000000*******");
8066 assert(ios.width() == 0);
8067 }
8068 ios.width(25);
8069 right(ios);
8070 {
8071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8072 std::string ex(str, iter.base());
8073 assert(ex == "*******0.0000000000000000");
8074 assert(ios.width() == 0);
8075 }
8076 ios.width(25);
8077 internal(ios);
8078 {
8079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8080 std::string ex(str, iter.base());
8081 assert(ex == "*******0.0000000000000000");
8082 assert(ios.width() == 0);
8083 }
8084 }
8085 ios.imbue(lg);
8086 {
8087 ios.width(0);
8088 {
8089 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8090 std::string ex(str, iter.base());
8091 assert(ex == "0;0000000000000000");
8092 assert(ios.width() == 0);
8093 }
8094 ios.width(25);
8095 left(ios);
8096 {
8097 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8098 std::string ex(str, iter.base());
8099 assert(ex == "0;0000000000000000*******");
8100 assert(ios.width() == 0);
8101 }
8102 ios.width(25);
8103 right(ios);
8104 {
8105 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8106 std::string ex(str, iter.base());
8107 assert(ex == "*******0;0000000000000000");
8108 assert(ios.width() == 0);
8109 }
8110 ios.width(25);
8111 internal(ios);
8112 {
8113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8114 std::string ex(str, iter.base());
8115 assert(ex == "*******0;0000000000000000");
8116 assert(ios.width() == 0);
8117 }
8118 }
8119 }
8120 showpoint(ios);
8121 {
8122 ios.imbue(lc);
8123 {
8124 ios.width(0);
8125 {
8126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8127 std::string ex(str, iter.base());
8128 assert(ex == "0.0000000000000000");
8129 assert(ios.width() == 0);
8130 }
8131 ios.width(25);
8132 left(ios);
8133 {
8134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8135 std::string ex(str, iter.base());
8136 assert(ex == "0.0000000000000000*******");
8137 assert(ios.width() == 0);
8138 }
8139 ios.width(25);
8140 right(ios);
8141 {
8142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8143 std::string ex(str, iter.base());
8144 assert(ex == "*******0.0000000000000000");
8145 assert(ios.width() == 0);
8146 }
8147 ios.width(25);
8148 internal(ios);
8149 {
8150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8151 std::string ex(str, iter.base());
8152 assert(ex == "*******0.0000000000000000");
8153 assert(ios.width() == 0);
8154 }
8155 }
8156 ios.imbue(lg);
8157 {
8158 ios.width(0);
8159 {
8160 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8161 std::string ex(str, iter.base());
8162 assert(ex == "0;0000000000000000");
8163 assert(ios.width() == 0);
8164 }
8165 ios.width(25);
8166 left(ios);
8167 {
8168 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8169 std::string ex(str, iter.base());
8170 assert(ex == "0;0000000000000000*******");
8171 assert(ios.width() == 0);
8172 }
8173 ios.width(25);
8174 right(ios);
8175 {
8176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8177 std::string ex(str, iter.base());
8178 assert(ex == "*******0;0000000000000000");
8179 assert(ios.width() == 0);
8180 }
8181 ios.width(25);
8182 internal(ios);
8183 {
8184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8185 std::string ex(str, iter.base());
8186 assert(ex == "*******0;0000000000000000");
8187 assert(ios.width() == 0);
8188 }
8189 }
8190 }
8191 }
8192 showpos(ios);
8193 {
8194 noshowpoint(ios);
8195 {
8196 ios.imbue(lc);
8197 {
8198 ios.width(0);
8199 {
8200 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8201 std::string ex(str, iter.base());
8202 assert(ex == "+0.0000000000000000");
8203 assert(ios.width() == 0);
8204 }
8205 ios.width(25);
8206 left(ios);
8207 {
8208 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8209 std::string ex(str, iter.base());
8210 assert(ex == "+0.0000000000000000******");
8211 assert(ios.width() == 0);
8212 }
8213 ios.width(25);
8214 right(ios);
8215 {
8216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8217 std::string ex(str, iter.base());
8218 assert(ex == "******+0.0000000000000000");
8219 assert(ios.width() == 0);
8220 }
8221 ios.width(25);
8222 internal(ios);
8223 {
8224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8225 std::string ex(str, iter.base());
8226 assert(ex == "+******0.0000000000000000");
8227 assert(ios.width() == 0);
8228 }
8229 }
8230 ios.imbue(lg);
8231 {
8232 ios.width(0);
8233 {
8234 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8235 std::string ex(str, iter.base());
8236 assert(ex == "+0;0000000000000000");
8237 assert(ios.width() == 0);
8238 }
8239 ios.width(25);
8240 left(ios);
8241 {
8242 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8243 std::string ex(str, iter.base());
8244 assert(ex == "+0;0000000000000000******");
8245 assert(ios.width() == 0);
8246 }
8247 ios.width(25);
8248 right(ios);
8249 {
8250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8251 std::string ex(str, iter.base());
8252 assert(ex == "******+0;0000000000000000");
8253 assert(ios.width() == 0);
8254 }
8255 ios.width(25);
8256 internal(ios);
8257 {
8258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8259 std::string ex(str, iter.base());
8260 assert(ex == "+******0;0000000000000000");
8261 assert(ios.width() == 0);
8262 }
8263 }
8264 }
8265 showpoint(ios);
8266 {
8267 ios.imbue(lc);
8268 {
8269 ios.width(0);
8270 {
8271 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8272 std::string ex(str, iter.base());
8273 assert(ex == "+0.0000000000000000");
8274 assert(ios.width() == 0);
8275 }
8276 ios.width(25);
8277 left(ios);
8278 {
8279 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8280 std::string ex(str, iter.base());
8281 assert(ex == "+0.0000000000000000******");
8282 assert(ios.width() == 0);
8283 }
8284 ios.width(25);
8285 right(ios);
8286 {
8287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8288 std::string ex(str, iter.base());
8289 assert(ex == "******+0.0000000000000000");
8290 assert(ios.width() == 0);
8291 }
8292 ios.width(25);
8293 internal(ios);
8294 {
8295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8296 std::string ex(str, iter.base());
8297 assert(ex == "+******0.0000000000000000");
8298 assert(ios.width() == 0);
8299 }
8300 }
8301 ios.imbue(lg);
8302 {
8303 ios.width(0);
8304 {
8305 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8306 std::string ex(str, iter.base());
8307 assert(ex == "+0;0000000000000000");
8308 assert(ios.width() == 0);
8309 }
8310 ios.width(25);
8311 left(ios);
8312 {
8313 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8314 std::string ex(str, iter.base());
8315 assert(ex == "+0;0000000000000000******");
8316 assert(ios.width() == 0);
8317 }
8318 ios.width(25);
8319 right(ios);
8320 {
8321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8322 std::string ex(str, iter.base());
8323 assert(ex == "******+0;0000000000000000");
8324 assert(ios.width() == 0);
8325 }
8326 ios.width(25);
8327 internal(ios);
8328 {
8329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8330 std::string ex(str, iter.base());
8331 assert(ex == "+******0;0000000000000000");
8332 assert(ios.width() == 0);
8333 }
8334 }
8335 }
8336 }
8337 }
8338 }
8339 ios.precision(60);
8340 {
8341 nouppercase(ios);
8342 {
8343 noshowpos(ios);
8344 {
8345 noshowpoint(ios);
8346 {
8347 ios.imbue(lc);
8348 {
8349 ios.width(0);
8350 {
8351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8352 std::string ex(str, iter.base());
8353 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8354 assert(ios.width() == 0);
8355 }
8356 ios.width(25);
8357 left(ios);
8358 {
8359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8360 std::string ex(str, iter.base());
8361 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8362 assert(ios.width() == 0);
8363 }
8364 ios.width(25);
8365 right(ios);
8366 {
8367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8368 std::string ex(str, iter.base());
8369 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8370 assert(ios.width() == 0);
8371 }
8372 ios.width(25);
8373 internal(ios);
8374 {
8375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8376 std::string ex(str, iter.base());
8377 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8378 assert(ios.width() == 0);
8379 }
8380 }
8381 ios.imbue(lg);
8382 {
8383 ios.width(0);
8384 {
8385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8386 std::string ex(str, iter.base());
8387 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8388 assert(ios.width() == 0);
8389 }
8390 ios.width(25);
8391 left(ios);
8392 {
8393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8394 std::string ex(str, iter.base());
8395 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8396 assert(ios.width() == 0);
8397 }
8398 ios.width(25);
8399 right(ios);
8400 {
8401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8402 std::string ex(str, iter.base());
8403 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8404 assert(ios.width() == 0);
8405 }
8406 ios.width(25);
8407 internal(ios);
8408 {
8409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8410 std::string ex(str, iter.base());
8411 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8412 assert(ios.width() == 0);
8413 }
8414 }
8415 }
8416 showpoint(ios);
8417 {
8418 ios.imbue(lc);
8419 {
8420 ios.width(0);
8421 {
8422 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8423 std::string ex(str, iter.base());
8424 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8425 assert(ios.width() == 0);
8426 }
8427 ios.width(25);
8428 left(ios);
8429 {
8430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8431 std::string ex(str, iter.base());
8432 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8433 assert(ios.width() == 0);
8434 }
8435 ios.width(25);
8436 right(ios);
8437 {
8438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8439 std::string ex(str, iter.base());
8440 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8441 assert(ios.width() == 0);
8442 }
8443 ios.width(25);
8444 internal(ios);
8445 {
8446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8447 std::string ex(str, iter.base());
8448 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8449 assert(ios.width() == 0);
8450 }
8451 }
8452 ios.imbue(lg);
8453 {
8454 ios.width(0);
8455 {
8456 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8457 std::string ex(str, iter.base());
8458 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8459 assert(ios.width() == 0);
8460 }
8461 ios.width(25);
8462 left(ios);
8463 {
8464 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8465 std::string ex(str, iter.base());
8466 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8467 assert(ios.width() == 0);
8468 }
8469 ios.width(25);
8470 right(ios);
8471 {
8472 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8473 std::string ex(str, iter.base());
8474 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8475 assert(ios.width() == 0);
8476 }
8477 ios.width(25);
8478 internal(ios);
8479 {
8480 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8481 std::string ex(str, iter.base());
8482 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8483 assert(ios.width() == 0);
8484 }
8485 }
8486 }
8487 }
8488 showpos(ios);
8489 {
8490 noshowpoint(ios);
8491 {
8492 ios.imbue(lc);
8493 {
8494 ios.width(0);
8495 {
8496 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8497 std::string ex(str, iter.base());
8498 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8499 assert(ios.width() == 0);
8500 }
8501 ios.width(25);
8502 left(ios);
8503 {
8504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8505 std::string ex(str, iter.base());
8506 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8507 assert(ios.width() == 0);
8508 }
8509 ios.width(25);
8510 right(ios);
8511 {
8512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8513 std::string ex(str, iter.base());
8514 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8515 assert(ios.width() == 0);
8516 }
8517 ios.width(25);
8518 internal(ios);
8519 {
8520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8521 std::string ex(str, iter.base());
8522 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8523 assert(ios.width() == 0);
8524 }
8525 }
8526 ios.imbue(lg);
8527 {
8528 ios.width(0);
8529 {
8530 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8531 std::string ex(str, iter.base());
8532 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8533 assert(ios.width() == 0);
8534 }
8535 ios.width(25);
8536 left(ios);
8537 {
8538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8539 std::string ex(str, iter.base());
8540 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8541 assert(ios.width() == 0);
8542 }
8543 ios.width(25);
8544 right(ios);
8545 {
8546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8547 std::string ex(str, iter.base());
8548 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8549 assert(ios.width() == 0);
8550 }
8551 ios.width(25);
8552 internal(ios);
8553 {
8554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8555 std::string ex(str, iter.base());
8556 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8557 assert(ios.width() == 0);
8558 }
8559 }
8560 }
8561 showpoint(ios);
8562 {
8563 ios.imbue(lc);
8564 {
8565 ios.width(0);
8566 {
8567 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8568 std::string ex(str, iter.base());
8569 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8570 assert(ios.width() == 0);
8571 }
8572 ios.width(25);
8573 left(ios);
8574 {
8575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8576 std::string ex(str, iter.base());
8577 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8578 assert(ios.width() == 0);
8579 }
8580 ios.width(25);
8581 right(ios);
8582 {
8583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8584 std::string ex(str, iter.base());
8585 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8586 assert(ios.width() == 0);
8587 }
8588 ios.width(25);
8589 internal(ios);
8590 {
8591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8592 std::string ex(str, iter.base());
8593 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8594 assert(ios.width() == 0);
8595 }
8596 }
8597 ios.imbue(lg);
8598 {
8599 ios.width(0);
8600 {
8601 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8602 std::string ex(str, iter.base());
8603 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8604 assert(ios.width() == 0);
8605 }
8606 ios.width(25);
8607 left(ios);
8608 {
8609 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8610 std::string ex(str, iter.base());
8611 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8612 assert(ios.width() == 0);
8613 }
8614 ios.width(25);
8615 right(ios);
8616 {
8617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8618 std::string ex(str, iter.base());
8619 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8620 assert(ios.width() == 0);
8621 }
8622 ios.width(25);
8623 internal(ios);
8624 {
8625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8626 std::string ex(str, iter.base());
8627 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8628 assert(ios.width() == 0);
8629 }
8630 }
8631 }
8632 }
8633 }
8634 uppercase(ios);
8635 {
8636 noshowpos(ios);
8637 {
8638 noshowpoint(ios);
8639 {
8640 ios.imbue(lc);
8641 {
8642 ios.width(0);
8643 {
8644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8645 std::string ex(str, iter.base());
8646 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8647 assert(ios.width() == 0);
8648 }
8649 ios.width(25);
8650 left(ios);
8651 {
8652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8653 std::string ex(str, iter.base());
8654 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8655 assert(ios.width() == 0);
8656 }
8657 ios.width(25);
8658 right(ios);
8659 {
8660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8661 std::string ex(str, iter.base());
8662 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8663 assert(ios.width() == 0);
8664 }
8665 ios.width(25);
8666 internal(ios);
8667 {
8668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8669 std::string ex(str, iter.base());
8670 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8671 assert(ios.width() == 0);
8672 }
8673 }
8674 ios.imbue(lg);
8675 {
8676 ios.width(0);
8677 {
8678 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8679 std::string ex(str, iter.base());
8680 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8681 assert(ios.width() == 0);
8682 }
8683 ios.width(25);
8684 left(ios);
8685 {
8686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8687 std::string ex(str, iter.base());
8688 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8689 assert(ios.width() == 0);
8690 }
8691 ios.width(25);
8692 right(ios);
8693 {
8694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8695 std::string ex(str, iter.base());
8696 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8697 assert(ios.width() == 0);
8698 }
8699 ios.width(25);
8700 internal(ios);
8701 {
8702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8703 std::string ex(str, iter.base());
8704 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8705 assert(ios.width() == 0);
8706 }
8707 }
8708 }
8709 showpoint(ios);
8710 {
8711 ios.imbue(lc);
8712 {
8713 ios.width(0);
8714 {
8715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8716 std::string ex(str, iter.base());
8717 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8718 assert(ios.width() == 0);
8719 }
8720 ios.width(25);
8721 left(ios);
8722 {
8723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8724 std::string ex(str, iter.base());
8725 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8726 assert(ios.width() == 0);
8727 }
8728 ios.width(25);
8729 right(ios);
8730 {
8731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8732 std::string ex(str, iter.base());
8733 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8734 assert(ios.width() == 0);
8735 }
8736 ios.width(25);
8737 internal(ios);
8738 {
8739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8740 std::string ex(str, iter.base());
8741 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8742 assert(ios.width() == 0);
8743 }
8744 }
8745 ios.imbue(lg);
8746 {
8747 ios.width(0);
8748 {
8749 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8750 std::string ex(str, iter.base());
8751 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8752 assert(ios.width() == 0);
8753 }
8754 ios.width(25);
8755 left(ios);
8756 {
8757 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8758 std::string ex(str, iter.base());
8759 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8760 assert(ios.width() == 0);
8761 }
8762 ios.width(25);
8763 right(ios);
8764 {
8765 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8766 std::string ex(str, iter.base());
8767 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8768 assert(ios.width() == 0);
8769 }
8770 ios.width(25);
8771 internal(ios);
8772 {
8773 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8774 std::string ex(str, iter.base());
8775 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8776 assert(ios.width() == 0);
8777 }
8778 }
8779 }
8780 }
8781 showpos(ios);
8782 {
8783 noshowpoint(ios);
8784 {
8785 ios.imbue(lc);
8786 {
8787 ios.width(0);
8788 {
8789 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8790 std::string ex(str, iter.base());
8791 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8792 assert(ios.width() == 0);
8793 }
8794 ios.width(25);
8795 left(ios);
8796 {
8797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8798 std::string ex(str, iter.base());
8799 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8800 assert(ios.width() == 0);
8801 }
8802 ios.width(25);
8803 right(ios);
8804 {
8805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8806 std::string ex(str, iter.base());
8807 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8808 assert(ios.width() == 0);
8809 }
8810 ios.width(25);
8811 internal(ios);
8812 {
8813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8814 std::string ex(str, iter.base());
8815 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8816 assert(ios.width() == 0);
8817 }
8818 }
8819 ios.imbue(lg);
8820 {
8821 ios.width(0);
8822 {
8823 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8824 std::string ex(str, iter.base());
8825 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8826 assert(ios.width() == 0);
8827 }
8828 ios.width(25);
8829 left(ios);
8830 {
8831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8832 std::string ex(str, iter.base());
8833 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8834 assert(ios.width() == 0);
8835 }
8836 ios.width(25);
8837 right(ios);
8838 {
8839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8840 std::string ex(str, iter.base());
8841 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8842 assert(ios.width() == 0);
8843 }
8844 ios.width(25);
8845 internal(ios);
8846 {
8847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8848 std::string ex(str, iter.base());
8849 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8850 assert(ios.width() == 0);
8851 }
8852 }
8853 }
8854 showpoint(ios);
8855 {
8856 ios.imbue(lc);
8857 {
8858 ios.width(0);
8859 {
8860 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8861 std::string ex(str, iter.base());
8862 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8863 assert(ios.width() == 0);
8864 }
8865 ios.width(25);
8866 left(ios);
8867 {
8868 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8869 std::string ex(str, iter.base());
8870 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8871 assert(ios.width() == 0);
8872 }
8873 ios.width(25);
8874 right(ios);
8875 {
8876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8877 std::string ex(str, iter.base());
8878 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8879 assert(ios.width() == 0);
8880 }
8881 ios.width(25);
8882 internal(ios);
8883 {
8884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8885 std::string ex(str, iter.base());
8886 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8887 assert(ios.width() == 0);
8888 }
8889 }
8890 ios.imbue(lg);
8891 {
8892 ios.width(0);
8893 {
8894 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8895 std::string ex(str, iter.base());
8896 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8897 assert(ios.width() == 0);
8898 }
8899 ios.width(25);
8900 left(ios);
8901 {
8902 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8903 std::string ex(str, iter.base());
8904 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8905 assert(ios.width() == 0);
8906 }
8907 ios.width(25);
8908 right(ios);
8909 {
8910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8911 std::string ex(str, iter.base());
8912 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8913 assert(ios.width() == 0);
8914 }
8915 ios.width(25);
8916 internal(ios);
8917 {
8918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8919 std::string ex(str, iter.base());
8920 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8921 assert(ios.width() == 0);
8922 }
8923 }
8924 }
8925 }
8926 }
8927 }
8928 }
8929 }
8930 }
8931
test4()8932 void test4()
8933 {
8934 char str[200];
8935 output_iterator<char*> iter;
8936 std::locale lc = std::locale::classic();
8937 std::locale lg(lc, new my_numpunct);
8938 const my_facet f(1);
8939 {
8940 double v = 1234567890.125;
8941 std::ios ios(0);
8942 fixed(ios);
8943 // %f
8944 {
8945 ios.precision(0);
8946 {
8947 nouppercase(ios);
8948 {
8949 noshowpos(ios);
8950 {
8951 noshowpoint(ios);
8952 {
8953 ios.imbue(lc);
8954 {
8955 ios.width(0);
8956 {
8957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8958 std::string ex(str, iter.base());
8959 assert(ex == "1234567890");
8960 assert(ios.width() == 0);
8961 }
8962 ios.width(25);
8963 left(ios);
8964 {
8965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8966 std::string ex(str, iter.base());
8967 assert(ex == "1234567890***************");
8968 assert(ios.width() == 0);
8969 }
8970 ios.width(25);
8971 right(ios);
8972 {
8973 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8974 std::string ex(str, iter.base());
8975 assert(ex == "***************1234567890");
8976 assert(ios.width() == 0);
8977 }
8978 ios.width(25);
8979 internal(ios);
8980 {
8981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8982 std::string ex(str, iter.base());
8983 assert(ex == "***************1234567890");
8984 assert(ios.width() == 0);
8985 }
8986 }
8987 ios.imbue(lg);
8988 {
8989 ios.width(0);
8990 {
8991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8992 std::string ex(str, iter.base());
8993 assert(ex == "1_234_567_89_0");
8994 assert(ios.width() == 0);
8995 }
8996 ios.width(25);
8997 left(ios);
8998 {
8999 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9000 std::string ex(str, iter.base());
9001 assert(ex == "1_234_567_89_0***********");
9002 assert(ios.width() == 0);
9003 }
9004 ios.width(25);
9005 right(ios);
9006 {
9007 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9008 std::string ex(str, iter.base());
9009 assert(ex == "***********1_234_567_89_0");
9010 assert(ios.width() == 0);
9011 }
9012 ios.width(25);
9013 internal(ios);
9014 {
9015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9016 std::string ex(str, iter.base());
9017 assert(ex == "***********1_234_567_89_0");
9018 assert(ios.width() == 0);
9019 }
9020 }
9021 }
9022 showpoint(ios);
9023 {
9024 ios.imbue(lc);
9025 {
9026 ios.width(0);
9027 {
9028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9029 std::string ex(str, iter.base());
9030 assert(ex == "1234567890.");
9031 assert(ios.width() == 0);
9032 }
9033 ios.width(25);
9034 left(ios);
9035 {
9036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9037 std::string ex(str, iter.base());
9038 assert(ex == "1234567890.**************");
9039 assert(ios.width() == 0);
9040 }
9041 ios.width(25);
9042 right(ios);
9043 {
9044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9045 std::string ex(str, iter.base());
9046 assert(ex == "**************1234567890.");
9047 assert(ios.width() == 0);
9048 }
9049 ios.width(25);
9050 internal(ios);
9051 {
9052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9053 std::string ex(str, iter.base());
9054 assert(ex == "**************1234567890.");
9055 assert(ios.width() == 0);
9056 }
9057 }
9058 ios.imbue(lg);
9059 {
9060 ios.width(0);
9061 {
9062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9063 std::string ex(str, iter.base());
9064 assert(ex == "1_234_567_89_0;");
9065 assert(ios.width() == 0);
9066 }
9067 ios.width(25);
9068 left(ios);
9069 {
9070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9071 std::string ex(str, iter.base());
9072 assert(ex == "1_234_567_89_0;**********");
9073 assert(ios.width() == 0);
9074 }
9075 ios.width(25);
9076 right(ios);
9077 {
9078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9079 std::string ex(str, iter.base());
9080 assert(ex == "**********1_234_567_89_0;");
9081 assert(ios.width() == 0);
9082 }
9083 ios.width(25);
9084 internal(ios);
9085 {
9086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9087 std::string ex(str, iter.base());
9088 assert(ex == "**********1_234_567_89_0;");
9089 assert(ios.width() == 0);
9090 }
9091 }
9092 }
9093 }
9094 showpos(ios);
9095 {
9096 noshowpoint(ios);
9097 {
9098 ios.imbue(lc);
9099 {
9100 ios.width(0);
9101 {
9102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9103 std::string ex(str, iter.base());
9104 assert(ex == "+1234567890");
9105 assert(ios.width() == 0);
9106 }
9107 ios.width(25);
9108 left(ios);
9109 {
9110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9111 std::string ex(str, iter.base());
9112 assert(ex == "+1234567890**************");
9113 assert(ios.width() == 0);
9114 }
9115 ios.width(25);
9116 right(ios);
9117 {
9118 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9119 std::string ex(str, iter.base());
9120 assert(ex == "**************+1234567890");
9121 assert(ios.width() == 0);
9122 }
9123 ios.width(25);
9124 internal(ios);
9125 {
9126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9127 std::string ex(str, iter.base());
9128 assert(ex == "+**************1234567890");
9129 assert(ios.width() == 0);
9130 }
9131 }
9132 ios.imbue(lg);
9133 {
9134 ios.width(0);
9135 {
9136 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9137 std::string ex(str, iter.base());
9138 assert(ex == "+1_234_567_89_0");
9139 assert(ios.width() == 0);
9140 }
9141 ios.width(25);
9142 left(ios);
9143 {
9144 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9145 std::string ex(str, iter.base());
9146 assert(ex == "+1_234_567_89_0**********");
9147 assert(ios.width() == 0);
9148 }
9149 ios.width(25);
9150 right(ios);
9151 {
9152 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9153 std::string ex(str, iter.base());
9154 assert(ex == "**********+1_234_567_89_0");
9155 assert(ios.width() == 0);
9156 }
9157 ios.width(25);
9158 internal(ios);
9159 {
9160 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9161 std::string ex(str, iter.base());
9162 assert(ex == "+**********1_234_567_89_0");
9163 assert(ios.width() == 0);
9164 }
9165 }
9166 }
9167 showpoint(ios);
9168 {
9169 ios.imbue(lc);
9170 {
9171 ios.width(0);
9172 {
9173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9174 std::string ex(str, iter.base());
9175 assert(ex == "+1234567890.");
9176 assert(ios.width() == 0);
9177 }
9178 ios.width(25);
9179 left(ios);
9180 {
9181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9182 std::string ex(str, iter.base());
9183 assert(ex == "+1234567890.*************");
9184 assert(ios.width() == 0);
9185 }
9186 ios.width(25);
9187 right(ios);
9188 {
9189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9190 std::string ex(str, iter.base());
9191 assert(ex == "*************+1234567890.");
9192 assert(ios.width() == 0);
9193 }
9194 ios.width(25);
9195 internal(ios);
9196 {
9197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9198 std::string ex(str, iter.base());
9199 assert(ex == "+*************1234567890.");
9200 assert(ios.width() == 0);
9201 }
9202 }
9203 ios.imbue(lg);
9204 {
9205 ios.width(0);
9206 {
9207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9208 std::string ex(str, iter.base());
9209 assert(ex == "+1_234_567_89_0;");
9210 assert(ios.width() == 0);
9211 }
9212 ios.width(25);
9213 left(ios);
9214 {
9215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9216 std::string ex(str, iter.base());
9217 assert(ex == "+1_234_567_89_0;*********");
9218 assert(ios.width() == 0);
9219 }
9220 ios.width(25);
9221 right(ios);
9222 {
9223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9224 std::string ex(str, iter.base());
9225 assert(ex == "*********+1_234_567_89_0;");
9226 assert(ios.width() == 0);
9227 }
9228 ios.width(25);
9229 internal(ios);
9230 {
9231 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9232 std::string ex(str, iter.base());
9233 assert(ex == "+*********1_234_567_89_0;");
9234 assert(ios.width() == 0);
9235 }
9236 }
9237 }
9238 }
9239 }
9240 uppercase(ios);
9241 {
9242 noshowpos(ios);
9243 {
9244 noshowpoint(ios);
9245 {
9246 ios.imbue(lc);
9247 {
9248 ios.width(0);
9249 {
9250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9251 std::string ex(str, iter.base());
9252 assert(ex == "1234567890");
9253 assert(ios.width() == 0);
9254 }
9255 ios.width(25);
9256 left(ios);
9257 {
9258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9259 std::string ex(str, iter.base());
9260 assert(ex == "1234567890***************");
9261 assert(ios.width() == 0);
9262 }
9263 ios.width(25);
9264 right(ios);
9265 {
9266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9267 std::string ex(str, iter.base());
9268 assert(ex == "***************1234567890");
9269 assert(ios.width() == 0);
9270 }
9271 ios.width(25);
9272 internal(ios);
9273 {
9274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9275 std::string ex(str, iter.base());
9276 assert(ex == "***************1234567890");
9277 assert(ios.width() == 0);
9278 }
9279 }
9280 ios.imbue(lg);
9281 {
9282 ios.width(0);
9283 {
9284 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9285 std::string ex(str, iter.base());
9286 assert(ex == "1_234_567_89_0");
9287 assert(ios.width() == 0);
9288 }
9289 ios.width(25);
9290 left(ios);
9291 {
9292 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9293 std::string ex(str, iter.base());
9294 assert(ex == "1_234_567_89_0***********");
9295 assert(ios.width() == 0);
9296 }
9297 ios.width(25);
9298 right(ios);
9299 {
9300 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9301 std::string ex(str, iter.base());
9302 assert(ex == "***********1_234_567_89_0");
9303 assert(ios.width() == 0);
9304 }
9305 ios.width(25);
9306 internal(ios);
9307 {
9308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9309 std::string ex(str, iter.base());
9310 assert(ex == "***********1_234_567_89_0");
9311 assert(ios.width() == 0);
9312 }
9313 }
9314 }
9315 showpoint(ios);
9316 {
9317 ios.imbue(lc);
9318 {
9319 ios.width(0);
9320 {
9321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9322 std::string ex(str, iter.base());
9323 assert(ex == "1234567890.");
9324 assert(ios.width() == 0);
9325 }
9326 ios.width(25);
9327 left(ios);
9328 {
9329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9330 std::string ex(str, iter.base());
9331 assert(ex == "1234567890.**************");
9332 assert(ios.width() == 0);
9333 }
9334 ios.width(25);
9335 right(ios);
9336 {
9337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9338 std::string ex(str, iter.base());
9339 assert(ex == "**************1234567890.");
9340 assert(ios.width() == 0);
9341 }
9342 ios.width(25);
9343 internal(ios);
9344 {
9345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9346 std::string ex(str, iter.base());
9347 assert(ex == "**************1234567890.");
9348 assert(ios.width() == 0);
9349 }
9350 }
9351 ios.imbue(lg);
9352 {
9353 ios.width(0);
9354 {
9355 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9356 std::string ex(str, iter.base());
9357 assert(ex == "1_234_567_89_0;");
9358 assert(ios.width() == 0);
9359 }
9360 ios.width(25);
9361 left(ios);
9362 {
9363 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9364 std::string ex(str, iter.base());
9365 assert(ex == "1_234_567_89_0;**********");
9366 assert(ios.width() == 0);
9367 }
9368 ios.width(25);
9369 right(ios);
9370 {
9371 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9372 std::string ex(str, iter.base());
9373 assert(ex == "**********1_234_567_89_0;");
9374 assert(ios.width() == 0);
9375 }
9376 ios.width(25);
9377 internal(ios);
9378 {
9379 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9380 std::string ex(str, iter.base());
9381 assert(ex == "**********1_234_567_89_0;");
9382 assert(ios.width() == 0);
9383 }
9384 }
9385 }
9386 }
9387 showpos(ios);
9388 {
9389 noshowpoint(ios);
9390 {
9391 ios.imbue(lc);
9392 {
9393 ios.width(0);
9394 {
9395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9396 std::string ex(str, iter.base());
9397 assert(ex == "+1234567890");
9398 assert(ios.width() == 0);
9399 }
9400 ios.width(25);
9401 left(ios);
9402 {
9403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9404 std::string ex(str, iter.base());
9405 assert(ex == "+1234567890**************");
9406 assert(ios.width() == 0);
9407 }
9408 ios.width(25);
9409 right(ios);
9410 {
9411 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9412 std::string ex(str, iter.base());
9413 assert(ex == "**************+1234567890");
9414 assert(ios.width() == 0);
9415 }
9416 ios.width(25);
9417 internal(ios);
9418 {
9419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9420 std::string ex(str, iter.base());
9421 assert(ex == "+**************1234567890");
9422 assert(ios.width() == 0);
9423 }
9424 }
9425 ios.imbue(lg);
9426 {
9427 ios.width(0);
9428 {
9429 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9430 std::string ex(str, iter.base());
9431 assert(ex == "+1_234_567_89_0");
9432 assert(ios.width() == 0);
9433 }
9434 ios.width(25);
9435 left(ios);
9436 {
9437 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9438 std::string ex(str, iter.base());
9439 assert(ex == "+1_234_567_89_0**********");
9440 assert(ios.width() == 0);
9441 }
9442 ios.width(25);
9443 right(ios);
9444 {
9445 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9446 std::string ex(str, iter.base());
9447 assert(ex == "**********+1_234_567_89_0");
9448 assert(ios.width() == 0);
9449 }
9450 ios.width(25);
9451 internal(ios);
9452 {
9453 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9454 std::string ex(str, iter.base());
9455 assert(ex == "+**********1_234_567_89_0");
9456 assert(ios.width() == 0);
9457 }
9458 }
9459 }
9460 showpoint(ios);
9461 {
9462 ios.imbue(lc);
9463 {
9464 ios.width(0);
9465 {
9466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9467 std::string ex(str, iter.base());
9468 assert(ex == "+1234567890.");
9469 assert(ios.width() == 0);
9470 }
9471 ios.width(25);
9472 left(ios);
9473 {
9474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9475 std::string ex(str, iter.base());
9476 assert(ex == "+1234567890.*************");
9477 assert(ios.width() == 0);
9478 }
9479 ios.width(25);
9480 right(ios);
9481 {
9482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9483 std::string ex(str, iter.base());
9484 assert(ex == "*************+1234567890.");
9485 assert(ios.width() == 0);
9486 }
9487 ios.width(25);
9488 internal(ios);
9489 {
9490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9491 std::string ex(str, iter.base());
9492 assert(ex == "+*************1234567890.");
9493 assert(ios.width() == 0);
9494 }
9495 }
9496 ios.imbue(lg);
9497 {
9498 ios.width(0);
9499 {
9500 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9501 std::string ex(str, iter.base());
9502 assert(ex == "+1_234_567_89_0;");
9503 assert(ios.width() == 0);
9504 }
9505 ios.width(25);
9506 left(ios);
9507 {
9508 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9509 std::string ex(str, iter.base());
9510 assert(ex == "+1_234_567_89_0;*********");
9511 assert(ios.width() == 0);
9512 }
9513 ios.width(25);
9514 right(ios);
9515 {
9516 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9517 std::string ex(str, iter.base());
9518 assert(ex == "*********+1_234_567_89_0;");
9519 assert(ios.width() == 0);
9520 }
9521 ios.width(25);
9522 internal(ios);
9523 {
9524 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9525 std::string ex(str, iter.base());
9526 assert(ex == "+*********1_234_567_89_0;");
9527 assert(ios.width() == 0);
9528 }
9529 }
9530 }
9531 }
9532 }
9533 }
9534 ios.precision(1);
9535 {
9536 nouppercase(ios);
9537 {
9538 noshowpos(ios);
9539 {
9540 noshowpoint(ios);
9541 {
9542 ios.imbue(lc);
9543 {
9544 ios.width(0);
9545 {
9546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9547 std::string ex(str, iter.base());
9548 assert(ex == "1234567890.1");
9549 assert(ios.width() == 0);
9550 }
9551 ios.width(25);
9552 left(ios);
9553 {
9554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9555 std::string ex(str, iter.base());
9556 assert(ex == "1234567890.1*************");
9557 assert(ios.width() == 0);
9558 }
9559 ios.width(25);
9560 right(ios);
9561 {
9562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9563 std::string ex(str, iter.base());
9564 assert(ex == "*************1234567890.1");
9565 assert(ios.width() == 0);
9566 }
9567 ios.width(25);
9568 internal(ios);
9569 {
9570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9571 std::string ex(str, iter.base());
9572 assert(ex == "*************1234567890.1");
9573 assert(ios.width() == 0);
9574 }
9575 }
9576 ios.imbue(lg);
9577 {
9578 ios.width(0);
9579 {
9580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9581 std::string ex(str, iter.base());
9582 assert(ex == "1_234_567_89_0;1");
9583 assert(ios.width() == 0);
9584 }
9585 ios.width(25);
9586 left(ios);
9587 {
9588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9589 std::string ex(str, iter.base());
9590 assert(ex == "1_234_567_89_0;1*********");
9591 assert(ios.width() == 0);
9592 }
9593 ios.width(25);
9594 right(ios);
9595 {
9596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9597 std::string ex(str, iter.base());
9598 assert(ex == "*********1_234_567_89_0;1");
9599 assert(ios.width() == 0);
9600 }
9601 ios.width(25);
9602 internal(ios);
9603 {
9604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9605 std::string ex(str, iter.base());
9606 assert(ex == "*********1_234_567_89_0;1");
9607 assert(ios.width() == 0);
9608 }
9609 }
9610 }
9611 showpoint(ios);
9612 {
9613 ios.imbue(lc);
9614 {
9615 ios.width(0);
9616 {
9617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9618 std::string ex(str, iter.base());
9619 assert(ex == "1234567890.1");
9620 assert(ios.width() == 0);
9621 }
9622 ios.width(25);
9623 left(ios);
9624 {
9625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9626 std::string ex(str, iter.base());
9627 assert(ex == "1234567890.1*************");
9628 assert(ios.width() == 0);
9629 }
9630 ios.width(25);
9631 right(ios);
9632 {
9633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9634 std::string ex(str, iter.base());
9635 assert(ex == "*************1234567890.1");
9636 assert(ios.width() == 0);
9637 }
9638 ios.width(25);
9639 internal(ios);
9640 {
9641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9642 std::string ex(str, iter.base());
9643 assert(ex == "*************1234567890.1");
9644 assert(ios.width() == 0);
9645 }
9646 }
9647 ios.imbue(lg);
9648 {
9649 ios.width(0);
9650 {
9651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9652 std::string ex(str, iter.base());
9653 assert(ex == "1_234_567_89_0;1");
9654 assert(ios.width() == 0);
9655 }
9656 ios.width(25);
9657 left(ios);
9658 {
9659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9660 std::string ex(str, iter.base());
9661 assert(ex == "1_234_567_89_0;1*********");
9662 assert(ios.width() == 0);
9663 }
9664 ios.width(25);
9665 right(ios);
9666 {
9667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9668 std::string ex(str, iter.base());
9669 assert(ex == "*********1_234_567_89_0;1");
9670 assert(ios.width() == 0);
9671 }
9672 ios.width(25);
9673 internal(ios);
9674 {
9675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9676 std::string ex(str, iter.base());
9677 assert(ex == "*********1_234_567_89_0;1");
9678 assert(ios.width() == 0);
9679 }
9680 }
9681 }
9682 }
9683 showpos(ios);
9684 {
9685 noshowpoint(ios);
9686 {
9687 ios.imbue(lc);
9688 {
9689 ios.width(0);
9690 {
9691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9692 std::string ex(str, iter.base());
9693 assert(ex == "+1234567890.1");
9694 assert(ios.width() == 0);
9695 }
9696 ios.width(25);
9697 left(ios);
9698 {
9699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9700 std::string ex(str, iter.base());
9701 assert(ex == "+1234567890.1************");
9702 assert(ios.width() == 0);
9703 }
9704 ios.width(25);
9705 right(ios);
9706 {
9707 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9708 std::string ex(str, iter.base());
9709 assert(ex == "************+1234567890.1");
9710 assert(ios.width() == 0);
9711 }
9712 ios.width(25);
9713 internal(ios);
9714 {
9715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9716 std::string ex(str, iter.base());
9717 assert(ex == "+************1234567890.1");
9718 assert(ios.width() == 0);
9719 }
9720 }
9721 ios.imbue(lg);
9722 {
9723 ios.width(0);
9724 {
9725 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9726 std::string ex(str, iter.base());
9727 assert(ex == "+1_234_567_89_0;1");
9728 assert(ios.width() == 0);
9729 }
9730 ios.width(25);
9731 left(ios);
9732 {
9733 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9734 std::string ex(str, iter.base());
9735 assert(ex == "+1_234_567_89_0;1********");
9736 assert(ios.width() == 0);
9737 }
9738 ios.width(25);
9739 right(ios);
9740 {
9741 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9742 std::string ex(str, iter.base());
9743 assert(ex == "********+1_234_567_89_0;1");
9744 assert(ios.width() == 0);
9745 }
9746 ios.width(25);
9747 internal(ios);
9748 {
9749 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9750 std::string ex(str, iter.base());
9751 assert(ex == "+********1_234_567_89_0;1");
9752 assert(ios.width() == 0);
9753 }
9754 }
9755 }
9756 showpoint(ios);
9757 {
9758 ios.imbue(lc);
9759 {
9760 ios.width(0);
9761 {
9762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9763 std::string ex(str, iter.base());
9764 assert(ex == "+1234567890.1");
9765 assert(ios.width() == 0);
9766 }
9767 ios.width(25);
9768 left(ios);
9769 {
9770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9771 std::string ex(str, iter.base());
9772 assert(ex == "+1234567890.1************");
9773 assert(ios.width() == 0);
9774 }
9775 ios.width(25);
9776 right(ios);
9777 {
9778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9779 std::string ex(str, iter.base());
9780 assert(ex == "************+1234567890.1");
9781 assert(ios.width() == 0);
9782 }
9783 ios.width(25);
9784 internal(ios);
9785 {
9786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9787 std::string ex(str, iter.base());
9788 assert(ex == "+************1234567890.1");
9789 assert(ios.width() == 0);
9790 }
9791 }
9792 ios.imbue(lg);
9793 {
9794 ios.width(0);
9795 {
9796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9797 std::string ex(str, iter.base());
9798 assert(ex == "+1_234_567_89_0;1");
9799 assert(ios.width() == 0);
9800 }
9801 ios.width(25);
9802 left(ios);
9803 {
9804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9805 std::string ex(str, iter.base());
9806 assert(ex == "+1_234_567_89_0;1********");
9807 assert(ios.width() == 0);
9808 }
9809 ios.width(25);
9810 right(ios);
9811 {
9812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9813 std::string ex(str, iter.base());
9814 assert(ex == "********+1_234_567_89_0;1");
9815 assert(ios.width() == 0);
9816 }
9817 ios.width(25);
9818 internal(ios);
9819 {
9820 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9821 std::string ex(str, iter.base());
9822 assert(ex == "+********1_234_567_89_0;1");
9823 assert(ios.width() == 0);
9824 }
9825 }
9826 }
9827 }
9828 }
9829 uppercase(ios);
9830 {
9831 noshowpos(ios);
9832 {
9833 noshowpoint(ios);
9834 {
9835 ios.imbue(lc);
9836 {
9837 ios.width(0);
9838 {
9839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9840 std::string ex(str, iter.base());
9841 assert(ex == "1234567890.1");
9842 assert(ios.width() == 0);
9843 }
9844 ios.width(25);
9845 left(ios);
9846 {
9847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9848 std::string ex(str, iter.base());
9849 assert(ex == "1234567890.1*************");
9850 assert(ios.width() == 0);
9851 }
9852 ios.width(25);
9853 right(ios);
9854 {
9855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9856 std::string ex(str, iter.base());
9857 assert(ex == "*************1234567890.1");
9858 assert(ios.width() == 0);
9859 }
9860 ios.width(25);
9861 internal(ios);
9862 {
9863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9864 std::string ex(str, iter.base());
9865 assert(ex == "*************1234567890.1");
9866 assert(ios.width() == 0);
9867 }
9868 }
9869 ios.imbue(lg);
9870 {
9871 ios.width(0);
9872 {
9873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9874 std::string ex(str, iter.base());
9875 assert(ex == "1_234_567_89_0;1");
9876 assert(ios.width() == 0);
9877 }
9878 ios.width(25);
9879 left(ios);
9880 {
9881 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9882 std::string ex(str, iter.base());
9883 assert(ex == "1_234_567_89_0;1*********");
9884 assert(ios.width() == 0);
9885 }
9886 ios.width(25);
9887 right(ios);
9888 {
9889 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9890 std::string ex(str, iter.base());
9891 assert(ex == "*********1_234_567_89_0;1");
9892 assert(ios.width() == 0);
9893 }
9894 ios.width(25);
9895 internal(ios);
9896 {
9897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9898 std::string ex(str, iter.base());
9899 assert(ex == "*********1_234_567_89_0;1");
9900 assert(ios.width() == 0);
9901 }
9902 }
9903 }
9904 showpoint(ios);
9905 {
9906 ios.imbue(lc);
9907 {
9908 ios.width(0);
9909 {
9910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9911 std::string ex(str, iter.base());
9912 assert(ex == "1234567890.1");
9913 assert(ios.width() == 0);
9914 }
9915 ios.width(25);
9916 left(ios);
9917 {
9918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9919 std::string ex(str, iter.base());
9920 assert(ex == "1234567890.1*************");
9921 assert(ios.width() == 0);
9922 }
9923 ios.width(25);
9924 right(ios);
9925 {
9926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9927 std::string ex(str, iter.base());
9928 assert(ex == "*************1234567890.1");
9929 assert(ios.width() == 0);
9930 }
9931 ios.width(25);
9932 internal(ios);
9933 {
9934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9935 std::string ex(str, iter.base());
9936 assert(ex == "*************1234567890.1");
9937 assert(ios.width() == 0);
9938 }
9939 }
9940 ios.imbue(lg);
9941 {
9942 ios.width(0);
9943 {
9944 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9945 std::string ex(str, iter.base());
9946 assert(ex == "1_234_567_89_0;1");
9947 assert(ios.width() == 0);
9948 }
9949 ios.width(25);
9950 left(ios);
9951 {
9952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9953 std::string ex(str, iter.base());
9954 assert(ex == "1_234_567_89_0;1*********");
9955 assert(ios.width() == 0);
9956 }
9957 ios.width(25);
9958 right(ios);
9959 {
9960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9961 std::string ex(str, iter.base());
9962 assert(ex == "*********1_234_567_89_0;1");
9963 assert(ios.width() == 0);
9964 }
9965 ios.width(25);
9966 internal(ios);
9967 {
9968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9969 std::string ex(str, iter.base());
9970 assert(ex == "*********1_234_567_89_0;1");
9971 assert(ios.width() == 0);
9972 }
9973 }
9974 }
9975 }
9976 showpos(ios);
9977 {
9978 noshowpoint(ios);
9979 {
9980 ios.imbue(lc);
9981 {
9982 ios.width(0);
9983 {
9984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9985 std::string ex(str, iter.base());
9986 assert(ex == "+1234567890.1");
9987 assert(ios.width() == 0);
9988 }
9989 ios.width(25);
9990 left(ios);
9991 {
9992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9993 std::string ex(str, iter.base());
9994 assert(ex == "+1234567890.1************");
9995 assert(ios.width() == 0);
9996 }
9997 ios.width(25);
9998 right(ios);
9999 {
10000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10001 std::string ex(str, iter.base());
10002 assert(ex == "************+1234567890.1");
10003 assert(ios.width() == 0);
10004 }
10005 ios.width(25);
10006 internal(ios);
10007 {
10008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10009 std::string ex(str, iter.base());
10010 assert(ex == "+************1234567890.1");
10011 assert(ios.width() == 0);
10012 }
10013 }
10014 ios.imbue(lg);
10015 {
10016 ios.width(0);
10017 {
10018 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10019 std::string ex(str, iter.base());
10020 assert(ex == "+1_234_567_89_0;1");
10021 assert(ios.width() == 0);
10022 }
10023 ios.width(25);
10024 left(ios);
10025 {
10026 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10027 std::string ex(str, iter.base());
10028 assert(ex == "+1_234_567_89_0;1********");
10029 assert(ios.width() == 0);
10030 }
10031 ios.width(25);
10032 right(ios);
10033 {
10034 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10035 std::string ex(str, iter.base());
10036 assert(ex == "********+1_234_567_89_0;1");
10037 assert(ios.width() == 0);
10038 }
10039 ios.width(25);
10040 internal(ios);
10041 {
10042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10043 std::string ex(str, iter.base());
10044 assert(ex == "+********1_234_567_89_0;1");
10045 assert(ios.width() == 0);
10046 }
10047 }
10048 }
10049 showpoint(ios);
10050 {
10051 ios.imbue(lc);
10052 {
10053 ios.width(0);
10054 {
10055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10056 std::string ex(str, iter.base());
10057 assert(ex == "+1234567890.1");
10058 assert(ios.width() == 0);
10059 }
10060 ios.width(25);
10061 left(ios);
10062 {
10063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10064 std::string ex(str, iter.base());
10065 assert(ex == "+1234567890.1************");
10066 assert(ios.width() == 0);
10067 }
10068 ios.width(25);
10069 right(ios);
10070 {
10071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10072 std::string ex(str, iter.base());
10073 assert(ex == "************+1234567890.1");
10074 assert(ios.width() == 0);
10075 }
10076 ios.width(25);
10077 internal(ios);
10078 {
10079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10080 std::string ex(str, iter.base());
10081 assert(ex == "+************1234567890.1");
10082 assert(ios.width() == 0);
10083 }
10084 }
10085 ios.imbue(lg);
10086 {
10087 ios.width(0);
10088 {
10089 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10090 std::string ex(str, iter.base());
10091 assert(ex == "+1_234_567_89_0;1");
10092 assert(ios.width() == 0);
10093 }
10094 ios.width(25);
10095 left(ios);
10096 {
10097 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10098 std::string ex(str, iter.base());
10099 assert(ex == "+1_234_567_89_0;1********");
10100 assert(ios.width() == 0);
10101 }
10102 ios.width(25);
10103 right(ios);
10104 {
10105 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10106 std::string ex(str, iter.base());
10107 assert(ex == "********+1_234_567_89_0;1");
10108 assert(ios.width() == 0);
10109 }
10110 ios.width(25);
10111 internal(ios);
10112 {
10113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10114 std::string ex(str, iter.base());
10115 assert(ex == "+********1_234_567_89_0;1");
10116 assert(ios.width() == 0);
10117 }
10118 }
10119 }
10120 }
10121 }
10122 }
10123 ios.precision(6);
10124 {
10125 nouppercase(ios);
10126 {
10127 noshowpos(ios);
10128 {
10129 noshowpoint(ios);
10130 {
10131 ios.imbue(lc);
10132 {
10133 ios.width(0);
10134 {
10135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10136 std::string ex(str, iter.base());
10137 assert(ex == "1234567890.125000");
10138 assert(ios.width() == 0);
10139 }
10140 ios.width(25);
10141 left(ios);
10142 {
10143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10144 std::string ex(str, iter.base());
10145 assert(ex == "1234567890.125000********");
10146 assert(ios.width() == 0);
10147 }
10148 ios.width(25);
10149 right(ios);
10150 {
10151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10152 std::string ex(str, iter.base());
10153 assert(ex == "********1234567890.125000");
10154 assert(ios.width() == 0);
10155 }
10156 ios.width(25);
10157 internal(ios);
10158 {
10159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10160 std::string ex(str, iter.base());
10161 assert(ex == "********1234567890.125000");
10162 assert(ios.width() == 0);
10163 }
10164 }
10165 ios.imbue(lg);
10166 {
10167 ios.width(0);
10168 {
10169 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10170 std::string ex(str, iter.base());
10171 assert(ex == "1_234_567_89_0;125000");
10172 assert(ios.width() == 0);
10173 }
10174 ios.width(25);
10175 left(ios);
10176 {
10177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10178 std::string ex(str, iter.base());
10179 assert(ex == "1_234_567_89_0;125000****");
10180 assert(ios.width() == 0);
10181 }
10182 ios.width(25);
10183 right(ios);
10184 {
10185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10186 std::string ex(str, iter.base());
10187 assert(ex == "****1_234_567_89_0;125000");
10188 assert(ios.width() == 0);
10189 }
10190 ios.width(25);
10191 internal(ios);
10192 {
10193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10194 std::string ex(str, iter.base());
10195 assert(ex == "****1_234_567_89_0;125000");
10196 assert(ios.width() == 0);
10197 }
10198 }
10199 }
10200 showpoint(ios);
10201 {
10202 ios.imbue(lc);
10203 {
10204 ios.width(0);
10205 {
10206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10207 std::string ex(str, iter.base());
10208 assert(ex == "1234567890.125000");
10209 assert(ios.width() == 0);
10210 }
10211 ios.width(25);
10212 left(ios);
10213 {
10214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10215 std::string ex(str, iter.base());
10216 assert(ex == "1234567890.125000********");
10217 assert(ios.width() == 0);
10218 }
10219 ios.width(25);
10220 right(ios);
10221 {
10222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10223 std::string ex(str, iter.base());
10224 assert(ex == "********1234567890.125000");
10225 assert(ios.width() == 0);
10226 }
10227 ios.width(25);
10228 internal(ios);
10229 {
10230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10231 std::string ex(str, iter.base());
10232 assert(ex == "********1234567890.125000");
10233 assert(ios.width() == 0);
10234 }
10235 }
10236 ios.imbue(lg);
10237 {
10238 ios.width(0);
10239 {
10240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10241 std::string ex(str, iter.base());
10242 assert(ex == "1_234_567_89_0;125000");
10243 assert(ios.width() == 0);
10244 }
10245 ios.width(25);
10246 left(ios);
10247 {
10248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10249 std::string ex(str, iter.base());
10250 assert(ex == "1_234_567_89_0;125000****");
10251 assert(ios.width() == 0);
10252 }
10253 ios.width(25);
10254 right(ios);
10255 {
10256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10257 std::string ex(str, iter.base());
10258 assert(ex == "****1_234_567_89_0;125000");
10259 assert(ios.width() == 0);
10260 }
10261 ios.width(25);
10262 internal(ios);
10263 {
10264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10265 std::string ex(str, iter.base());
10266 assert(ex == "****1_234_567_89_0;125000");
10267 assert(ios.width() == 0);
10268 }
10269 }
10270 }
10271 }
10272 showpos(ios);
10273 {
10274 noshowpoint(ios);
10275 {
10276 ios.imbue(lc);
10277 {
10278 ios.width(0);
10279 {
10280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10281 std::string ex(str, iter.base());
10282 assert(ex == "+1234567890.125000");
10283 assert(ios.width() == 0);
10284 }
10285 ios.width(25);
10286 left(ios);
10287 {
10288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10289 std::string ex(str, iter.base());
10290 assert(ex == "+1234567890.125000*******");
10291 assert(ios.width() == 0);
10292 }
10293 ios.width(25);
10294 right(ios);
10295 {
10296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10297 std::string ex(str, iter.base());
10298 assert(ex == "*******+1234567890.125000");
10299 assert(ios.width() == 0);
10300 }
10301 ios.width(25);
10302 internal(ios);
10303 {
10304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10305 std::string ex(str, iter.base());
10306 assert(ex == "+*******1234567890.125000");
10307 assert(ios.width() == 0);
10308 }
10309 }
10310 ios.imbue(lg);
10311 {
10312 ios.width(0);
10313 {
10314 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10315 std::string ex(str, iter.base());
10316 assert(ex == "+1_234_567_89_0;125000");
10317 assert(ios.width() == 0);
10318 }
10319 ios.width(25);
10320 left(ios);
10321 {
10322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10323 std::string ex(str, iter.base());
10324 assert(ex == "+1_234_567_89_0;125000***");
10325 assert(ios.width() == 0);
10326 }
10327 ios.width(25);
10328 right(ios);
10329 {
10330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10331 std::string ex(str, iter.base());
10332 assert(ex == "***+1_234_567_89_0;125000");
10333 assert(ios.width() == 0);
10334 }
10335 ios.width(25);
10336 internal(ios);
10337 {
10338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10339 std::string ex(str, iter.base());
10340 assert(ex == "+***1_234_567_89_0;125000");
10341 assert(ios.width() == 0);
10342 }
10343 }
10344 }
10345 showpoint(ios);
10346 {
10347 ios.imbue(lc);
10348 {
10349 ios.width(0);
10350 {
10351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10352 std::string ex(str, iter.base());
10353 assert(ex == "+1234567890.125000");
10354 assert(ios.width() == 0);
10355 }
10356 ios.width(25);
10357 left(ios);
10358 {
10359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10360 std::string ex(str, iter.base());
10361 assert(ex == "+1234567890.125000*******");
10362 assert(ios.width() == 0);
10363 }
10364 ios.width(25);
10365 right(ios);
10366 {
10367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10368 std::string ex(str, iter.base());
10369 assert(ex == "*******+1234567890.125000");
10370 assert(ios.width() == 0);
10371 }
10372 ios.width(25);
10373 internal(ios);
10374 {
10375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10376 std::string ex(str, iter.base());
10377 assert(ex == "+*******1234567890.125000");
10378 assert(ios.width() == 0);
10379 }
10380 }
10381 ios.imbue(lg);
10382 {
10383 ios.width(0);
10384 {
10385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10386 std::string ex(str, iter.base());
10387 assert(ex == "+1_234_567_89_0;125000");
10388 assert(ios.width() == 0);
10389 }
10390 ios.width(25);
10391 left(ios);
10392 {
10393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10394 std::string ex(str, iter.base());
10395 assert(ex == "+1_234_567_89_0;125000***");
10396 assert(ios.width() == 0);
10397 }
10398 ios.width(25);
10399 right(ios);
10400 {
10401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10402 std::string ex(str, iter.base());
10403 assert(ex == "***+1_234_567_89_0;125000");
10404 assert(ios.width() == 0);
10405 }
10406 ios.width(25);
10407 internal(ios);
10408 {
10409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10410 std::string ex(str, iter.base());
10411 assert(ex == "+***1_234_567_89_0;125000");
10412 assert(ios.width() == 0);
10413 }
10414 }
10415 }
10416 }
10417 }
10418 uppercase(ios);
10419 {
10420 noshowpos(ios);
10421 {
10422 noshowpoint(ios);
10423 {
10424 ios.imbue(lc);
10425 {
10426 ios.width(0);
10427 {
10428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10429 std::string ex(str, iter.base());
10430 assert(ex == "1234567890.125000");
10431 assert(ios.width() == 0);
10432 }
10433 ios.width(25);
10434 left(ios);
10435 {
10436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10437 std::string ex(str, iter.base());
10438 assert(ex == "1234567890.125000********");
10439 assert(ios.width() == 0);
10440 }
10441 ios.width(25);
10442 right(ios);
10443 {
10444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10445 std::string ex(str, iter.base());
10446 assert(ex == "********1234567890.125000");
10447 assert(ios.width() == 0);
10448 }
10449 ios.width(25);
10450 internal(ios);
10451 {
10452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10453 std::string ex(str, iter.base());
10454 assert(ex == "********1234567890.125000");
10455 assert(ios.width() == 0);
10456 }
10457 }
10458 ios.imbue(lg);
10459 {
10460 ios.width(0);
10461 {
10462 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10463 std::string ex(str, iter.base());
10464 assert(ex == "1_234_567_89_0;125000");
10465 assert(ios.width() == 0);
10466 }
10467 ios.width(25);
10468 left(ios);
10469 {
10470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10471 std::string ex(str, iter.base());
10472 assert(ex == "1_234_567_89_0;125000****");
10473 assert(ios.width() == 0);
10474 }
10475 ios.width(25);
10476 right(ios);
10477 {
10478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10479 std::string ex(str, iter.base());
10480 assert(ex == "****1_234_567_89_0;125000");
10481 assert(ios.width() == 0);
10482 }
10483 ios.width(25);
10484 internal(ios);
10485 {
10486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10487 std::string ex(str, iter.base());
10488 assert(ex == "****1_234_567_89_0;125000");
10489 assert(ios.width() == 0);
10490 }
10491 }
10492 }
10493 showpoint(ios);
10494 {
10495 ios.imbue(lc);
10496 {
10497 ios.width(0);
10498 {
10499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10500 std::string ex(str, iter.base());
10501 assert(ex == "1234567890.125000");
10502 assert(ios.width() == 0);
10503 }
10504 ios.width(25);
10505 left(ios);
10506 {
10507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10508 std::string ex(str, iter.base());
10509 assert(ex == "1234567890.125000********");
10510 assert(ios.width() == 0);
10511 }
10512 ios.width(25);
10513 right(ios);
10514 {
10515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10516 std::string ex(str, iter.base());
10517 assert(ex == "********1234567890.125000");
10518 assert(ios.width() == 0);
10519 }
10520 ios.width(25);
10521 internal(ios);
10522 {
10523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10524 std::string ex(str, iter.base());
10525 assert(ex == "********1234567890.125000");
10526 assert(ios.width() == 0);
10527 }
10528 }
10529 ios.imbue(lg);
10530 {
10531 ios.width(0);
10532 {
10533 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10534 std::string ex(str, iter.base());
10535 assert(ex == "1_234_567_89_0;125000");
10536 assert(ios.width() == 0);
10537 }
10538 ios.width(25);
10539 left(ios);
10540 {
10541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10542 std::string ex(str, iter.base());
10543 assert(ex == "1_234_567_89_0;125000****");
10544 assert(ios.width() == 0);
10545 }
10546 ios.width(25);
10547 right(ios);
10548 {
10549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10550 std::string ex(str, iter.base());
10551 assert(ex == "****1_234_567_89_0;125000");
10552 assert(ios.width() == 0);
10553 }
10554 ios.width(25);
10555 internal(ios);
10556 {
10557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10558 std::string ex(str, iter.base());
10559 assert(ex == "****1_234_567_89_0;125000");
10560 assert(ios.width() == 0);
10561 }
10562 }
10563 }
10564 }
10565 showpos(ios);
10566 {
10567 noshowpoint(ios);
10568 {
10569 ios.imbue(lc);
10570 {
10571 ios.width(0);
10572 {
10573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10574 std::string ex(str, iter.base());
10575 assert(ex == "+1234567890.125000");
10576 assert(ios.width() == 0);
10577 }
10578 ios.width(25);
10579 left(ios);
10580 {
10581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10582 std::string ex(str, iter.base());
10583 assert(ex == "+1234567890.125000*******");
10584 assert(ios.width() == 0);
10585 }
10586 ios.width(25);
10587 right(ios);
10588 {
10589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10590 std::string ex(str, iter.base());
10591 assert(ex == "*******+1234567890.125000");
10592 assert(ios.width() == 0);
10593 }
10594 ios.width(25);
10595 internal(ios);
10596 {
10597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10598 std::string ex(str, iter.base());
10599 assert(ex == "+*******1234567890.125000");
10600 assert(ios.width() == 0);
10601 }
10602 }
10603 ios.imbue(lg);
10604 {
10605 ios.width(0);
10606 {
10607 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10608 std::string ex(str, iter.base());
10609 assert(ex == "+1_234_567_89_0;125000");
10610 assert(ios.width() == 0);
10611 }
10612 ios.width(25);
10613 left(ios);
10614 {
10615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10616 std::string ex(str, iter.base());
10617 assert(ex == "+1_234_567_89_0;125000***");
10618 assert(ios.width() == 0);
10619 }
10620 ios.width(25);
10621 right(ios);
10622 {
10623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10624 std::string ex(str, iter.base());
10625 assert(ex == "***+1_234_567_89_0;125000");
10626 assert(ios.width() == 0);
10627 }
10628 ios.width(25);
10629 internal(ios);
10630 {
10631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10632 std::string ex(str, iter.base());
10633 assert(ex == "+***1_234_567_89_0;125000");
10634 assert(ios.width() == 0);
10635 }
10636 }
10637 }
10638 showpoint(ios);
10639 {
10640 ios.imbue(lc);
10641 {
10642 ios.width(0);
10643 {
10644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10645 std::string ex(str, iter.base());
10646 assert(ex == "+1234567890.125000");
10647 assert(ios.width() == 0);
10648 }
10649 ios.width(25);
10650 left(ios);
10651 {
10652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10653 std::string ex(str, iter.base());
10654 assert(ex == "+1234567890.125000*******");
10655 assert(ios.width() == 0);
10656 }
10657 ios.width(25);
10658 right(ios);
10659 {
10660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10661 std::string ex(str, iter.base());
10662 assert(ex == "*******+1234567890.125000");
10663 assert(ios.width() == 0);
10664 }
10665 ios.width(25);
10666 internal(ios);
10667 {
10668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10669 std::string ex(str, iter.base());
10670 assert(ex == "+*******1234567890.125000");
10671 assert(ios.width() == 0);
10672 }
10673 }
10674 ios.imbue(lg);
10675 {
10676 ios.width(0);
10677 {
10678 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10679 std::string ex(str, iter.base());
10680 assert(ex == "+1_234_567_89_0;125000");
10681 assert(ios.width() == 0);
10682 }
10683 ios.width(25);
10684 left(ios);
10685 {
10686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10687 std::string ex(str, iter.base());
10688 assert(ex == "+1_234_567_89_0;125000***");
10689 assert(ios.width() == 0);
10690 }
10691 ios.width(25);
10692 right(ios);
10693 {
10694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10695 std::string ex(str, iter.base());
10696 assert(ex == "***+1_234_567_89_0;125000");
10697 assert(ios.width() == 0);
10698 }
10699 ios.width(25);
10700 internal(ios);
10701 {
10702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10703 std::string ex(str, iter.base());
10704 assert(ex == "+***1_234_567_89_0;125000");
10705 assert(ios.width() == 0);
10706 }
10707 }
10708 }
10709 }
10710 }
10711 }
10712 ios.precision(16);
10713 {}
10714 ios.precision(60);
10715 {}
10716 }
10717 }
10718 }
10719
test5()10720 void test5()
10721 {
10722 char str[200];
10723 output_iterator<char*> iter;
10724 std::locale lc = std::locale::classic();
10725 std::locale lg(lc, new my_numpunct);
10726 const my_facet f(1);
10727 {
10728 double v = -0.;
10729 std::ios ios(0);
10730 scientific(ios);
10731 // %e
10732 {
10733 ios.precision(0);
10734 {
10735 nouppercase(ios);
10736 {
10737 noshowpos(ios);
10738 {
10739 noshowpoint(ios);
10740 {
10741 ios.imbue(lc);
10742 {
10743 ios.width(0);
10744 {
10745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10746 std::string ex(str, iter.base());
10747 assert(ex == "-0e+00");
10748 assert(ios.width() == 0);
10749 }
10750 ios.width(25);
10751 left(ios);
10752 {
10753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10754 std::string ex(str, iter.base());
10755 assert(ex == "-0e+00*******************");
10756 assert(ios.width() == 0);
10757 }
10758 ios.width(25);
10759 right(ios);
10760 {
10761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10762 std::string ex(str, iter.base());
10763 assert(ex == "*******************-0e+00");
10764 assert(ios.width() == 0);
10765 }
10766 ios.width(25);
10767 internal(ios);
10768 {
10769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10770 std::string ex(str, iter.base());
10771 assert(ex == "-*******************0e+00");
10772 assert(ios.width() == 0);
10773 }
10774 }
10775 ios.imbue(lg);
10776 {
10777 ios.width(0);
10778 {
10779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10780 std::string ex(str, iter.base());
10781 assert(ex == "-0e+00");
10782 assert(ios.width() == 0);
10783 }
10784 ios.width(25);
10785 left(ios);
10786 {
10787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10788 std::string ex(str, iter.base());
10789 assert(ex == "-0e+00*******************");
10790 assert(ios.width() == 0);
10791 }
10792 ios.width(25);
10793 right(ios);
10794 {
10795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10796 std::string ex(str, iter.base());
10797 assert(ex == "*******************-0e+00");
10798 assert(ios.width() == 0);
10799 }
10800 ios.width(25);
10801 internal(ios);
10802 {
10803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10804 std::string ex(str, iter.base());
10805 assert(ex == "-*******************0e+00");
10806 assert(ios.width() == 0);
10807 }
10808 }
10809 }
10810 showpoint(ios);
10811 {
10812 ios.imbue(lc);
10813 {
10814 ios.width(0);
10815 {
10816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10817 std::string ex(str, iter.base());
10818 assert(ex == "-0.e+00");
10819 assert(ios.width() == 0);
10820 }
10821 ios.width(25);
10822 left(ios);
10823 {
10824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10825 std::string ex(str, iter.base());
10826 assert(ex == "-0.e+00******************");
10827 assert(ios.width() == 0);
10828 }
10829 ios.width(25);
10830 right(ios);
10831 {
10832 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10833 std::string ex(str, iter.base());
10834 assert(ex == "******************-0.e+00");
10835 assert(ios.width() == 0);
10836 }
10837 ios.width(25);
10838 internal(ios);
10839 {
10840 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10841 std::string ex(str, iter.base());
10842 assert(ex == "-******************0.e+00");
10843 assert(ios.width() == 0);
10844 }
10845 }
10846 ios.imbue(lg);
10847 {
10848 ios.width(0);
10849 {
10850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10851 std::string ex(str, iter.base());
10852 assert(ex == "-0;e+00");
10853 assert(ios.width() == 0);
10854 }
10855 ios.width(25);
10856 left(ios);
10857 {
10858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10859 std::string ex(str, iter.base());
10860 assert(ex == "-0;e+00******************");
10861 assert(ios.width() == 0);
10862 }
10863 ios.width(25);
10864 right(ios);
10865 {
10866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10867 std::string ex(str, iter.base());
10868 assert(ex == "******************-0;e+00");
10869 assert(ios.width() == 0);
10870 }
10871 ios.width(25);
10872 internal(ios);
10873 {
10874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10875 std::string ex(str, iter.base());
10876 assert(ex == "-******************0;e+00");
10877 assert(ios.width() == 0);
10878 }
10879 }
10880 }
10881 }
10882 showpos(ios);
10883 {
10884 noshowpoint(ios);
10885 {
10886 ios.imbue(lc);
10887 {
10888 ios.width(0);
10889 {
10890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10891 std::string ex(str, iter.base());
10892 assert(ex == "-0e+00");
10893 assert(ios.width() == 0);
10894 }
10895 ios.width(25);
10896 left(ios);
10897 {
10898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10899 std::string ex(str, iter.base());
10900 assert(ex == "-0e+00*******************");
10901 assert(ios.width() == 0);
10902 }
10903 ios.width(25);
10904 right(ios);
10905 {
10906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10907 std::string ex(str, iter.base());
10908 assert(ex == "*******************-0e+00");
10909 assert(ios.width() == 0);
10910 }
10911 ios.width(25);
10912 internal(ios);
10913 {
10914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10915 std::string ex(str, iter.base());
10916 assert(ex == "-*******************0e+00");
10917 assert(ios.width() == 0);
10918 }
10919 }
10920 ios.imbue(lg);
10921 {
10922 ios.width(0);
10923 {
10924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10925 std::string ex(str, iter.base());
10926 assert(ex == "-0e+00");
10927 assert(ios.width() == 0);
10928 }
10929 ios.width(25);
10930 left(ios);
10931 {
10932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10933 std::string ex(str, iter.base());
10934 assert(ex == "-0e+00*******************");
10935 assert(ios.width() == 0);
10936 }
10937 ios.width(25);
10938 right(ios);
10939 {
10940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10941 std::string ex(str, iter.base());
10942 assert(ex == "*******************-0e+00");
10943 assert(ios.width() == 0);
10944 }
10945 ios.width(25);
10946 internal(ios);
10947 {
10948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10949 std::string ex(str, iter.base());
10950 assert(ex == "-*******************0e+00");
10951 assert(ios.width() == 0);
10952 }
10953 }
10954 }
10955 showpoint(ios);
10956 {
10957 ios.imbue(lc);
10958 {
10959 ios.width(0);
10960 {
10961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10962 std::string ex(str, iter.base());
10963 assert(ex == "-0.e+00");
10964 assert(ios.width() == 0);
10965 }
10966 ios.width(25);
10967 left(ios);
10968 {
10969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10970 std::string ex(str, iter.base());
10971 assert(ex == "-0.e+00******************");
10972 assert(ios.width() == 0);
10973 }
10974 ios.width(25);
10975 right(ios);
10976 {
10977 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10978 std::string ex(str, iter.base());
10979 assert(ex == "******************-0.e+00");
10980 assert(ios.width() == 0);
10981 }
10982 ios.width(25);
10983 internal(ios);
10984 {
10985 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10986 std::string ex(str, iter.base());
10987 assert(ex == "-******************0.e+00");
10988 assert(ios.width() == 0);
10989 }
10990 }
10991 ios.imbue(lg);
10992 {
10993 ios.width(0);
10994 {
10995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10996 std::string ex(str, iter.base());
10997 assert(ex == "-0;e+00");
10998 assert(ios.width() == 0);
10999 }
11000 ios.width(25);
11001 left(ios);
11002 {
11003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11004 std::string ex(str, iter.base());
11005 assert(ex == "-0;e+00******************");
11006 assert(ios.width() == 0);
11007 }
11008 ios.width(25);
11009 right(ios);
11010 {
11011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11012 std::string ex(str, iter.base());
11013 assert(ex == "******************-0;e+00");
11014 assert(ios.width() == 0);
11015 }
11016 ios.width(25);
11017 internal(ios);
11018 {
11019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11020 std::string ex(str, iter.base());
11021 assert(ex == "-******************0;e+00");
11022 assert(ios.width() == 0);
11023 }
11024 }
11025 }
11026 }
11027 }
11028 uppercase(ios);
11029 {
11030 noshowpos(ios);
11031 {
11032 noshowpoint(ios);
11033 {
11034 ios.imbue(lc);
11035 {
11036 ios.width(0);
11037 {
11038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11039 std::string ex(str, iter.base());
11040 assert(ex == "-0E+00");
11041 assert(ios.width() == 0);
11042 }
11043 ios.width(25);
11044 left(ios);
11045 {
11046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11047 std::string ex(str, iter.base());
11048 assert(ex == "-0E+00*******************");
11049 assert(ios.width() == 0);
11050 }
11051 ios.width(25);
11052 right(ios);
11053 {
11054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11055 std::string ex(str, iter.base());
11056 assert(ex == "*******************-0E+00");
11057 assert(ios.width() == 0);
11058 }
11059 ios.width(25);
11060 internal(ios);
11061 {
11062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11063 std::string ex(str, iter.base());
11064 assert(ex == "-*******************0E+00");
11065 assert(ios.width() == 0);
11066 }
11067 }
11068 ios.imbue(lg);
11069 {
11070 ios.width(0);
11071 {
11072 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11073 std::string ex(str, iter.base());
11074 assert(ex == "-0E+00");
11075 assert(ios.width() == 0);
11076 }
11077 ios.width(25);
11078 left(ios);
11079 {
11080 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11081 std::string ex(str, iter.base());
11082 assert(ex == "-0E+00*******************");
11083 assert(ios.width() == 0);
11084 }
11085 ios.width(25);
11086 right(ios);
11087 {
11088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11089 std::string ex(str, iter.base());
11090 assert(ex == "*******************-0E+00");
11091 assert(ios.width() == 0);
11092 }
11093 ios.width(25);
11094 internal(ios);
11095 {
11096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11097 std::string ex(str, iter.base());
11098 assert(ex == "-*******************0E+00");
11099 assert(ios.width() == 0);
11100 }
11101 }
11102 }
11103 showpoint(ios);
11104 {
11105 ios.imbue(lc);
11106 {
11107 ios.width(0);
11108 {
11109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11110 std::string ex(str, iter.base());
11111 assert(ex == "-0.E+00");
11112 assert(ios.width() == 0);
11113 }
11114 ios.width(25);
11115 left(ios);
11116 {
11117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11118 std::string ex(str, iter.base());
11119 assert(ex == "-0.E+00******************");
11120 assert(ios.width() == 0);
11121 }
11122 ios.width(25);
11123 right(ios);
11124 {
11125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11126 std::string ex(str, iter.base());
11127 assert(ex == "******************-0.E+00");
11128 assert(ios.width() == 0);
11129 }
11130 ios.width(25);
11131 internal(ios);
11132 {
11133 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11134 std::string ex(str, iter.base());
11135 assert(ex == "-******************0.E+00");
11136 assert(ios.width() == 0);
11137 }
11138 }
11139 ios.imbue(lg);
11140 {
11141 ios.width(0);
11142 {
11143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11144 std::string ex(str, iter.base());
11145 assert(ex == "-0;E+00");
11146 assert(ios.width() == 0);
11147 }
11148 ios.width(25);
11149 left(ios);
11150 {
11151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11152 std::string ex(str, iter.base());
11153 assert(ex == "-0;E+00******************");
11154 assert(ios.width() == 0);
11155 }
11156 ios.width(25);
11157 right(ios);
11158 {
11159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11160 std::string ex(str, iter.base());
11161 assert(ex == "******************-0;E+00");
11162 assert(ios.width() == 0);
11163 }
11164 ios.width(25);
11165 internal(ios);
11166 {
11167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11168 std::string ex(str, iter.base());
11169 assert(ex == "-******************0;E+00");
11170 assert(ios.width() == 0);
11171 }
11172 }
11173 }
11174 }
11175 showpos(ios);
11176 {
11177 noshowpoint(ios);
11178 {
11179 ios.imbue(lc);
11180 {
11181 ios.width(0);
11182 {
11183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11184 std::string ex(str, iter.base());
11185 assert(ex == "-0E+00");
11186 assert(ios.width() == 0);
11187 }
11188 ios.width(25);
11189 left(ios);
11190 {
11191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11192 std::string ex(str, iter.base());
11193 assert(ex == "-0E+00*******************");
11194 assert(ios.width() == 0);
11195 }
11196 ios.width(25);
11197 right(ios);
11198 {
11199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11200 std::string ex(str, iter.base());
11201 assert(ex == "*******************-0E+00");
11202 assert(ios.width() == 0);
11203 }
11204 ios.width(25);
11205 internal(ios);
11206 {
11207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11208 std::string ex(str, iter.base());
11209 assert(ex == "-*******************0E+00");
11210 assert(ios.width() == 0);
11211 }
11212 }
11213 ios.imbue(lg);
11214 {
11215 ios.width(0);
11216 {
11217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11218 std::string ex(str, iter.base());
11219 assert(ex == "-0E+00");
11220 assert(ios.width() == 0);
11221 }
11222 ios.width(25);
11223 left(ios);
11224 {
11225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11226 std::string ex(str, iter.base());
11227 assert(ex == "-0E+00*******************");
11228 assert(ios.width() == 0);
11229 }
11230 ios.width(25);
11231 right(ios);
11232 {
11233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11234 std::string ex(str, iter.base());
11235 assert(ex == "*******************-0E+00");
11236 assert(ios.width() == 0);
11237 }
11238 ios.width(25);
11239 internal(ios);
11240 {
11241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11242 std::string ex(str, iter.base());
11243 assert(ex == "-*******************0E+00");
11244 assert(ios.width() == 0);
11245 }
11246 }
11247 }
11248 showpoint(ios);
11249 {
11250 ios.imbue(lc);
11251 {
11252 ios.width(0);
11253 {
11254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11255 std::string ex(str, iter.base());
11256 assert(ex == "-0.E+00");
11257 assert(ios.width() == 0);
11258 }
11259 ios.width(25);
11260 left(ios);
11261 {
11262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11263 std::string ex(str, iter.base());
11264 assert(ex == "-0.E+00******************");
11265 assert(ios.width() == 0);
11266 }
11267 ios.width(25);
11268 right(ios);
11269 {
11270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11271 std::string ex(str, iter.base());
11272 assert(ex == "******************-0.E+00");
11273 assert(ios.width() == 0);
11274 }
11275 ios.width(25);
11276 internal(ios);
11277 {
11278 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11279 std::string ex(str, iter.base());
11280 assert(ex == "-******************0.E+00");
11281 assert(ios.width() == 0);
11282 }
11283 }
11284 ios.imbue(lg);
11285 {
11286 ios.width(0);
11287 {
11288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11289 std::string ex(str, iter.base());
11290 assert(ex == "-0;E+00");
11291 assert(ios.width() == 0);
11292 }
11293 ios.width(25);
11294 left(ios);
11295 {
11296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11297 std::string ex(str, iter.base());
11298 assert(ex == "-0;E+00******************");
11299 assert(ios.width() == 0);
11300 }
11301 ios.width(25);
11302 right(ios);
11303 {
11304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11305 std::string ex(str, iter.base());
11306 assert(ex == "******************-0;E+00");
11307 assert(ios.width() == 0);
11308 }
11309 ios.width(25);
11310 internal(ios);
11311 {
11312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11313 std::string ex(str, iter.base());
11314 assert(ex == "-******************0;E+00");
11315 assert(ios.width() == 0);
11316 }
11317 }
11318 }
11319 }
11320 }
11321 }
11322 ios.precision(1);
11323 {
11324 nouppercase(ios);
11325 {
11326 noshowpos(ios);
11327 {
11328 noshowpoint(ios);
11329 {
11330 ios.imbue(lc);
11331 {
11332 ios.width(0);
11333 {
11334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11335 std::string ex(str, iter.base());
11336 assert(ex == "-0.0e+00");
11337 assert(ios.width() == 0);
11338 }
11339 ios.width(25);
11340 left(ios);
11341 {
11342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11343 std::string ex(str, iter.base());
11344 assert(ex == "-0.0e+00*****************");
11345 assert(ios.width() == 0);
11346 }
11347 ios.width(25);
11348 right(ios);
11349 {
11350 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11351 std::string ex(str, iter.base());
11352 assert(ex == "*****************-0.0e+00");
11353 assert(ios.width() == 0);
11354 }
11355 ios.width(25);
11356 internal(ios);
11357 {
11358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11359 std::string ex(str, iter.base());
11360 assert(ex == "-*****************0.0e+00");
11361 assert(ios.width() == 0);
11362 }
11363 }
11364 ios.imbue(lg);
11365 {
11366 ios.width(0);
11367 {
11368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11369 std::string ex(str, iter.base());
11370 assert(ex == "-0;0e+00");
11371 assert(ios.width() == 0);
11372 }
11373 ios.width(25);
11374 left(ios);
11375 {
11376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11377 std::string ex(str, iter.base());
11378 assert(ex == "-0;0e+00*****************");
11379 assert(ios.width() == 0);
11380 }
11381 ios.width(25);
11382 right(ios);
11383 {
11384 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11385 std::string ex(str, iter.base());
11386 assert(ex == "*****************-0;0e+00");
11387 assert(ios.width() == 0);
11388 }
11389 ios.width(25);
11390 internal(ios);
11391 {
11392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11393 std::string ex(str, iter.base());
11394 assert(ex == "-*****************0;0e+00");
11395 assert(ios.width() == 0);
11396 }
11397 }
11398 }
11399 showpoint(ios);
11400 {
11401 ios.imbue(lc);
11402 {
11403 ios.width(0);
11404 {
11405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11406 std::string ex(str, iter.base());
11407 assert(ex == "-0.0e+00");
11408 assert(ios.width() == 0);
11409 }
11410 ios.width(25);
11411 left(ios);
11412 {
11413 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11414 std::string ex(str, iter.base());
11415 assert(ex == "-0.0e+00*****************");
11416 assert(ios.width() == 0);
11417 }
11418 ios.width(25);
11419 right(ios);
11420 {
11421 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11422 std::string ex(str, iter.base());
11423 assert(ex == "*****************-0.0e+00");
11424 assert(ios.width() == 0);
11425 }
11426 ios.width(25);
11427 internal(ios);
11428 {
11429 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11430 std::string ex(str, iter.base());
11431 assert(ex == "-*****************0.0e+00");
11432 assert(ios.width() == 0);
11433 }
11434 }
11435 ios.imbue(lg);
11436 {
11437 ios.width(0);
11438 {
11439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11440 std::string ex(str, iter.base());
11441 assert(ex == "-0;0e+00");
11442 assert(ios.width() == 0);
11443 }
11444 ios.width(25);
11445 left(ios);
11446 {
11447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11448 std::string ex(str, iter.base());
11449 assert(ex == "-0;0e+00*****************");
11450 assert(ios.width() == 0);
11451 }
11452 ios.width(25);
11453 right(ios);
11454 {
11455 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11456 std::string ex(str, iter.base());
11457 assert(ex == "*****************-0;0e+00");
11458 assert(ios.width() == 0);
11459 }
11460 ios.width(25);
11461 internal(ios);
11462 {
11463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11464 std::string ex(str, iter.base());
11465 assert(ex == "-*****************0;0e+00");
11466 assert(ios.width() == 0);
11467 }
11468 }
11469 }
11470 }
11471 showpos(ios);
11472 {
11473 noshowpoint(ios);
11474 {
11475 ios.imbue(lc);
11476 {
11477 ios.width(0);
11478 {
11479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11480 std::string ex(str, iter.base());
11481 assert(ex == "-0.0e+00");
11482 assert(ios.width() == 0);
11483 }
11484 ios.width(25);
11485 left(ios);
11486 {
11487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11488 std::string ex(str, iter.base());
11489 assert(ex == "-0.0e+00*****************");
11490 assert(ios.width() == 0);
11491 }
11492 ios.width(25);
11493 right(ios);
11494 {
11495 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11496 std::string ex(str, iter.base());
11497 assert(ex == "*****************-0.0e+00");
11498 assert(ios.width() == 0);
11499 }
11500 ios.width(25);
11501 internal(ios);
11502 {
11503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11504 std::string ex(str, iter.base());
11505 assert(ex == "-*****************0.0e+00");
11506 assert(ios.width() == 0);
11507 }
11508 }
11509 ios.imbue(lg);
11510 {
11511 ios.width(0);
11512 {
11513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11514 std::string ex(str, iter.base());
11515 assert(ex == "-0;0e+00");
11516 assert(ios.width() == 0);
11517 }
11518 ios.width(25);
11519 left(ios);
11520 {
11521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11522 std::string ex(str, iter.base());
11523 assert(ex == "-0;0e+00*****************");
11524 assert(ios.width() == 0);
11525 }
11526 ios.width(25);
11527 right(ios);
11528 {
11529 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11530 std::string ex(str, iter.base());
11531 assert(ex == "*****************-0;0e+00");
11532 assert(ios.width() == 0);
11533 }
11534 ios.width(25);
11535 internal(ios);
11536 {
11537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11538 std::string ex(str, iter.base());
11539 assert(ex == "-*****************0;0e+00");
11540 assert(ios.width() == 0);
11541 }
11542 }
11543 }
11544 showpoint(ios);
11545 {
11546 ios.imbue(lc);
11547 {
11548 ios.width(0);
11549 {
11550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11551 std::string ex(str, iter.base());
11552 assert(ex == "-0.0e+00");
11553 assert(ios.width() == 0);
11554 }
11555 ios.width(25);
11556 left(ios);
11557 {
11558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11559 std::string ex(str, iter.base());
11560 assert(ex == "-0.0e+00*****************");
11561 assert(ios.width() == 0);
11562 }
11563 ios.width(25);
11564 right(ios);
11565 {
11566 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11567 std::string ex(str, iter.base());
11568 assert(ex == "*****************-0.0e+00");
11569 assert(ios.width() == 0);
11570 }
11571 ios.width(25);
11572 internal(ios);
11573 {
11574 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11575 std::string ex(str, iter.base());
11576 assert(ex == "-*****************0.0e+00");
11577 assert(ios.width() == 0);
11578 }
11579 }
11580 ios.imbue(lg);
11581 {
11582 ios.width(0);
11583 {
11584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11585 std::string ex(str, iter.base());
11586 assert(ex == "-0;0e+00");
11587 assert(ios.width() == 0);
11588 }
11589 ios.width(25);
11590 left(ios);
11591 {
11592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11593 std::string ex(str, iter.base());
11594 assert(ex == "-0;0e+00*****************");
11595 assert(ios.width() == 0);
11596 }
11597 ios.width(25);
11598 right(ios);
11599 {
11600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11601 std::string ex(str, iter.base());
11602 assert(ex == "*****************-0;0e+00");
11603 assert(ios.width() == 0);
11604 }
11605 ios.width(25);
11606 internal(ios);
11607 {
11608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11609 std::string ex(str, iter.base());
11610 assert(ex == "-*****************0;0e+00");
11611 assert(ios.width() == 0);
11612 }
11613 }
11614 }
11615 }
11616 }
11617 uppercase(ios);
11618 {
11619 noshowpos(ios);
11620 {
11621 noshowpoint(ios);
11622 {
11623 ios.imbue(lc);
11624 {
11625 ios.width(0);
11626 {
11627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11628 std::string ex(str, iter.base());
11629 assert(ex == "-0.0E+00");
11630 assert(ios.width() == 0);
11631 }
11632 ios.width(25);
11633 left(ios);
11634 {
11635 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11636 std::string ex(str, iter.base());
11637 assert(ex == "-0.0E+00*****************");
11638 assert(ios.width() == 0);
11639 }
11640 ios.width(25);
11641 right(ios);
11642 {
11643 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11644 std::string ex(str, iter.base());
11645 assert(ex == "*****************-0.0E+00");
11646 assert(ios.width() == 0);
11647 }
11648 ios.width(25);
11649 internal(ios);
11650 {
11651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11652 std::string ex(str, iter.base());
11653 assert(ex == "-*****************0.0E+00");
11654 assert(ios.width() == 0);
11655 }
11656 }
11657 ios.imbue(lg);
11658 {
11659 ios.width(0);
11660 {
11661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11662 std::string ex(str, iter.base());
11663 assert(ex == "-0;0E+00");
11664 assert(ios.width() == 0);
11665 }
11666 ios.width(25);
11667 left(ios);
11668 {
11669 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11670 std::string ex(str, iter.base());
11671 assert(ex == "-0;0E+00*****************");
11672 assert(ios.width() == 0);
11673 }
11674 ios.width(25);
11675 right(ios);
11676 {
11677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11678 std::string ex(str, iter.base());
11679 assert(ex == "*****************-0;0E+00");
11680 assert(ios.width() == 0);
11681 }
11682 ios.width(25);
11683 internal(ios);
11684 {
11685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11686 std::string ex(str, iter.base());
11687 assert(ex == "-*****************0;0E+00");
11688 assert(ios.width() == 0);
11689 }
11690 }
11691 }
11692 showpoint(ios);
11693 {
11694 ios.imbue(lc);
11695 {
11696 ios.width(0);
11697 {
11698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11699 std::string ex(str, iter.base());
11700 assert(ex == "-0.0E+00");
11701 assert(ios.width() == 0);
11702 }
11703 ios.width(25);
11704 left(ios);
11705 {
11706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11707 std::string ex(str, iter.base());
11708 assert(ex == "-0.0E+00*****************");
11709 assert(ios.width() == 0);
11710 }
11711 ios.width(25);
11712 right(ios);
11713 {
11714 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11715 std::string ex(str, iter.base());
11716 assert(ex == "*****************-0.0E+00");
11717 assert(ios.width() == 0);
11718 }
11719 ios.width(25);
11720 internal(ios);
11721 {
11722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11723 std::string ex(str, iter.base());
11724 assert(ex == "-*****************0.0E+00");
11725 assert(ios.width() == 0);
11726 }
11727 }
11728 ios.imbue(lg);
11729 {
11730 ios.width(0);
11731 {
11732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11733 std::string ex(str, iter.base());
11734 assert(ex == "-0;0E+00");
11735 assert(ios.width() == 0);
11736 }
11737 ios.width(25);
11738 left(ios);
11739 {
11740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11741 std::string ex(str, iter.base());
11742 assert(ex == "-0;0E+00*****************");
11743 assert(ios.width() == 0);
11744 }
11745 ios.width(25);
11746 right(ios);
11747 {
11748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11749 std::string ex(str, iter.base());
11750 assert(ex == "*****************-0;0E+00");
11751 assert(ios.width() == 0);
11752 }
11753 ios.width(25);
11754 internal(ios);
11755 {
11756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11757 std::string ex(str, iter.base());
11758 assert(ex == "-*****************0;0E+00");
11759 assert(ios.width() == 0);
11760 }
11761 }
11762 }
11763 }
11764 showpos(ios);
11765 {
11766 noshowpoint(ios);
11767 {
11768 ios.imbue(lc);
11769 {
11770 ios.width(0);
11771 {
11772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11773 std::string ex(str, iter.base());
11774 assert(ex == "-0.0E+00");
11775 assert(ios.width() == 0);
11776 }
11777 ios.width(25);
11778 left(ios);
11779 {
11780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11781 std::string ex(str, iter.base());
11782 assert(ex == "-0.0E+00*****************");
11783 assert(ios.width() == 0);
11784 }
11785 ios.width(25);
11786 right(ios);
11787 {
11788 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11789 std::string ex(str, iter.base());
11790 assert(ex == "*****************-0.0E+00");
11791 assert(ios.width() == 0);
11792 }
11793 ios.width(25);
11794 internal(ios);
11795 {
11796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11797 std::string ex(str, iter.base());
11798 assert(ex == "-*****************0.0E+00");
11799 assert(ios.width() == 0);
11800 }
11801 }
11802 ios.imbue(lg);
11803 {
11804 ios.width(0);
11805 {
11806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11807 std::string ex(str, iter.base());
11808 assert(ex == "-0;0E+00");
11809 assert(ios.width() == 0);
11810 }
11811 ios.width(25);
11812 left(ios);
11813 {
11814 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11815 std::string ex(str, iter.base());
11816 assert(ex == "-0;0E+00*****************");
11817 assert(ios.width() == 0);
11818 }
11819 ios.width(25);
11820 right(ios);
11821 {
11822 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11823 std::string ex(str, iter.base());
11824 assert(ex == "*****************-0;0E+00");
11825 assert(ios.width() == 0);
11826 }
11827 ios.width(25);
11828 internal(ios);
11829 {
11830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11831 std::string ex(str, iter.base());
11832 assert(ex == "-*****************0;0E+00");
11833 assert(ios.width() == 0);
11834 }
11835 }
11836 }
11837 showpoint(ios);
11838 {
11839 ios.imbue(lc);
11840 {
11841 ios.width(0);
11842 {
11843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11844 std::string ex(str, iter.base());
11845 assert(ex == "-0.0E+00");
11846 assert(ios.width() == 0);
11847 }
11848 ios.width(25);
11849 left(ios);
11850 {
11851 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11852 std::string ex(str, iter.base());
11853 assert(ex == "-0.0E+00*****************");
11854 assert(ios.width() == 0);
11855 }
11856 ios.width(25);
11857 right(ios);
11858 {
11859 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11860 std::string ex(str, iter.base());
11861 assert(ex == "*****************-0.0E+00");
11862 assert(ios.width() == 0);
11863 }
11864 ios.width(25);
11865 internal(ios);
11866 {
11867 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11868 std::string ex(str, iter.base());
11869 assert(ex == "-*****************0.0E+00");
11870 assert(ios.width() == 0);
11871 }
11872 }
11873 ios.imbue(lg);
11874 {
11875 ios.width(0);
11876 {
11877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11878 std::string ex(str, iter.base());
11879 assert(ex == "-0;0E+00");
11880 assert(ios.width() == 0);
11881 }
11882 ios.width(25);
11883 left(ios);
11884 {
11885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11886 std::string ex(str, iter.base());
11887 assert(ex == "-0;0E+00*****************");
11888 assert(ios.width() == 0);
11889 }
11890 ios.width(25);
11891 right(ios);
11892 {
11893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11894 std::string ex(str, iter.base());
11895 assert(ex == "*****************-0;0E+00");
11896 assert(ios.width() == 0);
11897 }
11898 ios.width(25);
11899 internal(ios);
11900 {
11901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11902 std::string ex(str, iter.base());
11903 assert(ex == "-*****************0;0E+00");
11904 assert(ios.width() == 0);
11905 }
11906 }
11907 }
11908 }
11909 }
11910 }
11911 ios.precision(6);
11912 {
11913 nouppercase(ios);
11914 {
11915 noshowpos(ios);
11916 {
11917 noshowpoint(ios);
11918 {
11919 ios.imbue(lc);
11920 {
11921 ios.width(0);
11922 {
11923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11924 std::string ex(str, iter.base());
11925 assert(ex == "-0.000000e+00");
11926 assert(ios.width() == 0);
11927 }
11928 ios.width(25);
11929 left(ios);
11930 {
11931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11932 std::string ex(str, iter.base());
11933 assert(ex == "-0.000000e+00************");
11934 assert(ios.width() == 0);
11935 }
11936 ios.width(25);
11937 right(ios);
11938 {
11939 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11940 std::string ex(str, iter.base());
11941 assert(ex == "************-0.000000e+00");
11942 assert(ios.width() == 0);
11943 }
11944 ios.width(25);
11945 internal(ios);
11946 {
11947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11948 std::string ex(str, iter.base());
11949 assert(ex == "-************0.000000e+00");
11950 assert(ios.width() == 0);
11951 }
11952 }
11953 ios.imbue(lg);
11954 {
11955 ios.width(0);
11956 {
11957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11958 std::string ex(str, iter.base());
11959 assert(ex == "-0;000000e+00");
11960 assert(ios.width() == 0);
11961 }
11962 ios.width(25);
11963 left(ios);
11964 {
11965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11966 std::string ex(str, iter.base());
11967 assert(ex == "-0;000000e+00************");
11968 assert(ios.width() == 0);
11969 }
11970 ios.width(25);
11971 right(ios);
11972 {
11973 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11974 std::string ex(str, iter.base());
11975 assert(ex == "************-0;000000e+00");
11976 assert(ios.width() == 0);
11977 }
11978 ios.width(25);
11979 internal(ios);
11980 {
11981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11982 std::string ex(str, iter.base());
11983 assert(ex == "-************0;000000e+00");
11984 assert(ios.width() == 0);
11985 }
11986 }
11987 }
11988 showpoint(ios);
11989 {
11990 ios.imbue(lc);
11991 {
11992 ios.width(0);
11993 {
11994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11995 std::string ex(str, iter.base());
11996 assert(ex == "-0.000000e+00");
11997 assert(ios.width() == 0);
11998 }
11999 ios.width(25);
12000 left(ios);
12001 {
12002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12003 std::string ex(str, iter.base());
12004 assert(ex == "-0.000000e+00************");
12005 assert(ios.width() == 0);
12006 }
12007 ios.width(25);
12008 right(ios);
12009 {
12010 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12011 std::string ex(str, iter.base());
12012 assert(ex == "************-0.000000e+00");
12013 assert(ios.width() == 0);
12014 }
12015 ios.width(25);
12016 internal(ios);
12017 {
12018 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12019 std::string ex(str, iter.base());
12020 assert(ex == "-************0.000000e+00");
12021 assert(ios.width() == 0);
12022 }
12023 }
12024 ios.imbue(lg);
12025 {
12026 ios.width(0);
12027 {
12028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12029 std::string ex(str, iter.base());
12030 assert(ex == "-0;000000e+00");
12031 assert(ios.width() == 0);
12032 }
12033 ios.width(25);
12034 left(ios);
12035 {
12036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12037 std::string ex(str, iter.base());
12038 assert(ex == "-0;000000e+00************");
12039 assert(ios.width() == 0);
12040 }
12041 ios.width(25);
12042 right(ios);
12043 {
12044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12045 std::string ex(str, iter.base());
12046 assert(ex == "************-0;000000e+00");
12047 assert(ios.width() == 0);
12048 }
12049 ios.width(25);
12050 internal(ios);
12051 {
12052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12053 std::string ex(str, iter.base());
12054 assert(ex == "-************0;000000e+00");
12055 assert(ios.width() == 0);
12056 }
12057 }
12058 }
12059 }
12060 showpos(ios);
12061 {
12062 noshowpoint(ios);
12063 {
12064 ios.imbue(lc);
12065 {
12066 ios.width(0);
12067 {
12068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12069 std::string ex(str, iter.base());
12070 assert(ex == "-0.000000e+00");
12071 assert(ios.width() == 0);
12072 }
12073 ios.width(25);
12074 left(ios);
12075 {
12076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12077 std::string ex(str, iter.base());
12078 assert(ex == "-0.000000e+00************");
12079 assert(ios.width() == 0);
12080 }
12081 ios.width(25);
12082 right(ios);
12083 {
12084 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12085 std::string ex(str, iter.base());
12086 assert(ex == "************-0.000000e+00");
12087 assert(ios.width() == 0);
12088 }
12089 ios.width(25);
12090 internal(ios);
12091 {
12092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12093 std::string ex(str, iter.base());
12094 assert(ex == "-************0.000000e+00");
12095 assert(ios.width() == 0);
12096 }
12097 }
12098 ios.imbue(lg);
12099 {
12100 ios.width(0);
12101 {
12102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12103 std::string ex(str, iter.base());
12104 assert(ex == "-0;000000e+00");
12105 assert(ios.width() == 0);
12106 }
12107 ios.width(25);
12108 left(ios);
12109 {
12110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12111 std::string ex(str, iter.base());
12112 assert(ex == "-0;000000e+00************");
12113 assert(ios.width() == 0);
12114 }
12115 ios.width(25);
12116 right(ios);
12117 {
12118 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12119 std::string ex(str, iter.base());
12120 assert(ex == "************-0;000000e+00");
12121 assert(ios.width() == 0);
12122 }
12123 ios.width(25);
12124 internal(ios);
12125 {
12126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12127 std::string ex(str, iter.base());
12128 assert(ex == "-************0;000000e+00");
12129 assert(ios.width() == 0);
12130 }
12131 }
12132 }
12133 showpoint(ios);
12134 {
12135 ios.imbue(lc);
12136 {
12137 ios.width(0);
12138 {
12139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12140 std::string ex(str, iter.base());
12141 assert(ex == "-0.000000e+00");
12142 assert(ios.width() == 0);
12143 }
12144 ios.width(25);
12145 left(ios);
12146 {
12147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12148 std::string ex(str, iter.base());
12149 assert(ex == "-0.000000e+00************");
12150 assert(ios.width() == 0);
12151 }
12152 ios.width(25);
12153 right(ios);
12154 {
12155 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12156 std::string ex(str, iter.base());
12157 assert(ex == "************-0.000000e+00");
12158 assert(ios.width() == 0);
12159 }
12160 ios.width(25);
12161 internal(ios);
12162 {
12163 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12164 std::string ex(str, iter.base());
12165 assert(ex == "-************0.000000e+00");
12166 assert(ios.width() == 0);
12167 }
12168 }
12169 ios.imbue(lg);
12170 {
12171 ios.width(0);
12172 {
12173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12174 std::string ex(str, iter.base());
12175 assert(ex == "-0;000000e+00");
12176 assert(ios.width() == 0);
12177 }
12178 ios.width(25);
12179 left(ios);
12180 {
12181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12182 std::string ex(str, iter.base());
12183 assert(ex == "-0;000000e+00************");
12184 assert(ios.width() == 0);
12185 }
12186 ios.width(25);
12187 right(ios);
12188 {
12189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12190 std::string ex(str, iter.base());
12191 assert(ex == "************-0;000000e+00");
12192 assert(ios.width() == 0);
12193 }
12194 ios.width(25);
12195 internal(ios);
12196 {
12197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12198 std::string ex(str, iter.base());
12199 assert(ex == "-************0;000000e+00");
12200 assert(ios.width() == 0);
12201 }
12202 }
12203 }
12204 }
12205 }
12206 uppercase(ios);
12207 {
12208 noshowpos(ios);
12209 {
12210 noshowpoint(ios);
12211 {
12212 ios.imbue(lc);
12213 {
12214 ios.width(0);
12215 {
12216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12217 std::string ex(str, iter.base());
12218 assert(ex == "-0.000000E+00");
12219 assert(ios.width() == 0);
12220 }
12221 ios.width(25);
12222 left(ios);
12223 {
12224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12225 std::string ex(str, iter.base());
12226 assert(ex == "-0.000000E+00************");
12227 assert(ios.width() == 0);
12228 }
12229 ios.width(25);
12230 right(ios);
12231 {
12232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12233 std::string ex(str, iter.base());
12234 assert(ex == "************-0.000000E+00");
12235 assert(ios.width() == 0);
12236 }
12237 ios.width(25);
12238 internal(ios);
12239 {
12240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12241 std::string ex(str, iter.base());
12242 assert(ex == "-************0.000000E+00");
12243 assert(ios.width() == 0);
12244 }
12245 }
12246 ios.imbue(lg);
12247 {
12248 ios.width(0);
12249 {
12250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12251 std::string ex(str, iter.base());
12252 assert(ex == "-0;000000E+00");
12253 assert(ios.width() == 0);
12254 }
12255 ios.width(25);
12256 left(ios);
12257 {
12258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12259 std::string ex(str, iter.base());
12260 assert(ex == "-0;000000E+00************");
12261 assert(ios.width() == 0);
12262 }
12263 ios.width(25);
12264 right(ios);
12265 {
12266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12267 std::string ex(str, iter.base());
12268 assert(ex == "************-0;000000E+00");
12269 assert(ios.width() == 0);
12270 }
12271 ios.width(25);
12272 internal(ios);
12273 {
12274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12275 std::string ex(str, iter.base());
12276 assert(ex == "-************0;000000E+00");
12277 assert(ios.width() == 0);
12278 }
12279 }
12280 }
12281 showpoint(ios);
12282 {
12283 ios.imbue(lc);
12284 {
12285 ios.width(0);
12286 {
12287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12288 std::string ex(str, iter.base());
12289 assert(ex == "-0.000000E+00");
12290 assert(ios.width() == 0);
12291 }
12292 ios.width(25);
12293 left(ios);
12294 {
12295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12296 std::string ex(str, iter.base());
12297 assert(ex == "-0.000000E+00************");
12298 assert(ios.width() == 0);
12299 }
12300 ios.width(25);
12301 right(ios);
12302 {
12303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12304 std::string ex(str, iter.base());
12305 assert(ex == "************-0.000000E+00");
12306 assert(ios.width() == 0);
12307 }
12308 ios.width(25);
12309 internal(ios);
12310 {
12311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12312 std::string ex(str, iter.base());
12313 assert(ex == "-************0.000000E+00");
12314 assert(ios.width() == 0);
12315 }
12316 }
12317 ios.imbue(lg);
12318 {
12319 ios.width(0);
12320 {
12321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12322 std::string ex(str, iter.base());
12323 assert(ex == "-0;000000E+00");
12324 assert(ios.width() == 0);
12325 }
12326 ios.width(25);
12327 left(ios);
12328 {
12329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12330 std::string ex(str, iter.base());
12331 assert(ex == "-0;000000E+00************");
12332 assert(ios.width() == 0);
12333 }
12334 ios.width(25);
12335 right(ios);
12336 {
12337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12338 std::string ex(str, iter.base());
12339 assert(ex == "************-0;000000E+00");
12340 assert(ios.width() == 0);
12341 }
12342 ios.width(25);
12343 internal(ios);
12344 {
12345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12346 std::string ex(str, iter.base());
12347 assert(ex == "-************0;000000E+00");
12348 assert(ios.width() == 0);
12349 }
12350 }
12351 }
12352 }
12353 showpos(ios);
12354 {
12355 noshowpoint(ios);
12356 {
12357 ios.imbue(lc);
12358 {
12359 ios.width(0);
12360 {
12361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12362 std::string ex(str, iter.base());
12363 assert(ex == "-0.000000E+00");
12364 assert(ios.width() == 0);
12365 }
12366 ios.width(25);
12367 left(ios);
12368 {
12369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12370 std::string ex(str, iter.base());
12371 assert(ex == "-0.000000E+00************");
12372 assert(ios.width() == 0);
12373 }
12374 ios.width(25);
12375 right(ios);
12376 {
12377 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12378 std::string ex(str, iter.base());
12379 assert(ex == "************-0.000000E+00");
12380 assert(ios.width() == 0);
12381 }
12382 ios.width(25);
12383 internal(ios);
12384 {
12385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12386 std::string ex(str, iter.base());
12387 assert(ex == "-************0.000000E+00");
12388 assert(ios.width() == 0);
12389 }
12390 }
12391 ios.imbue(lg);
12392 {
12393 ios.width(0);
12394 {
12395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12396 std::string ex(str, iter.base());
12397 assert(ex == "-0;000000E+00");
12398 assert(ios.width() == 0);
12399 }
12400 ios.width(25);
12401 left(ios);
12402 {
12403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12404 std::string ex(str, iter.base());
12405 assert(ex == "-0;000000E+00************");
12406 assert(ios.width() == 0);
12407 }
12408 ios.width(25);
12409 right(ios);
12410 {
12411 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12412 std::string ex(str, iter.base());
12413 assert(ex == "************-0;000000E+00");
12414 assert(ios.width() == 0);
12415 }
12416 ios.width(25);
12417 internal(ios);
12418 {
12419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12420 std::string ex(str, iter.base());
12421 assert(ex == "-************0;000000E+00");
12422 assert(ios.width() == 0);
12423 }
12424 }
12425 }
12426 showpoint(ios);
12427 {
12428 ios.imbue(lc);
12429 {
12430 ios.width(0);
12431 {
12432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12433 std::string ex(str, iter.base());
12434 assert(ex == "-0.000000E+00");
12435 assert(ios.width() == 0);
12436 }
12437 ios.width(25);
12438 left(ios);
12439 {
12440 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12441 std::string ex(str, iter.base());
12442 assert(ex == "-0.000000E+00************");
12443 assert(ios.width() == 0);
12444 }
12445 ios.width(25);
12446 right(ios);
12447 {
12448 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12449 std::string ex(str, iter.base());
12450 assert(ex == "************-0.000000E+00");
12451 assert(ios.width() == 0);
12452 }
12453 ios.width(25);
12454 internal(ios);
12455 {
12456 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12457 std::string ex(str, iter.base());
12458 assert(ex == "-************0.000000E+00");
12459 assert(ios.width() == 0);
12460 }
12461 }
12462 ios.imbue(lg);
12463 {
12464 ios.width(0);
12465 {
12466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12467 std::string ex(str, iter.base());
12468 assert(ex == "-0;000000E+00");
12469 assert(ios.width() == 0);
12470 }
12471 ios.width(25);
12472 left(ios);
12473 {
12474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12475 std::string ex(str, iter.base());
12476 assert(ex == "-0;000000E+00************");
12477 assert(ios.width() == 0);
12478 }
12479 ios.width(25);
12480 right(ios);
12481 {
12482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12483 std::string ex(str, iter.base());
12484 assert(ex == "************-0;000000E+00");
12485 assert(ios.width() == 0);
12486 }
12487 ios.width(25);
12488 internal(ios);
12489 {
12490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12491 std::string ex(str, iter.base());
12492 assert(ex == "-************0;000000E+00");
12493 assert(ios.width() == 0);
12494 }
12495 }
12496 }
12497 }
12498 }
12499 }
12500 ios.precision(16);
12501 {
12502 }
12503 ios.precision(60);
12504 {
12505 }
12506 }
12507 }
12508 }
12509
test6()12510 void test6()
12511 {
12512 char str[200];
12513 output_iterator<char*> iter;
12514 std::locale lc = std::locale::classic();
12515 std::locale lg(lc, new my_numpunct);
12516 const my_facet f(1);
12517 {
12518 double v = 1234567890.125;
12519 std::ios ios(0);
12520 scientific(ios);
12521 // %e
12522 {
12523 ios.precision(0);
12524 {
12525 nouppercase(ios);
12526 {
12527 noshowpos(ios);
12528 {
12529 noshowpoint(ios);
12530 {
12531 ios.imbue(lc);
12532 {
12533 ios.width(0);
12534 {
12535 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12536 std::string ex(str, iter.base());
12537 assert(ex == "1e+09");
12538 assert(ios.width() == 0);
12539 }
12540 ios.width(25);
12541 left(ios);
12542 {
12543 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12544 std::string ex(str, iter.base());
12545 assert(ex == "1e+09********************");
12546 assert(ios.width() == 0);
12547 }
12548 ios.width(25);
12549 right(ios);
12550 {
12551 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12552 std::string ex(str, iter.base());
12553 assert(ex == "********************1e+09");
12554 assert(ios.width() == 0);
12555 }
12556 ios.width(25);
12557 internal(ios);
12558 {
12559 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12560 std::string ex(str, iter.base());
12561 assert(ex == "********************1e+09");
12562 assert(ios.width() == 0);
12563 }
12564 }
12565 ios.imbue(lg);
12566 {
12567 ios.width(0);
12568 {
12569 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12570 std::string ex(str, iter.base());
12571 assert(ex == "1e+09");
12572 assert(ios.width() == 0);
12573 }
12574 ios.width(25);
12575 left(ios);
12576 {
12577 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12578 std::string ex(str, iter.base());
12579 assert(ex == "1e+09********************");
12580 assert(ios.width() == 0);
12581 }
12582 ios.width(25);
12583 right(ios);
12584 {
12585 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12586 std::string ex(str, iter.base());
12587 assert(ex == "********************1e+09");
12588 assert(ios.width() == 0);
12589 }
12590 ios.width(25);
12591 internal(ios);
12592 {
12593 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12594 std::string ex(str, iter.base());
12595 assert(ex == "********************1e+09");
12596 assert(ios.width() == 0);
12597 }
12598 }
12599 }
12600 showpoint(ios);
12601 {
12602 ios.imbue(lc);
12603 {
12604 ios.width(0);
12605 {
12606 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12607 std::string ex(str, iter.base());
12608 assert(ex == "1.e+09");
12609 assert(ios.width() == 0);
12610 }
12611 ios.width(25);
12612 left(ios);
12613 {
12614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12615 std::string ex(str, iter.base());
12616 assert(ex == "1.e+09*******************");
12617 assert(ios.width() == 0);
12618 }
12619 ios.width(25);
12620 right(ios);
12621 {
12622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12623 std::string ex(str, iter.base());
12624 assert(ex == "*******************1.e+09");
12625 assert(ios.width() == 0);
12626 }
12627 ios.width(25);
12628 internal(ios);
12629 {
12630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12631 std::string ex(str, iter.base());
12632 assert(ex == "*******************1.e+09");
12633 assert(ios.width() == 0);
12634 }
12635 }
12636 ios.imbue(lg);
12637 {
12638 ios.width(0);
12639 {
12640 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12641 std::string ex(str, iter.base());
12642 assert(ex == "1;e+09");
12643 assert(ios.width() == 0);
12644 }
12645 ios.width(25);
12646 left(ios);
12647 {
12648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12649 std::string ex(str, iter.base());
12650 assert(ex == "1;e+09*******************");
12651 assert(ios.width() == 0);
12652 }
12653 ios.width(25);
12654 right(ios);
12655 {
12656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12657 std::string ex(str, iter.base());
12658 assert(ex == "*******************1;e+09");
12659 assert(ios.width() == 0);
12660 }
12661 ios.width(25);
12662 internal(ios);
12663 {
12664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12665 std::string ex(str, iter.base());
12666 assert(ex == "*******************1;e+09");
12667 assert(ios.width() == 0);
12668 }
12669 }
12670 }
12671 }
12672 showpos(ios);
12673 {
12674 noshowpoint(ios);
12675 {
12676 ios.imbue(lc);
12677 {
12678 ios.width(0);
12679 {
12680 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12681 std::string ex(str, iter.base());
12682 assert(ex == "+1e+09");
12683 assert(ios.width() == 0);
12684 }
12685 ios.width(25);
12686 left(ios);
12687 {
12688 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12689 std::string ex(str, iter.base());
12690 assert(ex == "+1e+09*******************");
12691 assert(ios.width() == 0);
12692 }
12693 ios.width(25);
12694 right(ios);
12695 {
12696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12697 std::string ex(str, iter.base());
12698 assert(ex == "*******************+1e+09");
12699 assert(ios.width() == 0);
12700 }
12701 ios.width(25);
12702 internal(ios);
12703 {
12704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12705 std::string ex(str, iter.base());
12706 assert(ex == "+*******************1e+09");
12707 assert(ios.width() == 0);
12708 }
12709 }
12710 ios.imbue(lg);
12711 {
12712 ios.width(0);
12713 {
12714 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12715 std::string ex(str, iter.base());
12716 assert(ex == "+1e+09");
12717 assert(ios.width() == 0);
12718 }
12719 ios.width(25);
12720 left(ios);
12721 {
12722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12723 std::string ex(str, iter.base());
12724 assert(ex == "+1e+09*******************");
12725 assert(ios.width() == 0);
12726 }
12727 ios.width(25);
12728 right(ios);
12729 {
12730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12731 std::string ex(str, iter.base());
12732 assert(ex == "*******************+1e+09");
12733 assert(ios.width() == 0);
12734 }
12735 ios.width(25);
12736 internal(ios);
12737 {
12738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12739 std::string ex(str, iter.base());
12740 assert(ex == "+*******************1e+09");
12741 assert(ios.width() == 0);
12742 }
12743 }
12744 }
12745 showpoint(ios);
12746 {
12747 ios.imbue(lc);
12748 {
12749 ios.width(0);
12750 {
12751 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12752 std::string ex(str, iter.base());
12753 assert(ex == "+1.e+09");
12754 assert(ios.width() == 0);
12755 }
12756 ios.width(25);
12757 left(ios);
12758 {
12759 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12760 std::string ex(str, iter.base());
12761 assert(ex == "+1.e+09******************");
12762 assert(ios.width() == 0);
12763 }
12764 ios.width(25);
12765 right(ios);
12766 {
12767 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12768 std::string ex(str, iter.base());
12769 assert(ex == "******************+1.e+09");
12770 assert(ios.width() == 0);
12771 }
12772 ios.width(25);
12773 internal(ios);
12774 {
12775 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12776 std::string ex(str, iter.base());
12777 assert(ex == "+******************1.e+09");
12778 assert(ios.width() == 0);
12779 }
12780 }
12781 ios.imbue(lg);
12782 {
12783 ios.width(0);
12784 {
12785 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12786 std::string ex(str, iter.base());
12787 assert(ex == "+1;e+09");
12788 assert(ios.width() == 0);
12789 }
12790 ios.width(25);
12791 left(ios);
12792 {
12793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12794 std::string ex(str, iter.base());
12795 assert(ex == "+1;e+09******************");
12796 assert(ios.width() == 0);
12797 }
12798 ios.width(25);
12799 right(ios);
12800 {
12801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12802 std::string ex(str, iter.base());
12803 assert(ex == "******************+1;e+09");
12804 assert(ios.width() == 0);
12805 }
12806 ios.width(25);
12807 internal(ios);
12808 {
12809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12810 std::string ex(str, iter.base());
12811 assert(ex == "+******************1;e+09");
12812 assert(ios.width() == 0);
12813 }
12814 }
12815 }
12816 }
12817 }
12818 uppercase(ios);
12819 {
12820 noshowpos(ios);
12821 {
12822 noshowpoint(ios);
12823 {
12824 ios.imbue(lc);
12825 {
12826 ios.width(0);
12827 {
12828 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12829 std::string ex(str, iter.base());
12830 assert(ex == "1E+09");
12831 assert(ios.width() == 0);
12832 }
12833 ios.width(25);
12834 left(ios);
12835 {
12836 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12837 std::string ex(str, iter.base());
12838 assert(ex == "1E+09********************");
12839 assert(ios.width() == 0);
12840 }
12841 ios.width(25);
12842 right(ios);
12843 {
12844 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12845 std::string ex(str, iter.base());
12846 assert(ex == "********************1E+09");
12847 assert(ios.width() == 0);
12848 }
12849 ios.width(25);
12850 internal(ios);
12851 {
12852 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12853 std::string ex(str, iter.base());
12854 assert(ex == "********************1E+09");
12855 assert(ios.width() == 0);
12856 }
12857 }
12858 ios.imbue(lg);
12859 {
12860 ios.width(0);
12861 {
12862 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12863 std::string ex(str, iter.base());
12864 assert(ex == "1E+09");
12865 assert(ios.width() == 0);
12866 }
12867 ios.width(25);
12868 left(ios);
12869 {
12870 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12871 std::string ex(str, iter.base());
12872 assert(ex == "1E+09********************");
12873 assert(ios.width() == 0);
12874 }
12875 ios.width(25);
12876 right(ios);
12877 {
12878 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12879 std::string ex(str, iter.base());
12880 assert(ex == "********************1E+09");
12881 assert(ios.width() == 0);
12882 }
12883 ios.width(25);
12884 internal(ios);
12885 {
12886 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12887 std::string ex(str, iter.base());
12888 assert(ex == "********************1E+09");
12889 assert(ios.width() == 0);
12890 }
12891 }
12892 }
12893 showpoint(ios);
12894 {
12895 ios.imbue(lc);
12896 {
12897 ios.width(0);
12898 {
12899 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12900 std::string ex(str, iter.base());
12901 assert(ex == "1.E+09");
12902 assert(ios.width() == 0);
12903 }
12904 ios.width(25);
12905 left(ios);
12906 {
12907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12908 std::string ex(str, iter.base());
12909 assert(ex == "1.E+09*******************");
12910 assert(ios.width() == 0);
12911 }
12912 ios.width(25);
12913 right(ios);
12914 {
12915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12916 std::string ex(str, iter.base());
12917 assert(ex == "*******************1.E+09");
12918 assert(ios.width() == 0);
12919 }
12920 ios.width(25);
12921 internal(ios);
12922 {
12923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12924 std::string ex(str, iter.base());
12925 assert(ex == "*******************1.E+09");
12926 assert(ios.width() == 0);
12927 }
12928 }
12929 ios.imbue(lg);
12930 {
12931 ios.width(0);
12932 {
12933 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12934 std::string ex(str, iter.base());
12935 assert(ex == "1;E+09");
12936 assert(ios.width() == 0);
12937 }
12938 ios.width(25);
12939 left(ios);
12940 {
12941 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12942 std::string ex(str, iter.base());
12943 assert(ex == "1;E+09*******************");
12944 assert(ios.width() == 0);
12945 }
12946 ios.width(25);
12947 right(ios);
12948 {
12949 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12950 std::string ex(str, iter.base());
12951 assert(ex == "*******************1;E+09");
12952 assert(ios.width() == 0);
12953 }
12954 ios.width(25);
12955 internal(ios);
12956 {
12957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12958 std::string ex(str, iter.base());
12959 assert(ex == "*******************1;E+09");
12960 assert(ios.width() == 0);
12961 }
12962 }
12963 }
12964 }
12965 showpos(ios);
12966 {
12967 noshowpoint(ios);
12968 {
12969 ios.imbue(lc);
12970 {
12971 ios.width(0);
12972 {
12973 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12974 std::string ex(str, iter.base());
12975 assert(ex == "+1E+09");
12976 assert(ios.width() == 0);
12977 }
12978 ios.width(25);
12979 left(ios);
12980 {
12981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12982 std::string ex(str, iter.base());
12983 assert(ex == "+1E+09*******************");
12984 assert(ios.width() == 0);
12985 }
12986 ios.width(25);
12987 right(ios);
12988 {
12989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12990 std::string ex(str, iter.base());
12991 assert(ex == "*******************+1E+09");
12992 assert(ios.width() == 0);
12993 }
12994 ios.width(25);
12995 internal(ios);
12996 {
12997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12998 std::string ex(str, iter.base());
12999 assert(ex == "+*******************1E+09");
13000 assert(ios.width() == 0);
13001 }
13002 }
13003 ios.imbue(lg);
13004 {
13005 ios.width(0);
13006 {
13007 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13008 std::string ex(str, iter.base());
13009 assert(ex == "+1E+09");
13010 assert(ios.width() == 0);
13011 }
13012 ios.width(25);
13013 left(ios);
13014 {
13015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13016 std::string ex(str, iter.base());
13017 assert(ex == "+1E+09*******************");
13018 assert(ios.width() == 0);
13019 }
13020 ios.width(25);
13021 right(ios);
13022 {
13023 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13024 std::string ex(str, iter.base());
13025 assert(ex == "*******************+1E+09");
13026 assert(ios.width() == 0);
13027 }
13028 ios.width(25);
13029 internal(ios);
13030 {
13031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13032 std::string ex(str, iter.base());
13033 assert(ex == "+*******************1E+09");
13034 assert(ios.width() == 0);
13035 }
13036 }
13037 }
13038 showpoint(ios);
13039 {
13040 ios.imbue(lc);
13041 {
13042 ios.width(0);
13043 {
13044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13045 std::string ex(str, iter.base());
13046 assert(ex == "+1.E+09");
13047 assert(ios.width() == 0);
13048 }
13049 ios.width(25);
13050 left(ios);
13051 {
13052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13053 std::string ex(str, iter.base());
13054 assert(ex == "+1.E+09******************");
13055 assert(ios.width() == 0);
13056 }
13057 ios.width(25);
13058 right(ios);
13059 {
13060 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13061 std::string ex(str, iter.base());
13062 assert(ex == "******************+1.E+09");
13063 assert(ios.width() == 0);
13064 }
13065 ios.width(25);
13066 internal(ios);
13067 {
13068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13069 std::string ex(str, iter.base());
13070 assert(ex == "+******************1.E+09");
13071 assert(ios.width() == 0);
13072 }
13073 }
13074 ios.imbue(lg);
13075 {
13076 ios.width(0);
13077 {
13078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13079 std::string ex(str, iter.base());
13080 assert(ex == "+1;E+09");
13081 assert(ios.width() == 0);
13082 }
13083 ios.width(25);
13084 left(ios);
13085 {
13086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13087 std::string ex(str, iter.base());
13088 assert(ex == "+1;E+09******************");
13089 assert(ios.width() == 0);
13090 }
13091 ios.width(25);
13092 right(ios);
13093 {
13094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13095 std::string ex(str, iter.base());
13096 assert(ex == "******************+1;E+09");
13097 assert(ios.width() == 0);
13098 }
13099 ios.width(25);
13100 internal(ios);
13101 {
13102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13103 std::string ex(str, iter.base());
13104 assert(ex == "+******************1;E+09");
13105 assert(ios.width() == 0);
13106 }
13107 }
13108 }
13109 }
13110 }
13111 }
13112 ios.precision(1);
13113 {
13114 nouppercase(ios);
13115 {
13116 noshowpos(ios);
13117 {
13118 noshowpoint(ios);
13119 {
13120 ios.imbue(lc);
13121 {
13122 ios.width(0);
13123 {
13124 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13125 std::string ex(str, iter.base());
13126 assert(ex == "1.2e+09");
13127 assert(ios.width() == 0);
13128 }
13129 ios.width(25);
13130 left(ios);
13131 {
13132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13133 std::string ex(str, iter.base());
13134 assert(ex == "1.2e+09******************");
13135 assert(ios.width() == 0);
13136 }
13137 ios.width(25);
13138 right(ios);
13139 {
13140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13141 std::string ex(str, iter.base());
13142 assert(ex == "******************1.2e+09");
13143 assert(ios.width() == 0);
13144 }
13145 ios.width(25);
13146 internal(ios);
13147 {
13148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13149 std::string ex(str, iter.base());
13150 assert(ex == "******************1.2e+09");
13151 assert(ios.width() == 0);
13152 }
13153 }
13154 ios.imbue(lg);
13155 {
13156 ios.width(0);
13157 {
13158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13159 std::string ex(str, iter.base());
13160 assert(ex == "1;2e+09");
13161 assert(ios.width() == 0);
13162 }
13163 ios.width(25);
13164 left(ios);
13165 {
13166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13167 std::string ex(str, iter.base());
13168 assert(ex == "1;2e+09******************");
13169 assert(ios.width() == 0);
13170 }
13171 ios.width(25);
13172 right(ios);
13173 {
13174 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13175 std::string ex(str, iter.base());
13176 assert(ex == "******************1;2e+09");
13177 assert(ios.width() == 0);
13178 }
13179 ios.width(25);
13180 internal(ios);
13181 {
13182 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13183 std::string ex(str, iter.base());
13184 assert(ex == "******************1;2e+09");
13185 assert(ios.width() == 0);
13186 }
13187 }
13188 }
13189 showpoint(ios);
13190 {
13191 ios.imbue(lc);
13192 {
13193 ios.width(0);
13194 {
13195 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13196 std::string ex(str, iter.base());
13197 assert(ex == "1.2e+09");
13198 assert(ios.width() == 0);
13199 }
13200 ios.width(25);
13201 left(ios);
13202 {
13203 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13204 std::string ex(str, iter.base());
13205 assert(ex == "1.2e+09******************");
13206 assert(ios.width() == 0);
13207 }
13208 ios.width(25);
13209 right(ios);
13210 {
13211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13212 std::string ex(str, iter.base());
13213 assert(ex == "******************1.2e+09");
13214 assert(ios.width() == 0);
13215 }
13216 ios.width(25);
13217 internal(ios);
13218 {
13219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13220 std::string ex(str, iter.base());
13221 assert(ex == "******************1.2e+09");
13222 assert(ios.width() == 0);
13223 }
13224 }
13225 ios.imbue(lg);
13226 {
13227 ios.width(0);
13228 {
13229 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13230 std::string ex(str, iter.base());
13231 assert(ex == "1;2e+09");
13232 assert(ios.width() == 0);
13233 }
13234 ios.width(25);
13235 left(ios);
13236 {
13237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13238 std::string ex(str, iter.base());
13239 assert(ex == "1;2e+09******************");
13240 assert(ios.width() == 0);
13241 }
13242 ios.width(25);
13243 right(ios);
13244 {
13245 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13246 std::string ex(str, iter.base());
13247 assert(ex == "******************1;2e+09");
13248 assert(ios.width() == 0);
13249 }
13250 ios.width(25);
13251 internal(ios);
13252 {
13253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13254 std::string ex(str, iter.base());
13255 assert(ex == "******************1;2e+09");
13256 assert(ios.width() == 0);
13257 }
13258 }
13259 }
13260 }
13261 showpos(ios);
13262 {
13263 noshowpoint(ios);
13264 {
13265 ios.imbue(lc);
13266 {
13267 ios.width(0);
13268 {
13269 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13270 std::string ex(str, iter.base());
13271 assert(ex == "+1.2e+09");
13272 assert(ios.width() == 0);
13273 }
13274 ios.width(25);
13275 left(ios);
13276 {
13277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13278 std::string ex(str, iter.base());
13279 assert(ex == "+1.2e+09*****************");
13280 assert(ios.width() == 0);
13281 }
13282 ios.width(25);
13283 right(ios);
13284 {
13285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13286 std::string ex(str, iter.base());
13287 assert(ex == "*****************+1.2e+09");
13288 assert(ios.width() == 0);
13289 }
13290 ios.width(25);
13291 internal(ios);
13292 {
13293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13294 std::string ex(str, iter.base());
13295 assert(ex == "+*****************1.2e+09");
13296 assert(ios.width() == 0);
13297 }
13298 }
13299 ios.imbue(lg);
13300 {
13301 ios.width(0);
13302 {
13303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13304 std::string ex(str, iter.base());
13305 assert(ex == "+1;2e+09");
13306 assert(ios.width() == 0);
13307 }
13308 ios.width(25);
13309 left(ios);
13310 {
13311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13312 std::string ex(str, iter.base());
13313 assert(ex == "+1;2e+09*****************");
13314 assert(ios.width() == 0);
13315 }
13316 ios.width(25);
13317 right(ios);
13318 {
13319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13320 std::string ex(str, iter.base());
13321 assert(ex == "*****************+1;2e+09");
13322 assert(ios.width() == 0);
13323 }
13324 ios.width(25);
13325 internal(ios);
13326 {
13327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13328 std::string ex(str, iter.base());
13329 assert(ex == "+*****************1;2e+09");
13330 assert(ios.width() == 0);
13331 }
13332 }
13333 }
13334 showpoint(ios);
13335 {
13336 ios.imbue(lc);
13337 {
13338 ios.width(0);
13339 {
13340 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13341 std::string ex(str, iter.base());
13342 assert(ex == "+1.2e+09");
13343 assert(ios.width() == 0);
13344 }
13345 ios.width(25);
13346 left(ios);
13347 {
13348 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13349 std::string ex(str, iter.base());
13350 assert(ex == "+1.2e+09*****************");
13351 assert(ios.width() == 0);
13352 }
13353 ios.width(25);
13354 right(ios);
13355 {
13356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13357 std::string ex(str, iter.base());
13358 assert(ex == "*****************+1.2e+09");
13359 assert(ios.width() == 0);
13360 }
13361 ios.width(25);
13362 internal(ios);
13363 {
13364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13365 std::string ex(str, iter.base());
13366 assert(ex == "+*****************1.2e+09");
13367 assert(ios.width() == 0);
13368 }
13369 }
13370 ios.imbue(lg);
13371 {
13372 ios.width(0);
13373 {
13374 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13375 std::string ex(str, iter.base());
13376 assert(ex == "+1;2e+09");
13377 assert(ios.width() == 0);
13378 }
13379 ios.width(25);
13380 left(ios);
13381 {
13382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13383 std::string ex(str, iter.base());
13384 assert(ex == "+1;2e+09*****************");
13385 assert(ios.width() == 0);
13386 }
13387 ios.width(25);
13388 right(ios);
13389 {
13390 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13391 std::string ex(str, iter.base());
13392 assert(ex == "*****************+1;2e+09");
13393 assert(ios.width() == 0);
13394 }
13395 ios.width(25);
13396 internal(ios);
13397 {
13398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13399 std::string ex(str, iter.base());
13400 assert(ex == "+*****************1;2e+09");
13401 assert(ios.width() == 0);
13402 }
13403 }
13404 }
13405 }
13406 }
13407 uppercase(ios);
13408 {
13409 noshowpos(ios);
13410 {
13411 noshowpoint(ios);
13412 {
13413 ios.imbue(lc);
13414 {
13415 ios.width(0);
13416 {
13417 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13418 std::string ex(str, iter.base());
13419 assert(ex == "1.2E+09");
13420 assert(ios.width() == 0);
13421 }
13422 ios.width(25);
13423 left(ios);
13424 {
13425 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13426 std::string ex(str, iter.base());
13427 assert(ex == "1.2E+09******************");
13428 assert(ios.width() == 0);
13429 }
13430 ios.width(25);
13431 right(ios);
13432 {
13433 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13434 std::string ex(str, iter.base());
13435 assert(ex == "******************1.2E+09");
13436 assert(ios.width() == 0);
13437 }
13438 ios.width(25);
13439 internal(ios);
13440 {
13441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13442 std::string ex(str, iter.base());
13443 assert(ex == "******************1.2E+09");
13444 assert(ios.width() == 0);
13445 }
13446 }
13447 ios.imbue(lg);
13448 {
13449 ios.width(0);
13450 {
13451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13452 std::string ex(str, iter.base());
13453 assert(ex == "1;2E+09");
13454 assert(ios.width() == 0);
13455 }
13456 ios.width(25);
13457 left(ios);
13458 {
13459 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13460 std::string ex(str, iter.base());
13461 assert(ex == "1;2E+09******************");
13462 assert(ios.width() == 0);
13463 }
13464 ios.width(25);
13465 right(ios);
13466 {
13467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13468 std::string ex(str, iter.base());
13469 assert(ex == "******************1;2E+09");
13470 assert(ios.width() == 0);
13471 }
13472 ios.width(25);
13473 internal(ios);
13474 {
13475 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13476 std::string ex(str, iter.base());
13477 assert(ex == "******************1;2E+09");
13478 assert(ios.width() == 0);
13479 }
13480 }
13481 }
13482 showpoint(ios);
13483 {
13484 ios.imbue(lc);
13485 {
13486 ios.width(0);
13487 {
13488 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13489 std::string ex(str, iter.base());
13490 assert(ex == "1.2E+09");
13491 assert(ios.width() == 0);
13492 }
13493 ios.width(25);
13494 left(ios);
13495 {
13496 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13497 std::string ex(str, iter.base());
13498 assert(ex == "1.2E+09******************");
13499 assert(ios.width() == 0);
13500 }
13501 ios.width(25);
13502 right(ios);
13503 {
13504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13505 std::string ex(str, iter.base());
13506 assert(ex == "******************1.2E+09");
13507 assert(ios.width() == 0);
13508 }
13509 ios.width(25);
13510 internal(ios);
13511 {
13512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13513 std::string ex(str, iter.base());
13514 assert(ex == "******************1.2E+09");
13515 assert(ios.width() == 0);
13516 }
13517 }
13518 ios.imbue(lg);
13519 {
13520 ios.width(0);
13521 {
13522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13523 std::string ex(str, iter.base());
13524 assert(ex == "1;2E+09");
13525 assert(ios.width() == 0);
13526 }
13527 ios.width(25);
13528 left(ios);
13529 {
13530 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13531 std::string ex(str, iter.base());
13532 assert(ex == "1;2E+09******************");
13533 assert(ios.width() == 0);
13534 }
13535 ios.width(25);
13536 right(ios);
13537 {
13538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13539 std::string ex(str, iter.base());
13540 assert(ex == "******************1;2E+09");
13541 assert(ios.width() == 0);
13542 }
13543 ios.width(25);
13544 internal(ios);
13545 {
13546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13547 std::string ex(str, iter.base());
13548 assert(ex == "******************1;2E+09");
13549 assert(ios.width() == 0);
13550 }
13551 }
13552 }
13553 }
13554 showpos(ios);
13555 {
13556 noshowpoint(ios);
13557 {
13558 ios.imbue(lc);
13559 {
13560 ios.width(0);
13561 {
13562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13563 std::string ex(str, iter.base());
13564 assert(ex == "+1.2E+09");
13565 assert(ios.width() == 0);
13566 }
13567 ios.width(25);
13568 left(ios);
13569 {
13570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13571 std::string ex(str, iter.base());
13572 assert(ex == "+1.2E+09*****************");
13573 assert(ios.width() == 0);
13574 }
13575 ios.width(25);
13576 right(ios);
13577 {
13578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13579 std::string ex(str, iter.base());
13580 assert(ex == "*****************+1.2E+09");
13581 assert(ios.width() == 0);
13582 }
13583 ios.width(25);
13584 internal(ios);
13585 {
13586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13587 std::string ex(str, iter.base());
13588 assert(ex == "+*****************1.2E+09");
13589 assert(ios.width() == 0);
13590 }
13591 }
13592 ios.imbue(lg);
13593 {
13594 ios.width(0);
13595 {
13596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13597 std::string ex(str, iter.base());
13598 assert(ex == "+1;2E+09");
13599 assert(ios.width() == 0);
13600 }
13601 ios.width(25);
13602 left(ios);
13603 {
13604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13605 std::string ex(str, iter.base());
13606 assert(ex == "+1;2E+09*****************");
13607 assert(ios.width() == 0);
13608 }
13609 ios.width(25);
13610 right(ios);
13611 {
13612 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13613 std::string ex(str, iter.base());
13614 assert(ex == "*****************+1;2E+09");
13615 assert(ios.width() == 0);
13616 }
13617 ios.width(25);
13618 internal(ios);
13619 {
13620 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13621 std::string ex(str, iter.base());
13622 assert(ex == "+*****************1;2E+09");
13623 assert(ios.width() == 0);
13624 }
13625 }
13626 }
13627 showpoint(ios);
13628 {
13629 ios.imbue(lc);
13630 {
13631 ios.width(0);
13632 {
13633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13634 std::string ex(str, iter.base());
13635 assert(ex == "+1.2E+09");
13636 assert(ios.width() == 0);
13637 }
13638 ios.width(25);
13639 left(ios);
13640 {
13641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13642 std::string ex(str, iter.base());
13643 assert(ex == "+1.2E+09*****************");
13644 assert(ios.width() == 0);
13645 }
13646 ios.width(25);
13647 right(ios);
13648 {
13649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13650 std::string ex(str, iter.base());
13651 assert(ex == "*****************+1.2E+09");
13652 assert(ios.width() == 0);
13653 }
13654 ios.width(25);
13655 internal(ios);
13656 {
13657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13658 std::string ex(str, iter.base());
13659 assert(ex == "+*****************1.2E+09");
13660 assert(ios.width() == 0);
13661 }
13662 }
13663 ios.imbue(lg);
13664 {
13665 ios.width(0);
13666 {
13667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13668 std::string ex(str, iter.base());
13669 assert(ex == "+1;2E+09");
13670 assert(ios.width() == 0);
13671 }
13672 ios.width(25);
13673 left(ios);
13674 {
13675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13676 std::string ex(str, iter.base());
13677 assert(ex == "+1;2E+09*****************");
13678 assert(ios.width() == 0);
13679 }
13680 ios.width(25);
13681 right(ios);
13682 {
13683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13684 std::string ex(str, iter.base());
13685 assert(ex == "*****************+1;2E+09");
13686 assert(ios.width() == 0);
13687 }
13688 ios.width(25);
13689 internal(ios);
13690 {
13691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13692 std::string ex(str, iter.base());
13693 assert(ex == "+*****************1;2E+09");
13694 assert(ios.width() == 0);
13695 }
13696 }
13697 }
13698 }
13699 }
13700 }
13701 ios.precision(6);
13702 {
13703 }
13704 ios.precision(16);
13705 {
13706 }
13707 ios.precision(60);
13708 {
13709 nouppercase(ios);
13710 {
13711 noshowpos(ios);
13712 {
13713 noshowpoint(ios);
13714 {
13715 ios.imbue(lc);
13716 {
13717 ios.width(0);
13718 {
13719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13720 std::string ex(str, iter.base());
13721 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13722 assert(ios.width() == 0);
13723 }
13724 ios.width(25);
13725 left(ios);
13726 {
13727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13728 std::string ex(str, iter.base());
13729 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13730 assert(ios.width() == 0);
13731 }
13732 ios.width(25);
13733 right(ios);
13734 {
13735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13736 std::string ex(str, iter.base());
13737 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13738 assert(ios.width() == 0);
13739 }
13740 ios.width(25);
13741 internal(ios);
13742 {
13743 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13744 std::string ex(str, iter.base());
13745 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13746 assert(ios.width() == 0);
13747 }
13748 }
13749 ios.imbue(lg);
13750 {
13751 ios.width(0);
13752 {
13753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13754 std::string ex(str, iter.base());
13755 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13756 assert(ios.width() == 0);
13757 }
13758 ios.width(25);
13759 left(ios);
13760 {
13761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13762 std::string ex(str, iter.base());
13763 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13764 assert(ios.width() == 0);
13765 }
13766 ios.width(25);
13767 right(ios);
13768 {
13769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13770 std::string ex(str, iter.base());
13771 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13772 assert(ios.width() == 0);
13773 }
13774 ios.width(25);
13775 internal(ios);
13776 {
13777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13778 std::string ex(str, iter.base());
13779 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13780 assert(ios.width() == 0);
13781 }
13782 }
13783 }
13784 showpoint(ios);
13785 {
13786 ios.imbue(lc);
13787 {
13788 ios.width(0);
13789 {
13790 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13791 std::string ex(str, iter.base());
13792 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13793 assert(ios.width() == 0);
13794 }
13795 ios.width(25);
13796 left(ios);
13797 {
13798 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13799 std::string ex(str, iter.base());
13800 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13801 assert(ios.width() == 0);
13802 }
13803 ios.width(25);
13804 right(ios);
13805 {
13806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13807 std::string ex(str, iter.base());
13808 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13809 assert(ios.width() == 0);
13810 }
13811 ios.width(25);
13812 internal(ios);
13813 {
13814 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13815 std::string ex(str, iter.base());
13816 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13817 assert(ios.width() == 0);
13818 }
13819 }
13820 ios.imbue(lg);
13821 {
13822 ios.width(0);
13823 {
13824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13825 std::string ex(str, iter.base());
13826 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13827 assert(ios.width() == 0);
13828 }
13829 ios.width(25);
13830 left(ios);
13831 {
13832 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13833 std::string ex(str, iter.base());
13834 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13835 assert(ios.width() == 0);
13836 }
13837 ios.width(25);
13838 right(ios);
13839 {
13840 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13841 std::string ex(str, iter.base());
13842 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13843 assert(ios.width() == 0);
13844 }
13845 ios.width(25);
13846 internal(ios);
13847 {
13848 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13849 std::string ex(str, iter.base());
13850 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13851 assert(ios.width() == 0);
13852 }
13853 }
13854 }
13855 }
13856 showpos(ios);
13857 {
13858 noshowpoint(ios);
13859 {
13860 ios.imbue(lc);
13861 {
13862 ios.width(0);
13863 {
13864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13865 std::string ex(str, iter.base());
13866 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13867 assert(ios.width() == 0);
13868 }
13869 ios.width(25);
13870 left(ios);
13871 {
13872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13873 std::string ex(str, iter.base());
13874 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13875 assert(ios.width() == 0);
13876 }
13877 ios.width(25);
13878 right(ios);
13879 {
13880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13881 std::string ex(str, iter.base());
13882 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13883 assert(ios.width() == 0);
13884 }
13885 ios.width(25);
13886 internal(ios);
13887 {
13888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13889 std::string ex(str, iter.base());
13890 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13891 assert(ios.width() == 0);
13892 }
13893 }
13894 ios.imbue(lg);
13895 {
13896 ios.width(0);
13897 {
13898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13899 std::string ex(str, iter.base());
13900 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13901 assert(ios.width() == 0);
13902 }
13903 ios.width(25);
13904 left(ios);
13905 {
13906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13907 std::string ex(str, iter.base());
13908 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13909 assert(ios.width() == 0);
13910 }
13911 ios.width(25);
13912 right(ios);
13913 {
13914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13915 std::string ex(str, iter.base());
13916 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13917 assert(ios.width() == 0);
13918 }
13919 ios.width(25);
13920 internal(ios);
13921 {
13922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13923 std::string ex(str, iter.base());
13924 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13925 assert(ios.width() == 0);
13926 }
13927 }
13928 }
13929 showpoint(ios);
13930 {
13931 ios.imbue(lc);
13932 {
13933 ios.width(0);
13934 {
13935 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13936 std::string ex(str, iter.base());
13937 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13938 assert(ios.width() == 0);
13939 }
13940 ios.width(25);
13941 left(ios);
13942 {
13943 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13944 std::string ex(str, iter.base());
13945 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13946 assert(ios.width() == 0);
13947 }
13948 ios.width(25);
13949 right(ios);
13950 {
13951 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13952 std::string ex(str, iter.base());
13953 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13954 assert(ios.width() == 0);
13955 }
13956 ios.width(25);
13957 internal(ios);
13958 {
13959 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13960 std::string ex(str, iter.base());
13961 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13962 assert(ios.width() == 0);
13963 }
13964 }
13965 ios.imbue(lg);
13966 {
13967 ios.width(0);
13968 {
13969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13970 std::string ex(str, iter.base());
13971 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13972 assert(ios.width() == 0);
13973 }
13974 ios.width(25);
13975 left(ios);
13976 {
13977 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13978 std::string ex(str, iter.base());
13979 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13980 assert(ios.width() == 0);
13981 }
13982 ios.width(25);
13983 right(ios);
13984 {
13985 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13986 std::string ex(str, iter.base());
13987 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13988 assert(ios.width() == 0);
13989 }
13990 ios.width(25);
13991 internal(ios);
13992 {
13993 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13994 std::string ex(str, iter.base());
13995 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13996 assert(ios.width() == 0);
13997 }
13998 }
13999 }
14000 }
14001 }
14002 uppercase(ios);
14003 {
14004 noshowpos(ios);
14005 {
14006 noshowpoint(ios);
14007 {
14008 ios.imbue(lc);
14009 {
14010 ios.width(0);
14011 {
14012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14013 std::string ex(str, iter.base());
14014 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14015 assert(ios.width() == 0);
14016 }
14017 ios.width(25);
14018 left(ios);
14019 {
14020 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14021 std::string ex(str, iter.base());
14022 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14023 assert(ios.width() == 0);
14024 }
14025 ios.width(25);
14026 right(ios);
14027 {
14028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14029 std::string ex(str, iter.base());
14030 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14031 assert(ios.width() == 0);
14032 }
14033 ios.width(25);
14034 internal(ios);
14035 {
14036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14037 std::string ex(str, iter.base());
14038 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14039 assert(ios.width() == 0);
14040 }
14041 }
14042 ios.imbue(lg);
14043 {
14044 ios.width(0);
14045 {
14046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14047 std::string ex(str, iter.base());
14048 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14049 assert(ios.width() == 0);
14050 }
14051 ios.width(25);
14052 left(ios);
14053 {
14054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14055 std::string ex(str, iter.base());
14056 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14057 assert(ios.width() == 0);
14058 }
14059 ios.width(25);
14060 right(ios);
14061 {
14062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14063 std::string ex(str, iter.base());
14064 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14065 assert(ios.width() == 0);
14066 }
14067 ios.width(25);
14068 internal(ios);
14069 {
14070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14071 std::string ex(str, iter.base());
14072 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14073 assert(ios.width() == 0);
14074 }
14075 }
14076 }
14077 showpoint(ios);
14078 {
14079 ios.imbue(lc);
14080 {
14081 ios.width(0);
14082 {
14083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14084 std::string ex(str, iter.base());
14085 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14086 assert(ios.width() == 0);
14087 }
14088 ios.width(25);
14089 left(ios);
14090 {
14091 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14092 std::string ex(str, iter.base());
14093 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14094 assert(ios.width() == 0);
14095 }
14096 ios.width(25);
14097 right(ios);
14098 {
14099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14100 std::string ex(str, iter.base());
14101 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14102 assert(ios.width() == 0);
14103 }
14104 ios.width(25);
14105 internal(ios);
14106 {
14107 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14108 std::string ex(str, iter.base());
14109 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14110 assert(ios.width() == 0);
14111 }
14112 }
14113 ios.imbue(lg);
14114 {
14115 ios.width(0);
14116 {
14117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14118 std::string ex(str, iter.base());
14119 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14120 assert(ios.width() == 0);
14121 }
14122 ios.width(25);
14123 left(ios);
14124 {
14125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14126 std::string ex(str, iter.base());
14127 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14128 assert(ios.width() == 0);
14129 }
14130 ios.width(25);
14131 right(ios);
14132 {
14133 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14134 std::string ex(str, iter.base());
14135 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14136 assert(ios.width() == 0);
14137 }
14138 ios.width(25);
14139 internal(ios);
14140 {
14141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14142 std::string ex(str, iter.base());
14143 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14144 assert(ios.width() == 0);
14145 }
14146 }
14147 }
14148 }
14149 showpos(ios);
14150 {
14151 noshowpoint(ios);
14152 {
14153 ios.imbue(lc);
14154 {
14155 ios.width(0);
14156 {
14157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14158 std::string ex(str, iter.base());
14159 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14160 assert(ios.width() == 0);
14161 }
14162 ios.width(25);
14163 left(ios);
14164 {
14165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14166 std::string ex(str, iter.base());
14167 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14168 assert(ios.width() == 0);
14169 }
14170 ios.width(25);
14171 right(ios);
14172 {
14173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14174 std::string ex(str, iter.base());
14175 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14176 assert(ios.width() == 0);
14177 }
14178 ios.width(25);
14179 internal(ios);
14180 {
14181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14182 std::string ex(str, iter.base());
14183 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14184 assert(ios.width() == 0);
14185 }
14186 }
14187 ios.imbue(lg);
14188 {
14189 ios.width(0);
14190 {
14191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14192 std::string ex(str, iter.base());
14193 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14194 assert(ios.width() == 0);
14195 }
14196 ios.width(25);
14197 left(ios);
14198 {
14199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14200 std::string ex(str, iter.base());
14201 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14202 assert(ios.width() == 0);
14203 }
14204 ios.width(25);
14205 right(ios);
14206 {
14207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14208 std::string ex(str, iter.base());
14209 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14210 assert(ios.width() == 0);
14211 }
14212 ios.width(25);
14213 internal(ios);
14214 {
14215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14216 std::string ex(str, iter.base());
14217 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14218 assert(ios.width() == 0);
14219 }
14220 }
14221 }
14222 showpoint(ios);
14223 {
14224 ios.imbue(lc);
14225 {
14226 ios.width(0);
14227 {
14228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14229 std::string ex(str, iter.base());
14230 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14231 assert(ios.width() == 0);
14232 }
14233 ios.width(25);
14234 left(ios);
14235 {
14236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14237 std::string ex(str, iter.base());
14238 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14239 assert(ios.width() == 0);
14240 }
14241 ios.width(25);
14242 right(ios);
14243 {
14244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14245 std::string ex(str, iter.base());
14246 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14247 assert(ios.width() == 0);
14248 }
14249 ios.width(25);
14250 internal(ios);
14251 {
14252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14253 std::string ex(str, iter.base());
14254 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14255 assert(ios.width() == 0);
14256 }
14257 }
14258 ios.imbue(lg);
14259 {
14260 ios.width(0);
14261 {
14262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14263 std::string ex(str, iter.base());
14264 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14265 assert(ios.width() == 0);
14266 }
14267 ios.width(25);
14268 left(ios);
14269 {
14270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14271 std::string ex(str, iter.base());
14272 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14273 assert(ios.width() == 0);
14274 }
14275 ios.width(25);
14276 right(ios);
14277 {
14278 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14279 std::string ex(str, iter.base());
14280 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14281 assert(ios.width() == 0);
14282 }
14283 ios.width(25);
14284 internal(ios);
14285 {
14286 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14287 std::string ex(str, iter.base());
14288 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14289 assert(ios.width() == 0);
14290 }
14291 }
14292 }
14293 }
14294 }
14295 }
14296 }
14297 }
14298 }
14299
test7()14300 void test7()
14301 {
14302 char str[200];
14303 output_iterator<char*> iter;
14304 std::locale lc = std::locale::classic();
14305 std::locale lg(lc, new my_numpunct);
14306 const my_facet f(1);
14307 {
14308 double v = -0.;
14309 std::ios ios(0);
14310 hexfloat(ios);
14311 // %a
14312 {
14313 ios.precision(0);
14314 {
14315 nouppercase(ios);
14316 {
14317 noshowpos(ios);
14318 {
14319 noshowpoint(ios);
14320 {
14321 ios.imbue(lc);
14322 {
14323 ios.width(0);
14324 {
14325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14326 std::string ex(str, iter.base());
14327 assert(ex == "-0x0p+0");
14328 assert(ios.width() == 0);
14329 }
14330 ios.width(25);
14331 left(ios);
14332 {
14333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14334 std::string ex(str, iter.base());
14335 assert(ex == "-0x0p+0******************");
14336 assert(ios.width() == 0);
14337 }
14338 ios.width(25);
14339 right(ios);
14340 {
14341 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14342 std::string ex(str, iter.base());
14343 assert(ex == "******************-0x0p+0");
14344 assert(ios.width() == 0);
14345 }
14346 ios.width(25);
14347 internal(ios);
14348 {
14349 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14350 std::string ex(str, iter.base());
14351 assert(ex == "-******************0x0p+0");
14352 assert(ios.width() == 0);
14353 }
14354 }
14355 ios.imbue(lg);
14356 {
14357 ios.width(0);
14358 {
14359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14360 std::string ex(str, iter.base());
14361 assert(ex == "-0x0p+0");
14362 assert(ios.width() == 0);
14363 }
14364 ios.width(25);
14365 left(ios);
14366 {
14367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14368 std::string ex(str, iter.base());
14369 assert(ex == "-0x0p+0******************");
14370 assert(ios.width() == 0);
14371 }
14372 ios.width(25);
14373 right(ios);
14374 {
14375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14376 std::string ex(str, iter.base());
14377 assert(ex == "******************-0x0p+0");
14378 assert(ios.width() == 0);
14379 }
14380 ios.width(25);
14381 internal(ios);
14382 {
14383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14384 std::string ex(str, iter.base());
14385 assert(ex == "-******************0x0p+0");
14386 assert(ios.width() == 0);
14387 }
14388 }
14389 }
14390 showpoint(ios);
14391 {
14392 ios.imbue(lc);
14393 {
14394 ios.width(0);
14395 {
14396 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14397 std::string ex(str, iter.base());
14398 assert(ex == "-0x0.p+0");
14399 assert(ios.width() == 0);
14400 }
14401 ios.width(25);
14402 left(ios);
14403 {
14404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14405 std::string ex(str, iter.base());
14406 assert(ex == "-0x0.p+0*****************");
14407 assert(ios.width() == 0);
14408 }
14409 ios.width(25);
14410 right(ios);
14411 {
14412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14413 std::string ex(str, iter.base());
14414 assert(ex == "*****************-0x0.p+0");
14415 assert(ios.width() == 0);
14416 }
14417 ios.width(25);
14418 internal(ios);
14419 {
14420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14421 std::string ex(str, iter.base());
14422 assert(ex == "-*****************0x0.p+0");
14423 assert(ios.width() == 0);
14424 }
14425 }
14426 ios.imbue(lg);
14427 {
14428 ios.width(0);
14429 {
14430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14431 std::string ex(str, iter.base());
14432 assert(ex == "-0x0;p+0");
14433 assert(ios.width() == 0);
14434 }
14435 ios.width(25);
14436 left(ios);
14437 {
14438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14439 std::string ex(str, iter.base());
14440 assert(ex == "-0x0;p+0*****************");
14441 assert(ios.width() == 0);
14442 }
14443 ios.width(25);
14444 right(ios);
14445 {
14446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14447 std::string ex(str, iter.base());
14448 assert(ex == "*****************-0x0;p+0");
14449 assert(ios.width() == 0);
14450 }
14451 ios.width(25);
14452 internal(ios);
14453 {
14454 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14455 std::string ex(str, iter.base());
14456 assert(ex == "-*****************0x0;p+0");
14457 assert(ios.width() == 0);
14458 }
14459 }
14460 }
14461 }
14462 showpos(ios);
14463 {
14464 noshowpoint(ios);
14465 {
14466 ios.imbue(lc);
14467 {
14468 ios.width(0);
14469 {
14470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14471 std::string ex(str, iter.base());
14472 assert(ex == "-0x0p+0");
14473 assert(ios.width() == 0);
14474 }
14475 ios.width(25);
14476 left(ios);
14477 {
14478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14479 std::string ex(str, iter.base());
14480 assert(ex == "-0x0p+0******************");
14481 assert(ios.width() == 0);
14482 }
14483 ios.width(25);
14484 right(ios);
14485 {
14486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14487 std::string ex(str, iter.base());
14488 assert(ex == "******************-0x0p+0");
14489 assert(ios.width() == 0);
14490 }
14491 ios.width(25);
14492 internal(ios);
14493 {
14494 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14495 std::string ex(str, iter.base());
14496 assert(ex == "-******************0x0p+0");
14497 assert(ios.width() == 0);
14498 }
14499 }
14500 ios.imbue(lg);
14501 {
14502 ios.width(0);
14503 {
14504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14505 std::string ex(str, iter.base());
14506 assert(ex == "-0x0p+0");
14507 assert(ios.width() == 0);
14508 }
14509 ios.width(25);
14510 left(ios);
14511 {
14512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14513 std::string ex(str, iter.base());
14514 assert(ex == "-0x0p+0******************");
14515 assert(ios.width() == 0);
14516 }
14517 ios.width(25);
14518 right(ios);
14519 {
14520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14521 std::string ex(str, iter.base());
14522 assert(ex == "******************-0x0p+0");
14523 assert(ios.width() == 0);
14524 }
14525 ios.width(25);
14526 internal(ios);
14527 {
14528 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14529 std::string ex(str, iter.base());
14530 assert(ex == "-******************0x0p+0");
14531 assert(ios.width() == 0);
14532 }
14533 }
14534 }
14535 showpoint(ios);
14536 {
14537 ios.imbue(lc);
14538 {
14539 ios.width(0);
14540 {
14541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14542 std::string ex(str, iter.base());
14543 assert(ex == "-0x0.p+0");
14544 assert(ios.width() == 0);
14545 }
14546 ios.width(25);
14547 left(ios);
14548 {
14549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14550 std::string ex(str, iter.base());
14551 assert(ex == "-0x0.p+0*****************");
14552 assert(ios.width() == 0);
14553 }
14554 ios.width(25);
14555 right(ios);
14556 {
14557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14558 std::string ex(str, iter.base());
14559 assert(ex == "*****************-0x0.p+0");
14560 assert(ios.width() == 0);
14561 }
14562 ios.width(25);
14563 internal(ios);
14564 {
14565 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14566 std::string ex(str, iter.base());
14567 assert(ex == "-*****************0x0.p+0");
14568 assert(ios.width() == 0);
14569 }
14570 }
14571 ios.imbue(lg);
14572 {
14573 ios.width(0);
14574 {
14575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14576 std::string ex(str, iter.base());
14577 assert(ex == "-0x0;p+0");
14578 assert(ios.width() == 0);
14579 }
14580 ios.width(25);
14581 left(ios);
14582 {
14583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14584 std::string ex(str, iter.base());
14585 assert(ex == "-0x0;p+0*****************");
14586 assert(ios.width() == 0);
14587 }
14588 ios.width(25);
14589 right(ios);
14590 {
14591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14592 std::string ex(str, iter.base());
14593 assert(ex == "*****************-0x0;p+0");
14594 assert(ios.width() == 0);
14595 }
14596 ios.width(25);
14597 internal(ios);
14598 {
14599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14600 std::string ex(str, iter.base());
14601 assert(ex == "-*****************0x0;p+0");
14602 assert(ios.width() == 0);
14603 }
14604 }
14605 }
14606 }
14607 }
14608 uppercase(ios);
14609 {
14610 noshowpos(ios);
14611 {
14612 noshowpoint(ios);
14613 {
14614 ios.imbue(lc);
14615 {
14616 ios.width(0);
14617 {
14618 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14619 std::string ex(str, iter.base());
14620 assert(ex == "-0X0P+0");
14621 assert(ios.width() == 0);
14622 }
14623 ios.width(25);
14624 left(ios);
14625 {
14626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14627 std::string ex(str, iter.base());
14628 assert(ex == "-0X0P+0******************");
14629 assert(ios.width() == 0);
14630 }
14631 ios.width(25);
14632 right(ios);
14633 {
14634 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14635 std::string ex(str, iter.base());
14636 assert(ex == "******************-0X0P+0");
14637 assert(ios.width() == 0);
14638 }
14639 ios.width(25);
14640 internal(ios);
14641 {
14642 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14643 std::string ex(str, iter.base());
14644 assert(ex == "-******************0X0P+0");
14645 assert(ios.width() == 0);
14646 }
14647 }
14648 ios.imbue(lg);
14649 {
14650 ios.width(0);
14651 {
14652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14653 std::string ex(str, iter.base());
14654 assert(ex == "-0X0P+0");
14655 assert(ios.width() == 0);
14656 }
14657 ios.width(25);
14658 left(ios);
14659 {
14660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14661 std::string ex(str, iter.base());
14662 assert(ex == "-0X0P+0******************");
14663 assert(ios.width() == 0);
14664 }
14665 ios.width(25);
14666 right(ios);
14667 {
14668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14669 std::string ex(str, iter.base());
14670 assert(ex == "******************-0X0P+0");
14671 assert(ios.width() == 0);
14672 }
14673 ios.width(25);
14674 internal(ios);
14675 {
14676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14677 std::string ex(str, iter.base());
14678 assert(ex == "-******************0X0P+0");
14679 assert(ios.width() == 0);
14680 }
14681 }
14682 }
14683 showpoint(ios);
14684 {
14685 ios.imbue(lc);
14686 {
14687 ios.width(0);
14688 {
14689 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14690 std::string ex(str, iter.base());
14691 assert(ex == "-0X0.P+0");
14692 assert(ios.width() == 0);
14693 }
14694 ios.width(25);
14695 left(ios);
14696 {
14697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14698 std::string ex(str, iter.base());
14699 assert(ex == "-0X0.P+0*****************");
14700 assert(ios.width() == 0);
14701 }
14702 ios.width(25);
14703 right(ios);
14704 {
14705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14706 std::string ex(str, iter.base());
14707 assert(ex == "*****************-0X0.P+0");
14708 assert(ios.width() == 0);
14709 }
14710 ios.width(25);
14711 internal(ios);
14712 {
14713 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14714 std::string ex(str, iter.base());
14715 assert(ex == "-*****************0X0.P+0");
14716 assert(ios.width() == 0);
14717 }
14718 }
14719 ios.imbue(lg);
14720 {
14721 ios.width(0);
14722 {
14723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14724 std::string ex(str, iter.base());
14725 assert(ex == "-0X0;P+0");
14726 assert(ios.width() == 0);
14727 }
14728 ios.width(25);
14729 left(ios);
14730 {
14731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14732 std::string ex(str, iter.base());
14733 assert(ex == "-0X0;P+0*****************");
14734 assert(ios.width() == 0);
14735 }
14736 ios.width(25);
14737 right(ios);
14738 {
14739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14740 std::string ex(str, iter.base());
14741 assert(ex == "*****************-0X0;P+0");
14742 assert(ios.width() == 0);
14743 }
14744 ios.width(25);
14745 internal(ios);
14746 {
14747 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14748 std::string ex(str, iter.base());
14749 assert(ex == "-*****************0X0;P+0");
14750 assert(ios.width() == 0);
14751 }
14752 }
14753 }
14754 }
14755 showpos(ios);
14756 {
14757 noshowpoint(ios);
14758 {
14759 ios.imbue(lc);
14760 {
14761 ios.width(0);
14762 {
14763 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14764 std::string ex(str, iter.base());
14765 assert(ex == "-0X0P+0");
14766 assert(ios.width() == 0);
14767 }
14768 ios.width(25);
14769 left(ios);
14770 {
14771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14772 std::string ex(str, iter.base());
14773 assert(ex == "-0X0P+0******************");
14774 assert(ios.width() == 0);
14775 }
14776 ios.width(25);
14777 right(ios);
14778 {
14779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14780 std::string ex(str, iter.base());
14781 assert(ex == "******************-0X0P+0");
14782 assert(ios.width() == 0);
14783 }
14784 ios.width(25);
14785 internal(ios);
14786 {
14787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14788 std::string ex(str, iter.base());
14789 assert(ex == "-******************0X0P+0");
14790 assert(ios.width() == 0);
14791 }
14792 }
14793 ios.imbue(lg);
14794 {
14795 ios.width(0);
14796 {
14797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14798 std::string ex(str, iter.base());
14799 assert(ex == "-0X0P+0");
14800 assert(ios.width() == 0);
14801 }
14802 ios.width(25);
14803 left(ios);
14804 {
14805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14806 std::string ex(str, iter.base());
14807 assert(ex == "-0X0P+0******************");
14808 assert(ios.width() == 0);
14809 }
14810 ios.width(25);
14811 right(ios);
14812 {
14813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14814 std::string ex(str, iter.base());
14815 assert(ex == "******************-0X0P+0");
14816 assert(ios.width() == 0);
14817 }
14818 ios.width(25);
14819 internal(ios);
14820 {
14821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14822 std::string ex(str, iter.base());
14823 assert(ex == "-******************0X0P+0");
14824 assert(ios.width() == 0);
14825 }
14826 }
14827 }
14828 showpoint(ios);
14829 {
14830 ios.imbue(lc);
14831 {
14832 ios.width(0);
14833 {
14834 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14835 std::string ex(str, iter.base());
14836 assert(ex == "-0X0.P+0");
14837 assert(ios.width() == 0);
14838 }
14839 ios.width(25);
14840 left(ios);
14841 {
14842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14843 std::string ex(str, iter.base());
14844 assert(ex == "-0X0.P+0*****************");
14845 assert(ios.width() == 0);
14846 }
14847 ios.width(25);
14848 right(ios);
14849 {
14850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14851 std::string ex(str, iter.base());
14852 assert(ex == "*****************-0X0.P+0");
14853 assert(ios.width() == 0);
14854 }
14855 ios.width(25);
14856 internal(ios);
14857 {
14858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14859 std::string ex(str, iter.base());
14860 assert(ex == "-*****************0X0.P+0");
14861 assert(ios.width() == 0);
14862 }
14863 }
14864 ios.imbue(lg);
14865 {
14866 ios.width(0);
14867 {
14868 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14869 std::string ex(str, iter.base());
14870 assert(ex == "-0X0;P+0");
14871 assert(ios.width() == 0);
14872 }
14873 ios.width(25);
14874 left(ios);
14875 {
14876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14877 std::string ex(str, iter.base());
14878 assert(ex == "-0X0;P+0*****************");
14879 assert(ios.width() == 0);
14880 }
14881 ios.width(25);
14882 right(ios);
14883 {
14884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14885 std::string ex(str, iter.base());
14886 assert(ex == "*****************-0X0;P+0");
14887 assert(ios.width() == 0);
14888 }
14889 ios.width(25);
14890 internal(ios);
14891 {
14892 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14893 std::string ex(str, iter.base());
14894 assert(ex == "-*****************0X0;P+0");
14895 assert(ios.width() == 0);
14896 }
14897 }
14898 }
14899 }
14900 }
14901 }
14902 ios.precision(1);
14903 {
14904 nouppercase(ios);
14905 {
14906 noshowpos(ios);
14907 {
14908 noshowpoint(ios);
14909 {
14910 ios.imbue(lc);
14911 {
14912 ios.width(0);
14913 {
14914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14915 std::string ex(str, iter.base());
14916 assert(ex == "-0x0p+0");
14917 assert(ios.width() == 0);
14918 }
14919 ios.width(25);
14920 left(ios);
14921 {
14922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14923 std::string ex(str, iter.base());
14924 assert(ex == "-0x0p+0******************");
14925 assert(ios.width() == 0);
14926 }
14927 ios.width(25);
14928 right(ios);
14929 {
14930 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14931 std::string ex(str, iter.base());
14932 assert(ex == "******************-0x0p+0");
14933 assert(ios.width() == 0);
14934 }
14935 ios.width(25);
14936 internal(ios);
14937 {
14938 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14939 std::string ex(str, iter.base());
14940 assert(ex == "-******************0x0p+0");
14941 assert(ios.width() == 0);
14942 }
14943 }
14944 ios.imbue(lg);
14945 {
14946 ios.width(0);
14947 {
14948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14949 std::string ex(str, iter.base());
14950 assert(ex == "-0x0p+0");
14951 assert(ios.width() == 0);
14952 }
14953 ios.width(25);
14954 left(ios);
14955 {
14956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14957 std::string ex(str, iter.base());
14958 assert(ex == "-0x0p+0******************");
14959 assert(ios.width() == 0);
14960 }
14961 ios.width(25);
14962 right(ios);
14963 {
14964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14965 std::string ex(str, iter.base());
14966 assert(ex == "******************-0x0p+0");
14967 assert(ios.width() == 0);
14968 }
14969 ios.width(25);
14970 internal(ios);
14971 {
14972 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14973 std::string ex(str, iter.base());
14974 assert(ex == "-******************0x0p+0");
14975 assert(ios.width() == 0);
14976 }
14977 }
14978 }
14979 showpoint(ios);
14980 {
14981 ios.imbue(lc);
14982 {
14983 ios.width(0);
14984 {
14985 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14986 std::string ex(str, iter.base());
14987 assert(ex == "-0x0.p+0");
14988 assert(ios.width() == 0);
14989 }
14990 ios.width(25);
14991 left(ios);
14992 {
14993 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14994 std::string ex(str, iter.base());
14995 assert(ex == "-0x0.p+0*****************");
14996 assert(ios.width() == 0);
14997 }
14998 ios.width(25);
14999 right(ios);
15000 {
15001 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15002 std::string ex(str, iter.base());
15003 assert(ex == "*****************-0x0.p+0");
15004 assert(ios.width() == 0);
15005 }
15006 ios.width(25);
15007 internal(ios);
15008 {
15009 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15010 std::string ex(str, iter.base());
15011 assert(ex == "-*****************0x0.p+0");
15012 assert(ios.width() == 0);
15013 }
15014 }
15015 ios.imbue(lg);
15016 {
15017 ios.width(0);
15018 {
15019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15020 std::string ex(str, iter.base());
15021 assert(ex == "-0x0;p+0");
15022 assert(ios.width() == 0);
15023 }
15024 ios.width(25);
15025 left(ios);
15026 {
15027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15028 std::string ex(str, iter.base());
15029 assert(ex == "-0x0;p+0*****************");
15030 assert(ios.width() == 0);
15031 }
15032 ios.width(25);
15033 right(ios);
15034 {
15035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15036 std::string ex(str, iter.base());
15037 assert(ex == "*****************-0x0;p+0");
15038 assert(ios.width() == 0);
15039 }
15040 ios.width(25);
15041 internal(ios);
15042 {
15043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15044 std::string ex(str, iter.base());
15045 assert(ex == "-*****************0x0;p+0");
15046 assert(ios.width() == 0);
15047 }
15048 }
15049 }
15050 }
15051 showpos(ios);
15052 {
15053 noshowpoint(ios);
15054 {
15055 ios.imbue(lc);
15056 {
15057 ios.width(0);
15058 {
15059 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15060 std::string ex(str, iter.base());
15061 assert(ex == "-0x0p+0");
15062 assert(ios.width() == 0);
15063 }
15064 ios.width(25);
15065 left(ios);
15066 {
15067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15068 std::string ex(str, iter.base());
15069 assert(ex == "-0x0p+0******************");
15070 assert(ios.width() == 0);
15071 }
15072 ios.width(25);
15073 right(ios);
15074 {
15075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15076 std::string ex(str, iter.base());
15077 assert(ex == "******************-0x0p+0");
15078 assert(ios.width() == 0);
15079 }
15080 ios.width(25);
15081 internal(ios);
15082 {
15083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15084 std::string ex(str, iter.base());
15085 assert(ex == "-******************0x0p+0");
15086 assert(ios.width() == 0);
15087 }
15088 }
15089 ios.imbue(lg);
15090 {
15091 ios.width(0);
15092 {
15093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15094 std::string ex(str, iter.base());
15095 assert(ex == "-0x0p+0");
15096 assert(ios.width() == 0);
15097 }
15098 ios.width(25);
15099 left(ios);
15100 {
15101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15102 std::string ex(str, iter.base());
15103 assert(ex == "-0x0p+0******************");
15104 assert(ios.width() == 0);
15105 }
15106 ios.width(25);
15107 right(ios);
15108 {
15109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15110 std::string ex(str, iter.base());
15111 assert(ex == "******************-0x0p+0");
15112 assert(ios.width() == 0);
15113 }
15114 ios.width(25);
15115 internal(ios);
15116 {
15117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15118 std::string ex(str, iter.base());
15119 assert(ex == "-******************0x0p+0");
15120 assert(ios.width() == 0);
15121 }
15122 }
15123 }
15124 showpoint(ios);
15125 {
15126 ios.imbue(lc);
15127 {
15128 ios.width(0);
15129 {
15130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15131 std::string ex(str, iter.base());
15132 assert(ex == "-0x0.p+0");
15133 assert(ios.width() == 0);
15134 }
15135 ios.width(25);
15136 left(ios);
15137 {
15138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15139 std::string ex(str, iter.base());
15140 assert(ex == "-0x0.p+0*****************");
15141 assert(ios.width() == 0);
15142 }
15143 ios.width(25);
15144 right(ios);
15145 {
15146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15147 std::string ex(str, iter.base());
15148 assert(ex == "*****************-0x0.p+0");
15149 assert(ios.width() == 0);
15150 }
15151 ios.width(25);
15152 internal(ios);
15153 {
15154 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15155 std::string ex(str, iter.base());
15156 assert(ex == "-*****************0x0.p+0");
15157 assert(ios.width() == 0);
15158 }
15159 }
15160 ios.imbue(lg);
15161 {
15162 ios.width(0);
15163 {
15164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15165 std::string ex(str, iter.base());
15166 assert(ex == "-0x0;p+0");
15167 assert(ios.width() == 0);
15168 }
15169 ios.width(25);
15170 left(ios);
15171 {
15172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15173 std::string ex(str, iter.base());
15174 assert(ex == "-0x0;p+0*****************");
15175 assert(ios.width() == 0);
15176 }
15177 ios.width(25);
15178 right(ios);
15179 {
15180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15181 std::string ex(str, iter.base());
15182 assert(ex == "*****************-0x0;p+0");
15183 assert(ios.width() == 0);
15184 }
15185 ios.width(25);
15186 internal(ios);
15187 {
15188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15189 std::string ex(str, iter.base());
15190 assert(ex == "-*****************0x0;p+0");
15191 assert(ios.width() == 0);
15192 }
15193 }
15194 }
15195 }
15196 }
15197 uppercase(ios);
15198 {
15199 noshowpos(ios);
15200 {
15201 noshowpoint(ios);
15202 {
15203 ios.imbue(lc);
15204 {
15205 ios.width(0);
15206 {
15207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15208 std::string ex(str, iter.base());
15209 assert(ex == "-0X0P+0");
15210 assert(ios.width() == 0);
15211 }
15212 ios.width(25);
15213 left(ios);
15214 {
15215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15216 std::string ex(str, iter.base());
15217 assert(ex == "-0X0P+0******************");
15218 assert(ios.width() == 0);
15219 }
15220 ios.width(25);
15221 right(ios);
15222 {
15223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15224 std::string ex(str, iter.base());
15225 assert(ex == "******************-0X0P+0");
15226 assert(ios.width() == 0);
15227 }
15228 ios.width(25);
15229 internal(ios);
15230 {
15231 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15232 std::string ex(str, iter.base());
15233 assert(ex == "-******************0X0P+0");
15234 assert(ios.width() == 0);
15235 }
15236 }
15237 ios.imbue(lg);
15238 {
15239 ios.width(0);
15240 {
15241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15242 std::string ex(str, iter.base());
15243 assert(ex == "-0X0P+0");
15244 assert(ios.width() == 0);
15245 }
15246 ios.width(25);
15247 left(ios);
15248 {
15249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15250 std::string ex(str, iter.base());
15251 assert(ex == "-0X0P+0******************");
15252 assert(ios.width() == 0);
15253 }
15254 ios.width(25);
15255 right(ios);
15256 {
15257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15258 std::string ex(str, iter.base());
15259 assert(ex == "******************-0X0P+0");
15260 assert(ios.width() == 0);
15261 }
15262 ios.width(25);
15263 internal(ios);
15264 {
15265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15266 std::string ex(str, iter.base());
15267 assert(ex == "-******************0X0P+0");
15268 assert(ios.width() == 0);
15269 }
15270 }
15271 }
15272 showpoint(ios);
15273 {
15274 ios.imbue(lc);
15275 {
15276 ios.width(0);
15277 {
15278 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15279 std::string ex(str, iter.base());
15280 assert(ex == "-0X0.P+0");
15281 assert(ios.width() == 0);
15282 }
15283 ios.width(25);
15284 left(ios);
15285 {
15286 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15287 std::string ex(str, iter.base());
15288 assert(ex == "-0X0.P+0*****************");
15289 assert(ios.width() == 0);
15290 }
15291 ios.width(25);
15292 right(ios);
15293 {
15294 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15295 std::string ex(str, iter.base());
15296 assert(ex == "*****************-0X0.P+0");
15297 assert(ios.width() == 0);
15298 }
15299 ios.width(25);
15300 internal(ios);
15301 {
15302 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15303 std::string ex(str, iter.base());
15304 assert(ex == "-*****************0X0.P+0");
15305 assert(ios.width() == 0);
15306 }
15307 }
15308 ios.imbue(lg);
15309 {
15310 ios.width(0);
15311 {
15312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15313 std::string ex(str, iter.base());
15314 assert(ex == "-0X0;P+0");
15315 assert(ios.width() == 0);
15316 }
15317 ios.width(25);
15318 left(ios);
15319 {
15320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15321 std::string ex(str, iter.base());
15322 assert(ex == "-0X0;P+0*****************");
15323 assert(ios.width() == 0);
15324 }
15325 ios.width(25);
15326 right(ios);
15327 {
15328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15329 std::string ex(str, iter.base());
15330 assert(ex == "*****************-0X0;P+0");
15331 assert(ios.width() == 0);
15332 }
15333 ios.width(25);
15334 internal(ios);
15335 {
15336 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15337 std::string ex(str, iter.base());
15338 assert(ex == "-*****************0X0;P+0");
15339 assert(ios.width() == 0);
15340 }
15341 }
15342 }
15343 }
15344 showpos(ios);
15345 {
15346 noshowpoint(ios);
15347 {
15348 ios.imbue(lc);
15349 {
15350 ios.width(0);
15351 {
15352 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15353 std::string ex(str, iter.base());
15354 assert(ex == "-0X0P+0");
15355 assert(ios.width() == 0);
15356 }
15357 ios.width(25);
15358 left(ios);
15359 {
15360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15361 std::string ex(str, iter.base());
15362 assert(ex == "-0X0P+0******************");
15363 assert(ios.width() == 0);
15364 }
15365 ios.width(25);
15366 right(ios);
15367 {
15368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15369 std::string ex(str, iter.base());
15370 assert(ex == "******************-0X0P+0");
15371 assert(ios.width() == 0);
15372 }
15373 ios.width(25);
15374 internal(ios);
15375 {
15376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15377 std::string ex(str, iter.base());
15378 assert(ex == "-******************0X0P+0");
15379 assert(ios.width() == 0);
15380 }
15381 }
15382 ios.imbue(lg);
15383 {
15384 ios.width(0);
15385 {
15386 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15387 std::string ex(str, iter.base());
15388 assert(ex == "-0X0P+0");
15389 assert(ios.width() == 0);
15390 }
15391 ios.width(25);
15392 left(ios);
15393 {
15394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15395 std::string ex(str, iter.base());
15396 assert(ex == "-0X0P+0******************");
15397 assert(ios.width() == 0);
15398 }
15399 ios.width(25);
15400 right(ios);
15401 {
15402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15403 std::string ex(str, iter.base());
15404 assert(ex == "******************-0X0P+0");
15405 assert(ios.width() == 0);
15406 }
15407 ios.width(25);
15408 internal(ios);
15409 {
15410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15411 std::string ex(str, iter.base());
15412 assert(ex == "-******************0X0P+0");
15413 assert(ios.width() == 0);
15414 }
15415 }
15416 }
15417 showpoint(ios);
15418 {
15419 ios.imbue(lc);
15420 {
15421 ios.width(0);
15422 {
15423 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15424 std::string ex(str, iter.base());
15425 assert(ex == "-0X0.P+0");
15426 assert(ios.width() == 0);
15427 }
15428 ios.width(25);
15429 left(ios);
15430 {
15431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15432 std::string ex(str, iter.base());
15433 assert(ex == "-0X0.P+0*****************");
15434 assert(ios.width() == 0);
15435 }
15436 ios.width(25);
15437 right(ios);
15438 {
15439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15440 std::string ex(str, iter.base());
15441 assert(ex == "*****************-0X0.P+0");
15442 assert(ios.width() == 0);
15443 }
15444 ios.width(25);
15445 internal(ios);
15446 {
15447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15448 std::string ex(str, iter.base());
15449 assert(ex == "-*****************0X0.P+0");
15450 assert(ios.width() == 0);
15451 }
15452 }
15453 ios.imbue(lg);
15454 {
15455 ios.width(0);
15456 {
15457 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15458 std::string ex(str, iter.base());
15459 assert(ex == "-0X0;P+0");
15460 assert(ios.width() == 0);
15461 }
15462 ios.width(25);
15463 left(ios);
15464 {
15465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15466 std::string ex(str, iter.base());
15467 assert(ex == "-0X0;P+0*****************");
15468 assert(ios.width() == 0);
15469 }
15470 ios.width(25);
15471 right(ios);
15472 {
15473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15474 std::string ex(str, iter.base());
15475 assert(ex == "*****************-0X0;P+0");
15476 assert(ios.width() == 0);
15477 }
15478 ios.width(25);
15479 internal(ios);
15480 {
15481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15482 std::string ex(str, iter.base());
15483 assert(ex == "-*****************0X0;P+0");
15484 assert(ios.width() == 0);
15485 }
15486 }
15487 }
15488 }
15489 }
15490 }
15491 ios.precision(6);
15492 {
15493 nouppercase(ios);
15494 {
15495 noshowpos(ios);
15496 {
15497 noshowpoint(ios);
15498 {
15499 ios.imbue(lc);
15500 {
15501 ios.width(0);
15502 {
15503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15504 std::string ex(str, iter.base());
15505 assert(ex == "-0x0p+0");
15506 assert(ios.width() == 0);
15507 }
15508 ios.width(25);
15509 left(ios);
15510 {
15511 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15512 std::string ex(str, iter.base());
15513 assert(ex == "-0x0p+0******************");
15514 assert(ios.width() == 0);
15515 }
15516 ios.width(25);
15517 right(ios);
15518 {
15519 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15520 std::string ex(str, iter.base());
15521 assert(ex == "******************-0x0p+0");
15522 assert(ios.width() == 0);
15523 }
15524 ios.width(25);
15525 internal(ios);
15526 {
15527 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15528 std::string ex(str, iter.base());
15529 assert(ex == "-******************0x0p+0");
15530 assert(ios.width() == 0);
15531 }
15532 }
15533 ios.imbue(lg);
15534 {
15535 ios.width(0);
15536 {
15537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15538 std::string ex(str, iter.base());
15539 assert(ex == "-0x0p+0");
15540 assert(ios.width() == 0);
15541 }
15542 ios.width(25);
15543 left(ios);
15544 {
15545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15546 std::string ex(str, iter.base());
15547 assert(ex == "-0x0p+0******************");
15548 assert(ios.width() == 0);
15549 }
15550 ios.width(25);
15551 right(ios);
15552 {
15553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15554 std::string ex(str, iter.base());
15555 assert(ex == "******************-0x0p+0");
15556 assert(ios.width() == 0);
15557 }
15558 ios.width(25);
15559 internal(ios);
15560 {
15561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15562 std::string ex(str, iter.base());
15563 assert(ex == "-******************0x0p+0");
15564 assert(ios.width() == 0);
15565 }
15566 }
15567 }
15568 showpoint(ios);
15569 {
15570 ios.imbue(lc);
15571 {
15572 ios.width(0);
15573 {
15574 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15575 std::string ex(str, iter.base());
15576 assert(ex == "-0x0.p+0");
15577 assert(ios.width() == 0);
15578 }
15579 ios.width(25);
15580 left(ios);
15581 {
15582 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15583 std::string ex(str, iter.base());
15584 assert(ex == "-0x0.p+0*****************");
15585 assert(ios.width() == 0);
15586 }
15587 ios.width(25);
15588 right(ios);
15589 {
15590 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15591 std::string ex(str, iter.base());
15592 assert(ex == "*****************-0x0.p+0");
15593 assert(ios.width() == 0);
15594 }
15595 ios.width(25);
15596 internal(ios);
15597 {
15598 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15599 std::string ex(str, iter.base());
15600 assert(ex == "-*****************0x0.p+0");
15601 assert(ios.width() == 0);
15602 }
15603 }
15604 ios.imbue(lg);
15605 {
15606 ios.width(0);
15607 {
15608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15609 std::string ex(str, iter.base());
15610 assert(ex == "-0x0;p+0");
15611 assert(ios.width() == 0);
15612 }
15613 ios.width(25);
15614 left(ios);
15615 {
15616 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15617 std::string ex(str, iter.base());
15618 assert(ex == "-0x0;p+0*****************");
15619 assert(ios.width() == 0);
15620 }
15621 ios.width(25);
15622 right(ios);
15623 {
15624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15625 std::string ex(str, iter.base());
15626 assert(ex == "*****************-0x0;p+0");
15627 assert(ios.width() == 0);
15628 }
15629 ios.width(25);
15630 internal(ios);
15631 {
15632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15633 std::string ex(str, iter.base());
15634 assert(ex == "-*****************0x0;p+0");
15635 assert(ios.width() == 0);
15636 }
15637 }
15638 }
15639 }
15640 showpos(ios);
15641 {
15642 noshowpoint(ios);
15643 {
15644 ios.imbue(lc);
15645 {
15646 ios.width(0);
15647 {
15648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15649 std::string ex(str, iter.base());
15650 assert(ex == "-0x0p+0");
15651 assert(ios.width() == 0);
15652 }
15653 ios.width(25);
15654 left(ios);
15655 {
15656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15657 std::string ex(str, iter.base());
15658 assert(ex == "-0x0p+0******************");
15659 assert(ios.width() == 0);
15660 }
15661 ios.width(25);
15662 right(ios);
15663 {
15664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15665 std::string ex(str, iter.base());
15666 assert(ex == "******************-0x0p+0");
15667 assert(ios.width() == 0);
15668 }
15669 ios.width(25);
15670 internal(ios);
15671 {
15672 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15673 std::string ex(str, iter.base());
15674 assert(ex == "-******************0x0p+0");
15675 assert(ios.width() == 0);
15676 }
15677 }
15678 ios.imbue(lg);
15679 {
15680 ios.width(0);
15681 {
15682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15683 std::string ex(str, iter.base());
15684 assert(ex == "-0x0p+0");
15685 assert(ios.width() == 0);
15686 }
15687 ios.width(25);
15688 left(ios);
15689 {
15690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15691 std::string ex(str, iter.base());
15692 assert(ex == "-0x0p+0******************");
15693 assert(ios.width() == 0);
15694 }
15695 ios.width(25);
15696 right(ios);
15697 {
15698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15699 std::string ex(str, iter.base());
15700 assert(ex == "******************-0x0p+0");
15701 assert(ios.width() == 0);
15702 }
15703 ios.width(25);
15704 internal(ios);
15705 {
15706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15707 std::string ex(str, iter.base());
15708 assert(ex == "-******************0x0p+0");
15709 assert(ios.width() == 0);
15710 }
15711 }
15712 }
15713 showpoint(ios);
15714 {
15715 ios.imbue(lc);
15716 {
15717 ios.width(0);
15718 {
15719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15720 std::string ex(str, iter.base());
15721 assert(ex == "-0x0.p+0");
15722 assert(ios.width() == 0);
15723 }
15724 ios.width(25);
15725 left(ios);
15726 {
15727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15728 std::string ex(str, iter.base());
15729 assert(ex == "-0x0.p+0*****************");
15730 assert(ios.width() == 0);
15731 }
15732 ios.width(25);
15733 right(ios);
15734 {
15735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15736 std::string ex(str, iter.base());
15737 assert(ex == "*****************-0x0.p+0");
15738 assert(ios.width() == 0);
15739 }
15740 ios.width(25);
15741 internal(ios);
15742 {
15743 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15744 std::string ex(str, iter.base());
15745 assert(ex == "-*****************0x0.p+0");
15746 assert(ios.width() == 0);
15747 }
15748 }
15749 ios.imbue(lg);
15750 {
15751 ios.width(0);
15752 {
15753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15754 std::string ex(str, iter.base());
15755 assert(ex == "-0x0;p+0");
15756 assert(ios.width() == 0);
15757 }
15758 ios.width(25);
15759 left(ios);
15760 {
15761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15762 std::string ex(str, iter.base());
15763 assert(ex == "-0x0;p+0*****************");
15764 assert(ios.width() == 0);
15765 }
15766 ios.width(25);
15767 right(ios);
15768 {
15769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15770 std::string ex(str, iter.base());
15771 assert(ex == "*****************-0x0;p+0");
15772 assert(ios.width() == 0);
15773 }
15774 ios.width(25);
15775 internal(ios);
15776 {
15777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15778 std::string ex(str, iter.base());
15779 assert(ex == "-*****************0x0;p+0");
15780 assert(ios.width() == 0);
15781 }
15782 }
15783 }
15784 }
15785 }
15786 uppercase(ios);
15787 {
15788 noshowpos(ios);
15789 {
15790 noshowpoint(ios);
15791 {
15792 ios.imbue(lc);
15793 {
15794 ios.width(0);
15795 {
15796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15797 std::string ex(str, iter.base());
15798 assert(ex == "-0X0P+0");
15799 assert(ios.width() == 0);
15800 }
15801 ios.width(25);
15802 left(ios);
15803 {
15804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15805 std::string ex(str, iter.base());
15806 assert(ex == "-0X0P+0******************");
15807 assert(ios.width() == 0);
15808 }
15809 ios.width(25);
15810 right(ios);
15811 {
15812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15813 std::string ex(str, iter.base());
15814 assert(ex == "******************-0X0P+0");
15815 assert(ios.width() == 0);
15816 }
15817 ios.width(25);
15818 internal(ios);
15819 {
15820 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15821 std::string ex(str, iter.base());
15822 assert(ex == "-******************0X0P+0");
15823 assert(ios.width() == 0);
15824 }
15825 }
15826 ios.imbue(lg);
15827 {
15828 ios.width(0);
15829 {
15830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15831 std::string ex(str, iter.base());
15832 assert(ex == "-0X0P+0");
15833 assert(ios.width() == 0);
15834 }
15835 ios.width(25);
15836 left(ios);
15837 {
15838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15839 std::string ex(str, iter.base());
15840 assert(ex == "-0X0P+0******************");
15841 assert(ios.width() == 0);
15842 }
15843 ios.width(25);
15844 right(ios);
15845 {
15846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15847 std::string ex(str, iter.base());
15848 assert(ex == "******************-0X0P+0");
15849 assert(ios.width() == 0);
15850 }
15851 ios.width(25);
15852 internal(ios);
15853 {
15854 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15855 std::string ex(str, iter.base());
15856 assert(ex == "-******************0X0P+0");
15857 assert(ios.width() == 0);
15858 }
15859 }
15860 }
15861 showpoint(ios);
15862 {
15863 ios.imbue(lc);
15864 {
15865 ios.width(0);
15866 {
15867 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15868 std::string ex(str, iter.base());
15869 assert(ex == "-0X0.P+0");
15870 assert(ios.width() == 0);
15871 }
15872 ios.width(25);
15873 left(ios);
15874 {
15875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15876 std::string ex(str, iter.base());
15877 assert(ex == "-0X0.P+0*****************");
15878 assert(ios.width() == 0);
15879 }
15880 ios.width(25);
15881 right(ios);
15882 {
15883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15884 std::string ex(str, iter.base());
15885 assert(ex == "*****************-0X0.P+0");
15886 assert(ios.width() == 0);
15887 }
15888 ios.width(25);
15889 internal(ios);
15890 {
15891 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15892 std::string ex(str, iter.base());
15893 assert(ex == "-*****************0X0.P+0");
15894 assert(ios.width() == 0);
15895 }
15896 }
15897 ios.imbue(lg);
15898 {
15899 ios.width(0);
15900 {
15901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15902 std::string ex(str, iter.base());
15903 assert(ex == "-0X0;P+0");
15904 assert(ios.width() == 0);
15905 }
15906 ios.width(25);
15907 left(ios);
15908 {
15909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15910 std::string ex(str, iter.base());
15911 assert(ex == "-0X0;P+0*****************");
15912 assert(ios.width() == 0);
15913 }
15914 ios.width(25);
15915 right(ios);
15916 {
15917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15918 std::string ex(str, iter.base());
15919 assert(ex == "*****************-0X0;P+0");
15920 assert(ios.width() == 0);
15921 }
15922 ios.width(25);
15923 internal(ios);
15924 {
15925 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15926 std::string ex(str, iter.base());
15927 assert(ex == "-*****************0X0;P+0");
15928 assert(ios.width() == 0);
15929 }
15930 }
15931 }
15932 }
15933 showpos(ios);
15934 {
15935 noshowpoint(ios);
15936 {
15937 ios.imbue(lc);
15938 {
15939 ios.width(0);
15940 {
15941 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15942 std::string ex(str, iter.base());
15943 assert(ex == "-0X0P+0");
15944 assert(ios.width() == 0);
15945 }
15946 ios.width(25);
15947 left(ios);
15948 {
15949 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15950 std::string ex(str, iter.base());
15951 assert(ex == "-0X0P+0******************");
15952 assert(ios.width() == 0);
15953 }
15954 ios.width(25);
15955 right(ios);
15956 {
15957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15958 std::string ex(str, iter.base());
15959 assert(ex == "******************-0X0P+0");
15960 assert(ios.width() == 0);
15961 }
15962 ios.width(25);
15963 internal(ios);
15964 {
15965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15966 std::string ex(str, iter.base());
15967 assert(ex == "-******************0X0P+0");
15968 assert(ios.width() == 0);
15969 }
15970 }
15971 ios.imbue(lg);
15972 {
15973 ios.width(0);
15974 {
15975 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15976 std::string ex(str, iter.base());
15977 assert(ex == "-0X0P+0");
15978 assert(ios.width() == 0);
15979 }
15980 ios.width(25);
15981 left(ios);
15982 {
15983 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15984 std::string ex(str, iter.base());
15985 assert(ex == "-0X0P+0******************");
15986 assert(ios.width() == 0);
15987 }
15988 ios.width(25);
15989 right(ios);
15990 {
15991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15992 std::string ex(str, iter.base());
15993 assert(ex == "******************-0X0P+0");
15994 assert(ios.width() == 0);
15995 }
15996 ios.width(25);
15997 internal(ios);
15998 {
15999 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16000 std::string ex(str, iter.base());
16001 assert(ex == "-******************0X0P+0");
16002 assert(ios.width() == 0);
16003 }
16004 }
16005 }
16006 showpoint(ios);
16007 {
16008 ios.imbue(lc);
16009 {
16010 ios.width(0);
16011 {
16012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16013 std::string ex(str, iter.base());
16014 assert(ex == "-0X0.P+0");
16015 assert(ios.width() == 0);
16016 }
16017 ios.width(25);
16018 left(ios);
16019 {
16020 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16021 std::string ex(str, iter.base());
16022 assert(ex == "-0X0.P+0*****************");
16023 assert(ios.width() == 0);
16024 }
16025 ios.width(25);
16026 right(ios);
16027 {
16028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16029 std::string ex(str, iter.base());
16030 assert(ex == "*****************-0X0.P+0");
16031 assert(ios.width() == 0);
16032 }
16033 ios.width(25);
16034 internal(ios);
16035 {
16036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16037 std::string ex(str, iter.base());
16038 assert(ex == "-*****************0X0.P+0");
16039 assert(ios.width() == 0);
16040 }
16041 }
16042 ios.imbue(lg);
16043 {
16044 ios.width(0);
16045 {
16046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16047 std::string ex(str, iter.base());
16048 assert(ex == "-0X0;P+0");
16049 assert(ios.width() == 0);
16050 }
16051 ios.width(25);
16052 left(ios);
16053 {
16054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16055 std::string ex(str, iter.base());
16056 assert(ex == "-0X0;P+0*****************");
16057 assert(ios.width() == 0);
16058 }
16059 ios.width(25);
16060 right(ios);
16061 {
16062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16063 std::string ex(str, iter.base());
16064 assert(ex == "*****************-0X0;P+0");
16065 assert(ios.width() == 0);
16066 }
16067 ios.width(25);
16068 internal(ios);
16069 {
16070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16071 std::string ex(str, iter.base());
16072 assert(ex == "-*****************0X0;P+0");
16073 assert(ios.width() == 0);
16074 }
16075 }
16076 }
16077 }
16078 }
16079 }
16080 ios.precision(16);
16081 {
16082 }
16083 ios.precision(60);
16084 {
16085 }
16086 }
16087 }
16088 }
16089
test8()16090 void test8()
16091 {
16092 char str[200];
16093 output_iterator<char*> iter;
16094 std::locale lc = std::locale::classic();
16095 std::locale lg(lc, new my_numpunct);
16096 const my_facet f(1);
16097 {
16098 double v = 1234567890.125;
16099 std::ios ios(0);
16100 hexfloat(ios);
16101 // %a
16102 {
16103 ios.precision(0);
16104 {
16105 nouppercase(ios);
16106 {
16107 noshowpos(ios);
16108 {
16109 noshowpoint(ios);
16110 {
16111 ios.imbue(lc);
16112 {
16113 ios.width(0);
16114 {
16115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16116 std::string ex(str, iter.base());
16117 assert(ex == "0x1.26580b488p+30");
16118 assert(ios.width() == 0);
16119 }
16120 ios.width(25);
16121 left(ios);
16122 {
16123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16124 std::string ex(str, iter.base());
16125 assert(ex == "0x1.26580b488p+30********");
16126 assert(ios.width() == 0);
16127 }
16128 ios.width(25);
16129 right(ios);
16130 {
16131 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16132 std::string ex(str, iter.base());
16133 assert(ex == "********0x1.26580b488p+30");
16134 assert(ios.width() == 0);
16135 }
16136 ios.width(25);
16137 internal(ios);
16138 {
16139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16140 std::string ex(str, iter.base());
16141 assert(ex == "0x********1.26580b488p+30");
16142 assert(ios.width() == 0);
16143 }
16144 }
16145 ios.imbue(lg);
16146 {
16147 ios.width(0);
16148 {
16149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16150 std::string ex(str, iter.base());
16151 assert(ex == "0x1;26580b488p+30");
16152 assert(ios.width() == 0);
16153 }
16154 ios.width(25);
16155 left(ios);
16156 {
16157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16158 std::string ex(str, iter.base());
16159 assert(ex == "0x1;26580b488p+30********");
16160 assert(ios.width() == 0);
16161 }
16162 ios.width(25);
16163 right(ios);
16164 {
16165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16166 std::string ex(str, iter.base());
16167 assert(ex == "********0x1;26580b488p+30");
16168 assert(ios.width() == 0);
16169 }
16170 ios.width(25);
16171 internal(ios);
16172 {
16173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16174 std::string ex(str, iter.base());
16175 assert(ex == "0x********1;26580b488p+30");
16176 assert(ios.width() == 0);
16177 }
16178 }
16179 }
16180 showpoint(ios);
16181 {
16182 ios.imbue(lc);
16183 {
16184 ios.width(0);
16185 {
16186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16187 std::string ex(str, iter.base());
16188 assert(ex == "0x1.26580b488p+30");
16189 assert(ios.width() == 0);
16190 }
16191 ios.width(25);
16192 left(ios);
16193 {
16194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16195 std::string ex(str, iter.base());
16196 assert(ex == "0x1.26580b488p+30********");
16197 assert(ios.width() == 0);
16198 }
16199 ios.width(25);
16200 right(ios);
16201 {
16202 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16203 std::string ex(str, iter.base());
16204 assert(ex == "********0x1.26580b488p+30");
16205 assert(ios.width() == 0);
16206 }
16207 ios.width(25);
16208 internal(ios);
16209 {
16210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16211 std::string ex(str, iter.base());
16212 assert(ex == "0x********1.26580b488p+30");
16213 assert(ios.width() == 0);
16214 }
16215 }
16216 ios.imbue(lg);
16217 {
16218 ios.width(0);
16219 {
16220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16221 std::string ex(str, iter.base());
16222 assert(ex == "0x1;26580b488p+30");
16223 assert(ios.width() == 0);
16224 }
16225 ios.width(25);
16226 left(ios);
16227 {
16228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16229 std::string ex(str, iter.base());
16230 assert(ex == "0x1;26580b488p+30********");
16231 assert(ios.width() == 0);
16232 }
16233 ios.width(25);
16234 right(ios);
16235 {
16236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16237 std::string ex(str, iter.base());
16238 assert(ex == "********0x1;26580b488p+30");
16239 assert(ios.width() == 0);
16240 }
16241 ios.width(25);
16242 internal(ios);
16243 {
16244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16245 std::string ex(str, iter.base());
16246 assert(ex == "0x********1;26580b488p+30");
16247 assert(ios.width() == 0);
16248 }
16249 }
16250 }
16251 }
16252 showpos(ios);
16253 {
16254 noshowpoint(ios);
16255 {
16256 ios.imbue(lc);
16257 {
16258 ios.width(0);
16259 {
16260 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16261 std::string ex(str, iter.base());
16262 assert(ex == "+0x1.26580b488p+30");
16263 assert(ios.width() == 0);
16264 }
16265 ios.width(25);
16266 left(ios);
16267 {
16268 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16269 std::string ex(str, iter.base());
16270 assert(ex == "+0x1.26580b488p+30*******");
16271 assert(ios.width() == 0);
16272 }
16273 ios.width(25);
16274 right(ios);
16275 {
16276 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16277 std::string ex(str, iter.base());
16278 assert(ex == "*******+0x1.26580b488p+30");
16279 assert(ios.width() == 0);
16280 }
16281 ios.width(25);
16282 internal(ios);
16283 {
16284 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16285 std::string ex(str, iter.base());
16286 assert(ex == "+*******0x1.26580b488p+30");
16287 assert(ios.width() == 0);
16288 }
16289 }
16290 ios.imbue(lg);
16291 {
16292 ios.width(0);
16293 {
16294 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16295 std::string ex(str, iter.base());
16296 assert(ex == "+0x1;26580b488p+30");
16297 assert(ios.width() == 0);
16298 }
16299 ios.width(25);
16300 left(ios);
16301 {
16302 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16303 std::string ex(str, iter.base());
16304 assert(ex == "+0x1;26580b488p+30*******");
16305 assert(ios.width() == 0);
16306 }
16307 ios.width(25);
16308 right(ios);
16309 {
16310 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16311 std::string ex(str, iter.base());
16312 assert(ex == "*******+0x1;26580b488p+30");
16313 assert(ios.width() == 0);
16314 }
16315 ios.width(25);
16316 internal(ios);
16317 {
16318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16319 std::string ex(str, iter.base());
16320 assert(ex == "+*******0x1;26580b488p+30");
16321 assert(ios.width() == 0);
16322 }
16323 }
16324 }
16325 showpoint(ios);
16326 {
16327 ios.imbue(lc);
16328 {
16329 ios.width(0);
16330 {
16331 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16332 std::string ex(str, iter.base());
16333 assert(ex == "+0x1.26580b488p+30");
16334 assert(ios.width() == 0);
16335 }
16336 ios.width(25);
16337 left(ios);
16338 {
16339 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16340 std::string ex(str, iter.base());
16341 assert(ex == "+0x1.26580b488p+30*******");
16342 assert(ios.width() == 0);
16343 }
16344 ios.width(25);
16345 right(ios);
16346 {
16347 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16348 std::string ex(str, iter.base());
16349 assert(ex == "*******+0x1.26580b488p+30");
16350 assert(ios.width() == 0);
16351 }
16352 ios.width(25);
16353 internal(ios);
16354 {
16355 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16356 std::string ex(str, iter.base());
16357 assert(ex == "+*******0x1.26580b488p+30");
16358 assert(ios.width() == 0);
16359 }
16360 }
16361 ios.imbue(lg);
16362 {
16363 ios.width(0);
16364 {
16365 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16366 std::string ex(str, iter.base());
16367 assert(ex == "+0x1;26580b488p+30");
16368 assert(ios.width() == 0);
16369 }
16370 ios.width(25);
16371 left(ios);
16372 {
16373 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16374 std::string ex(str, iter.base());
16375 assert(ex == "+0x1;26580b488p+30*******");
16376 assert(ios.width() == 0);
16377 }
16378 ios.width(25);
16379 right(ios);
16380 {
16381 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16382 std::string ex(str, iter.base());
16383 assert(ex == "*******+0x1;26580b488p+30");
16384 assert(ios.width() == 0);
16385 }
16386 ios.width(25);
16387 internal(ios);
16388 {
16389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16390 std::string ex(str, iter.base());
16391 assert(ex == "+*******0x1;26580b488p+30");
16392 assert(ios.width() == 0);
16393 }
16394 }
16395 }
16396 }
16397 }
16398 uppercase(ios);
16399 {
16400 noshowpos(ios);
16401 {
16402 noshowpoint(ios);
16403 {
16404 ios.imbue(lc);
16405 {
16406 ios.width(0);
16407 {
16408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16409 std::string ex(str, iter.base());
16410 assert(ex == "0X1.26580B488P+30");
16411 assert(ios.width() == 0);
16412 }
16413 ios.width(25);
16414 left(ios);
16415 {
16416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16417 std::string ex(str, iter.base());
16418 assert(ex == "0X1.26580B488P+30********");
16419 assert(ios.width() == 0);
16420 }
16421 ios.width(25);
16422 right(ios);
16423 {
16424 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16425 std::string ex(str, iter.base());
16426 assert(ex == "********0X1.26580B488P+30");
16427 assert(ios.width() == 0);
16428 }
16429 ios.width(25);
16430 internal(ios);
16431 {
16432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16433 std::string ex(str, iter.base());
16434 assert(ex == "0X********1.26580B488P+30");
16435 assert(ios.width() == 0);
16436 }
16437 }
16438 ios.imbue(lg);
16439 {
16440 ios.width(0);
16441 {
16442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16443 std::string ex(str, iter.base());
16444 assert(ex == "0X1;26580B488P+30");
16445 assert(ios.width() == 0);
16446 }
16447 ios.width(25);
16448 left(ios);
16449 {
16450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16451 std::string ex(str, iter.base());
16452 assert(ex == "0X1;26580B488P+30********");
16453 assert(ios.width() == 0);
16454 }
16455 ios.width(25);
16456 right(ios);
16457 {
16458 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16459 std::string ex(str, iter.base());
16460 assert(ex == "********0X1;26580B488P+30");
16461 assert(ios.width() == 0);
16462 }
16463 ios.width(25);
16464 internal(ios);
16465 {
16466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16467 std::string ex(str, iter.base());
16468 assert(ex == "0X********1;26580B488P+30");
16469 assert(ios.width() == 0);
16470 }
16471 }
16472 }
16473 showpoint(ios);
16474 {
16475 ios.imbue(lc);
16476 {
16477 ios.width(0);
16478 {
16479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16480 std::string ex(str, iter.base());
16481 assert(ex == "0X1.26580B488P+30");
16482 assert(ios.width() == 0);
16483 }
16484 ios.width(25);
16485 left(ios);
16486 {
16487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16488 std::string ex(str, iter.base());
16489 assert(ex == "0X1.26580B488P+30********");
16490 assert(ios.width() == 0);
16491 }
16492 ios.width(25);
16493 right(ios);
16494 {
16495 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16496 std::string ex(str, iter.base());
16497 assert(ex == "********0X1.26580B488P+30");
16498 assert(ios.width() == 0);
16499 }
16500 ios.width(25);
16501 internal(ios);
16502 {
16503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16504 std::string ex(str, iter.base());
16505 assert(ex == "0X********1.26580B488P+30");
16506 assert(ios.width() == 0);
16507 }
16508 }
16509 ios.imbue(lg);
16510 {
16511 ios.width(0);
16512 {
16513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16514 std::string ex(str, iter.base());
16515 assert(ex == "0X1;26580B488P+30");
16516 assert(ios.width() == 0);
16517 }
16518 ios.width(25);
16519 left(ios);
16520 {
16521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16522 std::string ex(str, iter.base());
16523 assert(ex == "0X1;26580B488P+30********");
16524 assert(ios.width() == 0);
16525 }
16526 ios.width(25);
16527 right(ios);
16528 {
16529 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16530 std::string ex(str, iter.base());
16531 assert(ex == "********0X1;26580B488P+30");
16532 assert(ios.width() == 0);
16533 }
16534 ios.width(25);
16535 internal(ios);
16536 {
16537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16538 std::string ex(str, iter.base());
16539 assert(ex == "0X********1;26580B488P+30");
16540 assert(ios.width() == 0);
16541 }
16542 }
16543 }
16544 }
16545 showpos(ios);
16546 {
16547 noshowpoint(ios);
16548 {
16549 ios.imbue(lc);
16550 {
16551 ios.width(0);
16552 {
16553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16554 std::string ex(str, iter.base());
16555 assert(ex == "+0X1.26580B488P+30");
16556 assert(ios.width() == 0);
16557 }
16558 ios.width(25);
16559 left(ios);
16560 {
16561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16562 std::string ex(str, iter.base());
16563 assert(ex == "+0X1.26580B488P+30*******");
16564 assert(ios.width() == 0);
16565 }
16566 ios.width(25);
16567 right(ios);
16568 {
16569 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16570 std::string ex(str, iter.base());
16571 assert(ex == "*******+0X1.26580B488P+30");
16572 assert(ios.width() == 0);
16573 }
16574 ios.width(25);
16575 internal(ios);
16576 {
16577 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16578 std::string ex(str, iter.base());
16579 assert(ex == "+*******0X1.26580B488P+30");
16580 assert(ios.width() == 0);
16581 }
16582 }
16583 ios.imbue(lg);
16584 {
16585 ios.width(0);
16586 {
16587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16588 std::string ex(str, iter.base());
16589 assert(ex == "+0X1;26580B488P+30");
16590 assert(ios.width() == 0);
16591 }
16592 ios.width(25);
16593 left(ios);
16594 {
16595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16596 std::string ex(str, iter.base());
16597 assert(ex == "+0X1;26580B488P+30*******");
16598 assert(ios.width() == 0);
16599 }
16600 ios.width(25);
16601 right(ios);
16602 {
16603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16604 std::string ex(str, iter.base());
16605 assert(ex == "*******+0X1;26580B488P+30");
16606 assert(ios.width() == 0);
16607 }
16608 ios.width(25);
16609 internal(ios);
16610 {
16611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16612 std::string ex(str, iter.base());
16613 assert(ex == "+*******0X1;26580B488P+30");
16614 assert(ios.width() == 0);
16615 }
16616 }
16617 }
16618 showpoint(ios);
16619 {
16620 ios.imbue(lc);
16621 {
16622 ios.width(0);
16623 {
16624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16625 std::string ex(str, iter.base());
16626 assert(ex == "+0X1.26580B488P+30");
16627 assert(ios.width() == 0);
16628 }
16629 ios.width(25);
16630 left(ios);
16631 {
16632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16633 std::string ex(str, iter.base());
16634 assert(ex == "+0X1.26580B488P+30*******");
16635 assert(ios.width() == 0);
16636 }
16637 ios.width(25);
16638 right(ios);
16639 {
16640 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16641 std::string ex(str, iter.base());
16642 assert(ex == "*******+0X1.26580B488P+30");
16643 assert(ios.width() == 0);
16644 }
16645 ios.width(25);
16646 internal(ios);
16647 {
16648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16649 std::string ex(str, iter.base());
16650 assert(ex == "+*******0X1.26580B488P+30");
16651 assert(ios.width() == 0);
16652 }
16653 }
16654 ios.imbue(lg);
16655 {
16656 ios.width(0);
16657 {
16658 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16659 std::string ex(str, iter.base());
16660 assert(ex == "+0X1;26580B488P+30");
16661 assert(ios.width() == 0);
16662 }
16663 ios.width(25);
16664 left(ios);
16665 {
16666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16667 std::string ex(str, iter.base());
16668 assert(ex == "+0X1;26580B488P+30*******");
16669 assert(ios.width() == 0);
16670 }
16671 ios.width(25);
16672 right(ios);
16673 {
16674 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16675 std::string ex(str, iter.base());
16676 assert(ex == "*******+0X1;26580B488P+30");
16677 assert(ios.width() == 0);
16678 }
16679 ios.width(25);
16680 internal(ios);
16681 {
16682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16683 std::string ex(str, iter.base());
16684 assert(ex == "+*******0X1;26580B488P+30");
16685 assert(ios.width() == 0);
16686 }
16687 }
16688 }
16689 }
16690 }
16691 }
16692 ios.precision(1);
16693 {
16694 nouppercase(ios);
16695 {
16696 noshowpos(ios);
16697 {
16698 noshowpoint(ios);
16699 {
16700 ios.imbue(lc);
16701 {
16702 ios.width(0);
16703 {
16704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16705 std::string ex(str, iter.base());
16706 assert(ex == "0x1.26580b488p+30");
16707 assert(ios.width() == 0);
16708 }
16709 ios.width(25);
16710 left(ios);
16711 {
16712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16713 std::string ex(str, iter.base());
16714 assert(ex == "0x1.26580b488p+30********");
16715 assert(ios.width() == 0);
16716 }
16717 ios.width(25);
16718 right(ios);
16719 {
16720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16721 std::string ex(str, iter.base());
16722 assert(ex == "********0x1.26580b488p+30");
16723 assert(ios.width() == 0);
16724 }
16725 ios.width(25);
16726 internal(ios);
16727 {
16728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16729 std::string ex(str, iter.base());
16730 assert(ex == "0x********1.26580b488p+30");
16731 assert(ios.width() == 0);
16732 }
16733 }
16734 ios.imbue(lg);
16735 {
16736 ios.width(0);
16737 {
16738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16739 std::string ex(str, iter.base());
16740 assert(ex == "0x1;26580b488p+30");
16741 assert(ios.width() == 0);
16742 }
16743 ios.width(25);
16744 left(ios);
16745 {
16746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16747 std::string ex(str, iter.base());
16748 assert(ex == "0x1;26580b488p+30********");
16749 assert(ios.width() == 0);
16750 }
16751 ios.width(25);
16752 right(ios);
16753 {
16754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16755 std::string ex(str, iter.base());
16756 assert(ex == "********0x1;26580b488p+30");
16757 assert(ios.width() == 0);
16758 }
16759 ios.width(25);
16760 internal(ios);
16761 {
16762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16763 std::string ex(str, iter.base());
16764 assert(ex == "0x********1;26580b488p+30");
16765 assert(ios.width() == 0);
16766 }
16767 }
16768 }
16769 showpoint(ios);
16770 {
16771 ios.imbue(lc);
16772 {
16773 ios.width(0);
16774 {
16775 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16776 std::string ex(str, iter.base());
16777 assert(ex == "0x1.26580b488p+30");
16778 assert(ios.width() == 0);
16779 }
16780 ios.width(25);
16781 left(ios);
16782 {
16783 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16784 std::string ex(str, iter.base());
16785 assert(ex == "0x1.26580b488p+30********");
16786 assert(ios.width() == 0);
16787 }
16788 ios.width(25);
16789 right(ios);
16790 {
16791 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16792 std::string ex(str, iter.base());
16793 assert(ex == "********0x1.26580b488p+30");
16794 assert(ios.width() == 0);
16795 }
16796 ios.width(25);
16797 internal(ios);
16798 {
16799 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16800 std::string ex(str, iter.base());
16801 assert(ex == "0x********1.26580b488p+30");
16802 assert(ios.width() == 0);
16803 }
16804 }
16805 ios.imbue(lg);
16806 {
16807 ios.width(0);
16808 {
16809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16810 std::string ex(str, iter.base());
16811 assert(ex == "0x1;26580b488p+30");
16812 assert(ios.width() == 0);
16813 }
16814 ios.width(25);
16815 left(ios);
16816 {
16817 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16818 std::string ex(str, iter.base());
16819 assert(ex == "0x1;26580b488p+30********");
16820 assert(ios.width() == 0);
16821 }
16822 ios.width(25);
16823 right(ios);
16824 {
16825 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16826 std::string ex(str, iter.base());
16827 assert(ex == "********0x1;26580b488p+30");
16828 assert(ios.width() == 0);
16829 }
16830 ios.width(25);
16831 internal(ios);
16832 {
16833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16834 std::string ex(str, iter.base());
16835 assert(ex == "0x********1;26580b488p+30");
16836 assert(ios.width() == 0);
16837 }
16838 }
16839 }
16840 }
16841 showpos(ios);
16842 {
16843 noshowpoint(ios);
16844 {
16845 ios.imbue(lc);
16846 {
16847 ios.width(0);
16848 {
16849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16850 std::string ex(str, iter.base());
16851 assert(ex == "+0x1.26580b488p+30");
16852 assert(ios.width() == 0);
16853 }
16854 ios.width(25);
16855 left(ios);
16856 {
16857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16858 std::string ex(str, iter.base());
16859 assert(ex == "+0x1.26580b488p+30*******");
16860 assert(ios.width() == 0);
16861 }
16862 ios.width(25);
16863 right(ios);
16864 {
16865 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16866 std::string ex(str, iter.base());
16867 assert(ex == "*******+0x1.26580b488p+30");
16868 assert(ios.width() == 0);
16869 }
16870 ios.width(25);
16871 internal(ios);
16872 {
16873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16874 std::string ex(str, iter.base());
16875 assert(ex == "+*******0x1.26580b488p+30");
16876 assert(ios.width() == 0);
16877 }
16878 }
16879 ios.imbue(lg);
16880 {
16881 ios.width(0);
16882 {
16883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16884 std::string ex(str, iter.base());
16885 assert(ex == "+0x1;26580b488p+30");
16886 assert(ios.width() == 0);
16887 }
16888 ios.width(25);
16889 left(ios);
16890 {
16891 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16892 std::string ex(str, iter.base());
16893 assert(ex == "+0x1;26580b488p+30*******");
16894 assert(ios.width() == 0);
16895 }
16896 ios.width(25);
16897 right(ios);
16898 {
16899 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16900 std::string ex(str, iter.base());
16901 assert(ex == "*******+0x1;26580b488p+30");
16902 assert(ios.width() == 0);
16903 }
16904 ios.width(25);
16905 internal(ios);
16906 {
16907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16908 std::string ex(str, iter.base());
16909 assert(ex == "+*******0x1;26580b488p+30");
16910 assert(ios.width() == 0);
16911 }
16912 }
16913 }
16914 showpoint(ios);
16915 {
16916 ios.imbue(lc);
16917 {
16918 ios.width(0);
16919 {
16920 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16921 std::string ex(str, iter.base());
16922 assert(ex == "+0x1.26580b488p+30");
16923 assert(ios.width() == 0);
16924 }
16925 ios.width(25);
16926 left(ios);
16927 {
16928 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16929 std::string ex(str, iter.base());
16930 assert(ex == "+0x1.26580b488p+30*******");
16931 assert(ios.width() == 0);
16932 }
16933 ios.width(25);
16934 right(ios);
16935 {
16936 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16937 std::string ex(str, iter.base());
16938 assert(ex == "*******+0x1.26580b488p+30");
16939 assert(ios.width() == 0);
16940 }
16941 ios.width(25);
16942 internal(ios);
16943 {
16944 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16945 std::string ex(str, iter.base());
16946 assert(ex == "+*******0x1.26580b488p+30");
16947 assert(ios.width() == 0);
16948 }
16949 }
16950 ios.imbue(lg);
16951 {
16952 ios.width(0);
16953 {
16954 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16955 std::string ex(str, iter.base());
16956 assert(ex == "+0x1;26580b488p+30");
16957 assert(ios.width() == 0);
16958 }
16959 ios.width(25);
16960 left(ios);
16961 {
16962 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16963 std::string ex(str, iter.base());
16964 assert(ex == "+0x1;26580b488p+30*******");
16965 assert(ios.width() == 0);
16966 }
16967 ios.width(25);
16968 right(ios);
16969 {
16970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16971 std::string ex(str, iter.base());
16972 assert(ex == "*******+0x1;26580b488p+30");
16973 assert(ios.width() == 0);
16974 }
16975 ios.width(25);
16976 internal(ios);
16977 {
16978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16979 std::string ex(str, iter.base());
16980 assert(ex == "+*******0x1;26580b488p+30");
16981 assert(ios.width() == 0);
16982 }
16983 }
16984 }
16985 }
16986 }
16987 uppercase(ios);
16988 {
16989 noshowpos(ios);
16990 {
16991 noshowpoint(ios);
16992 {
16993 ios.imbue(lc);
16994 {
16995 ios.width(0);
16996 {
16997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16998 std::string ex(str, iter.base());
16999 assert(ex == "0X1.26580B488P+30");
17000 assert(ios.width() == 0);
17001 }
17002 ios.width(25);
17003 left(ios);
17004 {
17005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17006 std::string ex(str, iter.base());
17007 assert(ex == "0X1.26580B488P+30********");
17008 assert(ios.width() == 0);
17009 }
17010 ios.width(25);
17011 right(ios);
17012 {
17013 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17014 std::string ex(str, iter.base());
17015 assert(ex == "********0X1.26580B488P+30");
17016 assert(ios.width() == 0);
17017 }
17018 ios.width(25);
17019 internal(ios);
17020 {
17021 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17022 std::string ex(str, iter.base());
17023 assert(ex == "0X********1.26580B488P+30");
17024 assert(ios.width() == 0);
17025 }
17026 }
17027 ios.imbue(lg);
17028 {
17029 ios.width(0);
17030 {
17031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17032 std::string ex(str, iter.base());
17033 assert(ex == "0X1;26580B488P+30");
17034 assert(ios.width() == 0);
17035 }
17036 ios.width(25);
17037 left(ios);
17038 {
17039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17040 std::string ex(str, iter.base());
17041 assert(ex == "0X1;26580B488P+30********");
17042 assert(ios.width() == 0);
17043 }
17044 ios.width(25);
17045 right(ios);
17046 {
17047 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17048 std::string ex(str, iter.base());
17049 assert(ex == "********0X1;26580B488P+30");
17050 assert(ios.width() == 0);
17051 }
17052 ios.width(25);
17053 internal(ios);
17054 {
17055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17056 std::string ex(str, iter.base());
17057 assert(ex == "0X********1;26580B488P+30");
17058 assert(ios.width() == 0);
17059 }
17060 }
17061 }
17062 showpoint(ios);
17063 {
17064 ios.imbue(lc);
17065 {
17066 ios.width(0);
17067 {
17068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17069 std::string ex(str, iter.base());
17070 assert(ex == "0X1.26580B488P+30");
17071 assert(ios.width() == 0);
17072 }
17073 ios.width(25);
17074 left(ios);
17075 {
17076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17077 std::string ex(str, iter.base());
17078 assert(ex == "0X1.26580B488P+30********");
17079 assert(ios.width() == 0);
17080 }
17081 ios.width(25);
17082 right(ios);
17083 {
17084 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17085 std::string ex(str, iter.base());
17086 assert(ex == "********0X1.26580B488P+30");
17087 assert(ios.width() == 0);
17088 }
17089 ios.width(25);
17090 internal(ios);
17091 {
17092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17093 std::string ex(str, iter.base());
17094 assert(ex == "0X********1.26580B488P+30");
17095 assert(ios.width() == 0);
17096 }
17097 }
17098 ios.imbue(lg);
17099 {
17100 ios.width(0);
17101 {
17102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17103 std::string ex(str, iter.base());
17104 assert(ex == "0X1;26580B488P+30");
17105 assert(ios.width() == 0);
17106 }
17107 ios.width(25);
17108 left(ios);
17109 {
17110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17111 std::string ex(str, iter.base());
17112 assert(ex == "0X1;26580B488P+30********");
17113 assert(ios.width() == 0);
17114 }
17115 ios.width(25);
17116 right(ios);
17117 {
17118 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17119 std::string ex(str, iter.base());
17120 assert(ex == "********0X1;26580B488P+30");
17121 assert(ios.width() == 0);
17122 }
17123 ios.width(25);
17124 internal(ios);
17125 {
17126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17127 std::string ex(str, iter.base());
17128 assert(ex == "0X********1;26580B488P+30");
17129 assert(ios.width() == 0);
17130 }
17131 }
17132 }
17133 }
17134 showpos(ios);
17135 {
17136 noshowpoint(ios);
17137 {
17138 ios.imbue(lc);
17139 {
17140 ios.width(0);
17141 {
17142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17143 std::string ex(str, iter.base());
17144 assert(ex == "+0X1.26580B488P+30");
17145 assert(ios.width() == 0);
17146 }
17147 ios.width(25);
17148 left(ios);
17149 {
17150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17151 std::string ex(str, iter.base());
17152 assert(ex == "+0X1.26580B488P+30*******");
17153 assert(ios.width() == 0);
17154 }
17155 ios.width(25);
17156 right(ios);
17157 {
17158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17159 std::string ex(str, iter.base());
17160 assert(ex == "*******+0X1.26580B488P+30");
17161 assert(ios.width() == 0);
17162 }
17163 ios.width(25);
17164 internal(ios);
17165 {
17166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17167 std::string ex(str, iter.base());
17168 assert(ex == "+*******0X1.26580B488P+30");
17169 assert(ios.width() == 0);
17170 }
17171 }
17172 ios.imbue(lg);
17173 {
17174 ios.width(0);
17175 {
17176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17177 std::string ex(str, iter.base());
17178 assert(ex == "+0X1;26580B488P+30");
17179 assert(ios.width() == 0);
17180 }
17181 ios.width(25);
17182 left(ios);
17183 {
17184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17185 std::string ex(str, iter.base());
17186 assert(ex == "+0X1;26580B488P+30*******");
17187 assert(ios.width() == 0);
17188 }
17189 ios.width(25);
17190 right(ios);
17191 {
17192 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17193 std::string ex(str, iter.base());
17194 assert(ex == "*******+0X1;26580B488P+30");
17195 assert(ios.width() == 0);
17196 }
17197 ios.width(25);
17198 internal(ios);
17199 {
17200 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17201 std::string ex(str, iter.base());
17202 assert(ex == "+*******0X1;26580B488P+30");
17203 assert(ios.width() == 0);
17204 }
17205 }
17206 }
17207 showpoint(ios);
17208 {
17209 ios.imbue(lc);
17210 {
17211 ios.width(0);
17212 {
17213 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17214 std::string ex(str, iter.base());
17215 assert(ex == "+0X1.26580B488P+30");
17216 assert(ios.width() == 0);
17217 }
17218 ios.width(25);
17219 left(ios);
17220 {
17221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17222 std::string ex(str, iter.base());
17223 assert(ex == "+0X1.26580B488P+30*******");
17224 assert(ios.width() == 0);
17225 }
17226 ios.width(25);
17227 right(ios);
17228 {
17229 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17230 std::string ex(str, iter.base());
17231 assert(ex == "*******+0X1.26580B488P+30");
17232 assert(ios.width() == 0);
17233 }
17234 ios.width(25);
17235 internal(ios);
17236 {
17237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17238 std::string ex(str, iter.base());
17239 assert(ex == "+*******0X1.26580B488P+30");
17240 assert(ios.width() == 0);
17241 }
17242 }
17243 ios.imbue(lg);
17244 {
17245 ios.width(0);
17246 {
17247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17248 std::string ex(str, iter.base());
17249 assert(ex == "+0X1;26580B488P+30");
17250 assert(ios.width() == 0);
17251 }
17252 ios.width(25);
17253 left(ios);
17254 {
17255 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17256 std::string ex(str, iter.base());
17257 assert(ex == "+0X1;26580B488P+30*******");
17258 assert(ios.width() == 0);
17259 }
17260 ios.width(25);
17261 right(ios);
17262 {
17263 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17264 std::string ex(str, iter.base());
17265 assert(ex == "*******+0X1;26580B488P+30");
17266 assert(ios.width() == 0);
17267 }
17268 ios.width(25);
17269 internal(ios);
17270 {
17271 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17272 std::string ex(str, iter.base());
17273 assert(ex == "+*******0X1;26580B488P+30");
17274 assert(ios.width() == 0);
17275 }
17276 }
17277 }
17278 }
17279 }
17280 }
17281 ios.precision(6);
17282 {
17283 }
17284 ios.precision(16);
17285 {
17286 }
17287 ios.precision(60);
17288 {
17289 nouppercase(ios);
17290 {
17291 noshowpos(ios);
17292 {
17293 noshowpoint(ios);
17294 {
17295 ios.imbue(lc);
17296 {
17297 ios.width(0);
17298 {
17299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17300 std::string ex(str, iter.base());
17301 assert(ex == "0x1.26580b488p+30");
17302 assert(ios.width() == 0);
17303 }
17304 ios.width(25);
17305 left(ios);
17306 {
17307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17308 std::string ex(str, iter.base());
17309 assert(ex == "0x1.26580b488p+30********");
17310 assert(ios.width() == 0);
17311 }
17312 ios.width(25);
17313 right(ios);
17314 {
17315 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17316 std::string ex(str, iter.base());
17317 assert(ex == "********0x1.26580b488p+30");
17318 assert(ios.width() == 0);
17319 }
17320 ios.width(25);
17321 internal(ios);
17322 {
17323 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17324 std::string ex(str, iter.base());
17325 assert(ex == "0x********1.26580b488p+30");
17326 assert(ios.width() == 0);
17327 }
17328 }
17329 ios.imbue(lg);
17330 {
17331 ios.width(0);
17332 {
17333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17334 std::string ex(str, iter.base());
17335 assert(ex == "0x1;26580b488p+30");
17336 assert(ios.width() == 0);
17337 }
17338 ios.width(25);
17339 left(ios);
17340 {
17341 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17342 std::string ex(str, iter.base());
17343 assert(ex == "0x1;26580b488p+30********");
17344 assert(ios.width() == 0);
17345 }
17346 ios.width(25);
17347 right(ios);
17348 {
17349 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17350 std::string ex(str, iter.base());
17351 assert(ex == "********0x1;26580b488p+30");
17352 assert(ios.width() == 0);
17353 }
17354 ios.width(25);
17355 internal(ios);
17356 {
17357 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17358 std::string ex(str, iter.base());
17359 assert(ex == "0x********1;26580b488p+30");
17360 assert(ios.width() == 0);
17361 }
17362 }
17363 }
17364 showpoint(ios);
17365 {
17366 ios.imbue(lc);
17367 {
17368 ios.width(0);
17369 {
17370 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17371 std::string ex(str, iter.base());
17372 assert(ex == "0x1.26580b488p+30");
17373 assert(ios.width() == 0);
17374 }
17375 ios.width(25);
17376 left(ios);
17377 {
17378 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17379 std::string ex(str, iter.base());
17380 assert(ex == "0x1.26580b488p+30********");
17381 assert(ios.width() == 0);
17382 }
17383 ios.width(25);
17384 right(ios);
17385 {
17386 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17387 std::string ex(str, iter.base());
17388 assert(ex == "********0x1.26580b488p+30");
17389 assert(ios.width() == 0);
17390 }
17391 ios.width(25);
17392 internal(ios);
17393 {
17394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17395 std::string ex(str, iter.base());
17396 assert(ex == "0x********1.26580b488p+30");
17397 assert(ios.width() == 0);
17398 }
17399 }
17400 ios.imbue(lg);
17401 {
17402 ios.width(0);
17403 {
17404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17405 std::string ex(str, iter.base());
17406 assert(ex == "0x1;26580b488p+30");
17407 assert(ios.width() == 0);
17408 }
17409 ios.width(25);
17410 left(ios);
17411 {
17412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17413 std::string ex(str, iter.base());
17414 assert(ex == "0x1;26580b488p+30********");
17415 assert(ios.width() == 0);
17416 }
17417 ios.width(25);
17418 right(ios);
17419 {
17420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17421 std::string ex(str, iter.base());
17422 assert(ex == "********0x1;26580b488p+30");
17423 assert(ios.width() == 0);
17424 }
17425 ios.width(25);
17426 internal(ios);
17427 {
17428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17429 std::string ex(str, iter.base());
17430 assert(ex == "0x********1;26580b488p+30");
17431 assert(ios.width() == 0);
17432 }
17433 }
17434 }
17435 }
17436 showpos(ios);
17437 {
17438 noshowpoint(ios);
17439 {
17440 ios.imbue(lc);
17441 {
17442 ios.width(0);
17443 {
17444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17445 std::string ex(str, iter.base());
17446 assert(ex == "+0x1.26580b488p+30");
17447 assert(ios.width() == 0);
17448 }
17449 ios.width(25);
17450 left(ios);
17451 {
17452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17453 std::string ex(str, iter.base());
17454 assert(ex == "+0x1.26580b488p+30*******");
17455 assert(ios.width() == 0);
17456 }
17457 ios.width(25);
17458 right(ios);
17459 {
17460 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17461 std::string ex(str, iter.base());
17462 assert(ex == "*******+0x1.26580b488p+30");
17463 assert(ios.width() == 0);
17464 }
17465 ios.width(25);
17466 internal(ios);
17467 {
17468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17469 std::string ex(str, iter.base());
17470 assert(ex == "+*******0x1.26580b488p+30");
17471 assert(ios.width() == 0);
17472 }
17473 }
17474 ios.imbue(lg);
17475 {
17476 ios.width(0);
17477 {
17478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17479 std::string ex(str, iter.base());
17480 assert(ex == "+0x1;26580b488p+30");
17481 assert(ios.width() == 0);
17482 }
17483 ios.width(25);
17484 left(ios);
17485 {
17486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17487 std::string ex(str, iter.base());
17488 assert(ex == "+0x1;26580b488p+30*******");
17489 assert(ios.width() == 0);
17490 }
17491 ios.width(25);
17492 right(ios);
17493 {
17494 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17495 std::string ex(str, iter.base());
17496 assert(ex == "*******+0x1;26580b488p+30");
17497 assert(ios.width() == 0);
17498 }
17499 ios.width(25);
17500 internal(ios);
17501 {
17502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17503 std::string ex(str, iter.base());
17504 assert(ex == "+*******0x1;26580b488p+30");
17505 assert(ios.width() == 0);
17506 }
17507 }
17508 }
17509 showpoint(ios);
17510 {
17511 ios.imbue(lc);
17512 {
17513 ios.width(0);
17514 {
17515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17516 std::string ex(str, iter.base());
17517 assert(ex == "+0x1.26580b488p+30");
17518 assert(ios.width() == 0);
17519 }
17520 ios.width(25);
17521 left(ios);
17522 {
17523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17524 std::string ex(str, iter.base());
17525 assert(ex == "+0x1.26580b488p+30*******");
17526 assert(ios.width() == 0);
17527 }
17528 ios.width(25);
17529 right(ios);
17530 {
17531 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17532 std::string ex(str, iter.base());
17533 assert(ex == "*******+0x1.26580b488p+30");
17534 assert(ios.width() == 0);
17535 }
17536 ios.width(25);
17537 internal(ios);
17538 {
17539 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17540 std::string ex(str, iter.base());
17541 assert(ex == "+*******0x1.26580b488p+30");
17542 assert(ios.width() == 0);
17543 }
17544 }
17545 ios.imbue(lg);
17546 {
17547 ios.width(0);
17548 {
17549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17550 std::string ex(str, iter.base());
17551 assert(ex == "+0x1;26580b488p+30");
17552 assert(ios.width() == 0);
17553 }
17554 ios.width(25);
17555 left(ios);
17556 {
17557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17558 std::string ex(str, iter.base());
17559 assert(ex == "+0x1;26580b488p+30*******");
17560 assert(ios.width() == 0);
17561 }
17562 ios.width(25);
17563 right(ios);
17564 {
17565 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17566 std::string ex(str, iter.base());
17567 assert(ex == "*******+0x1;26580b488p+30");
17568 assert(ios.width() == 0);
17569 }
17570 ios.width(25);
17571 internal(ios);
17572 {
17573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17574 std::string ex(str, iter.base());
17575 assert(ex == "+*******0x1;26580b488p+30");
17576 assert(ios.width() == 0);
17577 }
17578 }
17579 }
17580 }
17581 }
17582 uppercase(ios);
17583 {
17584 noshowpos(ios);
17585 {
17586 noshowpoint(ios);
17587 {
17588 ios.imbue(lc);
17589 {
17590 ios.width(0);
17591 {
17592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17593 std::string ex(str, iter.base());
17594 assert(ex == "0X1.26580B488P+30");
17595 assert(ios.width() == 0);
17596 }
17597 ios.width(25);
17598 left(ios);
17599 {
17600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17601 std::string ex(str, iter.base());
17602 assert(ex == "0X1.26580B488P+30********");
17603 assert(ios.width() == 0);
17604 }
17605 ios.width(25);
17606 right(ios);
17607 {
17608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17609 std::string ex(str, iter.base());
17610 assert(ex == "********0X1.26580B488P+30");
17611 assert(ios.width() == 0);
17612 }
17613 ios.width(25);
17614 internal(ios);
17615 {
17616 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17617 std::string ex(str, iter.base());
17618 assert(ex == "0X********1.26580B488P+30");
17619 assert(ios.width() == 0);
17620 }
17621 }
17622 ios.imbue(lg);
17623 {
17624 ios.width(0);
17625 {
17626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17627 std::string ex(str, iter.base());
17628 assert(ex == "0X1;26580B488P+30");
17629 assert(ios.width() == 0);
17630 }
17631 ios.width(25);
17632 left(ios);
17633 {
17634 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17635 std::string ex(str, iter.base());
17636 assert(ex == "0X1;26580B488P+30********");
17637 assert(ios.width() == 0);
17638 }
17639 ios.width(25);
17640 right(ios);
17641 {
17642 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17643 std::string ex(str, iter.base());
17644 assert(ex == "********0X1;26580B488P+30");
17645 assert(ios.width() == 0);
17646 }
17647 ios.width(25);
17648 internal(ios);
17649 {
17650 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17651 std::string ex(str, iter.base());
17652 assert(ex == "0X********1;26580B488P+30");
17653 assert(ios.width() == 0);
17654 }
17655 }
17656 }
17657 showpoint(ios);
17658 {
17659 ios.imbue(lc);
17660 {
17661 ios.width(0);
17662 {
17663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17664 std::string ex(str, iter.base());
17665 assert(ex == "0X1.26580B488P+30");
17666 assert(ios.width() == 0);
17667 }
17668 ios.width(25);
17669 left(ios);
17670 {
17671 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17672 std::string ex(str, iter.base());
17673 assert(ex == "0X1.26580B488P+30********");
17674 assert(ios.width() == 0);
17675 }
17676 ios.width(25);
17677 right(ios);
17678 {
17679 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17680 std::string ex(str, iter.base());
17681 assert(ex == "********0X1.26580B488P+30");
17682 assert(ios.width() == 0);
17683 }
17684 ios.width(25);
17685 internal(ios);
17686 {
17687 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17688 std::string ex(str, iter.base());
17689 assert(ex == "0X********1.26580B488P+30");
17690 assert(ios.width() == 0);
17691 }
17692 }
17693 ios.imbue(lg);
17694 {
17695 ios.width(0);
17696 {
17697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17698 std::string ex(str, iter.base());
17699 assert(ex == "0X1;26580B488P+30");
17700 assert(ios.width() == 0);
17701 }
17702 ios.width(25);
17703 left(ios);
17704 {
17705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17706 std::string ex(str, iter.base());
17707 assert(ex == "0X1;26580B488P+30********");
17708 assert(ios.width() == 0);
17709 }
17710 ios.width(25);
17711 right(ios);
17712 {
17713 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17714 std::string ex(str, iter.base());
17715 assert(ex == "********0X1;26580B488P+30");
17716 assert(ios.width() == 0);
17717 }
17718 ios.width(25);
17719 internal(ios);
17720 {
17721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17722 std::string ex(str, iter.base());
17723 assert(ex == "0X********1;26580B488P+30");
17724 assert(ios.width() == 0);
17725 }
17726 }
17727 }
17728 }
17729 showpos(ios);
17730 {
17731 noshowpoint(ios);
17732 {
17733 ios.imbue(lc);
17734 {
17735 ios.width(0);
17736 {
17737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17738 std::string ex(str, iter.base());
17739 assert(ex == "+0X1.26580B488P+30");
17740 assert(ios.width() == 0);
17741 }
17742 ios.width(25);
17743 left(ios);
17744 {
17745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17746 std::string ex(str, iter.base());
17747 assert(ex == "+0X1.26580B488P+30*******");
17748 assert(ios.width() == 0);
17749 }
17750 ios.width(25);
17751 right(ios);
17752 {
17753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17754 std::string ex(str, iter.base());
17755 assert(ex == "*******+0X1.26580B488P+30");
17756 assert(ios.width() == 0);
17757 }
17758 ios.width(25);
17759 internal(ios);
17760 {
17761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17762 std::string ex(str, iter.base());
17763 assert(ex == "+*******0X1.26580B488P+30");
17764 assert(ios.width() == 0);
17765 }
17766 }
17767 ios.imbue(lg);
17768 {
17769 ios.width(0);
17770 {
17771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17772 std::string ex(str, iter.base());
17773 assert(ex == "+0X1;26580B488P+30");
17774 assert(ios.width() == 0);
17775 }
17776 ios.width(25);
17777 left(ios);
17778 {
17779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17780 std::string ex(str, iter.base());
17781 assert(ex == "+0X1;26580B488P+30*******");
17782 assert(ios.width() == 0);
17783 }
17784 ios.width(25);
17785 right(ios);
17786 {
17787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17788 std::string ex(str, iter.base());
17789 assert(ex == "*******+0X1;26580B488P+30");
17790 assert(ios.width() == 0);
17791 }
17792 ios.width(25);
17793 internal(ios);
17794 {
17795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17796 std::string ex(str, iter.base());
17797 assert(ex == "+*******0X1;26580B488P+30");
17798 assert(ios.width() == 0);
17799 }
17800 }
17801 }
17802 showpoint(ios);
17803 {
17804 ios.imbue(lc);
17805 {
17806 ios.width(0);
17807 {
17808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17809 std::string ex(str, iter.base());
17810 assert(ex == "+0X1.26580B488P+30");
17811 assert(ios.width() == 0);
17812 }
17813 ios.width(25);
17814 left(ios);
17815 {
17816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17817 std::string ex(str, iter.base());
17818 assert(ex == "+0X1.26580B488P+30*******");
17819 assert(ios.width() == 0);
17820 }
17821 ios.width(25);
17822 right(ios);
17823 {
17824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17825 std::string ex(str, iter.base());
17826 assert(ex == "*******+0X1.26580B488P+30");
17827 assert(ios.width() == 0);
17828 }
17829 ios.width(25);
17830 internal(ios);
17831 {
17832 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17833 std::string ex(str, iter.base());
17834 assert(ex == "+*******0X1.26580B488P+30");
17835 assert(ios.width() == 0);
17836 }
17837 }
17838 ios.imbue(lg);
17839 {
17840 ios.width(0);
17841 {
17842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17843 std::string ex(str, iter.base());
17844 assert(ex == "+0X1;26580B488P+30");
17845 assert(ios.width() == 0);
17846 }
17847 ios.width(25);
17848 left(ios);
17849 {
17850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17851 std::string ex(str, iter.base());
17852 assert(ex == "+0X1;26580B488P+30*******");
17853 assert(ios.width() == 0);
17854 }
17855 ios.width(25);
17856 right(ios);
17857 {
17858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17859 std::string ex(str, iter.base());
17860 assert(ex == "*******+0X1;26580B488P+30");
17861 assert(ios.width() == 0);
17862 }
17863 ios.width(25);
17864 internal(ios);
17865 {
17866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17867 std::string ex(str, iter.base());
17868 assert(ex == "+*******0X1;26580B488P+30");
17869 assert(ios.width() == 0);
17870 }
17871 }
17872 }
17873 }
17874 }
17875 }
17876 }
17877 }
17878 }
17879
main(int,char **)17880 int main(int, char**)
17881 {
17882 test1();
17883 test2();
17884 test3();
17885 test4();
17886 test5();
17887 test6();
17888 test7();
17889 test8();
17890
17891 return 0;
17892 }
17893