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 #include <locale>
16 #include <ios>
17 #include <cassert>
18 #include <streambuf>
19 #include <cmath>
20 #include "test_macros.h"
21 #include "test_iterators.h"
22
23 typedef std::num_put<char, output_iterator<char*> > F;
24
25 class my_facet
26 : public F
27 {
28 public:
my_facet(std::size_t refs=0)29 explicit my_facet(std::size_t refs = 0)
30 : F(refs) {}
31 };
32
33 class my_numpunct
34 : public std::numpunct<char>
35 {
36 public:
my_numpunct()37 my_numpunct() : std::numpunct<char>() {}
38
39 protected:
do_decimal_point() const40 virtual char_type do_decimal_point() const {return ';';}
do_thousands_sep() const41 virtual char_type do_thousands_sep() const {return '_';}
do_grouping() const42 virtual std::string do_grouping() const {return std::string("\1\2\3");}
43 };
44
test1()45 void test1()
46 {
47 char str[200];
48 output_iterator<char*> iter;
49 std::locale lc = std::locale::classic();
50 std::locale lg(lc, new my_numpunct);
51 const my_facet f(1);
52 {
53 double v = +0.;
54 std::ios ios(0);
55 // %g
56 {
57 ios.precision(0);
58 {
59 nouppercase(ios);
60 {
61 noshowpos(ios);
62 {
63 noshowpoint(ios);
64 {
65 ios.imbue(lc);
66 {
67 ios.width(0);
68 {
69 iter = f.put(output_iterator<char*>(str), ios, '*', v);
70 std::string ex(str, iter.base());
71 assert(ex == "0");
72 assert(ios.width() == 0);
73 }
74 ios.width(25);
75 left(ios);
76 {
77 iter = f.put(output_iterator<char*>(str), ios, '*', v);
78 std::string ex(str, iter.base());
79 assert(ex == "0************************");
80 assert(ios.width() == 0);
81 }
82 ios.width(25);
83 right(ios);
84 {
85 iter = f.put(output_iterator<char*>(str), ios, '*', v);
86 std::string ex(str, iter.base());
87 assert(ex == "************************0");
88 assert(ios.width() == 0);
89 }
90 ios.width(25);
91 internal(ios);
92 {
93 iter = f.put(output_iterator<char*>(str), ios, '*', v);
94 std::string ex(str, iter.base());
95 assert(ex == "************************0");
96 assert(ios.width() == 0);
97 }
98 }
99 ios.imbue(lg);
100 {
101 ios.width(0);
102 {
103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
104 std::string ex(str, iter.base());
105 assert(ex == "0");
106 assert(ios.width() == 0);
107 }
108 ios.width(25);
109 left(ios);
110 {
111 iter = f.put(output_iterator<char*>(str), ios, '*', v);
112 std::string ex(str, iter.base());
113 assert(ex == "0************************");
114 assert(ios.width() == 0);
115 }
116 ios.width(25);
117 right(ios);
118 {
119 iter = f.put(output_iterator<char*>(str), ios, '*', v);
120 std::string ex(str, iter.base());
121 assert(ex == "************************0");
122 assert(ios.width() == 0);
123 }
124 ios.width(25);
125 internal(ios);
126 {
127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
128 std::string ex(str, iter.base());
129 assert(ex == "************************0");
130 assert(ios.width() == 0);
131 }
132 }
133 }
134 showpoint(ios);
135 {
136 ios.imbue(lc);
137 {
138 ios.width(0);
139 {
140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
141 std::string ex(str, iter.base());
142 assert(ex == "0.");
143 assert(ios.width() == 0);
144 }
145 ios.width(25);
146 left(ios);
147 {
148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
149 std::string ex(str, iter.base());
150 assert(ex == "0.***********************");
151 assert(ios.width() == 0);
152 }
153 ios.width(25);
154 right(ios);
155 {
156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
157 std::string ex(str, iter.base());
158 assert(ex == "***********************0.");
159 assert(ios.width() == 0);
160 }
161 ios.width(25);
162 internal(ios);
163 {
164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
165 std::string ex(str, iter.base());
166 assert(ex == "***********************0.");
167 assert(ios.width() == 0);
168 }
169 }
170 ios.imbue(lg);
171 {
172 ios.width(0);
173 {
174 iter = f.put(output_iterator<char*>(str), ios, '*', v);
175 std::string ex(str, iter.base());
176 assert(ex == "0;");
177 assert(ios.width() == 0);
178 }
179 ios.width(25);
180 left(ios);
181 {
182 iter = f.put(output_iterator<char*>(str), ios, '*', v);
183 std::string ex(str, iter.base());
184 assert(ex == "0;***********************");
185 assert(ios.width() == 0);
186 }
187 ios.width(25);
188 right(ios);
189 {
190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
191 std::string ex(str, iter.base());
192 assert(ex == "***********************0;");
193 assert(ios.width() == 0);
194 }
195 ios.width(25);
196 internal(ios);
197 {
198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
199 std::string ex(str, iter.base());
200 assert(ex == "***********************0;");
201 assert(ios.width() == 0);
202 }
203 }
204 }
205 }
206 showpos(ios);
207 {
208 noshowpoint(ios);
209 {
210 ios.imbue(lc);
211 {
212 ios.width(0);
213 {
214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
215 std::string ex(str, iter.base());
216 assert(ex == "+0");
217 assert(ios.width() == 0);
218 }
219 ios.width(25);
220 left(ios);
221 {
222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
223 std::string ex(str, iter.base());
224 assert(ex == "+0***********************");
225 assert(ios.width() == 0);
226 }
227 ios.width(25);
228 right(ios);
229 {
230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
231 std::string ex(str, iter.base());
232 assert(ex == "***********************+0");
233 assert(ios.width() == 0);
234 }
235 ios.width(25);
236 internal(ios);
237 {
238 iter = f.put(output_iterator<char*>(str), ios, '*', v);
239 std::string ex(str, iter.base());
240 assert(ex == "+***********************0");
241 assert(ios.width() == 0);
242 }
243 }
244 ios.imbue(lg);
245 {
246 ios.width(0);
247 {
248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
249 std::string ex(str, iter.base());
250 assert(ex == "+0");
251 assert(ios.width() == 0);
252 }
253 ios.width(25);
254 left(ios);
255 {
256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
257 std::string ex(str, iter.base());
258 assert(ex == "+0***********************");
259 assert(ios.width() == 0);
260 }
261 ios.width(25);
262 right(ios);
263 {
264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
265 std::string ex(str, iter.base());
266 assert(ex == "***********************+0");
267 assert(ios.width() == 0);
268 }
269 ios.width(25);
270 internal(ios);
271 {
272 iter = f.put(output_iterator<char*>(str), ios, '*', v);
273 std::string ex(str, iter.base());
274 assert(ex == "+***********************0");
275 assert(ios.width() == 0);
276 }
277 }
278 }
279 showpoint(ios);
280 {
281 ios.imbue(lc);
282 {
283 ios.width(0);
284 {
285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
286 std::string ex(str, iter.base());
287 assert(ex == "+0.");
288 assert(ios.width() == 0);
289 }
290 ios.width(25);
291 left(ios);
292 {
293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
294 std::string ex(str, iter.base());
295 assert(ex == "+0.**********************");
296 assert(ios.width() == 0);
297 }
298 ios.width(25);
299 right(ios);
300 {
301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
302 std::string ex(str, iter.base());
303 assert(ex == "**********************+0.");
304 assert(ios.width() == 0);
305 }
306 ios.width(25);
307 internal(ios);
308 {
309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
310 std::string ex(str, iter.base());
311 assert(ex == "+**********************0.");
312 assert(ios.width() == 0);
313 }
314 }
315 ios.imbue(lg);
316 {
317 ios.width(0);
318 {
319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
320 std::string ex(str, iter.base());
321 assert(ex == "+0;");
322 assert(ios.width() == 0);
323 }
324 ios.width(25);
325 left(ios);
326 {
327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
328 std::string ex(str, iter.base());
329 assert(ex == "+0;**********************");
330 assert(ios.width() == 0);
331 }
332 ios.width(25);
333 right(ios);
334 {
335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
336 std::string ex(str, iter.base());
337 assert(ex == "**********************+0;");
338 assert(ios.width() == 0);
339 }
340 ios.width(25);
341 internal(ios);
342 {
343 iter = f.put(output_iterator<char*>(str), ios, '*', v);
344 std::string ex(str, iter.base());
345 assert(ex == "+**********************0;");
346 assert(ios.width() == 0);
347 }
348 }
349 }
350 }
351 }
352 uppercase(ios);
353 {
354 noshowpos(ios);
355 {
356 noshowpoint(ios);
357 {
358 ios.imbue(lc);
359 {
360 ios.width(0);
361 {
362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
363 std::string ex(str, iter.base());
364 assert(ex == "0");
365 assert(ios.width() == 0);
366 }
367 ios.width(25);
368 left(ios);
369 {
370 iter = f.put(output_iterator<char*>(str), ios, '*', v);
371 std::string ex(str, iter.base());
372 assert(ex == "0************************");
373 assert(ios.width() == 0);
374 }
375 ios.width(25);
376 right(ios);
377 {
378 iter = f.put(output_iterator<char*>(str), ios, '*', v);
379 std::string ex(str, iter.base());
380 assert(ex == "************************0");
381 assert(ios.width() == 0);
382 }
383 ios.width(25);
384 internal(ios);
385 {
386 iter = f.put(output_iterator<char*>(str), ios, '*', v);
387 std::string ex(str, iter.base());
388 assert(ex == "************************0");
389 assert(ios.width() == 0);
390 }
391 }
392 ios.imbue(lg);
393 {
394 ios.width(0);
395 {
396 iter = f.put(output_iterator<char*>(str), ios, '*', v);
397 std::string ex(str, iter.base());
398 assert(ex == "0");
399 assert(ios.width() == 0);
400 }
401 ios.width(25);
402 left(ios);
403 {
404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
405 std::string ex(str, iter.base());
406 assert(ex == "0************************");
407 assert(ios.width() == 0);
408 }
409 ios.width(25);
410 right(ios);
411 {
412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
413 std::string ex(str, iter.base());
414 assert(ex == "************************0");
415 assert(ios.width() == 0);
416 }
417 ios.width(25);
418 internal(ios);
419 {
420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
421 std::string ex(str, iter.base());
422 assert(ex == "************************0");
423 assert(ios.width() == 0);
424 }
425 }
426 }
427 showpoint(ios);
428 {
429 ios.imbue(lc);
430 {
431 ios.width(0);
432 {
433 iter = f.put(output_iterator<char*>(str), ios, '*', v);
434 std::string ex(str, iter.base());
435 assert(ex == "0.");
436 assert(ios.width() == 0);
437 }
438 ios.width(25);
439 left(ios);
440 {
441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
442 std::string ex(str, iter.base());
443 assert(ex == "0.***********************");
444 assert(ios.width() == 0);
445 }
446 ios.width(25);
447 right(ios);
448 {
449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
450 std::string ex(str, iter.base());
451 assert(ex == "***********************0.");
452 assert(ios.width() == 0);
453 }
454 ios.width(25);
455 internal(ios);
456 {
457 iter = f.put(output_iterator<char*>(str), ios, '*', v);
458 std::string ex(str, iter.base());
459 assert(ex == "***********************0.");
460 assert(ios.width() == 0);
461 }
462 }
463 ios.imbue(lg);
464 {
465 ios.width(0);
466 {
467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
468 std::string ex(str, iter.base());
469 assert(ex == "0;");
470 assert(ios.width() == 0);
471 }
472 ios.width(25);
473 left(ios);
474 {
475 iter = f.put(output_iterator<char*>(str), ios, '*', v);
476 std::string ex(str, iter.base());
477 assert(ex == "0;***********************");
478 assert(ios.width() == 0);
479 }
480 ios.width(25);
481 right(ios);
482 {
483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
484 std::string ex(str, iter.base());
485 assert(ex == "***********************0;");
486 assert(ios.width() == 0);
487 }
488 ios.width(25);
489 internal(ios);
490 {
491 iter = f.put(output_iterator<char*>(str), ios, '*', v);
492 std::string ex(str, iter.base());
493 assert(ex == "***********************0;");
494 assert(ios.width() == 0);
495 }
496 }
497 }
498 }
499 showpos(ios);
500 {
501 noshowpoint(ios);
502 {
503 ios.imbue(lc);
504 {
505 ios.width(0);
506 {
507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
508 std::string ex(str, iter.base());
509 assert(ex == "+0");
510 assert(ios.width() == 0);
511 }
512 ios.width(25);
513 left(ios);
514 {
515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
516 std::string ex(str, iter.base());
517 assert(ex == "+0***********************");
518 assert(ios.width() == 0);
519 }
520 ios.width(25);
521 right(ios);
522 {
523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
524 std::string ex(str, iter.base());
525 assert(ex == "***********************+0");
526 assert(ios.width() == 0);
527 }
528 ios.width(25);
529 internal(ios);
530 {
531 iter = f.put(output_iterator<char*>(str), ios, '*', v);
532 std::string ex(str, iter.base());
533 assert(ex == "+***********************0");
534 assert(ios.width() == 0);
535 }
536 }
537 ios.imbue(lg);
538 {
539 ios.width(0);
540 {
541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
542 std::string ex(str, iter.base());
543 assert(ex == "+0");
544 assert(ios.width() == 0);
545 }
546 ios.width(25);
547 left(ios);
548 {
549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
550 std::string ex(str, iter.base());
551 assert(ex == "+0***********************");
552 assert(ios.width() == 0);
553 }
554 ios.width(25);
555 right(ios);
556 {
557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
558 std::string ex(str, iter.base());
559 assert(ex == "***********************+0");
560 assert(ios.width() == 0);
561 }
562 ios.width(25);
563 internal(ios);
564 {
565 iter = f.put(output_iterator<char*>(str), ios, '*', v);
566 std::string ex(str, iter.base());
567 assert(ex == "+***********************0");
568 assert(ios.width() == 0);
569 }
570 }
571 }
572 showpoint(ios);
573 {
574 ios.imbue(lc);
575 {
576 ios.width(0);
577 {
578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
579 std::string ex(str, iter.base());
580 assert(ex == "+0.");
581 assert(ios.width() == 0);
582 }
583 ios.width(25);
584 left(ios);
585 {
586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
587 std::string ex(str, iter.base());
588 assert(ex == "+0.**********************");
589 assert(ios.width() == 0);
590 }
591 ios.width(25);
592 right(ios);
593 {
594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
595 std::string ex(str, iter.base());
596 assert(ex == "**********************+0.");
597 assert(ios.width() == 0);
598 }
599 ios.width(25);
600 internal(ios);
601 {
602 iter = f.put(output_iterator<char*>(str), ios, '*', v);
603 std::string ex(str, iter.base());
604 assert(ex == "+**********************0.");
605 assert(ios.width() == 0);
606 }
607 }
608 ios.imbue(lg);
609 {
610 ios.width(0);
611 {
612 iter = f.put(output_iterator<char*>(str), ios, '*', v);
613 std::string ex(str, iter.base());
614 assert(ex == "+0;");
615 assert(ios.width() == 0);
616 }
617 ios.width(25);
618 left(ios);
619 {
620 iter = f.put(output_iterator<char*>(str), ios, '*', v);
621 std::string ex(str, iter.base());
622 assert(ex == "+0;**********************");
623 assert(ios.width() == 0);
624 }
625 ios.width(25);
626 right(ios);
627 {
628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
629 std::string ex(str, iter.base());
630 assert(ex == "**********************+0;");
631 assert(ios.width() == 0);
632 }
633 ios.width(25);
634 internal(ios);
635 {
636 iter = f.put(output_iterator<char*>(str), ios, '*', v);
637 std::string ex(str, iter.base());
638 assert(ex == "+**********************0;");
639 assert(ios.width() == 0);
640 }
641 }
642 }
643 }
644 }
645 }
646 ios.precision(1);
647 {
648 nouppercase(ios);
649 {
650 noshowpos(ios);
651 {
652 noshowpoint(ios);
653 {
654 ios.imbue(lc);
655 {
656 ios.width(0);
657 {
658 iter = f.put(output_iterator<char*>(str), ios, '*', v);
659 std::string ex(str, iter.base());
660 assert(ex == "0");
661 assert(ios.width() == 0);
662 }
663 ios.width(25);
664 left(ios);
665 {
666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
667 std::string ex(str, iter.base());
668 assert(ex == "0************************");
669 assert(ios.width() == 0);
670 }
671 ios.width(25);
672 right(ios);
673 {
674 iter = f.put(output_iterator<char*>(str), ios, '*', v);
675 std::string ex(str, iter.base());
676 assert(ex == "************************0");
677 assert(ios.width() == 0);
678 }
679 ios.width(25);
680 internal(ios);
681 {
682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
683 std::string ex(str, iter.base());
684 assert(ex == "************************0");
685 assert(ios.width() == 0);
686 }
687 }
688 ios.imbue(lg);
689 {
690 ios.width(0);
691 {
692 iter = f.put(output_iterator<char*>(str), ios, '*', v);
693 std::string ex(str, iter.base());
694 assert(ex == "0");
695 assert(ios.width() == 0);
696 }
697 ios.width(25);
698 left(ios);
699 {
700 iter = f.put(output_iterator<char*>(str), ios, '*', v);
701 std::string ex(str, iter.base());
702 assert(ex == "0************************");
703 assert(ios.width() == 0);
704 }
705 ios.width(25);
706 right(ios);
707 {
708 iter = f.put(output_iterator<char*>(str), ios, '*', v);
709 std::string ex(str, iter.base());
710 assert(ex == "************************0");
711 assert(ios.width() == 0);
712 }
713 ios.width(25);
714 internal(ios);
715 {
716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
717 std::string ex(str, iter.base());
718 assert(ex == "************************0");
719 assert(ios.width() == 0);
720 }
721 }
722 }
723 showpoint(ios);
724 {
725 ios.imbue(lc);
726 {
727 ios.width(0);
728 {
729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
730 std::string ex(str, iter.base());
731 assert(ex == "0.");
732 assert(ios.width() == 0);
733 }
734 ios.width(25);
735 left(ios);
736 {
737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
738 std::string ex(str, iter.base());
739 assert(ex == "0.***********************");
740 assert(ios.width() == 0);
741 }
742 ios.width(25);
743 right(ios);
744 {
745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
746 std::string ex(str, iter.base());
747 assert(ex == "***********************0.");
748 assert(ios.width() == 0);
749 }
750 ios.width(25);
751 internal(ios);
752 {
753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
754 std::string ex(str, iter.base());
755 assert(ex == "***********************0.");
756 assert(ios.width() == 0);
757 }
758 }
759 ios.imbue(lg);
760 {
761 ios.width(0);
762 {
763 iter = f.put(output_iterator<char*>(str), ios, '*', v);
764 std::string ex(str, iter.base());
765 assert(ex == "0;");
766 assert(ios.width() == 0);
767 }
768 ios.width(25);
769 left(ios);
770 {
771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
772 std::string ex(str, iter.base());
773 assert(ex == "0;***********************");
774 assert(ios.width() == 0);
775 }
776 ios.width(25);
777 right(ios);
778 {
779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
780 std::string ex(str, iter.base());
781 assert(ex == "***********************0;");
782 assert(ios.width() == 0);
783 }
784 ios.width(25);
785 internal(ios);
786 {
787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
788 std::string ex(str, iter.base());
789 assert(ex == "***********************0;");
790 assert(ios.width() == 0);
791 }
792 }
793 }
794 }
795 showpos(ios);
796 {
797 noshowpoint(ios);
798 {
799 ios.imbue(lc);
800 {
801 ios.width(0);
802 {
803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
804 std::string ex(str, iter.base());
805 assert(ex == "+0");
806 assert(ios.width() == 0);
807 }
808 ios.width(25);
809 left(ios);
810 {
811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
812 std::string ex(str, iter.base());
813 assert(ex == "+0***********************");
814 assert(ios.width() == 0);
815 }
816 ios.width(25);
817 right(ios);
818 {
819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
820 std::string ex(str, iter.base());
821 assert(ex == "***********************+0");
822 assert(ios.width() == 0);
823 }
824 ios.width(25);
825 internal(ios);
826 {
827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
828 std::string ex(str, iter.base());
829 assert(ex == "+***********************0");
830 assert(ios.width() == 0);
831 }
832 }
833 ios.imbue(lg);
834 {
835 ios.width(0);
836 {
837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
838 std::string ex(str, iter.base());
839 assert(ex == "+0");
840 assert(ios.width() == 0);
841 }
842 ios.width(25);
843 left(ios);
844 {
845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
846 std::string ex(str, iter.base());
847 assert(ex == "+0***********************");
848 assert(ios.width() == 0);
849 }
850 ios.width(25);
851 right(ios);
852 {
853 iter = f.put(output_iterator<char*>(str), ios, '*', v);
854 std::string ex(str, iter.base());
855 assert(ex == "***********************+0");
856 assert(ios.width() == 0);
857 }
858 ios.width(25);
859 internal(ios);
860 {
861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
862 std::string ex(str, iter.base());
863 assert(ex == "+***********************0");
864 assert(ios.width() == 0);
865 }
866 }
867 }
868 showpoint(ios);
869 {
870 ios.imbue(lc);
871 {
872 ios.width(0);
873 {
874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
875 std::string ex(str, iter.base());
876 assert(ex == "+0.");
877 assert(ios.width() == 0);
878 }
879 ios.width(25);
880 left(ios);
881 {
882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
883 std::string ex(str, iter.base());
884 assert(ex == "+0.**********************");
885 assert(ios.width() == 0);
886 }
887 ios.width(25);
888 right(ios);
889 {
890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
891 std::string ex(str, iter.base());
892 assert(ex == "**********************+0.");
893 assert(ios.width() == 0);
894 }
895 ios.width(25);
896 internal(ios);
897 {
898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
899 std::string ex(str, iter.base());
900 assert(ex == "+**********************0.");
901 assert(ios.width() == 0);
902 }
903 }
904 ios.imbue(lg);
905 {
906 ios.width(0);
907 {
908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
909 std::string ex(str, iter.base());
910 assert(ex == "+0;");
911 assert(ios.width() == 0);
912 }
913 ios.width(25);
914 left(ios);
915 {
916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
917 std::string ex(str, iter.base());
918 assert(ex == "+0;**********************");
919 assert(ios.width() == 0);
920 }
921 ios.width(25);
922 right(ios);
923 {
924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
925 std::string ex(str, iter.base());
926 assert(ex == "**********************+0;");
927 assert(ios.width() == 0);
928 }
929 ios.width(25);
930 internal(ios);
931 {
932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
933 std::string ex(str, iter.base());
934 assert(ex == "+**********************0;");
935 assert(ios.width() == 0);
936 }
937 }
938 }
939 }
940 }
941 uppercase(ios);
942 {
943 noshowpos(ios);
944 {
945 noshowpoint(ios);
946 {
947 ios.imbue(lc);
948 {
949 ios.width(0);
950 {
951 iter = f.put(output_iterator<char*>(str), ios, '*', v);
952 std::string ex(str, iter.base());
953 assert(ex == "0");
954 assert(ios.width() == 0);
955 }
956 ios.width(25);
957 left(ios);
958 {
959 iter = f.put(output_iterator<char*>(str), ios, '*', v);
960 std::string ex(str, iter.base());
961 assert(ex == "0************************");
962 assert(ios.width() == 0);
963 }
964 ios.width(25);
965 right(ios);
966 {
967 iter = f.put(output_iterator<char*>(str), ios, '*', v);
968 std::string ex(str, iter.base());
969 assert(ex == "************************0");
970 assert(ios.width() == 0);
971 }
972 ios.width(25);
973 internal(ios);
974 {
975 iter = f.put(output_iterator<char*>(str), ios, '*', v);
976 std::string ex(str, iter.base());
977 assert(ex == "************************0");
978 assert(ios.width() == 0);
979 }
980 }
981 ios.imbue(lg);
982 {
983 ios.width(0);
984 {
985 iter = f.put(output_iterator<char*>(str), ios, '*', v);
986 std::string ex(str, iter.base());
987 assert(ex == "0");
988 assert(ios.width() == 0);
989 }
990 ios.width(25);
991 left(ios);
992 {
993 iter = f.put(output_iterator<char*>(str), ios, '*', v);
994 std::string ex(str, iter.base());
995 assert(ex == "0************************");
996 assert(ios.width() == 0);
997 }
998 ios.width(25);
999 right(ios);
1000 {
1001 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1002 std::string ex(str, iter.base());
1003 assert(ex == "************************0");
1004 assert(ios.width() == 0);
1005 }
1006 ios.width(25);
1007 internal(ios);
1008 {
1009 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1010 std::string ex(str, iter.base());
1011 assert(ex == "************************0");
1012 assert(ios.width() == 0);
1013 }
1014 }
1015 }
1016 showpoint(ios);
1017 {
1018 ios.imbue(lc);
1019 {
1020 ios.width(0);
1021 {
1022 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1023 std::string ex(str, iter.base());
1024 assert(ex == "0.");
1025 assert(ios.width() == 0);
1026 }
1027 ios.width(25);
1028 left(ios);
1029 {
1030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1031 std::string ex(str, iter.base());
1032 assert(ex == "0.***********************");
1033 assert(ios.width() == 0);
1034 }
1035 ios.width(25);
1036 right(ios);
1037 {
1038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1039 std::string ex(str, iter.base());
1040 assert(ex == "***********************0.");
1041 assert(ios.width() == 0);
1042 }
1043 ios.width(25);
1044 internal(ios);
1045 {
1046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1047 std::string ex(str, iter.base());
1048 assert(ex == "***********************0.");
1049 assert(ios.width() == 0);
1050 }
1051 }
1052 ios.imbue(lg);
1053 {
1054 ios.width(0);
1055 {
1056 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1057 std::string ex(str, iter.base());
1058 assert(ex == "0;");
1059 assert(ios.width() == 0);
1060 }
1061 ios.width(25);
1062 left(ios);
1063 {
1064 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1065 std::string ex(str, iter.base());
1066 assert(ex == "0;***********************");
1067 assert(ios.width() == 0);
1068 }
1069 ios.width(25);
1070 right(ios);
1071 {
1072 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1073 std::string ex(str, iter.base());
1074 assert(ex == "***********************0;");
1075 assert(ios.width() == 0);
1076 }
1077 ios.width(25);
1078 internal(ios);
1079 {
1080 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1081 std::string ex(str, iter.base());
1082 assert(ex == "***********************0;");
1083 assert(ios.width() == 0);
1084 }
1085 }
1086 }
1087 }
1088 showpos(ios);
1089 {
1090 noshowpoint(ios);
1091 {
1092 ios.imbue(lc);
1093 {
1094 ios.width(0);
1095 {
1096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1097 std::string ex(str, iter.base());
1098 assert(ex == "+0");
1099 assert(ios.width() == 0);
1100 }
1101 ios.width(25);
1102 left(ios);
1103 {
1104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1105 std::string ex(str, iter.base());
1106 assert(ex == "+0***********************");
1107 assert(ios.width() == 0);
1108 }
1109 ios.width(25);
1110 right(ios);
1111 {
1112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1113 std::string ex(str, iter.base());
1114 assert(ex == "***********************+0");
1115 assert(ios.width() == 0);
1116 }
1117 ios.width(25);
1118 internal(ios);
1119 {
1120 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1121 std::string ex(str, iter.base());
1122 assert(ex == "+***********************0");
1123 assert(ios.width() == 0);
1124 }
1125 }
1126 ios.imbue(lg);
1127 {
1128 ios.width(0);
1129 {
1130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1131 std::string ex(str, iter.base());
1132 assert(ex == "+0");
1133 assert(ios.width() == 0);
1134 }
1135 ios.width(25);
1136 left(ios);
1137 {
1138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1139 std::string ex(str, iter.base());
1140 assert(ex == "+0***********************");
1141 assert(ios.width() == 0);
1142 }
1143 ios.width(25);
1144 right(ios);
1145 {
1146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1147 std::string ex(str, iter.base());
1148 assert(ex == "***********************+0");
1149 assert(ios.width() == 0);
1150 }
1151 ios.width(25);
1152 internal(ios);
1153 {
1154 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1155 std::string ex(str, iter.base());
1156 assert(ex == "+***********************0");
1157 assert(ios.width() == 0);
1158 }
1159 }
1160 }
1161 showpoint(ios);
1162 {
1163 ios.imbue(lc);
1164 {
1165 ios.width(0);
1166 {
1167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1168 std::string ex(str, iter.base());
1169 assert(ex == "+0.");
1170 assert(ios.width() == 0);
1171 }
1172 ios.width(25);
1173 left(ios);
1174 {
1175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1176 std::string ex(str, iter.base());
1177 assert(ex == "+0.**********************");
1178 assert(ios.width() == 0);
1179 }
1180 ios.width(25);
1181 right(ios);
1182 {
1183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1184 std::string ex(str, iter.base());
1185 assert(ex == "**********************+0.");
1186 assert(ios.width() == 0);
1187 }
1188 ios.width(25);
1189 internal(ios);
1190 {
1191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1192 std::string ex(str, iter.base());
1193 assert(ex == "+**********************0.");
1194 assert(ios.width() == 0);
1195 }
1196 }
1197 ios.imbue(lg);
1198 {
1199 ios.width(0);
1200 {
1201 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1202 std::string ex(str, iter.base());
1203 assert(ex == "+0;");
1204 assert(ios.width() == 0);
1205 }
1206 ios.width(25);
1207 left(ios);
1208 {
1209 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1210 std::string ex(str, iter.base());
1211 assert(ex == "+0;**********************");
1212 assert(ios.width() == 0);
1213 }
1214 ios.width(25);
1215 right(ios);
1216 {
1217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1218 std::string ex(str, iter.base());
1219 assert(ex == "**********************+0;");
1220 assert(ios.width() == 0);
1221 }
1222 ios.width(25);
1223 internal(ios);
1224 {
1225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1226 std::string ex(str, iter.base());
1227 assert(ex == "+**********************0;");
1228 assert(ios.width() == 0);
1229 }
1230 }
1231 }
1232 }
1233 }
1234 }
1235 ios.precision(6);
1236 {
1237 nouppercase(ios);
1238 {
1239 noshowpos(ios);
1240 {
1241 noshowpoint(ios);
1242 {
1243 ios.imbue(lc);
1244 {
1245 ios.width(0);
1246 {
1247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1248 std::string ex(str, iter.base());
1249 assert(ex == "0");
1250 assert(ios.width() == 0);
1251 }
1252 ios.width(25);
1253 left(ios);
1254 {
1255 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1256 std::string ex(str, iter.base());
1257 assert(ex == "0************************");
1258 assert(ios.width() == 0);
1259 }
1260 ios.width(25);
1261 right(ios);
1262 {
1263 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1264 std::string ex(str, iter.base());
1265 assert(ex == "************************0");
1266 assert(ios.width() == 0);
1267 }
1268 ios.width(25);
1269 internal(ios);
1270 {
1271 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1272 std::string ex(str, iter.base());
1273 assert(ex == "************************0");
1274 assert(ios.width() == 0);
1275 }
1276 }
1277 ios.imbue(lg);
1278 {
1279 ios.width(0);
1280 {
1281 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1282 std::string ex(str, iter.base());
1283 assert(ex == "0");
1284 assert(ios.width() == 0);
1285 }
1286 ios.width(25);
1287 left(ios);
1288 {
1289 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1290 std::string ex(str, iter.base());
1291 assert(ex == "0************************");
1292 assert(ios.width() == 0);
1293 }
1294 ios.width(25);
1295 right(ios);
1296 {
1297 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1298 std::string ex(str, iter.base());
1299 assert(ex == "************************0");
1300 assert(ios.width() == 0);
1301 }
1302 ios.width(25);
1303 internal(ios);
1304 {
1305 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1306 std::string ex(str, iter.base());
1307 assert(ex == "************************0");
1308 assert(ios.width() == 0);
1309 }
1310 }
1311 }
1312 showpoint(ios);
1313 {
1314 ios.imbue(lc);
1315 {
1316 ios.width(0);
1317 {
1318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1319 std::string ex(str, iter.base());
1320 assert(ex == "0.00000");
1321 assert(ios.width() == 0);
1322 }
1323 ios.width(25);
1324 left(ios);
1325 {
1326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1327 std::string ex(str, iter.base());
1328 assert(ex == "0.00000******************");
1329 assert(ios.width() == 0);
1330 }
1331 ios.width(25);
1332 right(ios);
1333 {
1334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1335 std::string ex(str, iter.base());
1336 assert(ex == "******************0.00000");
1337 assert(ios.width() == 0);
1338 }
1339 ios.width(25);
1340 internal(ios);
1341 {
1342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1343 std::string ex(str, iter.base());
1344 assert(ex == "******************0.00000");
1345 assert(ios.width() == 0);
1346 }
1347 }
1348 ios.imbue(lg);
1349 {
1350 ios.width(0);
1351 {
1352 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1353 std::string ex(str, iter.base());
1354 assert(ex == "0;00000");
1355 assert(ios.width() == 0);
1356 }
1357 ios.width(25);
1358 left(ios);
1359 {
1360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1361 std::string ex(str, iter.base());
1362 assert(ex == "0;00000******************");
1363 assert(ios.width() == 0);
1364 }
1365 ios.width(25);
1366 right(ios);
1367 {
1368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1369 std::string ex(str, iter.base());
1370 assert(ex == "******************0;00000");
1371 assert(ios.width() == 0);
1372 }
1373 ios.width(25);
1374 internal(ios);
1375 {
1376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1377 std::string ex(str, iter.base());
1378 assert(ex == "******************0;00000");
1379 assert(ios.width() == 0);
1380 }
1381 }
1382 }
1383 }
1384 showpos(ios);
1385 {
1386 noshowpoint(ios);
1387 {
1388 ios.imbue(lc);
1389 {
1390 ios.width(0);
1391 {
1392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1393 std::string ex(str, iter.base());
1394 assert(ex == "+0");
1395 assert(ios.width() == 0);
1396 }
1397 ios.width(25);
1398 left(ios);
1399 {
1400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1401 std::string ex(str, iter.base());
1402 assert(ex == "+0***********************");
1403 assert(ios.width() == 0);
1404 }
1405 ios.width(25);
1406 right(ios);
1407 {
1408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1409 std::string ex(str, iter.base());
1410 assert(ex == "***********************+0");
1411 assert(ios.width() == 0);
1412 }
1413 ios.width(25);
1414 internal(ios);
1415 {
1416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1417 std::string ex(str, iter.base());
1418 assert(ex == "+***********************0");
1419 assert(ios.width() == 0);
1420 }
1421 }
1422 ios.imbue(lg);
1423 {
1424 ios.width(0);
1425 {
1426 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1427 std::string ex(str, iter.base());
1428 assert(ex == "+0");
1429 assert(ios.width() == 0);
1430 }
1431 ios.width(25);
1432 left(ios);
1433 {
1434 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1435 std::string ex(str, iter.base());
1436 assert(ex == "+0***********************");
1437 assert(ios.width() == 0);
1438 }
1439 ios.width(25);
1440 right(ios);
1441 {
1442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1443 std::string ex(str, iter.base());
1444 assert(ex == "***********************+0");
1445 assert(ios.width() == 0);
1446 }
1447 ios.width(25);
1448 internal(ios);
1449 {
1450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1451 std::string ex(str, iter.base());
1452 assert(ex == "+***********************0");
1453 assert(ios.width() == 0);
1454 }
1455 }
1456 }
1457 showpoint(ios);
1458 {
1459 ios.imbue(lc);
1460 {
1461 ios.width(0);
1462 {
1463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1464 std::string ex(str, iter.base());
1465 assert(ex == "+0.00000");
1466 assert(ios.width() == 0);
1467 }
1468 ios.width(25);
1469 left(ios);
1470 {
1471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1472 std::string ex(str, iter.base());
1473 assert(ex == "+0.00000*****************");
1474 assert(ios.width() == 0);
1475 }
1476 ios.width(25);
1477 right(ios);
1478 {
1479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1480 std::string ex(str, iter.base());
1481 assert(ex == "*****************+0.00000");
1482 assert(ios.width() == 0);
1483 }
1484 ios.width(25);
1485 internal(ios);
1486 {
1487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1488 std::string ex(str, iter.base());
1489 assert(ex == "+*****************0.00000");
1490 assert(ios.width() == 0);
1491 }
1492 }
1493 ios.imbue(lg);
1494 {
1495 ios.width(0);
1496 {
1497 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1498 std::string ex(str, iter.base());
1499 assert(ex == "+0;00000");
1500 assert(ios.width() == 0);
1501 }
1502 ios.width(25);
1503 left(ios);
1504 {
1505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1506 std::string ex(str, iter.base());
1507 assert(ex == "+0;00000*****************");
1508 assert(ios.width() == 0);
1509 }
1510 ios.width(25);
1511 right(ios);
1512 {
1513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1514 std::string ex(str, iter.base());
1515 assert(ex == "*****************+0;00000");
1516 assert(ios.width() == 0);
1517 }
1518 ios.width(25);
1519 internal(ios);
1520 {
1521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1522 std::string ex(str, iter.base());
1523 assert(ex == "+*****************0;00000");
1524 assert(ios.width() == 0);
1525 }
1526 }
1527 }
1528 }
1529 }
1530 uppercase(ios);
1531 {
1532 noshowpos(ios);
1533 {
1534 noshowpoint(ios);
1535 {
1536 ios.imbue(lc);
1537 {
1538 ios.width(0);
1539 {
1540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1541 std::string ex(str, iter.base());
1542 assert(ex == "0");
1543 assert(ios.width() == 0);
1544 }
1545 ios.width(25);
1546 left(ios);
1547 {
1548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1549 std::string ex(str, iter.base());
1550 assert(ex == "0************************");
1551 assert(ios.width() == 0);
1552 }
1553 ios.width(25);
1554 right(ios);
1555 {
1556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1557 std::string ex(str, iter.base());
1558 assert(ex == "************************0");
1559 assert(ios.width() == 0);
1560 }
1561 ios.width(25);
1562 internal(ios);
1563 {
1564 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1565 std::string ex(str, iter.base());
1566 assert(ex == "************************0");
1567 assert(ios.width() == 0);
1568 }
1569 }
1570 ios.imbue(lg);
1571 {
1572 ios.width(0);
1573 {
1574 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1575 std::string ex(str, iter.base());
1576 assert(ex == "0");
1577 assert(ios.width() == 0);
1578 }
1579 ios.width(25);
1580 left(ios);
1581 {
1582 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1583 std::string ex(str, iter.base());
1584 assert(ex == "0************************");
1585 assert(ios.width() == 0);
1586 }
1587 ios.width(25);
1588 right(ios);
1589 {
1590 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1591 std::string ex(str, iter.base());
1592 assert(ex == "************************0");
1593 assert(ios.width() == 0);
1594 }
1595 ios.width(25);
1596 internal(ios);
1597 {
1598 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1599 std::string ex(str, iter.base());
1600 assert(ex == "************************0");
1601 assert(ios.width() == 0);
1602 }
1603 }
1604 }
1605 showpoint(ios);
1606 {
1607 ios.imbue(lc);
1608 {
1609 ios.width(0);
1610 {
1611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1612 std::string ex(str, iter.base());
1613 assert(ex == "0.00000");
1614 assert(ios.width() == 0);
1615 }
1616 ios.width(25);
1617 left(ios);
1618 {
1619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1620 std::string ex(str, iter.base());
1621 assert(ex == "0.00000******************");
1622 assert(ios.width() == 0);
1623 }
1624 ios.width(25);
1625 right(ios);
1626 {
1627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1628 std::string ex(str, iter.base());
1629 assert(ex == "******************0.00000");
1630 assert(ios.width() == 0);
1631 }
1632 ios.width(25);
1633 internal(ios);
1634 {
1635 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1636 std::string ex(str, iter.base());
1637 assert(ex == "******************0.00000");
1638 assert(ios.width() == 0);
1639 }
1640 }
1641 ios.imbue(lg);
1642 {
1643 ios.width(0);
1644 {
1645 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1646 std::string ex(str, iter.base());
1647 assert(ex == "0;00000");
1648 assert(ios.width() == 0);
1649 }
1650 ios.width(25);
1651 left(ios);
1652 {
1653 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1654 std::string ex(str, iter.base());
1655 assert(ex == "0;00000******************");
1656 assert(ios.width() == 0);
1657 }
1658 ios.width(25);
1659 right(ios);
1660 {
1661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1662 std::string ex(str, iter.base());
1663 assert(ex == "******************0;00000");
1664 assert(ios.width() == 0);
1665 }
1666 ios.width(25);
1667 internal(ios);
1668 {
1669 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1670 std::string ex(str, iter.base());
1671 assert(ex == "******************0;00000");
1672 assert(ios.width() == 0);
1673 }
1674 }
1675 }
1676 }
1677 showpos(ios);
1678 {
1679 noshowpoint(ios);
1680 {
1681 ios.imbue(lc);
1682 {
1683 ios.width(0);
1684 {
1685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1686 std::string ex(str, iter.base());
1687 assert(ex == "+0");
1688 assert(ios.width() == 0);
1689 }
1690 ios.width(25);
1691 left(ios);
1692 {
1693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1694 std::string ex(str, iter.base());
1695 assert(ex == "+0***********************");
1696 assert(ios.width() == 0);
1697 }
1698 ios.width(25);
1699 right(ios);
1700 {
1701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1702 std::string ex(str, iter.base());
1703 assert(ex == "***********************+0");
1704 assert(ios.width() == 0);
1705 }
1706 ios.width(25);
1707 internal(ios);
1708 {
1709 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1710 std::string ex(str, iter.base());
1711 assert(ex == "+***********************0");
1712 assert(ios.width() == 0);
1713 }
1714 }
1715 ios.imbue(lg);
1716 {
1717 ios.width(0);
1718 {
1719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1720 std::string ex(str, iter.base());
1721 assert(ex == "+0");
1722 assert(ios.width() == 0);
1723 }
1724 ios.width(25);
1725 left(ios);
1726 {
1727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1728 std::string ex(str, iter.base());
1729 assert(ex == "+0***********************");
1730 assert(ios.width() == 0);
1731 }
1732 ios.width(25);
1733 right(ios);
1734 {
1735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1736 std::string ex(str, iter.base());
1737 assert(ex == "***********************+0");
1738 assert(ios.width() == 0);
1739 }
1740 ios.width(25);
1741 internal(ios);
1742 {
1743 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1744 std::string ex(str, iter.base());
1745 assert(ex == "+***********************0");
1746 assert(ios.width() == 0);
1747 }
1748 }
1749 }
1750 showpoint(ios);
1751 {
1752 ios.imbue(lc);
1753 {
1754 ios.width(0);
1755 {
1756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1757 std::string ex(str, iter.base());
1758 assert(ex == "+0.00000");
1759 assert(ios.width() == 0);
1760 }
1761 ios.width(25);
1762 left(ios);
1763 {
1764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1765 std::string ex(str, iter.base());
1766 assert(ex == "+0.00000*****************");
1767 assert(ios.width() == 0);
1768 }
1769 ios.width(25);
1770 right(ios);
1771 {
1772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1773 std::string ex(str, iter.base());
1774 assert(ex == "*****************+0.00000");
1775 assert(ios.width() == 0);
1776 }
1777 ios.width(25);
1778 internal(ios);
1779 {
1780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1781 std::string ex(str, iter.base());
1782 assert(ex == "+*****************0.00000");
1783 assert(ios.width() == 0);
1784 }
1785 }
1786 ios.imbue(lg);
1787 {
1788 ios.width(0);
1789 {
1790 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1791 std::string ex(str, iter.base());
1792 assert(ex == "+0;00000");
1793 assert(ios.width() == 0);
1794 }
1795 ios.width(25);
1796 left(ios);
1797 {
1798 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1799 std::string ex(str, iter.base());
1800 assert(ex == "+0;00000*****************");
1801 assert(ios.width() == 0);
1802 }
1803 ios.width(25);
1804 right(ios);
1805 {
1806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1807 std::string ex(str, iter.base());
1808 assert(ex == "*****************+0;00000");
1809 assert(ios.width() == 0);
1810 }
1811 ios.width(25);
1812 internal(ios);
1813 {
1814 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1815 std::string ex(str, iter.base());
1816 assert(ex == "+*****************0;00000");
1817 assert(ios.width() == 0);
1818 }
1819 }
1820 }
1821 }
1822 }
1823 }
1824 ios.precision(16);
1825 {
1826 nouppercase(ios);
1827 {
1828 noshowpos(ios);
1829 {
1830 noshowpoint(ios);
1831 {
1832 ios.imbue(lc);
1833 {
1834 ios.width(0);
1835 {
1836 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1837 std::string ex(str, iter.base());
1838 assert(ex == "0");
1839 assert(ios.width() == 0);
1840 }
1841 ios.width(25);
1842 left(ios);
1843 {
1844 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1845 std::string ex(str, iter.base());
1846 assert(ex == "0************************");
1847 assert(ios.width() == 0);
1848 }
1849 ios.width(25);
1850 right(ios);
1851 {
1852 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1853 std::string ex(str, iter.base());
1854 assert(ex == "************************0");
1855 assert(ios.width() == 0);
1856 }
1857 ios.width(25);
1858 internal(ios);
1859 {
1860 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1861 std::string ex(str, iter.base());
1862 assert(ex == "************************0");
1863 assert(ios.width() == 0);
1864 }
1865 }
1866 ios.imbue(lg);
1867 {
1868 ios.width(0);
1869 {
1870 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1871 std::string ex(str, iter.base());
1872 assert(ex == "0");
1873 assert(ios.width() == 0);
1874 }
1875 ios.width(25);
1876 left(ios);
1877 {
1878 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1879 std::string ex(str, iter.base());
1880 assert(ex == "0************************");
1881 assert(ios.width() == 0);
1882 }
1883 ios.width(25);
1884 right(ios);
1885 {
1886 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1887 std::string ex(str, iter.base());
1888 assert(ex == "************************0");
1889 assert(ios.width() == 0);
1890 }
1891 ios.width(25);
1892 internal(ios);
1893 {
1894 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1895 std::string ex(str, iter.base());
1896 assert(ex == "************************0");
1897 assert(ios.width() == 0);
1898 }
1899 }
1900 }
1901 showpoint(ios);
1902 {
1903 ios.imbue(lc);
1904 {
1905 ios.width(0);
1906 {
1907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1908 std::string ex(str, iter.base());
1909 assert(ex == "0.000000000000000");
1910 assert(ios.width() == 0);
1911 }
1912 ios.width(25);
1913 left(ios);
1914 {
1915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1916 std::string ex(str, iter.base());
1917 assert(ex == "0.000000000000000********");
1918 assert(ios.width() == 0);
1919 }
1920 ios.width(25);
1921 right(ios);
1922 {
1923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1924 std::string ex(str, iter.base());
1925 assert(ex == "********0.000000000000000");
1926 assert(ios.width() == 0);
1927 }
1928 ios.width(25);
1929 internal(ios);
1930 {
1931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1932 std::string ex(str, iter.base());
1933 assert(ex == "********0.000000000000000");
1934 assert(ios.width() == 0);
1935 }
1936 }
1937 ios.imbue(lg);
1938 {
1939 ios.width(0);
1940 {
1941 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1942 std::string ex(str, iter.base());
1943 assert(ex == "0;000000000000000");
1944 assert(ios.width() == 0);
1945 }
1946 ios.width(25);
1947 left(ios);
1948 {
1949 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1950 std::string ex(str, iter.base());
1951 assert(ex == "0;000000000000000********");
1952 assert(ios.width() == 0);
1953 }
1954 ios.width(25);
1955 right(ios);
1956 {
1957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1958 std::string ex(str, iter.base());
1959 assert(ex == "********0;000000000000000");
1960 assert(ios.width() == 0);
1961 }
1962 ios.width(25);
1963 internal(ios);
1964 {
1965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1966 std::string ex(str, iter.base());
1967 assert(ex == "********0;000000000000000");
1968 assert(ios.width() == 0);
1969 }
1970 }
1971 }
1972 }
1973 showpos(ios);
1974 {
1975 noshowpoint(ios);
1976 {
1977 ios.imbue(lc);
1978 {
1979 ios.width(0);
1980 {
1981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1982 std::string ex(str, iter.base());
1983 assert(ex == "+0");
1984 assert(ios.width() == 0);
1985 }
1986 ios.width(25);
1987 left(ios);
1988 {
1989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1990 std::string ex(str, iter.base());
1991 assert(ex == "+0***********************");
1992 assert(ios.width() == 0);
1993 }
1994 ios.width(25);
1995 right(ios);
1996 {
1997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1998 std::string ex(str, iter.base());
1999 assert(ex == "***********************+0");
2000 assert(ios.width() == 0);
2001 }
2002 ios.width(25);
2003 internal(ios);
2004 {
2005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2006 std::string ex(str, iter.base());
2007 assert(ex == "+***********************0");
2008 assert(ios.width() == 0);
2009 }
2010 }
2011 ios.imbue(lg);
2012 {
2013 ios.width(0);
2014 {
2015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2016 std::string ex(str, iter.base());
2017 assert(ex == "+0");
2018 assert(ios.width() == 0);
2019 }
2020 ios.width(25);
2021 left(ios);
2022 {
2023 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2024 std::string ex(str, iter.base());
2025 assert(ex == "+0***********************");
2026 assert(ios.width() == 0);
2027 }
2028 ios.width(25);
2029 right(ios);
2030 {
2031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2032 std::string ex(str, iter.base());
2033 assert(ex == "***********************+0");
2034 assert(ios.width() == 0);
2035 }
2036 ios.width(25);
2037 internal(ios);
2038 {
2039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2040 std::string ex(str, iter.base());
2041 assert(ex == "+***********************0");
2042 assert(ios.width() == 0);
2043 }
2044 }
2045 }
2046 showpoint(ios);
2047 {
2048 ios.imbue(lc);
2049 {
2050 ios.width(0);
2051 {
2052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2053 std::string ex(str, iter.base());
2054 assert(ex == "+0.000000000000000");
2055 assert(ios.width() == 0);
2056 }
2057 ios.width(25);
2058 left(ios);
2059 {
2060 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2061 std::string ex(str, iter.base());
2062 assert(ex == "+0.000000000000000*******");
2063 assert(ios.width() == 0);
2064 }
2065 ios.width(25);
2066 right(ios);
2067 {
2068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2069 std::string ex(str, iter.base());
2070 assert(ex == "*******+0.000000000000000");
2071 assert(ios.width() == 0);
2072 }
2073 ios.width(25);
2074 internal(ios);
2075 {
2076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2077 std::string ex(str, iter.base());
2078 assert(ex == "+*******0.000000000000000");
2079 assert(ios.width() == 0);
2080 }
2081 }
2082 ios.imbue(lg);
2083 {
2084 ios.width(0);
2085 {
2086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2087 std::string ex(str, iter.base());
2088 assert(ex == "+0;000000000000000");
2089 assert(ios.width() == 0);
2090 }
2091 ios.width(25);
2092 left(ios);
2093 {
2094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2095 std::string ex(str, iter.base());
2096 assert(ex == "+0;000000000000000*******");
2097 assert(ios.width() == 0);
2098 }
2099 ios.width(25);
2100 right(ios);
2101 {
2102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2103 std::string ex(str, iter.base());
2104 assert(ex == "*******+0;000000000000000");
2105 assert(ios.width() == 0);
2106 }
2107 ios.width(25);
2108 internal(ios);
2109 {
2110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2111 std::string ex(str, iter.base());
2112 assert(ex == "+*******0;000000000000000");
2113 assert(ios.width() == 0);
2114 }
2115 }
2116 }
2117 }
2118 }
2119 uppercase(ios);
2120 {
2121 noshowpos(ios);
2122 {
2123 noshowpoint(ios);
2124 {
2125 ios.imbue(lc);
2126 {
2127 ios.width(0);
2128 {
2129 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2130 std::string ex(str, iter.base());
2131 assert(ex == "0");
2132 assert(ios.width() == 0);
2133 }
2134 ios.width(25);
2135 left(ios);
2136 {
2137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2138 std::string ex(str, iter.base());
2139 assert(ex == "0************************");
2140 assert(ios.width() == 0);
2141 }
2142 ios.width(25);
2143 right(ios);
2144 {
2145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2146 std::string ex(str, iter.base());
2147 assert(ex == "************************0");
2148 assert(ios.width() == 0);
2149 }
2150 ios.width(25);
2151 internal(ios);
2152 {
2153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2154 std::string ex(str, iter.base());
2155 assert(ex == "************************0");
2156 assert(ios.width() == 0);
2157 }
2158 }
2159 ios.imbue(lg);
2160 {
2161 ios.width(0);
2162 {
2163 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2164 std::string ex(str, iter.base());
2165 assert(ex == "0");
2166 assert(ios.width() == 0);
2167 }
2168 ios.width(25);
2169 left(ios);
2170 {
2171 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2172 std::string ex(str, iter.base());
2173 assert(ex == "0************************");
2174 assert(ios.width() == 0);
2175 }
2176 ios.width(25);
2177 right(ios);
2178 {
2179 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2180 std::string ex(str, iter.base());
2181 assert(ex == "************************0");
2182 assert(ios.width() == 0);
2183 }
2184 ios.width(25);
2185 internal(ios);
2186 {
2187 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2188 std::string ex(str, iter.base());
2189 assert(ex == "************************0");
2190 assert(ios.width() == 0);
2191 }
2192 }
2193 }
2194 showpoint(ios);
2195 {
2196 ios.imbue(lc);
2197 {
2198 ios.width(0);
2199 {
2200 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2201 std::string ex(str, iter.base());
2202 assert(ex == "0.000000000000000");
2203 assert(ios.width() == 0);
2204 }
2205 ios.width(25);
2206 left(ios);
2207 {
2208 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2209 std::string ex(str, iter.base());
2210 assert(ex == "0.000000000000000********");
2211 assert(ios.width() == 0);
2212 }
2213 ios.width(25);
2214 right(ios);
2215 {
2216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2217 std::string ex(str, iter.base());
2218 assert(ex == "********0.000000000000000");
2219 assert(ios.width() == 0);
2220 }
2221 ios.width(25);
2222 internal(ios);
2223 {
2224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2225 std::string ex(str, iter.base());
2226 assert(ex == "********0.000000000000000");
2227 assert(ios.width() == 0);
2228 }
2229 }
2230 ios.imbue(lg);
2231 {
2232 ios.width(0);
2233 {
2234 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2235 std::string ex(str, iter.base());
2236 assert(ex == "0;000000000000000");
2237 assert(ios.width() == 0);
2238 }
2239 ios.width(25);
2240 left(ios);
2241 {
2242 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2243 std::string ex(str, iter.base());
2244 assert(ex == "0;000000000000000********");
2245 assert(ios.width() == 0);
2246 }
2247 ios.width(25);
2248 right(ios);
2249 {
2250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2251 std::string ex(str, iter.base());
2252 assert(ex == "********0;000000000000000");
2253 assert(ios.width() == 0);
2254 }
2255 ios.width(25);
2256 internal(ios);
2257 {
2258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2259 std::string ex(str, iter.base());
2260 assert(ex == "********0;000000000000000");
2261 assert(ios.width() == 0);
2262 }
2263 }
2264 }
2265 }
2266 showpos(ios);
2267 {
2268 noshowpoint(ios);
2269 {
2270 ios.imbue(lc);
2271 {
2272 ios.width(0);
2273 {
2274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2275 std::string ex(str, iter.base());
2276 assert(ex == "+0");
2277 assert(ios.width() == 0);
2278 }
2279 ios.width(25);
2280 left(ios);
2281 {
2282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2283 std::string ex(str, iter.base());
2284 assert(ex == "+0***********************");
2285 assert(ios.width() == 0);
2286 }
2287 ios.width(25);
2288 right(ios);
2289 {
2290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2291 std::string ex(str, iter.base());
2292 assert(ex == "***********************+0");
2293 assert(ios.width() == 0);
2294 }
2295 ios.width(25);
2296 internal(ios);
2297 {
2298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2299 std::string ex(str, iter.base());
2300 assert(ex == "+***********************0");
2301 assert(ios.width() == 0);
2302 }
2303 }
2304 ios.imbue(lg);
2305 {
2306 ios.width(0);
2307 {
2308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2309 std::string ex(str, iter.base());
2310 assert(ex == "+0");
2311 assert(ios.width() == 0);
2312 }
2313 ios.width(25);
2314 left(ios);
2315 {
2316 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2317 std::string ex(str, iter.base());
2318 assert(ex == "+0***********************");
2319 assert(ios.width() == 0);
2320 }
2321 ios.width(25);
2322 right(ios);
2323 {
2324 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2325 std::string ex(str, iter.base());
2326 assert(ex == "***********************+0");
2327 assert(ios.width() == 0);
2328 }
2329 ios.width(25);
2330 internal(ios);
2331 {
2332 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2333 std::string ex(str, iter.base());
2334 assert(ex == "+***********************0");
2335 assert(ios.width() == 0);
2336 }
2337 }
2338 }
2339 showpoint(ios);
2340 {
2341 ios.imbue(lc);
2342 {
2343 ios.width(0);
2344 {
2345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2346 std::string ex(str, iter.base());
2347 assert(ex == "+0.000000000000000");
2348 assert(ios.width() == 0);
2349 }
2350 ios.width(25);
2351 left(ios);
2352 {
2353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2354 std::string ex(str, iter.base());
2355 assert(ex == "+0.000000000000000*******");
2356 assert(ios.width() == 0);
2357 }
2358 ios.width(25);
2359 right(ios);
2360 {
2361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2362 std::string ex(str, iter.base());
2363 assert(ex == "*******+0.000000000000000");
2364 assert(ios.width() == 0);
2365 }
2366 ios.width(25);
2367 internal(ios);
2368 {
2369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2370 std::string ex(str, iter.base());
2371 assert(ex == "+*******0.000000000000000");
2372 assert(ios.width() == 0);
2373 }
2374 }
2375 ios.imbue(lg);
2376 {
2377 ios.width(0);
2378 {
2379 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2380 std::string ex(str, iter.base());
2381 assert(ex == "+0;000000000000000");
2382 assert(ios.width() == 0);
2383 }
2384 ios.width(25);
2385 left(ios);
2386 {
2387 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2388 std::string ex(str, iter.base());
2389 assert(ex == "+0;000000000000000*******");
2390 assert(ios.width() == 0);
2391 }
2392 ios.width(25);
2393 right(ios);
2394 {
2395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2396 std::string ex(str, iter.base());
2397 assert(ex == "*******+0;000000000000000");
2398 assert(ios.width() == 0);
2399 }
2400 ios.width(25);
2401 internal(ios);
2402 {
2403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2404 std::string ex(str, iter.base());
2405 assert(ex == "+*******0;000000000000000");
2406 assert(ios.width() == 0);
2407 }
2408 }
2409 }
2410 }
2411 }
2412 }
2413 ios.precision(60);
2414 {
2415 nouppercase(ios);
2416 {
2417 noshowpos(ios);
2418 {
2419 noshowpoint(ios);
2420 {
2421 ios.imbue(lc);
2422 {
2423 ios.width(0);
2424 {
2425 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2426 std::string ex(str, iter.base());
2427 assert(ex == "0");
2428 assert(ios.width() == 0);
2429 }
2430 ios.width(25);
2431 left(ios);
2432 {
2433 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2434 std::string ex(str, iter.base());
2435 assert(ex == "0************************");
2436 assert(ios.width() == 0);
2437 }
2438 ios.width(25);
2439 right(ios);
2440 {
2441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2442 std::string ex(str, iter.base());
2443 assert(ex == "************************0");
2444 assert(ios.width() == 0);
2445 }
2446 ios.width(25);
2447 internal(ios);
2448 {
2449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2450 std::string ex(str, iter.base());
2451 assert(ex == "************************0");
2452 assert(ios.width() == 0);
2453 }
2454 }
2455 ios.imbue(lg);
2456 {
2457 ios.width(0);
2458 {
2459 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2460 std::string ex(str, iter.base());
2461 assert(ex == "0");
2462 assert(ios.width() == 0);
2463 }
2464 ios.width(25);
2465 left(ios);
2466 {
2467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2468 std::string ex(str, iter.base());
2469 assert(ex == "0************************");
2470 assert(ios.width() == 0);
2471 }
2472 ios.width(25);
2473 right(ios);
2474 {
2475 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2476 std::string ex(str, iter.base());
2477 assert(ex == "************************0");
2478 assert(ios.width() == 0);
2479 }
2480 ios.width(25);
2481 internal(ios);
2482 {
2483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2484 std::string ex(str, iter.base());
2485 assert(ex == "************************0");
2486 assert(ios.width() == 0);
2487 }
2488 }
2489 }
2490 showpoint(ios);
2491 {
2492 ios.imbue(lc);
2493 {
2494 ios.width(0);
2495 {
2496 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2497 std::string ex(str, iter.base());
2498 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2499 assert(ios.width() == 0);
2500 }
2501 ios.width(25);
2502 left(ios);
2503 {
2504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2505 std::string ex(str, iter.base());
2506 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2507 assert(ios.width() == 0);
2508 }
2509 ios.width(25);
2510 right(ios);
2511 {
2512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2513 std::string ex(str, iter.base());
2514 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2515 assert(ios.width() == 0);
2516 }
2517 ios.width(25);
2518 internal(ios);
2519 {
2520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2521 std::string ex(str, iter.base());
2522 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2523 assert(ios.width() == 0);
2524 }
2525 }
2526 ios.imbue(lg);
2527 {
2528 ios.width(0);
2529 {
2530 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2531 std::string ex(str, iter.base());
2532 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2533 assert(ios.width() == 0);
2534 }
2535 ios.width(25);
2536 left(ios);
2537 {
2538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2539 std::string ex(str, iter.base());
2540 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2541 assert(ios.width() == 0);
2542 }
2543 ios.width(25);
2544 right(ios);
2545 {
2546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2547 std::string ex(str, iter.base());
2548 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2549 assert(ios.width() == 0);
2550 }
2551 ios.width(25);
2552 internal(ios);
2553 {
2554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2555 std::string ex(str, iter.base());
2556 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2557 assert(ios.width() == 0);
2558 }
2559 }
2560 }
2561 }
2562 showpos(ios);
2563 {
2564 noshowpoint(ios);
2565 {
2566 ios.imbue(lc);
2567 {
2568 ios.width(0);
2569 {
2570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2571 std::string ex(str, iter.base());
2572 assert(ex == "+0");
2573 assert(ios.width() == 0);
2574 }
2575 ios.width(25);
2576 left(ios);
2577 {
2578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2579 std::string ex(str, iter.base());
2580 assert(ex == "+0***********************");
2581 assert(ios.width() == 0);
2582 }
2583 ios.width(25);
2584 right(ios);
2585 {
2586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2587 std::string ex(str, iter.base());
2588 assert(ex == "***********************+0");
2589 assert(ios.width() == 0);
2590 }
2591 ios.width(25);
2592 internal(ios);
2593 {
2594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2595 std::string ex(str, iter.base());
2596 assert(ex == "+***********************0");
2597 assert(ios.width() == 0);
2598 }
2599 }
2600 ios.imbue(lg);
2601 {
2602 ios.width(0);
2603 {
2604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2605 std::string ex(str, iter.base());
2606 assert(ex == "+0");
2607 assert(ios.width() == 0);
2608 }
2609 ios.width(25);
2610 left(ios);
2611 {
2612 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2613 std::string ex(str, iter.base());
2614 assert(ex == "+0***********************");
2615 assert(ios.width() == 0);
2616 }
2617 ios.width(25);
2618 right(ios);
2619 {
2620 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2621 std::string ex(str, iter.base());
2622 assert(ex == "***********************+0");
2623 assert(ios.width() == 0);
2624 }
2625 ios.width(25);
2626 internal(ios);
2627 {
2628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2629 std::string ex(str, iter.base());
2630 assert(ex == "+***********************0");
2631 assert(ios.width() == 0);
2632 }
2633 }
2634 }
2635 showpoint(ios);
2636 {
2637 ios.imbue(lc);
2638 {
2639 ios.width(0);
2640 {
2641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2642 std::string ex(str, iter.base());
2643 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2644 assert(ios.width() == 0);
2645 }
2646 ios.width(25);
2647 left(ios);
2648 {
2649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2650 std::string ex(str, iter.base());
2651 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2652 assert(ios.width() == 0);
2653 }
2654 ios.width(25);
2655 right(ios);
2656 {
2657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2658 std::string ex(str, iter.base());
2659 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2660 assert(ios.width() == 0);
2661 }
2662 ios.width(25);
2663 internal(ios);
2664 {
2665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2666 std::string ex(str, iter.base());
2667 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2668 assert(ios.width() == 0);
2669 }
2670 }
2671 ios.imbue(lg);
2672 {
2673 ios.width(0);
2674 {
2675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2676 std::string ex(str, iter.base());
2677 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2678 assert(ios.width() == 0);
2679 }
2680 ios.width(25);
2681 left(ios);
2682 {
2683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2684 std::string ex(str, iter.base());
2685 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2686 assert(ios.width() == 0);
2687 }
2688 ios.width(25);
2689 right(ios);
2690 {
2691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2692 std::string ex(str, iter.base());
2693 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2694 assert(ios.width() == 0);
2695 }
2696 ios.width(25);
2697 internal(ios);
2698 {
2699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2700 std::string ex(str, iter.base());
2701 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2702 assert(ios.width() == 0);
2703 }
2704 }
2705 }
2706 }
2707 }
2708 uppercase(ios);
2709 {
2710 noshowpos(ios);
2711 {
2712 noshowpoint(ios);
2713 {
2714 ios.imbue(lc);
2715 {
2716 ios.width(0);
2717 {
2718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2719 std::string ex(str, iter.base());
2720 assert(ex == "0");
2721 assert(ios.width() == 0);
2722 }
2723 ios.width(25);
2724 left(ios);
2725 {
2726 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2727 std::string ex(str, iter.base());
2728 assert(ex == "0************************");
2729 assert(ios.width() == 0);
2730 }
2731 ios.width(25);
2732 right(ios);
2733 {
2734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2735 std::string ex(str, iter.base());
2736 assert(ex == "************************0");
2737 assert(ios.width() == 0);
2738 }
2739 ios.width(25);
2740 internal(ios);
2741 {
2742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2743 std::string ex(str, iter.base());
2744 assert(ex == "************************0");
2745 assert(ios.width() == 0);
2746 }
2747 }
2748 ios.imbue(lg);
2749 {
2750 ios.width(0);
2751 {
2752 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2753 std::string ex(str, iter.base());
2754 assert(ex == "0");
2755 assert(ios.width() == 0);
2756 }
2757 ios.width(25);
2758 left(ios);
2759 {
2760 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2761 std::string ex(str, iter.base());
2762 assert(ex == "0************************");
2763 assert(ios.width() == 0);
2764 }
2765 ios.width(25);
2766 right(ios);
2767 {
2768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2769 std::string ex(str, iter.base());
2770 assert(ex == "************************0");
2771 assert(ios.width() == 0);
2772 }
2773 ios.width(25);
2774 internal(ios);
2775 {
2776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2777 std::string ex(str, iter.base());
2778 assert(ex == "************************0");
2779 assert(ios.width() == 0);
2780 }
2781 }
2782 }
2783 showpoint(ios);
2784 {
2785 ios.imbue(lc);
2786 {
2787 ios.width(0);
2788 {
2789 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2790 std::string ex(str, iter.base());
2791 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2792 assert(ios.width() == 0);
2793 }
2794 ios.width(25);
2795 left(ios);
2796 {
2797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2798 std::string ex(str, iter.base());
2799 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2800 assert(ios.width() == 0);
2801 }
2802 ios.width(25);
2803 right(ios);
2804 {
2805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2806 std::string ex(str, iter.base());
2807 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2808 assert(ios.width() == 0);
2809 }
2810 ios.width(25);
2811 internal(ios);
2812 {
2813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2814 std::string ex(str, iter.base());
2815 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2816 assert(ios.width() == 0);
2817 }
2818 }
2819 ios.imbue(lg);
2820 {
2821 ios.width(0);
2822 {
2823 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2824 std::string ex(str, iter.base());
2825 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2826 assert(ios.width() == 0);
2827 }
2828 ios.width(25);
2829 left(ios);
2830 {
2831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2832 std::string ex(str, iter.base());
2833 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2834 assert(ios.width() == 0);
2835 }
2836 ios.width(25);
2837 right(ios);
2838 {
2839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2840 std::string ex(str, iter.base());
2841 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2842 assert(ios.width() == 0);
2843 }
2844 ios.width(25);
2845 internal(ios);
2846 {
2847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2848 std::string ex(str, iter.base());
2849 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2850 assert(ios.width() == 0);
2851 }
2852 }
2853 }
2854 }
2855 showpos(ios);
2856 {
2857 noshowpoint(ios);
2858 {
2859 ios.imbue(lc);
2860 {
2861 ios.width(0);
2862 {
2863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2864 std::string ex(str, iter.base());
2865 assert(ex == "+0");
2866 assert(ios.width() == 0);
2867 }
2868 ios.width(25);
2869 left(ios);
2870 {
2871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2872 std::string ex(str, iter.base());
2873 assert(ex == "+0***********************");
2874 assert(ios.width() == 0);
2875 }
2876 ios.width(25);
2877 right(ios);
2878 {
2879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2880 std::string ex(str, iter.base());
2881 assert(ex == "***********************+0");
2882 assert(ios.width() == 0);
2883 }
2884 ios.width(25);
2885 internal(ios);
2886 {
2887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2888 std::string ex(str, iter.base());
2889 assert(ex == "+***********************0");
2890 assert(ios.width() == 0);
2891 }
2892 }
2893 ios.imbue(lg);
2894 {
2895 ios.width(0);
2896 {
2897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2898 std::string ex(str, iter.base());
2899 assert(ex == "+0");
2900 assert(ios.width() == 0);
2901 }
2902 ios.width(25);
2903 left(ios);
2904 {
2905 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2906 std::string ex(str, iter.base());
2907 assert(ex == "+0***********************");
2908 assert(ios.width() == 0);
2909 }
2910 ios.width(25);
2911 right(ios);
2912 {
2913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2914 std::string ex(str, iter.base());
2915 assert(ex == "***********************+0");
2916 assert(ios.width() == 0);
2917 }
2918 ios.width(25);
2919 internal(ios);
2920 {
2921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2922 std::string ex(str, iter.base());
2923 assert(ex == "+***********************0");
2924 assert(ios.width() == 0);
2925 }
2926 }
2927 }
2928 showpoint(ios);
2929 {
2930 ios.imbue(lc);
2931 {
2932 ios.width(0);
2933 {
2934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2935 std::string ex(str, iter.base());
2936 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2937 assert(ios.width() == 0);
2938 }
2939 ios.width(25);
2940 left(ios);
2941 {
2942 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2943 std::string ex(str, iter.base());
2944 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2945 assert(ios.width() == 0);
2946 }
2947 ios.width(25);
2948 right(ios);
2949 {
2950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2951 std::string ex(str, iter.base());
2952 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2953 assert(ios.width() == 0);
2954 }
2955 ios.width(25);
2956 internal(ios);
2957 {
2958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2959 std::string ex(str, iter.base());
2960 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2961 assert(ios.width() == 0);
2962 }
2963 }
2964 ios.imbue(lg);
2965 {
2966 ios.width(0);
2967 {
2968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2969 std::string ex(str, iter.base());
2970 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2971 assert(ios.width() == 0);
2972 }
2973 ios.width(25);
2974 left(ios);
2975 {
2976 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2977 std::string ex(str, iter.base());
2978 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2979 assert(ios.width() == 0);
2980 }
2981 ios.width(25);
2982 right(ios);
2983 {
2984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2985 std::string ex(str, iter.base());
2986 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2987 assert(ios.width() == 0);
2988 }
2989 ios.width(25);
2990 internal(ios);
2991 {
2992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2993 std::string ex(str, iter.base());
2994 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2995 assert(ios.width() == 0);
2996 }
2997 }
2998 }
2999 }
3000 }
3001 }
3002 }
3003 }
3004 }
3005
test2()3006 void test2()
3007 {
3008 char str[200];
3009 output_iterator<char*> iter;
3010 std::locale lc = std::locale::classic();
3011 std::locale lg(lc, new my_numpunct);
3012 const my_facet f(1);
3013 {
3014 double v = 1234567890.125;
3015 std::ios ios(0);
3016 // %g
3017 {
3018 ios.precision(0);
3019 {
3020 nouppercase(ios);
3021 {
3022 noshowpos(ios);
3023 {
3024 noshowpoint(ios);
3025 {
3026 ios.imbue(lc);
3027 {
3028 ios.width(0);
3029 {
3030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3031 std::string ex(str, iter.base());
3032 assert(ex == "1e+09");
3033 assert(ios.width() == 0);
3034 }
3035 ios.width(25);
3036 left(ios);
3037 {
3038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3039 std::string ex(str, iter.base());
3040 assert(ex == "1e+09********************");
3041 assert(ios.width() == 0);
3042 }
3043 ios.width(25);
3044 right(ios);
3045 {
3046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3047 std::string ex(str, iter.base());
3048 assert(ex == "********************1e+09");
3049 assert(ios.width() == 0);
3050 }
3051 ios.width(25);
3052 internal(ios);
3053 {
3054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3055 std::string ex(str, iter.base());
3056 assert(ex == "********************1e+09");
3057 assert(ios.width() == 0);
3058 }
3059 }
3060 ios.imbue(lg);
3061 {
3062 ios.width(0);
3063 {
3064 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3065 std::string ex(str, iter.base());
3066 assert(ex == "1e+09");
3067 assert(ios.width() == 0);
3068 }
3069 ios.width(25);
3070 left(ios);
3071 {
3072 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3073 std::string ex(str, iter.base());
3074 assert(ex == "1e+09********************");
3075 assert(ios.width() == 0);
3076 }
3077 ios.width(25);
3078 right(ios);
3079 {
3080 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3081 std::string ex(str, iter.base());
3082 assert(ex == "********************1e+09");
3083 assert(ios.width() == 0);
3084 }
3085 ios.width(25);
3086 internal(ios);
3087 {
3088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3089 std::string ex(str, iter.base());
3090 assert(ex == "********************1e+09");
3091 assert(ios.width() == 0);
3092 }
3093 }
3094 }
3095 showpoint(ios);
3096 {
3097 ios.imbue(lc);
3098 {
3099 ios.width(0);
3100 {
3101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3102 std::string ex(str, iter.base());
3103 assert(ex == "1.e+09");
3104 assert(ios.width() == 0);
3105 }
3106 ios.width(25);
3107 left(ios);
3108 {
3109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3110 std::string ex(str, iter.base());
3111 assert(ex == "1.e+09*******************");
3112 assert(ios.width() == 0);
3113 }
3114 ios.width(25);
3115 right(ios);
3116 {
3117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3118 std::string ex(str, iter.base());
3119 assert(ex == "*******************1.e+09");
3120 assert(ios.width() == 0);
3121 }
3122 ios.width(25);
3123 internal(ios);
3124 {
3125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3126 std::string ex(str, iter.base());
3127 assert(ex == "*******************1.e+09");
3128 assert(ios.width() == 0);
3129 }
3130 }
3131 ios.imbue(lg);
3132 {
3133 ios.width(0);
3134 {
3135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3136 std::string ex(str, iter.base());
3137 assert(ex == "1;e+09");
3138 assert(ios.width() == 0);
3139 }
3140 ios.width(25);
3141 left(ios);
3142 {
3143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3144 std::string ex(str, iter.base());
3145 assert(ex == "1;e+09*******************");
3146 assert(ios.width() == 0);
3147 }
3148 ios.width(25);
3149 right(ios);
3150 {
3151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3152 std::string ex(str, iter.base());
3153 assert(ex == "*******************1;e+09");
3154 assert(ios.width() == 0);
3155 }
3156 ios.width(25);
3157 internal(ios);
3158 {
3159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3160 std::string ex(str, iter.base());
3161 assert(ex == "*******************1;e+09");
3162 assert(ios.width() == 0);
3163 }
3164 }
3165 }
3166 }
3167 showpos(ios);
3168 {
3169 noshowpoint(ios);
3170 {
3171 ios.imbue(lc);
3172 {
3173 ios.width(0);
3174 {
3175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3176 std::string ex(str, iter.base());
3177 assert(ex == "+1e+09");
3178 assert(ios.width() == 0);
3179 }
3180 ios.width(25);
3181 left(ios);
3182 {
3183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3184 std::string ex(str, iter.base());
3185 assert(ex == "+1e+09*******************");
3186 assert(ios.width() == 0);
3187 }
3188 ios.width(25);
3189 right(ios);
3190 {
3191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3192 std::string ex(str, iter.base());
3193 assert(ex == "*******************+1e+09");
3194 assert(ios.width() == 0);
3195 }
3196 ios.width(25);
3197 internal(ios);
3198 {
3199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3200 std::string ex(str, iter.base());
3201 assert(ex == "+*******************1e+09");
3202 assert(ios.width() == 0);
3203 }
3204 }
3205 ios.imbue(lg);
3206 {
3207 ios.width(0);
3208 {
3209 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3210 std::string ex(str, iter.base());
3211 assert(ex == "+1e+09");
3212 assert(ios.width() == 0);
3213 }
3214 ios.width(25);
3215 left(ios);
3216 {
3217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3218 std::string ex(str, iter.base());
3219 assert(ex == "+1e+09*******************");
3220 assert(ios.width() == 0);
3221 }
3222 ios.width(25);
3223 right(ios);
3224 {
3225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3226 std::string ex(str, iter.base());
3227 assert(ex == "*******************+1e+09");
3228 assert(ios.width() == 0);
3229 }
3230 ios.width(25);
3231 internal(ios);
3232 {
3233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3234 std::string ex(str, iter.base());
3235 assert(ex == "+*******************1e+09");
3236 assert(ios.width() == 0);
3237 }
3238 }
3239 }
3240 showpoint(ios);
3241 {
3242 ios.imbue(lc);
3243 {
3244 ios.width(0);
3245 {
3246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3247 std::string ex(str, iter.base());
3248 assert(ex == "+1.e+09");
3249 assert(ios.width() == 0);
3250 }
3251 ios.width(25);
3252 left(ios);
3253 {
3254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3255 std::string ex(str, iter.base());
3256 assert(ex == "+1.e+09******************");
3257 assert(ios.width() == 0);
3258 }
3259 ios.width(25);
3260 right(ios);
3261 {
3262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3263 std::string ex(str, iter.base());
3264 assert(ex == "******************+1.e+09");
3265 assert(ios.width() == 0);
3266 }
3267 ios.width(25);
3268 internal(ios);
3269 {
3270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3271 std::string ex(str, iter.base());
3272 assert(ex == "+******************1.e+09");
3273 assert(ios.width() == 0);
3274 }
3275 }
3276 ios.imbue(lg);
3277 {
3278 ios.width(0);
3279 {
3280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3281 std::string ex(str, iter.base());
3282 assert(ex == "+1;e+09");
3283 assert(ios.width() == 0);
3284 }
3285 ios.width(25);
3286 left(ios);
3287 {
3288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3289 std::string ex(str, iter.base());
3290 assert(ex == "+1;e+09******************");
3291 assert(ios.width() == 0);
3292 }
3293 ios.width(25);
3294 right(ios);
3295 {
3296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3297 std::string ex(str, iter.base());
3298 assert(ex == "******************+1;e+09");
3299 assert(ios.width() == 0);
3300 }
3301 ios.width(25);
3302 internal(ios);
3303 {
3304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3305 std::string ex(str, iter.base());
3306 assert(ex == "+******************1;e+09");
3307 assert(ios.width() == 0);
3308 }
3309 }
3310 }
3311 }
3312 }
3313 uppercase(ios);
3314 {
3315 noshowpos(ios);
3316 {
3317 noshowpoint(ios);
3318 {
3319 ios.imbue(lc);
3320 {
3321 ios.width(0);
3322 {
3323 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3324 std::string ex(str, iter.base());
3325 assert(ex == "1E+09");
3326 assert(ios.width() == 0);
3327 }
3328 ios.width(25);
3329 left(ios);
3330 {
3331 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3332 std::string ex(str, iter.base());
3333 assert(ex == "1E+09********************");
3334 assert(ios.width() == 0);
3335 }
3336 ios.width(25);
3337 right(ios);
3338 {
3339 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3340 std::string ex(str, iter.base());
3341 assert(ex == "********************1E+09");
3342 assert(ios.width() == 0);
3343 }
3344 ios.width(25);
3345 internal(ios);
3346 {
3347 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3348 std::string ex(str, iter.base());
3349 assert(ex == "********************1E+09");
3350 assert(ios.width() == 0);
3351 }
3352 }
3353 ios.imbue(lg);
3354 {
3355 ios.width(0);
3356 {
3357 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3358 std::string ex(str, iter.base());
3359 assert(ex == "1E+09");
3360 assert(ios.width() == 0);
3361 }
3362 ios.width(25);
3363 left(ios);
3364 {
3365 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3366 std::string ex(str, iter.base());
3367 assert(ex == "1E+09********************");
3368 assert(ios.width() == 0);
3369 }
3370 ios.width(25);
3371 right(ios);
3372 {
3373 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3374 std::string ex(str, iter.base());
3375 assert(ex == "********************1E+09");
3376 assert(ios.width() == 0);
3377 }
3378 ios.width(25);
3379 internal(ios);
3380 {
3381 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3382 std::string ex(str, iter.base());
3383 assert(ex == "********************1E+09");
3384 assert(ios.width() == 0);
3385 }
3386 }
3387 }
3388 showpoint(ios);
3389 {
3390 ios.imbue(lc);
3391 {
3392 ios.width(0);
3393 {
3394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3395 std::string ex(str, iter.base());
3396 assert(ex == "1.E+09");
3397 assert(ios.width() == 0);
3398 }
3399 ios.width(25);
3400 left(ios);
3401 {
3402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3403 std::string ex(str, iter.base());
3404 assert(ex == "1.E+09*******************");
3405 assert(ios.width() == 0);
3406 }
3407 ios.width(25);
3408 right(ios);
3409 {
3410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3411 std::string ex(str, iter.base());
3412 assert(ex == "*******************1.E+09");
3413 assert(ios.width() == 0);
3414 }
3415 ios.width(25);
3416 internal(ios);
3417 {
3418 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3419 std::string ex(str, iter.base());
3420 assert(ex == "*******************1.E+09");
3421 assert(ios.width() == 0);
3422 }
3423 }
3424 ios.imbue(lg);
3425 {
3426 ios.width(0);
3427 {
3428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3429 std::string ex(str, iter.base());
3430 assert(ex == "1;E+09");
3431 assert(ios.width() == 0);
3432 }
3433 ios.width(25);
3434 left(ios);
3435 {
3436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3437 std::string ex(str, iter.base());
3438 assert(ex == "1;E+09*******************");
3439 assert(ios.width() == 0);
3440 }
3441 ios.width(25);
3442 right(ios);
3443 {
3444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3445 std::string ex(str, iter.base());
3446 assert(ex == "*******************1;E+09");
3447 assert(ios.width() == 0);
3448 }
3449 ios.width(25);
3450 internal(ios);
3451 {
3452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3453 std::string ex(str, iter.base());
3454 assert(ex == "*******************1;E+09");
3455 assert(ios.width() == 0);
3456 }
3457 }
3458 }
3459 }
3460 showpos(ios);
3461 {
3462 noshowpoint(ios);
3463 {
3464 ios.imbue(lc);
3465 {
3466 ios.width(0);
3467 {
3468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3469 std::string ex(str, iter.base());
3470 assert(ex == "+1E+09");
3471 assert(ios.width() == 0);
3472 }
3473 ios.width(25);
3474 left(ios);
3475 {
3476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3477 std::string ex(str, iter.base());
3478 assert(ex == "+1E+09*******************");
3479 assert(ios.width() == 0);
3480 }
3481 ios.width(25);
3482 right(ios);
3483 {
3484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3485 std::string ex(str, iter.base());
3486 assert(ex == "*******************+1E+09");
3487 assert(ios.width() == 0);
3488 }
3489 ios.width(25);
3490 internal(ios);
3491 {
3492 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3493 std::string ex(str, iter.base());
3494 assert(ex == "+*******************1E+09");
3495 assert(ios.width() == 0);
3496 }
3497 }
3498 ios.imbue(lg);
3499 {
3500 ios.width(0);
3501 {
3502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3503 std::string ex(str, iter.base());
3504 assert(ex == "+1E+09");
3505 assert(ios.width() == 0);
3506 }
3507 ios.width(25);
3508 left(ios);
3509 {
3510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3511 std::string ex(str, iter.base());
3512 assert(ex == "+1E+09*******************");
3513 assert(ios.width() == 0);
3514 }
3515 ios.width(25);
3516 right(ios);
3517 {
3518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3519 std::string ex(str, iter.base());
3520 assert(ex == "*******************+1E+09");
3521 assert(ios.width() == 0);
3522 }
3523 ios.width(25);
3524 internal(ios);
3525 {
3526 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3527 std::string ex(str, iter.base());
3528 assert(ex == "+*******************1E+09");
3529 assert(ios.width() == 0);
3530 }
3531 }
3532 }
3533 showpoint(ios);
3534 {
3535 ios.imbue(lc);
3536 {
3537 ios.width(0);
3538 {
3539 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3540 std::string ex(str, iter.base());
3541 assert(ex == "+1.E+09");
3542 assert(ios.width() == 0);
3543 }
3544 ios.width(25);
3545 left(ios);
3546 {
3547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3548 std::string ex(str, iter.base());
3549 assert(ex == "+1.E+09******************");
3550 assert(ios.width() == 0);
3551 }
3552 ios.width(25);
3553 right(ios);
3554 {
3555 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3556 std::string ex(str, iter.base());
3557 assert(ex == "******************+1.E+09");
3558 assert(ios.width() == 0);
3559 }
3560 ios.width(25);
3561 internal(ios);
3562 {
3563 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3564 std::string ex(str, iter.base());
3565 assert(ex == "+******************1.E+09");
3566 assert(ios.width() == 0);
3567 }
3568 }
3569 ios.imbue(lg);
3570 {
3571 ios.width(0);
3572 {
3573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3574 std::string ex(str, iter.base());
3575 assert(ex == "+1;E+09");
3576 assert(ios.width() == 0);
3577 }
3578 ios.width(25);
3579 left(ios);
3580 {
3581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3582 std::string ex(str, iter.base());
3583 assert(ex == "+1;E+09******************");
3584 assert(ios.width() == 0);
3585 }
3586 ios.width(25);
3587 right(ios);
3588 {
3589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3590 std::string ex(str, iter.base());
3591 assert(ex == "******************+1;E+09");
3592 assert(ios.width() == 0);
3593 }
3594 ios.width(25);
3595 internal(ios);
3596 {
3597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3598 std::string ex(str, iter.base());
3599 assert(ex == "+******************1;E+09");
3600 assert(ios.width() == 0);
3601 }
3602 }
3603 }
3604 }
3605 }
3606 }
3607 ios.precision(1);
3608 {
3609 nouppercase(ios);
3610 {
3611 noshowpos(ios);
3612 {
3613 noshowpoint(ios);
3614 {
3615 ios.imbue(lc);
3616 {
3617 ios.width(0);
3618 {
3619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3620 std::string ex(str, iter.base());
3621 assert(ex == "1e+09");
3622 assert(ios.width() == 0);
3623 }
3624 ios.width(25);
3625 left(ios);
3626 {
3627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3628 std::string ex(str, iter.base());
3629 assert(ex == "1e+09********************");
3630 assert(ios.width() == 0);
3631 }
3632 ios.width(25);
3633 right(ios);
3634 {
3635 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3636 std::string ex(str, iter.base());
3637 assert(ex == "********************1e+09");
3638 assert(ios.width() == 0);
3639 }
3640 ios.width(25);
3641 internal(ios);
3642 {
3643 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3644 std::string ex(str, iter.base());
3645 assert(ex == "********************1e+09");
3646 assert(ios.width() == 0);
3647 }
3648 }
3649 ios.imbue(lg);
3650 {
3651 ios.width(0);
3652 {
3653 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3654 std::string ex(str, iter.base());
3655 assert(ex == "1e+09");
3656 assert(ios.width() == 0);
3657 }
3658 ios.width(25);
3659 left(ios);
3660 {
3661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3662 std::string ex(str, iter.base());
3663 assert(ex == "1e+09********************");
3664 assert(ios.width() == 0);
3665 }
3666 ios.width(25);
3667 right(ios);
3668 {
3669 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3670 std::string ex(str, iter.base());
3671 assert(ex == "********************1e+09");
3672 assert(ios.width() == 0);
3673 }
3674 ios.width(25);
3675 internal(ios);
3676 {
3677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3678 std::string ex(str, iter.base());
3679 assert(ex == "********************1e+09");
3680 assert(ios.width() == 0);
3681 }
3682 }
3683 }
3684 showpoint(ios);
3685 {
3686 ios.imbue(lc);
3687 {
3688 ios.width(0);
3689 {
3690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3691 std::string ex(str, iter.base());
3692 assert(ex == "1.e+09");
3693 assert(ios.width() == 0);
3694 }
3695 ios.width(25);
3696 left(ios);
3697 {
3698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3699 std::string ex(str, iter.base());
3700 assert(ex == "1.e+09*******************");
3701 assert(ios.width() == 0);
3702 }
3703 ios.width(25);
3704 right(ios);
3705 {
3706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3707 std::string ex(str, iter.base());
3708 assert(ex == "*******************1.e+09");
3709 assert(ios.width() == 0);
3710 }
3711 ios.width(25);
3712 internal(ios);
3713 {
3714 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3715 std::string ex(str, iter.base());
3716 assert(ex == "*******************1.e+09");
3717 assert(ios.width() == 0);
3718 }
3719 }
3720 ios.imbue(lg);
3721 {
3722 ios.width(0);
3723 {
3724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3725 std::string ex(str, iter.base());
3726 assert(ex == "1;e+09");
3727 assert(ios.width() == 0);
3728 }
3729 ios.width(25);
3730 left(ios);
3731 {
3732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3733 std::string ex(str, iter.base());
3734 assert(ex == "1;e+09*******************");
3735 assert(ios.width() == 0);
3736 }
3737 ios.width(25);
3738 right(ios);
3739 {
3740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3741 std::string ex(str, iter.base());
3742 assert(ex == "*******************1;e+09");
3743 assert(ios.width() == 0);
3744 }
3745 ios.width(25);
3746 internal(ios);
3747 {
3748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3749 std::string ex(str, iter.base());
3750 assert(ex == "*******************1;e+09");
3751 assert(ios.width() == 0);
3752 }
3753 }
3754 }
3755 }
3756 showpos(ios);
3757 {
3758 noshowpoint(ios);
3759 {
3760 ios.imbue(lc);
3761 {
3762 ios.width(0);
3763 {
3764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3765 std::string ex(str, iter.base());
3766 assert(ex == "+1e+09");
3767 assert(ios.width() == 0);
3768 }
3769 ios.width(25);
3770 left(ios);
3771 {
3772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3773 std::string ex(str, iter.base());
3774 assert(ex == "+1e+09*******************");
3775 assert(ios.width() == 0);
3776 }
3777 ios.width(25);
3778 right(ios);
3779 {
3780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3781 std::string ex(str, iter.base());
3782 assert(ex == "*******************+1e+09");
3783 assert(ios.width() == 0);
3784 }
3785 ios.width(25);
3786 internal(ios);
3787 {
3788 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3789 std::string ex(str, iter.base());
3790 assert(ex == "+*******************1e+09");
3791 assert(ios.width() == 0);
3792 }
3793 }
3794 ios.imbue(lg);
3795 {
3796 ios.width(0);
3797 {
3798 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3799 std::string ex(str, iter.base());
3800 assert(ex == "+1e+09");
3801 assert(ios.width() == 0);
3802 }
3803 ios.width(25);
3804 left(ios);
3805 {
3806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3807 std::string ex(str, iter.base());
3808 assert(ex == "+1e+09*******************");
3809 assert(ios.width() == 0);
3810 }
3811 ios.width(25);
3812 right(ios);
3813 {
3814 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3815 std::string ex(str, iter.base());
3816 assert(ex == "*******************+1e+09");
3817 assert(ios.width() == 0);
3818 }
3819 ios.width(25);
3820 internal(ios);
3821 {
3822 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3823 std::string ex(str, iter.base());
3824 assert(ex == "+*******************1e+09");
3825 assert(ios.width() == 0);
3826 }
3827 }
3828 }
3829 showpoint(ios);
3830 {
3831 ios.imbue(lc);
3832 {
3833 ios.width(0);
3834 {
3835 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3836 std::string ex(str, iter.base());
3837 assert(ex == "+1.e+09");
3838 assert(ios.width() == 0);
3839 }
3840 ios.width(25);
3841 left(ios);
3842 {
3843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3844 std::string ex(str, iter.base());
3845 assert(ex == "+1.e+09******************");
3846 assert(ios.width() == 0);
3847 }
3848 ios.width(25);
3849 right(ios);
3850 {
3851 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3852 std::string ex(str, iter.base());
3853 assert(ex == "******************+1.e+09");
3854 assert(ios.width() == 0);
3855 }
3856 ios.width(25);
3857 internal(ios);
3858 {
3859 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3860 std::string ex(str, iter.base());
3861 assert(ex == "+******************1.e+09");
3862 assert(ios.width() == 0);
3863 }
3864 }
3865 ios.imbue(lg);
3866 {
3867 ios.width(0);
3868 {
3869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3870 std::string ex(str, iter.base());
3871 assert(ex == "+1;e+09");
3872 assert(ios.width() == 0);
3873 }
3874 ios.width(25);
3875 left(ios);
3876 {
3877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3878 std::string ex(str, iter.base());
3879 assert(ex == "+1;e+09******************");
3880 assert(ios.width() == 0);
3881 }
3882 ios.width(25);
3883 right(ios);
3884 {
3885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3886 std::string ex(str, iter.base());
3887 assert(ex == "******************+1;e+09");
3888 assert(ios.width() == 0);
3889 }
3890 ios.width(25);
3891 internal(ios);
3892 {
3893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3894 std::string ex(str, iter.base());
3895 assert(ex == "+******************1;e+09");
3896 assert(ios.width() == 0);
3897 }
3898 }
3899 }
3900 }
3901 }
3902 uppercase(ios);
3903 {
3904 noshowpos(ios);
3905 {
3906 noshowpoint(ios);
3907 {
3908 ios.imbue(lc);
3909 {
3910 ios.width(0);
3911 {
3912 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3913 std::string ex(str, iter.base());
3914 assert(ex == "1E+09");
3915 assert(ios.width() == 0);
3916 }
3917 ios.width(25);
3918 left(ios);
3919 {
3920 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3921 std::string ex(str, iter.base());
3922 assert(ex == "1E+09********************");
3923 assert(ios.width() == 0);
3924 }
3925 ios.width(25);
3926 right(ios);
3927 {
3928 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3929 std::string ex(str, iter.base());
3930 assert(ex == "********************1E+09");
3931 assert(ios.width() == 0);
3932 }
3933 ios.width(25);
3934 internal(ios);
3935 {
3936 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3937 std::string ex(str, iter.base());
3938 assert(ex == "********************1E+09");
3939 assert(ios.width() == 0);
3940 }
3941 }
3942 ios.imbue(lg);
3943 {
3944 ios.width(0);
3945 {
3946 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3947 std::string ex(str, iter.base());
3948 assert(ex == "1E+09");
3949 assert(ios.width() == 0);
3950 }
3951 ios.width(25);
3952 left(ios);
3953 {
3954 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3955 std::string ex(str, iter.base());
3956 assert(ex == "1E+09********************");
3957 assert(ios.width() == 0);
3958 }
3959 ios.width(25);
3960 right(ios);
3961 {
3962 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3963 std::string ex(str, iter.base());
3964 assert(ex == "********************1E+09");
3965 assert(ios.width() == 0);
3966 }
3967 ios.width(25);
3968 internal(ios);
3969 {
3970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3971 std::string ex(str, iter.base());
3972 assert(ex == "********************1E+09");
3973 assert(ios.width() == 0);
3974 }
3975 }
3976 }
3977 showpoint(ios);
3978 {
3979 ios.imbue(lc);
3980 {
3981 ios.width(0);
3982 {
3983 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3984 std::string ex(str, iter.base());
3985 assert(ex == "1.E+09");
3986 assert(ios.width() == 0);
3987 }
3988 ios.width(25);
3989 left(ios);
3990 {
3991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3992 std::string ex(str, iter.base());
3993 assert(ex == "1.E+09*******************");
3994 assert(ios.width() == 0);
3995 }
3996 ios.width(25);
3997 right(ios);
3998 {
3999 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4000 std::string ex(str, iter.base());
4001 assert(ex == "*******************1.E+09");
4002 assert(ios.width() == 0);
4003 }
4004 ios.width(25);
4005 internal(ios);
4006 {
4007 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4008 std::string ex(str, iter.base());
4009 assert(ex == "*******************1.E+09");
4010 assert(ios.width() == 0);
4011 }
4012 }
4013 ios.imbue(lg);
4014 {
4015 ios.width(0);
4016 {
4017 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4018 std::string ex(str, iter.base());
4019 assert(ex == "1;E+09");
4020 assert(ios.width() == 0);
4021 }
4022 ios.width(25);
4023 left(ios);
4024 {
4025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4026 std::string ex(str, iter.base());
4027 assert(ex == "1;E+09*******************");
4028 assert(ios.width() == 0);
4029 }
4030 ios.width(25);
4031 right(ios);
4032 {
4033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4034 std::string ex(str, iter.base());
4035 assert(ex == "*******************1;E+09");
4036 assert(ios.width() == 0);
4037 }
4038 ios.width(25);
4039 internal(ios);
4040 {
4041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4042 std::string ex(str, iter.base());
4043 assert(ex == "*******************1;E+09");
4044 assert(ios.width() == 0);
4045 }
4046 }
4047 }
4048 }
4049 showpos(ios);
4050 {
4051 noshowpoint(ios);
4052 {
4053 ios.imbue(lc);
4054 {
4055 ios.width(0);
4056 {
4057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4058 std::string ex(str, iter.base());
4059 assert(ex == "+1E+09");
4060 assert(ios.width() == 0);
4061 }
4062 ios.width(25);
4063 left(ios);
4064 {
4065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4066 std::string ex(str, iter.base());
4067 assert(ex == "+1E+09*******************");
4068 assert(ios.width() == 0);
4069 }
4070 ios.width(25);
4071 right(ios);
4072 {
4073 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4074 std::string ex(str, iter.base());
4075 assert(ex == "*******************+1E+09");
4076 assert(ios.width() == 0);
4077 }
4078 ios.width(25);
4079 internal(ios);
4080 {
4081 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4082 std::string ex(str, iter.base());
4083 assert(ex == "+*******************1E+09");
4084 assert(ios.width() == 0);
4085 }
4086 }
4087 ios.imbue(lg);
4088 {
4089 ios.width(0);
4090 {
4091 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4092 std::string ex(str, iter.base());
4093 assert(ex == "+1E+09");
4094 assert(ios.width() == 0);
4095 }
4096 ios.width(25);
4097 left(ios);
4098 {
4099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4100 std::string ex(str, iter.base());
4101 assert(ex == "+1E+09*******************");
4102 assert(ios.width() == 0);
4103 }
4104 ios.width(25);
4105 right(ios);
4106 {
4107 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4108 std::string ex(str, iter.base());
4109 assert(ex == "*******************+1E+09");
4110 assert(ios.width() == 0);
4111 }
4112 ios.width(25);
4113 internal(ios);
4114 {
4115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4116 std::string ex(str, iter.base());
4117 assert(ex == "+*******************1E+09");
4118 assert(ios.width() == 0);
4119 }
4120 }
4121 }
4122 showpoint(ios);
4123 {
4124 ios.imbue(lc);
4125 {
4126 ios.width(0);
4127 {
4128 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4129 std::string ex(str, iter.base());
4130 assert(ex == "+1.E+09");
4131 assert(ios.width() == 0);
4132 }
4133 ios.width(25);
4134 left(ios);
4135 {
4136 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4137 std::string ex(str, iter.base());
4138 assert(ex == "+1.E+09******************");
4139 assert(ios.width() == 0);
4140 }
4141 ios.width(25);
4142 right(ios);
4143 {
4144 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4145 std::string ex(str, iter.base());
4146 assert(ex == "******************+1.E+09");
4147 assert(ios.width() == 0);
4148 }
4149 ios.width(25);
4150 internal(ios);
4151 {
4152 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4153 std::string ex(str, iter.base());
4154 assert(ex == "+******************1.E+09");
4155 assert(ios.width() == 0);
4156 }
4157 }
4158 ios.imbue(lg);
4159 {
4160 ios.width(0);
4161 {
4162 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4163 std::string ex(str, iter.base());
4164 assert(ex == "+1;E+09");
4165 assert(ios.width() == 0);
4166 }
4167 ios.width(25);
4168 left(ios);
4169 {
4170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4171 std::string ex(str, iter.base());
4172 assert(ex == "+1;E+09******************");
4173 assert(ios.width() == 0);
4174 }
4175 ios.width(25);
4176 right(ios);
4177 {
4178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4179 std::string ex(str, iter.base());
4180 assert(ex == "******************+1;E+09");
4181 assert(ios.width() == 0);
4182 }
4183 ios.width(25);
4184 internal(ios);
4185 {
4186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4187 std::string ex(str, iter.base());
4188 assert(ex == "+******************1;E+09");
4189 assert(ios.width() == 0);
4190 }
4191 }
4192 }
4193 }
4194 }
4195 }
4196 ios.precision(6);
4197 {
4198 nouppercase(ios);
4199 {
4200 noshowpos(ios);
4201 {
4202 noshowpoint(ios);
4203 {
4204 ios.imbue(lc);
4205 {
4206 ios.width(0);
4207 {
4208 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4209 std::string ex(str, iter.base());
4210 assert(ex == "1.23457e+09");
4211 assert(ios.width() == 0);
4212 }
4213 ios.width(25);
4214 left(ios);
4215 {
4216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4217 std::string ex(str, iter.base());
4218 assert(ex == "1.23457e+09**************");
4219 assert(ios.width() == 0);
4220 }
4221 ios.width(25);
4222 right(ios);
4223 {
4224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4225 std::string ex(str, iter.base());
4226 assert(ex == "**************1.23457e+09");
4227 assert(ios.width() == 0);
4228 }
4229 ios.width(25);
4230 internal(ios);
4231 {
4232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4233 std::string ex(str, iter.base());
4234 assert(ex == "**************1.23457e+09");
4235 assert(ios.width() == 0);
4236 }
4237 }
4238 ios.imbue(lg);
4239 {
4240 ios.width(0);
4241 {
4242 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4243 std::string ex(str, iter.base());
4244 assert(ex == "1;23457e+09");
4245 assert(ios.width() == 0);
4246 }
4247 ios.width(25);
4248 left(ios);
4249 {
4250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4251 std::string ex(str, iter.base());
4252 assert(ex == "1;23457e+09**************");
4253 assert(ios.width() == 0);
4254 }
4255 ios.width(25);
4256 right(ios);
4257 {
4258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4259 std::string ex(str, iter.base());
4260 assert(ex == "**************1;23457e+09");
4261 assert(ios.width() == 0);
4262 }
4263 ios.width(25);
4264 internal(ios);
4265 {
4266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4267 std::string ex(str, iter.base());
4268 assert(ex == "**************1;23457e+09");
4269 assert(ios.width() == 0);
4270 }
4271 }
4272 }
4273 showpoint(ios);
4274 {
4275 ios.imbue(lc);
4276 {
4277 ios.width(0);
4278 {
4279 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4280 std::string ex(str, iter.base());
4281 assert(ex == "1.23457e+09");
4282 assert(ios.width() == 0);
4283 }
4284 ios.width(25);
4285 left(ios);
4286 {
4287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4288 std::string ex(str, iter.base());
4289 assert(ex == "1.23457e+09**************");
4290 assert(ios.width() == 0);
4291 }
4292 ios.width(25);
4293 right(ios);
4294 {
4295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4296 std::string ex(str, iter.base());
4297 assert(ex == "**************1.23457e+09");
4298 assert(ios.width() == 0);
4299 }
4300 ios.width(25);
4301 internal(ios);
4302 {
4303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4304 std::string ex(str, iter.base());
4305 assert(ex == "**************1.23457e+09");
4306 assert(ios.width() == 0);
4307 }
4308 }
4309 ios.imbue(lg);
4310 {
4311 ios.width(0);
4312 {
4313 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4314 std::string ex(str, iter.base());
4315 assert(ex == "1;23457e+09");
4316 assert(ios.width() == 0);
4317 }
4318 ios.width(25);
4319 left(ios);
4320 {
4321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4322 std::string ex(str, iter.base());
4323 assert(ex == "1;23457e+09**************");
4324 assert(ios.width() == 0);
4325 }
4326 ios.width(25);
4327 right(ios);
4328 {
4329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4330 std::string ex(str, iter.base());
4331 assert(ex == "**************1;23457e+09");
4332 assert(ios.width() == 0);
4333 }
4334 ios.width(25);
4335 internal(ios);
4336 {
4337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4338 std::string ex(str, iter.base());
4339 assert(ex == "**************1;23457e+09");
4340 assert(ios.width() == 0);
4341 }
4342 }
4343 }
4344 }
4345 showpos(ios);
4346 {
4347 noshowpoint(ios);
4348 {
4349 ios.imbue(lc);
4350 {
4351 ios.width(0);
4352 {
4353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4354 std::string ex(str, iter.base());
4355 assert(ex == "+1.23457e+09");
4356 assert(ios.width() == 0);
4357 }
4358 ios.width(25);
4359 left(ios);
4360 {
4361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4362 std::string ex(str, iter.base());
4363 assert(ex == "+1.23457e+09*************");
4364 assert(ios.width() == 0);
4365 }
4366 ios.width(25);
4367 right(ios);
4368 {
4369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4370 std::string ex(str, iter.base());
4371 assert(ex == "*************+1.23457e+09");
4372 assert(ios.width() == 0);
4373 }
4374 ios.width(25);
4375 internal(ios);
4376 {
4377 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4378 std::string ex(str, iter.base());
4379 assert(ex == "+*************1.23457e+09");
4380 assert(ios.width() == 0);
4381 }
4382 }
4383 ios.imbue(lg);
4384 {
4385 ios.width(0);
4386 {
4387 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4388 std::string ex(str, iter.base());
4389 assert(ex == "+1;23457e+09");
4390 assert(ios.width() == 0);
4391 }
4392 ios.width(25);
4393 left(ios);
4394 {
4395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4396 std::string ex(str, iter.base());
4397 assert(ex == "+1;23457e+09*************");
4398 assert(ios.width() == 0);
4399 }
4400 ios.width(25);
4401 right(ios);
4402 {
4403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4404 std::string ex(str, iter.base());
4405 assert(ex == "*************+1;23457e+09");
4406 assert(ios.width() == 0);
4407 }
4408 ios.width(25);
4409 internal(ios);
4410 {
4411 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4412 std::string ex(str, iter.base());
4413 assert(ex == "+*************1;23457e+09");
4414 assert(ios.width() == 0);
4415 }
4416 }
4417 }
4418 showpoint(ios);
4419 {
4420 ios.imbue(lc);
4421 {
4422 ios.width(0);
4423 {
4424 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4425 std::string ex(str, iter.base());
4426 assert(ex == "+1.23457e+09");
4427 assert(ios.width() == 0);
4428 }
4429 ios.width(25);
4430 left(ios);
4431 {
4432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4433 std::string ex(str, iter.base());
4434 assert(ex == "+1.23457e+09*************");
4435 assert(ios.width() == 0);
4436 }
4437 ios.width(25);
4438 right(ios);
4439 {
4440 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4441 std::string ex(str, iter.base());
4442 assert(ex == "*************+1.23457e+09");
4443 assert(ios.width() == 0);
4444 }
4445 ios.width(25);
4446 internal(ios);
4447 {
4448 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4449 std::string ex(str, iter.base());
4450 assert(ex == "+*************1.23457e+09");
4451 assert(ios.width() == 0);
4452 }
4453 }
4454 ios.imbue(lg);
4455 {
4456 ios.width(0);
4457 {
4458 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4459 std::string ex(str, iter.base());
4460 assert(ex == "+1;23457e+09");
4461 assert(ios.width() == 0);
4462 }
4463 ios.width(25);
4464 left(ios);
4465 {
4466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4467 std::string ex(str, iter.base());
4468 assert(ex == "+1;23457e+09*************");
4469 assert(ios.width() == 0);
4470 }
4471 ios.width(25);
4472 right(ios);
4473 {
4474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4475 std::string ex(str, iter.base());
4476 assert(ex == "*************+1;23457e+09");
4477 assert(ios.width() == 0);
4478 }
4479 ios.width(25);
4480 internal(ios);
4481 {
4482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4483 std::string ex(str, iter.base());
4484 assert(ex == "+*************1;23457e+09");
4485 assert(ios.width() == 0);
4486 }
4487 }
4488 }
4489 }
4490 }
4491 uppercase(ios);
4492 {
4493 noshowpos(ios);
4494 {
4495 noshowpoint(ios);
4496 {
4497 ios.imbue(lc);
4498 {
4499 ios.width(0);
4500 {
4501 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4502 std::string ex(str, iter.base());
4503 assert(ex == "1.23457E+09");
4504 assert(ios.width() == 0);
4505 }
4506 ios.width(25);
4507 left(ios);
4508 {
4509 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4510 std::string ex(str, iter.base());
4511 assert(ex == "1.23457E+09**************");
4512 assert(ios.width() == 0);
4513 }
4514 ios.width(25);
4515 right(ios);
4516 {
4517 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4518 std::string ex(str, iter.base());
4519 assert(ex == "**************1.23457E+09");
4520 assert(ios.width() == 0);
4521 }
4522 ios.width(25);
4523 internal(ios);
4524 {
4525 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4526 std::string ex(str, iter.base());
4527 assert(ex == "**************1.23457E+09");
4528 assert(ios.width() == 0);
4529 }
4530 }
4531 ios.imbue(lg);
4532 {
4533 ios.width(0);
4534 {
4535 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4536 std::string ex(str, iter.base());
4537 assert(ex == "1;23457E+09");
4538 assert(ios.width() == 0);
4539 }
4540 ios.width(25);
4541 left(ios);
4542 {
4543 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4544 std::string ex(str, iter.base());
4545 assert(ex == "1;23457E+09**************");
4546 assert(ios.width() == 0);
4547 }
4548 ios.width(25);
4549 right(ios);
4550 {
4551 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4552 std::string ex(str, iter.base());
4553 assert(ex == "**************1;23457E+09");
4554 assert(ios.width() == 0);
4555 }
4556 ios.width(25);
4557 internal(ios);
4558 {
4559 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4560 std::string ex(str, iter.base());
4561 assert(ex == "**************1;23457E+09");
4562 assert(ios.width() == 0);
4563 }
4564 }
4565 }
4566 showpoint(ios);
4567 {
4568 ios.imbue(lc);
4569 {
4570 ios.width(0);
4571 {
4572 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4573 std::string ex(str, iter.base());
4574 assert(ex == "1.23457E+09");
4575 assert(ios.width() == 0);
4576 }
4577 ios.width(25);
4578 left(ios);
4579 {
4580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4581 std::string ex(str, iter.base());
4582 assert(ex == "1.23457E+09**************");
4583 assert(ios.width() == 0);
4584 }
4585 ios.width(25);
4586 right(ios);
4587 {
4588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4589 std::string ex(str, iter.base());
4590 assert(ex == "**************1.23457E+09");
4591 assert(ios.width() == 0);
4592 }
4593 ios.width(25);
4594 internal(ios);
4595 {
4596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4597 std::string ex(str, iter.base());
4598 assert(ex == "**************1.23457E+09");
4599 assert(ios.width() == 0);
4600 }
4601 }
4602 ios.imbue(lg);
4603 {
4604 ios.width(0);
4605 {
4606 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4607 std::string ex(str, iter.base());
4608 assert(ex == "1;23457E+09");
4609 assert(ios.width() == 0);
4610 }
4611 ios.width(25);
4612 left(ios);
4613 {
4614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4615 std::string ex(str, iter.base());
4616 assert(ex == "1;23457E+09**************");
4617 assert(ios.width() == 0);
4618 }
4619 ios.width(25);
4620 right(ios);
4621 {
4622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4623 std::string ex(str, iter.base());
4624 assert(ex == "**************1;23457E+09");
4625 assert(ios.width() == 0);
4626 }
4627 ios.width(25);
4628 internal(ios);
4629 {
4630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4631 std::string ex(str, iter.base());
4632 assert(ex == "**************1;23457E+09");
4633 assert(ios.width() == 0);
4634 }
4635 }
4636 }
4637 }
4638 showpos(ios);
4639 {
4640 noshowpoint(ios);
4641 {
4642 ios.imbue(lc);
4643 {
4644 ios.width(0);
4645 {
4646 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4647 std::string ex(str, iter.base());
4648 assert(ex == "+1.23457E+09");
4649 assert(ios.width() == 0);
4650 }
4651 ios.width(25);
4652 left(ios);
4653 {
4654 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4655 std::string ex(str, iter.base());
4656 assert(ex == "+1.23457E+09*************");
4657 assert(ios.width() == 0);
4658 }
4659 ios.width(25);
4660 right(ios);
4661 {
4662 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4663 std::string ex(str, iter.base());
4664 assert(ex == "*************+1.23457E+09");
4665 assert(ios.width() == 0);
4666 }
4667 ios.width(25);
4668 internal(ios);
4669 {
4670 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4671 std::string ex(str, iter.base());
4672 assert(ex == "+*************1.23457E+09");
4673 assert(ios.width() == 0);
4674 }
4675 }
4676 ios.imbue(lg);
4677 {
4678 ios.width(0);
4679 {
4680 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4681 std::string ex(str, iter.base());
4682 assert(ex == "+1;23457E+09");
4683 assert(ios.width() == 0);
4684 }
4685 ios.width(25);
4686 left(ios);
4687 {
4688 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4689 std::string ex(str, iter.base());
4690 assert(ex == "+1;23457E+09*************");
4691 assert(ios.width() == 0);
4692 }
4693 ios.width(25);
4694 right(ios);
4695 {
4696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4697 std::string ex(str, iter.base());
4698 assert(ex == "*************+1;23457E+09");
4699 assert(ios.width() == 0);
4700 }
4701 ios.width(25);
4702 internal(ios);
4703 {
4704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4705 std::string ex(str, iter.base());
4706 assert(ex == "+*************1;23457E+09");
4707 assert(ios.width() == 0);
4708 }
4709 }
4710 }
4711 showpoint(ios);
4712 {
4713 ios.imbue(lc);
4714 {
4715 ios.width(0);
4716 {
4717 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4718 std::string ex(str, iter.base());
4719 assert(ex == "+1.23457E+09");
4720 assert(ios.width() == 0);
4721 }
4722 ios.width(25);
4723 left(ios);
4724 {
4725 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4726 std::string ex(str, iter.base());
4727 assert(ex == "+1.23457E+09*************");
4728 assert(ios.width() == 0);
4729 }
4730 ios.width(25);
4731 right(ios);
4732 {
4733 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4734 std::string ex(str, iter.base());
4735 assert(ex == "*************+1.23457E+09");
4736 assert(ios.width() == 0);
4737 }
4738 ios.width(25);
4739 internal(ios);
4740 {
4741 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4742 std::string ex(str, iter.base());
4743 assert(ex == "+*************1.23457E+09");
4744 assert(ios.width() == 0);
4745 }
4746 }
4747 ios.imbue(lg);
4748 {
4749 ios.width(0);
4750 {
4751 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4752 std::string ex(str, iter.base());
4753 assert(ex == "+1;23457E+09");
4754 assert(ios.width() == 0);
4755 }
4756 ios.width(25);
4757 left(ios);
4758 {
4759 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4760 std::string ex(str, iter.base());
4761 assert(ex == "+1;23457E+09*************");
4762 assert(ios.width() == 0);
4763 }
4764 ios.width(25);
4765 right(ios);
4766 {
4767 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4768 std::string ex(str, iter.base());
4769 assert(ex == "*************+1;23457E+09");
4770 assert(ios.width() == 0);
4771 }
4772 ios.width(25);
4773 internal(ios);
4774 {
4775 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4776 std::string ex(str, iter.base());
4777 assert(ex == "+*************1;23457E+09");
4778 assert(ios.width() == 0);
4779 }
4780 }
4781 }
4782 }
4783 }
4784 }
4785 ios.precision(16);
4786 {
4787 nouppercase(ios);
4788 {
4789 noshowpos(ios);
4790 {
4791 noshowpoint(ios);
4792 {
4793 ios.imbue(lc);
4794 {
4795 ios.width(0);
4796 {
4797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4798 std::string ex(str, iter.base());
4799 assert(ex == "1234567890.125");
4800 assert(ios.width() == 0);
4801 }
4802 ios.width(25);
4803 left(ios);
4804 {
4805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4806 std::string ex(str, iter.base());
4807 assert(ex == "1234567890.125***********");
4808 assert(ios.width() == 0);
4809 }
4810 ios.width(25);
4811 right(ios);
4812 {
4813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4814 std::string ex(str, iter.base());
4815 assert(ex == "***********1234567890.125");
4816 assert(ios.width() == 0);
4817 }
4818 ios.width(25);
4819 internal(ios);
4820 {
4821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4822 std::string ex(str, iter.base());
4823 assert(ex == "***********1234567890.125");
4824 assert(ios.width() == 0);
4825 }
4826 }
4827 ios.imbue(lg);
4828 {
4829 ios.width(0);
4830 {
4831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4832 std::string ex(str, iter.base());
4833 assert(ex == "1_234_567_89_0;125");
4834 assert(ios.width() == 0);
4835 }
4836 ios.width(25);
4837 left(ios);
4838 {
4839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4840 std::string ex(str, iter.base());
4841 assert(ex == "1_234_567_89_0;125*******");
4842 assert(ios.width() == 0);
4843 }
4844 ios.width(25);
4845 right(ios);
4846 {
4847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4848 std::string ex(str, iter.base());
4849 assert(ex == "*******1_234_567_89_0;125");
4850 assert(ios.width() == 0);
4851 }
4852 ios.width(25);
4853 internal(ios);
4854 {
4855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4856 std::string ex(str, iter.base());
4857 assert(ex == "*******1_234_567_89_0;125");
4858 assert(ios.width() == 0);
4859 }
4860 }
4861 }
4862 showpoint(ios);
4863 {
4864 ios.imbue(lc);
4865 {
4866 ios.width(0);
4867 {
4868 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4869 std::string ex(str, iter.base());
4870 assert(ex == "1234567890.125000");
4871 assert(ios.width() == 0);
4872 }
4873 ios.width(25);
4874 left(ios);
4875 {
4876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4877 std::string ex(str, iter.base());
4878 assert(ex == "1234567890.125000********");
4879 assert(ios.width() == 0);
4880 }
4881 ios.width(25);
4882 right(ios);
4883 {
4884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4885 std::string ex(str, iter.base());
4886 assert(ex == "********1234567890.125000");
4887 assert(ios.width() == 0);
4888 }
4889 ios.width(25);
4890 internal(ios);
4891 {
4892 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4893 std::string ex(str, iter.base());
4894 assert(ex == "********1234567890.125000");
4895 assert(ios.width() == 0);
4896 }
4897 }
4898 ios.imbue(lg);
4899 {
4900 ios.width(0);
4901 {
4902 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4903 std::string ex(str, iter.base());
4904 assert(ex == "1_234_567_89_0;125000");
4905 assert(ios.width() == 0);
4906 }
4907 ios.width(25);
4908 left(ios);
4909 {
4910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4911 std::string ex(str, iter.base());
4912 assert(ex == "1_234_567_89_0;125000****");
4913 assert(ios.width() == 0);
4914 }
4915 ios.width(25);
4916 right(ios);
4917 {
4918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4919 std::string ex(str, iter.base());
4920 assert(ex == "****1_234_567_89_0;125000");
4921 assert(ios.width() == 0);
4922 }
4923 ios.width(25);
4924 internal(ios);
4925 {
4926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4927 std::string ex(str, iter.base());
4928 assert(ex == "****1_234_567_89_0;125000");
4929 assert(ios.width() == 0);
4930 }
4931 }
4932 }
4933 }
4934 showpos(ios);
4935 {
4936 noshowpoint(ios);
4937 {
4938 ios.imbue(lc);
4939 {
4940 ios.width(0);
4941 {
4942 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4943 std::string ex(str, iter.base());
4944 assert(ex == "+1234567890.125");
4945 assert(ios.width() == 0);
4946 }
4947 ios.width(25);
4948 left(ios);
4949 {
4950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4951 std::string ex(str, iter.base());
4952 assert(ex == "+1234567890.125**********");
4953 assert(ios.width() == 0);
4954 }
4955 ios.width(25);
4956 right(ios);
4957 {
4958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4959 std::string ex(str, iter.base());
4960 assert(ex == "**********+1234567890.125");
4961 assert(ios.width() == 0);
4962 }
4963 ios.width(25);
4964 internal(ios);
4965 {
4966 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4967 std::string ex(str, iter.base());
4968 assert(ex == "+**********1234567890.125");
4969 assert(ios.width() == 0);
4970 }
4971 }
4972 ios.imbue(lg);
4973 {
4974 ios.width(0);
4975 {
4976 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4977 std::string ex(str, iter.base());
4978 assert(ex == "+1_234_567_89_0;125");
4979 assert(ios.width() == 0);
4980 }
4981 ios.width(25);
4982 left(ios);
4983 {
4984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4985 std::string ex(str, iter.base());
4986 assert(ex == "+1_234_567_89_0;125******");
4987 assert(ios.width() == 0);
4988 }
4989 ios.width(25);
4990 right(ios);
4991 {
4992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4993 std::string ex(str, iter.base());
4994 assert(ex == "******+1_234_567_89_0;125");
4995 assert(ios.width() == 0);
4996 }
4997 ios.width(25);
4998 internal(ios);
4999 {
5000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5001 std::string ex(str, iter.base());
5002 assert(ex == "+******1_234_567_89_0;125");
5003 assert(ios.width() == 0);
5004 }
5005 }
5006 }
5007 showpoint(ios);
5008 {
5009 ios.imbue(lc);
5010 {
5011 ios.width(0);
5012 {
5013 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5014 std::string ex(str, iter.base());
5015 assert(ex == "+1234567890.125000");
5016 assert(ios.width() == 0);
5017 }
5018 ios.width(25);
5019 left(ios);
5020 {
5021 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5022 std::string ex(str, iter.base());
5023 assert(ex == "+1234567890.125000*******");
5024 assert(ios.width() == 0);
5025 }
5026 ios.width(25);
5027 right(ios);
5028 {
5029 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5030 std::string ex(str, iter.base());
5031 assert(ex == "*******+1234567890.125000");
5032 assert(ios.width() == 0);
5033 }
5034 ios.width(25);
5035 internal(ios);
5036 {
5037 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5038 std::string ex(str, iter.base());
5039 assert(ex == "+*******1234567890.125000");
5040 assert(ios.width() == 0);
5041 }
5042 }
5043 ios.imbue(lg);
5044 {
5045 ios.width(0);
5046 {
5047 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5048 std::string ex(str, iter.base());
5049 assert(ex == "+1_234_567_89_0;125000");
5050 assert(ios.width() == 0);
5051 }
5052 ios.width(25);
5053 left(ios);
5054 {
5055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5056 std::string ex(str, iter.base());
5057 assert(ex == "+1_234_567_89_0;125000***");
5058 assert(ios.width() == 0);
5059 }
5060 ios.width(25);
5061 right(ios);
5062 {
5063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5064 std::string ex(str, iter.base());
5065 assert(ex == "***+1_234_567_89_0;125000");
5066 assert(ios.width() == 0);
5067 }
5068 ios.width(25);
5069 internal(ios);
5070 {
5071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5072 std::string ex(str, iter.base());
5073 assert(ex == "+***1_234_567_89_0;125000");
5074 assert(ios.width() == 0);
5075 }
5076 }
5077 }
5078 }
5079 }
5080 uppercase(ios);
5081 {
5082 noshowpos(ios);
5083 {
5084 noshowpoint(ios);
5085 {
5086 ios.imbue(lc);
5087 {
5088 ios.width(0);
5089 {
5090 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5091 std::string ex(str, iter.base());
5092 assert(ex == "1234567890.125");
5093 assert(ios.width() == 0);
5094 }
5095 ios.width(25);
5096 left(ios);
5097 {
5098 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5099 std::string ex(str, iter.base());
5100 assert(ex == "1234567890.125***********");
5101 assert(ios.width() == 0);
5102 }
5103 ios.width(25);
5104 right(ios);
5105 {
5106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5107 std::string ex(str, iter.base());
5108 assert(ex == "***********1234567890.125");
5109 assert(ios.width() == 0);
5110 }
5111 ios.width(25);
5112 internal(ios);
5113 {
5114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5115 std::string ex(str, iter.base());
5116 assert(ex == "***********1234567890.125");
5117 assert(ios.width() == 0);
5118 }
5119 }
5120 ios.imbue(lg);
5121 {
5122 ios.width(0);
5123 {
5124 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5125 std::string ex(str, iter.base());
5126 assert(ex == "1_234_567_89_0;125");
5127 assert(ios.width() == 0);
5128 }
5129 ios.width(25);
5130 left(ios);
5131 {
5132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5133 std::string ex(str, iter.base());
5134 assert(ex == "1_234_567_89_0;125*******");
5135 assert(ios.width() == 0);
5136 }
5137 ios.width(25);
5138 right(ios);
5139 {
5140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5141 std::string ex(str, iter.base());
5142 assert(ex == "*******1_234_567_89_0;125");
5143 assert(ios.width() == 0);
5144 }
5145 ios.width(25);
5146 internal(ios);
5147 {
5148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5149 std::string ex(str, iter.base());
5150 assert(ex == "*******1_234_567_89_0;125");
5151 assert(ios.width() == 0);
5152 }
5153 }
5154 }
5155 showpoint(ios);
5156 {
5157 ios.imbue(lc);
5158 {
5159 ios.width(0);
5160 {
5161 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5162 std::string ex(str, iter.base());
5163 assert(ex == "1234567890.125000");
5164 assert(ios.width() == 0);
5165 }
5166 ios.width(25);
5167 left(ios);
5168 {
5169 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5170 std::string ex(str, iter.base());
5171 assert(ex == "1234567890.125000********");
5172 assert(ios.width() == 0);
5173 }
5174 ios.width(25);
5175 right(ios);
5176 {
5177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5178 std::string ex(str, iter.base());
5179 assert(ex == "********1234567890.125000");
5180 assert(ios.width() == 0);
5181 }
5182 ios.width(25);
5183 internal(ios);
5184 {
5185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5186 std::string ex(str, iter.base());
5187 assert(ex == "********1234567890.125000");
5188 assert(ios.width() == 0);
5189 }
5190 }
5191 ios.imbue(lg);
5192 {
5193 ios.width(0);
5194 {
5195 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5196 std::string ex(str, iter.base());
5197 assert(ex == "1_234_567_89_0;125000");
5198 assert(ios.width() == 0);
5199 }
5200 ios.width(25);
5201 left(ios);
5202 {
5203 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5204 std::string ex(str, iter.base());
5205 assert(ex == "1_234_567_89_0;125000****");
5206 assert(ios.width() == 0);
5207 }
5208 ios.width(25);
5209 right(ios);
5210 {
5211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5212 std::string ex(str, iter.base());
5213 assert(ex == "****1_234_567_89_0;125000");
5214 assert(ios.width() == 0);
5215 }
5216 ios.width(25);
5217 internal(ios);
5218 {
5219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5220 std::string ex(str, iter.base());
5221 assert(ex == "****1_234_567_89_0;125000");
5222 assert(ios.width() == 0);
5223 }
5224 }
5225 }
5226 }
5227 showpos(ios);
5228 {
5229 noshowpoint(ios);
5230 {
5231 ios.imbue(lc);
5232 {
5233 ios.width(0);
5234 {
5235 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5236 std::string ex(str, iter.base());
5237 assert(ex == "+1234567890.125");
5238 assert(ios.width() == 0);
5239 }
5240 ios.width(25);
5241 left(ios);
5242 {
5243 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5244 std::string ex(str, iter.base());
5245 assert(ex == "+1234567890.125**********");
5246 assert(ios.width() == 0);
5247 }
5248 ios.width(25);
5249 right(ios);
5250 {
5251 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5252 std::string ex(str, iter.base());
5253 assert(ex == "**********+1234567890.125");
5254 assert(ios.width() == 0);
5255 }
5256 ios.width(25);
5257 internal(ios);
5258 {
5259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5260 std::string ex(str, iter.base());
5261 assert(ex == "+**********1234567890.125");
5262 assert(ios.width() == 0);
5263 }
5264 }
5265 ios.imbue(lg);
5266 {
5267 ios.width(0);
5268 {
5269 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5270 std::string ex(str, iter.base());
5271 assert(ex == "+1_234_567_89_0;125");
5272 assert(ios.width() == 0);
5273 }
5274 ios.width(25);
5275 left(ios);
5276 {
5277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5278 std::string ex(str, iter.base());
5279 assert(ex == "+1_234_567_89_0;125******");
5280 assert(ios.width() == 0);
5281 }
5282 ios.width(25);
5283 right(ios);
5284 {
5285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5286 std::string ex(str, iter.base());
5287 assert(ex == "******+1_234_567_89_0;125");
5288 assert(ios.width() == 0);
5289 }
5290 ios.width(25);
5291 internal(ios);
5292 {
5293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5294 std::string ex(str, iter.base());
5295 assert(ex == "+******1_234_567_89_0;125");
5296 assert(ios.width() == 0);
5297 }
5298 }
5299 }
5300 showpoint(ios);
5301 {
5302 ios.imbue(lc);
5303 {
5304 ios.width(0);
5305 {
5306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5307 std::string ex(str, iter.base());
5308 assert(ex == "+1234567890.125000");
5309 assert(ios.width() == 0);
5310 }
5311 ios.width(25);
5312 left(ios);
5313 {
5314 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5315 std::string ex(str, iter.base());
5316 assert(ex == "+1234567890.125000*******");
5317 assert(ios.width() == 0);
5318 }
5319 ios.width(25);
5320 right(ios);
5321 {
5322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5323 std::string ex(str, iter.base());
5324 assert(ex == "*******+1234567890.125000");
5325 assert(ios.width() == 0);
5326 }
5327 ios.width(25);
5328 internal(ios);
5329 {
5330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5331 std::string ex(str, iter.base());
5332 assert(ex == "+*******1234567890.125000");
5333 assert(ios.width() == 0);
5334 }
5335 }
5336 ios.imbue(lg);
5337 {
5338 ios.width(0);
5339 {
5340 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5341 std::string ex(str, iter.base());
5342 assert(ex == "+1_234_567_89_0;125000");
5343 assert(ios.width() == 0);
5344 }
5345 ios.width(25);
5346 left(ios);
5347 {
5348 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5349 std::string ex(str, iter.base());
5350 assert(ex == "+1_234_567_89_0;125000***");
5351 assert(ios.width() == 0);
5352 }
5353 ios.width(25);
5354 right(ios);
5355 {
5356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5357 std::string ex(str, iter.base());
5358 assert(ex == "***+1_234_567_89_0;125000");
5359 assert(ios.width() == 0);
5360 }
5361 ios.width(25);
5362 internal(ios);
5363 {
5364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5365 std::string ex(str, iter.base());
5366 assert(ex == "+***1_234_567_89_0;125000");
5367 assert(ios.width() == 0);
5368 }
5369 }
5370 }
5371 }
5372 }
5373 }
5374 ios.precision(60);
5375 {
5376 nouppercase(ios);
5377 {
5378 noshowpos(ios);
5379 {
5380 noshowpoint(ios);
5381 {
5382 ios.imbue(lc);
5383 {
5384 ios.width(0);
5385 {
5386 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5387 std::string ex(str, iter.base());
5388 assert(ex == "1234567890.125");
5389 assert(ios.width() == 0);
5390 }
5391 ios.width(25);
5392 left(ios);
5393 {
5394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5395 std::string ex(str, iter.base());
5396 assert(ex == "1234567890.125***********");
5397 assert(ios.width() == 0);
5398 }
5399 ios.width(25);
5400 right(ios);
5401 {
5402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5403 std::string ex(str, iter.base());
5404 assert(ex == "***********1234567890.125");
5405 assert(ios.width() == 0);
5406 }
5407 ios.width(25);
5408 internal(ios);
5409 {
5410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5411 std::string ex(str, iter.base());
5412 assert(ex == "***********1234567890.125");
5413 assert(ios.width() == 0);
5414 }
5415 }
5416 ios.imbue(lg);
5417 {
5418 ios.width(0);
5419 {
5420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5421 std::string ex(str, iter.base());
5422 assert(ex == "1_234_567_89_0;125");
5423 assert(ios.width() == 0);
5424 }
5425 ios.width(25);
5426 left(ios);
5427 {
5428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5429 std::string ex(str, iter.base());
5430 assert(ex == "1_234_567_89_0;125*******");
5431 assert(ios.width() == 0);
5432 }
5433 ios.width(25);
5434 right(ios);
5435 {
5436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5437 std::string ex(str, iter.base());
5438 assert(ex == "*******1_234_567_89_0;125");
5439 assert(ios.width() == 0);
5440 }
5441 ios.width(25);
5442 internal(ios);
5443 {
5444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5445 std::string ex(str, iter.base());
5446 assert(ex == "*******1_234_567_89_0;125");
5447 assert(ios.width() == 0);
5448 }
5449 }
5450 }
5451 showpoint(ios);
5452 {
5453 ios.imbue(lc);
5454 {
5455 ios.width(0);
5456 {
5457 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5458 std::string ex(str, iter.base());
5459 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5460 assert(ios.width() == 0);
5461 }
5462 ios.width(25);
5463 left(ios);
5464 {
5465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5466 std::string ex(str, iter.base());
5467 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5468 assert(ios.width() == 0);
5469 }
5470 ios.width(25);
5471 right(ios);
5472 {
5473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5474 std::string ex(str, iter.base());
5475 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5476 assert(ios.width() == 0);
5477 }
5478 ios.width(25);
5479 internal(ios);
5480 {
5481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5482 std::string ex(str, iter.base());
5483 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5484 assert(ios.width() == 0);
5485 }
5486 }
5487 ios.imbue(lg);
5488 {
5489 ios.width(0);
5490 {
5491 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5492 std::string ex(str, iter.base());
5493 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5494 assert(ios.width() == 0);
5495 }
5496 ios.width(25);
5497 left(ios);
5498 {
5499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5500 std::string ex(str, iter.base());
5501 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5502 assert(ios.width() == 0);
5503 }
5504 ios.width(25);
5505 right(ios);
5506 {
5507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5508 std::string ex(str, iter.base());
5509 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5510 assert(ios.width() == 0);
5511 }
5512 ios.width(25);
5513 internal(ios);
5514 {
5515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5516 std::string ex(str, iter.base());
5517 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5518 assert(ios.width() == 0);
5519 }
5520 }
5521 }
5522 }
5523 showpos(ios);
5524 {
5525 noshowpoint(ios);
5526 {
5527 ios.imbue(lc);
5528 {
5529 ios.width(0);
5530 {
5531 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5532 std::string ex(str, iter.base());
5533 assert(ex == "+1234567890.125");
5534 assert(ios.width() == 0);
5535 }
5536 ios.width(25);
5537 left(ios);
5538 {
5539 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5540 std::string ex(str, iter.base());
5541 assert(ex == "+1234567890.125**********");
5542 assert(ios.width() == 0);
5543 }
5544 ios.width(25);
5545 right(ios);
5546 {
5547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5548 std::string ex(str, iter.base());
5549 assert(ex == "**********+1234567890.125");
5550 assert(ios.width() == 0);
5551 }
5552 ios.width(25);
5553 internal(ios);
5554 {
5555 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5556 std::string ex(str, iter.base());
5557 assert(ex == "+**********1234567890.125");
5558 assert(ios.width() == 0);
5559 }
5560 }
5561 ios.imbue(lg);
5562 {
5563 ios.width(0);
5564 {
5565 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5566 std::string ex(str, iter.base());
5567 assert(ex == "+1_234_567_89_0;125");
5568 assert(ios.width() == 0);
5569 }
5570 ios.width(25);
5571 left(ios);
5572 {
5573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5574 std::string ex(str, iter.base());
5575 assert(ex == "+1_234_567_89_0;125******");
5576 assert(ios.width() == 0);
5577 }
5578 ios.width(25);
5579 right(ios);
5580 {
5581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5582 std::string ex(str, iter.base());
5583 assert(ex == "******+1_234_567_89_0;125");
5584 assert(ios.width() == 0);
5585 }
5586 ios.width(25);
5587 internal(ios);
5588 {
5589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5590 std::string ex(str, iter.base());
5591 assert(ex == "+******1_234_567_89_0;125");
5592 assert(ios.width() == 0);
5593 }
5594 }
5595 }
5596 showpoint(ios);
5597 {
5598 ios.imbue(lc);
5599 {
5600 ios.width(0);
5601 {
5602 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5603 std::string ex(str, iter.base());
5604 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5605 assert(ios.width() == 0);
5606 }
5607 ios.width(25);
5608 left(ios);
5609 {
5610 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5611 std::string ex(str, iter.base());
5612 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5613 assert(ios.width() == 0);
5614 }
5615 ios.width(25);
5616 right(ios);
5617 {
5618 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5619 std::string ex(str, iter.base());
5620 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5621 assert(ios.width() == 0);
5622 }
5623 ios.width(25);
5624 internal(ios);
5625 {
5626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5627 std::string ex(str, iter.base());
5628 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5629 assert(ios.width() == 0);
5630 }
5631 }
5632 ios.imbue(lg);
5633 {
5634 ios.width(0);
5635 {
5636 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5637 std::string ex(str, iter.base());
5638 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5639 assert(ios.width() == 0);
5640 }
5641 ios.width(25);
5642 left(ios);
5643 {
5644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5645 std::string ex(str, iter.base());
5646 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5647 assert(ios.width() == 0);
5648 }
5649 ios.width(25);
5650 right(ios);
5651 {
5652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5653 std::string ex(str, iter.base());
5654 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5655 assert(ios.width() == 0);
5656 }
5657 ios.width(25);
5658 internal(ios);
5659 {
5660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5661 std::string ex(str, iter.base());
5662 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5663 assert(ios.width() == 0);
5664 }
5665 }
5666 }
5667 }
5668 }
5669 uppercase(ios);
5670 {
5671 noshowpos(ios);
5672 {
5673 noshowpoint(ios);
5674 {
5675 ios.imbue(lc);
5676 {
5677 ios.width(0);
5678 {
5679 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5680 std::string ex(str, iter.base());
5681 assert(ex == "1234567890.125");
5682 assert(ios.width() == 0);
5683 }
5684 ios.width(25);
5685 left(ios);
5686 {
5687 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5688 std::string ex(str, iter.base());
5689 assert(ex == "1234567890.125***********");
5690 assert(ios.width() == 0);
5691 }
5692 ios.width(25);
5693 right(ios);
5694 {
5695 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5696 std::string ex(str, iter.base());
5697 assert(ex == "***********1234567890.125");
5698 assert(ios.width() == 0);
5699 }
5700 ios.width(25);
5701 internal(ios);
5702 {
5703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5704 std::string ex(str, iter.base());
5705 assert(ex == "***********1234567890.125");
5706 assert(ios.width() == 0);
5707 }
5708 }
5709 ios.imbue(lg);
5710 {
5711 ios.width(0);
5712 {
5713 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5714 std::string ex(str, iter.base());
5715 assert(ex == "1_234_567_89_0;125");
5716 assert(ios.width() == 0);
5717 }
5718 ios.width(25);
5719 left(ios);
5720 {
5721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5722 std::string ex(str, iter.base());
5723 assert(ex == "1_234_567_89_0;125*******");
5724 assert(ios.width() == 0);
5725 }
5726 ios.width(25);
5727 right(ios);
5728 {
5729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5730 std::string ex(str, iter.base());
5731 assert(ex == "*******1_234_567_89_0;125");
5732 assert(ios.width() == 0);
5733 }
5734 ios.width(25);
5735 internal(ios);
5736 {
5737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5738 std::string ex(str, iter.base());
5739 assert(ex == "*******1_234_567_89_0;125");
5740 assert(ios.width() == 0);
5741 }
5742 }
5743 }
5744 showpoint(ios);
5745 {
5746 ios.imbue(lc);
5747 {
5748 ios.width(0);
5749 {
5750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5751 std::string ex(str, iter.base());
5752 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5753 assert(ios.width() == 0);
5754 }
5755 ios.width(25);
5756 left(ios);
5757 {
5758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5759 std::string ex(str, iter.base());
5760 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5761 assert(ios.width() == 0);
5762 }
5763 ios.width(25);
5764 right(ios);
5765 {
5766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5767 std::string ex(str, iter.base());
5768 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5769 assert(ios.width() == 0);
5770 }
5771 ios.width(25);
5772 internal(ios);
5773 {
5774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5775 std::string ex(str, iter.base());
5776 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
5777 assert(ios.width() == 0);
5778 }
5779 }
5780 ios.imbue(lg);
5781 {
5782 ios.width(0);
5783 {
5784 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5785 std::string ex(str, iter.base());
5786 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5787 assert(ios.width() == 0);
5788 }
5789 ios.width(25);
5790 left(ios);
5791 {
5792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5793 std::string ex(str, iter.base());
5794 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5795 assert(ios.width() == 0);
5796 }
5797 ios.width(25);
5798 right(ios);
5799 {
5800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5801 std::string ex(str, iter.base());
5802 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5803 assert(ios.width() == 0);
5804 }
5805 ios.width(25);
5806 internal(ios);
5807 {
5808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5809 std::string ex(str, iter.base());
5810 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5811 assert(ios.width() == 0);
5812 }
5813 }
5814 }
5815 }
5816 showpos(ios);
5817 {
5818 noshowpoint(ios);
5819 {
5820 ios.imbue(lc);
5821 {
5822 ios.width(0);
5823 {
5824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5825 std::string ex(str, iter.base());
5826 assert(ex == "+1234567890.125");
5827 assert(ios.width() == 0);
5828 }
5829 ios.width(25);
5830 left(ios);
5831 {
5832 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5833 std::string ex(str, iter.base());
5834 assert(ex == "+1234567890.125**********");
5835 assert(ios.width() == 0);
5836 }
5837 ios.width(25);
5838 right(ios);
5839 {
5840 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5841 std::string ex(str, iter.base());
5842 assert(ex == "**********+1234567890.125");
5843 assert(ios.width() == 0);
5844 }
5845 ios.width(25);
5846 internal(ios);
5847 {
5848 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5849 std::string ex(str, iter.base());
5850 assert(ex == "+**********1234567890.125");
5851 assert(ios.width() == 0);
5852 }
5853 }
5854 ios.imbue(lg);
5855 {
5856 ios.width(0);
5857 {
5858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5859 std::string ex(str, iter.base());
5860 assert(ex == "+1_234_567_89_0;125");
5861 assert(ios.width() == 0);
5862 }
5863 ios.width(25);
5864 left(ios);
5865 {
5866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5867 std::string ex(str, iter.base());
5868 assert(ex == "+1_234_567_89_0;125******");
5869 assert(ios.width() == 0);
5870 }
5871 ios.width(25);
5872 right(ios);
5873 {
5874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5875 std::string ex(str, iter.base());
5876 assert(ex == "******+1_234_567_89_0;125");
5877 assert(ios.width() == 0);
5878 }
5879 ios.width(25);
5880 internal(ios);
5881 {
5882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5883 std::string ex(str, iter.base());
5884 assert(ex == "+******1_234_567_89_0;125");
5885 assert(ios.width() == 0);
5886 }
5887 }
5888 }
5889 showpoint(ios);
5890 {
5891 ios.imbue(lc);
5892 {
5893 ios.width(0);
5894 {
5895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5896 std::string ex(str, iter.base());
5897 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5898 assert(ios.width() == 0);
5899 }
5900 ios.width(25);
5901 left(ios);
5902 {
5903 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5904 std::string ex(str, iter.base());
5905 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5906 assert(ios.width() == 0);
5907 }
5908 ios.width(25);
5909 right(ios);
5910 {
5911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5912 std::string ex(str, iter.base());
5913 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5914 assert(ios.width() == 0);
5915 }
5916 ios.width(25);
5917 internal(ios);
5918 {
5919 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5920 std::string ex(str, iter.base());
5921 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
5922 assert(ios.width() == 0);
5923 }
5924 }
5925 ios.imbue(lg);
5926 {
5927 ios.width(0);
5928 {
5929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5930 std::string ex(str, iter.base());
5931 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5932 assert(ios.width() == 0);
5933 }
5934 ios.width(25);
5935 left(ios);
5936 {
5937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5938 std::string ex(str, iter.base());
5939 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5940 assert(ios.width() == 0);
5941 }
5942 ios.width(25);
5943 right(ios);
5944 {
5945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5946 std::string ex(str, iter.base());
5947 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5948 assert(ios.width() == 0);
5949 }
5950 ios.width(25);
5951 internal(ios);
5952 {
5953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5954 std::string ex(str, iter.base());
5955 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
5956 assert(ios.width() == 0);
5957 }
5958 }
5959 }
5960 }
5961 }
5962 }
5963 }
5964 }
5965 }
5966
test3()5967 void test3()
5968 {
5969 char str[200];
5970 output_iterator<char*> iter;
5971 std::locale lc = std::locale::classic();
5972 std::locale lg(lc, new my_numpunct);
5973 const my_facet f(1);
5974 {
5975 double v = +0.;
5976 std::ios ios(0);
5977 fixed(ios);
5978 // %f
5979 {
5980 ios.precision(0);
5981 {
5982 nouppercase(ios);
5983 {
5984 noshowpos(ios);
5985 {
5986 noshowpoint(ios);
5987 {
5988 ios.imbue(lc);
5989 {
5990 ios.width(0);
5991 {
5992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5993 std::string ex(str, iter.base());
5994 assert(ex == "0");
5995 assert(ios.width() == 0);
5996 }
5997 ios.width(25);
5998 left(ios);
5999 {
6000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6001 std::string ex(str, iter.base());
6002 assert(ex == "0************************");
6003 assert(ios.width() == 0);
6004 }
6005 ios.width(25);
6006 right(ios);
6007 {
6008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6009 std::string ex(str, iter.base());
6010 assert(ex == "************************0");
6011 assert(ios.width() == 0);
6012 }
6013 ios.width(25);
6014 internal(ios);
6015 {
6016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6017 std::string ex(str, iter.base());
6018 assert(ex == "************************0");
6019 assert(ios.width() == 0);
6020 }
6021 }
6022 ios.imbue(lg);
6023 {
6024 ios.width(0);
6025 {
6026 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6027 std::string ex(str, iter.base());
6028 assert(ex == "0");
6029 assert(ios.width() == 0);
6030 }
6031 ios.width(25);
6032 left(ios);
6033 {
6034 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6035 std::string ex(str, iter.base());
6036 assert(ex == "0************************");
6037 assert(ios.width() == 0);
6038 }
6039 ios.width(25);
6040 right(ios);
6041 {
6042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6043 std::string ex(str, iter.base());
6044 assert(ex == "************************0");
6045 assert(ios.width() == 0);
6046 }
6047 ios.width(25);
6048 internal(ios);
6049 {
6050 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6051 std::string ex(str, iter.base());
6052 assert(ex == "************************0");
6053 assert(ios.width() == 0);
6054 }
6055 }
6056 }
6057 showpoint(ios);
6058 {
6059 ios.imbue(lc);
6060 {
6061 ios.width(0);
6062 {
6063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6064 std::string ex(str, iter.base());
6065 assert(ex == "0.");
6066 assert(ios.width() == 0);
6067 }
6068 ios.width(25);
6069 left(ios);
6070 {
6071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6072 std::string ex(str, iter.base());
6073 assert(ex == "0.***********************");
6074 assert(ios.width() == 0);
6075 }
6076 ios.width(25);
6077 right(ios);
6078 {
6079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6080 std::string ex(str, iter.base());
6081 assert(ex == "***********************0.");
6082 assert(ios.width() == 0);
6083 }
6084 ios.width(25);
6085 internal(ios);
6086 {
6087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6088 std::string ex(str, iter.base());
6089 assert(ex == "***********************0.");
6090 assert(ios.width() == 0);
6091 }
6092 }
6093 ios.imbue(lg);
6094 {
6095 ios.width(0);
6096 {
6097 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6098 std::string ex(str, iter.base());
6099 assert(ex == "0;");
6100 assert(ios.width() == 0);
6101 }
6102 ios.width(25);
6103 left(ios);
6104 {
6105 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6106 std::string ex(str, iter.base());
6107 assert(ex == "0;***********************");
6108 assert(ios.width() == 0);
6109 }
6110 ios.width(25);
6111 right(ios);
6112 {
6113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6114 std::string ex(str, iter.base());
6115 assert(ex == "***********************0;");
6116 assert(ios.width() == 0);
6117 }
6118 ios.width(25);
6119 internal(ios);
6120 {
6121 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6122 std::string ex(str, iter.base());
6123 assert(ex == "***********************0;");
6124 assert(ios.width() == 0);
6125 }
6126 }
6127 }
6128 }
6129 showpos(ios);
6130 {
6131 noshowpoint(ios);
6132 {
6133 ios.imbue(lc);
6134 {
6135 ios.width(0);
6136 {
6137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6138 std::string ex(str, iter.base());
6139 assert(ex == "+0");
6140 assert(ios.width() == 0);
6141 }
6142 ios.width(25);
6143 left(ios);
6144 {
6145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6146 std::string ex(str, iter.base());
6147 assert(ex == "+0***********************");
6148 assert(ios.width() == 0);
6149 }
6150 ios.width(25);
6151 right(ios);
6152 {
6153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6154 std::string ex(str, iter.base());
6155 assert(ex == "***********************+0");
6156 assert(ios.width() == 0);
6157 }
6158 ios.width(25);
6159 internal(ios);
6160 {
6161 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6162 std::string ex(str, iter.base());
6163 assert(ex == "+***********************0");
6164 assert(ios.width() == 0);
6165 }
6166 }
6167 ios.imbue(lg);
6168 {
6169 ios.width(0);
6170 {
6171 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6172 std::string ex(str, iter.base());
6173 assert(ex == "+0");
6174 assert(ios.width() == 0);
6175 }
6176 ios.width(25);
6177 left(ios);
6178 {
6179 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6180 std::string ex(str, iter.base());
6181 assert(ex == "+0***********************");
6182 assert(ios.width() == 0);
6183 }
6184 ios.width(25);
6185 right(ios);
6186 {
6187 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6188 std::string ex(str, iter.base());
6189 assert(ex == "***********************+0");
6190 assert(ios.width() == 0);
6191 }
6192 ios.width(25);
6193 internal(ios);
6194 {
6195 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6196 std::string ex(str, iter.base());
6197 assert(ex == "+***********************0");
6198 assert(ios.width() == 0);
6199 }
6200 }
6201 }
6202 showpoint(ios);
6203 {
6204 ios.imbue(lc);
6205 {
6206 ios.width(0);
6207 {
6208 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6209 std::string ex(str, iter.base());
6210 assert(ex == "+0.");
6211 assert(ios.width() == 0);
6212 }
6213 ios.width(25);
6214 left(ios);
6215 {
6216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6217 std::string ex(str, iter.base());
6218 assert(ex == "+0.**********************");
6219 assert(ios.width() == 0);
6220 }
6221 ios.width(25);
6222 right(ios);
6223 {
6224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6225 std::string ex(str, iter.base());
6226 assert(ex == "**********************+0.");
6227 assert(ios.width() == 0);
6228 }
6229 ios.width(25);
6230 internal(ios);
6231 {
6232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6233 std::string ex(str, iter.base());
6234 assert(ex == "+**********************0.");
6235 assert(ios.width() == 0);
6236 }
6237 }
6238 ios.imbue(lg);
6239 {
6240 ios.width(0);
6241 {
6242 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6243 std::string ex(str, iter.base());
6244 assert(ex == "+0;");
6245 assert(ios.width() == 0);
6246 }
6247 ios.width(25);
6248 left(ios);
6249 {
6250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6251 std::string ex(str, iter.base());
6252 assert(ex == "+0;**********************");
6253 assert(ios.width() == 0);
6254 }
6255 ios.width(25);
6256 right(ios);
6257 {
6258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6259 std::string ex(str, iter.base());
6260 assert(ex == "**********************+0;");
6261 assert(ios.width() == 0);
6262 }
6263 ios.width(25);
6264 internal(ios);
6265 {
6266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6267 std::string ex(str, iter.base());
6268 assert(ex == "+**********************0;");
6269 assert(ios.width() == 0);
6270 }
6271 }
6272 }
6273 }
6274 }
6275 uppercase(ios);
6276 {
6277 noshowpos(ios);
6278 {
6279 noshowpoint(ios);
6280 {
6281 ios.imbue(lc);
6282 {
6283 ios.width(0);
6284 {
6285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6286 std::string ex(str, iter.base());
6287 assert(ex == "0");
6288 assert(ios.width() == 0);
6289 }
6290 ios.width(25);
6291 left(ios);
6292 {
6293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6294 std::string ex(str, iter.base());
6295 assert(ex == "0************************");
6296 assert(ios.width() == 0);
6297 }
6298 ios.width(25);
6299 right(ios);
6300 {
6301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6302 std::string ex(str, iter.base());
6303 assert(ex == "************************0");
6304 assert(ios.width() == 0);
6305 }
6306 ios.width(25);
6307 internal(ios);
6308 {
6309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6310 std::string ex(str, iter.base());
6311 assert(ex == "************************0");
6312 assert(ios.width() == 0);
6313 }
6314 }
6315 ios.imbue(lg);
6316 {
6317 ios.width(0);
6318 {
6319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6320 std::string ex(str, iter.base());
6321 assert(ex == "0");
6322 assert(ios.width() == 0);
6323 }
6324 ios.width(25);
6325 left(ios);
6326 {
6327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6328 std::string ex(str, iter.base());
6329 assert(ex == "0************************");
6330 assert(ios.width() == 0);
6331 }
6332 ios.width(25);
6333 right(ios);
6334 {
6335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6336 std::string ex(str, iter.base());
6337 assert(ex == "************************0");
6338 assert(ios.width() == 0);
6339 }
6340 ios.width(25);
6341 internal(ios);
6342 {
6343 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6344 std::string ex(str, iter.base());
6345 assert(ex == "************************0");
6346 assert(ios.width() == 0);
6347 }
6348 }
6349 }
6350 showpoint(ios);
6351 {
6352 ios.imbue(lc);
6353 {
6354 ios.width(0);
6355 {
6356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6357 std::string ex(str, iter.base());
6358 assert(ex == "0.");
6359 assert(ios.width() == 0);
6360 }
6361 ios.width(25);
6362 left(ios);
6363 {
6364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6365 std::string ex(str, iter.base());
6366 assert(ex == "0.***********************");
6367 assert(ios.width() == 0);
6368 }
6369 ios.width(25);
6370 right(ios);
6371 {
6372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6373 std::string ex(str, iter.base());
6374 assert(ex == "***********************0.");
6375 assert(ios.width() == 0);
6376 }
6377 ios.width(25);
6378 internal(ios);
6379 {
6380 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6381 std::string ex(str, iter.base());
6382 assert(ex == "***********************0.");
6383 assert(ios.width() == 0);
6384 }
6385 }
6386 ios.imbue(lg);
6387 {
6388 ios.width(0);
6389 {
6390 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6391 std::string ex(str, iter.base());
6392 assert(ex == "0;");
6393 assert(ios.width() == 0);
6394 }
6395 ios.width(25);
6396 left(ios);
6397 {
6398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6399 std::string ex(str, iter.base());
6400 assert(ex == "0;***********************");
6401 assert(ios.width() == 0);
6402 }
6403 ios.width(25);
6404 right(ios);
6405 {
6406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6407 std::string ex(str, iter.base());
6408 assert(ex == "***********************0;");
6409 assert(ios.width() == 0);
6410 }
6411 ios.width(25);
6412 internal(ios);
6413 {
6414 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6415 std::string ex(str, iter.base());
6416 assert(ex == "***********************0;");
6417 assert(ios.width() == 0);
6418 }
6419 }
6420 }
6421 }
6422 showpos(ios);
6423 {
6424 noshowpoint(ios);
6425 {
6426 ios.imbue(lc);
6427 {
6428 ios.width(0);
6429 {
6430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6431 std::string ex(str, iter.base());
6432 assert(ex == "+0");
6433 assert(ios.width() == 0);
6434 }
6435 ios.width(25);
6436 left(ios);
6437 {
6438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6439 std::string ex(str, iter.base());
6440 assert(ex == "+0***********************");
6441 assert(ios.width() == 0);
6442 }
6443 ios.width(25);
6444 right(ios);
6445 {
6446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6447 std::string ex(str, iter.base());
6448 assert(ex == "***********************+0");
6449 assert(ios.width() == 0);
6450 }
6451 ios.width(25);
6452 internal(ios);
6453 {
6454 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6455 std::string ex(str, iter.base());
6456 assert(ex == "+***********************0");
6457 assert(ios.width() == 0);
6458 }
6459 }
6460 ios.imbue(lg);
6461 {
6462 ios.width(0);
6463 {
6464 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6465 std::string ex(str, iter.base());
6466 assert(ex == "+0");
6467 assert(ios.width() == 0);
6468 }
6469 ios.width(25);
6470 left(ios);
6471 {
6472 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6473 std::string ex(str, iter.base());
6474 assert(ex == "+0***********************");
6475 assert(ios.width() == 0);
6476 }
6477 ios.width(25);
6478 right(ios);
6479 {
6480 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6481 std::string ex(str, iter.base());
6482 assert(ex == "***********************+0");
6483 assert(ios.width() == 0);
6484 }
6485 ios.width(25);
6486 internal(ios);
6487 {
6488 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6489 std::string ex(str, iter.base());
6490 assert(ex == "+***********************0");
6491 assert(ios.width() == 0);
6492 }
6493 }
6494 }
6495 showpoint(ios);
6496 {
6497 ios.imbue(lc);
6498 {
6499 ios.width(0);
6500 {
6501 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6502 std::string ex(str, iter.base());
6503 assert(ex == "+0.");
6504 assert(ios.width() == 0);
6505 }
6506 ios.width(25);
6507 left(ios);
6508 {
6509 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6510 std::string ex(str, iter.base());
6511 assert(ex == "+0.**********************");
6512 assert(ios.width() == 0);
6513 }
6514 ios.width(25);
6515 right(ios);
6516 {
6517 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6518 std::string ex(str, iter.base());
6519 assert(ex == "**********************+0.");
6520 assert(ios.width() == 0);
6521 }
6522 ios.width(25);
6523 internal(ios);
6524 {
6525 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6526 std::string ex(str, iter.base());
6527 assert(ex == "+**********************0.");
6528 assert(ios.width() == 0);
6529 }
6530 }
6531 ios.imbue(lg);
6532 {
6533 ios.width(0);
6534 {
6535 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6536 std::string ex(str, iter.base());
6537 assert(ex == "+0;");
6538 assert(ios.width() == 0);
6539 }
6540 ios.width(25);
6541 left(ios);
6542 {
6543 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6544 std::string ex(str, iter.base());
6545 assert(ex == "+0;**********************");
6546 assert(ios.width() == 0);
6547 }
6548 ios.width(25);
6549 right(ios);
6550 {
6551 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6552 std::string ex(str, iter.base());
6553 assert(ex == "**********************+0;");
6554 assert(ios.width() == 0);
6555 }
6556 ios.width(25);
6557 internal(ios);
6558 {
6559 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6560 std::string ex(str, iter.base());
6561 assert(ex == "+**********************0;");
6562 assert(ios.width() == 0);
6563 }
6564 }
6565 }
6566 }
6567 }
6568 }
6569 ios.precision(1);
6570 {
6571 nouppercase(ios);
6572 {
6573 noshowpos(ios);
6574 {
6575 noshowpoint(ios);
6576 {
6577 ios.imbue(lc);
6578 {
6579 ios.width(0);
6580 {
6581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6582 std::string ex(str, iter.base());
6583 assert(ex == "0.0");
6584 assert(ios.width() == 0);
6585 }
6586 ios.width(25);
6587 left(ios);
6588 {
6589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6590 std::string ex(str, iter.base());
6591 assert(ex == "0.0**********************");
6592 assert(ios.width() == 0);
6593 }
6594 ios.width(25);
6595 right(ios);
6596 {
6597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6598 std::string ex(str, iter.base());
6599 assert(ex == "**********************0.0");
6600 assert(ios.width() == 0);
6601 }
6602 ios.width(25);
6603 internal(ios);
6604 {
6605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6606 std::string ex(str, iter.base());
6607 assert(ex == "**********************0.0");
6608 assert(ios.width() == 0);
6609 }
6610 }
6611 ios.imbue(lg);
6612 {
6613 ios.width(0);
6614 {
6615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6616 std::string ex(str, iter.base());
6617 assert(ex == "0;0");
6618 assert(ios.width() == 0);
6619 }
6620 ios.width(25);
6621 left(ios);
6622 {
6623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6624 std::string ex(str, iter.base());
6625 assert(ex == "0;0**********************");
6626 assert(ios.width() == 0);
6627 }
6628 ios.width(25);
6629 right(ios);
6630 {
6631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6632 std::string ex(str, iter.base());
6633 assert(ex == "**********************0;0");
6634 assert(ios.width() == 0);
6635 }
6636 ios.width(25);
6637 internal(ios);
6638 {
6639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6640 std::string ex(str, iter.base());
6641 assert(ex == "**********************0;0");
6642 assert(ios.width() == 0);
6643 }
6644 }
6645 }
6646 showpoint(ios);
6647 {
6648 ios.imbue(lc);
6649 {
6650 ios.width(0);
6651 {
6652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6653 std::string ex(str, iter.base());
6654 assert(ex == "0.0");
6655 assert(ios.width() == 0);
6656 }
6657 ios.width(25);
6658 left(ios);
6659 {
6660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6661 std::string ex(str, iter.base());
6662 assert(ex == "0.0**********************");
6663 assert(ios.width() == 0);
6664 }
6665 ios.width(25);
6666 right(ios);
6667 {
6668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6669 std::string ex(str, iter.base());
6670 assert(ex == "**********************0.0");
6671 assert(ios.width() == 0);
6672 }
6673 ios.width(25);
6674 internal(ios);
6675 {
6676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6677 std::string ex(str, iter.base());
6678 assert(ex == "**********************0.0");
6679 assert(ios.width() == 0);
6680 }
6681 }
6682 ios.imbue(lg);
6683 {
6684 ios.width(0);
6685 {
6686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6687 std::string ex(str, iter.base());
6688 assert(ex == "0;0");
6689 assert(ios.width() == 0);
6690 }
6691 ios.width(25);
6692 left(ios);
6693 {
6694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6695 std::string ex(str, iter.base());
6696 assert(ex == "0;0**********************");
6697 assert(ios.width() == 0);
6698 }
6699 ios.width(25);
6700 right(ios);
6701 {
6702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6703 std::string ex(str, iter.base());
6704 assert(ex == "**********************0;0");
6705 assert(ios.width() == 0);
6706 }
6707 ios.width(25);
6708 internal(ios);
6709 {
6710 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6711 std::string ex(str, iter.base());
6712 assert(ex == "**********************0;0");
6713 assert(ios.width() == 0);
6714 }
6715 }
6716 }
6717 }
6718 showpos(ios);
6719 {
6720 noshowpoint(ios);
6721 {
6722 ios.imbue(lc);
6723 {
6724 ios.width(0);
6725 {
6726 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6727 std::string ex(str, iter.base());
6728 assert(ex == "+0.0");
6729 assert(ios.width() == 0);
6730 }
6731 ios.width(25);
6732 left(ios);
6733 {
6734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6735 std::string ex(str, iter.base());
6736 assert(ex == "+0.0*********************");
6737 assert(ios.width() == 0);
6738 }
6739 ios.width(25);
6740 right(ios);
6741 {
6742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6743 std::string ex(str, iter.base());
6744 assert(ex == "*********************+0.0");
6745 assert(ios.width() == 0);
6746 }
6747 ios.width(25);
6748 internal(ios);
6749 {
6750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6751 std::string ex(str, iter.base());
6752 assert(ex == "+*********************0.0");
6753 assert(ios.width() == 0);
6754 }
6755 }
6756 ios.imbue(lg);
6757 {
6758 ios.width(0);
6759 {
6760 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6761 std::string ex(str, iter.base());
6762 assert(ex == "+0;0");
6763 assert(ios.width() == 0);
6764 }
6765 ios.width(25);
6766 left(ios);
6767 {
6768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6769 std::string ex(str, iter.base());
6770 assert(ex == "+0;0*********************");
6771 assert(ios.width() == 0);
6772 }
6773 ios.width(25);
6774 right(ios);
6775 {
6776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6777 std::string ex(str, iter.base());
6778 assert(ex == "*********************+0;0");
6779 assert(ios.width() == 0);
6780 }
6781 ios.width(25);
6782 internal(ios);
6783 {
6784 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6785 std::string ex(str, iter.base());
6786 assert(ex == "+*********************0;0");
6787 assert(ios.width() == 0);
6788 }
6789 }
6790 }
6791 showpoint(ios);
6792 {
6793 ios.imbue(lc);
6794 {
6795 ios.width(0);
6796 {
6797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6798 std::string ex(str, iter.base());
6799 assert(ex == "+0.0");
6800 assert(ios.width() == 0);
6801 }
6802 ios.width(25);
6803 left(ios);
6804 {
6805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6806 std::string ex(str, iter.base());
6807 assert(ex == "+0.0*********************");
6808 assert(ios.width() == 0);
6809 }
6810 ios.width(25);
6811 right(ios);
6812 {
6813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6814 std::string ex(str, iter.base());
6815 assert(ex == "*********************+0.0");
6816 assert(ios.width() == 0);
6817 }
6818 ios.width(25);
6819 internal(ios);
6820 {
6821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6822 std::string ex(str, iter.base());
6823 assert(ex == "+*********************0.0");
6824 assert(ios.width() == 0);
6825 }
6826 }
6827 ios.imbue(lg);
6828 {
6829 ios.width(0);
6830 {
6831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6832 std::string ex(str, iter.base());
6833 assert(ex == "+0;0");
6834 assert(ios.width() == 0);
6835 }
6836 ios.width(25);
6837 left(ios);
6838 {
6839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6840 std::string ex(str, iter.base());
6841 assert(ex == "+0;0*********************");
6842 assert(ios.width() == 0);
6843 }
6844 ios.width(25);
6845 right(ios);
6846 {
6847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6848 std::string ex(str, iter.base());
6849 assert(ex == "*********************+0;0");
6850 assert(ios.width() == 0);
6851 }
6852 ios.width(25);
6853 internal(ios);
6854 {
6855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6856 std::string ex(str, iter.base());
6857 assert(ex == "+*********************0;0");
6858 assert(ios.width() == 0);
6859 }
6860 }
6861 }
6862 }
6863 }
6864 uppercase(ios);
6865 {
6866 noshowpos(ios);
6867 {
6868 noshowpoint(ios);
6869 {
6870 ios.imbue(lc);
6871 {
6872 ios.width(0);
6873 {
6874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6875 std::string ex(str, iter.base());
6876 assert(ex == "0.0");
6877 assert(ios.width() == 0);
6878 }
6879 ios.width(25);
6880 left(ios);
6881 {
6882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6883 std::string ex(str, iter.base());
6884 assert(ex == "0.0**********************");
6885 assert(ios.width() == 0);
6886 }
6887 ios.width(25);
6888 right(ios);
6889 {
6890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6891 std::string ex(str, iter.base());
6892 assert(ex == "**********************0.0");
6893 assert(ios.width() == 0);
6894 }
6895 ios.width(25);
6896 internal(ios);
6897 {
6898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6899 std::string ex(str, iter.base());
6900 assert(ex == "**********************0.0");
6901 assert(ios.width() == 0);
6902 }
6903 }
6904 ios.imbue(lg);
6905 {
6906 ios.width(0);
6907 {
6908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6909 std::string ex(str, iter.base());
6910 assert(ex == "0;0");
6911 assert(ios.width() == 0);
6912 }
6913 ios.width(25);
6914 left(ios);
6915 {
6916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6917 std::string ex(str, iter.base());
6918 assert(ex == "0;0**********************");
6919 assert(ios.width() == 0);
6920 }
6921 ios.width(25);
6922 right(ios);
6923 {
6924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6925 std::string ex(str, iter.base());
6926 assert(ex == "**********************0;0");
6927 assert(ios.width() == 0);
6928 }
6929 ios.width(25);
6930 internal(ios);
6931 {
6932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6933 std::string ex(str, iter.base());
6934 assert(ex == "**********************0;0");
6935 assert(ios.width() == 0);
6936 }
6937 }
6938 }
6939 showpoint(ios);
6940 {
6941 ios.imbue(lc);
6942 {
6943 ios.width(0);
6944 {
6945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6946 std::string ex(str, iter.base());
6947 assert(ex == "0.0");
6948 assert(ios.width() == 0);
6949 }
6950 ios.width(25);
6951 left(ios);
6952 {
6953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6954 std::string ex(str, iter.base());
6955 assert(ex == "0.0**********************");
6956 assert(ios.width() == 0);
6957 }
6958 ios.width(25);
6959 right(ios);
6960 {
6961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6962 std::string ex(str, iter.base());
6963 assert(ex == "**********************0.0");
6964 assert(ios.width() == 0);
6965 }
6966 ios.width(25);
6967 internal(ios);
6968 {
6969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6970 std::string ex(str, iter.base());
6971 assert(ex == "**********************0.0");
6972 assert(ios.width() == 0);
6973 }
6974 }
6975 ios.imbue(lg);
6976 {
6977 ios.width(0);
6978 {
6979 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6980 std::string ex(str, iter.base());
6981 assert(ex == "0;0");
6982 assert(ios.width() == 0);
6983 }
6984 ios.width(25);
6985 left(ios);
6986 {
6987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6988 std::string ex(str, iter.base());
6989 assert(ex == "0;0**********************");
6990 assert(ios.width() == 0);
6991 }
6992 ios.width(25);
6993 right(ios);
6994 {
6995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6996 std::string ex(str, iter.base());
6997 assert(ex == "**********************0;0");
6998 assert(ios.width() == 0);
6999 }
7000 ios.width(25);
7001 internal(ios);
7002 {
7003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7004 std::string ex(str, iter.base());
7005 assert(ex == "**********************0;0");
7006 assert(ios.width() == 0);
7007 }
7008 }
7009 }
7010 }
7011 showpos(ios);
7012 {
7013 noshowpoint(ios);
7014 {
7015 ios.imbue(lc);
7016 {
7017 ios.width(0);
7018 {
7019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7020 std::string ex(str, iter.base());
7021 assert(ex == "+0.0");
7022 assert(ios.width() == 0);
7023 }
7024 ios.width(25);
7025 left(ios);
7026 {
7027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7028 std::string ex(str, iter.base());
7029 assert(ex == "+0.0*********************");
7030 assert(ios.width() == 0);
7031 }
7032 ios.width(25);
7033 right(ios);
7034 {
7035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7036 std::string ex(str, iter.base());
7037 assert(ex == "*********************+0.0");
7038 assert(ios.width() == 0);
7039 }
7040 ios.width(25);
7041 internal(ios);
7042 {
7043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7044 std::string ex(str, iter.base());
7045 assert(ex == "+*********************0.0");
7046 assert(ios.width() == 0);
7047 }
7048 }
7049 ios.imbue(lg);
7050 {
7051 ios.width(0);
7052 {
7053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7054 std::string ex(str, iter.base());
7055 assert(ex == "+0;0");
7056 assert(ios.width() == 0);
7057 }
7058 ios.width(25);
7059 left(ios);
7060 {
7061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7062 std::string ex(str, iter.base());
7063 assert(ex == "+0;0*********************");
7064 assert(ios.width() == 0);
7065 }
7066 ios.width(25);
7067 right(ios);
7068 {
7069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7070 std::string ex(str, iter.base());
7071 assert(ex == "*********************+0;0");
7072 assert(ios.width() == 0);
7073 }
7074 ios.width(25);
7075 internal(ios);
7076 {
7077 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7078 std::string ex(str, iter.base());
7079 assert(ex == "+*********************0;0");
7080 assert(ios.width() == 0);
7081 }
7082 }
7083 }
7084 showpoint(ios);
7085 {
7086 ios.imbue(lc);
7087 {
7088 ios.width(0);
7089 {
7090 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7091 std::string ex(str, iter.base());
7092 assert(ex == "+0.0");
7093 assert(ios.width() == 0);
7094 }
7095 ios.width(25);
7096 left(ios);
7097 {
7098 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7099 std::string ex(str, iter.base());
7100 assert(ex == "+0.0*********************");
7101 assert(ios.width() == 0);
7102 }
7103 ios.width(25);
7104 right(ios);
7105 {
7106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7107 std::string ex(str, iter.base());
7108 assert(ex == "*********************+0.0");
7109 assert(ios.width() == 0);
7110 }
7111 ios.width(25);
7112 internal(ios);
7113 {
7114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7115 std::string ex(str, iter.base());
7116 assert(ex == "+*********************0.0");
7117 assert(ios.width() == 0);
7118 }
7119 }
7120 ios.imbue(lg);
7121 {
7122 ios.width(0);
7123 {
7124 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7125 std::string ex(str, iter.base());
7126 assert(ex == "+0;0");
7127 assert(ios.width() == 0);
7128 }
7129 ios.width(25);
7130 left(ios);
7131 {
7132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7133 std::string ex(str, iter.base());
7134 assert(ex == "+0;0*********************");
7135 assert(ios.width() == 0);
7136 }
7137 ios.width(25);
7138 right(ios);
7139 {
7140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7141 std::string ex(str, iter.base());
7142 assert(ex == "*********************+0;0");
7143 assert(ios.width() == 0);
7144 }
7145 ios.width(25);
7146 internal(ios);
7147 {
7148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7149 std::string ex(str, iter.base());
7150 assert(ex == "+*********************0;0");
7151 assert(ios.width() == 0);
7152 }
7153 }
7154 }
7155 }
7156 }
7157 }
7158 ios.precision(6);
7159 {
7160 nouppercase(ios);
7161 {
7162 noshowpos(ios);
7163 {
7164 noshowpoint(ios);
7165 {
7166 ios.imbue(lc);
7167 {
7168 ios.width(0);
7169 {
7170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7171 std::string ex(str, iter.base());
7172 assert(ex == "0.000000");
7173 assert(ios.width() == 0);
7174 }
7175 ios.width(25);
7176 left(ios);
7177 {
7178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7179 std::string ex(str, iter.base());
7180 assert(ex == "0.000000*****************");
7181 assert(ios.width() == 0);
7182 }
7183 ios.width(25);
7184 right(ios);
7185 {
7186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7187 std::string ex(str, iter.base());
7188 assert(ex == "*****************0.000000");
7189 assert(ios.width() == 0);
7190 }
7191 ios.width(25);
7192 internal(ios);
7193 {
7194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7195 std::string ex(str, iter.base());
7196 assert(ex == "*****************0.000000");
7197 assert(ios.width() == 0);
7198 }
7199 }
7200 ios.imbue(lg);
7201 {
7202 ios.width(0);
7203 {
7204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7205 std::string ex(str, iter.base());
7206 assert(ex == "0;000000");
7207 assert(ios.width() == 0);
7208 }
7209 ios.width(25);
7210 left(ios);
7211 {
7212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7213 std::string ex(str, iter.base());
7214 assert(ex == "0;000000*****************");
7215 assert(ios.width() == 0);
7216 }
7217 ios.width(25);
7218 right(ios);
7219 {
7220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7221 std::string ex(str, iter.base());
7222 assert(ex == "*****************0;000000");
7223 assert(ios.width() == 0);
7224 }
7225 ios.width(25);
7226 internal(ios);
7227 {
7228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7229 std::string ex(str, iter.base());
7230 assert(ex == "*****************0;000000");
7231 assert(ios.width() == 0);
7232 }
7233 }
7234 }
7235 showpoint(ios);
7236 {
7237 ios.imbue(lc);
7238 {
7239 ios.width(0);
7240 {
7241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7242 std::string ex(str, iter.base());
7243 assert(ex == "0.000000");
7244 assert(ios.width() == 0);
7245 }
7246 ios.width(25);
7247 left(ios);
7248 {
7249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7250 std::string ex(str, iter.base());
7251 assert(ex == "0.000000*****************");
7252 assert(ios.width() == 0);
7253 }
7254 ios.width(25);
7255 right(ios);
7256 {
7257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7258 std::string ex(str, iter.base());
7259 assert(ex == "*****************0.000000");
7260 assert(ios.width() == 0);
7261 }
7262 ios.width(25);
7263 internal(ios);
7264 {
7265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7266 std::string ex(str, iter.base());
7267 assert(ex == "*****************0.000000");
7268 assert(ios.width() == 0);
7269 }
7270 }
7271 ios.imbue(lg);
7272 {
7273 ios.width(0);
7274 {
7275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7276 std::string ex(str, iter.base());
7277 assert(ex == "0;000000");
7278 assert(ios.width() == 0);
7279 }
7280 ios.width(25);
7281 left(ios);
7282 {
7283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7284 std::string ex(str, iter.base());
7285 assert(ex == "0;000000*****************");
7286 assert(ios.width() == 0);
7287 }
7288 ios.width(25);
7289 right(ios);
7290 {
7291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7292 std::string ex(str, iter.base());
7293 assert(ex == "*****************0;000000");
7294 assert(ios.width() == 0);
7295 }
7296 ios.width(25);
7297 internal(ios);
7298 {
7299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7300 std::string ex(str, iter.base());
7301 assert(ex == "*****************0;000000");
7302 assert(ios.width() == 0);
7303 }
7304 }
7305 }
7306 }
7307 showpos(ios);
7308 {
7309 noshowpoint(ios);
7310 {
7311 ios.imbue(lc);
7312 {
7313 ios.width(0);
7314 {
7315 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7316 std::string ex(str, iter.base());
7317 assert(ex == "+0.000000");
7318 assert(ios.width() == 0);
7319 }
7320 ios.width(25);
7321 left(ios);
7322 {
7323 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7324 std::string ex(str, iter.base());
7325 assert(ex == "+0.000000****************");
7326 assert(ios.width() == 0);
7327 }
7328 ios.width(25);
7329 right(ios);
7330 {
7331 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7332 std::string ex(str, iter.base());
7333 assert(ex == "****************+0.000000");
7334 assert(ios.width() == 0);
7335 }
7336 ios.width(25);
7337 internal(ios);
7338 {
7339 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7340 std::string ex(str, iter.base());
7341 assert(ex == "+****************0.000000");
7342 assert(ios.width() == 0);
7343 }
7344 }
7345 ios.imbue(lg);
7346 {
7347 ios.width(0);
7348 {
7349 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7350 std::string ex(str, iter.base());
7351 assert(ex == "+0;000000");
7352 assert(ios.width() == 0);
7353 }
7354 ios.width(25);
7355 left(ios);
7356 {
7357 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7358 std::string ex(str, iter.base());
7359 assert(ex == "+0;000000****************");
7360 assert(ios.width() == 0);
7361 }
7362 ios.width(25);
7363 right(ios);
7364 {
7365 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7366 std::string ex(str, iter.base());
7367 assert(ex == "****************+0;000000");
7368 assert(ios.width() == 0);
7369 }
7370 ios.width(25);
7371 internal(ios);
7372 {
7373 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7374 std::string ex(str, iter.base());
7375 assert(ex == "+****************0;000000");
7376 assert(ios.width() == 0);
7377 }
7378 }
7379 }
7380 showpoint(ios);
7381 {
7382 ios.imbue(lc);
7383 {
7384 ios.width(0);
7385 {
7386 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7387 std::string ex(str, iter.base());
7388 assert(ex == "+0.000000");
7389 assert(ios.width() == 0);
7390 }
7391 ios.width(25);
7392 left(ios);
7393 {
7394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7395 std::string ex(str, iter.base());
7396 assert(ex == "+0.000000****************");
7397 assert(ios.width() == 0);
7398 }
7399 ios.width(25);
7400 right(ios);
7401 {
7402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7403 std::string ex(str, iter.base());
7404 assert(ex == "****************+0.000000");
7405 assert(ios.width() == 0);
7406 }
7407 ios.width(25);
7408 internal(ios);
7409 {
7410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7411 std::string ex(str, iter.base());
7412 assert(ex == "+****************0.000000");
7413 assert(ios.width() == 0);
7414 }
7415 }
7416 ios.imbue(lg);
7417 {
7418 ios.width(0);
7419 {
7420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7421 std::string ex(str, iter.base());
7422 assert(ex == "+0;000000");
7423 assert(ios.width() == 0);
7424 }
7425 ios.width(25);
7426 left(ios);
7427 {
7428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7429 std::string ex(str, iter.base());
7430 assert(ex == "+0;000000****************");
7431 assert(ios.width() == 0);
7432 }
7433 ios.width(25);
7434 right(ios);
7435 {
7436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7437 std::string ex(str, iter.base());
7438 assert(ex == "****************+0;000000");
7439 assert(ios.width() == 0);
7440 }
7441 ios.width(25);
7442 internal(ios);
7443 {
7444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7445 std::string ex(str, iter.base());
7446 assert(ex == "+****************0;000000");
7447 assert(ios.width() == 0);
7448 }
7449 }
7450 }
7451 }
7452 }
7453 uppercase(ios);
7454 {
7455 noshowpos(ios);
7456 {
7457 noshowpoint(ios);
7458 {
7459 ios.imbue(lc);
7460 {
7461 ios.width(0);
7462 {
7463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7464 std::string ex(str, iter.base());
7465 assert(ex == "0.000000");
7466 assert(ios.width() == 0);
7467 }
7468 ios.width(25);
7469 left(ios);
7470 {
7471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7472 std::string ex(str, iter.base());
7473 assert(ex == "0.000000*****************");
7474 assert(ios.width() == 0);
7475 }
7476 ios.width(25);
7477 right(ios);
7478 {
7479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7480 std::string ex(str, iter.base());
7481 assert(ex == "*****************0.000000");
7482 assert(ios.width() == 0);
7483 }
7484 ios.width(25);
7485 internal(ios);
7486 {
7487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7488 std::string ex(str, iter.base());
7489 assert(ex == "*****************0.000000");
7490 assert(ios.width() == 0);
7491 }
7492 }
7493 ios.imbue(lg);
7494 {
7495 ios.width(0);
7496 {
7497 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7498 std::string ex(str, iter.base());
7499 assert(ex == "0;000000");
7500 assert(ios.width() == 0);
7501 }
7502 ios.width(25);
7503 left(ios);
7504 {
7505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7506 std::string ex(str, iter.base());
7507 assert(ex == "0;000000*****************");
7508 assert(ios.width() == 0);
7509 }
7510 ios.width(25);
7511 right(ios);
7512 {
7513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7514 std::string ex(str, iter.base());
7515 assert(ex == "*****************0;000000");
7516 assert(ios.width() == 0);
7517 }
7518 ios.width(25);
7519 internal(ios);
7520 {
7521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7522 std::string ex(str, iter.base());
7523 assert(ex == "*****************0;000000");
7524 assert(ios.width() == 0);
7525 }
7526 }
7527 }
7528 showpoint(ios);
7529 {
7530 ios.imbue(lc);
7531 {
7532 ios.width(0);
7533 {
7534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7535 std::string ex(str, iter.base());
7536 assert(ex == "0.000000");
7537 assert(ios.width() == 0);
7538 }
7539 ios.width(25);
7540 left(ios);
7541 {
7542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7543 std::string ex(str, iter.base());
7544 assert(ex == "0.000000*****************");
7545 assert(ios.width() == 0);
7546 }
7547 ios.width(25);
7548 right(ios);
7549 {
7550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7551 std::string ex(str, iter.base());
7552 assert(ex == "*****************0.000000");
7553 assert(ios.width() == 0);
7554 }
7555 ios.width(25);
7556 internal(ios);
7557 {
7558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7559 std::string ex(str, iter.base());
7560 assert(ex == "*****************0.000000");
7561 assert(ios.width() == 0);
7562 }
7563 }
7564 ios.imbue(lg);
7565 {
7566 ios.width(0);
7567 {
7568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7569 std::string ex(str, iter.base());
7570 assert(ex == "0;000000");
7571 assert(ios.width() == 0);
7572 }
7573 ios.width(25);
7574 left(ios);
7575 {
7576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7577 std::string ex(str, iter.base());
7578 assert(ex == "0;000000*****************");
7579 assert(ios.width() == 0);
7580 }
7581 ios.width(25);
7582 right(ios);
7583 {
7584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7585 std::string ex(str, iter.base());
7586 assert(ex == "*****************0;000000");
7587 assert(ios.width() == 0);
7588 }
7589 ios.width(25);
7590 internal(ios);
7591 {
7592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7593 std::string ex(str, iter.base());
7594 assert(ex == "*****************0;000000");
7595 assert(ios.width() == 0);
7596 }
7597 }
7598 }
7599 }
7600 showpos(ios);
7601 {
7602 noshowpoint(ios);
7603 {
7604 ios.imbue(lc);
7605 {
7606 ios.width(0);
7607 {
7608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7609 std::string ex(str, iter.base());
7610 assert(ex == "+0.000000");
7611 assert(ios.width() == 0);
7612 }
7613 ios.width(25);
7614 left(ios);
7615 {
7616 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7617 std::string ex(str, iter.base());
7618 assert(ex == "+0.000000****************");
7619 assert(ios.width() == 0);
7620 }
7621 ios.width(25);
7622 right(ios);
7623 {
7624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7625 std::string ex(str, iter.base());
7626 assert(ex == "****************+0.000000");
7627 assert(ios.width() == 0);
7628 }
7629 ios.width(25);
7630 internal(ios);
7631 {
7632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7633 std::string ex(str, iter.base());
7634 assert(ex == "+****************0.000000");
7635 assert(ios.width() == 0);
7636 }
7637 }
7638 ios.imbue(lg);
7639 {
7640 ios.width(0);
7641 {
7642 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7643 std::string ex(str, iter.base());
7644 assert(ex == "+0;000000");
7645 assert(ios.width() == 0);
7646 }
7647 ios.width(25);
7648 left(ios);
7649 {
7650 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7651 std::string ex(str, iter.base());
7652 assert(ex == "+0;000000****************");
7653 assert(ios.width() == 0);
7654 }
7655 ios.width(25);
7656 right(ios);
7657 {
7658 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7659 std::string ex(str, iter.base());
7660 assert(ex == "****************+0;000000");
7661 assert(ios.width() == 0);
7662 }
7663 ios.width(25);
7664 internal(ios);
7665 {
7666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7667 std::string ex(str, iter.base());
7668 assert(ex == "+****************0;000000");
7669 assert(ios.width() == 0);
7670 }
7671 }
7672 }
7673 showpoint(ios);
7674 {
7675 ios.imbue(lc);
7676 {
7677 ios.width(0);
7678 {
7679 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7680 std::string ex(str, iter.base());
7681 assert(ex == "+0.000000");
7682 assert(ios.width() == 0);
7683 }
7684 ios.width(25);
7685 left(ios);
7686 {
7687 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7688 std::string ex(str, iter.base());
7689 assert(ex == "+0.000000****************");
7690 assert(ios.width() == 0);
7691 }
7692 ios.width(25);
7693 right(ios);
7694 {
7695 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7696 std::string ex(str, iter.base());
7697 assert(ex == "****************+0.000000");
7698 assert(ios.width() == 0);
7699 }
7700 ios.width(25);
7701 internal(ios);
7702 {
7703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7704 std::string ex(str, iter.base());
7705 assert(ex == "+****************0.000000");
7706 assert(ios.width() == 0);
7707 }
7708 }
7709 ios.imbue(lg);
7710 {
7711 ios.width(0);
7712 {
7713 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7714 std::string ex(str, iter.base());
7715 assert(ex == "+0;000000");
7716 assert(ios.width() == 0);
7717 }
7718 ios.width(25);
7719 left(ios);
7720 {
7721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7722 std::string ex(str, iter.base());
7723 assert(ex == "+0;000000****************");
7724 assert(ios.width() == 0);
7725 }
7726 ios.width(25);
7727 right(ios);
7728 {
7729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7730 std::string ex(str, iter.base());
7731 assert(ex == "****************+0;000000");
7732 assert(ios.width() == 0);
7733 }
7734 ios.width(25);
7735 internal(ios);
7736 {
7737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7738 std::string ex(str, iter.base());
7739 assert(ex == "+****************0;000000");
7740 assert(ios.width() == 0);
7741 }
7742 }
7743 }
7744 }
7745 }
7746 }
7747 ios.precision(16);
7748 {
7749 nouppercase(ios);
7750 {
7751 noshowpos(ios);
7752 {
7753 noshowpoint(ios);
7754 {
7755 ios.imbue(lc);
7756 {
7757 ios.width(0);
7758 {
7759 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7760 std::string ex(str, iter.base());
7761 assert(ex == "0.0000000000000000");
7762 assert(ios.width() == 0);
7763 }
7764 ios.width(25);
7765 left(ios);
7766 {
7767 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7768 std::string ex(str, iter.base());
7769 assert(ex == "0.0000000000000000*******");
7770 assert(ios.width() == 0);
7771 }
7772 ios.width(25);
7773 right(ios);
7774 {
7775 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7776 std::string ex(str, iter.base());
7777 assert(ex == "*******0.0000000000000000");
7778 assert(ios.width() == 0);
7779 }
7780 ios.width(25);
7781 internal(ios);
7782 {
7783 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7784 std::string ex(str, iter.base());
7785 assert(ex == "*******0.0000000000000000");
7786 assert(ios.width() == 0);
7787 }
7788 }
7789 ios.imbue(lg);
7790 {
7791 ios.width(0);
7792 {
7793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7794 std::string ex(str, iter.base());
7795 assert(ex == "0;0000000000000000");
7796 assert(ios.width() == 0);
7797 }
7798 ios.width(25);
7799 left(ios);
7800 {
7801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7802 std::string ex(str, iter.base());
7803 assert(ex == "0;0000000000000000*******");
7804 assert(ios.width() == 0);
7805 }
7806 ios.width(25);
7807 right(ios);
7808 {
7809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7810 std::string ex(str, iter.base());
7811 assert(ex == "*******0;0000000000000000");
7812 assert(ios.width() == 0);
7813 }
7814 ios.width(25);
7815 internal(ios);
7816 {
7817 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7818 std::string ex(str, iter.base());
7819 assert(ex == "*******0;0000000000000000");
7820 assert(ios.width() == 0);
7821 }
7822 }
7823 }
7824 showpoint(ios);
7825 {
7826 ios.imbue(lc);
7827 {
7828 ios.width(0);
7829 {
7830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7831 std::string ex(str, iter.base());
7832 assert(ex == "0.0000000000000000");
7833 assert(ios.width() == 0);
7834 }
7835 ios.width(25);
7836 left(ios);
7837 {
7838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7839 std::string ex(str, iter.base());
7840 assert(ex == "0.0000000000000000*******");
7841 assert(ios.width() == 0);
7842 }
7843 ios.width(25);
7844 right(ios);
7845 {
7846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7847 std::string ex(str, iter.base());
7848 assert(ex == "*******0.0000000000000000");
7849 assert(ios.width() == 0);
7850 }
7851 ios.width(25);
7852 internal(ios);
7853 {
7854 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7855 std::string ex(str, iter.base());
7856 assert(ex == "*******0.0000000000000000");
7857 assert(ios.width() == 0);
7858 }
7859 }
7860 ios.imbue(lg);
7861 {
7862 ios.width(0);
7863 {
7864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7865 std::string ex(str, iter.base());
7866 assert(ex == "0;0000000000000000");
7867 assert(ios.width() == 0);
7868 }
7869 ios.width(25);
7870 left(ios);
7871 {
7872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7873 std::string ex(str, iter.base());
7874 assert(ex == "0;0000000000000000*******");
7875 assert(ios.width() == 0);
7876 }
7877 ios.width(25);
7878 right(ios);
7879 {
7880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7881 std::string ex(str, iter.base());
7882 assert(ex == "*******0;0000000000000000");
7883 assert(ios.width() == 0);
7884 }
7885 ios.width(25);
7886 internal(ios);
7887 {
7888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7889 std::string ex(str, iter.base());
7890 assert(ex == "*******0;0000000000000000");
7891 assert(ios.width() == 0);
7892 }
7893 }
7894 }
7895 }
7896 showpos(ios);
7897 {
7898 noshowpoint(ios);
7899 {
7900 ios.imbue(lc);
7901 {
7902 ios.width(0);
7903 {
7904 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7905 std::string ex(str, iter.base());
7906 assert(ex == "+0.0000000000000000");
7907 assert(ios.width() == 0);
7908 }
7909 ios.width(25);
7910 left(ios);
7911 {
7912 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7913 std::string ex(str, iter.base());
7914 assert(ex == "+0.0000000000000000******");
7915 assert(ios.width() == 0);
7916 }
7917 ios.width(25);
7918 right(ios);
7919 {
7920 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7921 std::string ex(str, iter.base());
7922 assert(ex == "******+0.0000000000000000");
7923 assert(ios.width() == 0);
7924 }
7925 ios.width(25);
7926 internal(ios);
7927 {
7928 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7929 std::string ex(str, iter.base());
7930 assert(ex == "+******0.0000000000000000");
7931 assert(ios.width() == 0);
7932 }
7933 }
7934 ios.imbue(lg);
7935 {
7936 ios.width(0);
7937 {
7938 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7939 std::string ex(str, iter.base());
7940 assert(ex == "+0;0000000000000000");
7941 assert(ios.width() == 0);
7942 }
7943 ios.width(25);
7944 left(ios);
7945 {
7946 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7947 std::string ex(str, iter.base());
7948 assert(ex == "+0;0000000000000000******");
7949 assert(ios.width() == 0);
7950 }
7951 ios.width(25);
7952 right(ios);
7953 {
7954 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7955 std::string ex(str, iter.base());
7956 assert(ex == "******+0;0000000000000000");
7957 assert(ios.width() == 0);
7958 }
7959 ios.width(25);
7960 internal(ios);
7961 {
7962 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7963 std::string ex(str, iter.base());
7964 assert(ex == "+******0;0000000000000000");
7965 assert(ios.width() == 0);
7966 }
7967 }
7968 }
7969 showpoint(ios);
7970 {
7971 ios.imbue(lc);
7972 {
7973 ios.width(0);
7974 {
7975 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7976 std::string ex(str, iter.base());
7977 assert(ex == "+0.0000000000000000");
7978 assert(ios.width() == 0);
7979 }
7980 ios.width(25);
7981 left(ios);
7982 {
7983 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7984 std::string ex(str, iter.base());
7985 assert(ex == "+0.0000000000000000******");
7986 assert(ios.width() == 0);
7987 }
7988 ios.width(25);
7989 right(ios);
7990 {
7991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7992 std::string ex(str, iter.base());
7993 assert(ex == "******+0.0000000000000000");
7994 assert(ios.width() == 0);
7995 }
7996 ios.width(25);
7997 internal(ios);
7998 {
7999 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8000 std::string ex(str, iter.base());
8001 assert(ex == "+******0.0000000000000000");
8002 assert(ios.width() == 0);
8003 }
8004 }
8005 ios.imbue(lg);
8006 {
8007 ios.width(0);
8008 {
8009 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8010 std::string ex(str, iter.base());
8011 assert(ex == "+0;0000000000000000");
8012 assert(ios.width() == 0);
8013 }
8014 ios.width(25);
8015 left(ios);
8016 {
8017 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8018 std::string ex(str, iter.base());
8019 assert(ex == "+0;0000000000000000******");
8020 assert(ios.width() == 0);
8021 }
8022 ios.width(25);
8023 right(ios);
8024 {
8025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8026 std::string ex(str, iter.base());
8027 assert(ex == "******+0;0000000000000000");
8028 assert(ios.width() == 0);
8029 }
8030 ios.width(25);
8031 internal(ios);
8032 {
8033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8034 std::string ex(str, iter.base());
8035 assert(ex == "+******0;0000000000000000");
8036 assert(ios.width() == 0);
8037 }
8038 }
8039 }
8040 }
8041 }
8042 uppercase(ios);
8043 {
8044 noshowpos(ios);
8045 {
8046 noshowpoint(ios);
8047 {
8048 ios.imbue(lc);
8049 {
8050 ios.width(0);
8051 {
8052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8053 std::string ex(str, iter.base());
8054 assert(ex == "0.0000000000000000");
8055 assert(ios.width() == 0);
8056 }
8057 ios.width(25);
8058 left(ios);
8059 {
8060 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8061 std::string ex(str, iter.base());
8062 assert(ex == "0.0000000000000000*******");
8063 assert(ios.width() == 0);
8064 }
8065 ios.width(25);
8066 right(ios);
8067 {
8068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8069 std::string ex(str, iter.base());
8070 assert(ex == "*******0.0000000000000000");
8071 assert(ios.width() == 0);
8072 }
8073 ios.width(25);
8074 internal(ios);
8075 {
8076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8077 std::string ex(str, iter.base());
8078 assert(ex == "*******0.0000000000000000");
8079 assert(ios.width() == 0);
8080 }
8081 }
8082 ios.imbue(lg);
8083 {
8084 ios.width(0);
8085 {
8086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8087 std::string ex(str, iter.base());
8088 assert(ex == "0;0000000000000000");
8089 assert(ios.width() == 0);
8090 }
8091 ios.width(25);
8092 left(ios);
8093 {
8094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8095 std::string ex(str, iter.base());
8096 assert(ex == "0;0000000000000000*******");
8097 assert(ios.width() == 0);
8098 }
8099 ios.width(25);
8100 right(ios);
8101 {
8102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8103 std::string ex(str, iter.base());
8104 assert(ex == "*******0;0000000000000000");
8105 assert(ios.width() == 0);
8106 }
8107 ios.width(25);
8108 internal(ios);
8109 {
8110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8111 std::string ex(str, iter.base());
8112 assert(ex == "*******0;0000000000000000");
8113 assert(ios.width() == 0);
8114 }
8115 }
8116 }
8117 showpoint(ios);
8118 {
8119 ios.imbue(lc);
8120 {
8121 ios.width(0);
8122 {
8123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8124 std::string ex(str, iter.base());
8125 assert(ex == "0.0000000000000000");
8126 assert(ios.width() == 0);
8127 }
8128 ios.width(25);
8129 left(ios);
8130 {
8131 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8132 std::string ex(str, iter.base());
8133 assert(ex == "0.0000000000000000*******");
8134 assert(ios.width() == 0);
8135 }
8136 ios.width(25);
8137 right(ios);
8138 {
8139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8140 std::string ex(str, iter.base());
8141 assert(ex == "*******0.0000000000000000");
8142 assert(ios.width() == 0);
8143 }
8144 ios.width(25);
8145 internal(ios);
8146 {
8147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8148 std::string ex(str, iter.base());
8149 assert(ex == "*******0.0000000000000000");
8150 assert(ios.width() == 0);
8151 }
8152 }
8153 ios.imbue(lg);
8154 {
8155 ios.width(0);
8156 {
8157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8158 std::string ex(str, iter.base());
8159 assert(ex == "0;0000000000000000");
8160 assert(ios.width() == 0);
8161 }
8162 ios.width(25);
8163 left(ios);
8164 {
8165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8166 std::string ex(str, iter.base());
8167 assert(ex == "0;0000000000000000*******");
8168 assert(ios.width() == 0);
8169 }
8170 ios.width(25);
8171 right(ios);
8172 {
8173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8174 std::string ex(str, iter.base());
8175 assert(ex == "*******0;0000000000000000");
8176 assert(ios.width() == 0);
8177 }
8178 ios.width(25);
8179 internal(ios);
8180 {
8181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8182 std::string ex(str, iter.base());
8183 assert(ex == "*******0;0000000000000000");
8184 assert(ios.width() == 0);
8185 }
8186 }
8187 }
8188 }
8189 showpos(ios);
8190 {
8191 noshowpoint(ios);
8192 {
8193 ios.imbue(lc);
8194 {
8195 ios.width(0);
8196 {
8197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8198 std::string ex(str, iter.base());
8199 assert(ex == "+0.0000000000000000");
8200 assert(ios.width() == 0);
8201 }
8202 ios.width(25);
8203 left(ios);
8204 {
8205 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8206 std::string ex(str, iter.base());
8207 assert(ex == "+0.0000000000000000******");
8208 assert(ios.width() == 0);
8209 }
8210 ios.width(25);
8211 right(ios);
8212 {
8213 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8214 std::string ex(str, iter.base());
8215 assert(ex == "******+0.0000000000000000");
8216 assert(ios.width() == 0);
8217 }
8218 ios.width(25);
8219 internal(ios);
8220 {
8221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8222 std::string ex(str, iter.base());
8223 assert(ex == "+******0.0000000000000000");
8224 assert(ios.width() == 0);
8225 }
8226 }
8227 ios.imbue(lg);
8228 {
8229 ios.width(0);
8230 {
8231 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8232 std::string ex(str, iter.base());
8233 assert(ex == "+0;0000000000000000");
8234 assert(ios.width() == 0);
8235 }
8236 ios.width(25);
8237 left(ios);
8238 {
8239 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8240 std::string ex(str, iter.base());
8241 assert(ex == "+0;0000000000000000******");
8242 assert(ios.width() == 0);
8243 }
8244 ios.width(25);
8245 right(ios);
8246 {
8247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8248 std::string ex(str, iter.base());
8249 assert(ex == "******+0;0000000000000000");
8250 assert(ios.width() == 0);
8251 }
8252 ios.width(25);
8253 internal(ios);
8254 {
8255 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8256 std::string ex(str, iter.base());
8257 assert(ex == "+******0;0000000000000000");
8258 assert(ios.width() == 0);
8259 }
8260 }
8261 }
8262 showpoint(ios);
8263 {
8264 ios.imbue(lc);
8265 {
8266 ios.width(0);
8267 {
8268 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8269 std::string ex(str, iter.base());
8270 assert(ex == "+0.0000000000000000");
8271 assert(ios.width() == 0);
8272 }
8273 ios.width(25);
8274 left(ios);
8275 {
8276 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8277 std::string ex(str, iter.base());
8278 assert(ex == "+0.0000000000000000******");
8279 assert(ios.width() == 0);
8280 }
8281 ios.width(25);
8282 right(ios);
8283 {
8284 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8285 std::string ex(str, iter.base());
8286 assert(ex == "******+0.0000000000000000");
8287 assert(ios.width() == 0);
8288 }
8289 ios.width(25);
8290 internal(ios);
8291 {
8292 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8293 std::string ex(str, iter.base());
8294 assert(ex == "+******0.0000000000000000");
8295 assert(ios.width() == 0);
8296 }
8297 }
8298 ios.imbue(lg);
8299 {
8300 ios.width(0);
8301 {
8302 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8303 std::string ex(str, iter.base());
8304 assert(ex == "+0;0000000000000000");
8305 assert(ios.width() == 0);
8306 }
8307 ios.width(25);
8308 left(ios);
8309 {
8310 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8311 std::string ex(str, iter.base());
8312 assert(ex == "+0;0000000000000000******");
8313 assert(ios.width() == 0);
8314 }
8315 ios.width(25);
8316 right(ios);
8317 {
8318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8319 std::string ex(str, iter.base());
8320 assert(ex == "******+0;0000000000000000");
8321 assert(ios.width() == 0);
8322 }
8323 ios.width(25);
8324 internal(ios);
8325 {
8326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8327 std::string ex(str, iter.base());
8328 assert(ex == "+******0;0000000000000000");
8329 assert(ios.width() == 0);
8330 }
8331 }
8332 }
8333 }
8334 }
8335 }
8336 ios.precision(60);
8337 {
8338 nouppercase(ios);
8339 {
8340 noshowpos(ios);
8341 {
8342 noshowpoint(ios);
8343 {
8344 ios.imbue(lc);
8345 {
8346 ios.width(0);
8347 {
8348 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8349 std::string ex(str, iter.base());
8350 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8351 assert(ios.width() == 0);
8352 }
8353 ios.width(25);
8354 left(ios);
8355 {
8356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8357 std::string ex(str, iter.base());
8358 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8359 assert(ios.width() == 0);
8360 }
8361 ios.width(25);
8362 right(ios);
8363 {
8364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8365 std::string ex(str, iter.base());
8366 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8367 assert(ios.width() == 0);
8368 }
8369 ios.width(25);
8370 internal(ios);
8371 {
8372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8373 std::string ex(str, iter.base());
8374 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8375 assert(ios.width() == 0);
8376 }
8377 }
8378 ios.imbue(lg);
8379 {
8380 ios.width(0);
8381 {
8382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8383 std::string ex(str, iter.base());
8384 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8385 assert(ios.width() == 0);
8386 }
8387 ios.width(25);
8388 left(ios);
8389 {
8390 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8391 std::string ex(str, iter.base());
8392 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8393 assert(ios.width() == 0);
8394 }
8395 ios.width(25);
8396 right(ios);
8397 {
8398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8399 std::string ex(str, iter.base());
8400 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8401 assert(ios.width() == 0);
8402 }
8403 ios.width(25);
8404 internal(ios);
8405 {
8406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8407 std::string ex(str, iter.base());
8408 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8409 assert(ios.width() == 0);
8410 }
8411 }
8412 }
8413 showpoint(ios);
8414 {
8415 ios.imbue(lc);
8416 {
8417 ios.width(0);
8418 {
8419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8420 std::string ex(str, iter.base());
8421 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8422 assert(ios.width() == 0);
8423 }
8424 ios.width(25);
8425 left(ios);
8426 {
8427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8428 std::string ex(str, iter.base());
8429 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8430 assert(ios.width() == 0);
8431 }
8432 ios.width(25);
8433 right(ios);
8434 {
8435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8436 std::string ex(str, iter.base());
8437 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8438 assert(ios.width() == 0);
8439 }
8440 ios.width(25);
8441 internal(ios);
8442 {
8443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8444 std::string ex(str, iter.base());
8445 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8446 assert(ios.width() == 0);
8447 }
8448 }
8449 ios.imbue(lg);
8450 {
8451 ios.width(0);
8452 {
8453 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8454 std::string ex(str, iter.base());
8455 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8456 assert(ios.width() == 0);
8457 }
8458 ios.width(25);
8459 left(ios);
8460 {
8461 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8462 std::string ex(str, iter.base());
8463 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8464 assert(ios.width() == 0);
8465 }
8466 ios.width(25);
8467 right(ios);
8468 {
8469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8470 std::string ex(str, iter.base());
8471 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8472 assert(ios.width() == 0);
8473 }
8474 ios.width(25);
8475 internal(ios);
8476 {
8477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8478 std::string ex(str, iter.base());
8479 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8480 assert(ios.width() == 0);
8481 }
8482 }
8483 }
8484 }
8485 showpos(ios);
8486 {
8487 noshowpoint(ios);
8488 {
8489 ios.imbue(lc);
8490 {
8491 ios.width(0);
8492 {
8493 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8494 std::string ex(str, iter.base());
8495 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8496 assert(ios.width() == 0);
8497 }
8498 ios.width(25);
8499 left(ios);
8500 {
8501 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8502 std::string ex(str, iter.base());
8503 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8504 assert(ios.width() == 0);
8505 }
8506 ios.width(25);
8507 right(ios);
8508 {
8509 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8510 std::string ex(str, iter.base());
8511 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8512 assert(ios.width() == 0);
8513 }
8514 ios.width(25);
8515 internal(ios);
8516 {
8517 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8518 std::string ex(str, iter.base());
8519 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8520 assert(ios.width() == 0);
8521 }
8522 }
8523 ios.imbue(lg);
8524 {
8525 ios.width(0);
8526 {
8527 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8528 std::string ex(str, iter.base());
8529 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8530 assert(ios.width() == 0);
8531 }
8532 ios.width(25);
8533 left(ios);
8534 {
8535 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8536 std::string ex(str, iter.base());
8537 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8538 assert(ios.width() == 0);
8539 }
8540 ios.width(25);
8541 right(ios);
8542 {
8543 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8544 std::string ex(str, iter.base());
8545 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8546 assert(ios.width() == 0);
8547 }
8548 ios.width(25);
8549 internal(ios);
8550 {
8551 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8552 std::string ex(str, iter.base());
8553 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8554 assert(ios.width() == 0);
8555 }
8556 }
8557 }
8558 showpoint(ios);
8559 {
8560 ios.imbue(lc);
8561 {
8562 ios.width(0);
8563 {
8564 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8565 std::string ex(str, iter.base());
8566 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8567 assert(ios.width() == 0);
8568 }
8569 ios.width(25);
8570 left(ios);
8571 {
8572 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8573 std::string ex(str, iter.base());
8574 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8575 assert(ios.width() == 0);
8576 }
8577 ios.width(25);
8578 right(ios);
8579 {
8580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8581 std::string ex(str, iter.base());
8582 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8583 assert(ios.width() == 0);
8584 }
8585 ios.width(25);
8586 internal(ios);
8587 {
8588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8589 std::string ex(str, iter.base());
8590 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8591 assert(ios.width() == 0);
8592 }
8593 }
8594 ios.imbue(lg);
8595 {
8596 ios.width(0);
8597 {
8598 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8599 std::string ex(str, iter.base());
8600 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8601 assert(ios.width() == 0);
8602 }
8603 ios.width(25);
8604 left(ios);
8605 {
8606 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8607 std::string ex(str, iter.base());
8608 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8609 assert(ios.width() == 0);
8610 }
8611 ios.width(25);
8612 right(ios);
8613 {
8614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8615 std::string ex(str, iter.base());
8616 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8617 assert(ios.width() == 0);
8618 }
8619 ios.width(25);
8620 internal(ios);
8621 {
8622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8623 std::string ex(str, iter.base());
8624 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8625 assert(ios.width() == 0);
8626 }
8627 }
8628 }
8629 }
8630 }
8631 uppercase(ios);
8632 {
8633 noshowpos(ios);
8634 {
8635 noshowpoint(ios);
8636 {
8637 ios.imbue(lc);
8638 {
8639 ios.width(0);
8640 {
8641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8642 std::string ex(str, iter.base());
8643 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8644 assert(ios.width() == 0);
8645 }
8646 ios.width(25);
8647 left(ios);
8648 {
8649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8650 std::string ex(str, iter.base());
8651 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8652 assert(ios.width() == 0);
8653 }
8654 ios.width(25);
8655 right(ios);
8656 {
8657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8658 std::string ex(str, iter.base());
8659 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8660 assert(ios.width() == 0);
8661 }
8662 ios.width(25);
8663 internal(ios);
8664 {
8665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8666 std::string ex(str, iter.base());
8667 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8668 assert(ios.width() == 0);
8669 }
8670 }
8671 ios.imbue(lg);
8672 {
8673 ios.width(0);
8674 {
8675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8676 std::string ex(str, iter.base());
8677 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8678 assert(ios.width() == 0);
8679 }
8680 ios.width(25);
8681 left(ios);
8682 {
8683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8684 std::string ex(str, iter.base());
8685 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8686 assert(ios.width() == 0);
8687 }
8688 ios.width(25);
8689 right(ios);
8690 {
8691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8692 std::string ex(str, iter.base());
8693 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8694 assert(ios.width() == 0);
8695 }
8696 ios.width(25);
8697 internal(ios);
8698 {
8699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8700 std::string ex(str, iter.base());
8701 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8702 assert(ios.width() == 0);
8703 }
8704 }
8705 }
8706 showpoint(ios);
8707 {
8708 ios.imbue(lc);
8709 {
8710 ios.width(0);
8711 {
8712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8713 std::string ex(str, iter.base());
8714 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8715 assert(ios.width() == 0);
8716 }
8717 ios.width(25);
8718 left(ios);
8719 {
8720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8721 std::string ex(str, iter.base());
8722 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8723 assert(ios.width() == 0);
8724 }
8725 ios.width(25);
8726 right(ios);
8727 {
8728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8729 std::string ex(str, iter.base());
8730 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8731 assert(ios.width() == 0);
8732 }
8733 ios.width(25);
8734 internal(ios);
8735 {
8736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8737 std::string ex(str, iter.base());
8738 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
8739 assert(ios.width() == 0);
8740 }
8741 }
8742 ios.imbue(lg);
8743 {
8744 ios.width(0);
8745 {
8746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8747 std::string ex(str, iter.base());
8748 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8749 assert(ios.width() == 0);
8750 }
8751 ios.width(25);
8752 left(ios);
8753 {
8754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8755 std::string ex(str, iter.base());
8756 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8757 assert(ios.width() == 0);
8758 }
8759 ios.width(25);
8760 right(ios);
8761 {
8762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8763 std::string ex(str, iter.base());
8764 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8765 assert(ios.width() == 0);
8766 }
8767 ios.width(25);
8768 internal(ios);
8769 {
8770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8771 std::string ex(str, iter.base());
8772 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
8773 assert(ios.width() == 0);
8774 }
8775 }
8776 }
8777 }
8778 showpos(ios);
8779 {
8780 noshowpoint(ios);
8781 {
8782 ios.imbue(lc);
8783 {
8784 ios.width(0);
8785 {
8786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8787 std::string ex(str, iter.base());
8788 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8789 assert(ios.width() == 0);
8790 }
8791 ios.width(25);
8792 left(ios);
8793 {
8794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8795 std::string ex(str, iter.base());
8796 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8797 assert(ios.width() == 0);
8798 }
8799 ios.width(25);
8800 right(ios);
8801 {
8802 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8803 std::string ex(str, iter.base());
8804 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8805 assert(ios.width() == 0);
8806 }
8807 ios.width(25);
8808 internal(ios);
8809 {
8810 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8811 std::string ex(str, iter.base());
8812 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8813 assert(ios.width() == 0);
8814 }
8815 }
8816 ios.imbue(lg);
8817 {
8818 ios.width(0);
8819 {
8820 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8821 std::string ex(str, iter.base());
8822 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8823 assert(ios.width() == 0);
8824 }
8825 ios.width(25);
8826 left(ios);
8827 {
8828 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8829 std::string ex(str, iter.base());
8830 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8831 assert(ios.width() == 0);
8832 }
8833 ios.width(25);
8834 right(ios);
8835 {
8836 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8837 std::string ex(str, iter.base());
8838 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8839 assert(ios.width() == 0);
8840 }
8841 ios.width(25);
8842 internal(ios);
8843 {
8844 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8845 std::string ex(str, iter.base());
8846 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8847 assert(ios.width() == 0);
8848 }
8849 }
8850 }
8851 showpoint(ios);
8852 {
8853 ios.imbue(lc);
8854 {
8855 ios.width(0);
8856 {
8857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8858 std::string ex(str, iter.base());
8859 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8860 assert(ios.width() == 0);
8861 }
8862 ios.width(25);
8863 left(ios);
8864 {
8865 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8866 std::string ex(str, iter.base());
8867 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8868 assert(ios.width() == 0);
8869 }
8870 ios.width(25);
8871 right(ios);
8872 {
8873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8874 std::string ex(str, iter.base());
8875 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8876 assert(ios.width() == 0);
8877 }
8878 ios.width(25);
8879 internal(ios);
8880 {
8881 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8882 std::string ex(str, iter.base());
8883 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
8884 assert(ios.width() == 0);
8885 }
8886 }
8887 ios.imbue(lg);
8888 {
8889 ios.width(0);
8890 {
8891 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8892 std::string ex(str, iter.base());
8893 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8894 assert(ios.width() == 0);
8895 }
8896 ios.width(25);
8897 left(ios);
8898 {
8899 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8900 std::string ex(str, iter.base());
8901 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8902 assert(ios.width() == 0);
8903 }
8904 ios.width(25);
8905 right(ios);
8906 {
8907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8908 std::string ex(str, iter.base());
8909 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8910 assert(ios.width() == 0);
8911 }
8912 ios.width(25);
8913 internal(ios);
8914 {
8915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8916 std::string ex(str, iter.base());
8917 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
8918 assert(ios.width() == 0);
8919 }
8920 }
8921 }
8922 }
8923 }
8924 }
8925 }
8926 }
8927 }
8928
test4()8929 void test4()
8930 {
8931 char str[200];
8932 output_iterator<char*> iter;
8933 std::locale lc = std::locale::classic();
8934 std::locale lg(lc, new my_numpunct);
8935 const my_facet f(1);
8936 {
8937 double v = 1234567890.125;
8938 std::ios ios(0);
8939 fixed(ios);
8940 // %f
8941 {
8942 ios.precision(0);
8943 {
8944 nouppercase(ios);
8945 {
8946 noshowpos(ios);
8947 {
8948 noshowpoint(ios);
8949 {
8950 ios.imbue(lc);
8951 {
8952 ios.width(0);
8953 {
8954 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8955 std::string ex(str, iter.base());
8956 assert(ex == "1234567890");
8957 assert(ios.width() == 0);
8958 }
8959 ios.width(25);
8960 left(ios);
8961 {
8962 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8963 std::string ex(str, iter.base());
8964 assert(ex == "1234567890***************");
8965 assert(ios.width() == 0);
8966 }
8967 ios.width(25);
8968 right(ios);
8969 {
8970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8971 std::string ex(str, iter.base());
8972 assert(ex == "***************1234567890");
8973 assert(ios.width() == 0);
8974 }
8975 ios.width(25);
8976 internal(ios);
8977 {
8978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8979 std::string ex(str, iter.base());
8980 assert(ex == "***************1234567890");
8981 assert(ios.width() == 0);
8982 }
8983 }
8984 ios.imbue(lg);
8985 {
8986 ios.width(0);
8987 {
8988 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8989 std::string ex(str, iter.base());
8990 assert(ex == "1_234_567_89_0");
8991 assert(ios.width() == 0);
8992 }
8993 ios.width(25);
8994 left(ios);
8995 {
8996 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8997 std::string ex(str, iter.base());
8998 assert(ex == "1_234_567_89_0***********");
8999 assert(ios.width() == 0);
9000 }
9001 ios.width(25);
9002 right(ios);
9003 {
9004 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9005 std::string ex(str, iter.base());
9006 assert(ex == "***********1_234_567_89_0");
9007 assert(ios.width() == 0);
9008 }
9009 ios.width(25);
9010 internal(ios);
9011 {
9012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9013 std::string ex(str, iter.base());
9014 assert(ex == "***********1_234_567_89_0");
9015 assert(ios.width() == 0);
9016 }
9017 }
9018 }
9019 showpoint(ios);
9020 {
9021 ios.imbue(lc);
9022 {
9023 ios.width(0);
9024 {
9025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9026 std::string ex(str, iter.base());
9027 assert(ex == "1234567890.");
9028 assert(ios.width() == 0);
9029 }
9030 ios.width(25);
9031 left(ios);
9032 {
9033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9034 std::string ex(str, iter.base());
9035 assert(ex == "1234567890.**************");
9036 assert(ios.width() == 0);
9037 }
9038 ios.width(25);
9039 right(ios);
9040 {
9041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9042 std::string ex(str, iter.base());
9043 assert(ex == "**************1234567890.");
9044 assert(ios.width() == 0);
9045 }
9046 ios.width(25);
9047 internal(ios);
9048 {
9049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9050 std::string ex(str, iter.base());
9051 assert(ex == "**************1234567890.");
9052 assert(ios.width() == 0);
9053 }
9054 }
9055 ios.imbue(lg);
9056 {
9057 ios.width(0);
9058 {
9059 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9060 std::string ex(str, iter.base());
9061 assert(ex == "1_234_567_89_0;");
9062 assert(ios.width() == 0);
9063 }
9064 ios.width(25);
9065 left(ios);
9066 {
9067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9068 std::string ex(str, iter.base());
9069 assert(ex == "1_234_567_89_0;**********");
9070 assert(ios.width() == 0);
9071 }
9072 ios.width(25);
9073 right(ios);
9074 {
9075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9076 std::string ex(str, iter.base());
9077 assert(ex == "**********1_234_567_89_0;");
9078 assert(ios.width() == 0);
9079 }
9080 ios.width(25);
9081 internal(ios);
9082 {
9083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9084 std::string ex(str, iter.base());
9085 assert(ex == "**********1_234_567_89_0;");
9086 assert(ios.width() == 0);
9087 }
9088 }
9089 }
9090 }
9091 showpos(ios);
9092 {
9093 noshowpoint(ios);
9094 {
9095 ios.imbue(lc);
9096 {
9097 ios.width(0);
9098 {
9099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9100 std::string ex(str, iter.base());
9101 assert(ex == "+1234567890");
9102 assert(ios.width() == 0);
9103 }
9104 ios.width(25);
9105 left(ios);
9106 {
9107 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9108 std::string ex(str, iter.base());
9109 assert(ex == "+1234567890**************");
9110 assert(ios.width() == 0);
9111 }
9112 ios.width(25);
9113 right(ios);
9114 {
9115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9116 std::string ex(str, iter.base());
9117 assert(ex == "**************+1234567890");
9118 assert(ios.width() == 0);
9119 }
9120 ios.width(25);
9121 internal(ios);
9122 {
9123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9124 std::string ex(str, iter.base());
9125 assert(ex == "+**************1234567890");
9126 assert(ios.width() == 0);
9127 }
9128 }
9129 ios.imbue(lg);
9130 {
9131 ios.width(0);
9132 {
9133 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9134 std::string ex(str, iter.base());
9135 assert(ex == "+1_234_567_89_0");
9136 assert(ios.width() == 0);
9137 }
9138 ios.width(25);
9139 left(ios);
9140 {
9141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9142 std::string ex(str, iter.base());
9143 assert(ex == "+1_234_567_89_0**********");
9144 assert(ios.width() == 0);
9145 }
9146 ios.width(25);
9147 right(ios);
9148 {
9149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9150 std::string ex(str, iter.base());
9151 assert(ex == "**********+1_234_567_89_0");
9152 assert(ios.width() == 0);
9153 }
9154 ios.width(25);
9155 internal(ios);
9156 {
9157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9158 std::string ex(str, iter.base());
9159 assert(ex == "+**********1_234_567_89_0");
9160 assert(ios.width() == 0);
9161 }
9162 }
9163 }
9164 showpoint(ios);
9165 {
9166 ios.imbue(lc);
9167 {
9168 ios.width(0);
9169 {
9170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9171 std::string ex(str, iter.base());
9172 assert(ex == "+1234567890.");
9173 assert(ios.width() == 0);
9174 }
9175 ios.width(25);
9176 left(ios);
9177 {
9178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9179 std::string ex(str, iter.base());
9180 assert(ex == "+1234567890.*************");
9181 assert(ios.width() == 0);
9182 }
9183 ios.width(25);
9184 right(ios);
9185 {
9186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9187 std::string ex(str, iter.base());
9188 assert(ex == "*************+1234567890.");
9189 assert(ios.width() == 0);
9190 }
9191 ios.width(25);
9192 internal(ios);
9193 {
9194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9195 std::string ex(str, iter.base());
9196 assert(ex == "+*************1234567890.");
9197 assert(ios.width() == 0);
9198 }
9199 }
9200 ios.imbue(lg);
9201 {
9202 ios.width(0);
9203 {
9204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9205 std::string ex(str, iter.base());
9206 assert(ex == "+1_234_567_89_0;");
9207 assert(ios.width() == 0);
9208 }
9209 ios.width(25);
9210 left(ios);
9211 {
9212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9213 std::string ex(str, iter.base());
9214 assert(ex == "+1_234_567_89_0;*********");
9215 assert(ios.width() == 0);
9216 }
9217 ios.width(25);
9218 right(ios);
9219 {
9220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9221 std::string ex(str, iter.base());
9222 assert(ex == "*********+1_234_567_89_0;");
9223 assert(ios.width() == 0);
9224 }
9225 ios.width(25);
9226 internal(ios);
9227 {
9228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9229 std::string ex(str, iter.base());
9230 assert(ex == "+*********1_234_567_89_0;");
9231 assert(ios.width() == 0);
9232 }
9233 }
9234 }
9235 }
9236 }
9237 uppercase(ios);
9238 {
9239 noshowpos(ios);
9240 {
9241 noshowpoint(ios);
9242 {
9243 ios.imbue(lc);
9244 {
9245 ios.width(0);
9246 {
9247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9248 std::string ex(str, iter.base());
9249 assert(ex == "1234567890");
9250 assert(ios.width() == 0);
9251 }
9252 ios.width(25);
9253 left(ios);
9254 {
9255 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9256 std::string ex(str, iter.base());
9257 assert(ex == "1234567890***************");
9258 assert(ios.width() == 0);
9259 }
9260 ios.width(25);
9261 right(ios);
9262 {
9263 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9264 std::string ex(str, iter.base());
9265 assert(ex == "***************1234567890");
9266 assert(ios.width() == 0);
9267 }
9268 ios.width(25);
9269 internal(ios);
9270 {
9271 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9272 std::string ex(str, iter.base());
9273 assert(ex == "***************1234567890");
9274 assert(ios.width() == 0);
9275 }
9276 }
9277 ios.imbue(lg);
9278 {
9279 ios.width(0);
9280 {
9281 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9282 std::string ex(str, iter.base());
9283 assert(ex == "1_234_567_89_0");
9284 assert(ios.width() == 0);
9285 }
9286 ios.width(25);
9287 left(ios);
9288 {
9289 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9290 std::string ex(str, iter.base());
9291 assert(ex == "1_234_567_89_0***********");
9292 assert(ios.width() == 0);
9293 }
9294 ios.width(25);
9295 right(ios);
9296 {
9297 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9298 std::string ex(str, iter.base());
9299 assert(ex == "***********1_234_567_89_0");
9300 assert(ios.width() == 0);
9301 }
9302 ios.width(25);
9303 internal(ios);
9304 {
9305 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9306 std::string ex(str, iter.base());
9307 assert(ex == "***********1_234_567_89_0");
9308 assert(ios.width() == 0);
9309 }
9310 }
9311 }
9312 showpoint(ios);
9313 {
9314 ios.imbue(lc);
9315 {
9316 ios.width(0);
9317 {
9318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9319 std::string ex(str, iter.base());
9320 assert(ex == "1234567890.");
9321 assert(ios.width() == 0);
9322 }
9323 ios.width(25);
9324 left(ios);
9325 {
9326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9327 std::string ex(str, iter.base());
9328 assert(ex == "1234567890.**************");
9329 assert(ios.width() == 0);
9330 }
9331 ios.width(25);
9332 right(ios);
9333 {
9334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9335 std::string ex(str, iter.base());
9336 assert(ex == "**************1234567890.");
9337 assert(ios.width() == 0);
9338 }
9339 ios.width(25);
9340 internal(ios);
9341 {
9342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9343 std::string ex(str, iter.base());
9344 assert(ex == "**************1234567890.");
9345 assert(ios.width() == 0);
9346 }
9347 }
9348 ios.imbue(lg);
9349 {
9350 ios.width(0);
9351 {
9352 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9353 std::string ex(str, iter.base());
9354 assert(ex == "1_234_567_89_0;");
9355 assert(ios.width() == 0);
9356 }
9357 ios.width(25);
9358 left(ios);
9359 {
9360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9361 std::string ex(str, iter.base());
9362 assert(ex == "1_234_567_89_0;**********");
9363 assert(ios.width() == 0);
9364 }
9365 ios.width(25);
9366 right(ios);
9367 {
9368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9369 std::string ex(str, iter.base());
9370 assert(ex == "**********1_234_567_89_0;");
9371 assert(ios.width() == 0);
9372 }
9373 ios.width(25);
9374 internal(ios);
9375 {
9376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9377 std::string ex(str, iter.base());
9378 assert(ex == "**********1_234_567_89_0;");
9379 assert(ios.width() == 0);
9380 }
9381 }
9382 }
9383 }
9384 showpos(ios);
9385 {
9386 noshowpoint(ios);
9387 {
9388 ios.imbue(lc);
9389 {
9390 ios.width(0);
9391 {
9392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9393 std::string ex(str, iter.base());
9394 assert(ex == "+1234567890");
9395 assert(ios.width() == 0);
9396 }
9397 ios.width(25);
9398 left(ios);
9399 {
9400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9401 std::string ex(str, iter.base());
9402 assert(ex == "+1234567890**************");
9403 assert(ios.width() == 0);
9404 }
9405 ios.width(25);
9406 right(ios);
9407 {
9408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9409 std::string ex(str, iter.base());
9410 assert(ex == "**************+1234567890");
9411 assert(ios.width() == 0);
9412 }
9413 ios.width(25);
9414 internal(ios);
9415 {
9416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9417 std::string ex(str, iter.base());
9418 assert(ex == "+**************1234567890");
9419 assert(ios.width() == 0);
9420 }
9421 }
9422 ios.imbue(lg);
9423 {
9424 ios.width(0);
9425 {
9426 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9427 std::string ex(str, iter.base());
9428 assert(ex == "+1_234_567_89_0");
9429 assert(ios.width() == 0);
9430 }
9431 ios.width(25);
9432 left(ios);
9433 {
9434 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9435 std::string ex(str, iter.base());
9436 assert(ex == "+1_234_567_89_0**********");
9437 assert(ios.width() == 0);
9438 }
9439 ios.width(25);
9440 right(ios);
9441 {
9442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9443 std::string ex(str, iter.base());
9444 assert(ex == "**********+1_234_567_89_0");
9445 assert(ios.width() == 0);
9446 }
9447 ios.width(25);
9448 internal(ios);
9449 {
9450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9451 std::string ex(str, iter.base());
9452 assert(ex == "+**********1_234_567_89_0");
9453 assert(ios.width() == 0);
9454 }
9455 }
9456 }
9457 showpoint(ios);
9458 {
9459 ios.imbue(lc);
9460 {
9461 ios.width(0);
9462 {
9463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9464 std::string ex(str, iter.base());
9465 assert(ex == "+1234567890.");
9466 assert(ios.width() == 0);
9467 }
9468 ios.width(25);
9469 left(ios);
9470 {
9471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9472 std::string ex(str, iter.base());
9473 assert(ex == "+1234567890.*************");
9474 assert(ios.width() == 0);
9475 }
9476 ios.width(25);
9477 right(ios);
9478 {
9479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9480 std::string ex(str, iter.base());
9481 assert(ex == "*************+1234567890.");
9482 assert(ios.width() == 0);
9483 }
9484 ios.width(25);
9485 internal(ios);
9486 {
9487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9488 std::string ex(str, iter.base());
9489 assert(ex == "+*************1234567890.");
9490 assert(ios.width() == 0);
9491 }
9492 }
9493 ios.imbue(lg);
9494 {
9495 ios.width(0);
9496 {
9497 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9498 std::string ex(str, iter.base());
9499 assert(ex == "+1_234_567_89_0;");
9500 assert(ios.width() == 0);
9501 }
9502 ios.width(25);
9503 left(ios);
9504 {
9505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9506 std::string ex(str, iter.base());
9507 assert(ex == "+1_234_567_89_0;*********");
9508 assert(ios.width() == 0);
9509 }
9510 ios.width(25);
9511 right(ios);
9512 {
9513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9514 std::string ex(str, iter.base());
9515 assert(ex == "*********+1_234_567_89_0;");
9516 assert(ios.width() == 0);
9517 }
9518 ios.width(25);
9519 internal(ios);
9520 {
9521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9522 std::string ex(str, iter.base());
9523 assert(ex == "+*********1_234_567_89_0;");
9524 assert(ios.width() == 0);
9525 }
9526 }
9527 }
9528 }
9529 }
9530 }
9531 ios.precision(1);
9532 {
9533 nouppercase(ios);
9534 {
9535 noshowpos(ios);
9536 {
9537 noshowpoint(ios);
9538 {
9539 ios.imbue(lc);
9540 {
9541 ios.width(0);
9542 {
9543 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9544 std::string ex(str, iter.base());
9545 assert(ex == "1234567890.1");
9546 assert(ios.width() == 0);
9547 }
9548 ios.width(25);
9549 left(ios);
9550 {
9551 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9552 std::string ex(str, iter.base());
9553 assert(ex == "1234567890.1*************");
9554 assert(ios.width() == 0);
9555 }
9556 ios.width(25);
9557 right(ios);
9558 {
9559 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9560 std::string ex(str, iter.base());
9561 assert(ex == "*************1234567890.1");
9562 assert(ios.width() == 0);
9563 }
9564 ios.width(25);
9565 internal(ios);
9566 {
9567 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9568 std::string ex(str, iter.base());
9569 assert(ex == "*************1234567890.1");
9570 assert(ios.width() == 0);
9571 }
9572 }
9573 ios.imbue(lg);
9574 {
9575 ios.width(0);
9576 {
9577 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9578 std::string ex(str, iter.base());
9579 assert(ex == "1_234_567_89_0;1");
9580 assert(ios.width() == 0);
9581 }
9582 ios.width(25);
9583 left(ios);
9584 {
9585 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9586 std::string ex(str, iter.base());
9587 assert(ex == "1_234_567_89_0;1*********");
9588 assert(ios.width() == 0);
9589 }
9590 ios.width(25);
9591 right(ios);
9592 {
9593 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9594 std::string ex(str, iter.base());
9595 assert(ex == "*********1_234_567_89_0;1");
9596 assert(ios.width() == 0);
9597 }
9598 ios.width(25);
9599 internal(ios);
9600 {
9601 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9602 std::string ex(str, iter.base());
9603 assert(ex == "*********1_234_567_89_0;1");
9604 assert(ios.width() == 0);
9605 }
9606 }
9607 }
9608 showpoint(ios);
9609 {
9610 ios.imbue(lc);
9611 {
9612 ios.width(0);
9613 {
9614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9615 std::string ex(str, iter.base());
9616 assert(ex == "1234567890.1");
9617 assert(ios.width() == 0);
9618 }
9619 ios.width(25);
9620 left(ios);
9621 {
9622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9623 std::string ex(str, iter.base());
9624 assert(ex == "1234567890.1*************");
9625 assert(ios.width() == 0);
9626 }
9627 ios.width(25);
9628 right(ios);
9629 {
9630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9631 std::string ex(str, iter.base());
9632 assert(ex == "*************1234567890.1");
9633 assert(ios.width() == 0);
9634 }
9635 ios.width(25);
9636 internal(ios);
9637 {
9638 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9639 std::string ex(str, iter.base());
9640 assert(ex == "*************1234567890.1");
9641 assert(ios.width() == 0);
9642 }
9643 }
9644 ios.imbue(lg);
9645 {
9646 ios.width(0);
9647 {
9648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9649 std::string ex(str, iter.base());
9650 assert(ex == "1_234_567_89_0;1");
9651 assert(ios.width() == 0);
9652 }
9653 ios.width(25);
9654 left(ios);
9655 {
9656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9657 std::string ex(str, iter.base());
9658 assert(ex == "1_234_567_89_0;1*********");
9659 assert(ios.width() == 0);
9660 }
9661 ios.width(25);
9662 right(ios);
9663 {
9664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9665 std::string ex(str, iter.base());
9666 assert(ex == "*********1_234_567_89_0;1");
9667 assert(ios.width() == 0);
9668 }
9669 ios.width(25);
9670 internal(ios);
9671 {
9672 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9673 std::string ex(str, iter.base());
9674 assert(ex == "*********1_234_567_89_0;1");
9675 assert(ios.width() == 0);
9676 }
9677 }
9678 }
9679 }
9680 showpos(ios);
9681 {
9682 noshowpoint(ios);
9683 {
9684 ios.imbue(lc);
9685 {
9686 ios.width(0);
9687 {
9688 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9689 std::string ex(str, iter.base());
9690 assert(ex == "+1234567890.1");
9691 assert(ios.width() == 0);
9692 }
9693 ios.width(25);
9694 left(ios);
9695 {
9696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9697 std::string ex(str, iter.base());
9698 assert(ex == "+1234567890.1************");
9699 assert(ios.width() == 0);
9700 }
9701 ios.width(25);
9702 right(ios);
9703 {
9704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9705 std::string ex(str, iter.base());
9706 assert(ex == "************+1234567890.1");
9707 assert(ios.width() == 0);
9708 }
9709 ios.width(25);
9710 internal(ios);
9711 {
9712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9713 std::string ex(str, iter.base());
9714 assert(ex == "+************1234567890.1");
9715 assert(ios.width() == 0);
9716 }
9717 }
9718 ios.imbue(lg);
9719 {
9720 ios.width(0);
9721 {
9722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9723 std::string ex(str, iter.base());
9724 assert(ex == "+1_234_567_89_0;1");
9725 assert(ios.width() == 0);
9726 }
9727 ios.width(25);
9728 left(ios);
9729 {
9730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9731 std::string ex(str, iter.base());
9732 assert(ex == "+1_234_567_89_0;1********");
9733 assert(ios.width() == 0);
9734 }
9735 ios.width(25);
9736 right(ios);
9737 {
9738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9739 std::string ex(str, iter.base());
9740 assert(ex == "********+1_234_567_89_0;1");
9741 assert(ios.width() == 0);
9742 }
9743 ios.width(25);
9744 internal(ios);
9745 {
9746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9747 std::string ex(str, iter.base());
9748 assert(ex == "+********1_234_567_89_0;1");
9749 assert(ios.width() == 0);
9750 }
9751 }
9752 }
9753 showpoint(ios);
9754 {
9755 ios.imbue(lc);
9756 {
9757 ios.width(0);
9758 {
9759 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9760 std::string ex(str, iter.base());
9761 assert(ex == "+1234567890.1");
9762 assert(ios.width() == 0);
9763 }
9764 ios.width(25);
9765 left(ios);
9766 {
9767 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9768 std::string ex(str, iter.base());
9769 assert(ex == "+1234567890.1************");
9770 assert(ios.width() == 0);
9771 }
9772 ios.width(25);
9773 right(ios);
9774 {
9775 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9776 std::string ex(str, iter.base());
9777 assert(ex == "************+1234567890.1");
9778 assert(ios.width() == 0);
9779 }
9780 ios.width(25);
9781 internal(ios);
9782 {
9783 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9784 std::string ex(str, iter.base());
9785 assert(ex == "+************1234567890.1");
9786 assert(ios.width() == 0);
9787 }
9788 }
9789 ios.imbue(lg);
9790 {
9791 ios.width(0);
9792 {
9793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9794 std::string ex(str, iter.base());
9795 assert(ex == "+1_234_567_89_0;1");
9796 assert(ios.width() == 0);
9797 }
9798 ios.width(25);
9799 left(ios);
9800 {
9801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9802 std::string ex(str, iter.base());
9803 assert(ex == "+1_234_567_89_0;1********");
9804 assert(ios.width() == 0);
9805 }
9806 ios.width(25);
9807 right(ios);
9808 {
9809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9810 std::string ex(str, iter.base());
9811 assert(ex == "********+1_234_567_89_0;1");
9812 assert(ios.width() == 0);
9813 }
9814 ios.width(25);
9815 internal(ios);
9816 {
9817 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9818 std::string ex(str, iter.base());
9819 assert(ex == "+********1_234_567_89_0;1");
9820 assert(ios.width() == 0);
9821 }
9822 }
9823 }
9824 }
9825 }
9826 uppercase(ios);
9827 {
9828 noshowpos(ios);
9829 {
9830 noshowpoint(ios);
9831 {
9832 ios.imbue(lc);
9833 {
9834 ios.width(0);
9835 {
9836 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9837 std::string ex(str, iter.base());
9838 assert(ex == "1234567890.1");
9839 assert(ios.width() == 0);
9840 }
9841 ios.width(25);
9842 left(ios);
9843 {
9844 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9845 std::string ex(str, iter.base());
9846 assert(ex == "1234567890.1*************");
9847 assert(ios.width() == 0);
9848 }
9849 ios.width(25);
9850 right(ios);
9851 {
9852 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9853 std::string ex(str, iter.base());
9854 assert(ex == "*************1234567890.1");
9855 assert(ios.width() == 0);
9856 }
9857 ios.width(25);
9858 internal(ios);
9859 {
9860 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9861 std::string ex(str, iter.base());
9862 assert(ex == "*************1234567890.1");
9863 assert(ios.width() == 0);
9864 }
9865 }
9866 ios.imbue(lg);
9867 {
9868 ios.width(0);
9869 {
9870 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9871 std::string ex(str, iter.base());
9872 assert(ex == "1_234_567_89_0;1");
9873 assert(ios.width() == 0);
9874 }
9875 ios.width(25);
9876 left(ios);
9877 {
9878 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9879 std::string ex(str, iter.base());
9880 assert(ex == "1_234_567_89_0;1*********");
9881 assert(ios.width() == 0);
9882 }
9883 ios.width(25);
9884 right(ios);
9885 {
9886 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9887 std::string ex(str, iter.base());
9888 assert(ex == "*********1_234_567_89_0;1");
9889 assert(ios.width() == 0);
9890 }
9891 ios.width(25);
9892 internal(ios);
9893 {
9894 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9895 std::string ex(str, iter.base());
9896 assert(ex == "*********1_234_567_89_0;1");
9897 assert(ios.width() == 0);
9898 }
9899 }
9900 }
9901 showpoint(ios);
9902 {
9903 ios.imbue(lc);
9904 {
9905 ios.width(0);
9906 {
9907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9908 std::string ex(str, iter.base());
9909 assert(ex == "1234567890.1");
9910 assert(ios.width() == 0);
9911 }
9912 ios.width(25);
9913 left(ios);
9914 {
9915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9916 std::string ex(str, iter.base());
9917 assert(ex == "1234567890.1*************");
9918 assert(ios.width() == 0);
9919 }
9920 ios.width(25);
9921 right(ios);
9922 {
9923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9924 std::string ex(str, iter.base());
9925 assert(ex == "*************1234567890.1");
9926 assert(ios.width() == 0);
9927 }
9928 ios.width(25);
9929 internal(ios);
9930 {
9931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9932 std::string ex(str, iter.base());
9933 assert(ex == "*************1234567890.1");
9934 assert(ios.width() == 0);
9935 }
9936 }
9937 ios.imbue(lg);
9938 {
9939 ios.width(0);
9940 {
9941 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9942 std::string ex(str, iter.base());
9943 assert(ex == "1_234_567_89_0;1");
9944 assert(ios.width() == 0);
9945 }
9946 ios.width(25);
9947 left(ios);
9948 {
9949 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9950 std::string ex(str, iter.base());
9951 assert(ex == "1_234_567_89_0;1*********");
9952 assert(ios.width() == 0);
9953 }
9954 ios.width(25);
9955 right(ios);
9956 {
9957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9958 std::string ex(str, iter.base());
9959 assert(ex == "*********1_234_567_89_0;1");
9960 assert(ios.width() == 0);
9961 }
9962 ios.width(25);
9963 internal(ios);
9964 {
9965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9966 std::string ex(str, iter.base());
9967 assert(ex == "*********1_234_567_89_0;1");
9968 assert(ios.width() == 0);
9969 }
9970 }
9971 }
9972 }
9973 showpos(ios);
9974 {
9975 noshowpoint(ios);
9976 {
9977 ios.imbue(lc);
9978 {
9979 ios.width(0);
9980 {
9981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9982 std::string ex(str, iter.base());
9983 assert(ex == "+1234567890.1");
9984 assert(ios.width() == 0);
9985 }
9986 ios.width(25);
9987 left(ios);
9988 {
9989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9990 std::string ex(str, iter.base());
9991 assert(ex == "+1234567890.1************");
9992 assert(ios.width() == 0);
9993 }
9994 ios.width(25);
9995 right(ios);
9996 {
9997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9998 std::string ex(str, iter.base());
9999 assert(ex == "************+1234567890.1");
10000 assert(ios.width() == 0);
10001 }
10002 ios.width(25);
10003 internal(ios);
10004 {
10005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10006 std::string ex(str, iter.base());
10007 assert(ex == "+************1234567890.1");
10008 assert(ios.width() == 0);
10009 }
10010 }
10011 ios.imbue(lg);
10012 {
10013 ios.width(0);
10014 {
10015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10016 std::string ex(str, iter.base());
10017 assert(ex == "+1_234_567_89_0;1");
10018 assert(ios.width() == 0);
10019 }
10020 ios.width(25);
10021 left(ios);
10022 {
10023 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10024 std::string ex(str, iter.base());
10025 assert(ex == "+1_234_567_89_0;1********");
10026 assert(ios.width() == 0);
10027 }
10028 ios.width(25);
10029 right(ios);
10030 {
10031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10032 std::string ex(str, iter.base());
10033 assert(ex == "********+1_234_567_89_0;1");
10034 assert(ios.width() == 0);
10035 }
10036 ios.width(25);
10037 internal(ios);
10038 {
10039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10040 std::string ex(str, iter.base());
10041 assert(ex == "+********1_234_567_89_0;1");
10042 assert(ios.width() == 0);
10043 }
10044 }
10045 }
10046 showpoint(ios);
10047 {
10048 ios.imbue(lc);
10049 {
10050 ios.width(0);
10051 {
10052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10053 std::string ex(str, iter.base());
10054 assert(ex == "+1234567890.1");
10055 assert(ios.width() == 0);
10056 }
10057 ios.width(25);
10058 left(ios);
10059 {
10060 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10061 std::string ex(str, iter.base());
10062 assert(ex == "+1234567890.1************");
10063 assert(ios.width() == 0);
10064 }
10065 ios.width(25);
10066 right(ios);
10067 {
10068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10069 std::string ex(str, iter.base());
10070 assert(ex == "************+1234567890.1");
10071 assert(ios.width() == 0);
10072 }
10073 ios.width(25);
10074 internal(ios);
10075 {
10076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10077 std::string ex(str, iter.base());
10078 assert(ex == "+************1234567890.1");
10079 assert(ios.width() == 0);
10080 }
10081 }
10082 ios.imbue(lg);
10083 {
10084 ios.width(0);
10085 {
10086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10087 std::string ex(str, iter.base());
10088 assert(ex == "+1_234_567_89_0;1");
10089 assert(ios.width() == 0);
10090 }
10091 ios.width(25);
10092 left(ios);
10093 {
10094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10095 std::string ex(str, iter.base());
10096 assert(ex == "+1_234_567_89_0;1********");
10097 assert(ios.width() == 0);
10098 }
10099 ios.width(25);
10100 right(ios);
10101 {
10102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10103 std::string ex(str, iter.base());
10104 assert(ex == "********+1_234_567_89_0;1");
10105 assert(ios.width() == 0);
10106 }
10107 ios.width(25);
10108 internal(ios);
10109 {
10110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10111 std::string ex(str, iter.base());
10112 assert(ex == "+********1_234_567_89_0;1");
10113 assert(ios.width() == 0);
10114 }
10115 }
10116 }
10117 }
10118 }
10119 }
10120 ios.precision(6);
10121 {
10122 nouppercase(ios);
10123 {
10124 noshowpos(ios);
10125 {
10126 noshowpoint(ios);
10127 {
10128 ios.imbue(lc);
10129 {
10130 ios.width(0);
10131 {
10132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10133 std::string ex(str, iter.base());
10134 assert(ex == "1234567890.125000");
10135 assert(ios.width() == 0);
10136 }
10137 ios.width(25);
10138 left(ios);
10139 {
10140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10141 std::string ex(str, iter.base());
10142 assert(ex == "1234567890.125000********");
10143 assert(ios.width() == 0);
10144 }
10145 ios.width(25);
10146 right(ios);
10147 {
10148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10149 std::string ex(str, iter.base());
10150 assert(ex == "********1234567890.125000");
10151 assert(ios.width() == 0);
10152 }
10153 ios.width(25);
10154 internal(ios);
10155 {
10156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10157 std::string ex(str, iter.base());
10158 assert(ex == "********1234567890.125000");
10159 assert(ios.width() == 0);
10160 }
10161 }
10162 ios.imbue(lg);
10163 {
10164 ios.width(0);
10165 {
10166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10167 std::string ex(str, iter.base());
10168 assert(ex == "1_234_567_89_0;125000");
10169 assert(ios.width() == 0);
10170 }
10171 ios.width(25);
10172 left(ios);
10173 {
10174 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10175 std::string ex(str, iter.base());
10176 assert(ex == "1_234_567_89_0;125000****");
10177 assert(ios.width() == 0);
10178 }
10179 ios.width(25);
10180 right(ios);
10181 {
10182 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10183 std::string ex(str, iter.base());
10184 assert(ex == "****1_234_567_89_0;125000");
10185 assert(ios.width() == 0);
10186 }
10187 ios.width(25);
10188 internal(ios);
10189 {
10190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10191 std::string ex(str, iter.base());
10192 assert(ex == "****1_234_567_89_0;125000");
10193 assert(ios.width() == 0);
10194 }
10195 }
10196 }
10197 showpoint(ios);
10198 {
10199 ios.imbue(lc);
10200 {
10201 ios.width(0);
10202 {
10203 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10204 std::string ex(str, iter.base());
10205 assert(ex == "1234567890.125000");
10206 assert(ios.width() == 0);
10207 }
10208 ios.width(25);
10209 left(ios);
10210 {
10211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10212 std::string ex(str, iter.base());
10213 assert(ex == "1234567890.125000********");
10214 assert(ios.width() == 0);
10215 }
10216 ios.width(25);
10217 right(ios);
10218 {
10219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10220 std::string ex(str, iter.base());
10221 assert(ex == "********1234567890.125000");
10222 assert(ios.width() == 0);
10223 }
10224 ios.width(25);
10225 internal(ios);
10226 {
10227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10228 std::string ex(str, iter.base());
10229 assert(ex == "********1234567890.125000");
10230 assert(ios.width() == 0);
10231 }
10232 }
10233 ios.imbue(lg);
10234 {
10235 ios.width(0);
10236 {
10237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10238 std::string ex(str, iter.base());
10239 assert(ex == "1_234_567_89_0;125000");
10240 assert(ios.width() == 0);
10241 }
10242 ios.width(25);
10243 left(ios);
10244 {
10245 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10246 std::string ex(str, iter.base());
10247 assert(ex == "1_234_567_89_0;125000****");
10248 assert(ios.width() == 0);
10249 }
10250 ios.width(25);
10251 right(ios);
10252 {
10253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10254 std::string ex(str, iter.base());
10255 assert(ex == "****1_234_567_89_0;125000");
10256 assert(ios.width() == 0);
10257 }
10258 ios.width(25);
10259 internal(ios);
10260 {
10261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10262 std::string ex(str, iter.base());
10263 assert(ex == "****1_234_567_89_0;125000");
10264 assert(ios.width() == 0);
10265 }
10266 }
10267 }
10268 }
10269 showpos(ios);
10270 {
10271 noshowpoint(ios);
10272 {
10273 ios.imbue(lc);
10274 {
10275 ios.width(0);
10276 {
10277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10278 std::string ex(str, iter.base());
10279 assert(ex == "+1234567890.125000");
10280 assert(ios.width() == 0);
10281 }
10282 ios.width(25);
10283 left(ios);
10284 {
10285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10286 std::string ex(str, iter.base());
10287 assert(ex == "+1234567890.125000*******");
10288 assert(ios.width() == 0);
10289 }
10290 ios.width(25);
10291 right(ios);
10292 {
10293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10294 std::string ex(str, iter.base());
10295 assert(ex == "*******+1234567890.125000");
10296 assert(ios.width() == 0);
10297 }
10298 ios.width(25);
10299 internal(ios);
10300 {
10301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10302 std::string ex(str, iter.base());
10303 assert(ex == "+*******1234567890.125000");
10304 assert(ios.width() == 0);
10305 }
10306 }
10307 ios.imbue(lg);
10308 {
10309 ios.width(0);
10310 {
10311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10312 std::string ex(str, iter.base());
10313 assert(ex == "+1_234_567_89_0;125000");
10314 assert(ios.width() == 0);
10315 }
10316 ios.width(25);
10317 left(ios);
10318 {
10319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10320 std::string ex(str, iter.base());
10321 assert(ex == "+1_234_567_89_0;125000***");
10322 assert(ios.width() == 0);
10323 }
10324 ios.width(25);
10325 right(ios);
10326 {
10327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10328 std::string ex(str, iter.base());
10329 assert(ex == "***+1_234_567_89_0;125000");
10330 assert(ios.width() == 0);
10331 }
10332 ios.width(25);
10333 internal(ios);
10334 {
10335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10336 std::string ex(str, iter.base());
10337 assert(ex == "+***1_234_567_89_0;125000");
10338 assert(ios.width() == 0);
10339 }
10340 }
10341 }
10342 showpoint(ios);
10343 {
10344 ios.imbue(lc);
10345 {
10346 ios.width(0);
10347 {
10348 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10349 std::string ex(str, iter.base());
10350 assert(ex == "+1234567890.125000");
10351 assert(ios.width() == 0);
10352 }
10353 ios.width(25);
10354 left(ios);
10355 {
10356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10357 std::string ex(str, iter.base());
10358 assert(ex == "+1234567890.125000*******");
10359 assert(ios.width() == 0);
10360 }
10361 ios.width(25);
10362 right(ios);
10363 {
10364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10365 std::string ex(str, iter.base());
10366 assert(ex == "*******+1234567890.125000");
10367 assert(ios.width() == 0);
10368 }
10369 ios.width(25);
10370 internal(ios);
10371 {
10372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10373 std::string ex(str, iter.base());
10374 assert(ex == "+*******1234567890.125000");
10375 assert(ios.width() == 0);
10376 }
10377 }
10378 ios.imbue(lg);
10379 {
10380 ios.width(0);
10381 {
10382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10383 std::string ex(str, iter.base());
10384 assert(ex == "+1_234_567_89_0;125000");
10385 assert(ios.width() == 0);
10386 }
10387 ios.width(25);
10388 left(ios);
10389 {
10390 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10391 std::string ex(str, iter.base());
10392 assert(ex == "+1_234_567_89_0;125000***");
10393 assert(ios.width() == 0);
10394 }
10395 ios.width(25);
10396 right(ios);
10397 {
10398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10399 std::string ex(str, iter.base());
10400 assert(ex == "***+1_234_567_89_0;125000");
10401 assert(ios.width() == 0);
10402 }
10403 ios.width(25);
10404 internal(ios);
10405 {
10406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10407 std::string ex(str, iter.base());
10408 assert(ex == "+***1_234_567_89_0;125000");
10409 assert(ios.width() == 0);
10410 }
10411 }
10412 }
10413 }
10414 }
10415 uppercase(ios);
10416 {
10417 noshowpos(ios);
10418 {
10419 noshowpoint(ios);
10420 {
10421 ios.imbue(lc);
10422 {
10423 ios.width(0);
10424 {
10425 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10426 std::string ex(str, iter.base());
10427 assert(ex == "1234567890.125000");
10428 assert(ios.width() == 0);
10429 }
10430 ios.width(25);
10431 left(ios);
10432 {
10433 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10434 std::string ex(str, iter.base());
10435 assert(ex == "1234567890.125000********");
10436 assert(ios.width() == 0);
10437 }
10438 ios.width(25);
10439 right(ios);
10440 {
10441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10442 std::string ex(str, iter.base());
10443 assert(ex == "********1234567890.125000");
10444 assert(ios.width() == 0);
10445 }
10446 ios.width(25);
10447 internal(ios);
10448 {
10449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10450 std::string ex(str, iter.base());
10451 assert(ex == "********1234567890.125000");
10452 assert(ios.width() == 0);
10453 }
10454 }
10455 ios.imbue(lg);
10456 {
10457 ios.width(0);
10458 {
10459 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10460 std::string ex(str, iter.base());
10461 assert(ex == "1_234_567_89_0;125000");
10462 assert(ios.width() == 0);
10463 }
10464 ios.width(25);
10465 left(ios);
10466 {
10467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10468 std::string ex(str, iter.base());
10469 assert(ex == "1_234_567_89_0;125000****");
10470 assert(ios.width() == 0);
10471 }
10472 ios.width(25);
10473 right(ios);
10474 {
10475 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10476 std::string ex(str, iter.base());
10477 assert(ex == "****1_234_567_89_0;125000");
10478 assert(ios.width() == 0);
10479 }
10480 ios.width(25);
10481 internal(ios);
10482 {
10483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10484 std::string ex(str, iter.base());
10485 assert(ex == "****1_234_567_89_0;125000");
10486 assert(ios.width() == 0);
10487 }
10488 }
10489 }
10490 showpoint(ios);
10491 {
10492 ios.imbue(lc);
10493 {
10494 ios.width(0);
10495 {
10496 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10497 std::string ex(str, iter.base());
10498 assert(ex == "1234567890.125000");
10499 assert(ios.width() == 0);
10500 }
10501 ios.width(25);
10502 left(ios);
10503 {
10504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10505 std::string ex(str, iter.base());
10506 assert(ex == "1234567890.125000********");
10507 assert(ios.width() == 0);
10508 }
10509 ios.width(25);
10510 right(ios);
10511 {
10512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10513 std::string ex(str, iter.base());
10514 assert(ex == "********1234567890.125000");
10515 assert(ios.width() == 0);
10516 }
10517 ios.width(25);
10518 internal(ios);
10519 {
10520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10521 std::string ex(str, iter.base());
10522 assert(ex == "********1234567890.125000");
10523 assert(ios.width() == 0);
10524 }
10525 }
10526 ios.imbue(lg);
10527 {
10528 ios.width(0);
10529 {
10530 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10531 std::string ex(str, iter.base());
10532 assert(ex == "1_234_567_89_0;125000");
10533 assert(ios.width() == 0);
10534 }
10535 ios.width(25);
10536 left(ios);
10537 {
10538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10539 std::string ex(str, iter.base());
10540 assert(ex == "1_234_567_89_0;125000****");
10541 assert(ios.width() == 0);
10542 }
10543 ios.width(25);
10544 right(ios);
10545 {
10546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10547 std::string ex(str, iter.base());
10548 assert(ex == "****1_234_567_89_0;125000");
10549 assert(ios.width() == 0);
10550 }
10551 ios.width(25);
10552 internal(ios);
10553 {
10554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10555 std::string ex(str, iter.base());
10556 assert(ex == "****1_234_567_89_0;125000");
10557 assert(ios.width() == 0);
10558 }
10559 }
10560 }
10561 }
10562 showpos(ios);
10563 {
10564 noshowpoint(ios);
10565 {
10566 ios.imbue(lc);
10567 {
10568 ios.width(0);
10569 {
10570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10571 std::string ex(str, iter.base());
10572 assert(ex == "+1234567890.125000");
10573 assert(ios.width() == 0);
10574 }
10575 ios.width(25);
10576 left(ios);
10577 {
10578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10579 std::string ex(str, iter.base());
10580 assert(ex == "+1234567890.125000*******");
10581 assert(ios.width() == 0);
10582 }
10583 ios.width(25);
10584 right(ios);
10585 {
10586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10587 std::string ex(str, iter.base());
10588 assert(ex == "*******+1234567890.125000");
10589 assert(ios.width() == 0);
10590 }
10591 ios.width(25);
10592 internal(ios);
10593 {
10594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10595 std::string ex(str, iter.base());
10596 assert(ex == "+*******1234567890.125000");
10597 assert(ios.width() == 0);
10598 }
10599 }
10600 ios.imbue(lg);
10601 {
10602 ios.width(0);
10603 {
10604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10605 std::string ex(str, iter.base());
10606 assert(ex == "+1_234_567_89_0;125000");
10607 assert(ios.width() == 0);
10608 }
10609 ios.width(25);
10610 left(ios);
10611 {
10612 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10613 std::string ex(str, iter.base());
10614 assert(ex == "+1_234_567_89_0;125000***");
10615 assert(ios.width() == 0);
10616 }
10617 ios.width(25);
10618 right(ios);
10619 {
10620 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10621 std::string ex(str, iter.base());
10622 assert(ex == "***+1_234_567_89_0;125000");
10623 assert(ios.width() == 0);
10624 }
10625 ios.width(25);
10626 internal(ios);
10627 {
10628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10629 std::string ex(str, iter.base());
10630 assert(ex == "+***1_234_567_89_0;125000");
10631 assert(ios.width() == 0);
10632 }
10633 }
10634 }
10635 showpoint(ios);
10636 {
10637 ios.imbue(lc);
10638 {
10639 ios.width(0);
10640 {
10641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10642 std::string ex(str, iter.base());
10643 assert(ex == "+1234567890.125000");
10644 assert(ios.width() == 0);
10645 }
10646 ios.width(25);
10647 left(ios);
10648 {
10649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10650 std::string ex(str, iter.base());
10651 assert(ex == "+1234567890.125000*******");
10652 assert(ios.width() == 0);
10653 }
10654 ios.width(25);
10655 right(ios);
10656 {
10657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10658 std::string ex(str, iter.base());
10659 assert(ex == "*******+1234567890.125000");
10660 assert(ios.width() == 0);
10661 }
10662 ios.width(25);
10663 internal(ios);
10664 {
10665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10666 std::string ex(str, iter.base());
10667 assert(ex == "+*******1234567890.125000");
10668 assert(ios.width() == 0);
10669 }
10670 }
10671 ios.imbue(lg);
10672 {
10673 ios.width(0);
10674 {
10675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10676 std::string ex(str, iter.base());
10677 assert(ex == "+1_234_567_89_0;125000");
10678 assert(ios.width() == 0);
10679 }
10680 ios.width(25);
10681 left(ios);
10682 {
10683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10684 std::string ex(str, iter.base());
10685 assert(ex == "+1_234_567_89_0;125000***");
10686 assert(ios.width() == 0);
10687 }
10688 ios.width(25);
10689 right(ios);
10690 {
10691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10692 std::string ex(str, iter.base());
10693 assert(ex == "***+1_234_567_89_0;125000");
10694 assert(ios.width() == 0);
10695 }
10696 ios.width(25);
10697 internal(ios);
10698 {
10699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10700 std::string ex(str, iter.base());
10701 assert(ex == "+***1_234_567_89_0;125000");
10702 assert(ios.width() == 0);
10703 }
10704 }
10705 }
10706 }
10707 }
10708 }
10709 ios.precision(16);
10710 {}
10711 ios.precision(60);
10712 {}
10713 }
10714 }
10715 }
10716
test5()10717 void test5()
10718 {
10719 char str[200];
10720 output_iterator<char*> iter;
10721 std::locale lc = std::locale::classic();
10722 std::locale lg(lc, new my_numpunct);
10723 const my_facet f(1);
10724 {
10725 double v = -0.;
10726 std::ios ios(0);
10727 scientific(ios);
10728 // %e
10729 {
10730 ios.precision(0);
10731 {
10732 nouppercase(ios);
10733 {
10734 noshowpos(ios);
10735 {
10736 noshowpoint(ios);
10737 {
10738 ios.imbue(lc);
10739 {
10740 ios.width(0);
10741 {
10742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10743 std::string ex(str, iter.base());
10744 assert(ex == "-0e+00");
10745 assert(ios.width() == 0);
10746 }
10747 ios.width(25);
10748 left(ios);
10749 {
10750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10751 std::string ex(str, iter.base());
10752 assert(ex == "-0e+00*******************");
10753 assert(ios.width() == 0);
10754 }
10755 ios.width(25);
10756 right(ios);
10757 {
10758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10759 std::string ex(str, iter.base());
10760 assert(ex == "*******************-0e+00");
10761 assert(ios.width() == 0);
10762 }
10763 ios.width(25);
10764 internal(ios);
10765 {
10766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10767 std::string ex(str, iter.base());
10768 assert(ex == "-*******************0e+00");
10769 assert(ios.width() == 0);
10770 }
10771 }
10772 ios.imbue(lg);
10773 {
10774 ios.width(0);
10775 {
10776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10777 std::string ex(str, iter.base());
10778 assert(ex == "-0e+00");
10779 assert(ios.width() == 0);
10780 }
10781 ios.width(25);
10782 left(ios);
10783 {
10784 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10785 std::string ex(str, iter.base());
10786 assert(ex == "-0e+00*******************");
10787 assert(ios.width() == 0);
10788 }
10789 ios.width(25);
10790 right(ios);
10791 {
10792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10793 std::string ex(str, iter.base());
10794 assert(ex == "*******************-0e+00");
10795 assert(ios.width() == 0);
10796 }
10797 ios.width(25);
10798 internal(ios);
10799 {
10800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10801 std::string ex(str, iter.base());
10802 assert(ex == "-*******************0e+00");
10803 assert(ios.width() == 0);
10804 }
10805 }
10806 }
10807 showpoint(ios);
10808 {
10809 ios.imbue(lc);
10810 {
10811 ios.width(0);
10812 {
10813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10814 std::string ex(str, iter.base());
10815 assert(ex == "-0.e+00");
10816 assert(ios.width() == 0);
10817 }
10818 ios.width(25);
10819 left(ios);
10820 {
10821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10822 std::string ex(str, iter.base());
10823 assert(ex == "-0.e+00******************");
10824 assert(ios.width() == 0);
10825 }
10826 ios.width(25);
10827 right(ios);
10828 {
10829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10830 std::string ex(str, iter.base());
10831 assert(ex == "******************-0.e+00");
10832 assert(ios.width() == 0);
10833 }
10834 ios.width(25);
10835 internal(ios);
10836 {
10837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10838 std::string ex(str, iter.base());
10839 assert(ex == "-******************0.e+00");
10840 assert(ios.width() == 0);
10841 }
10842 }
10843 ios.imbue(lg);
10844 {
10845 ios.width(0);
10846 {
10847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10848 std::string ex(str, iter.base());
10849 assert(ex == "-0;e+00");
10850 assert(ios.width() == 0);
10851 }
10852 ios.width(25);
10853 left(ios);
10854 {
10855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10856 std::string ex(str, iter.base());
10857 assert(ex == "-0;e+00******************");
10858 assert(ios.width() == 0);
10859 }
10860 ios.width(25);
10861 right(ios);
10862 {
10863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10864 std::string ex(str, iter.base());
10865 assert(ex == "******************-0;e+00");
10866 assert(ios.width() == 0);
10867 }
10868 ios.width(25);
10869 internal(ios);
10870 {
10871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10872 std::string ex(str, iter.base());
10873 assert(ex == "-******************0;e+00");
10874 assert(ios.width() == 0);
10875 }
10876 }
10877 }
10878 }
10879 showpos(ios);
10880 {
10881 noshowpoint(ios);
10882 {
10883 ios.imbue(lc);
10884 {
10885 ios.width(0);
10886 {
10887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10888 std::string ex(str, iter.base());
10889 assert(ex == "-0e+00");
10890 assert(ios.width() == 0);
10891 }
10892 ios.width(25);
10893 left(ios);
10894 {
10895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10896 std::string ex(str, iter.base());
10897 assert(ex == "-0e+00*******************");
10898 assert(ios.width() == 0);
10899 }
10900 ios.width(25);
10901 right(ios);
10902 {
10903 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10904 std::string ex(str, iter.base());
10905 assert(ex == "*******************-0e+00");
10906 assert(ios.width() == 0);
10907 }
10908 ios.width(25);
10909 internal(ios);
10910 {
10911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10912 std::string ex(str, iter.base());
10913 assert(ex == "-*******************0e+00");
10914 assert(ios.width() == 0);
10915 }
10916 }
10917 ios.imbue(lg);
10918 {
10919 ios.width(0);
10920 {
10921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10922 std::string ex(str, iter.base());
10923 assert(ex == "-0e+00");
10924 assert(ios.width() == 0);
10925 }
10926 ios.width(25);
10927 left(ios);
10928 {
10929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10930 std::string ex(str, iter.base());
10931 assert(ex == "-0e+00*******************");
10932 assert(ios.width() == 0);
10933 }
10934 ios.width(25);
10935 right(ios);
10936 {
10937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10938 std::string ex(str, iter.base());
10939 assert(ex == "*******************-0e+00");
10940 assert(ios.width() == 0);
10941 }
10942 ios.width(25);
10943 internal(ios);
10944 {
10945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10946 std::string ex(str, iter.base());
10947 assert(ex == "-*******************0e+00");
10948 assert(ios.width() == 0);
10949 }
10950 }
10951 }
10952 showpoint(ios);
10953 {
10954 ios.imbue(lc);
10955 {
10956 ios.width(0);
10957 {
10958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10959 std::string ex(str, iter.base());
10960 assert(ex == "-0.e+00");
10961 assert(ios.width() == 0);
10962 }
10963 ios.width(25);
10964 left(ios);
10965 {
10966 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10967 std::string ex(str, iter.base());
10968 assert(ex == "-0.e+00******************");
10969 assert(ios.width() == 0);
10970 }
10971 ios.width(25);
10972 right(ios);
10973 {
10974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10975 std::string ex(str, iter.base());
10976 assert(ex == "******************-0.e+00");
10977 assert(ios.width() == 0);
10978 }
10979 ios.width(25);
10980 internal(ios);
10981 {
10982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10983 std::string ex(str, iter.base());
10984 assert(ex == "-******************0.e+00");
10985 assert(ios.width() == 0);
10986 }
10987 }
10988 ios.imbue(lg);
10989 {
10990 ios.width(0);
10991 {
10992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10993 std::string ex(str, iter.base());
10994 assert(ex == "-0;e+00");
10995 assert(ios.width() == 0);
10996 }
10997 ios.width(25);
10998 left(ios);
10999 {
11000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11001 std::string ex(str, iter.base());
11002 assert(ex == "-0;e+00******************");
11003 assert(ios.width() == 0);
11004 }
11005 ios.width(25);
11006 right(ios);
11007 {
11008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11009 std::string ex(str, iter.base());
11010 assert(ex == "******************-0;e+00");
11011 assert(ios.width() == 0);
11012 }
11013 ios.width(25);
11014 internal(ios);
11015 {
11016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11017 std::string ex(str, iter.base());
11018 assert(ex == "-******************0;e+00");
11019 assert(ios.width() == 0);
11020 }
11021 }
11022 }
11023 }
11024 }
11025 uppercase(ios);
11026 {
11027 noshowpos(ios);
11028 {
11029 noshowpoint(ios);
11030 {
11031 ios.imbue(lc);
11032 {
11033 ios.width(0);
11034 {
11035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11036 std::string ex(str, iter.base());
11037 assert(ex == "-0E+00");
11038 assert(ios.width() == 0);
11039 }
11040 ios.width(25);
11041 left(ios);
11042 {
11043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11044 std::string ex(str, iter.base());
11045 assert(ex == "-0E+00*******************");
11046 assert(ios.width() == 0);
11047 }
11048 ios.width(25);
11049 right(ios);
11050 {
11051 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11052 std::string ex(str, iter.base());
11053 assert(ex == "*******************-0E+00");
11054 assert(ios.width() == 0);
11055 }
11056 ios.width(25);
11057 internal(ios);
11058 {
11059 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11060 std::string ex(str, iter.base());
11061 assert(ex == "-*******************0E+00");
11062 assert(ios.width() == 0);
11063 }
11064 }
11065 ios.imbue(lg);
11066 {
11067 ios.width(0);
11068 {
11069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11070 std::string ex(str, iter.base());
11071 assert(ex == "-0E+00");
11072 assert(ios.width() == 0);
11073 }
11074 ios.width(25);
11075 left(ios);
11076 {
11077 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11078 std::string ex(str, iter.base());
11079 assert(ex == "-0E+00*******************");
11080 assert(ios.width() == 0);
11081 }
11082 ios.width(25);
11083 right(ios);
11084 {
11085 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11086 std::string ex(str, iter.base());
11087 assert(ex == "*******************-0E+00");
11088 assert(ios.width() == 0);
11089 }
11090 ios.width(25);
11091 internal(ios);
11092 {
11093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11094 std::string ex(str, iter.base());
11095 assert(ex == "-*******************0E+00");
11096 assert(ios.width() == 0);
11097 }
11098 }
11099 }
11100 showpoint(ios);
11101 {
11102 ios.imbue(lc);
11103 {
11104 ios.width(0);
11105 {
11106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11107 std::string ex(str, iter.base());
11108 assert(ex == "-0.E+00");
11109 assert(ios.width() == 0);
11110 }
11111 ios.width(25);
11112 left(ios);
11113 {
11114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11115 std::string ex(str, iter.base());
11116 assert(ex == "-0.E+00******************");
11117 assert(ios.width() == 0);
11118 }
11119 ios.width(25);
11120 right(ios);
11121 {
11122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11123 std::string ex(str, iter.base());
11124 assert(ex == "******************-0.E+00");
11125 assert(ios.width() == 0);
11126 }
11127 ios.width(25);
11128 internal(ios);
11129 {
11130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11131 std::string ex(str, iter.base());
11132 assert(ex == "-******************0.E+00");
11133 assert(ios.width() == 0);
11134 }
11135 }
11136 ios.imbue(lg);
11137 {
11138 ios.width(0);
11139 {
11140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11141 std::string ex(str, iter.base());
11142 assert(ex == "-0;E+00");
11143 assert(ios.width() == 0);
11144 }
11145 ios.width(25);
11146 left(ios);
11147 {
11148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11149 std::string ex(str, iter.base());
11150 assert(ex == "-0;E+00******************");
11151 assert(ios.width() == 0);
11152 }
11153 ios.width(25);
11154 right(ios);
11155 {
11156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11157 std::string ex(str, iter.base());
11158 assert(ex == "******************-0;E+00");
11159 assert(ios.width() == 0);
11160 }
11161 ios.width(25);
11162 internal(ios);
11163 {
11164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11165 std::string ex(str, iter.base());
11166 assert(ex == "-******************0;E+00");
11167 assert(ios.width() == 0);
11168 }
11169 }
11170 }
11171 }
11172 showpos(ios);
11173 {
11174 noshowpoint(ios);
11175 {
11176 ios.imbue(lc);
11177 {
11178 ios.width(0);
11179 {
11180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11181 std::string ex(str, iter.base());
11182 assert(ex == "-0E+00");
11183 assert(ios.width() == 0);
11184 }
11185 ios.width(25);
11186 left(ios);
11187 {
11188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11189 std::string ex(str, iter.base());
11190 assert(ex == "-0E+00*******************");
11191 assert(ios.width() == 0);
11192 }
11193 ios.width(25);
11194 right(ios);
11195 {
11196 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11197 std::string ex(str, iter.base());
11198 assert(ex == "*******************-0E+00");
11199 assert(ios.width() == 0);
11200 }
11201 ios.width(25);
11202 internal(ios);
11203 {
11204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11205 std::string ex(str, iter.base());
11206 assert(ex == "-*******************0E+00");
11207 assert(ios.width() == 0);
11208 }
11209 }
11210 ios.imbue(lg);
11211 {
11212 ios.width(0);
11213 {
11214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11215 std::string ex(str, iter.base());
11216 assert(ex == "-0E+00");
11217 assert(ios.width() == 0);
11218 }
11219 ios.width(25);
11220 left(ios);
11221 {
11222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11223 std::string ex(str, iter.base());
11224 assert(ex == "-0E+00*******************");
11225 assert(ios.width() == 0);
11226 }
11227 ios.width(25);
11228 right(ios);
11229 {
11230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11231 std::string ex(str, iter.base());
11232 assert(ex == "*******************-0E+00");
11233 assert(ios.width() == 0);
11234 }
11235 ios.width(25);
11236 internal(ios);
11237 {
11238 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11239 std::string ex(str, iter.base());
11240 assert(ex == "-*******************0E+00");
11241 assert(ios.width() == 0);
11242 }
11243 }
11244 }
11245 showpoint(ios);
11246 {
11247 ios.imbue(lc);
11248 {
11249 ios.width(0);
11250 {
11251 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11252 std::string ex(str, iter.base());
11253 assert(ex == "-0.E+00");
11254 assert(ios.width() == 0);
11255 }
11256 ios.width(25);
11257 left(ios);
11258 {
11259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11260 std::string ex(str, iter.base());
11261 assert(ex == "-0.E+00******************");
11262 assert(ios.width() == 0);
11263 }
11264 ios.width(25);
11265 right(ios);
11266 {
11267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11268 std::string ex(str, iter.base());
11269 assert(ex == "******************-0.E+00");
11270 assert(ios.width() == 0);
11271 }
11272 ios.width(25);
11273 internal(ios);
11274 {
11275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11276 std::string ex(str, iter.base());
11277 assert(ex == "-******************0.E+00");
11278 assert(ios.width() == 0);
11279 }
11280 }
11281 ios.imbue(lg);
11282 {
11283 ios.width(0);
11284 {
11285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11286 std::string ex(str, iter.base());
11287 assert(ex == "-0;E+00");
11288 assert(ios.width() == 0);
11289 }
11290 ios.width(25);
11291 left(ios);
11292 {
11293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11294 std::string ex(str, iter.base());
11295 assert(ex == "-0;E+00******************");
11296 assert(ios.width() == 0);
11297 }
11298 ios.width(25);
11299 right(ios);
11300 {
11301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11302 std::string ex(str, iter.base());
11303 assert(ex == "******************-0;E+00");
11304 assert(ios.width() == 0);
11305 }
11306 ios.width(25);
11307 internal(ios);
11308 {
11309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11310 std::string ex(str, iter.base());
11311 assert(ex == "-******************0;E+00");
11312 assert(ios.width() == 0);
11313 }
11314 }
11315 }
11316 }
11317 }
11318 }
11319 ios.precision(1);
11320 {
11321 nouppercase(ios);
11322 {
11323 noshowpos(ios);
11324 {
11325 noshowpoint(ios);
11326 {
11327 ios.imbue(lc);
11328 {
11329 ios.width(0);
11330 {
11331 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11332 std::string ex(str, iter.base());
11333 assert(ex == "-0.0e+00");
11334 assert(ios.width() == 0);
11335 }
11336 ios.width(25);
11337 left(ios);
11338 {
11339 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11340 std::string ex(str, iter.base());
11341 assert(ex == "-0.0e+00*****************");
11342 assert(ios.width() == 0);
11343 }
11344 ios.width(25);
11345 right(ios);
11346 {
11347 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11348 std::string ex(str, iter.base());
11349 assert(ex == "*****************-0.0e+00");
11350 assert(ios.width() == 0);
11351 }
11352 ios.width(25);
11353 internal(ios);
11354 {
11355 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11356 std::string ex(str, iter.base());
11357 assert(ex == "-*****************0.0e+00");
11358 assert(ios.width() == 0);
11359 }
11360 }
11361 ios.imbue(lg);
11362 {
11363 ios.width(0);
11364 {
11365 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11366 std::string ex(str, iter.base());
11367 assert(ex == "-0;0e+00");
11368 assert(ios.width() == 0);
11369 }
11370 ios.width(25);
11371 left(ios);
11372 {
11373 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11374 std::string ex(str, iter.base());
11375 assert(ex == "-0;0e+00*****************");
11376 assert(ios.width() == 0);
11377 }
11378 ios.width(25);
11379 right(ios);
11380 {
11381 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11382 std::string ex(str, iter.base());
11383 assert(ex == "*****************-0;0e+00");
11384 assert(ios.width() == 0);
11385 }
11386 ios.width(25);
11387 internal(ios);
11388 {
11389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11390 std::string ex(str, iter.base());
11391 assert(ex == "-*****************0;0e+00");
11392 assert(ios.width() == 0);
11393 }
11394 }
11395 }
11396 showpoint(ios);
11397 {
11398 ios.imbue(lc);
11399 {
11400 ios.width(0);
11401 {
11402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11403 std::string ex(str, iter.base());
11404 assert(ex == "-0.0e+00");
11405 assert(ios.width() == 0);
11406 }
11407 ios.width(25);
11408 left(ios);
11409 {
11410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11411 std::string ex(str, iter.base());
11412 assert(ex == "-0.0e+00*****************");
11413 assert(ios.width() == 0);
11414 }
11415 ios.width(25);
11416 right(ios);
11417 {
11418 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11419 std::string ex(str, iter.base());
11420 assert(ex == "*****************-0.0e+00");
11421 assert(ios.width() == 0);
11422 }
11423 ios.width(25);
11424 internal(ios);
11425 {
11426 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11427 std::string ex(str, iter.base());
11428 assert(ex == "-*****************0.0e+00");
11429 assert(ios.width() == 0);
11430 }
11431 }
11432 ios.imbue(lg);
11433 {
11434 ios.width(0);
11435 {
11436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11437 std::string ex(str, iter.base());
11438 assert(ex == "-0;0e+00");
11439 assert(ios.width() == 0);
11440 }
11441 ios.width(25);
11442 left(ios);
11443 {
11444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11445 std::string ex(str, iter.base());
11446 assert(ex == "-0;0e+00*****************");
11447 assert(ios.width() == 0);
11448 }
11449 ios.width(25);
11450 right(ios);
11451 {
11452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11453 std::string ex(str, iter.base());
11454 assert(ex == "*****************-0;0e+00");
11455 assert(ios.width() == 0);
11456 }
11457 ios.width(25);
11458 internal(ios);
11459 {
11460 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11461 std::string ex(str, iter.base());
11462 assert(ex == "-*****************0;0e+00");
11463 assert(ios.width() == 0);
11464 }
11465 }
11466 }
11467 }
11468 showpos(ios);
11469 {
11470 noshowpoint(ios);
11471 {
11472 ios.imbue(lc);
11473 {
11474 ios.width(0);
11475 {
11476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11477 std::string ex(str, iter.base());
11478 assert(ex == "-0.0e+00");
11479 assert(ios.width() == 0);
11480 }
11481 ios.width(25);
11482 left(ios);
11483 {
11484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11485 std::string ex(str, iter.base());
11486 assert(ex == "-0.0e+00*****************");
11487 assert(ios.width() == 0);
11488 }
11489 ios.width(25);
11490 right(ios);
11491 {
11492 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11493 std::string ex(str, iter.base());
11494 assert(ex == "*****************-0.0e+00");
11495 assert(ios.width() == 0);
11496 }
11497 ios.width(25);
11498 internal(ios);
11499 {
11500 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11501 std::string ex(str, iter.base());
11502 assert(ex == "-*****************0.0e+00");
11503 assert(ios.width() == 0);
11504 }
11505 }
11506 ios.imbue(lg);
11507 {
11508 ios.width(0);
11509 {
11510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11511 std::string ex(str, iter.base());
11512 assert(ex == "-0;0e+00");
11513 assert(ios.width() == 0);
11514 }
11515 ios.width(25);
11516 left(ios);
11517 {
11518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11519 std::string ex(str, iter.base());
11520 assert(ex == "-0;0e+00*****************");
11521 assert(ios.width() == 0);
11522 }
11523 ios.width(25);
11524 right(ios);
11525 {
11526 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11527 std::string ex(str, iter.base());
11528 assert(ex == "*****************-0;0e+00");
11529 assert(ios.width() == 0);
11530 }
11531 ios.width(25);
11532 internal(ios);
11533 {
11534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11535 std::string ex(str, iter.base());
11536 assert(ex == "-*****************0;0e+00");
11537 assert(ios.width() == 0);
11538 }
11539 }
11540 }
11541 showpoint(ios);
11542 {
11543 ios.imbue(lc);
11544 {
11545 ios.width(0);
11546 {
11547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11548 std::string ex(str, iter.base());
11549 assert(ex == "-0.0e+00");
11550 assert(ios.width() == 0);
11551 }
11552 ios.width(25);
11553 left(ios);
11554 {
11555 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11556 std::string ex(str, iter.base());
11557 assert(ex == "-0.0e+00*****************");
11558 assert(ios.width() == 0);
11559 }
11560 ios.width(25);
11561 right(ios);
11562 {
11563 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11564 std::string ex(str, iter.base());
11565 assert(ex == "*****************-0.0e+00");
11566 assert(ios.width() == 0);
11567 }
11568 ios.width(25);
11569 internal(ios);
11570 {
11571 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11572 std::string ex(str, iter.base());
11573 assert(ex == "-*****************0.0e+00");
11574 assert(ios.width() == 0);
11575 }
11576 }
11577 ios.imbue(lg);
11578 {
11579 ios.width(0);
11580 {
11581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11582 std::string ex(str, iter.base());
11583 assert(ex == "-0;0e+00");
11584 assert(ios.width() == 0);
11585 }
11586 ios.width(25);
11587 left(ios);
11588 {
11589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11590 std::string ex(str, iter.base());
11591 assert(ex == "-0;0e+00*****************");
11592 assert(ios.width() == 0);
11593 }
11594 ios.width(25);
11595 right(ios);
11596 {
11597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11598 std::string ex(str, iter.base());
11599 assert(ex == "*****************-0;0e+00");
11600 assert(ios.width() == 0);
11601 }
11602 ios.width(25);
11603 internal(ios);
11604 {
11605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11606 std::string ex(str, iter.base());
11607 assert(ex == "-*****************0;0e+00");
11608 assert(ios.width() == 0);
11609 }
11610 }
11611 }
11612 }
11613 }
11614 uppercase(ios);
11615 {
11616 noshowpos(ios);
11617 {
11618 noshowpoint(ios);
11619 {
11620 ios.imbue(lc);
11621 {
11622 ios.width(0);
11623 {
11624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11625 std::string ex(str, iter.base());
11626 assert(ex == "-0.0E+00");
11627 assert(ios.width() == 0);
11628 }
11629 ios.width(25);
11630 left(ios);
11631 {
11632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11633 std::string ex(str, iter.base());
11634 assert(ex == "-0.0E+00*****************");
11635 assert(ios.width() == 0);
11636 }
11637 ios.width(25);
11638 right(ios);
11639 {
11640 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11641 std::string ex(str, iter.base());
11642 assert(ex == "*****************-0.0E+00");
11643 assert(ios.width() == 0);
11644 }
11645 ios.width(25);
11646 internal(ios);
11647 {
11648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11649 std::string ex(str, iter.base());
11650 assert(ex == "-*****************0.0E+00");
11651 assert(ios.width() == 0);
11652 }
11653 }
11654 ios.imbue(lg);
11655 {
11656 ios.width(0);
11657 {
11658 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11659 std::string ex(str, iter.base());
11660 assert(ex == "-0;0E+00");
11661 assert(ios.width() == 0);
11662 }
11663 ios.width(25);
11664 left(ios);
11665 {
11666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11667 std::string ex(str, iter.base());
11668 assert(ex == "-0;0E+00*****************");
11669 assert(ios.width() == 0);
11670 }
11671 ios.width(25);
11672 right(ios);
11673 {
11674 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11675 std::string ex(str, iter.base());
11676 assert(ex == "*****************-0;0E+00");
11677 assert(ios.width() == 0);
11678 }
11679 ios.width(25);
11680 internal(ios);
11681 {
11682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11683 std::string ex(str, iter.base());
11684 assert(ex == "-*****************0;0E+00");
11685 assert(ios.width() == 0);
11686 }
11687 }
11688 }
11689 showpoint(ios);
11690 {
11691 ios.imbue(lc);
11692 {
11693 ios.width(0);
11694 {
11695 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11696 std::string ex(str, iter.base());
11697 assert(ex == "-0.0E+00");
11698 assert(ios.width() == 0);
11699 }
11700 ios.width(25);
11701 left(ios);
11702 {
11703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11704 std::string ex(str, iter.base());
11705 assert(ex == "-0.0E+00*****************");
11706 assert(ios.width() == 0);
11707 }
11708 ios.width(25);
11709 right(ios);
11710 {
11711 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11712 std::string ex(str, iter.base());
11713 assert(ex == "*****************-0.0E+00");
11714 assert(ios.width() == 0);
11715 }
11716 ios.width(25);
11717 internal(ios);
11718 {
11719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11720 std::string ex(str, iter.base());
11721 assert(ex == "-*****************0.0E+00");
11722 assert(ios.width() == 0);
11723 }
11724 }
11725 ios.imbue(lg);
11726 {
11727 ios.width(0);
11728 {
11729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11730 std::string ex(str, iter.base());
11731 assert(ex == "-0;0E+00");
11732 assert(ios.width() == 0);
11733 }
11734 ios.width(25);
11735 left(ios);
11736 {
11737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11738 std::string ex(str, iter.base());
11739 assert(ex == "-0;0E+00*****************");
11740 assert(ios.width() == 0);
11741 }
11742 ios.width(25);
11743 right(ios);
11744 {
11745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11746 std::string ex(str, iter.base());
11747 assert(ex == "*****************-0;0E+00");
11748 assert(ios.width() == 0);
11749 }
11750 ios.width(25);
11751 internal(ios);
11752 {
11753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11754 std::string ex(str, iter.base());
11755 assert(ex == "-*****************0;0E+00");
11756 assert(ios.width() == 0);
11757 }
11758 }
11759 }
11760 }
11761 showpos(ios);
11762 {
11763 noshowpoint(ios);
11764 {
11765 ios.imbue(lc);
11766 {
11767 ios.width(0);
11768 {
11769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11770 std::string ex(str, iter.base());
11771 assert(ex == "-0.0E+00");
11772 assert(ios.width() == 0);
11773 }
11774 ios.width(25);
11775 left(ios);
11776 {
11777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11778 std::string ex(str, iter.base());
11779 assert(ex == "-0.0E+00*****************");
11780 assert(ios.width() == 0);
11781 }
11782 ios.width(25);
11783 right(ios);
11784 {
11785 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11786 std::string ex(str, iter.base());
11787 assert(ex == "*****************-0.0E+00");
11788 assert(ios.width() == 0);
11789 }
11790 ios.width(25);
11791 internal(ios);
11792 {
11793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11794 std::string ex(str, iter.base());
11795 assert(ex == "-*****************0.0E+00");
11796 assert(ios.width() == 0);
11797 }
11798 }
11799 ios.imbue(lg);
11800 {
11801 ios.width(0);
11802 {
11803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11804 std::string ex(str, iter.base());
11805 assert(ex == "-0;0E+00");
11806 assert(ios.width() == 0);
11807 }
11808 ios.width(25);
11809 left(ios);
11810 {
11811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11812 std::string ex(str, iter.base());
11813 assert(ex == "-0;0E+00*****************");
11814 assert(ios.width() == 0);
11815 }
11816 ios.width(25);
11817 right(ios);
11818 {
11819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11820 std::string ex(str, iter.base());
11821 assert(ex == "*****************-0;0E+00");
11822 assert(ios.width() == 0);
11823 }
11824 ios.width(25);
11825 internal(ios);
11826 {
11827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11828 std::string ex(str, iter.base());
11829 assert(ex == "-*****************0;0E+00");
11830 assert(ios.width() == 0);
11831 }
11832 }
11833 }
11834 showpoint(ios);
11835 {
11836 ios.imbue(lc);
11837 {
11838 ios.width(0);
11839 {
11840 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11841 std::string ex(str, iter.base());
11842 assert(ex == "-0.0E+00");
11843 assert(ios.width() == 0);
11844 }
11845 ios.width(25);
11846 left(ios);
11847 {
11848 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11849 std::string ex(str, iter.base());
11850 assert(ex == "-0.0E+00*****************");
11851 assert(ios.width() == 0);
11852 }
11853 ios.width(25);
11854 right(ios);
11855 {
11856 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11857 std::string ex(str, iter.base());
11858 assert(ex == "*****************-0.0E+00");
11859 assert(ios.width() == 0);
11860 }
11861 ios.width(25);
11862 internal(ios);
11863 {
11864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11865 std::string ex(str, iter.base());
11866 assert(ex == "-*****************0.0E+00");
11867 assert(ios.width() == 0);
11868 }
11869 }
11870 ios.imbue(lg);
11871 {
11872 ios.width(0);
11873 {
11874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11875 std::string ex(str, iter.base());
11876 assert(ex == "-0;0E+00");
11877 assert(ios.width() == 0);
11878 }
11879 ios.width(25);
11880 left(ios);
11881 {
11882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11883 std::string ex(str, iter.base());
11884 assert(ex == "-0;0E+00*****************");
11885 assert(ios.width() == 0);
11886 }
11887 ios.width(25);
11888 right(ios);
11889 {
11890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11891 std::string ex(str, iter.base());
11892 assert(ex == "*****************-0;0E+00");
11893 assert(ios.width() == 0);
11894 }
11895 ios.width(25);
11896 internal(ios);
11897 {
11898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11899 std::string ex(str, iter.base());
11900 assert(ex == "-*****************0;0E+00");
11901 assert(ios.width() == 0);
11902 }
11903 }
11904 }
11905 }
11906 }
11907 }
11908 ios.precision(6);
11909 {
11910 nouppercase(ios);
11911 {
11912 noshowpos(ios);
11913 {
11914 noshowpoint(ios);
11915 {
11916 ios.imbue(lc);
11917 {
11918 ios.width(0);
11919 {
11920 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11921 std::string ex(str, iter.base());
11922 assert(ex == "-0.000000e+00");
11923 assert(ios.width() == 0);
11924 }
11925 ios.width(25);
11926 left(ios);
11927 {
11928 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11929 std::string ex(str, iter.base());
11930 assert(ex == "-0.000000e+00************");
11931 assert(ios.width() == 0);
11932 }
11933 ios.width(25);
11934 right(ios);
11935 {
11936 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11937 std::string ex(str, iter.base());
11938 assert(ex == "************-0.000000e+00");
11939 assert(ios.width() == 0);
11940 }
11941 ios.width(25);
11942 internal(ios);
11943 {
11944 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11945 std::string ex(str, iter.base());
11946 assert(ex == "-************0.000000e+00");
11947 assert(ios.width() == 0);
11948 }
11949 }
11950 ios.imbue(lg);
11951 {
11952 ios.width(0);
11953 {
11954 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11955 std::string ex(str, iter.base());
11956 assert(ex == "-0;000000e+00");
11957 assert(ios.width() == 0);
11958 }
11959 ios.width(25);
11960 left(ios);
11961 {
11962 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11963 std::string ex(str, iter.base());
11964 assert(ex == "-0;000000e+00************");
11965 assert(ios.width() == 0);
11966 }
11967 ios.width(25);
11968 right(ios);
11969 {
11970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11971 std::string ex(str, iter.base());
11972 assert(ex == "************-0;000000e+00");
11973 assert(ios.width() == 0);
11974 }
11975 ios.width(25);
11976 internal(ios);
11977 {
11978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11979 std::string ex(str, iter.base());
11980 assert(ex == "-************0;000000e+00");
11981 assert(ios.width() == 0);
11982 }
11983 }
11984 }
11985 showpoint(ios);
11986 {
11987 ios.imbue(lc);
11988 {
11989 ios.width(0);
11990 {
11991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11992 std::string ex(str, iter.base());
11993 assert(ex == "-0.000000e+00");
11994 assert(ios.width() == 0);
11995 }
11996 ios.width(25);
11997 left(ios);
11998 {
11999 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12000 std::string ex(str, iter.base());
12001 assert(ex == "-0.000000e+00************");
12002 assert(ios.width() == 0);
12003 }
12004 ios.width(25);
12005 right(ios);
12006 {
12007 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12008 std::string ex(str, iter.base());
12009 assert(ex == "************-0.000000e+00");
12010 assert(ios.width() == 0);
12011 }
12012 ios.width(25);
12013 internal(ios);
12014 {
12015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12016 std::string ex(str, iter.base());
12017 assert(ex == "-************0.000000e+00");
12018 assert(ios.width() == 0);
12019 }
12020 }
12021 ios.imbue(lg);
12022 {
12023 ios.width(0);
12024 {
12025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12026 std::string ex(str, iter.base());
12027 assert(ex == "-0;000000e+00");
12028 assert(ios.width() == 0);
12029 }
12030 ios.width(25);
12031 left(ios);
12032 {
12033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12034 std::string ex(str, iter.base());
12035 assert(ex == "-0;000000e+00************");
12036 assert(ios.width() == 0);
12037 }
12038 ios.width(25);
12039 right(ios);
12040 {
12041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12042 std::string ex(str, iter.base());
12043 assert(ex == "************-0;000000e+00");
12044 assert(ios.width() == 0);
12045 }
12046 ios.width(25);
12047 internal(ios);
12048 {
12049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12050 std::string ex(str, iter.base());
12051 assert(ex == "-************0;000000e+00");
12052 assert(ios.width() == 0);
12053 }
12054 }
12055 }
12056 }
12057 showpos(ios);
12058 {
12059 noshowpoint(ios);
12060 {
12061 ios.imbue(lc);
12062 {
12063 ios.width(0);
12064 {
12065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12066 std::string ex(str, iter.base());
12067 assert(ex == "-0.000000e+00");
12068 assert(ios.width() == 0);
12069 }
12070 ios.width(25);
12071 left(ios);
12072 {
12073 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12074 std::string ex(str, iter.base());
12075 assert(ex == "-0.000000e+00************");
12076 assert(ios.width() == 0);
12077 }
12078 ios.width(25);
12079 right(ios);
12080 {
12081 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12082 std::string ex(str, iter.base());
12083 assert(ex == "************-0.000000e+00");
12084 assert(ios.width() == 0);
12085 }
12086 ios.width(25);
12087 internal(ios);
12088 {
12089 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12090 std::string ex(str, iter.base());
12091 assert(ex == "-************0.000000e+00");
12092 assert(ios.width() == 0);
12093 }
12094 }
12095 ios.imbue(lg);
12096 {
12097 ios.width(0);
12098 {
12099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12100 std::string ex(str, iter.base());
12101 assert(ex == "-0;000000e+00");
12102 assert(ios.width() == 0);
12103 }
12104 ios.width(25);
12105 left(ios);
12106 {
12107 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12108 std::string ex(str, iter.base());
12109 assert(ex == "-0;000000e+00************");
12110 assert(ios.width() == 0);
12111 }
12112 ios.width(25);
12113 right(ios);
12114 {
12115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12116 std::string ex(str, iter.base());
12117 assert(ex == "************-0;000000e+00");
12118 assert(ios.width() == 0);
12119 }
12120 ios.width(25);
12121 internal(ios);
12122 {
12123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12124 std::string ex(str, iter.base());
12125 assert(ex == "-************0;000000e+00");
12126 assert(ios.width() == 0);
12127 }
12128 }
12129 }
12130 showpoint(ios);
12131 {
12132 ios.imbue(lc);
12133 {
12134 ios.width(0);
12135 {
12136 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12137 std::string ex(str, iter.base());
12138 assert(ex == "-0.000000e+00");
12139 assert(ios.width() == 0);
12140 }
12141 ios.width(25);
12142 left(ios);
12143 {
12144 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12145 std::string ex(str, iter.base());
12146 assert(ex == "-0.000000e+00************");
12147 assert(ios.width() == 0);
12148 }
12149 ios.width(25);
12150 right(ios);
12151 {
12152 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12153 std::string ex(str, iter.base());
12154 assert(ex == "************-0.000000e+00");
12155 assert(ios.width() == 0);
12156 }
12157 ios.width(25);
12158 internal(ios);
12159 {
12160 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12161 std::string ex(str, iter.base());
12162 assert(ex == "-************0.000000e+00");
12163 assert(ios.width() == 0);
12164 }
12165 }
12166 ios.imbue(lg);
12167 {
12168 ios.width(0);
12169 {
12170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12171 std::string ex(str, iter.base());
12172 assert(ex == "-0;000000e+00");
12173 assert(ios.width() == 0);
12174 }
12175 ios.width(25);
12176 left(ios);
12177 {
12178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12179 std::string ex(str, iter.base());
12180 assert(ex == "-0;000000e+00************");
12181 assert(ios.width() == 0);
12182 }
12183 ios.width(25);
12184 right(ios);
12185 {
12186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12187 std::string ex(str, iter.base());
12188 assert(ex == "************-0;000000e+00");
12189 assert(ios.width() == 0);
12190 }
12191 ios.width(25);
12192 internal(ios);
12193 {
12194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12195 std::string ex(str, iter.base());
12196 assert(ex == "-************0;000000e+00");
12197 assert(ios.width() == 0);
12198 }
12199 }
12200 }
12201 }
12202 }
12203 uppercase(ios);
12204 {
12205 noshowpos(ios);
12206 {
12207 noshowpoint(ios);
12208 {
12209 ios.imbue(lc);
12210 {
12211 ios.width(0);
12212 {
12213 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12214 std::string ex(str, iter.base());
12215 assert(ex == "-0.000000E+00");
12216 assert(ios.width() == 0);
12217 }
12218 ios.width(25);
12219 left(ios);
12220 {
12221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12222 std::string ex(str, iter.base());
12223 assert(ex == "-0.000000E+00************");
12224 assert(ios.width() == 0);
12225 }
12226 ios.width(25);
12227 right(ios);
12228 {
12229 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12230 std::string ex(str, iter.base());
12231 assert(ex == "************-0.000000E+00");
12232 assert(ios.width() == 0);
12233 }
12234 ios.width(25);
12235 internal(ios);
12236 {
12237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12238 std::string ex(str, iter.base());
12239 assert(ex == "-************0.000000E+00");
12240 assert(ios.width() == 0);
12241 }
12242 }
12243 ios.imbue(lg);
12244 {
12245 ios.width(0);
12246 {
12247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12248 std::string ex(str, iter.base());
12249 assert(ex == "-0;000000E+00");
12250 assert(ios.width() == 0);
12251 }
12252 ios.width(25);
12253 left(ios);
12254 {
12255 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12256 std::string ex(str, iter.base());
12257 assert(ex == "-0;000000E+00************");
12258 assert(ios.width() == 0);
12259 }
12260 ios.width(25);
12261 right(ios);
12262 {
12263 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12264 std::string ex(str, iter.base());
12265 assert(ex == "************-0;000000E+00");
12266 assert(ios.width() == 0);
12267 }
12268 ios.width(25);
12269 internal(ios);
12270 {
12271 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12272 std::string ex(str, iter.base());
12273 assert(ex == "-************0;000000E+00");
12274 assert(ios.width() == 0);
12275 }
12276 }
12277 }
12278 showpoint(ios);
12279 {
12280 ios.imbue(lc);
12281 {
12282 ios.width(0);
12283 {
12284 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12285 std::string ex(str, iter.base());
12286 assert(ex == "-0.000000E+00");
12287 assert(ios.width() == 0);
12288 }
12289 ios.width(25);
12290 left(ios);
12291 {
12292 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12293 std::string ex(str, iter.base());
12294 assert(ex == "-0.000000E+00************");
12295 assert(ios.width() == 0);
12296 }
12297 ios.width(25);
12298 right(ios);
12299 {
12300 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12301 std::string ex(str, iter.base());
12302 assert(ex == "************-0.000000E+00");
12303 assert(ios.width() == 0);
12304 }
12305 ios.width(25);
12306 internal(ios);
12307 {
12308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12309 std::string ex(str, iter.base());
12310 assert(ex == "-************0.000000E+00");
12311 assert(ios.width() == 0);
12312 }
12313 }
12314 ios.imbue(lg);
12315 {
12316 ios.width(0);
12317 {
12318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12319 std::string ex(str, iter.base());
12320 assert(ex == "-0;000000E+00");
12321 assert(ios.width() == 0);
12322 }
12323 ios.width(25);
12324 left(ios);
12325 {
12326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12327 std::string ex(str, iter.base());
12328 assert(ex == "-0;000000E+00************");
12329 assert(ios.width() == 0);
12330 }
12331 ios.width(25);
12332 right(ios);
12333 {
12334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12335 std::string ex(str, iter.base());
12336 assert(ex == "************-0;000000E+00");
12337 assert(ios.width() == 0);
12338 }
12339 ios.width(25);
12340 internal(ios);
12341 {
12342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12343 std::string ex(str, iter.base());
12344 assert(ex == "-************0;000000E+00");
12345 assert(ios.width() == 0);
12346 }
12347 }
12348 }
12349 }
12350 showpos(ios);
12351 {
12352 noshowpoint(ios);
12353 {
12354 ios.imbue(lc);
12355 {
12356 ios.width(0);
12357 {
12358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12359 std::string ex(str, iter.base());
12360 assert(ex == "-0.000000E+00");
12361 assert(ios.width() == 0);
12362 }
12363 ios.width(25);
12364 left(ios);
12365 {
12366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12367 std::string ex(str, iter.base());
12368 assert(ex == "-0.000000E+00************");
12369 assert(ios.width() == 0);
12370 }
12371 ios.width(25);
12372 right(ios);
12373 {
12374 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12375 std::string ex(str, iter.base());
12376 assert(ex == "************-0.000000E+00");
12377 assert(ios.width() == 0);
12378 }
12379 ios.width(25);
12380 internal(ios);
12381 {
12382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12383 std::string ex(str, iter.base());
12384 assert(ex == "-************0.000000E+00");
12385 assert(ios.width() == 0);
12386 }
12387 }
12388 ios.imbue(lg);
12389 {
12390 ios.width(0);
12391 {
12392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12393 std::string ex(str, iter.base());
12394 assert(ex == "-0;000000E+00");
12395 assert(ios.width() == 0);
12396 }
12397 ios.width(25);
12398 left(ios);
12399 {
12400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12401 std::string ex(str, iter.base());
12402 assert(ex == "-0;000000E+00************");
12403 assert(ios.width() == 0);
12404 }
12405 ios.width(25);
12406 right(ios);
12407 {
12408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12409 std::string ex(str, iter.base());
12410 assert(ex == "************-0;000000E+00");
12411 assert(ios.width() == 0);
12412 }
12413 ios.width(25);
12414 internal(ios);
12415 {
12416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12417 std::string ex(str, iter.base());
12418 assert(ex == "-************0;000000E+00");
12419 assert(ios.width() == 0);
12420 }
12421 }
12422 }
12423 showpoint(ios);
12424 {
12425 ios.imbue(lc);
12426 {
12427 ios.width(0);
12428 {
12429 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12430 std::string ex(str, iter.base());
12431 assert(ex == "-0.000000E+00");
12432 assert(ios.width() == 0);
12433 }
12434 ios.width(25);
12435 left(ios);
12436 {
12437 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12438 std::string ex(str, iter.base());
12439 assert(ex == "-0.000000E+00************");
12440 assert(ios.width() == 0);
12441 }
12442 ios.width(25);
12443 right(ios);
12444 {
12445 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12446 std::string ex(str, iter.base());
12447 assert(ex == "************-0.000000E+00");
12448 assert(ios.width() == 0);
12449 }
12450 ios.width(25);
12451 internal(ios);
12452 {
12453 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12454 std::string ex(str, iter.base());
12455 assert(ex == "-************0.000000E+00");
12456 assert(ios.width() == 0);
12457 }
12458 }
12459 ios.imbue(lg);
12460 {
12461 ios.width(0);
12462 {
12463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12464 std::string ex(str, iter.base());
12465 assert(ex == "-0;000000E+00");
12466 assert(ios.width() == 0);
12467 }
12468 ios.width(25);
12469 left(ios);
12470 {
12471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12472 std::string ex(str, iter.base());
12473 assert(ex == "-0;000000E+00************");
12474 assert(ios.width() == 0);
12475 }
12476 ios.width(25);
12477 right(ios);
12478 {
12479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12480 std::string ex(str, iter.base());
12481 assert(ex == "************-0;000000E+00");
12482 assert(ios.width() == 0);
12483 }
12484 ios.width(25);
12485 internal(ios);
12486 {
12487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12488 std::string ex(str, iter.base());
12489 assert(ex == "-************0;000000E+00");
12490 assert(ios.width() == 0);
12491 }
12492 }
12493 }
12494 }
12495 }
12496 }
12497 ios.precision(16);
12498 {
12499 }
12500 ios.precision(60);
12501 {
12502 }
12503 }
12504 }
12505 }
12506
test6()12507 void test6()
12508 {
12509 char str[200];
12510 output_iterator<char*> iter;
12511 std::locale lc = std::locale::classic();
12512 std::locale lg(lc, new my_numpunct);
12513 const my_facet f(1);
12514 {
12515 double v = 1234567890.125;
12516 std::ios ios(0);
12517 scientific(ios);
12518 // %e
12519 {
12520 ios.precision(0);
12521 {
12522 nouppercase(ios);
12523 {
12524 noshowpos(ios);
12525 {
12526 noshowpoint(ios);
12527 {
12528 ios.imbue(lc);
12529 {
12530 ios.width(0);
12531 {
12532 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12533 std::string ex(str, iter.base());
12534 assert(ex == "1e+09");
12535 assert(ios.width() == 0);
12536 }
12537 ios.width(25);
12538 left(ios);
12539 {
12540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12541 std::string ex(str, iter.base());
12542 assert(ex == "1e+09********************");
12543 assert(ios.width() == 0);
12544 }
12545 ios.width(25);
12546 right(ios);
12547 {
12548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12549 std::string ex(str, iter.base());
12550 assert(ex == "********************1e+09");
12551 assert(ios.width() == 0);
12552 }
12553 ios.width(25);
12554 internal(ios);
12555 {
12556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12557 std::string ex(str, iter.base());
12558 assert(ex == "********************1e+09");
12559 assert(ios.width() == 0);
12560 }
12561 }
12562 ios.imbue(lg);
12563 {
12564 ios.width(0);
12565 {
12566 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12567 std::string ex(str, iter.base());
12568 assert(ex == "1e+09");
12569 assert(ios.width() == 0);
12570 }
12571 ios.width(25);
12572 left(ios);
12573 {
12574 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12575 std::string ex(str, iter.base());
12576 assert(ex == "1e+09********************");
12577 assert(ios.width() == 0);
12578 }
12579 ios.width(25);
12580 right(ios);
12581 {
12582 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12583 std::string ex(str, iter.base());
12584 assert(ex == "********************1e+09");
12585 assert(ios.width() == 0);
12586 }
12587 ios.width(25);
12588 internal(ios);
12589 {
12590 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12591 std::string ex(str, iter.base());
12592 assert(ex == "********************1e+09");
12593 assert(ios.width() == 0);
12594 }
12595 }
12596 }
12597 showpoint(ios);
12598 {
12599 ios.imbue(lc);
12600 {
12601 ios.width(0);
12602 {
12603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12604 std::string ex(str, iter.base());
12605 assert(ex == "1.e+09");
12606 assert(ios.width() == 0);
12607 }
12608 ios.width(25);
12609 left(ios);
12610 {
12611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12612 std::string ex(str, iter.base());
12613 assert(ex == "1.e+09*******************");
12614 assert(ios.width() == 0);
12615 }
12616 ios.width(25);
12617 right(ios);
12618 {
12619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12620 std::string ex(str, iter.base());
12621 assert(ex == "*******************1.e+09");
12622 assert(ios.width() == 0);
12623 }
12624 ios.width(25);
12625 internal(ios);
12626 {
12627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12628 std::string ex(str, iter.base());
12629 assert(ex == "*******************1.e+09");
12630 assert(ios.width() == 0);
12631 }
12632 }
12633 ios.imbue(lg);
12634 {
12635 ios.width(0);
12636 {
12637 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12638 std::string ex(str, iter.base());
12639 assert(ex == "1;e+09");
12640 assert(ios.width() == 0);
12641 }
12642 ios.width(25);
12643 left(ios);
12644 {
12645 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12646 std::string ex(str, iter.base());
12647 assert(ex == "1;e+09*******************");
12648 assert(ios.width() == 0);
12649 }
12650 ios.width(25);
12651 right(ios);
12652 {
12653 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12654 std::string ex(str, iter.base());
12655 assert(ex == "*******************1;e+09");
12656 assert(ios.width() == 0);
12657 }
12658 ios.width(25);
12659 internal(ios);
12660 {
12661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12662 std::string ex(str, iter.base());
12663 assert(ex == "*******************1;e+09");
12664 assert(ios.width() == 0);
12665 }
12666 }
12667 }
12668 }
12669 showpos(ios);
12670 {
12671 noshowpoint(ios);
12672 {
12673 ios.imbue(lc);
12674 {
12675 ios.width(0);
12676 {
12677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12678 std::string ex(str, iter.base());
12679 assert(ex == "+1e+09");
12680 assert(ios.width() == 0);
12681 }
12682 ios.width(25);
12683 left(ios);
12684 {
12685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12686 std::string ex(str, iter.base());
12687 assert(ex == "+1e+09*******************");
12688 assert(ios.width() == 0);
12689 }
12690 ios.width(25);
12691 right(ios);
12692 {
12693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12694 std::string ex(str, iter.base());
12695 assert(ex == "*******************+1e+09");
12696 assert(ios.width() == 0);
12697 }
12698 ios.width(25);
12699 internal(ios);
12700 {
12701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12702 std::string ex(str, iter.base());
12703 assert(ex == "+*******************1e+09");
12704 assert(ios.width() == 0);
12705 }
12706 }
12707 ios.imbue(lg);
12708 {
12709 ios.width(0);
12710 {
12711 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12712 std::string ex(str, iter.base());
12713 assert(ex == "+1e+09");
12714 assert(ios.width() == 0);
12715 }
12716 ios.width(25);
12717 left(ios);
12718 {
12719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12720 std::string ex(str, iter.base());
12721 assert(ex == "+1e+09*******************");
12722 assert(ios.width() == 0);
12723 }
12724 ios.width(25);
12725 right(ios);
12726 {
12727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12728 std::string ex(str, iter.base());
12729 assert(ex == "*******************+1e+09");
12730 assert(ios.width() == 0);
12731 }
12732 ios.width(25);
12733 internal(ios);
12734 {
12735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12736 std::string ex(str, iter.base());
12737 assert(ex == "+*******************1e+09");
12738 assert(ios.width() == 0);
12739 }
12740 }
12741 }
12742 showpoint(ios);
12743 {
12744 ios.imbue(lc);
12745 {
12746 ios.width(0);
12747 {
12748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12749 std::string ex(str, iter.base());
12750 assert(ex == "+1.e+09");
12751 assert(ios.width() == 0);
12752 }
12753 ios.width(25);
12754 left(ios);
12755 {
12756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12757 std::string ex(str, iter.base());
12758 assert(ex == "+1.e+09******************");
12759 assert(ios.width() == 0);
12760 }
12761 ios.width(25);
12762 right(ios);
12763 {
12764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12765 std::string ex(str, iter.base());
12766 assert(ex == "******************+1.e+09");
12767 assert(ios.width() == 0);
12768 }
12769 ios.width(25);
12770 internal(ios);
12771 {
12772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12773 std::string ex(str, iter.base());
12774 assert(ex == "+******************1.e+09");
12775 assert(ios.width() == 0);
12776 }
12777 }
12778 ios.imbue(lg);
12779 {
12780 ios.width(0);
12781 {
12782 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12783 std::string ex(str, iter.base());
12784 assert(ex == "+1;e+09");
12785 assert(ios.width() == 0);
12786 }
12787 ios.width(25);
12788 left(ios);
12789 {
12790 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12791 std::string ex(str, iter.base());
12792 assert(ex == "+1;e+09******************");
12793 assert(ios.width() == 0);
12794 }
12795 ios.width(25);
12796 right(ios);
12797 {
12798 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12799 std::string ex(str, iter.base());
12800 assert(ex == "******************+1;e+09");
12801 assert(ios.width() == 0);
12802 }
12803 ios.width(25);
12804 internal(ios);
12805 {
12806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12807 std::string ex(str, iter.base());
12808 assert(ex == "+******************1;e+09");
12809 assert(ios.width() == 0);
12810 }
12811 }
12812 }
12813 }
12814 }
12815 uppercase(ios);
12816 {
12817 noshowpos(ios);
12818 {
12819 noshowpoint(ios);
12820 {
12821 ios.imbue(lc);
12822 {
12823 ios.width(0);
12824 {
12825 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12826 std::string ex(str, iter.base());
12827 assert(ex == "1E+09");
12828 assert(ios.width() == 0);
12829 }
12830 ios.width(25);
12831 left(ios);
12832 {
12833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12834 std::string ex(str, iter.base());
12835 assert(ex == "1E+09********************");
12836 assert(ios.width() == 0);
12837 }
12838 ios.width(25);
12839 right(ios);
12840 {
12841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12842 std::string ex(str, iter.base());
12843 assert(ex == "********************1E+09");
12844 assert(ios.width() == 0);
12845 }
12846 ios.width(25);
12847 internal(ios);
12848 {
12849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12850 std::string ex(str, iter.base());
12851 assert(ex == "********************1E+09");
12852 assert(ios.width() == 0);
12853 }
12854 }
12855 ios.imbue(lg);
12856 {
12857 ios.width(0);
12858 {
12859 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12860 std::string ex(str, iter.base());
12861 assert(ex == "1E+09");
12862 assert(ios.width() == 0);
12863 }
12864 ios.width(25);
12865 left(ios);
12866 {
12867 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12868 std::string ex(str, iter.base());
12869 assert(ex == "1E+09********************");
12870 assert(ios.width() == 0);
12871 }
12872 ios.width(25);
12873 right(ios);
12874 {
12875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12876 std::string ex(str, iter.base());
12877 assert(ex == "********************1E+09");
12878 assert(ios.width() == 0);
12879 }
12880 ios.width(25);
12881 internal(ios);
12882 {
12883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12884 std::string ex(str, iter.base());
12885 assert(ex == "********************1E+09");
12886 assert(ios.width() == 0);
12887 }
12888 }
12889 }
12890 showpoint(ios);
12891 {
12892 ios.imbue(lc);
12893 {
12894 ios.width(0);
12895 {
12896 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12897 std::string ex(str, iter.base());
12898 assert(ex == "1.E+09");
12899 assert(ios.width() == 0);
12900 }
12901 ios.width(25);
12902 left(ios);
12903 {
12904 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12905 std::string ex(str, iter.base());
12906 assert(ex == "1.E+09*******************");
12907 assert(ios.width() == 0);
12908 }
12909 ios.width(25);
12910 right(ios);
12911 {
12912 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12913 std::string ex(str, iter.base());
12914 assert(ex == "*******************1.E+09");
12915 assert(ios.width() == 0);
12916 }
12917 ios.width(25);
12918 internal(ios);
12919 {
12920 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12921 std::string ex(str, iter.base());
12922 assert(ex == "*******************1.E+09");
12923 assert(ios.width() == 0);
12924 }
12925 }
12926 ios.imbue(lg);
12927 {
12928 ios.width(0);
12929 {
12930 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12931 std::string ex(str, iter.base());
12932 assert(ex == "1;E+09");
12933 assert(ios.width() == 0);
12934 }
12935 ios.width(25);
12936 left(ios);
12937 {
12938 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12939 std::string ex(str, iter.base());
12940 assert(ex == "1;E+09*******************");
12941 assert(ios.width() == 0);
12942 }
12943 ios.width(25);
12944 right(ios);
12945 {
12946 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12947 std::string ex(str, iter.base());
12948 assert(ex == "*******************1;E+09");
12949 assert(ios.width() == 0);
12950 }
12951 ios.width(25);
12952 internal(ios);
12953 {
12954 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12955 std::string ex(str, iter.base());
12956 assert(ex == "*******************1;E+09");
12957 assert(ios.width() == 0);
12958 }
12959 }
12960 }
12961 }
12962 showpos(ios);
12963 {
12964 noshowpoint(ios);
12965 {
12966 ios.imbue(lc);
12967 {
12968 ios.width(0);
12969 {
12970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12971 std::string ex(str, iter.base());
12972 assert(ex == "+1E+09");
12973 assert(ios.width() == 0);
12974 }
12975 ios.width(25);
12976 left(ios);
12977 {
12978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12979 std::string ex(str, iter.base());
12980 assert(ex == "+1E+09*******************");
12981 assert(ios.width() == 0);
12982 }
12983 ios.width(25);
12984 right(ios);
12985 {
12986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12987 std::string ex(str, iter.base());
12988 assert(ex == "*******************+1E+09");
12989 assert(ios.width() == 0);
12990 }
12991 ios.width(25);
12992 internal(ios);
12993 {
12994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12995 std::string ex(str, iter.base());
12996 assert(ex == "+*******************1E+09");
12997 assert(ios.width() == 0);
12998 }
12999 }
13000 ios.imbue(lg);
13001 {
13002 ios.width(0);
13003 {
13004 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13005 std::string ex(str, iter.base());
13006 assert(ex == "+1E+09");
13007 assert(ios.width() == 0);
13008 }
13009 ios.width(25);
13010 left(ios);
13011 {
13012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13013 std::string ex(str, iter.base());
13014 assert(ex == "+1E+09*******************");
13015 assert(ios.width() == 0);
13016 }
13017 ios.width(25);
13018 right(ios);
13019 {
13020 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13021 std::string ex(str, iter.base());
13022 assert(ex == "*******************+1E+09");
13023 assert(ios.width() == 0);
13024 }
13025 ios.width(25);
13026 internal(ios);
13027 {
13028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13029 std::string ex(str, iter.base());
13030 assert(ex == "+*******************1E+09");
13031 assert(ios.width() == 0);
13032 }
13033 }
13034 }
13035 showpoint(ios);
13036 {
13037 ios.imbue(lc);
13038 {
13039 ios.width(0);
13040 {
13041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13042 std::string ex(str, iter.base());
13043 assert(ex == "+1.E+09");
13044 assert(ios.width() == 0);
13045 }
13046 ios.width(25);
13047 left(ios);
13048 {
13049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13050 std::string ex(str, iter.base());
13051 assert(ex == "+1.E+09******************");
13052 assert(ios.width() == 0);
13053 }
13054 ios.width(25);
13055 right(ios);
13056 {
13057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13058 std::string ex(str, iter.base());
13059 assert(ex == "******************+1.E+09");
13060 assert(ios.width() == 0);
13061 }
13062 ios.width(25);
13063 internal(ios);
13064 {
13065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13066 std::string ex(str, iter.base());
13067 assert(ex == "+******************1.E+09");
13068 assert(ios.width() == 0);
13069 }
13070 }
13071 ios.imbue(lg);
13072 {
13073 ios.width(0);
13074 {
13075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13076 std::string ex(str, iter.base());
13077 assert(ex == "+1;E+09");
13078 assert(ios.width() == 0);
13079 }
13080 ios.width(25);
13081 left(ios);
13082 {
13083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13084 std::string ex(str, iter.base());
13085 assert(ex == "+1;E+09******************");
13086 assert(ios.width() == 0);
13087 }
13088 ios.width(25);
13089 right(ios);
13090 {
13091 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13092 std::string ex(str, iter.base());
13093 assert(ex == "******************+1;E+09");
13094 assert(ios.width() == 0);
13095 }
13096 ios.width(25);
13097 internal(ios);
13098 {
13099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13100 std::string ex(str, iter.base());
13101 assert(ex == "+******************1;E+09");
13102 assert(ios.width() == 0);
13103 }
13104 }
13105 }
13106 }
13107 }
13108 }
13109 ios.precision(1);
13110 {
13111 nouppercase(ios);
13112 {
13113 noshowpos(ios);
13114 {
13115 noshowpoint(ios);
13116 {
13117 ios.imbue(lc);
13118 {
13119 ios.width(0);
13120 {
13121 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13122 std::string ex(str, iter.base());
13123 assert(ex == "1.2e+09");
13124 assert(ios.width() == 0);
13125 }
13126 ios.width(25);
13127 left(ios);
13128 {
13129 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13130 std::string ex(str, iter.base());
13131 assert(ex == "1.2e+09******************");
13132 assert(ios.width() == 0);
13133 }
13134 ios.width(25);
13135 right(ios);
13136 {
13137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13138 std::string ex(str, iter.base());
13139 assert(ex == "******************1.2e+09");
13140 assert(ios.width() == 0);
13141 }
13142 ios.width(25);
13143 internal(ios);
13144 {
13145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13146 std::string ex(str, iter.base());
13147 assert(ex == "******************1.2e+09");
13148 assert(ios.width() == 0);
13149 }
13150 }
13151 ios.imbue(lg);
13152 {
13153 ios.width(0);
13154 {
13155 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13156 std::string ex(str, iter.base());
13157 assert(ex == "1;2e+09");
13158 assert(ios.width() == 0);
13159 }
13160 ios.width(25);
13161 left(ios);
13162 {
13163 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13164 std::string ex(str, iter.base());
13165 assert(ex == "1;2e+09******************");
13166 assert(ios.width() == 0);
13167 }
13168 ios.width(25);
13169 right(ios);
13170 {
13171 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13172 std::string ex(str, iter.base());
13173 assert(ex == "******************1;2e+09");
13174 assert(ios.width() == 0);
13175 }
13176 ios.width(25);
13177 internal(ios);
13178 {
13179 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13180 std::string ex(str, iter.base());
13181 assert(ex == "******************1;2e+09");
13182 assert(ios.width() == 0);
13183 }
13184 }
13185 }
13186 showpoint(ios);
13187 {
13188 ios.imbue(lc);
13189 {
13190 ios.width(0);
13191 {
13192 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13193 std::string ex(str, iter.base());
13194 assert(ex == "1.2e+09");
13195 assert(ios.width() == 0);
13196 }
13197 ios.width(25);
13198 left(ios);
13199 {
13200 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13201 std::string ex(str, iter.base());
13202 assert(ex == "1.2e+09******************");
13203 assert(ios.width() == 0);
13204 }
13205 ios.width(25);
13206 right(ios);
13207 {
13208 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13209 std::string ex(str, iter.base());
13210 assert(ex == "******************1.2e+09");
13211 assert(ios.width() == 0);
13212 }
13213 ios.width(25);
13214 internal(ios);
13215 {
13216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13217 std::string ex(str, iter.base());
13218 assert(ex == "******************1.2e+09");
13219 assert(ios.width() == 0);
13220 }
13221 }
13222 ios.imbue(lg);
13223 {
13224 ios.width(0);
13225 {
13226 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13227 std::string ex(str, iter.base());
13228 assert(ex == "1;2e+09");
13229 assert(ios.width() == 0);
13230 }
13231 ios.width(25);
13232 left(ios);
13233 {
13234 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13235 std::string ex(str, iter.base());
13236 assert(ex == "1;2e+09******************");
13237 assert(ios.width() == 0);
13238 }
13239 ios.width(25);
13240 right(ios);
13241 {
13242 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13243 std::string ex(str, iter.base());
13244 assert(ex == "******************1;2e+09");
13245 assert(ios.width() == 0);
13246 }
13247 ios.width(25);
13248 internal(ios);
13249 {
13250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13251 std::string ex(str, iter.base());
13252 assert(ex == "******************1;2e+09");
13253 assert(ios.width() == 0);
13254 }
13255 }
13256 }
13257 }
13258 showpos(ios);
13259 {
13260 noshowpoint(ios);
13261 {
13262 ios.imbue(lc);
13263 {
13264 ios.width(0);
13265 {
13266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13267 std::string ex(str, iter.base());
13268 assert(ex == "+1.2e+09");
13269 assert(ios.width() == 0);
13270 }
13271 ios.width(25);
13272 left(ios);
13273 {
13274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13275 std::string ex(str, iter.base());
13276 assert(ex == "+1.2e+09*****************");
13277 assert(ios.width() == 0);
13278 }
13279 ios.width(25);
13280 right(ios);
13281 {
13282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13283 std::string ex(str, iter.base());
13284 assert(ex == "*****************+1.2e+09");
13285 assert(ios.width() == 0);
13286 }
13287 ios.width(25);
13288 internal(ios);
13289 {
13290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13291 std::string ex(str, iter.base());
13292 assert(ex == "+*****************1.2e+09");
13293 assert(ios.width() == 0);
13294 }
13295 }
13296 ios.imbue(lg);
13297 {
13298 ios.width(0);
13299 {
13300 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13301 std::string ex(str, iter.base());
13302 assert(ex == "+1;2e+09");
13303 assert(ios.width() == 0);
13304 }
13305 ios.width(25);
13306 left(ios);
13307 {
13308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13309 std::string ex(str, iter.base());
13310 assert(ex == "+1;2e+09*****************");
13311 assert(ios.width() == 0);
13312 }
13313 ios.width(25);
13314 right(ios);
13315 {
13316 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13317 std::string ex(str, iter.base());
13318 assert(ex == "*****************+1;2e+09");
13319 assert(ios.width() == 0);
13320 }
13321 ios.width(25);
13322 internal(ios);
13323 {
13324 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13325 std::string ex(str, iter.base());
13326 assert(ex == "+*****************1;2e+09");
13327 assert(ios.width() == 0);
13328 }
13329 }
13330 }
13331 showpoint(ios);
13332 {
13333 ios.imbue(lc);
13334 {
13335 ios.width(0);
13336 {
13337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13338 std::string ex(str, iter.base());
13339 assert(ex == "+1.2e+09");
13340 assert(ios.width() == 0);
13341 }
13342 ios.width(25);
13343 left(ios);
13344 {
13345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13346 std::string ex(str, iter.base());
13347 assert(ex == "+1.2e+09*****************");
13348 assert(ios.width() == 0);
13349 }
13350 ios.width(25);
13351 right(ios);
13352 {
13353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13354 std::string ex(str, iter.base());
13355 assert(ex == "*****************+1.2e+09");
13356 assert(ios.width() == 0);
13357 }
13358 ios.width(25);
13359 internal(ios);
13360 {
13361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13362 std::string ex(str, iter.base());
13363 assert(ex == "+*****************1.2e+09");
13364 assert(ios.width() == 0);
13365 }
13366 }
13367 ios.imbue(lg);
13368 {
13369 ios.width(0);
13370 {
13371 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13372 std::string ex(str, iter.base());
13373 assert(ex == "+1;2e+09");
13374 assert(ios.width() == 0);
13375 }
13376 ios.width(25);
13377 left(ios);
13378 {
13379 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13380 std::string ex(str, iter.base());
13381 assert(ex == "+1;2e+09*****************");
13382 assert(ios.width() == 0);
13383 }
13384 ios.width(25);
13385 right(ios);
13386 {
13387 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13388 std::string ex(str, iter.base());
13389 assert(ex == "*****************+1;2e+09");
13390 assert(ios.width() == 0);
13391 }
13392 ios.width(25);
13393 internal(ios);
13394 {
13395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13396 std::string ex(str, iter.base());
13397 assert(ex == "+*****************1;2e+09");
13398 assert(ios.width() == 0);
13399 }
13400 }
13401 }
13402 }
13403 }
13404 uppercase(ios);
13405 {
13406 noshowpos(ios);
13407 {
13408 noshowpoint(ios);
13409 {
13410 ios.imbue(lc);
13411 {
13412 ios.width(0);
13413 {
13414 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13415 std::string ex(str, iter.base());
13416 assert(ex == "1.2E+09");
13417 assert(ios.width() == 0);
13418 }
13419 ios.width(25);
13420 left(ios);
13421 {
13422 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13423 std::string ex(str, iter.base());
13424 assert(ex == "1.2E+09******************");
13425 assert(ios.width() == 0);
13426 }
13427 ios.width(25);
13428 right(ios);
13429 {
13430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13431 std::string ex(str, iter.base());
13432 assert(ex == "******************1.2E+09");
13433 assert(ios.width() == 0);
13434 }
13435 ios.width(25);
13436 internal(ios);
13437 {
13438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13439 std::string ex(str, iter.base());
13440 assert(ex == "******************1.2E+09");
13441 assert(ios.width() == 0);
13442 }
13443 }
13444 ios.imbue(lg);
13445 {
13446 ios.width(0);
13447 {
13448 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13449 std::string ex(str, iter.base());
13450 assert(ex == "1;2E+09");
13451 assert(ios.width() == 0);
13452 }
13453 ios.width(25);
13454 left(ios);
13455 {
13456 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13457 std::string ex(str, iter.base());
13458 assert(ex == "1;2E+09******************");
13459 assert(ios.width() == 0);
13460 }
13461 ios.width(25);
13462 right(ios);
13463 {
13464 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13465 std::string ex(str, iter.base());
13466 assert(ex == "******************1;2E+09");
13467 assert(ios.width() == 0);
13468 }
13469 ios.width(25);
13470 internal(ios);
13471 {
13472 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13473 std::string ex(str, iter.base());
13474 assert(ex == "******************1;2E+09");
13475 assert(ios.width() == 0);
13476 }
13477 }
13478 }
13479 showpoint(ios);
13480 {
13481 ios.imbue(lc);
13482 {
13483 ios.width(0);
13484 {
13485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13486 std::string ex(str, iter.base());
13487 assert(ex == "1.2E+09");
13488 assert(ios.width() == 0);
13489 }
13490 ios.width(25);
13491 left(ios);
13492 {
13493 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13494 std::string ex(str, iter.base());
13495 assert(ex == "1.2E+09******************");
13496 assert(ios.width() == 0);
13497 }
13498 ios.width(25);
13499 right(ios);
13500 {
13501 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13502 std::string ex(str, iter.base());
13503 assert(ex == "******************1.2E+09");
13504 assert(ios.width() == 0);
13505 }
13506 ios.width(25);
13507 internal(ios);
13508 {
13509 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13510 std::string ex(str, iter.base());
13511 assert(ex == "******************1.2E+09");
13512 assert(ios.width() == 0);
13513 }
13514 }
13515 ios.imbue(lg);
13516 {
13517 ios.width(0);
13518 {
13519 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13520 std::string ex(str, iter.base());
13521 assert(ex == "1;2E+09");
13522 assert(ios.width() == 0);
13523 }
13524 ios.width(25);
13525 left(ios);
13526 {
13527 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13528 std::string ex(str, iter.base());
13529 assert(ex == "1;2E+09******************");
13530 assert(ios.width() == 0);
13531 }
13532 ios.width(25);
13533 right(ios);
13534 {
13535 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13536 std::string ex(str, iter.base());
13537 assert(ex == "******************1;2E+09");
13538 assert(ios.width() == 0);
13539 }
13540 ios.width(25);
13541 internal(ios);
13542 {
13543 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13544 std::string ex(str, iter.base());
13545 assert(ex == "******************1;2E+09");
13546 assert(ios.width() == 0);
13547 }
13548 }
13549 }
13550 }
13551 showpos(ios);
13552 {
13553 noshowpoint(ios);
13554 {
13555 ios.imbue(lc);
13556 {
13557 ios.width(0);
13558 {
13559 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13560 std::string ex(str, iter.base());
13561 assert(ex == "+1.2E+09");
13562 assert(ios.width() == 0);
13563 }
13564 ios.width(25);
13565 left(ios);
13566 {
13567 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13568 std::string ex(str, iter.base());
13569 assert(ex == "+1.2E+09*****************");
13570 assert(ios.width() == 0);
13571 }
13572 ios.width(25);
13573 right(ios);
13574 {
13575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13576 std::string ex(str, iter.base());
13577 assert(ex == "*****************+1.2E+09");
13578 assert(ios.width() == 0);
13579 }
13580 ios.width(25);
13581 internal(ios);
13582 {
13583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13584 std::string ex(str, iter.base());
13585 assert(ex == "+*****************1.2E+09");
13586 assert(ios.width() == 0);
13587 }
13588 }
13589 ios.imbue(lg);
13590 {
13591 ios.width(0);
13592 {
13593 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13594 std::string ex(str, iter.base());
13595 assert(ex == "+1;2E+09");
13596 assert(ios.width() == 0);
13597 }
13598 ios.width(25);
13599 left(ios);
13600 {
13601 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13602 std::string ex(str, iter.base());
13603 assert(ex == "+1;2E+09*****************");
13604 assert(ios.width() == 0);
13605 }
13606 ios.width(25);
13607 right(ios);
13608 {
13609 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13610 std::string ex(str, iter.base());
13611 assert(ex == "*****************+1;2E+09");
13612 assert(ios.width() == 0);
13613 }
13614 ios.width(25);
13615 internal(ios);
13616 {
13617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13618 std::string ex(str, iter.base());
13619 assert(ex == "+*****************1;2E+09");
13620 assert(ios.width() == 0);
13621 }
13622 }
13623 }
13624 showpoint(ios);
13625 {
13626 ios.imbue(lc);
13627 {
13628 ios.width(0);
13629 {
13630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13631 std::string ex(str, iter.base());
13632 assert(ex == "+1.2E+09");
13633 assert(ios.width() == 0);
13634 }
13635 ios.width(25);
13636 left(ios);
13637 {
13638 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13639 std::string ex(str, iter.base());
13640 assert(ex == "+1.2E+09*****************");
13641 assert(ios.width() == 0);
13642 }
13643 ios.width(25);
13644 right(ios);
13645 {
13646 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13647 std::string ex(str, iter.base());
13648 assert(ex == "*****************+1.2E+09");
13649 assert(ios.width() == 0);
13650 }
13651 ios.width(25);
13652 internal(ios);
13653 {
13654 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13655 std::string ex(str, iter.base());
13656 assert(ex == "+*****************1.2E+09");
13657 assert(ios.width() == 0);
13658 }
13659 }
13660 ios.imbue(lg);
13661 {
13662 ios.width(0);
13663 {
13664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13665 std::string ex(str, iter.base());
13666 assert(ex == "+1;2E+09");
13667 assert(ios.width() == 0);
13668 }
13669 ios.width(25);
13670 left(ios);
13671 {
13672 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13673 std::string ex(str, iter.base());
13674 assert(ex == "+1;2E+09*****************");
13675 assert(ios.width() == 0);
13676 }
13677 ios.width(25);
13678 right(ios);
13679 {
13680 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13681 std::string ex(str, iter.base());
13682 assert(ex == "*****************+1;2E+09");
13683 assert(ios.width() == 0);
13684 }
13685 ios.width(25);
13686 internal(ios);
13687 {
13688 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13689 std::string ex(str, iter.base());
13690 assert(ex == "+*****************1;2E+09");
13691 assert(ios.width() == 0);
13692 }
13693 }
13694 }
13695 }
13696 }
13697 }
13698 ios.precision(6);
13699 {
13700 }
13701 ios.precision(16);
13702 {
13703 }
13704 ios.precision(60);
13705 {
13706 nouppercase(ios);
13707 {
13708 noshowpos(ios);
13709 {
13710 noshowpoint(ios);
13711 {
13712 ios.imbue(lc);
13713 {
13714 ios.width(0);
13715 {
13716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13717 std::string ex(str, iter.base());
13718 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13719 assert(ios.width() == 0);
13720 }
13721 ios.width(25);
13722 left(ios);
13723 {
13724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13725 std::string ex(str, iter.base());
13726 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13727 assert(ios.width() == 0);
13728 }
13729 ios.width(25);
13730 right(ios);
13731 {
13732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13733 std::string ex(str, iter.base());
13734 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13735 assert(ios.width() == 0);
13736 }
13737 ios.width(25);
13738 internal(ios);
13739 {
13740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13741 std::string ex(str, iter.base());
13742 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13743 assert(ios.width() == 0);
13744 }
13745 }
13746 ios.imbue(lg);
13747 {
13748 ios.width(0);
13749 {
13750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13751 std::string ex(str, iter.base());
13752 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13753 assert(ios.width() == 0);
13754 }
13755 ios.width(25);
13756 left(ios);
13757 {
13758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13759 std::string ex(str, iter.base());
13760 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13761 assert(ios.width() == 0);
13762 }
13763 ios.width(25);
13764 right(ios);
13765 {
13766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13767 std::string ex(str, iter.base());
13768 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13769 assert(ios.width() == 0);
13770 }
13771 ios.width(25);
13772 internal(ios);
13773 {
13774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13775 std::string ex(str, iter.base());
13776 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13777 assert(ios.width() == 0);
13778 }
13779 }
13780 }
13781 showpoint(ios);
13782 {
13783 ios.imbue(lc);
13784 {
13785 ios.width(0);
13786 {
13787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13788 std::string ex(str, iter.base());
13789 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13790 assert(ios.width() == 0);
13791 }
13792 ios.width(25);
13793 left(ios);
13794 {
13795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13796 std::string ex(str, iter.base());
13797 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13798 assert(ios.width() == 0);
13799 }
13800 ios.width(25);
13801 right(ios);
13802 {
13803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13804 std::string ex(str, iter.base());
13805 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13806 assert(ios.width() == 0);
13807 }
13808 ios.width(25);
13809 internal(ios);
13810 {
13811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13812 std::string ex(str, iter.base());
13813 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
13814 assert(ios.width() == 0);
13815 }
13816 }
13817 ios.imbue(lg);
13818 {
13819 ios.width(0);
13820 {
13821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13822 std::string ex(str, iter.base());
13823 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13824 assert(ios.width() == 0);
13825 }
13826 ios.width(25);
13827 left(ios);
13828 {
13829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13830 std::string ex(str, iter.base());
13831 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13832 assert(ios.width() == 0);
13833 }
13834 ios.width(25);
13835 right(ios);
13836 {
13837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13838 std::string ex(str, iter.base());
13839 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13840 assert(ios.width() == 0);
13841 }
13842 ios.width(25);
13843 internal(ios);
13844 {
13845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13846 std::string ex(str, iter.base());
13847 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
13848 assert(ios.width() == 0);
13849 }
13850 }
13851 }
13852 }
13853 showpos(ios);
13854 {
13855 noshowpoint(ios);
13856 {
13857 ios.imbue(lc);
13858 {
13859 ios.width(0);
13860 {
13861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13862 std::string ex(str, iter.base());
13863 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13864 assert(ios.width() == 0);
13865 }
13866 ios.width(25);
13867 left(ios);
13868 {
13869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13870 std::string ex(str, iter.base());
13871 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13872 assert(ios.width() == 0);
13873 }
13874 ios.width(25);
13875 right(ios);
13876 {
13877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13878 std::string ex(str, iter.base());
13879 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13880 assert(ios.width() == 0);
13881 }
13882 ios.width(25);
13883 internal(ios);
13884 {
13885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13886 std::string ex(str, iter.base());
13887 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13888 assert(ios.width() == 0);
13889 }
13890 }
13891 ios.imbue(lg);
13892 {
13893 ios.width(0);
13894 {
13895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13896 std::string ex(str, iter.base());
13897 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13898 assert(ios.width() == 0);
13899 }
13900 ios.width(25);
13901 left(ios);
13902 {
13903 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13904 std::string ex(str, iter.base());
13905 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13906 assert(ios.width() == 0);
13907 }
13908 ios.width(25);
13909 right(ios);
13910 {
13911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13912 std::string ex(str, iter.base());
13913 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13914 assert(ios.width() == 0);
13915 }
13916 ios.width(25);
13917 internal(ios);
13918 {
13919 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13920 std::string ex(str, iter.base());
13921 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13922 assert(ios.width() == 0);
13923 }
13924 }
13925 }
13926 showpoint(ios);
13927 {
13928 ios.imbue(lc);
13929 {
13930 ios.width(0);
13931 {
13932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13933 std::string ex(str, iter.base());
13934 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13935 assert(ios.width() == 0);
13936 }
13937 ios.width(25);
13938 left(ios);
13939 {
13940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13941 std::string ex(str, iter.base());
13942 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13943 assert(ios.width() == 0);
13944 }
13945 ios.width(25);
13946 right(ios);
13947 {
13948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13949 std::string ex(str, iter.base());
13950 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13951 assert(ios.width() == 0);
13952 }
13953 ios.width(25);
13954 internal(ios);
13955 {
13956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13957 std::string ex(str, iter.base());
13958 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
13959 assert(ios.width() == 0);
13960 }
13961 }
13962 ios.imbue(lg);
13963 {
13964 ios.width(0);
13965 {
13966 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13967 std::string ex(str, iter.base());
13968 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13969 assert(ios.width() == 0);
13970 }
13971 ios.width(25);
13972 left(ios);
13973 {
13974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13975 std::string ex(str, iter.base());
13976 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13977 assert(ios.width() == 0);
13978 }
13979 ios.width(25);
13980 right(ios);
13981 {
13982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13983 std::string ex(str, iter.base());
13984 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13985 assert(ios.width() == 0);
13986 }
13987 ios.width(25);
13988 internal(ios);
13989 {
13990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13991 std::string ex(str, iter.base());
13992 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
13993 assert(ios.width() == 0);
13994 }
13995 }
13996 }
13997 }
13998 }
13999 uppercase(ios);
14000 {
14001 noshowpos(ios);
14002 {
14003 noshowpoint(ios);
14004 {
14005 ios.imbue(lc);
14006 {
14007 ios.width(0);
14008 {
14009 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14010 std::string ex(str, iter.base());
14011 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14012 assert(ios.width() == 0);
14013 }
14014 ios.width(25);
14015 left(ios);
14016 {
14017 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14018 std::string ex(str, iter.base());
14019 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14020 assert(ios.width() == 0);
14021 }
14022 ios.width(25);
14023 right(ios);
14024 {
14025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14026 std::string ex(str, iter.base());
14027 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14028 assert(ios.width() == 0);
14029 }
14030 ios.width(25);
14031 internal(ios);
14032 {
14033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14034 std::string ex(str, iter.base());
14035 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14036 assert(ios.width() == 0);
14037 }
14038 }
14039 ios.imbue(lg);
14040 {
14041 ios.width(0);
14042 {
14043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14044 std::string ex(str, iter.base());
14045 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14046 assert(ios.width() == 0);
14047 }
14048 ios.width(25);
14049 left(ios);
14050 {
14051 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14052 std::string ex(str, iter.base());
14053 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14054 assert(ios.width() == 0);
14055 }
14056 ios.width(25);
14057 right(ios);
14058 {
14059 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14060 std::string ex(str, iter.base());
14061 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14062 assert(ios.width() == 0);
14063 }
14064 ios.width(25);
14065 internal(ios);
14066 {
14067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14068 std::string ex(str, iter.base());
14069 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14070 assert(ios.width() == 0);
14071 }
14072 }
14073 }
14074 showpoint(ios);
14075 {
14076 ios.imbue(lc);
14077 {
14078 ios.width(0);
14079 {
14080 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14081 std::string ex(str, iter.base());
14082 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14083 assert(ios.width() == 0);
14084 }
14085 ios.width(25);
14086 left(ios);
14087 {
14088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14089 std::string ex(str, iter.base());
14090 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14091 assert(ios.width() == 0);
14092 }
14093 ios.width(25);
14094 right(ios);
14095 {
14096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14097 std::string ex(str, iter.base());
14098 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14099 assert(ios.width() == 0);
14100 }
14101 ios.width(25);
14102 internal(ios);
14103 {
14104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14105 std::string ex(str, iter.base());
14106 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
14107 assert(ios.width() == 0);
14108 }
14109 }
14110 ios.imbue(lg);
14111 {
14112 ios.width(0);
14113 {
14114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14115 std::string ex(str, iter.base());
14116 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14117 assert(ios.width() == 0);
14118 }
14119 ios.width(25);
14120 left(ios);
14121 {
14122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14123 std::string ex(str, iter.base());
14124 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14125 assert(ios.width() == 0);
14126 }
14127 ios.width(25);
14128 right(ios);
14129 {
14130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14131 std::string ex(str, iter.base());
14132 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14133 assert(ios.width() == 0);
14134 }
14135 ios.width(25);
14136 internal(ios);
14137 {
14138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14139 std::string ex(str, iter.base());
14140 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
14141 assert(ios.width() == 0);
14142 }
14143 }
14144 }
14145 }
14146 showpos(ios);
14147 {
14148 noshowpoint(ios);
14149 {
14150 ios.imbue(lc);
14151 {
14152 ios.width(0);
14153 {
14154 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14155 std::string ex(str, iter.base());
14156 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14157 assert(ios.width() == 0);
14158 }
14159 ios.width(25);
14160 left(ios);
14161 {
14162 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14163 std::string ex(str, iter.base());
14164 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14165 assert(ios.width() == 0);
14166 }
14167 ios.width(25);
14168 right(ios);
14169 {
14170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14171 std::string ex(str, iter.base());
14172 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14173 assert(ios.width() == 0);
14174 }
14175 ios.width(25);
14176 internal(ios);
14177 {
14178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14179 std::string ex(str, iter.base());
14180 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14181 assert(ios.width() == 0);
14182 }
14183 }
14184 ios.imbue(lg);
14185 {
14186 ios.width(0);
14187 {
14188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14189 std::string ex(str, iter.base());
14190 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14191 assert(ios.width() == 0);
14192 }
14193 ios.width(25);
14194 left(ios);
14195 {
14196 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14197 std::string ex(str, iter.base());
14198 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14199 assert(ios.width() == 0);
14200 }
14201 ios.width(25);
14202 right(ios);
14203 {
14204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14205 std::string ex(str, iter.base());
14206 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14207 assert(ios.width() == 0);
14208 }
14209 ios.width(25);
14210 internal(ios);
14211 {
14212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14213 std::string ex(str, iter.base());
14214 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14215 assert(ios.width() == 0);
14216 }
14217 }
14218 }
14219 showpoint(ios);
14220 {
14221 ios.imbue(lc);
14222 {
14223 ios.width(0);
14224 {
14225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14226 std::string ex(str, iter.base());
14227 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14228 assert(ios.width() == 0);
14229 }
14230 ios.width(25);
14231 left(ios);
14232 {
14233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14234 std::string ex(str, iter.base());
14235 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14236 assert(ios.width() == 0);
14237 }
14238 ios.width(25);
14239 right(ios);
14240 {
14241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14242 std::string ex(str, iter.base());
14243 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14244 assert(ios.width() == 0);
14245 }
14246 ios.width(25);
14247 internal(ios);
14248 {
14249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14250 std::string ex(str, iter.base());
14251 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
14252 assert(ios.width() == 0);
14253 }
14254 }
14255 ios.imbue(lg);
14256 {
14257 ios.width(0);
14258 {
14259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14260 std::string ex(str, iter.base());
14261 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14262 assert(ios.width() == 0);
14263 }
14264 ios.width(25);
14265 left(ios);
14266 {
14267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14268 std::string ex(str, iter.base());
14269 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14270 assert(ios.width() == 0);
14271 }
14272 ios.width(25);
14273 right(ios);
14274 {
14275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14276 std::string ex(str, iter.base());
14277 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14278 assert(ios.width() == 0);
14279 }
14280 ios.width(25);
14281 internal(ios);
14282 {
14283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14284 std::string ex(str, iter.base());
14285 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
14286 assert(ios.width() == 0);
14287 }
14288 }
14289 }
14290 }
14291 }
14292 }
14293 }
14294 }
14295 }
14296
test7()14297 void test7()
14298 {
14299 char str[200];
14300 output_iterator<char*> iter;
14301 std::locale lc = std::locale::classic();
14302 std::locale lg(lc, new my_numpunct);
14303 const my_facet f(1);
14304 {
14305 double v = -0.;
14306 std::ios ios(0);
14307 hexfloat(ios);
14308 // %a
14309 {
14310 ios.precision(0);
14311 {
14312 nouppercase(ios);
14313 {
14314 noshowpos(ios);
14315 {
14316 noshowpoint(ios);
14317 {
14318 ios.imbue(lc);
14319 {
14320 ios.width(0);
14321 {
14322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14323 std::string ex(str, iter.base());
14324 assert(ex == "-0x0p+0");
14325 assert(ios.width() == 0);
14326 }
14327 ios.width(25);
14328 left(ios);
14329 {
14330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14331 std::string ex(str, iter.base());
14332 assert(ex == "-0x0p+0******************");
14333 assert(ios.width() == 0);
14334 }
14335 ios.width(25);
14336 right(ios);
14337 {
14338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14339 std::string ex(str, iter.base());
14340 assert(ex == "******************-0x0p+0");
14341 assert(ios.width() == 0);
14342 }
14343 ios.width(25);
14344 internal(ios);
14345 {
14346 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14347 std::string ex(str, iter.base());
14348 assert(ex == "-******************0x0p+0");
14349 assert(ios.width() == 0);
14350 }
14351 }
14352 ios.imbue(lg);
14353 {
14354 ios.width(0);
14355 {
14356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14357 std::string ex(str, iter.base());
14358 assert(ex == "-0x0p+0");
14359 assert(ios.width() == 0);
14360 }
14361 ios.width(25);
14362 left(ios);
14363 {
14364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14365 std::string ex(str, iter.base());
14366 assert(ex == "-0x0p+0******************");
14367 assert(ios.width() == 0);
14368 }
14369 ios.width(25);
14370 right(ios);
14371 {
14372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14373 std::string ex(str, iter.base());
14374 assert(ex == "******************-0x0p+0");
14375 assert(ios.width() == 0);
14376 }
14377 ios.width(25);
14378 internal(ios);
14379 {
14380 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14381 std::string ex(str, iter.base());
14382 assert(ex == "-******************0x0p+0");
14383 assert(ios.width() == 0);
14384 }
14385 }
14386 }
14387 showpoint(ios);
14388 {
14389 ios.imbue(lc);
14390 {
14391 ios.width(0);
14392 {
14393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14394 std::string ex(str, iter.base());
14395 assert(ex == "-0x0.p+0");
14396 assert(ios.width() == 0);
14397 }
14398 ios.width(25);
14399 left(ios);
14400 {
14401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14402 std::string ex(str, iter.base());
14403 assert(ex == "-0x0.p+0*****************");
14404 assert(ios.width() == 0);
14405 }
14406 ios.width(25);
14407 right(ios);
14408 {
14409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14410 std::string ex(str, iter.base());
14411 assert(ex == "*****************-0x0.p+0");
14412 assert(ios.width() == 0);
14413 }
14414 ios.width(25);
14415 internal(ios);
14416 {
14417 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14418 std::string ex(str, iter.base());
14419 assert(ex == "-*****************0x0.p+0");
14420 assert(ios.width() == 0);
14421 }
14422 }
14423 ios.imbue(lg);
14424 {
14425 ios.width(0);
14426 {
14427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14428 std::string ex(str, iter.base());
14429 assert(ex == "-0x0;p+0");
14430 assert(ios.width() == 0);
14431 }
14432 ios.width(25);
14433 left(ios);
14434 {
14435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14436 std::string ex(str, iter.base());
14437 assert(ex == "-0x0;p+0*****************");
14438 assert(ios.width() == 0);
14439 }
14440 ios.width(25);
14441 right(ios);
14442 {
14443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14444 std::string ex(str, iter.base());
14445 assert(ex == "*****************-0x0;p+0");
14446 assert(ios.width() == 0);
14447 }
14448 ios.width(25);
14449 internal(ios);
14450 {
14451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14452 std::string ex(str, iter.base());
14453 assert(ex == "-*****************0x0;p+0");
14454 assert(ios.width() == 0);
14455 }
14456 }
14457 }
14458 }
14459 showpos(ios);
14460 {
14461 noshowpoint(ios);
14462 {
14463 ios.imbue(lc);
14464 {
14465 ios.width(0);
14466 {
14467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14468 std::string ex(str, iter.base());
14469 assert(ex == "-0x0p+0");
14470 assert(ios.width() == 0);
14471 }
14472 ios.width(25);
14473 left(ios);
14474 {
14475 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14476 std::string ex(str, iter.base());
14477 assert(ex == "-0x0p+0******************");
14478 assert(ios.width() == 0);
14479 }
14480 ios.width(25);
14481 right(ios);
14482 {
14483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14484 std::string ex(str, iter.base());
14485 assert(ex == "******************-0x0p+0");
14486 assert(ios.width() == 0);
14487 }
14488 ios.width(25);
14489 internal(ios);
14490 {
14491 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14492 std::string ex(str, iter.base());
14493 assert(ex == "-******************0x0p+0");
14494 assert(ios.width() == 0);
14495 }
14496 }
14497 ios.imbue(lg);
14498 {
14499 ios.width(0);
14500 {
14501 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14502 std::string ex(str, iter.base());
14503 assert(ex == "-0x0p+0");
14504 assert(ios.width() == 0);
14505 }
14506 ios.width(25);
14507 left(ios);
14508 {
14509 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14510 std::string ex(str, iter.base());
14511 assert(ex == "-0x0p+0******************");
14512 assert(ios.width() == 0);
14513 }
14514 ios.width(25);
14515 right(ios);
14516 {
14517 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14518 std::string ex(str, iter.base());
14519 assert(ex == "******************-0x0p+0");
14520 assert(ios.width() == 0);
14521 }
14522 ios.width(25);
14523 internal(ios);
14524 {
14525 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14526 std::string ex(str, iter.base());
14527 assert(ex == "-******************0x0p+0");
14528 assert(ios.width() == 0);
14529 }
14530 }
14531 }
14532 showpoint(ios);
14533 {
14534 ios.imbue(lc);
14535 {
14536 ios.width(0);
14537 {
14538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14539 std::string ex(str, iter.base());
14540 assert(ex == "-0x0.p+0");
14541 assert(ios.width() == 0);
14542 }
14543 ios.width(25);
14544 left(ios);
14545 {
14546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14547 std::string ex(str, iter.base());
14548 assert(ex == "-0x0.p+0*****************");
14549 assert(ios.width() == 0);
14550 }
14551 ios.width(25);
14552 right(ios);
14553 {
14554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14555 std::string ex(str, iter.base());
14556 assert(ex == "*****************-0x0.p+0");
14557 assert(ios.width() == 0);
14558 }
14559 ios.width(25);
14560 internal(ios);
14561 {
14562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14563 std::string ex(str, iter.base());
14564 assert(ex == "-*****************0x0.p+0");
14565 assert(ios.width() == 0);
14566 }
14567 }
14568 ios.imbue(lg);
14569 {
14570 ios.width(0);
14571 {
14572 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14573 std::string ex(str, iter.base());
14574 assert(ex == "-0x0;p+0");
14575 assert(ios.width() == 0);
14576 }
14577 ios.width(25);
14578 left(ios);
14579 {
14580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14581 std::string ex(str, iter.base());
14582 assert(ex == "-0x0;p+0*****************");
14583 assert(ios.width() == 0);
14584 }
14585 ios.width(25);
14586 right(ios);
14587 {
14588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14589 std::string ex(str, iter.base());
14590 assert(ex == "*****************-0x0;p+0");
14591 assert(ios.width() == 0);
14592 }
14593 ios.width(25);
14594 internal(ios);
14595 {
14596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14597 std::string ex(str, iter.base());
14598 assert(ex == "-*****************0x0;p+0");
14599 assert(ios.width() == 0);
14600 }
14601 }
14602 }
14603 }
14604 }
14605 uppercase(ios);
14606 {
14607 noshowpos(ios);
14608 {
14609 noshowpoint(ios);
14610 {
14611 ios.imbue(lc);
14612 {
14613 ios.width(0);
14614 {
14615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14616 std::string ex(str, iter.base());
14617 assert(ex == "-0X0P+0");
14618 assert(ios.width() == 0);
14619 }
14620 ios.width(25);
14621 left(ios);
14622 {
14623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14624 std::string ex(str, iter.base());
14625 assert(ex == "-0X0P+0******************");
14626 assert(ios.width() == 0);
14627 }
14628 ios.width(25);
14629 right(ios);
14630 {
14631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14632 std::string ex(str, iter.base());
14633 assert(ex == "******************-0X0P+0");
14634 assert(ios.width() == 0);
14635 }
14636 ios.width(25);
14637 internal(ios);
14638 {
14639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14640 std::string ex(str, iter.base());
14641 assert(ex == "-******************0X0P+0");
14642 assert(ios.width() == 0);
14643 }
14644 }
14645 ios.imbue(lg);
14646 {
14647 ios.width(0);
14648 {
14649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14650 std::string ex(str, iter.base());
14651 assert(ex == "-0X0P+0");
14652 assert(ios.width() == 0);
14653 }
14654 ios.width(25);
14655 left(ios);
14656 {
14657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14658 std::string ex(str, iter.base());
14659 assert(ex == "-0X0P+0******************");
14660 assert(ios.width() == 0);
14661 }
14662 ios.width(25);
14663 right(ios);
14664 {
14665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14666 std::string ex(str, iter.base());
14667 assert(ex == "******************-0X0P+0");
14668 assert(ios.width() == 0);
14669 }
14670 ios.width(25);
14671 internal(ios);
14672 {
14673 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14674 std::string ex(str, iter.base());
14675 assert(ex == "-******************0X0P+0");
14676 assert(ios.width() == 0);
14677 }
14678 }
14679 }
14680 showpoint(ios);
14681 {
14682 ios.imbue(lc);
14683 {
14684 ios.width(0);
14685 {
14686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14687 std::string ex(str, iter.base());
14688 assert(ex == "-0X0.P+0");
14689 assert(ios.width() == 0);
14690 }
14691 ios.width(25);
14692 left(ios);
14693 {
14694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14695 std::string ex(str, iter.base());
14696 assert(ex == "-0X0.P+0*****************");
14697 assert(ios.width() == 0);
14698 }
14699 ios.width(25);
14700 right(ios);
14701 {
14702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14703 std::string ex(str, iter.base());
14704 assert(ex == "*****************-0X0.P+0");
14705 assert(ios.width() == 0);
14706 }
14707 ios.width(25);
14708 internal(ios);
14709 {
14710 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14711 std::string ex(str, iter.base());
14712 assert(ex == "-*****************0X0.P+0");
14713 assert(ios.width() == 0);
14714 }
14715 }
14716 ios.imbue(lg);
14717 {
14718 ios.width(0);
14719 {
14720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14721 std::string ex(str, iter.base());
14722 assert(ex == "-0X0;P+0");
14723 assert(ios.width() == 0);
14724 }
14725 ios.width(25);
14726 left(ios);
14727 {
14728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14729 std::string ex(str, iter.base());
14730 assert(ex == "-0X0;P+0*****************");
14731 assert(ios.width() == 0);
14732 }
14733 ios.width(25);
14734 right(ios);
14735 {
14736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14737 std::string ex(str, iter.base());
14738 assert(ex == "*****************-0X0;P+0");
14739 assert(ios.width() == 0);
14740 }
14741 ios.width(25);
14742 internal(ios);
14743 {
14744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14745 std::string ex(str, iter.base());
14746 assert(ex == "-*****************0X0;P+0");
14747 assert(ios.width() == 0);
14748 }
14749 }
14750 }
14751 }
14752 showpos(ios);
14753 {
14754 noshowpoint(ios);
14755 {
14756 ios.imbue(lc);
14757 {
14758 ios.width(0);
14759 {
14760 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14761 std::string ex(str, iter.base());
14762 assert(ex == "-0X0P+0");
14763 assert(ios.width() == 0);
14764 }
14765 ios.width(25);
14766 left(ios);
14767 {
14768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14769 std::string ex(str, iter.base());
14770 assert(ex == "-0X0P+0******************");
14771 assert(ios.width() == 0);
14772 }
14773 ios.width(25);
14774 right(ios);
14775 {
14776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14777 std::string ex(str, iter.base());
14778 assert(ex == "******************-0X0P+0");
14779 assert(ios.width() == 0);
14780 }
14781 ios.width(25);
14782 internal(ios);
14783 {
14784 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14785 std::string ex(str, iter.base());
14786 assert(ex == "-******************0X0P+0");
14787 assert(ios.width() == 0);
14788 }
14789 }
14790 ios.imbue(lg);
14791 {
14792 ios.width(0);
14793 {
14794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14795 std::string ex(str, iter.base());
14796 assert(ex == "-0X0P+0");
14797 assert(ios.width() == 0);
14798 }
14799 ios.width(25);
14800 left(ios);
14801 {
14802 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14803 std::string ex(str, iter.base());
14804 assert(ex == "-0X0P+0******************");
14805 assert(ios.width() == 0);
14806 }
14807 ios.width(25);
14808 right(ios);
14809 {
14810 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14811 std::string ex(str, iter.base());
14812 assert(ex == "******************-0X0P+0");
14813 assert(ios.width() == 0);
14814 }
14815 ios.width(25);
14816 internal(ios);
14817 {
14818 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14819 std::string ex(str, iter.base());
14820 assert(ex == "-******************0X0P+0");
14821 assert(ios.width() == 0);
14822 }
14823 }
14824 }
14825 showpoint(ios);
14826 {
14827 ios.imbue(lc);
14828 {
14829 ios.width(0);
14830 {
14831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14832 std::string ex(str, iter.base());
14833 assert(ex == "-0X0.P+0");
14834 assert(ios.width() == 0);
14835 }
14836 ios.width(25);
14837 left(ios);
14838 {
14839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14840 std::string ex(str, iter.base());
14841 assert(ex == "-0X0.P+0*****************");
14842 assert(ios.width() == 0);
14843 }
14844 ios.width(25);
14845 right(ios);
14846 {
14847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14848 std::string ex(str, iter.base());
14849 assert(ex == "*****************-0X0.P+0");
14850 assert(ios.width() == 0);
14851 }
14852 ios.width(25);
14853 internal(ios);
14854 {
14855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14856 std::string ex(str, iter.base());
14857 assert(ex == "-*****************0X0.P+0");
14858 assert(ios.width() == 0);
14859 }
14860 }
14861 ios.imbue(lg);
14862 {
14863 ios.width(0);
14864 {
14865 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14866 std::string ex(str, iter.base());
14867 assert(ex == "-0X0;P+0");
14868 assert(ios.width() == 0);
14869 }
14870 ios.width(25);
14871 left(ios);
14872 {
14873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14874 std::string ex(str, iter.base());
14875 assert(ex == "-0X0;P+0*****************");
14876 assert(ios.width() == 0);
14877 }
14878 ios.width(25);
14879 right(ios);
14880 {
14881 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14882 std::string ex(str, iter.base());
14883 assert(ex == "*****************-0X0;P+0");
14884 assert(ios.width() == 0);
14885 }
14886 ios.width(25);
14887 internal(ios);
14888 {
14889 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14890 std::string ex(str, iter.base());
14891 assert(ex == "-*****************0X0;P+0");
14892 assert(ios.width() == 0);
14893 }
14894 }
14895 }
14896 }
14897 }
14898 }
14899 ios.precision(1);
14900 {
14901 nouppercase(ios);
14902 {
14903 noshowpos(ios);
14904 {
14905 noshowpoint(ios);
14906 {
14907 ios.imbue(lc);
14908 {
14909 ios.width(0);
14910 {
14911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14912 std::string ex(str, iter.base());
14913 assert(ex == "-0x0p+0");
14914 assert(ios.width() == 0);
14915 }
14916 ios.width(25);
14917 left(ios);
14918 {
14919 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14920 std::string ex(str, iter.base());
14921 assert(ex == "-0x0p+0******************");
14922 assert(ios.width() == 0);
14923 }
14924 ios.width(25);
14925 right(ios);
14926 {
14927 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14928 std::string ex(str, iter.base());
14929 assert(ex == "******************-0x0p+0");
14930 assert(ios.width() == 0);
14931 }
14932 ios.width(25);
14933 internal(ios);
14934 {
14935 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14936 std::string ex(str, iter.base());
14937 assert(ex == "-******************0x0p+0");
14938 assert(ios.width() == 0);
14939 }
14940 }
14941 ios.imbue(lg);
14942 {
14943 ios.width(0);
14944 {
14945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14946 std::string ex(str, iter.base());
14947 assert(ex == "-0x0p+0");
14948 assert(ios.width() == 0);
14949 }
14950 ios.width(25);
14951 left(ios);
14952 {
14953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14954 std::string ex(str, iter.base());
14955 assert(ex == "-0x0p+0******************");
14956 assert(ios.width() == 0);
14957 }
14958 ios.width(25);
14959 right(ios);
14960 {
14961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14962 std::string ex(str, iter.base());
14963 assert(ex == "******************-0x0p+0");
14964 assert(ios.width() == 0);
14965 }
14966 ios.width(25);
14967 internal(ios);
14968 {
14969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14970 std::string ex(str, iter.base());
14971 assert(ex == "-******************0x0p+0");
14972 assert(ios.width() == 0);
14973 }
14974 }
14975 }
14976 showpoint(ios);
14977 {
14978 ios.imbue(lc);
14979 {
14980 ios.width(0);
14981 {
14982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14983 std::string ex(str, iter.base());
14984 assert(ex == "-0x0.p+0");
14985 assert(ios.width() == 0);
14986 }
14987 ios.width(25);
14988 left(ios);
14989 {
14990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14991 std::string ex(str, iter.base());
14992 assert(ex == "-0x0.p+0*****************");
14993 assert(ios.width() == 0);
14994 }
14995 ios.width(25);
14996 right(ios);
14997 {
14998 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14999 std::string ex(str, iter.base());
15000 assert(ex == "*****************-0x0.p+0");
15001 assert(ios.width() == 0);
15002 }
15003 ios.width(25);
15004 internal(ios);
15005 {
15006 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15007 std::string ex(str, iter.base());
15008 assert(ex == "-*****************0x0.p+0");
15009 assert(ios.width() == 0);
15010 }
15011 }
15012 ios.imbue(lg);
15013 {
15014 ios.width(0);
15015 {
15016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15017 std::string ex(str, iter.base());
15018 assert(ex == "-0x0;p+0");
15019 assert(ios.width() == 0);
15020 }
15021 ios.width(25);
15022 left(ios);
15023 {
15024 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15025 std::string ex(str, iter.base());
15026 assert(ex == "-0x0;p+0*****************");
15027 assert(ios.width() == 0);
15028 }
15029 ios.width(25);
15030 right(ios);
15031 {
15032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15033 std::string ex(str, iter.base());
15034 assert(ex == "*****************-0x0;p+0");
15035 assert(ios.width() == 0);
15036 }
15037 ios.width(25);
15038 internal(ios);
15039 {
15040 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15041 std::string ex(str, iter.base());
15042 assert(ex == "-*****************0x0;p+0");
15043 assert(ios.width() == 0);
15044 }
15045 }
15046 }
15047 }
15048 showpos(ios);
15049 {
15050 noshowpoint(ios);
15051 {
15052 ios.imbue(lc);
15053 {
15054 ios.width(0);
15055 {
15056 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15057 std::string ex(str, iter.base());
15058 assert(ex == "-0x0p+0");
15059 assert(ios.width() == 0);
15060 }
15061 ios.width(25);
15062 left(ios);
15063 {
15064 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15065 std::string ex(str, iter.base());
15066 assert(ex == "-0x0p+0******************");
15067 assert(ios.width() == 0);
15068 }
15069 ios.width(25);
15070 right(ios);
15071 {
15072 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15073 std::string ex(str, iter.base());
15074 assert(ex == "******************-0x0p+0");
15075 assert(ios.width() == 0);
15076 }
15077 ios.width(25);
15078 internal(ios);
15079 {
15080 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15081 std::string ex(str, iter.base());
15082 assert(ex == "-******************0x0p+0");
15083 assert(ios.width() == 0);
15084 }
15085 }
15086 ios.imbue(lg);
15087 {
15088 ios.width(0);
15089 {
15090 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15091 std::string ex(str, iter.base());
15092 assert(ex == "-0x0p+0");
15093 assert(ios.width() == 0);
15094 }
15095 ios.width(25);
15096 left(ios);
15097 {
15098 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15099 std::string ex(str, iter.base());
15100 assert(ex == "-0x0p+0******************");
15101 assert(ios.width() == 0);
15102 }
15103 ios.width(25);
15104 right(ios);
15105 {
15106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15107 std::string ex(str, iter.base());
15108 assert(ex == "******************-0x0p+0");
15109 assert(ios.width() == 0);
15110 }
15111 ios.width(25);
15112 internal(ios);
15113 {
15114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15115 std::string ex(str, iter.base());
15116 assert(ex == "-******************0x0p+0");
15117 assert(ios.width() == 0);
15118 }
15119 }
15120 }
15121 showpoint(ios);
15122 {
15123 ios.imbue(lc);
15124 {
15125 ios.width(0);
15126 {
15127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15128 std::string ex(str, iter.base());
15129 assert(ex == "-0x0.p+0");
15130 assert(ios.width() == 0);
15131 }
15132 ios.width(25);
15133 left(ios);
15134 {
15135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15136 std::string ex(str, iter.base());
15137 assert(ex == "-0x0.p+0*****************");
15138 assert(ios.width() == 0);
15139 }
15140 ios.width(25);
15141 right(ios);
15142 {
15143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15144 std::string ex(str, iter.base());
15145 assert(ex == "*****************-0x0.p+0");
15146 assert(ios.width() == 0);
15147 }
15148 ios.width(25);
15149 internal(ios);
15150 {
15151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15152 std::string ex(str, iter.base());
15153 assert(ex == "-*****************0x0.p+0");
15154 assert(ios.width() == 0);
15155 }
15156 }
15157 ios.imbue(lg);
15158 {
15159 ios.width(0);
15160 {
15161 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15162 std::string ex(str, iter.base());
15163 assert(ex == "-0x0;p+0");
15164 assert(ios.width() == 0);
15165 }
15166 ios.width(25);
15167 left(ios);
15168 {
15169 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15170 std::string ex(str, iter.base());
15171 assert(ex == "-0x0;p+0*****************");
15172 assert(ios.width() == 0);
15173 }
15174 ios.width(25);
15175 right(ios);
15176 {
15177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15178 std::string ex(str, iter.base());
15179 assert(ex == "*****************-0x0;p+0");
15180 assert(ios.width() == 0);
15181 }
15182 ios.width(25);
15183 internal(ios);
15184 {
15185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15186 std::string ex(str, iter.base());
15187 assert(ex == "-*****************0x0;p+0");
15188 assert(ios.width() == 0);
15189 }
15190 }
15191 }
15192 }
15193 }
15194 uppercase(ios);
15195 {
15196 noshowpos(ios);
15197 {
15198 noshowpoint(ios);
15199 {
15200 ios.imbue(lc);
15201 {
15202 ios.width(0);
15203 {
15204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15205 std::string ex(str, iter.base());
15206 assert(ex == "-0X0P+0");
15207 assert(ios.width() == 0);
15208 }
15209 ios.width(25);
15210 left(ios);
15211 {
15212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15213 std::string ex(str, iter.base());
15214 assert(ex == "-0X0P+0******************");
15215 assert(ios.width() == 0);
15216 }
15217 ios.width(25);
15218 right(ios);
15219 {
15220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15221 std::string ex(str, iter.base());
15222 assert(ex == "******************-0X0P+0");
15223 assert(ios.width() == 0);
15224 }
15225 ios.width(25);
15226 internal(ios);
15227 {
15228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15229 std::string ex(str, iter.base());
15230 assert(ex == "-******************0X0P+0");
15231 assert(ios.width() == 0);
15232 }
15233 }
15234 ios.imbue(lg);
15235 {
15236 ios.width(0);
15237 {
15238 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15239 std::string ex(str, iter.base());
15240 assert(ex == "-0X0P+0");
15241 assert(ios.width() == 0);
15242 }
15243 ios.width(25);
15244 left(ios);
15245 {
15246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15247 std::string ex(str, iter.base());
15248 assert(ex == "-0X0P+0******************");
15249 assert(ios.width() == 0);
15250 }
15251 ios.width(25);
15252 right(ios);
15253 {
15254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15255 std::string ex(str, iter.base());
15256 assert(ex == "******************-0X0P+0");
15257 assert(ios.width() == 0);
15258 }
15259 ios.width(25);
15260 internal(ios);
15261 {
15262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15263 std::string ex(str, iter.base());
15264 assert(ex == "-******************0X0P+0");
15265 assert(ios.width() == 0);
15266 }
15267 }
15268 }
15269 showpoint(ios);
15270 {
15271 ios.imbue(lc);
15272 {
15273 ios.width(0);
15274 {
15275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15276 std::string ex(str, iter.base());
15277 assert(ex == "-0X0.P+0");
15278 assert(ios.width() == 0);
15279 }
15280 ios.width(25);
15281 left(ios);
15282 {
15283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15284 std::string ex(str, iter.base());
15285 assert(ex == "-0X0.P+0*****************");
15286 assert(ios.width() == 0);
15287 }
15288 ios.width(25);
15289 right(ios);
15290 {
15291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15292 std::string ex(str, iter.base());
15293 assert(ex == "*****************-0X0.P+0");
15294 assert(ios.width() == 0);
15295 }
15296 ios.width(25);
15297 internal(ios);
15298 {
15299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15300 std::string ex(str, iter.base());
15301 assert(ex == "-*****************0X0.P+0");
15302 assert(ios.width() == 0);
15303 }
15304 }
15305 ios.imbue(lg);
15306 {
15307 ios.width(0);
15308 {
15309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15310 std::string ex(str, iter.base());
15311 assert(ex == "-0X0;P+0");
15312 assert(ios.width() == 0);
15313 }
15314 ios.width(25);
15315 left(ios);
15316 {
15317 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15318 std::string ex(str, iter.base());
15319 assert(ex == "-0X0;P+0*****************");
15320 assert(ios.width() == 0);
15321 }
15322 ios.width(25);
15323 right(ios);
15324 {
15325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15326 std::string ex(str, iter.base());
15327 assert(ex == "*****************-0X0;P+0");
15328 assert(ios.width() == 0);
15329 }
15330 ios.width(25);
15331 internal(ios);
15332 {
15333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15334 std::string ex(str, iter.base());
15335 assert(ex == "-*****************0X0;P+0");
15336 assert(ios.width() == 0);
15337 }
15338 }
15339 }
15340 }
15341 showpos(ios);
15342 {
15343 noshowpoint(ios);
15344 {
15345 ios.imbue(lc);
15346 {
15347 ios.width(0);
15348 {
15349 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15350 std::string ex(str, iter.base());
15351 assert(ex == "-0X0P+0");
15352 assert(ios.width() == 0);
15353 }
15354 ios.width(25);
15355 left(ios);
15356 {
15357 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15358 std::string ex(str, iter.base());
15359 assert(ex == "-0X0P+0******************");
15360 assert(ios.width() == 0);
15361 }
15362 ios.width(25);
15363 right(ios);
15364 {
15365 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15366 std::string ex(str, iter.base());
15367 assert(ex == "******************-0X0P+0");
15368 assert(ios.width() == 0);
15369 }
15370 ios.width(25);
15371 internal(ios);
15372 {
15373 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15374 std::string ex(str, iter.base());
15375 assert(ex == "-******************0X0P+0");
15376 assert(ios.width() == 0);
15377 }
15378 }
15379 ios.imbue(lg);
15380 {
15381 ios.width(0);
15382 {
15383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15384 std::string ex(str, iter.base());
15385 assert(ex == "-0X0P+0");
15386 assert(ios.width() == 0);
15387 }
15388 ios.width(25);
15389 left(ios);
15390 {
15391 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15392 std::string ex(str, iter.base());
15393 assert(ex == "-0X0P+0******************");
15394 assert(ios.width() == 0);
15395 }
15396 ios.width(25);
15397 right(ios);
15398 {
15399 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15400 std::string ex(str, iter.base());
15401 assert(ex == "******************-0X0P+0");
15402 assert(ios.width() == 0);
15403 }
15404 ios.width(25);
15405 internal(ios);
15406 {
15407 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15408 std::string ex(str, iter.base());
15409 assert(ex == "-******************0X0P+0");
15410 assert(ios.width() == 0);
15411 }
15412 }
15413 }
15414 showpoint(ios);
15415 {
15416 ios.imbue(lc);
15417 {
15418 ios.width(0);
15419 {
15420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15421 std::string ex(str, iter.base());
15422 assert(ex == "-0X0.P+0");
15423 assert(ios.width() == 0);
15424 }
15425 ios.width(25);
15426 left(ios);
15427 {
15428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15429 std::string ex(str, iter.base());
15430 assert(ex == "-0X0.P+0*****************");
15431 assert(ios.width() == 0);
15432 }
15433 ios.width(25);
15434 right(ios);
15435 {
15436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15437 std::string ex(str, iter.base());
15438 assert(ex == "*****************-0X0.P+0");
15439 assert(ios.width() == 0);
15440 }
15441 ios.width(25);
15442 internal(ios);
15443 {
15444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15445 std::string ex(str, iter.base());
15446 assert(ex == "-*****************0X0.P+0");
15447 assert(ios.width() == 0);
15448 }
15449 }
15450 ios.imbue(lg);
15451 {
15452 ios.width(0);
15453 {
15454 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15455 std::string ex(str, iter.base());
15456 assert(ex == "-0X0;P+0");
15457 assert(ios.width() == 0);
15458 }
15459 ios.width(25);
15460 left(ios);
15461 {
15462 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15463 std::string ex(str, iter.base());
15464 assert(ex == "-0X0;P+0*****************");
15465 assert(ios.width() == 0);
15466 }
15467 ios.width(25);
15468 right(ios);
15469 {
15470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15471 std::string ex(str, iter.base());
15472 assert(ex == "*****************-0X0;P+0");
15473 assert(ios.width() == 0);
15474 }
15475 ios.width(25);
15476 internal(ios);
15477 {
15478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15479 std::string ex(str, iter.base());
15480 assert(ex == "-*****************0X0;P+0");
15481 assert(ios.width() == 0);
15482 }
15483 }
15484 }
15485 }
15486 }
15487 }
15488 ios.precision(6);
15489 {
15490 nouppercase(ios);
15491 {
15492 noshowpos(ios);
15493 {
15494 noshowpoint(ios);
15495 {
15496 ios.imbue(lc);
15497 {
15498 ios.width(0);
15499 {
15500 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15501 std::string ex(str, iter.base());
15502 assert(ex == "-0x0p+0");
15503 assert(ios.width() == 0);
15504 }
15505 ios.width(25);
15506 left(ios);
15507 {
15508 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15509 std::string ex(str, iter.base());
15510 assert(ex == "-0x0p+0******************");
15511 assert(ios.width() == 0);
15512 }
15513 ios.width(25);
15514 right(ios);
15515 {
15516 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15517 std::string ex(str, iter.base());
15518 assert(ex == "******************-0x0p+0");
15519 assert(ios.width() == 0);
15520 }
15521 ios.width(25);
15522 internal(ios);
15523 {
15524 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15525 std::string ex(str, iter.base());
15526 assert(ex == "-******************0x0p+0");
15527 assert(ios.width() == 0);
15528 }
15529 }
15530 ios.imbue(lg);
15531 {
15532 ios.width(0);
15533 {
15534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15535 std::string ex(str, iter.base());
15536 assert(ex == "-0x0p+0");
15537 assert(ios.width() == 0);
15538 }
15539 ios.width(25);
15540 left(ios);
15541 {
15542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15543 std::string ex(str, iter.base());
15544 assert(ex == "-0x0p+0******************");
15545 assert(ios.width() == 0);
15546 }
15547 ios.width(25);
15548 right(ios);
15549 {
15550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15551 std::string ex(str, iter.base());
15552 assert(ex == "******************-0x0p+0");
15553 assert(ios.width() == 0);
15554 }
15555 ios.width(25);
15556 internal(ios);
15557 {
15558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15559 std::string ex(str, iter.base());
15560 assert(ex == "-******************0x0p+0");
15561 assert(ios.width() == 0);
15562 }
15563 }
15564 }
15565 showpoint(ios);
15566 {
15567 ios.imbue(lc);
15568 {
15569 ios.width(0);
15570 {
15571 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15572 std::string ex(str, iter.base());
15573 assert(ex == "-0x0.p+0");
15574 assert(ios.width() == 0);
15575 }
15576 ios.width(25);
15577 left(ios);
15578 {
15579 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15580 std::string ex(str, iter.base());
15581 assert(ex == "-0x0.p+0*****************");
15582 assert(ios.width() == 0);
15583 }
15584 ios.width(25);
15585 right(ios);
15586 {
15587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15588 std::string ex(str, iter.base());
15589 assert(ex == "*****************-0x0.p+0");
15590 assert(ios.width() == 0);
15591 }
15592 ios.width(25);
15593 internal(ios);
15594 {
15595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15596 std::string ex(str, iter.base());
15597 assert(ex == "-*****************0x0.p+0");
15598 assert(ios.width() == 0);
15599 }
15600 }
15601 ios.imbue(lg);
15602 {
15603 ios.width(0);
15604 {
15605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15606 std::string ex(str, iter.base());
15607 assert(ex == "-0x0;p+0");
15608 assert(ios.width() == 0);
15609 }
15610 ios.width(25);
15611 left(ios);
15612 {
15613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15614 std::string ex(str, iter.base());
15615 assert(ex == "-0x0;p+0*****************");
15616 assert(ios.width() == 0);
15617 }
15618 ios.width(25);
15619 right(ios);
15620 {
15621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15622 std::string ex(str, iter.base());
15623 assert(ex == "*****************-0x0;p+0");
15624 assert(ios.width() == 0);
15625 }
15626 ios.width(25);
15627 internal(ios);
15628 {
15629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15630 std::string ex(str, iter.base());
15631 assert(ex == "-*****************0x0;p+0");
15632 assert(ios.width() == 0);
15633 }
15634 }
15635 }
15636 }
15637 showpos(ios);
15638 {
15639 noshowpoint(ios);
15640 {
15641 ios.imbue(lc);
15642 {
15643 ios.width(0);
15644 {
15645 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15646 std::string ex(str, iter.base());
15647 assert(ex == "-0x0p+0");
15648 assert(ios.width() == 0);
15649 }
15650 ios.width(25);
15651 left(ios);
15652 {
15653 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15654 std::string ex(str, iter.base());
15655 assert(ex == "-0x0p+0******************");
15656 assert(ios.width() == 0);
15657 }
15658 ios.width(25);
15659 right(ios);
15660 {
15661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15662 std::string ex(str, iter.base());
15663 assert(ex == "******************-0x0p+0");
15664 assert(ios.width() == 0);
15665 }
15666 ios.width(25);
15667 internal(ios);
15668 {
15669 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15670 std::string ex(str, iter.base());
15671 assert(ex == "-******************0x0p+0");
15672 assert(ios.width() == 0);
15673 }
15674 }
15675 ios.imbue(lg);
15676 {
15677 ios.width(0);
15678 {
15679 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15680 std::string ex(str, iter.base());
15681 assert(ex == "-0x0p+0");
15682 assert(ios.width() == 0);
15683 }
15684 ios.width(25);
15685 left(ios);
15686 {
15687 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15688 std::string ex(str, iter.base());
15689 assert(ex == "-0x0p+0******************");
15690 assert(ios.width() == 0);
15691 }
15692 ios.width(25);
15693 right(ios);
15694 {
15695 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15696 std::string ex(str, iter.base());
15697 assert(ex == "******************-0x0p+0");
15698 assert(ios.width() == 0);
15699 }
15700 ios.width(25);
15701 internal(ios);
15702 {
15703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15704 std::string ex(str, iter.base());
15705 assert(ex == "-******************0x0p+0");
15706 assert(ios.width() == 0);
15707 }
15708 }
15709 }
15710 showpoint(ios);
15711 {
15712 ios.imbue(lc);
15713 {
15714 ios.width(0);
15715 {
15716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15717 std::string ex(str, iter.base());
15718 assert(ex == "-0x0.p+0");
15719 assert(ios.width() == 0);
15720 }
15721 ios.width(25);
15722 left(ios);
15723 {
15724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15725 std::string ex(str, iter.base());
15726 assert(ex == "-0x0.p+0*****************");
15727 assert(ios.width() == 0);
15728 }
15729 ios.width(25);
15730 right(ios);
15731 {
15732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15733 std::string ex(str, iter.base());
15734 assert(ex == "*****************-0x0.p+0");
15735 assert(ios.width() == 0);
15736 }
15737 ios.width(25);
15738 internal(ios);
15739 {
15740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15741 std::string ex(str, iter.base());
15742 assert(ex == "-*****************0x0.p+0");
15743 assert(ios.width() == 0);
15744 }
15745 }
15746 ios.imbue(lg);
15747 {
15748 ios.width(0);
15749 {
15750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15751 std::string ex(str, iter.base());
15752 assert(ex == "-0x0;p+0");
15753 assert(ios.width() == 0);
15754 }
15755 ios.width(25);
15756 left(ios);
15757 {
15758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15759 std::string ex(str, iter.base());
15760 assert(ex == "-0x0;p+0*****************");
15761 assert(ios.width() == 0);
15762 }
15763 ios.width(25);
15764 right(ios);
15765 {
15766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15767 std::string ex(str, iter.base());
15768 assert(ex == "*****************-0x0;p+0");
15769 assert(ios.width() == 0);
15770 }
15771 ios.width(25);
15772 internal(ios);
15773 {
15774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15775 std::string ex(str, iter.base());
15776 assert(ex == "-*****************0x0;p+0");
15777 assert(ios.width() == 0);
15778 }
15779 }
15780 }
15781 }
15782 }
15783 uppercase(ios);
15784 {
15785 noshowpos(ios);
15786 {
15787 noshowpoint(ios);
15788 {
15789 ios.imbue(lc);
15790 {
15791 ios.width(0);
15792 {
15793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15794 std::string ex(str, iter.base());
15795 assert(ex == "-0X0P+0");
15796 assert(ios.width() == 0);
15797 }
15798 ios.width(25);
15799 left(ios);
15800 {
15801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15802 std::string ex(str, iter.base());
15803 assert(ex == "-0X0P+0******************");
15804 assert(ios.width() == 0);
15805 }
15806 ios.width(25);
15807 right(ios);
15808 {
15809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15810 std::string ex(str, iter.base());
15811 assert(ex == "******************-0X0P+0");
15812 assert(ios.width() == 0);
15813 }
15814 ios.width(25);
15815 internal(ios);
15816 {
15817 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15818 std::string ex(str, iter.base());
15819 assert(ex == "-******************0X0P+0");
15820 assert(ios.width() == 0);
15821 }
15822 }
15823 ios.imbue(lg);
15824 {
15825 ios.width(0);
15826 {
15827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15828 std::string ex(str, iter.base());
15829 assert(ex == "-0X0P+0");
15830 assert(ios.width() == 0);
15831 }
15832 ios.width(25);
15833 left(ios);
15834 {
15835 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15836 std::string ex(str, iter.base());
15837 assert(ex == "-0X0P+0******************");
15838 assert(ios.width() == 0);
15839 }
15840 ios.width(25);
15841 right(ios);
15842 {
15843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15844 std::string ex(str, iter.base());
15845 assert(ex == "******************-0X0P+0");
15846 assert(ios.width() == 0);
15847 }
15848 ios.width(25);
15849 internal(ios);
15850 {
15851 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15852 std::string ex(str, iter.base());
15853 assert(ex == "-******************0X0P+0");
15854 assert(ios.width() == 0);
15855 }
15856 }
15857 }
15858 showpoint(ios);
15859 {
15860 ios.imbue(lc);
15861 {
15862 ios.width(0);
15863 {
15864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15865 std::string ex(str, iter.base());
15866 assert(ex == "-0X0.P+0");
15867 assert(ios.width() == 0);
15868 }
15869 ios.width(25);
15870 left(ios);
15871 {
15872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15873 std::string ex(str, iter.base());
15874 assert(ex == "-0X0.P+0*****************");
15875 assert(ios.width() == 0);
15876 }
15877 ios.width(25);
15878 right(ios);
15879 {
15880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15881 std::string ex(str, iter.base());
15882 assert(ex == "*****************-0X0.P+0");
15883 assert(ios.width() == 0);
15884 }
15885 ios.width(25);
15886 internal(ios);
15887 {
15888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15889 std::string ex(str, iter.base());
15890 assert(ex == "-*****************0X0.P+0");
15891 assert(ios.width() == 0);
15892 }
15893 }
15894 ios.imbue(lg);
15895 {
15896 ios.width(0);
15897 {
15898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15899 std::string ex(str, iter.base());
15900 assert(ex == "-0X0;P+0");
15901 assert(ios.width() == 0);
15902 }
15903 ios.width(25);
15904 left(ios);
15905 {
15906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15907 std::string ex(str, iter.base());
15908 assert(ex == "-0X0;P+0*****************");
15909 assert(ios.width() == 0);
15910 }
15911 ios.width(25);
15912 right(ios);
15913 {
15914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15915 std::string ex(str, iter.base());
15916 assert(ex == "*****************-0X0;P+0");
15917 assert(ios.width() == 0);
15918 }
15919 ios.width(25);
15920 internal(ios);
15921 {
15922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15923 std::string ex(str, iter.base());
15924 assert(ex == "-*****************0X0;P+0");
15925 assert(ios.width() == 0);
15926 }
15927 }
15928 }
15929 }
15930 showpos(ios);
15931 {
15932 noshowpoint(ios);
15933 {
15934 ios.imbue(lc);
15935 {
15936 ios.width(0);
15937 {
15938 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15939 std::string ex(str, iter.base());
15940 assert(ex == "-0X0P+0");
15941 assert(ios.width() == 0);
15942 }
15943 ios.width(25);
15944 left(ios);
15945 {
15946 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15947 std::string ex(str, iter.base());
15948 assert(ex == "-0X0P+0******************");
15949 assert(ios.width() == 0);
15950 }
15951 ios.width(25);
15952 right(ios);
15953 {
15954 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15955 std::string ex(str, iter.base());
15956 assert(ex == "******************-0X0P+0");
15957 assert(ios.width() == 0);
15958 }
15959 ios.width(25);
15960 internal(ios);
15961 {
15962 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15963 std::string ex(str, iter.base());
15964 assert(ex == "-******************0X0P+0");
15965 assert(ios.width() == 0);
15966 }
15967 }
15968 ios.imbue(lg);
15969 {
15970 ios.width(0);
15971 {
15972 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15973 std::string ex(str, iter.base());
15974 assert(ex == "-0X0P+0");
15975 assert(ios.width() == 0);
15976 }
15977 ios.width(25);
15978 left(ios);
15979 {
15980 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15981 std::string ex(str, iter.base());
15982 assert(ex == "-0X0P+0******************");
15983 assert(ios.width() == 0);
15984 }
15985 ios.width(25);
15986 right(ios);
15987 {
15988 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15989 std::string ex(str, iter.base());
15990 assert(ex == "******************-0X0P+0");
15991 assert(ios.width() == 0);
15992 }
15993 ios.width(25);
15994 internal(ios);
15995 {
15996 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15997 std::string ex(str, iter.base());
15998 assert(ex == "-******************0X0P+0");
15999 assert(ios.width() == 0);
16000 }
16001 }
16002 }
16003 showpoint(ios);
16004 {
16005 ios.imbue(lc);
16006 {
16007 ios.width(0);
16008 {
16009 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16010 std::string ex(str, iter.base());
16011 assert(ex == "-0X0.P+0");
16012 assert(ios.width() == 0);
16013 }
16014 ios.width(25);
16015 left(ios);
16016 {
16017 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16018 std::string ex(str, iter.base());
16019 assert(ex == "-0X0.P+0*****************");
16020 assert(ios.width() == 0);
16021 }
16022 ios.width(25);
16023 right(ios);
16024 {
16025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16026 std::string ex(str, iter.base());
16027 assert(ex == "*****************-0X0.P+0");
16028 assert(ios.width() == 0);
16029 }
16030 ios.width(25);
16031 internal(ios);
16032 {
16033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16034 std::string ex(str, iter.base());
16035 assert(ex == "-*****************0X0.P+0");
16036 assert(ios.width() == 0);
16037 }
16038 }
16039 ios.imbue(lg);
16040 {
16041 ios.width(0);
16042 {
16043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16044 std::string ex(str, iter.base());
16045 assert(ex == "-0X0;P+0");
16046 assert(ios.width() == 0);
16047 }
16048 ios.width(25);
16049 left(ios);
16050 {
16051 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16052 std::string ex(str, iter.base());
16053 assert(ex == "-0X0;P+0*****************");
16054 assert(ios.width() == 0);
16055 }
16056 ios.width(25);
16057 right(ios);
16058 {
16059 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16060 std::string ex(str, iter.base());
16061 assert(ex == "*****************-0X0;P+0");
16062 assert(ios.width() == 0);
16063 }
16064 ios.width(25);
16065 internal(ios);
16066 {
16067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16068 std::string ex(str, iter.base());
16069 assert(ex == "-*****************0X0;P+0");
16070 assert(ios.width() == 0);
16071 }
16072 }
16073 }
16074 }
16075 }
16076 }
16077 ios.precision(16);
16078 {
16079 }
16080 ios.precision(60);
16081 {
16082 }
16083 }
16084 }
16085 }
16086
test8()16087 void test8()
16088 {
16089 char str[200];
16090 output_iterator<char*> iter;
16091 std::locale lc = std::locale::classic();
16092 std::locale lg(lc, new my_numpunct);
16093 const my_facet f(1);
16094 {
16095 double v = 1234567890.125;
16096 std::ios ios(0);
16097 hexfloat(ios);
16098 // %a
16099 {
16100 ios.precision(0);
16101 {
16102 nouppercase(ios);
16103 {
16104 noshowpos(ios);
16105 {
16106 noshowpoint(ios);
16107 {
16108 ios.imbue(lc);
16109 {
16110 ios.width(0);
16111 {
16112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16113 std::string ex(str, iter.base());
16114 assert(ex == "0x1.26580b488p+30");
16115 assert(ios.width() == 0);
16116 }
16117 ios.width(25);
16118 left(ios);
16119 {
16120 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16121 std::string ex(str, iter.base());
16122 assert(ex == "0x1.26580b488p+30********");
16123 assert(ios.width() == 0);
16124 }
16125 ios.width(25);
16126 right(ios);
16127 {
16128 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16129 std::string ex(str, iter.base());
16130 assert(ex == "********0x1.26580b488p+30");
16131 assert(ios.width() == 0);
16132 }
16133 ios.width(25);
16134 internal(ios);
16135 {
16136 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16137 std::string ex(str, iter.base());
16138 assert(ex == "0x********1.26580b488p+30");
16139 assert(ios.width() == 0);
16140 }
16141 }
16142 ios.imbue(lg);
16143 {
16144 ios.width(0);
16145 {
16146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16147 std::string ex(str, iter.base());
16148 assert(ex == "0x1;26580b488p+30");
16149 assert(ios.width() == 0);
16150 }
16151 ios.width(25);
16152 left(ios);
16153 {
16154 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16155 std::string ex(str, iter.base());
16156 assert(ex == "0x1;26580b488p+30********");
16157 assert(ios.width() == 0);
16158 }
16159 ios.width(25);
16160 right(ios);
16161 {
16162 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16163 std::string ex(str, iter.base());
16164 assert(ex == "********0x1;26580b488p+30");
16165 assert(ios.width() == 0);
16166 }
16167 ios.width(25);
16168 internal(ios);
16169 {
16170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16171 std::string ex(str, iter.base());
16172 assert(ex == "0x********1;26580b488p+30");
16173 assert(ios.width() == 0);
16174 }
16175 }
16176 }
16177 showpoint(ios);
16178 {
16179 ios.imbue(lc);
16180 {
16181 ios.width(0);
16182 {
16183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16184 std::string ex(str, iter.base());
16185 assert(ex == "0x1.26580b488p+30");
16186 assert(ios.width() == 0);
16187 }
16188 ios.width(25);
16189 left(ios);
16190 {
16191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16192 std::string ex(str, iter.base());
16193 assert(ex == "0x1.26580b488p+30********");
16194 assert(ios.width() == 0);
16195 }
16196 ios.width(25);
16197 right(ios);
16198 {
16199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16200 std::string ex(str, iter.base());
16201 assert(ex == "********0x1.26580b488p+30");
16202 assert(ios.width() == 0);
16203 }
16204 ios.width(25);
16205 internal(ios);
16206 {
16207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16208 std::string ex(str, iter.base());
16209 assert(ex == "0x********1.26580b488p+30");
16210 assert(ios.width() == 0);
16211 }
16212 }
16213 ios.imbue(lg);
16214 {
16215 ios.width(0);
16216 {
16217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16218 std::string ex(str, iter.base());
16219 assert(ex == "0x1;26580b488p+30");
16220 assert(ios.width() == 0);
16221 }
16222 ios.width(25);
16223 left(ios);
16224 {
16225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16226 std::string ex(str, iter.base());
16227 assert(ex == "0x1;26580b488p+30********");
16228 assert(ios.width() == 0);
16229 }
16230 ios.width(25);
16231 right(ios);
16232 {
16233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16234 std::string ex(str, iter.base());
16235 assert(ex == "********0x1;26580b488p+30");
16236 assert(ios.width() == 0);
16237 }
16238 ios.width(25);
16239 internal(ios);
16240 {
16241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16242 std::string ex(str, iter.base());
16243 assert(ex == "0x********1;26580b488p+30");
16244 assert(ios.width() == 0);
16245 }
16246 }
16247 }
16248 }
16249 showpos(ios);
16250 {
16251 noshowpoint(ios);
16252 {
16253 ios.imbue(lc);
16254 {
16255 ios.width(0);
16256 {
16257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16258 std::string ex(str, iter.base());
16259 assert(ex == "+0x1.26580b488p+30");
16260 assert(ios.width() == 0);
16261 }
16262 ios.width(25);
16263 left(ios);
16264 {
16265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16266 std::string ex(str, iter.base());
16267 assert(ex == "+0x1.26580b488p+30*******");
16268 assert(ios.width() == 0);
16269 }
16270 ios.width(25);
16271 right(ios);
16272 {
16273 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16274 std::string ex(str, iter.base());
16275 assert(ex == "*******+0x1.26580b488p+30");
16276 assert(ios.width() == 0);
16277 }
16278 ios.width(25);
16279 internal(ios);
16280 {
16281 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16282 std::string ex(str, iter.base());
16283 assert(ex == "+*******0x1.26580b488p+30");
16284 assert(ios.width() == 0);
16285 }
16286 }
16287 ios.imbue(lg);
16288 {
16289 ios.width(0);
16290 {
16291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16292 std::string ex(str, iter.base());
16293 assert(ex == "+0x1;26580b488p+30");
16294 assert(ios.width() == 0);
16295 }
16296 ios.width(25);
16297 left(ios);
16298 {
16299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16300 std::string ex(str, iter.base());
16301 assert(ex == "+0x1;26580b488p+30*******");
16302 assert(ios.width() == 0);
16303 }
16304 ios.width(25);
16305 right(ios);
16306 {
16307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16308 std::string ex(str, iter.base());
16309 assert(ex == "*******+0x1;26580b488p+30");
16310 assert(ios.width() == 0);
16311 }
16312 ios.width(25);
16313 internal(ios);
16314 {
16315 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16316 std::string ex(str, iter.base());
16317 assert(ex == "+*******0x1;26580b488p+30");
16318 assert(ios.width() == 0);
16319 }
16320 }
16321 }
16322 showpoint(ios);
16323 {
16324 ios.imbue(lc);
16325 {
16326 ios.width(0);
16327 {
16328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16329 std::string ex(str, iter.base());
16330 assert(ex == "+0x1.26580b488p+30");
16331 assert(ios.width() == 0);
16332 }
16333 ios.width(25);
16334 left(ios);
16335 {
16336 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16337 std::string ex(str, iter.base());
16338 assert(ex == "+0x1.26580b488p+30*******");
16339 assert(ios.width() == 0);
16340 }
16341 ios.width(25);
16342 right(ios);
16343 {
16344 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16345 std::string ex(str, iter.base());
16346 assert(ex == "*******+0x1.26580b488p+30");
16347 assert(ios.width() == 0);
16348 }
16349 ios.width(25);
16350 internal(ios);
16351 {
16352 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16353 std::string ex(str, iter.base());
16354 assert(ex == "+*******0x1.26580b488p+30");
16355 assert(ios.width() == 0);
16356 }
16357 }
16358 ios.imbue(lg);
16359 {
16360 ios.width(0);
16361 {
16362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16363 std::string ex(str, iter.base());
16364 assert(ex == "+0x1;26580b488p+30");
16365 assert(ios.width() == 0);
16366 }
16367 ios.width(25);
16368 left(ios);
16369 {
16370 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16371 std::string ex(str, iter.base());
16372 assert(ex == "+0x1;26580b488p+30*******");
16373 assert(ios.width() == 0);
16374 }
16375 ios.width(25);
16376 right(ios);
16377 {
16378 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16379 std::string ex(str, iter.base());
16380 assert(ex == "*******+0x1;26580b488p+30");
16381 assert(ios.width() == 0);
16382 }
16383 ios.width(25);
16384 internal(ios);
16385 {
16386 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16387 std::string ex(str, iter.base());
16388 assert(ex == "+*******0x1;26580b488p+30");
16389 assert(ios.width() == 0);
16390 }
16391 }
16392 }
16393 }
16394 }
16395 uppercase(ios);
16396 {
16397 noshowpos(ios);
16398 {
16399 noshowpoint(ios);
16400 {
16401 ios.imbue(lc);
16402 {
16403 ios.width(0);
16404 {
16405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16406 std::string ex(str, iter.base());
16407 assert(ex == "0X1.26580B488P+30");
16408 assert(ios.width() == 0);
16409 }
16410 ios.width(25);
16411 left(ios);
16412 {
16413 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16414 std::string ex(str, iter.base());
16415 assert(ex == "0X1.26580B488P+30********");
16416 assert(ios.width() == 0);
16417 }
16418 ios.width(25);
16419 right(ios);
16420 {
16421 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16422 std::string ex(str, iter.base());
16423 assert(ex == "********0X1.26580B488P+30");
16424 assert(ios.width() == 0);
16425 }
16426 ios.width(25);
16427 internal(ios);
16428 {
16429 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16430 std::string ex(str, iter.base());
16431 assert(ex == "0X********1.26580B488P+30");
16432 assert(ios.width() == 0);
16433 }
16434 }
16435 ios.imbue(lg);
16436 {
16437 ios.width(0);
16438 {
16439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16440 std::string ex(str, iter.base());
16441 assert(ex == "0X1;26580B488P+30");
16442 assert(ios.width() == 0);
16443 }
16444 ios.width(25);
16445 left(ios);
16446 {
16447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16448 std::string ex(str, iter.base());
16449 assert(ex == "0X1;26580B488P+30********");
16450 assert(ios.width() == 0);
16451 }
16452 ios.width(25);
16453 right(ios);
16454 {
16455 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16456 std::string ex(str, iter.base());
16457 assert(ex == "********0X1;26580B488P+30");
16458 assert(ios.width() == 0);
16459 }
16460 ios.width(25);
16461 internal(ios);
16462 {
16463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16464 std::string ex(str, iter.base());
16465 assert(ex == "0X********1;26580B488P+30");
16466 assert(ios.width() == 0);
16467 }
16468 }
16469 }
16470 showpoint(ios);
16471 {
16472 ios.imbue(lc);
16473 {
16474 ios.width(0);
16475 {
16476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16477 std::string ex(str, iter.base());
16478 assert(ex == "0X1.26580B488P+30");
16479 assert(ios.width() == 0);
16480 }
16481 ios.width(25);
16482 left(ios);
16483 {
16484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16485 std::string ex(str, iter.base());
16486 assert(ex == "0X1.26580B488P+30********");
16487 assert(ios.width() == 0);
16488 }
16489 ios.width(25);
16490 right(ios);
16491 {
16492 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16493 std::string ex(str, iter.base());
16494 assert(ex == "********0X1.26580B488P+30");
16495 assert(ios.width() == 0);
16496 }
16497 ios.width(25);
16498 internal(ios);
16499 {
16500 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16501 std::string ex(str, iter.base());
16502 assert(ex == "0X********1.26580B488P+30");
16503 assert(ios.width() == 0);
16504 }
16505 }
16506 ios.imbue(lg);
16507 {
16508 ios.width(0);
16509 {
16510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16511 std::string ex(str, iter.base());
16512 assert(ex == "0X1;26580B488P+30");
16513 assert(ios.width() == 0);
16514 }
16515 ios.width(25);
16516 left(ios);
16517 {
16518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16519 std::string ex(str, iter.base());
16520 assert(ex == "0X1;26580B488P+30********");
16521 assert(ios.width() == 0);
16522 }
16523 ios.width(25);
16524 right(ios);
16525 {
16526 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16527 std::string ex(str, iter.base());
16528 assert(ex == "********0X1;26580B488P+30");
16529 assert(ios.width() == 0);
16530 }
16531 ios.width(25);
16532 internal(ios);
16533 {
16534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16535 std::string ex(str, iter.base());
16536 assert(ex == "0X********1;26580B488P+30");
16537 assert(ios.width() == 0);
16538 }
16539 }
16540 }
16541 }
16542 showpos(ios);
16543 {
16544 noshowpoint(ios);
16545 {
16546 ios.imbue(lc);
16547 {
16548 ios.width(0);
16549 {
16550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16551 std::string ex(str, iter.base());
16552 assert(ex == "+0X1.26580B488P+30");
16553 assert(ios.width() == 0);
16554 }
16555 ios.width(25);
16556 left(ios);
16557 {
16558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16559 std::string ex(str, iter.base());
16560 assert(ex == "+0X1.26580B488P+30*******");
16561 assert(ios.width() == 0);
16562 }
16563 ios.width(25);
16564 right(ios);
16565 {
16566 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16567 std::string ex(str, iter.base());
16568 assert(ex == "*******+0X1.26580B488P+30");
16569 assert(ios.width() == 0);
16570 }
16571 ios.width(25);
16572 internal(ios);
16573 {
16574 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16575 std::string ex(str, iter.base());
16576 assert(ex == "+*******0X1.26580B488P+30");
16577 assert(ios.width() == 0);
16578 }
16579 }
16580 ios.imbue(lg);
16581 {
16582 ios.width(0);
16583 {
16584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16585 std::string ex(str, iter.base());
16586 assert(ex == "+0X1;26580B488P+30");
16587 assert(ios.width() == 0);
16588 }
16589 ios.width(25);
16590 left(ios);
16591 {
16592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16593 std::string ex(str, iter.base());
16594 assert(ex == "+0X1;26580B488P+30*******");
16595 assert(ios.width() == 0);
16596 }
16597 ios.width(25);
16598 right(ios);
16599 {
16600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16601 std::string ex(str, iter.base());
16602 assert(ex == "*******+0X1;26580B488P+30");
16603 assert(ios.width() == 0);
16604 }
16605 ios.width(25);
16606 internal(ios);
16607 {
16608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16609 std::string ex(str, iter.base());
16610 assert(ex == "+*******0X1;26580B488P+30");
16611 assert(ios.width() == 0);
16612 }
16613 }
16614 }
16615 showpoint(ios);
16616 {
16617 ios.imbue(lc);
16618 {
16619 ios.width(0);
16620 {
16621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16622 std::string ex(str, iter.base());
16623 assert(ex == "+0X1.26580B488P+30");
16624 assert(ios.width() == 0);
16625 }
16626 ios.width(25);
16627 left(ios);
16628 {
16629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16630 std::string ex(str, iter.base());
16631 assert(ex == "+0X1.26580B488P+30*******");
16632 assert(ios.width() == 0);
16633 }
16634 ios.width(25);
16635 right(ios);
16636 {
16637 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16638 std::string ex(str, iter.base());
16639 assert(ex == "*******+0X1.26580B488P+30");
16640 assert(ios.width() == 0);
16641 }
16642 ios.width(25);
16643 internal(ios);
16644 {
16645 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16646 std::string ex(str, iter.base());
16647 assert(ex == "+*******0X1.26580B488P+30");
16648 assert(ios.width() == 0);
16649 }
16650 }
16651 ios.imbue(lg);
16652 {
16653 ios.width(0);
16654 {
16655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16656 std::string ex(str, iter.base());
16657 assert(ex == "+0X1;26580B488P+30");
16658 assert(ios.width() == 0);
16659 }
16660 ios.width(25);
16661 left(ios);
16662 {
16663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16664 std::string ex(str, iter.base());
16665 assert(ex == "+0X1;26580B488P+30*******");
16666 assert(ios.width() == 0);
16667 }
16668 ios.width(25);
16669 right(ios);
16670 {
16671 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16672 std::string ex(str, iter.base());
16673 assert(ex == "*******+0X1;26580B488P+30");
16674 assert(ios.width() == 0);
16675 }
16676 ios.width(25);
16677 internal(ios);
16678 {
16679 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16680 std::string ex(str, iter.base());
16681 assert(ex == "+*******0X1;26580B488P+30");
16682 assert(ios.width() == 0);
16683 }
16684 }
16685 }
16686 }
16687 }
16688 }
16689 ios.precision(1);
16690 {
16691 nouppercase(ios);
16692 {
16693 noshowpos(ios);
16694 {
16695 noshowpoint(ios);
16696 {
16697 ios.imbue(lc);
16698 {
16699 ios.width(0);
16700 {
16701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16702 std::string ex(str, iter.base());
16703 assert(ex == "0x1.26580b488p+30");
16704 assert(ios.width() == 0);
16705 }
16706 ios.width(25);
16707 left(ios);
16708 {
16709 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16710 std::string ex(str, iter.base());
16711 assert(ex == "0x1.26580b488p+30********");
16712 assert(ios.width() == 0);
16713 }
16714 ios.width(25);
16715 right(ios);
16716 {
16717 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16718 std::string ex(str, iter.base());
16719 assert(ex == "********0x1.26580b488p+30");
16720 assert(ios.width() == 0);
16721 }
16722 ios.width(25);
16723 internal(ios);
16724 {
16725 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16726 std::string ex(str, iter.base());
16727 assert(ex == "0x********1.26580b488p+30");
16728 assert(ios.width() == 0);
16729 }
16730 }
16731 ios.imbue(lg);
16732 {
16733 ios.width(0);
16734 {
16735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16736 std::string ex(str, iter.base());
16737 assert(ex == "0x1;26580b488p+30");
16738 assert(ios.width() == 0);
16739 }
16740 ios.width(25);
16741 left(ios);
16742 {
16743 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16744 std::string ex(str, iter.base());
16745 assert(ex == "0x1;26580b488p+30********");
16746 assert(ios.width() == 0);
16747 }
16748 ios.width(25);
16749 right(ios);
16750 {
16751 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16752 std::string ex(str, iter.base());
16753 assert(ex == "********0x1;26580b488p+30");
16754 assert(ios.width() == 0);
16755 }
16756 ios.width(25);
16757 internal(ios);
16758 {
16759 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16760 std::string ex(str, iter.base());
16761 assert(ex == "0x********1;26580b488p+30");
16762 assert(ios.width() == 0);
16763 }
16764 }
16765 }
16766 showpoint(ios);
16767 {
16768 ios.imbue(lc);
16769 {
16770 ios.width(0);
16771 {
16772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16773 std::string ex(str, iter.base());
16774 assert(ex == "0x1.26580b488p+30");
16775 assert(ios.width() == 0);
16776 }
16777 ios.width(25);
16778 left(ios);
16779 {
16780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16781 std::string ex(str, iter.base());
16782 assert(ex == "0x1.26580b488p+30********");
16783 assert(ios.width() == 0);
16784 }
16785 ios.width(25);
16786 right(ios);
16787 {
16788 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16789 std::string ex(str, iter.base());
16790 assert(ex == "********0x1.26580b488p+30");
16791 assert(ios.width() == 0);
16792 }
16793 ios.width(25);
16794 internal(ios);
16795 {
16796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16797 std::string ex(str, iter.base());
16798 assert(ex == "0x********1.26580b488p+30");
16799 assert(ios.width() == 0);
16800 }
16801 }
16802 ios.imbue(lg);
16803 {
16804 ios.width(0);
16805 {
16806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16807 std::string ex(str, iter.base());
16808 assert(ex == "0x1;26580b488p+30");
16809 assert(ios.width() == 0);
16810 }
16811 ios.width(25);
16812 left(ios);
16813 {
16814 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16815 std::string ex(str, iter.base());
16816 assert(ex == "0x1;26580b488p+30********");
16817 assert(ios.width() == 0);
16818 }
16819 ios.width(25);
16820 right(ios);
16821 {
16822 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16823 std::string ex(str, iter.base());
16824 assert(ex == "********0x1;26580b488p+30");
16825 assert(ios.width() == 0);
16826 }
16827 ios.width(25);
16828 internal(ios);
16829 {
16830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16831 std::string ex(str, iter.base());
16832 assert(ex == "0x********1;26580b488p+30");
16833 assert(ios.width() == 0);
16834 }
16835 }
16836 }
16837 }
16838 showpos(ios);
16839 {
16840 noshowpoint(ios);
16841 {
16842 ios.imbue(lc);
16843 {
16844 ios.width(0);
16845 {
16846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16847 std::string ex(str, iter.base());
16848 assert(ex == "+0x1.26580b488p+30");
16849 assert(ios.width() == 0);
16850 }
16851 ios.width(25);
16852 left(ios);
16853 {
16854 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16855 std::string ex(str, iter.base());
16856 assert(ex == "+0x1.26580b488p+30*******");
16857 assert(ios.width() == 0);
16858 }
16859 ios.width(25);
16860 right(ios);
16861 {
16862 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16863 std::string ex(str, iter.base());
16864 assert(ex == "*******+0x1.26580b488p+30");
16865 assert(ios.width() == 0);
16866 }
16867 ios.width(25);
16868 internal(ios);
16869 {
16870 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16871 std::string ex(str, iter.base());
16872 assert(ex == "+*******0x1.26580b488p+30");
16873 assert(ios.width() == 0);
16874 }
16875 }
16876 ios.imbue(lg);
16877 {
16878 ios.width(0);
16879 {
16880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16881 std::string ex(str, iter.base());
16882 assert(ex == "+0x1;26580b488p+30");
16883 assert(ios.width() == 0);
16884 }
16885 ios.width(25);
16886 left(ios);
16887 {
16888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16889 std::string ex(str, iter.base());
16890 assert(ex == "+0x1;26580b488p+30*******");
16891 assert(ios.width() == 0);
16892 }
16893 ios.width(25);
16894 right(ios);
16895 {
16896 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16897 std::string ex(str, iter.base());
16898 assert(ex == "*******+0x1;26580b488p+30");
16899 assert(ios.width() == 0);
16900 }
16901 ios.width(25);
16902 internal(ios);
16903 {
16904 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16905 std::string ex(str, iter.base());
16906 assert(ex == "+*******0x1;26580b488p+30");
16907 assert(ios.width() == 0);
16908 }
16909 }
16910 }
16911 showpoint(ios);
16912 {
16913 ios.imbue(lc);
16914 {
16915 ios.width(0);
16916 {
16917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16918 std::string ex(str, iter.base());
16919 assert(ex == "+0x1.26580b488p+30");
16920 assert(ios.width() == 0);
16921 }
16922 ios.width(25);
16923 left(ios);
16924 {
16925 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16926 std::string ex(str, iter.base());
16927 assert(ex == "+0x1.26580b488p+30*******");
16928 assert(ios.width() == 0);
16929 }
16930 ios.width(25);
16931 right(ios);
16932 {
16933 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16934 std::string ex(str, iter.base());
16935 assert(ex == "*******+0x1.26580b488p+30");
16936 assert(ios.width() == 0);
16937 }
16938 ios.width(25);
16939 internal(ios);
16940 {
16941 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16942 std::string ex(str, iter.base());
16943 assert(ex == "+*******0x1.26580b488p+30");
16944 assert(ios.width() == 0);
16945 }
16946 }
16947 ios.imbue(lg);
16948 {
16949 ios.width(0);
16950 {
16951 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16952 std::string ex(str, iter.base());
16953 assert(ex == "+0x1;26580b488p+30");
16954 assert(ios.width() == 0);
16955 }
16956 ios.width(25);
16957 left(ios);
16958 {
16959 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16960 std::string ex(str, iter.base());
16961 assert(ex == "+0x1;26580b488p+30*******");
16962 assert(ios.width() == 0);
16963 }
16964 ios.width(25);
16965 right(ios);
16966 {
16967 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16968 std::string ex(str, iter.base());
16969 assert(ex == "*******+0x1;26580b488p+30");
16970 assert(ios.width() == 0);
16971 }
16972 ios.width(25);
16973 internal(ios);
16974 {
16975 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16976 std::string ex(str, iter.base());
16977 assert(ex == "+*******0x1;26580b488p+30");
16978 assert(ios.width() == 0);
16979 }
16980 }
16981 }
16982 }
16983 }
16984 uppercase(ios);
16985 {
16986 noshowpos(ios);
16987 {
16988 noshowpoint(ios);
16989 {
16990 ios.imbue(lc);
16991 {
16992 ios.width(0);
16993 {
16994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16995 std::string ex(str, iter.base());
16996 assert(ex == "0X1.26580B488P+30");
16997 assert(ios.width() == 0);
16998 }
16999 ios.width(25);
17000 left(ios);
17001 {
17002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17003 std::string ex(str, iter.base());
17004 assert(ex == "0X1.26580B488P+30********");
17005 assert(ios.width() == 0);
17006 }
17007 ios.width(25);
17008 right(ios);
17009 {
17010 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17011 std::string ex(str, iter.base());
17012 assert(ex == "********0X1.26580B488P+30");
17013 assert(ios.width() == 0);
17014 }
17015 ios.width(25);
17016 internal(ios);
17017 {
17018 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17019 std::string ex(str, iter.base());
17020 assert(ex == "0X********1.26580B488P+30");
17021 assert(ios.width() == 0);
17022 }
17023 }
17024 ios.imbue(lg);
17025 {
17026 ios.width(0);
17027 {
17028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17029 std::string ex(str, iter.base());
17030 assert(ex == "0X1;26580B488P+30");
17031 assert(ios.width() == 0);
17032 }
17033 ios.width(25);
17034 left(ios);
17035 {
17036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17037 std::string ex(str, iter.base());
17038 assert(ex == "0X1;26580B488P+30********");
17039 assert(ios.width() == 0);
17040 }
17041 ios.width(25);
17042 right(ios);
17043 {
17044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17045 std::string ex(str, iter.base());
17046 assert(ex == "********0X1;26580B488P+30");
17047 assert(ios.width() == 0);
17048 }
17049 ios.width(25);
17050 internal(ios);
17051 {
17052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17053 std::string ex(str, iter.base());
17054 assert(ex == "0X********1;26580B488P+30");
17055 assert(ios.width() == 0);
17056 }
17057 }
17058 }
17059 showpoint(ios);
17060 {
17061 ios.imbue(lc);
17062 {
17063 ios.width(0);
17064 {
17065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17066 std::string ex(str, iter.base());
17067 assert(ex == "0X1.26580B488P+30");
17068 assert(ios.width() == 0);
17069 }
17070 ios.width(25);
17071 left(ios);
17072 {
17073 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17074 std::string ex(str, iter.base());
17075 assert(ex == "0X1.26580B488P+30********");
17076 assert(ios.width() == 0);
17077 }
17078 ios.width(25);
17079 right(ios);
17080 {
17081 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17082 std::string ex(str, iter.base());
17083 assert(ex == "********0X1.26580B488P+30");
17084 assert(ios.width() == 0);
17085 }
17086 ios.width(25);
17087 internal(ios);
17088 {
17089 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17090 std::string ex(str, iter.base());
17091 assert(ex == "0X********1.26580B488P+30");
17092 assert(ios.width() == 0);
17093 }
17094 }
17095 ios.imbue(lg);
17096 {
17097 ios.width(0);
17098 {
17099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17100 std::string ex(str, iter.base());
17101 assert(ex == "0X1;26580B488P+30");
17102 assert(ios.width() == 0);
17103 }
17104 ios.width(25);
17105 left(ios);
17106 {
17107 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17108 std::string ex(str, iter.base());
17109 assert(ex == "0X1;26580B488P+30********");
17110 assert(ios.width() == 0);
17111 }
17112 ios.width(25);
17113 right(ios);
17114 {
17115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17116 std::string ex(str, iter.base());
17117 assert(ex == "********0X1;26580B488P+30");
17118 assert(ios.width() == 0);
17119 }
17120 ios.width(25);
17121 internal(ios);
17122 {
17123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17124 std::string ex(str, iter.base());
17125 assert(ex == "0X********1;26580B488P+30");
17126 assert(ios.width() == 0);
17127 }
17128 }
17129 }
17130 }
17131 showpos(ios);
17132 {
17133 noshowpoint(ios);
17134 {
17135 ios.imbue(lc);
17136 {
17137 ios.width(0);
17138 {
17139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17140 std::string ex(str, iter.base());
17141 assert(ex == "+0X1.26580B488P+30");
17142 assert(ios.width() == 0);
17143 }
17144 ios.width(25);
17145 left(ios);
17146 {
17147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17148 std::string ex(str, iter.base());
17149 assert(ex == "+0X1.26580B488P+30*******");
17150 assert(ios.width() == 0);
17151 }
17152 ios.width(25);
17153 right(ios);
17154 {
17155 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17156 std::string ex(str, iter.base());
17157 assert(ex == "*******+0X1.26580B488P+30");
17158 assert(ios.width() == 0);
17159 }
17160 ios.width(25);
17161 internal(ios);
17162 {
17163 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17164 std::string ex(str, iter.base());
17165 assert(ex == "+*******0X1.26580B488P+30");
17166 assert(ios.width() == 0);
17167 }
17168 }
17169 ios.imbue(lg);
17170 {
17171 ios.width(0);
17172 {
17173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17174 std::string ex(str, iter.base());
17175 assert(ex == "+0X1;26580B488P+30");
17176 assert(ios.width() == 0);
17177 }
17178 ios.width(25);
17179 left(ios);
17180 {
17181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17182 std::string ex(str, iter.base());
17183 assert(ex == "+0X1;26580B488P+30*******");
17184 assert(ios.width() == 0);
17185 }
17186 ios.width(25);
17187 right(ios);
17188 {
17189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17190 std::string ex(str, iter.base());
17191 assert(ex == "*******+0X1;26580B488P+30");
17192 assert(ios.width() == 0);
17193 }
17194 ios.width(25);
17195 internal(ios);
17196 {
17197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17198 std::string ex(str, iter.base());
17199 assert(ex == "+*******0X1;26580B488P+30");
17200 assert(ios.width() == 0);
17201 }
17202 }
17203 }
17204 showpoint(ios);
17205 {
17206 ios.imbue(lc);
17207 {
17208 ios.width(0);
17209 {
17210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17211 std::string ex(str, iter.base());
17212 assert(ex == "+0X1.26580B488P+30");
17213 assert(ios.width() == 0);
17214 }
17215 ios.width(25);
17216 left(ios);
17217 {
17218 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17219 std::string ex(str, iter.base());
17220 assert(ex == "+0X1.26580B488P+30*******");
17221 assert(ios.width() == 0);
17222 }
17223 ios.width(25);
17224 right(ios);
17225 {
17226 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17227 std::string ex(str, iter.base());
17228 assert(ex == "*******+0X1.26580B488P+30");
17229 assert(ios.width() == 0);
17230 }
17231 ios.width(25);
17232 internal(ios);
17233 {
17234 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17235 std::string ex(str, iter.base());
17236 assert(ex == "+*******0X1.26580B488P+30");
17237 assert(ios.width() == 0);
17238 }
17239 }
17240 ios.imbue(lg);
17241 {
17242 ios.width(0);
17243 {
17244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17245 std::string ex(str, iter.base());
17246 assert(ex == "+0X1;26580B488P+30");
17247 assert(ios.width() == 0);
17248 }
17249 ios.width(25);
17250 left(ios);
17251 {
17252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17253 std::string ex(str, iter.base());
17254 assert(ex == "+0X1;26580B488P+30*******");
17255 assert(ios.width() == 0);
17256 }
17257 ios.width(25);
17258 right(ios);
17259 {
17260 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17261 std::string ex(str, iter.base());
17262 assert(ex == "*******+0X1;26580B488P+30");
17263 assert(ios.width() == 0);
17264 }
17265 ios.width(25);
17266 internal(ios);
17267 {
17268 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17269 std::string ex(str, iter.base());
17270 assert(ex == "+*******0X1;26580B488P+30");
17271 assert(ios.width() == 0);
17272 }
17273 }
17274 }
17275 }
17276 }
17277 }
17278 ios.precision(6);
17279 {
17280 }
17281 ios.precision(16);
17282 {
17283 }
17284 ios.precision(60);
17285 {
17286 nouppercase(ios);
17287 {
17288 noshowpos(ios);
17289 {
17290 noshowpoint(ios);
17291 {
17292 ios.imbue(lc);
17293 {
17294 ios.width(0);
17295 {
17296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17297 std::string ex(str, iter.base());
17298 assert(ex == "0x1.26580b488p+30");
17299 assert(ios.width() == 0);
17300 }
17301 ios.width(25);
17302 left(ios);
17303 {
17304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17305 std::string ex(str, iter.base());
17306 assert(ex == "0x1.26580b488p+30********");
17307 assert(ios.width() == 0);
17308 }
17309 ios.width(25);
17310 right(ios);
17311 {
17312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17313 std::string ex(str, iter.base());
17314 assert(ex == "********0x1.26580b488p+30");
17315 assert(ios.width() == 0);
17316 }
17317 ios.width(25);
17318 internal(ios);
17319 {
17320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17321 std::string ex(str, iter.base());
17322 assert(ex == "0x********1.26580b488p+30");
17323 assert(ios.width() == 0);
17324 }
17325 }
17326 ios.imbue(lg);
17327 {
17328 ios.width(0);
17329 {
17330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17331 std::string ex(str, iter.base());
17332 assert(ex == "0x1;26580b488p+30");
17333 assert(ios.width() == 0);
17334 }
17335 ios.width(25);
17336 left(ios);
17337 {
17338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17339 std::string ex(str, iter.base());
17340 assert(ex == "0x1;26580b488p+30********");
17341 assert(ios.width() == 0);
17342 }
17343 ios.width(25);
17344 right(ios);
17345 {
17346 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17347 std::string ex(str, iter.base());
17348 assert(ex == "********0x1;26580b488p+30");
17349 assert(ios.width() == 0);
17350 }
17351 ios.width(25);
17352 internal(ios);
17353 {
17354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17355 std::string ex(str, iter.base());
17356 assert(ex == "0x********1;26580b488p+30");
17357 assert(ios.width() == 0);
17358 }
17359 }
17360 }
17361 showpoint(ios);
17362 {
17363 ios.imbue(lc);
17364 {
17365 ios.width(0);
17366 {
17367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17368 std::string ex(str, iter.base());
17369 assert(ex == "0x1.26580b488p+30");
17370 assert(ios.width() == 0);
17371 }
17372 ios.width(25);
17373 left(ios);
17374 {
17375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17376 std::string ex(str, iter.base());
17377 assert(ex == "0x1.26580b488p+30********");
17378 assert(ios.width() == 0);
17379 }
17380 ios.width(25);
17381 right(ios);
17382 {
17383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17384 std::string ex(str, iter.base());
17385 assert(ex == "********0x1.26580b488p+30");
17386 assert(ios.width() == 0);
17387 }
17388 ios.width(25);
17389 internal(ios);
17390 {
17391 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17392 std::string ex(str, iter.base());
17393 assert(ex == "0x********1.26580b488p+30");
17394 assert(ios.width() == 0);
17395 }
17396 }
17397 ios.imbue(lg);
17398 {
17399 ios.width(0);
17400 {
17401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17402 std::string ex(str, iter.base());
17403 assert(ex == "0x1;26580b488p+30");
17404 assert(ios.width() == 0);
17405 }
17406 ios.width(25);
17407 left(ios);
17408 {
17409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17410 std::string ex(str, iter.base());
17411 assert(ex == "0x1;26580b488p+30********");
17412 assert(ios.width() == 0);
17413 }
17414 ios.width(25);
17415 right(ios);
17416 {
17417 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17418 std::string ex(str, iter.base());
17419 assert(ex == "********0x1;26580b488p+30");
17420 assert(ios.width() == 0);
17421 }
17422 ios.width(25);
17423 internal(ios);
17424 {
17425 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17426 std::string ex(str, iter.base());
17427 assert(ex == "0x********1;26580b488p+30");
17428 assert(ios.width() == 0);
17429 }
17430 }
17431 }
17432 }
17433 showpos(ios);
17434 {
17435 noshowpoint(ios);
17436 {
17437 ios.imbue(lc);
17438 {
17439 ios.width(0);
17440 {
17441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17442 std::string ex(str, iter.base());
17443 assert(ex == "+0x1.26580b488p+30");
17444 assert(ios.width() == 0);
17445 }
17446 ios.width(25);
17447 left(ios);
17448 {
17449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17450 std::string ex(str, iter.base());
17451 assert(ex == "+0x1.26580b488p+30*******");
17452 assert(ios.width() == 0);
17453 }
17454 ios.width(25);
17455 right(ios);
17456 {
17457 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17458 std::string ex(str, iter.base());
17459 assert(ex == "*******+0x1.26580b488p+30");
17460 assert(ios.width() == 0);
17461 }
17462 ios.width(25);
17463 internal(ios);
17464 {
17465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17466 std::string ex(str, iter.base());
17467 assert(ex == "+*******0x1.26580b488p+30");
17468 assert(ios.width() == 0);
17469 }
17470 }
17471 ios.imbue(lg);
17472 {
17473 ios.width(0);
17474 {
17475 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17476 std::string ex(str, iter.base());
17477 assert(ex == "+0x1;26580b488p+30");
17478 assert(ios.width() == 0);
17479 }
17480 ios.width(25);
17481 left(ios);
17482 {
17483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17484 std::string ex(str, iter.base());
17485 assert(ex == "+0x1;26580b488p+30*******");
17486 assert(ios.width() == 0);
17487 }
17488 ios.width(25);
17489 right(ios);
17490 {
17491 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17492 std::string ex(str, iter.base());
17493 assert(ex == "*******+0x1;26580b488p+30");
17494 assert(ios.width() == 0);
17495 }
17496 ios.width(25);
17497 internal(ios);
17498 {
17499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17500 std::string ex(str, iter.base());
17501 assert(ex == "+*******0x1;26580b488p+30");
17502 assert(ios.width() == 0);
17503 }
17504 }
17505 }
17506 showpoint(ios);
17507 {
17508 ios.imbue(lc);
17509 {
17510 ios.width(0);
17511 {
17512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17513 std::string ex(str, iter.base());
17514 assert(ex == "+0x1.26580b488p+30");
17515 assert(ios.width() == 0);
17516 }
17517 ios.width(25);
17518 left(ios);
17519 {
17520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17521 std::string ex(str, iter.base());
17522 assert(ex == "+0x1.26580b488p+30*******");
17523 assert(ios.width() == 0);
17524 }
17525 ios.width(25);
17526 right(ios);
17527 {
17528 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17529 std::string ex(str, iter.base());
17530 assert(ex == "*******+0x1.26580b488p+30");
17531 assert(ios.width() == 0);
17532 }
17533 ios.width(25);
17534 internal(ios);
17535 {
17536 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17537 std::string ex(str, iter.base());
17538 assert(ex == "+*******0x1.26580b488p+30");
17539 assert(ios.width() == 0);
17540 }
17541 }
17542 ios.imbue(lg);
17543 {
17544 ios.width(0);
17545 {
17546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17547 std::string ex(str, iter.base());
17548 assert(ex == "+0x1;26580b488p+30");
17549 assert(ios.width() == 0);
17550 }
17551 ios.width(25);
17552 left(ios);
17553 {
17554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17555 std::string ex(str, iter.base());
17556 assert(ex == "+0x1;26580b488p+30*******");
17557 assert(ios.width() == 0);
17558 }
17559 ios.width(25);
17560 right(ios);
17561 {
17562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17563 std::string ex(str, iter.base());
17564 assert(ex == "*******+0x1;26580b488p+30");
17565 assert(ios.width() == 0);
17566 }
17567 ios.width(25);
17568 internal(ios);
17569 {
17570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17571 std::string ex(str, iter.base());
17572 assert(ex == "+*******0x1;26580b488p+30");
17573 assert(ios.width() == 0);
17574 }
17575 }
17576 }
17577 }
17578 }
17579 uppercase(ios);
17580 {
17581 noshowpos(ios);
17582 {
17583 noshowpoint(ios);
17584 {
17585 ios.imbue(lc);
17586 {
17587 ios.width(0);
17588 {
17589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17590 std::string ex(str, iter.base());
17591 assert(ex == "0X1.26580B488P+30");
17592 assert(ios.width() == 0);
17593 }
17594 ios.width(25);
17595 left(ios);
17596 {
17597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17598 std::string ex(str, iter.base());
17599 assert(ex == "0X1.26580B488P+30********");
17600 assert(ios.width() == 0);
17601 }
17602 ios.width(25);
17603 right(ios);
17604 {
17605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17606 std::string ex(str, iter.base());
17607 assert(ex == "********0X1.26580B488P+30");
17608 assert(ios.width() == 0);
17609 }
17610 ios.width(25);
17611 internal(ios);
17612 {
17613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17614 std::string ex(str, iter.base());
17615 assert(ex == "0X********1.26580B488P+30");
17616 assert(ios.width() == 0);
17617 }
17618 }
17619 ios.imbue(lg);
17620 {
17621 ios.width(0);
17622 {
17623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17624 std::string ex(str, iter.base());
17625 assert(ex == "0X1;26580B488P+30");
17626 assert(ios.width() == 0);
17627 }
17628 ios.width(25);
17629 left(ios);
17630 {
17631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17632 std::string ex(str, iter.base());
17633 assert(ex == "0X1;26580B488P+30********");
17634 assert(ios.width() == 0);
17635 }
17636 ios.width(25);
17637 right(ios);
17638 {
17639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17640 std::string ex(str, iter.base());
17641 assert(ex == "********0X1;26580B488P+30");
17642 assert(ios.width() == 0);
17643 }
17644 ios.width(25);
17645 internal(ios);
17646 {
17647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17648 std::string ex(str, iter.base());
17649 assert(ex == "0X********1;26580B488P+30");
17650 assert(ios.width() == 0);
17651 }
17652 }
17653 }
17654 showpoint(ios);
17655 {
17656 ios.imbue(lc);
17657 {
17658 ios.width(0);
17659 {
17660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17661 std::string ex(str, iter.base());
17662 assert(ex == "0X1.26580B488P+30");
17663 assert(ios.width() == 0);
17664 }
17665 ios.width(25);
17666 left(ios);
17667 {
17668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17669 std::string ex(str, iter.base());
17670 assert(ex == "0X1.26580B488P+30********");
17671 assert(ios.width() == 0);
17672 }
17673 ios.width(25);
17674 right(ios);
17675 {
17676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17677 std::string ex(str, iter.base());
17678 assert(ex == "********0X1.26580B488P+30");
17679 assert(ios.width() == 0);
17680 }
17681 ios.width(25);
17682 internal(ios);
17683 {
17684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17685 std::string ex(str, iter.base());
17686 assert(ex == "0X********1.26580B488P+30");
17687 assert(ios.width() == 0);
17688 }
17689 }
17690 ios.imbue(lg);
17691 {
17692 ios.width(0);
17693 {
17694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17695 std::string ex(str, iter.base());
17696 assert(ex == "0X1;26580B488P+30");
17697 assert(ios.width() == 0);
17698 }
17699 ios.width(25);
17700 left(ios);
17701 {
17702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17703 std::string ex(str, iter.base());
17704 assert(ex == "0X1;26580B488P+30********");
17705 assert(ios.width() == 0);
17706 }
17707 ios.width(25);
17708 right(ios);
17709 {
17710 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17711 std::string ex(str, iter.base());
17712 assert(ex == "********0X1;26580B488P+30");
17713 assert(ios.width() == 0);
17714 }
17715 ios.width(25);
17716 internal(ios);
17717 {
17718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17719 std::string ex(str, iter.base());
17720 assert(ex == "0X********1;26580B488P+30");
17721 assert(ios.width() == 0);
17722 }
17723 }
17724 }
17725 }
17726 showpos(ios);
17727 {
17728 noshowpoint(ios);
17729 {
17730 ios.imbue(lc);
17731 {
17732 ios.width(0);
17733 {
17734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17735 std::string ex(str, iter.base());
17736 assert(ex == "+0X1.26580B488P+30");
17737 assert(ios.width() == 0);
17738 }
17739 ios.width(25);
17740 left(ios);
17741 {
17742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17743 std::string ex(str, iter.base());
17744 assert(ex == "+0X1.26580B488P+30*******");
17745 assert(ios.width() == 0);
17746 }
17747 ios.width(25);
17748 right(ios);
17749 {
17750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17751 std::string ex(str, iter.base());
17752 assert(ex == "*******+0X1.26580B488P+30");
17753 assert(ios.width() == 0);
17754 }
17755 ios.width(25);
17756 internal(ios);
17757 {
17758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17759 std::string ex(str, iter.base());
17760 assert(ex == "+*******0X1.26580B488P+30");
17761 assert(ios.width() == 0);
17762 }
17763 }
17764 ios.imbue(lg);
17765 {
17766 ios.width(0);
17767 {
17768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17769 std::string ex(str, iter.base());
17770 assert(ex == "+0X1;26580B488P+30");
17771 assert(ios.width() == 0);
17772 }
17773 ios.width(25);
17774 left(ios);
17775 {
17776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17777 std::string ex(str, iter.base());
17778 assert(ex == "+0X1;26580B488P+30*******");
17779 assert(ios.width() == 0);
17780 }
17781 ios.width(25);
17782 right(ios);
17783 {
17784 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17785 std::string ex(str, iter.base());
17786 assert(ex == "*******+0X1;26580B488P+30");
17787 assert(ios.width() == 0);
17788 }
17789 ios.width(25);
17790 internal(ios);
17791 {
17792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17793 std::string ex(str, iter.base());
17794 assert(ex == "+*******0X1;26580B488P+30");
17795 assert(ios.width() == 0);
17796 }
17797 }
17798 }
17799 showpoint(ios);
17800 {
17801 ios.imbue(lc);
17802 {
17803 ios.width(0);
17804 {
17805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17806 std::string ex(str, iter.base());
17807 assert(ex == "+0X1.26580B488P+30");
17808 assert(ios.width() == 0);
17809 }
17810 ios.width(25);
17811 left(ios);
17812 {
17813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17814 std::string ex(str, iter.base());
17815 assert(ex == "+0X1.26580B488P+30*******");
17816 assert(ios.width() == 0);
17817 }
17818 ios.width(25);
17819 right(ios);
17820 {
17821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17822 std::string ex(str, iter.base());
17823 assert(ex == "*******+0X1.26580B488P+30");
17824 assert(ios.width() == 0);
17825 }
17826 ios.width(25);
17827 internal(ios);
17828 {
17829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17830 std::string ex(str, iter.base());
17831 assert(ex == "+*******0X1.26580B488P+30");
17832 assert(ios.width() == 0);
17833 }
17834 }
17835 ios.imbue(lg);
17836 {
17837 ios.width(0);
17838 {
17839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17840 std::string ex(str, iter.base());
17841 assert(ex == "+0X1;26580B488P+30");
17842 assert(ios.width() == 0);
17843 }
17844 ios.width(25);
17845 left(ios);
17846 {
17847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17848 std::string ex(str, iter.base());
17849 assert(ex == "+0X1;26580B488P+30*******");
17850 assert(ios.width() == 0);
17851 }
17852 ios.width(25);
17853 right(ios);
17854 {
17855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17856 std::string ex(str, iter.base());
17857 assert(ex == "*******+0X1;26580B488P+30");
17858 assert(ios.width() == 0);
17859 }
17860 ios.width(25);
17861 internal(ios);
17862 {
17863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17864 std::string ex(str, iter.base());
17865 assert(ex == "+*******0X1;26580B488P+30");
17866 assert(ios.width() == 0);
17867 }
17868 }
17869 }
17870 }
17871 }
17872 }
17873 }
17874 }
17875 }
17876
main(int,char **)17877 int main(int, char**)
17878 {
17879 test1();
17880 test2();
17881 test3();
17882 test4();
17883 test5();
17884 test6();
17885 test7();
17886 test8();
17887
17888 return 0;
17889 }
17890