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, long double v) const;
14
15 // TODO GLIBC uses a different string for positive and negative NAN numbers.
16 // XFAIL: target={{.*}}-linux-gnu{{.*}}
17
18 // XFAIL: LIBCXX-WINDOWS-FIXME
19
20 #include <locale>
21 #include <ios>
22 #include <cassert>
23 #include <streambuf>
24 #include <cmath>
25 #include "test_macros.h"
26 #include "test_iterators.h"
27
28 typedef std::num_put<char, output_iterator<char*> > F;
29
30 class my_facet
31 : public F
32 {
33 public:
my_facet(std::size_t refs=0)34 explicit my_facet(std::size_t refs = 0)
35 : F(refs) {}
36 };
37
38 class my_numpunct
39 : public std::numpunct<char>
40 {
41 public:
my_numpunct()42 my_numpunct() : std::numpunct<char>() {}
43
44 protected:
do_decimal_point() const45 virtual char_type do_decimal_point() const {return ';';}
do_thousands_sep() const46 virtual char_type do_thousands_sep() const {return '_';}
do_grouping() const47 virtual std::string do_grouping() const {return std::string("\1\2\3");}
48 };
49
test1()50 void test1()
51 {
52 char str[200];
53 output_iterator<char*> iter;
54 std::locale lc = std::locale::classic();
55 std::locale lg(lc, new my_numpunct);
56 const my_facet f(1);
57 {
58 long double v = +0.;
59 std::ios ios(0);
60 // %g
61 {
62 ios.precision(0);
63 {
64 nouppercase(ios);
65 {
66 noshowpos(ios);
67 {
68 noshowpoint(ios);
69 {
70 ios.imbue(lc);
71 {
72 ios.width(0);
73 {
74 iter = f.put(output_iterator<char*>(str), ios, '*', v);
75 std::string ex(str, iter.base());
76 assert(ex == "0");
77 assert(ios.width() == 0);
78 }
79 ios.width(25);
80 left(ios);
81 {
82 iter = f.put(output_iterator<char*>(str), ios, '*', v);
83 std::string ex(str, iter.base());
84 assert(ex == "0************************");
85 assert(ios.width() == 0);
86 }
87 ios.width(25);
88 right(ios);
89 {
90 iter = f.put(output_iterator<char*>(str), ios, '*', v);
91 std::string ex(str, iter.base());
92 assert(ex == "************************0");
93 assert(ios.width() == 0);
94 }
95 ios.width(25);
96 internal(ios);
97 {
98 iter = f.put(output_iterator<char*>(str), ios, '*', v);
99 std::string ex(str, iter.base());
100 assert(ex == "************************0");
101 assert(ios.width() == 0);
102 }
103 }
104 ios.imbue(lg);
105 {
106 ios.width(0);
107 {
108 iter = f.put(output_iterator<char*>(str), ios, '*', v);
109 std::string ex(str, iter.base());
110 assert(ex == "0");
111 assert(ios.width() == 0);
112 }
113 ios.width(25);
114 left(ios);
115 {
116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
117 std::string ex(str, iter.base());
118 assert(ex == "0************************");
119 assert(ios.width() == 0);
120 }
121 ios.width(25);
122 right(ios);
123 {
124 iter = f.put(output_iterator<char*>(str), ios, '*', v);
125 std::string ex(str, iter.base());
126 assert(ex == "************************0");
127 assert(ios.width() == 0);
128 }
129 ios.width(25);
130 internal(ios);
131 {
132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
133 std::string ex(str, iter.base());
134 assert(ex == "************************0");
135 assert(ios.width() == 0);
136 }
137 }
138 }
139 showpoint(ios);
140 {
141 ios.imbue(lc);
142 {
143 ios.width(0);
144 {
145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
146 std::string ex(str, iter.base());
147 assert(ex == "0.");
148 assert(ios.width() == 0);
149 }
150 ios.width(25);
151 left(ios);
152 {
153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
154 std::string ex(str, iter.base());
155 assert(ex == "0.***********************");
156 assert(ios.width() == 0);
157 }
158 ios.width(25);
159 right(ios);
160 {
161 iter = f.put(output_iterator<char*>(str), ios, '*', v);
162 std::string ex(str, iter.base());
163 assert(ex == "***********************0.");
164 assert(ios.width() == 0);
165 }
166 ios.width(25);
167 internal(ios);
168 {
169 iter = f.put(output_iterator<char*>(str), ios, '*', v);
170 std::string ex(str, iter.base());
171 assert(ex == "***********************0.");
172 assert(ios.width() == 0);
173 }
174 }
175 ios.imbue(lg);
176 {
177 ios.width(0);
178 {
179 iter = f.put(output_iterator<char*>(str), ios, '*', v);
180 std::string ex(str, iter.base());
181 assert(ex == "0;");
182 assert(ios.width() == 0);
183 }
184 ios.width(25);
185 left(ios);
186 {
187 iter = f.put(output_iterator<char*>(str), ios, '*', v);
188 std::string ex(str, iter.base());
189 assert(ex == "0;***********************");
190 assert(ios.width() == 0);
191 }
192 ios.width(25);
193 right(ios);
194 {
195 iter = f.put(output_iterator<char*>(str), ios, '*', v);
196 std::string ex(str, iter.base());
197 assert(ex == "***********************0;");
198 assert(ios.width() == 0);
199 }
200 ios.width(25);
201 internal(ios);
202 {
203 iter = f.put(output_iterator<char*>(str), ios, '*', v);
204 std::string ex(str, iter.base());
205 assert(ex == "***********************0;");
206 assert(ios.width() == 0);
207 }
208 }
209 }
210 }
211 showpos(ios);
212 {
213 noshowpoint(ios);
214 {
215 ios.imbue(lc);
216 {
217 ios.width(0);
218 {
219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
220 std::string ex(str, iter.base());
221 assert(ex == "+0");
222 assert(ios.width() == 0);
223 }
224 ios.width(25);
225 left(ios);
226 {
227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
228 std::string ex(str, iter.base());
229 assert(ex == "+0***********************");
230 assert(ios.width() == 0);
231 }
232 ios.width(25);
233 right(ios);
234 {
235 iter = f.put(output_iterator<char*>(str), ios, '*', v);
236 std::string ex(str, iter.base());
237 assert(ex == "***********************+0");
238 assert(ios.width() == 0);
239 }
240 ios.width(25);
241 internal(ios);
242 {
243 iter = f.put(output_iterator<char*>(str), ios, '*', v);
244 std::string ex(str, iter.base());
245 assert(ex == "+***********************0");
246 assert(ios.width() == 0);
247 }
248 }
249 ios.imbue(lg);
250 {
251 ios.width(0);
252 {
253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
254 std::string ex(str, iter.base());
255 assert(ex == "+0");
256 assert(ios.width() == 0);
257 }
258 ios.width(25);
259 left(ios);
260 {
261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
262 std::string ex(str, iter.base());
263 assert(ex == "+0***********************");
264 assert(ios.width() == 0);
265 }
266 ios.width(25);
267 right(ios);
268 {
269 iter = f.put(output_iterator<char*>(str), ios, '*', v);
270 std::string ex(str, iter.base());
271 assert(ex == "***********************+0");
272 assert(ios.width() == 0);
273 }
274 ios.width(25);
275 internal(ios);
276 {
277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
278 std::string ex(str, iter.base());
279 assert(ex == "+***********************0");
280 assert(ios.width() == 0);
281 }
282 }
283 }
284 showpoint(ios);
285 {
286 ios.imbue(lc);
287 {
288 ios.width(0);
289 {
290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
291 std::string ex(str, iter.base());
292 assert(ex == "+0.");
293 assert(ios.width() == 0);
294 }
295 ios.width(25);
296 left(ios);
297 {
298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
299 std::string ex(str, iter.base());
300 assert(ex == "+0.**********************");
301 assert(ios.width() == 0);
302 }
303 ios.width(25);
304 right(ios);
305 {
306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
307 std::string ex(str, iter.base());
308 assert(ex == "**********************+0.");
309 assert(ios.width() == 0);
310 }
311 ios.width(25);
312 internal(ios);
313 {
314 iter = f.put(output_iterator<char*>(str), ios, '*', v);
315 std::string ex(str, iter.base());
316 assert(ex == "+**********************0.");
317 assert(ios.width() == 0);
318 }
319 }
320 ios.imbue(lg);
321 {
322 ios.width(0);
323 {
324 iter = f.put(output_iterator<char*>(str), ios, '*', v);
325 std::string ex(str, iter.base());
326 assert(ex == "+0;");
327 assert(ios.width() == 0);
328 }
329 ios.width(25);
330 left(ios);
331 {
332 iter = f.put(output_iterator<char*>(str), ios, '*', v);
333 std::string ex(str, iter.base());
334 assert(ex == "+0;**********************");
335 assert(ios.width() == 0);
336 }
337 ios.width(25);
338 right(ios);
339 {
340 iter = f.put(output_iterator<char*>(str), ios, '*', v);
341 std::string ex(str, iter.base());
342 assert(ex == "**********************+0;");
343 assert(ios.width() == 0);
344 }
345 ios.width(25);
346 internal(ios);
347 {
348 iter = f.put(output_iterator<char*>(str), ios, '*', v);
349 std::string ex(str, iter.base());
350 assert(ex == "+**********************0;");
351 assert(ios.width() == 0);
352 }
353 }
354 }
355 }
356 }
357 uppercase(ios);
358 {
359 noshowpos(ios);
360 {
361 noshowpoint(ios);
362 {
363 ios.imbue(lc);
364 {
365 ios.width(0);
366 {
367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
368 std::string ex(str, iter.base());
369 assert(ex == "0");
370 assert(ios.width() == 0);
371 }
372 ios.width(25);
373 left(ios);
374 {
375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
376 std::string ex(str, iter.base());
377 assert(ex == "0************************");
378 assert(ios.width() == 0);
379 }
380 ios.width(25);
381 right(ios);
382 {
383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
384 std::string ex(str, iter.base());
385 assert(ex == "************************0");
386 assert(ios.width() == 0);
387 }
388 ios.width(25);
389 internal(ios);
390 {
391 iter = f.put(output_iterator<char*>(str), ios, '*', v);
392 std::string ex(str, iter.base());
393 assert(ex == "************************0");
394 assert(ios.width() == 0);
395 }
396 }
397 ios.imbue(lg);
398 {
399 ios.width(0);
400 {
401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
402 std::string ex(str, iter.base());
403 assert(ex == "0");
404 assert(ios.width() == 0);
405 }
406 ios.width(25);
407 left(ios);
408 {
409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
410 std::string ex(str, iter.base());
411 assert(ex == "0************************");
412 assert(ios.width() == 0);
413 }
414 ios.width(25);
415 right(ios);
416 {
417 iter = f.put(output_iterator<char*>(str), ios, '*', v);
418 std::string ex(str, iter.base());
419 assert(ex == "************************0");
420 assert(ios.width() == 0);
421 }
422 ios.width(25);
423 internal(ios);
424 {
425 iter = f.put(output_iterator<char*>(str), ios, '*', v);
426 std::string ex(str, iter.base());
427 assert(ex == "************************0");
428 assert(ios.width() == 0);
429 }
430 }
431 }
432 showpoint(ios);
433 {
434 ios.imbue(lc);
435 {
436 ios.width(0);
437 {
438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
439 std::string ex(str, iter.base());
440 assert(ex == "0.");
441 assert(ios.width() == 0);
442 }
443 ios.width(25);
444 left(ios);
445 {
446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
447 std::string ex(str, iter.base());
448 assert(ex == "0.***********************");
449 assert(ios.width() == 0);
450 }
451 ios.width(25);
452 right(ios);
453 {
454 iter = f.put(output_iterator<char*>(str), ios, '*', v);
455 std::string ex(str, iter.base());
456 assert(ex == "***********************0.");
457 assert(ios.width() == 0);
458 }
459 ios.width(25);
460 internal(ios);
461 {
462 iter = f.put(output_iterator<char*>(str), ios, '*', v);
463 std::string ex(str, iter.base());
464 assert(ex == "***********************0.");
465 assert(ios.width() == 0);
466 }
467 }
468 ios.imbue(lg);
469 {
470 ios.width(0);
471 {
472 iter = f.put(output_iterator<char*>(str), ios, '*', v);
473 std::string ex(str, iter.base());
474 assert(ex == "0;");
475 assert(ios.width() == 0);
476 }
477 ios.width(25);
478 left(ios);
479 {
480 iter = f.put(output_iterator<char*>(str), ios, '*', v);
481 std::string ex(str, iter.base());
482 assert(ex == "0;***********************");
483 assert(ios.width() == 0);
484 }
485 ios.width(25);
486 right(ios);
487 {
488 iter = f.put(output_iterator<char*>(str), ios, '*', v);
489 std::string ex(str, iter.base());
490 assert(ex == "***********************0;");
491 assert(ios.width() == 0);
492 }
493 ios.width(25);
494 internal(ios);
495 {
496 iter = f.put(output_iterator<char*>(str), ios, '*', v);
497 std::string ex(str, iter.base());
498 assert(ex == "***********************0;");
499 assert(ios.width() == 0);
500 }
501 }
502 }
503 }
504 showpos(ios);
505 {
506 noshowpoint(ios);
507 {
508 ios.imbue(lc);
509 {
510 ios.width(0);
511 {
512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
513 std::string ex(str, iter.base());
514 assert(ex == "+0");
515 assert(ios.width() == 0);
516 }
517 ios.width(25);
518 left(ios);
519 {
520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
521 std::string ex(str, iter.base());
522 assert(ex == "+0***********************");
523 assert(ios.width() == 0);
524 }
525 ios.width(25);
526 right(ios);
527 {
528 iter = f.put(output_iterator<char*>(str), ios, '*', v);
529 std::string ex(str, iter.base());
530 assert(ex == "***********************+0");
531 assert(ios.width() == 0);
532 }
533 ios.width(25);
534 internal(ios);
535 {
536 iter = f.put(output_iterator<char*>(str), ios, '*', v);
537 std::string ex(str, iter.base());
538 assert(ex == "+***********************0");
539 assert(ios.width() == 0);
540 }
541 }
542 ios.imbue(lg);
543 {
544 ios.width(0);
545 {
546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
547 std::string ex(str, iter.base());
548 assert(ex == "+0");
549 assert(ios.width() == 0);
550 }
551 ios.width(25);
552 left(ios);
553 {
554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
555 std::string ex(str, iter.base());
556 assert(ex == "+0***********************");
557 assert(ios.width() == 0);
558 }
559 ios.width(25);
560 right(ios);
561 {
562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
563 std::string ex(str, iter.base());
564 assert(ex == "***********************+0");
565 assert(ios.width() == 0);
566 }
567 ios.width(25);
568 internal(ios);
569 {
570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
571 std::string ex(str, iter.base());
572 assert(ex == "+***********************0");
573 assert(ios.width() == 0);
574 }
575 }
576 }
577 showpoint(ios);
578 {
579 ios.imbue(lc);
580 {
581 ios.width(0);
582 {
583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
584 std::string ex(str, iter.base());
585 assert(ex == "+0.");
586 assert(ios.width() == 0);
587 }
588 ios.width(25);
589 left(ios);
590 {
591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
592 std::string ex(str, iter.base());
593 assert(ex == "+0.**********************");
594 assert(ios.width() == 0);
595 }
596 ios.width(25);
597 right(ios);
598 {
599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
600 std::string ex(str, iter.base());
601 assert(ex == "**********************+0.");
602 assert(ios.width() == 0);
603 }
604 ios.width(25);
605 internal(ios);
606 {
607 iter = f.put(output_iterator<char*>(str), ios, '*', v);
608 std::string ex(str, iter.base());
609 assert(ex == "+**********************0.");
610 assert(ios.width() == 0);
611 }
612 }
613 ios.imbue(lg);
614 {
615 ios.width(0);
616 {
617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
618 std::string ex(str, iter.base());
619 assert(ex == "+0;");
620 assert(ios.width() == 0);
621 }
622 ios.width(25);
623 left(ios);
624 {
625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
626 std::string ex(str, iter.base());
627 assert(ex == "+0;**********************");
628 assert(ios.width() == 0);
629 }
630 ios.width(25);
631 right(ios);
632 {
633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
634 std::string ex(str, iter.base());
635 assert(ex == "**********************+0;");
636 assert(ios.width() == 0);
637 }
638 ios.width(25);
639 internal(ios);
640 {
641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
642 std::string ex(str, iter.base());
643 assert(ex == "+**********************0;");
644 assert(ios.width() == 0);
645 }
646 }
647 }
648 }
649 }
650 }
651 ios.precision(1);
652 {
653 nouppercase(ios);
654 {
655 noshowpos(ios);
656 {
657 noshowpoint(ios);
658 {
659 ios.imbue(lc);
660 {
661 ios.width(0);
662 {
663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
664 std::string ex(str, iter.base());
665 assert(ex == "0");
666 assert(ios.width() == 0);
667 }
668 ios.width(25);
669 left(ios);
670 {
671 iter = f.put(output_iterator<char*>(str), ios, '*', v);
672 std::string ex(str, iter.base());
673 assert(ex == "0************************");
674 assert(ios.width() == 0);
675 }
676 ios.width(25);
677 right(ios);
678 {
679 iter = f.put(output_iterator<char*>(str), ios, '*', v);
680 std::string ex(str, iter.base());
681 assert(ex == "************************0");
682 assert(ios.width() == 0);
683 }
684 ios.width(25);
685 internal(ios);
686 {
687 iter = f.put(output_iterator<char*>(str), ios, '*', v);
688 std::string ex(str, iter.base());
689 assert(ex == "************************0");
690 assert(ios.width() == 0);
691 }
692 }
693 ios.imbue(lg);
694 {
695 ios.width(0);
696 {
697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
698 std::string ex(str, iter.base());
699 assert(ex == "0");
700 assert(ios.width() == 0);
701 }
702 ios.width(25);
703 left(ios);
704 {
705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
706 std::string ex(str, iter.base());
707 assert(ex == "0************************");
708 assert(ios.width() == 0);
709 }
710 ios.width(25);
711 right(ios);
712 {
713 iter = f.put(output_iterator<char*>(str), ios, '*', v);
714 std::string ex(str, iter.base());
715 assert(ex == "************************0");
716 assert(ios.width() == 0);
717 }
718 ios.width(25);
719 internal(ios);
720 {
721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
722 std::string ex(str, iter.base());
723 assert(ex == "************************0");
724 assert(ios.width() == 0);
725 }
726 }
727 }
728 showpoint(ios);
729 {
730 ios.imbue(lc);
731 {
732 ios.width(0);
733 {
734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
735 std::string ex(str, iter.base());
736 assert(ex == "0.");
737 assert(ios.width() == 0);
738 }
739 ios.width(25);
740 left(ios);
741 {
742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
743 std::string ex(str, iter.base());
744 assert(ex == "0.***********************");
745 assert(ios.width() == 0);
746 }
747 ios.width(25);
748 right(ios);
749 {
750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
751 std::string ex(str, iter.base());
752 assert(ex == "***********************0.");
753 assert(ios.width() == 0);
754 }
755 ios.width(25);
756 internal(ios);
757 {
758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
759 std::string ex(str, iter.base());
760 assert(ex == "***********************0.");
761 assert(ios.width() == 0);
762 }
763 }
764 ios.imbue(lg);
765 {
766 ios.width(0);
767 {
768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
769 std::string ex(str, iter.base());
770 assert(ex == "0;");
771 assert(ios.width() == 0);
772 }
773 ios.width(25);
774 left(ios);
775 {
776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
777 std::string ex(str, iter.base());
778 assert(ex == "0;***********************");
779 assert(ios.width() == 0);
780 }
781 ios.width(25);
782 right(ios);
783 {
784 iter = f.put(output_iterator<char*>(str), ios, '*', v);
785 std::string ex(str, iter.base());
786 assert(ex == "***********************0;");
787 assert(ios.width() == 0);
788 }
789 ios.width(25);
790 internal(ios);
791 {
792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
793 std::string ex(str, iter.base());
794 assert(ex == "***********************0;");
795 assert(ios.width() == 0);
796 }
797 }
798 }
799 }
800 showpos(ios);
801 {
802 noshowpoint(ios);
803 {
804 ios.imbue(lc);
805 {
806 ios.width(0);
807 {
808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
809 std::string ex(str, iter.base());
810 assert(ex == "+0");
811 assert(ios.width() == 0);
812 }
813 ios.width(25);
814 left(ios);
815 {
816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
817 std::string ex(str, iter.base());
818 assert(ex == "+0***********************");
819 assert(ios.width() == 0);
820 }
821 ios.width(25);
822 right(ios);
823 {
824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
825 std::string ex(str, iter.base());
826 assert(ex == "***********************+0");
827 assert(ios.width() == 0);
828 }
829 ios.width(25);
830 internal(ios);
831 {
832 iter = f.put(output_iterator<char*>(str), ios, '*', v);
833 std::string ex(str, iter.base());
834 assert(ex == "+***********************0");
835 assert(ios.width() == 0);
836 }
837 }
838 ios.imbue(lg);
839 {
840 ios.width(0);
841 {
842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
843 std::string ex(str, iter.base());
844 assert(ex == "+0");
845 assert(ios.width() == 0);
846 }
847 ios.width(25);
848 left(ios);
849 {
850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
851 std::string ex(str, iter.base());
852 assert(ex == "+0***********************");
853 assert(ios.width() == 0);
854 }
855 ios.width(25);
856 right(ios);
857 {
858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
859 std::string ex(str, iter.base());
860 assert(ex == "***********************+0");
861 assert(ios.width() == 0);
862 }
863 ios.width(25);
864 internal(ios);
865 {
866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
867 std::string ex(str, iter.base());
868 assert(ex == "+***********************0");
869 assert(ios.width() == 0);
870 }
871 }
872 }
873 showpoint(ios);
874 {
875 ios.imbue(lc);
876 {
877 ios.width(0);
878 {
879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
880 std::string ex(str, iter.base());
881 assert(ex == "+0.");
882 assert(ios.width() == 0);
883 }
884 ios.width(25);
885 left(ios);
886 {
887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
888 std::string ex(str, iter.base());
889 assert(ex == "+0.**********************");
890 assert(ios.width() == 0);
891 }
892 ios.width(25);
893 right(ios);
894 {
895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
896 std::string ex(str, iter.base());
897 assert(ex == "**********************+0.");
898 assert(ios.width() == 0);
899 }
900 ios.width(25);
901 internal(ios);
902 {
903 iter = f.put(output_iterator<char*>(str), ios, '*', v);
904 std::string ex(str, iter.base());
905 assert(ex == "+**********************0.");
906 assert(ios.width() == 0);
907 }
908 }
909 ios.imbue(lg);
910 {
911 ios.width(0);
912 {
913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
914 std::string ex(str, iter.base());
915 assert(ex == "+0;");
916 assert(ios.width() == 0);
917 }
918 ios.width(25);
919 left(ios);
920 {
921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
922 std::string ex(str, iter.base());
923 assert(ex == "+0;**********************");
924 assert(ios.width() == 0);
925 }
926 ios.width(25);
927 right(ios);
928 {
929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
930 std::string ex(str, iter.base());
931 assert(ex == "**********************+0;");
932 assert(ios.width() == 0);
933 }
934 ios.width(25);
935 internal(ios);
936 {
937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
938 std::string ex(str, iter.base());
939 assert(ex == "+**********************0;");
940 assert(ios.width() == 0);
941 }
942 }
943 }
944 }
945 }
946 uppercase(ios);
947 {
948 noshowpos(ios);
949 {
950 noshowpoint(ios);
951 {
952 ios.imbue(lc);
953 {
954 ios.width(0);
955 {
956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
957 std::string ex(str, iter.base());
958 assert(ex == "0");
959 assert(ios.width() == 0);
960 }
961 ios.width(25);
962 left(ios);
963 {
964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
965 std::string ex(str, iter.base());
966 assert(ex == "0************************");
967 assert(ios.width() == 0);
968 }
969 ios.width(25);
970 right(ios);
971 {
972 iter = f.put(output_iterator<char*>(str), ios, '*', v);
973 std::string ex(str, iter.base());
974 assert(ex == "************************0");
975 assert(ios.width() == 0);
976 }
977 ios.width(25);
978 internal(ios);
979 {
980 iter = f.put(output_iterator<char*>(str), ios, '*', v);
981 std::string ex(str, iter.base());
982 assert(ex == "************************0");
983 assert(ios.width() == 0);
984 }
985 }
986 ios.imbue(lg);
987 {
988 ios.width(0);
989 {
990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
991 std::string ex(str, iter.base());
992 assert(ex == "0");
993 assert(ios.width() == 0);
994 }
995 ios.width(25);
996 left(ios);
997 {
998 iter = f.put(output_iterator<char*>(str), ios, '*', v);
999 std::string ex(str, iter.base());
1000 assert(ex == "0************************");
1001 assert(ios.width() == 0);
1002 }
1003 ios.width(25);
1004 right(ios);
1005 {
1006 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1007 std::string ex(str, iter.base());
1008 assert(ex == "************************0");
1009 assert(ios.width() == 0);
1010 }
1011 ios.width(25);
1012 internal(ios);
1013 {
1014 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1015 std::string ex(str, iter.base());
1016 assert(ex == "************************0");
1017 assert(ios.width() == 0);
1018 }
1019 }
1020 }
1021 showpoint(ios);
1022 {
1023 ios.imbue(lc);
1024 {
1025 ios.width(0);
1026 {
1027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1028 std::string ex(str, iter.base());
1029 assert(ex == "0.");
1030 assert(ios.width() == 0);
1031 }
1032 ios.width(25);
1033 left(ios);
1034 {
1035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1036 std::string ex(str, iter.base());
1037 assert(ex == "0.***********************");
1038 assert(ios.width() == 0);
1039 }
1040 ios.width(25);
1041 right(ios);
1042 {
1043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1044 std::string ex(str, iter.base());
1045 assert(ex == "***********************0.");
1046 assert(ios.width() == 0);
1047 }
1048 ios.width(25);
1049 internal(ios);
1050 {
1051 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1052 std::string ex(str, iter.base());
1053 assert(ex == "***********************0.");
1054 assert(ios.width() == 0);
1055 }
1056 }
1057 ios.imbue(lg);
1058 {
1059 ios.width(0);
1060 {
1061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1062 std::string ex(str, iter.base());
1063 assert(ex == "0;");
1064 assert(ios.width() == 0);
1065 }
1066 ios.width(25);
1067 left(ios);
1068 {
1069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1070 std::string ex(str, iter.base());
1071 assert(ex == "0;***********************");
1072 assert(ios.width() == 0);
1073 }
1074 ios.width(25);
1075 right(ios);
1076 {
1077 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1078 std::string ex(str, iter.base());
1079 assert(ex == "***********************0;");
1080 assert(ios.width() == 0);
1081 }
1082 ios.width(25);
1083 internal(ios);
1084 {
1085 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1086 std::string ex(str, iter.base());
1087 assert(ex == "***********************0;");
1088 assert(ios.width() == 0);
1089 }
1090 }
1091 }
1092 }
1093 showpos(ios);
1094 {
1095 noshowpoint(ios);
1096 {
1097 ios.imbue(lc);
1098 {
1099 ios.width(0);
1100 {
1101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1102 std::string ex(str, iter.base());
1103 assert(ex == "+0");
1104 assert(ios.width() == 0);
1105 }
1106 ios.width(25);
1107 left(ios);
1108 {
1109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1110 std::string ex(str, iter.base());
1111 assert(ex == "+0***********************");
1112 assert(ios.width() == 0);
1113 }
1114 ios.width(25);
1115 right(ios);
1116 {
1117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1118 std::string ex(str, iter.base());
1119 assert(ex == "***********************+0");
1120 assert(ios.width() == 0);
1121 }
1122 ios.width(25);
1123 internal(ios);
1124 {
1125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1126 std::string ex(str, iter.base());
1127 assert(ex == "+***********************0");
1128 assert(ios.width() == 0);
1129 }
1130 }
1131 ios.imbue(lg);
1132 {
1133 ios.width(0);
1134 {
1135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1136 std::string ex(str, iter.base());
1137 assert(ex == "+0");
1138 assert(ios.width() == 0);
1139 }
1140 ios.width(25);
1141 left(ios);
1142 {
1143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1144 std::string ex(str, iter.base());
1145 assert(ex == "+0***********************");
1146 assert(ios.width() == 0);
1147 }
1148 ios.width(25);
1149 right(ios);
1150 {
1151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1152 std::string ex(str, iter.base());
1153 assert(ex == "***********************+0");
1154 assert(ios.width() == 0);
1155 }
1156 ios.width(25);
1157 internal(ios);
1158 {
1159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1160 std::string ex(str, iter.base());
1161 assert(ex == "+***********************0");
1162 assert(ios.width() == 0);
1163 }
1164 }
1165 }
1166 showpoint(ios);
1167 {
1168 ios.imbue(lc);
1169 {
1170 ios.width(0);
1171 {
1172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1173 std::string ex(str, iter.base());
1174 assert(ex == "+0.");
1175 assert(ios.width() == 0);
1176 }
1177 ios.width(25);
1178 left(ios);
1179 {
1180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1181 std::string ex(str, iter.base());
1182 assert(ex == "+0.**********************");
1183 assert(ios.width() == 0);
1184 }
1185 ios.width(25);
1186 right(ios);
1187 {
1188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1189 std::string ex(str, iter.base());
1190 assert(ex == "**********************+0.");
1191 assert(ios.width() == 0);
1192 }
1193 ios.width(25);
1194 internal(ios);
1195 {
1196 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1197 std::string ex(str, iter.base());
1198 assert(ex == "+**********************0.");
1199 assert(ios.width() == 0);
1200 }
1201 }
1202 ios.imbue(lg);
1203 {
1204 ios.width(0);
1205 {
1206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1207 std::string ex(str, iter.base());
1208 assert(ex == "+0;");
1209 assert(ios.width() == 0);
1210 }
1211 ios.width(25);
1212 left(ios);
1213 {
1214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1215 std::string ex(str, iter.base());
1216 assert(ex == "+0;**********************");
1217 assert(ios.width() == 0);
1218 }
1219 ios.width(25);
1220 right(ios);
1221 {
1222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1223 std::string ex(str, iter.base());
1224 assert(ex == "**********************+0;");
1225 assert(ios.width() == 0);
1226 }
1227 ios.width(25);
1228 internal(ios);
1229 {
1230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1231 std::string ex(str, iter.base());
1232 assert(ex == "+**********************0;");
1233 assert(ios.width() == 0);
1234 }
1235 }
1236 }
1237 }
1238 }
1239 }
1240 ios.precision(6);
1241 {
1242 nouppercase(ios);
1243 {
1244 noshowpos(ios);
1245 {
1246 noshowpoint(ios);
1247 {
1248 ios.imbue(lc);
1249 {
1250 ios.width(0);
1251 {
1252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1253 std::string ex(str, iter.base());
1254 assert(ex == "0");
1255 assert(ios.width() == 0);
1256 }
1257 ios.width(25);
1258 left(ios);
1259 {
1260 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1261 std::string ex(str, iter.base());
1262 assert(ex == "0************************");
1263 assert(ios.width() == 0);
1264 }
1265 ios.width(25);
1266 right(ios);
1267 {
1268 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1269 std::string ex(str, iter.base());
1270 assert(ex == "************************0");
1271 assert(ios.width() == 0);
1272 }
1273 ios.width(25);
1274 internal(ios);
1275 {
1276 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1277 std::string ex(str, iter.base());
1278 assert(ex == "************************0");
1279 assert(ios.width() == 0);
1280 }
1281 }
1282 ios.imbue(lg);
1283 {
1284 ios.width(0);
1285 {
1286 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1287 std::string ex(str, iter.base());
1288 assert(ex == "0");
1289 assert(ios.width() == 0);
1290 }
1291 ios.width(25);
1292 left(ios);
1293 {
1294 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1295 std::string ex(str, iter.base());
1296 assert(ex == "0************************");
1297 assert(ios.width() == 0);
1298 }
1299 ios.width(25);
1300 right(ios);
1301 {
1302 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1303 std::string ex(str, iter.base());
1304 assert(ex == "************************0");
1305 assert(ios.width() == 0);
1306 }
1307 ios.width(25);
1308 internal(ios);
1309 {
1310 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1311 std::string ex(str, iter.base());
1312 assert(ex == "************************0");
1313 assert(ios.width() == 0);
1314 }
1315 }
1316 }
1317 showpoint(ios);
1318 {
1319 ios.imbue(lc);
1320 {
1321 ios.width(0);
1322 {
1323 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1324 std::string ex(str, iter.base());
1325 assert(ex == "0.00000");
1326 assert(ios.width() == 0);
1327 }
1328 ios.width(25);
1329 left(ios);
1330 {
1331 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1332 std::string ex(str, iter.base());
1333 assert(ex == "0.00000******************");
1334 assert(ios.width() == 0);
1335 }
1336 ios.width(25);
1337 right(ios);
1338 {
1339 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1340 std::string ex(str, iter.base());
1341 assert(ex == "******************0.00000");
1342 assert(ios.width() == 0);
1343 }
1344 ios.width(25);
1345 internal(ios);
1346 {
1347 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1348 std::string ex(str, iter.base());
1349 assert(ex == "******************0.00000");
1350 assert(ios.width() == 0);
1351 }
1352 }
1353 ios.imbue(lg);
1354 {
1355 ios.width(0);
1356 {
1357 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1358 std::string ex(str, iter.base());
1359 assert(ex == "0;00000");
1360 assert(ios.width() == 0);
1361 }
1362 ios.width(25);
1363 left(ios);
1364 {
1365 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1366 std::string ex(str, iter.base());
1367 assert(ex == "0;00000******************");
1368 assert(ios.width() == 0);
1369 }
1370 ios.width(25);
1371 right(ios);
1372 {
1373 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1374 std::string ex(str, iter.base());
1375 assert(ex == "******************0;00000");
1376 assert(ios.width() == 0);
1377 }
1378 ios.width(25);
1379 internal(ios);
1380 {
1381 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1382 std::string ex(str, iter.base());
1383 assert(ex == "******************0;00000");
1384 assert(ios.width() == 0);
1385 }
1386 }
1387 }
1388 }
1389 showpos(ios);
1390 {
1391 noshowpoint(ios);
1392 {
1393 ios.imbue(lc);
1394 {
1395 ios.width(0);
1396 {
1397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1398 std::string ex(str, iter.base());
1399 assert(ex == "+0");
1400 assert(ios.width() == 0);
1401 }
1402 ios.width(25);
1403 left(ios);
1404 {
1405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1406 std::string ex(str, iter.base());
1407 assert(ex == "+0***********************");
1408 assert(ios.width() == 0);
1409 }
1410 ios.width(25);
1411 right(ios);
1412 {
1413 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1414 std::string ex(str, iter.base());
1415 assert(ex == "***********************+0");
1416 assert(ios.width() == 0);
1417 }
1418 ios.width(25);
1419 internal(ios);
1420 {
1421 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1422 std::string ex(str, iter.base());
1423 assert(ex == "+***********************0");
1424 assert(ios.width() == 0);
1425 }
1426 }
1427 ios.imbue(lg);
1428 {
1429 ios.width(0);
1430 {
1431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1432 std::string ex(str, iter.base());
1433 assert(ex == "+0");
1434 assert(ios.width() == 0);
1435 }
1436 ios.width(25);
1437 left(ios);
1438 {
1439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1440 std::string ex(str, iter.base());
1441 assert(ex == "+0***********************");
1442 assert(ios.width() == 0);
1443 }
1444 ios.width(25);
1445 right(ios);
1446 {
1447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1448 std::string ex(str, iter.base());
1449 assert(ex == "***********************+0");
1450 assert(ios.width() == 0);
1451 }
1452 ios.width(25);
1453 internal(ios);
1454 {
1455 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1456 std::string ex(str, iter.base());
1457 assert(ex == "+***********************0");
1458 assert(ios.width() == 0);
1459 }
1460 }
1461 }
1462 showpoint(ios);
1463 {
1464 ios.imbue(lc);
1465 {
1466 ios.width(0);
1467 {
1468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1469 std::string ex(str, iter.base());
1470 assert(ex == "+0.00000");
1471 assert(ios.width() == 0);
1472 }
1473 ios.width(25);
1474 left(ios);
1475 {
1476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1477 std::string ex(str, iter.base());
1478 assert(ex == "+0.00000*****************");
1479 assert(ios.width() == 0);
1480 }
1481 ios.width(25);
1482 right(ios);
1483 {
1484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1485 std::string ex(str, iter.base());
1486 assert(ex == "*****************+0.00000");
1487 assert(ios.width() == 0);
1488 }
1489 ios.width(25);
1490 internal(ios);
1491 {
1492 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1493 std::string ex(str, iter.base());
1494 assert(ex == "+*****************0.00000");
1495 assert(ios.width() == 0);
1496 }
1497 }
1498 ios.imbue(lg);
1499 {
1500 ios.width(0);
1501 {
1502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1503 std::string ex(str, iter.base());
1504 assert(ex == "+0;00000");
1505 assert(ios.width() == 0);
1506 }
1507 ios.width(25);
1508 left(ios);
1509 {
1510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1511 std::string ex(str, iter.base());
1512 assert(ex == "+0;00000*****************");
1513 assert(ios.width() == 0);
1514 }
1515 ios.width(25);
1516 right(ios);
1517 {
1518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1519 std::string ex(str, iter.base());
1520 assert(ex == "*****************+0;00000");
1521 assert(ios.width() == 0);
1522 }
1523 ios.width(25);
1524 internal(ios);
1525 {
1526 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1527 std::string ex(str, iter.base());
1528 assert(ex == "+*****************0;00000");
1529 assert(ios.width() == 0);
1530 }
1531 }
1532 }
1533 }
1534 }
1535 uppercase(ios);
1536 {
1537 noshowpos(ios);
1538 {
1539 noshowpoint(ios);
1540 {
1541 ios.imbue(lc);
1542 {
1543 ios.width(0);
1544 {
1545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1546 std::string ex(str, iter.base());
1547 assert(ex == "0");
1548 assert(ios.width() == 0);
1549 }
1550 ios.width(25);
1551 left(ios);
1552 {
1553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1554 std::string ex(str, iter.base());
1555 assert(ex == "0************************");
1556 assert(ios.width() == 0);
1557 }
1558 ios.width(25);
1559 right(ios);
1560 {
1561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1562 std::string ex(str, iter.base());
1563 assert(ex == "************************0");
1564 assert(ios.width() == 0);
1565 }
1566 ios.width(25);
1567 internal(ios);
1568 {
1569 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1570 std::string ex(str, iter.base());
1571 assert(ex == "************************0");
1572 assert(ios.width() == 0);
1573 }
1574 }
1575 ios.imbue(lg);
1576 {
1577 ios.width(0);
1578 {
1579 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1580 std::string ex(str, iter.base());
1581 assert(ex == "0");
1582 assert(ios.width() == 0);
1583 }
1584 ios.width(25);
1585 left(ios);
1586 {
1587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1588 std::string ex(str, iter.base());
1589 assert(ex == "0************************");
1590 assert(ios.width() == 0);
1591 }
1592 ios.width(25);
1593 right(ios);
1594 {
1595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1596 std::string ex(str, iter.base());
1597 assert(ex == "************************0");
1598 assert(ios.width() == 0);
1599 }
1600 ios.width(25);
1601 internal(ios);
1602 {
1603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1604 std::string ex(str, iter.base());
1605 assert(ex == "************************0");
1606 assert(ios.width() == 0);
1607 }
1608 }
1609 }
1610 showpoint(ios);
1611 {
1612 ios.imbue(lc);
1613 {
1614 ios.width(0);
1615 {
1616 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1617 std::string ex(str, iter.base());
1618 assert(ex == "0.00000");
1619 assert(ios.width() == 0);
1620 }
1621 ios.width(25);
1622 left(ios);
1623 {
1624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1625 std::string ex(str, iter.base());
1626 assert(ex == "0.00000******************");
1627 assert(ios.width() == 0);
1628 }
1629 ios.width(25);
1630 right(ios);
1631 {
1632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1633 std::string ex(str, iter.base());
1634 assert(ex == "******************0.00000");
1635 assert(ios.width() == 0);
1636 }
1637 ios.width(25);
1638 internal(ios);
1639 {
1640 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1641 std::string ex(str, iter.base());
1642 assert(ex == "******************0.00000");
1643 assert(ios.width() == 0);
1644 }
1645 }
1646 ios.imbue(lg);
1647 {
1648 ios.width(0);
1649 {
1650 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1651 std::string ex(str, iter.base());
1652 assert(ex == "0;00000");
1653 assert(ios.width() == 0);
1654 }
1655 ios.width(25);
1656 left(ios);
1657 {
1658 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1659 std::string ex(str, iter.base());
1660 assert(ex == "0;00000******************");
1661 assert(ios.width() == 0);
1662 }
1663 ios.width(25);
1664 right(ios);
1665 {
1666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1667 std::string ex(str, iter.base());
1668 assert(ex == "******************0;00000");
1669 assert(ios.width() == 0);
1670 }
1671 ios.width(25);
1672 internal(ios);
1673 {
1674 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1675 std::string ex(str, iter.base());
1676 assert(ex == "******************0;00000");
1677 assert(ios.width() == 0);
1678 }
1679 }
1680 }
1681 }
1682 showpos(ios);
1683 {
1684 noshowpoint(ios);
1685 {
1686 ios.imbue(lc);
1687 {
1688 ios.width(0);
1689 {
1690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1691 std::string ex(str, iter.base());
1692 assert(ex == "+0");
1693 assert(ios.width() == 0);
1694 }
1695 ios.width(25);
1696 left(ios);
1697 {
1698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1699 std::string ex(str, iter.base());
1700 assert(ex == "+0***********************");
1701 assert(ios.width() == 0);
1702 }
1703 ios.width(25);
1704 right(ios);
1705 {
1706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1707 std::string ex(str, iter.base());
1708 assert(ex == "***********************+0");
1709 assert(ios.width() == 0);
1710 }
1711 ios.width(25);
1712 internal(ios);
1713 {
1714 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1715 std::string ex(str, iter.base());
1716 assert(ex == "+***********************0");
1717 assert(ios.width() == 0);
1718 }
1719 }
1720 ios.imbue(lg);
1721 {
1722 ios.width(0);
1723 {
1724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1725 std::string ex(str, iter.base());
1726 assert(ex == "+0");
1727 assert(ios.width() == 0);
1728 }
1729 ios.width(25);
1730 left(ios);
1731 {
1732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1733 std::string ex(str, iter.base());
1734 assert(ex == "+0***********************");
1735 assert(ios.width() == 0);
1736 }
1737 ios.width(25);
1738 right(ios);
1739 {
1740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1741 std::string ex(str, iter.base());
1742 assert(ex == "***********************+0");
1743 assert(ios.width() == 0);
1744 }
1745 ios.width(25);
1746 internal(ios);
1747 {
1748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1749 std::string ex(str, iter.base());
1750 assert(ex == "+***********************0");
1751 assert(ios.width() == 0);
1752 }
1753 }
1754 }
1755 showpoint(ios);
1756 {
1757 ios.imbue(lc);
1758 {
1759 ios.width(0);
1760 {
1761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1762 std::string ex(str, iter.base());
1763 assert(ex == "+0.00000");
1764 assert(ios.width() == 0);
1765 }
1766 ios.width(25);
1767 left(ios);
1768 {
1769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1770 std::string ex(str, iter.base());
1771 assert(ex == "+0.00000*****************");
1772 assert(ios.width() == 0);
1773 }
1774 ios.width(25);
1775 right(ios);
1776 {
1777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1778 std::string ex(str, iter.base());
1779 assert(ex == "*****************+0.00000");
1780 assert(ios.width() == 0);
1781 }
1782 ios.width(25);
1783 internal(ios);
1784 {
1785 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1786 std::string ex(str, iter.base());
1787 assert(ex == "+*****************0.00000");
1788 assert(ios.width() == 0);
1789 }
1790 }
1791 ios.imbue(lg);
1792 {
1793 ios.width(0);
1794 {
1795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1796 std::string ex(str, iter.base());
1797 assert(ex == "+0;00000");
1798 assert(ios.width() == 0);
1799 }
1800 ios.width(25);
1801 left(ios);
1802 {
1803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1804 std::string ex(str, iter.base());
1805 assert(ex == "+0;00000*****************");
1806 assert(ios.width() == 0);
1807 }
1808 ios.width(25);
1809 right(ios);
1810 {
1811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1812 std::string ex(str, iter.base());
1813 assert(ex == "*****************+0;00000");
1814 assert(ios.width() == 0);
1815 }
1816 ios.width(25);
1817 internal(ios);
1818 {
1819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1820 std::string ex(str, iter.base());
1821 assert(ex == "+*****************0;00000");
1822 assert(ios.width() == 0);
1823 }
1824 }
1825 }
1826 }
1827 }
1828 }
1829 ios.precision(16);
1830 {
1831 nouppercase(ios);
1832 {
1833 noshowpos(ios);
1834 {
1835 noshowpoint(ios);
1836 {
1837 ios.imbue(lc);
1838 {
1839 ios.width(0);
1840 {
1841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1842 std::string ex(str, iter.base());
1843 assert(ex == "0");
1844 assert(ios.width() == 0);
1845 }
1846 ios.width(25);
1847 left(ios);
1848 {
1849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1850 std::string ex(str, iter.base());
1851 assert(ex == "0************************");
1852 assert(ios.width() == 0);
1853 }
1854 ios.width(25);
1855 right(ios);
1856 {
1857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1858 std::string ex(str, iter.base());
1859 assert(ex == "************************0");
1860 assert(ios.width() == 0);
1861 }
1862 ios.width(25);
1863 internal(ios);
1864 {
1865 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1866 std::string ex(str, iter.base());
1867 assert(ex == "************************0");
1868 assert(ios.width() == 0);
1869 }
1870 }
1871 ios.imbue(lg);
1872 {
1873 ios.width(0);
1874 {
1875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1876 std::string ex(str, iter.base());
1877 assert(ex == "0");
1878 assert(ios.width() == 0);
1879 }
1880 ios.width(25);
1881 left(ios);
1882 {
1883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1884 std::string ex(str, iter.base());
1885 assert(ex == "0************************");
1886 assert(ios.width() == 0);
1887 }
1888 ios.width(25);
1889 right(ios);
1890 {
1891 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1892 std::string ex(str, iter.base());
1893 assert(ex == "************************0");
1894 assert(ios.width() == 0);
1895 }
1896 ios.width(25);
1897 internal(ios);
1898 {
1899 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1900 std::string ex(str, iter.base());
1901 assert(ex == "************************0");
1902 assert(ios.width() == 0);
1903 }
1904 }
1905 }
1906 showpoint(ios);
1907 {
1908 ios.imbue(lc);
1909 {
1910 ios.width(0);
1911 {
1912 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1913 std::string ex(str, iter.base());
1914 assert(ex == "0.000000000000000");
1915 assert(ios.width() == 0);
1916 }
1917 ios.width(25);
1918 left(ios);
1919 {
1920 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1921 std::string ex(str, iter.base());
1922 assert(ex == "0.000000000000000********");
1923 assert(ios.width() == 0);
1924 }
1925 ios.width(25);
1926 right(ios);
1927 {
1928 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1929 std::string ex(str, iter.base());
1930 assert(ex == "********0.000000000000000");
1931 assert(ios.width() == 0);
1932 }
1933 ios.width(25);
1934 internal(ios);
1935 {
1936 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1937 std::string ex(str, iter.base());
1938 assert(ex == "********0.000000000000000");
1939 assert(ios.width() == 0);
1940 }
1941 }
1942 ios.imbue(lg);
1943 {
1944 ios.width(0);
1945 {
1946 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1947 std::string ex(str, iter.base());
1948 assert(ex == "0;000000000000000");
1949 assert(ios.width() == 0);
1950 }
1951 ios.width(25);
1952 left(ios);
1953 {
1954 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1955 std::string ex(str, iter.base());
1956 assert(ex == "0;000000000000000********");
1957 assert(ios.width() == 0);
1958 }
1959 ios.width(25);
1960 right(ios);
1961 {
1962 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1963 std::string ex(str, iter.base());
1964 assert(ex == "********0;000000000000000");
1965 assert(ios.width() == 0);
1966 }
1967 ios.width(25);
1968 internal(ios);
1969 {
1970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1971 std::string ex(str, iter.base());
1972 assert(ex == "********0;000000000000000");
1973 assert(ios.width() == 0);
1974 }
1975 }
1976 }
1977 }
1978 showpos(ios);
1979 {
1980 noshowpoint(ios);
1981 {
1982 ios.imbue(lc);
1983 {
1984 ios.width(0);
1985 {
1986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1987 std::string ex(str, iter.base());
1988 assert(ex == "+0");
1989 assert(ios.width() == 0);
1990 }
1991 ios.width(25);
1992 left(ios);
1993 {
1994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1995 std::string ex(str, iter.base());
1996 assert(ex == "+0***********************");
1997 assert(ios.width() == 0);
1998 }
1999 ios.width(25);
2000 right(ios);
2001 {
2002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2003 std::string ex(str, iter.base());
2004 assert(ex == "***********************+0");
2005 assert(ios.width() == 0);
2006 }
2007 ios.width(25);
2008 internal(ios);
2009 {
2010 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2011 std::string ex(str, iter.base());
2012 assert(ex == "+***********************0");
2013 assert(ios.width() == 0);
2014 }
2015 }
2016 ios.imbue(lg);
2017 {
2018 ios.width(0);
2019 {
2020 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2021 std::string ex(str, iter.base());
2022 assert(ex == "+0");
2023 assert(ios.width() == 0);
2024 }
2025 ios.width(25);
2026 left(ios);
2027 {
2028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2029 std::string ex(str, iter.base());
2030 assert(ex == "+0***********************");
2031 assert(ios.width() == 0);
2032 }
2033 ios.width(25);
2034 right(ios);
2035 {
2036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2037 std::string ex(str, iter.base());
2038 assert(ex == "***********************+0");
2039 assert(ios.width() == 0);
2040 }
2041 ios.width(25);
2042 internal(ios);
2043 {
2044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2045 std::string ex(str, iter.base());
2046 assert(ex == "+***********************0");
2047 assert(ios.width() == 0);
2048 }
2049 }
2050 }
2051 showpoint(ios);
2052 {
2053 ios.imbue(lc);
2054 {
2055 ios.width(0);
2056 {
2057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2058 std::string ex(str, iter.base());
2059 assert(ex == "+0.000000000000000");
2060 assert(ios.width() == 0);
2061 }
2062 ios.width(25);
2063 left(ios);
2064 {
2065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2066 std::string ex(str, iter.base());
2067 assert(ex == "+0.000000000000000*******");
2068 assert(ios.width() == 0);
2069 }
2070 ios.width(25);
2071 right(ios);
2072 {
2073 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2074 std::string ex(str, iter.base());
2075 assert(ex == "*******+0.000000000000000");
2076 assert(ios.width() == 0);
2077 }
2078 ios.width(25);
2079 internal(ios);
2080 {
2081 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2082 std::string ex(str, iter.base());
2083 assert(ex == "+*******0.000000000000000");
2084 assert(ios.width() == 0);
2085 }
2086 }
2087 ios.imbue(lg);
2088 {
2089 ios.width(0);
2090 {
2091 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2092 std::string ex(str, iter.base());
2093 assert(ex == "+0;000000000000000");
2094 assert(ios.width() == 0);
2095 }
2096 ios.width(25);
2097 left(ios);
2098 {
2099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2100 std::string ex(str, iter.base());
2101 assert(ex == "+0;000000000000000*******");
2102 assert(ios.width() == 0);
2103 }
2104 ios.width(25);
2105 right(ios);
2106 {
2107 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2108 std::string ex(str, iter.base());
2109 assert(ex == "*******+0;000000000000000");
2110 assert(ios.width() == 0);
2111 }
2112 ios.width(25);
2113 internal(ios);
2114 {
2115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2116 std::string ex(str, iter.base());
2117 assert(ex == "+*******0;000000000000000");
2118 assert(ios.width() == 0);
2119 }
2120 }
2121 }
2122 }
2123 }
2124 uppercase(ios);
2125 {
2126 noshowpos(ios);
2127 {
2128 noshowpoint(ios);
2129 {
2130 ios.imbue(lc);
2131 {
2132 ios.width(0);
2133 {
2134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2135 std::string ex(str, iter.base());
2136 assert(ex == "0");
2137 assert(ios.width() == 0);
2138 }
2139 ios.width(25);
2140 left(ios);
2141 {
2142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2143 std::string ex(str, iter.base());
2144 assert(ex == "0************************");
2145 assert(ios.width() == 0);
2146 }
2147 ios.width(25);
2148 right(ios);
2149 {
2150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2151 std::string ex(str, iter.base());
2152 assert(ex == "************************0");
2153 assert(ios.width() == 0);
2154 }
2155 ios.width(25);
2156 internal(ios);
2157 {
2158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2159 std::string ex(str, iter.base());
2160 assert(ex == "************************0");
2161 assert(ios.width() == 0);
2162 }
2163 }
2164 ios.imbue(lg);
2165 {
2166 ios.width(0);
2167 {
2168 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2169 std::string ex(str, iter.base());
2170 assert(ex == "0");
2171 assert(ios.width() == 0);
2172 }
2173 ios.width(25);
2174 left(ios);
2175 {
2176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2177 std::string ex(str, iter.base());
2178 assert(ex == "0************************");
2179 assert(ios.width() == 0);
2180 }
2181 ios.width(25);
2182 right(ios);
2183 {
2184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2185 std::string ex(str, iter.base());
2186 assert(ex == "************************0");
2187 assert(ios.width() == 0);
2188 }
2189 ios.width(25);
2190 internal(ios);
2191 {
2192 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2193 std::string ex(str, iter.base());
2194 assert(ex == "************************0");
2195 assert(ios.width() == 0);
2196 }
2197 }
2198 }
2199 showpoint(ios);
2200 {
2201 ios.imbue(lc);
2202 {
2203 ios.width(0);
2204 {
2205 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2206 std::string ex(str, iter.base());
2207 assert(ex == "0.000000000000000");
2208 assert(ios.width() == 0);
2209 }
2210 ios.width(25);
2211 left(ios);
2212 {
2213 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2214 std::string ex(str, iter.base());
2215 assert(ex == "0.000000000000000********");
2216 assert(ios.width() == 0);
2217 }
2218 ios.width(25);
2219 right(ios);
2220 {
2221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2222 std::string ex(str, iter.base());
2223 assert(ex == "********0.000000000000000");
2224 assert(ios.width() == 0);
2225 }
2226 ios.width(25);
2227 internal(ios);
2228 {
2229 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2230 std::string ex(str, iter.base());
2231 assert(ex == "********0.000000000000000");
2232 assert(ios.width() == 0);
2233 }
2234 }
2235 ios.imbue(lg);
2236 {
2237 ios.width(0);
2238 {
2239 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2240 std::string ex(str, iter.base());
2241 assert(ex == "0;000000000000000");
2242 assert(ios.width() == 0);
2243 }
2244 ios.width(25);
2245 left(ios);
2246 {
2247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2248 std::string ex(str, iter.base());
2249 assert(ex == "0;000000000000000********");
2250 assert(ios.width() == 0);
2251 }
2252 ios.width(25);
2253 right(ios);
2254 {
2255 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2256 std::string ex(str, iter.base());
2257 assert(ex == "********0;000000000000000");
2258 assert(ios.width() == 0);
2259 }
2260 ios.width(25);
2261 internal(ios);
2262 {
2263 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2264 std::string ex(str, iter.base());
2265 assert(ex == "********0;000000000000000");
2266 assert(ios.width() == 0);
2267 }
2268 }
2269 }
2270 }
2271 showpos(ios);
2272 {
2273 noshowpoint(ios);
2274 {
2275 ios.imbue(lc);
2276 {
2277 ios.width(0);
2278 {
2279 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2280 std::string ex(str, iter.base());
2281 assert(ex == "+0");
2282 assert(ios.width() == 0);
2283 }
2284 ios.width(25);
2285 left(ios);
2286 {
2287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2288 std::string ex(str, iter.base());
2289 assert(ex == "+0***********************");
2290 assert(ios.width() == 0);
2291 }
2292 ios.width(25);
2293 right(ios);
2294 {
2295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2296 std::string ex(str, iter.base());
2297 assert(ex == "***********************+0");
2298 assert(ios.width() == 0);
2299 }
2300 ios.width(25);
2301 internal(ios);
2302 {
2303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2304 std::string ex(str, iter.base());
2305 assert(ex == "+***********************0");
2306 assert(ios.width() == 0);
2307 }
2308 }
2309 ios.imbue(lg);
2310 {
2311 ios.width(0);
2312 {
2313 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2314 std::string ex(str, iter.base());
2315 assert(ex == "+0");
2316 assert(ios.width() == 0);
2317 }
2318 ios.width(25);
2319 left(ios);
2320 {
2321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2322 std::string ex(str, iter.base());
2323 assert(ex == "+0***********************");
2324 assert(ios.width() == 0);
2325 }
2326 ios.width(25);
2327 right(ios);
2328 {
2329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2330 std::string ex(str, iter.base());
2331 assert(ex == "***********************+0");
2332 assert(ios.width() == 0);
2333 }
2334 ios.width(25);
2335 internal(ios);
2336 {
2337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2338 std::string ex(str, iter.base());
2339 assert(ex == "+***********************0");
2340 assert(ios.width() == 0);
2341 }
2342 }
2343 }
2344 showpoint(ios);
2345 {
2346 ios.imbue(lc);
2347 {
2348 ios.width(0);
2349 {
2350 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2351 std::string ex(str, iter.base());
2352 assert(ex == "+0.000000000000000");
2353 assert(ios.width() == 0);
2354 }
2355 ios.width(25);
2356 left(ios);
2357 {
2358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2359 std::string ex(str, iter.base());
2360 assert(ex == "+0.000000000000000*******");
2361 assert(ios.width() == 0);
2362 }
2363 ios.width(25);
2364 right(ios);
2365 {
2366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2367 std::string ex(str, iter.base());
2368 assert(ex == "*******+0.000000000000000");
2369 assert(ios.width() == 0);
2370 }
2371 ios.width(25);
2372 internal(ios);
2373 {
2374 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2375 std::string ex(str, iter.base());
2376 assert(ex == "+*******0.000000000000000");
2377 assert(ios.width() == 0);
2378 }
2379 }
2380 ios.imbue(lg);
2381 {
2382 ios.width(0);
2383 {
2384 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2385 std::string ex(str, iter.base());
2386 assert(ex == "+0;000000000000000");
2387 assert(ios.width() == 0);
2388 }
2389 ios.width(25);
2390 left(ios);
2391 {
2392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2393 std::string ex(str, iter.base());
2394 assert(ex == "+0;000000000000000*******");
2395 assert(ios.width() == 0);
2396 }
2397 ios.width(25);
2398 right(ios);
2399 {
2400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2401 std::string ex(str, iter.base());
2402 assert(ex == "*******+0;000000000000000");
2403 assert(ios.width() == 0);
2404 }
2405 ios.width(25);
2406 internal(ios);
2407 {
2408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2409 std::string ex(str, iter.base());
2410 assert(ex == "+*******0;000000000000000");
2411 assert(ios.width() == 0);
2412 }
2413 }
2414 }
2415 }
2416 }
2417 }
2418 ios.precision(60);
2419 {
2420 nouppercase(ios);
2421 {
2422 noshowpos(ios);
2423 {
2424 noshowpoint(ios);
2425 {
2426 ios.imbue(lc);
2427 {
2428 ios.width(0);
2429 {
2430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2431 std::string ex(str, iter.base());
2432 assert(ex == "0");
2433 assert(ios.width() == 0);
2434 }
2435 ios.width(25);
2436 left(ios);
2437 {
2438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2439 std::string ex(str, iter.base());
2440 assert(ex == "0************************");
2441 assert(ios.width() == 0);
2442 }
2443 ios.width(25);
2444 right(ios);
2445 {
2446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2447 std::string ex(str, iter.base());
2448 assert(ex == "************************0");
2449 assert(ios.width() == 0);
2450 }
2451 ios.width(25);
2452 internal(ios);
2453 {
2454 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2455 std::string ex(str, iter.base());
2456 assert(ex == "************************0");
2457 assert(ios.width() == 0);
2458 }
2459 }
2460 ios.imbue(lg);
2461 {
2462 ios.width(0);
2463 {
2464 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2465 std::string ex(str, iter.base());
2466 assert(ex == "0");
2467 assert(ios.width() == 0);
2468 }
2469 ios.width(25);
2470 left(ios);
2471 {
2472 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2473 std::string ex(str, iter.base());
2474 assert(ex == "0************************");
2475 assert(ios.width() == 0);
2476 }
2477 ios.width(25);
2478 right(ios);
2479 {
2480 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2481 std::string ex(str, iter.base());
2482 assert(ex == "************************0");
2483 assert(ios.width() == 0);
2484 }
2485 ios.width(25);
2486 internal(ios);
2487 {
2488 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2489 std::string ex(str, iter.base());
2490 assert(ex == "************************0");
2491 assert(ios.width() == 0);
2492 }
2493 }
2494 }
2495 showpoint(ios);
2496 {
2497 ios.imbue(lc);
2498 {
2499 ios.width(0);
2500 {
2501 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2502 std::string ex(str, iter.base());
2503 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2504 assert(ios.width() == 0);
2505 }
2506 ios.width(25);
2507 left(ios);
2508 {
2509 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2510 std::string ex(str, iter.base());
2511 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2512 assert(ios.width() == 0);
2513 }
2514 ios.width(25);
2515 right(ios);
2516 {
2517 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2518 std::string ex(str, iter.base());
2519 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2520 assert(ios.width() == 0);
2521 }
2522 ios.width(25);
2523 internal(ios);
2524 {
2525 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2526 std::string ex(str, iter.base());
2527 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2528 assert(ios.width() == 0);
2529 }
2530 }
2531 ios.imbue(lg);
2532 {
2533 ios.width(0);
2534 {
2535 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2536 std::string ex(str, iter.base());
2537 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2538 assert(ios.width() == 0);
2539 }
2540 ios.width(25);
2541 left(ios);
2542 {
2543 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2544 std::string ex(str, iter.base());
2545 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2546 assert(ios.width() == 0);
2547 }
2548 ios.width(25);
2549 right(ios);
2550 {
2551 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2552 std::string ex(str, iter.base());
2553 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2554 assert(ios.width() == 0);
2555 }
2556 ios.width(25);
2557 internal(ios);
2558 {
2559 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2560 std::string ex(str, iter.base());
2561 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2562 assert(ios.width() == 0);
2563 }
2564 }
2565 }
2566 }
2567 showpos(ios);
2568 {
2569 noshowpoint(ios);
2570 {
2571 ios.imbue(lc);
2572 {
2573 ios.width(0);
2574 {
2575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2576 std::string ex(str, iter.base());
2577 assert(ex == "+0");
2578 assert(ios.width() == 0);
2579 }
2580 ios.width(25);
2581 left(ios);
2582 {
2583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2584 std::string ex(str, iter.base());
2585 assert(ex == "+0***********************");
2586 assert(ios.width() == 0);
2587 }
2588 ios.width(25);
2589 right(ios);
2590 {
2591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2592 std::string ex(str, iter.base());
2593 assert(ex == "***********************+0");
2594 assert(ios.width() == 0);
2595 }
2596 ios.width(25);
2597 internal(ios);
2598 {
2599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2600 std::string ex(str, iter.base());
2601 assert(ex == "+***********************0");
2602 assert(ios.width() == 0);
2603 }
2604 }
2605 ios.imbue(lg);
2606 {
2607 ios.width(0);
2608 {
2609 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2610 std::string ex(str, iter.base());
2611 assert(ex == "+0");
2612 assert(ios.width() == 0);
2613 }
2614 ios.width(25);
2615 left(ios);
2616 {
2617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2618 std::string ex(str, iter.base());
2619 assert(ex == "+0***********************");
2620 assert(ios.width() == 0);
2621 }
2622 ios.width(25);
2623 right(ios);
2624 {
2625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2626 std::string ex(str, iter.base());
2627 assert(ex == "***********************+0");
2628 assert(ios.width() == 0);
2629 }
2630 ios.width(25);
2631 internal(ios);
2632 {
2633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2634 std::string ex(str, iter.base());
2635 assert(ex == "+***********************0");
2636 assert(ios.width() == 0);
2637 }
2638 }
2639 }
2640 showpoint(ios);
2641 {
2642 ios.imbue(lc);
2643 {
2644 ios.width(0);
2645 {
2646 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2647 std::string ex(str, iter.base());
2648 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2649 assert(ios.width() == 0);
2650 }
2651 ios.width(25);
2652 left(ios);
2653 {
2654 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2655 std::string ex(str, iter.base());
2656 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2657 assert(ios.width() == 0);
2658 }
2659 ios.width(25);
2660 right(ios);
2661 {
2662 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2663 std::string ex(str, iter.base());
2664 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2665 assert(ios.width() == 0);
2666 }
2667 ios.width(25);
2668 internal(ios);
2669 {
2670 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2671 std::string ex(str, iter.base());
2672 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2673 assert(ios.width() == 0);
2674 }
2675 }
2676 ios.imbue(lg);
2677 {
2678 ios.width(0);
2679 {
2680 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2681 std::string ex(str, iter.base());
2682 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2683 assert(ios.width() == 0);
2684 }
2685 ios.width(25);
2686 left(ios);
2687 {
2688 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2689 std::string ex(str, iter.base());
2690 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2691 assert(ios.width() == 0);
2692 }
2693 ios.width(25);
2694 right(ios);
2695 {
2696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2697 std::string ex(str, iter.base());
2698 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2699 assert(ios.width() == 0);
2700 }
2701 ios.width(25);
2702 internal(ios);
2703 {
2704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2705 std::string ex(str, iter.base());
2706 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2707 assert(ios.width() == 0);
2708 }
2709 }
2710 }
2711 }
2712 }
2713 uppercase(ios);
2714 {
2715 noshowpos(ios);
2716 {
2717 noshowpoint(ios);
2718 {
2719 ios.imbue(lc);
2720 {
2721 ios.width(0);
2722 {
2723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2724 std::string ex(str, iter.base());
2725 assert(ex == "0");
2726 assert(ios.width() == 0);
2727 }
2728 ios.width(25);
2729 left(ios);
2730 {
2731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2732 std::string ex(str, iter.base());
2733 assert(ex == "0************************");
2734 assert(ios.width() == 0);
2735 }
2736 ios.width(25);
2737 right(ios);
2738 {
2739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2740 std::string ex(str, iter.base());
2741 assert(ex == "************************0");
2742 assert(ios.width() == 0);
2743 }
2744 ios.width(25);
2745 internal(ios);
2746 {
2747 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2748 std::string ex(str, iter.base());
2749 assert(ex == "************************0");
2750 assert(ios.width() == 0);
2751 }
2752 }
2753 ios.imbue(lg);
2754 {
2755 ios.width(0);
2756 {
2757 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2758 std::string ex(str, iter.base());
2759 assert(ex == "0");
2760 assert(ios.width() == 0);
2761 }
2762 ios.width(25);
2763 left(ios);
2764 {
2765 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2766 std::string ex(str, iter.base());
2767 assert(ex == "0************************");
2768 assert(ios.width() == 0);
2769 }
2770 ios.width(25);
2771 right(ios);
2772 {
2773 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2774 std::string ex(str, iter.base());
2775 assert(ex == "************************0");
2776 assert(ios.width() == 0);
2777 }
2778 ios.width(25);
2779 internal(ios);
2780 {
2781 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2782 std::string ex(str, iter.base());
2783 assert(ex == "************************0");
2784 assert(ios.width() == 0);
2785 }
2786 }
2787 }
2788 showpoint(ios);
2789 {
2790 ios.imbue(lc);
2791 {
2792 ios.width(0);
2793 {
2794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2795 std::string ex(str, iter.base());
2796 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2797 assert(ios.width() == 0);
2798 }
2799 ios.width(25);
2800 left(ios);
2801 {
2802 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2803 std::string ex(str, iter.base());
2804 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2805 assert(ios.width() == 0);
2806 }
2807 ios.width(25);
2808 right(ios);
2809 {
2810 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2811 std::string ex(str, iter.base());
2812 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2813 assert(ios.width() == 0);
2814 }
2815 ios.width(25);
2816 internal(ios);
2817 {
2818 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2819 std::string ex(str, iter.base());
2820 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2821 assert(ios.width() == 0);
2822 }
2823 }
2824 ios.imbue(lg);
2825 {
2826 ios.width(0);
2827 {
2828 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2829 std::string ex(str, iter.base());
2830 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2831 assert(ios.width() == 0);
2832 }
2833 ios.width(25);
2834 left(ios);
2835 {
2836 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2837 std::string ex(str, iter.base());
2838 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2839 assert(ios.width() == 0);
2840 }
2841 ios.width(25);
2842 right(ios);
2843 {
2844 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2845 std::string ex(str, iter.base());
2846 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2847 assert(ios.width() == 0);
2848 }
2849 ios.width(25);
2850 internal(ios);
2851 {
2852 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2853 std::string ex(str, iter.base());
2854 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2855 assert(ios.width() == 0);
2856 }
2857 }
2858 }
2859 }
2860 showpos(ios);
2861 {
2862 noshowpoint(ios);
2863 {
2864 ios.imbue(lc);
2865 {
2866 ios.width(0);
2867 {
2868 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2869 std::string ex(str, iter.base());
2870 assert(ex == "+0");
2871 assert(ios.width() == 0);
2872 }
2873 ios.width(25);
2874 left(ios);
2875 {
2876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2877 std::string ex(str, iter.base());
2878 assert(ex == "+0***********************");
2879 assert(ios.width() == 0);
2880 }
2881 ios.width(25);
2882 right(ios);
2883 {
2884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2885 std::string ex(str, iter.base());
2886 assert(ex == "***********************+0");
2887 assert(ios.width() == 0);
2888 }
2889 ios.width(25);
2890 internal(ios);
2891 {
2892 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2893 std::string ex(str, iter.base());
2894 assert(ex == "+***********************0");
2895 assert(ios.width() == 0);
2896 }
2897 }
2898 ios.imbue(lg);
2899 {
2900 ios.width(0);
2901 {
2902 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2903 std::string ex(str, iter.base());
2904 assert(ex == "+0");
2905 assert(ios.width() == 0);
2906 }
2907 ios.width(25);
2908 left(ios);
2909 {
2910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2911 std::string ex(str, iter.base());
2912 assert(ex == "+0***********************");
2913 assert(ios.width() == 0);
2914 }
2915 ios.width(25);
2916 right(ios);
2917 {
2918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2919 std::string ex(str, iter.base());
2920 assert(ex == "***********************+0");
2921 assert(ios.width() == 0);
2922 }
2923 ios.width(25);
2924 internal(ios);
2925 {
2926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2927 std::string ex(str, iter.base());
2928 assert(ex == "+***********************0");
2929 assert(ios.width() == 0);
2930 }
2931 }
2932 }
2933 showpoint(ios);
2934 {
2935 ios.imbue(lc);
2936 {
2937 ios.width(0);
2938 {
2939 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2940 std::string ex(str, iter.base());
2941 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2942 assert(ios.width() == 0);
2943 }
2944 ios.width(25);
2945 left(ios);
2946 {
2947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2948 std::string ex(str, iter.base());
2949 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2950 assert(ios.width() == 0);
2951 }
2952 ios.width(25);
2953 right(ios);
2954 {
2955 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2956 std::string ex(str, iter.base());
2957 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2958 assert(ios.width() == 0);
2959 }
2960 ios.width(25);
2961 internal(ios);
2962 {
2963 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2964 std::string ex(str, iter.base());
2965 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2966 assert(ios.width() == 0);
2967 }
2968 }
2969 ios.imbue(lg);
2970 {
2971 ios.width(0);
2972 {
2973 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2974 std::string ex(str, iter.base());
2975 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2976 assert(ios.width() == 0);
2977 }
2978 ios.width(25);
2979 left(ios);
2980 {
2981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2982 std::string ex(str, iter.base());
2983 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2984 assert(ios.width() == 0);
2985 }
2986 ios.width(25);
2987 right(ios);
2988 {
2989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2990 std::string ex(str, iter.base());
2991 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2992 assert(ios.width() == 0);
2993 }
2994 ios.width(25);
2995 internal(ios);
2996 {
2997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2998 std::string ex(str, iter.base());
2999 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
3000 assert(ios.width() == 0);
3001 }
3002 }
3003 }
3004 }
3005 }
3006 }
3007 }
3008 }
3009 }
3010
test2()3011 void test2()
3012 {
3013 char str[200];
3014 output_iterator<char*> iter;
3015 std::locale lc = std::locale::classic();
3016 std::locale lg(lc, new my_numpunct);
3017 const my_facet f(1);
3018 {
3019 long double v = -0.;
3020 std::ios ios(0);
3021 // %g
3022 {
3023 ios.precision(0);
3024 {
3025 nouppercase(ios);
3026 {
3027 noshowpos(ios);
3028 {
3029 noshowpoint(ios);
3030 {
3031 ios.imbue(lc);
3032 {
3033 ios.width(0);
3034 {
3035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3036 std::string ex(str, iter.base());
3037 assert(ex == "-0");
3038 assert(ios.width() == 0);
3039 }
3040 ios.width(25);
3041 left(ios);
3042 {
3043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3044 std::string ex(str, iter.base());
3045 assert(ex == "-0***********************");
3046 assert(ios.width() == 0);
3047 }
3048 ios.width(25);
3049 right(ios);
3050 {
3051 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3052 std::string ex(str, iter.base());
3053 assert(ex == "***********************-0");
3054 assert(ios.width() == 0);
3055 }
3056 ios.width(25);
3057 internal(ios);
3058 {
3059 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3060 std::string ex(str, iter.base());
3061 assert(ex == "-***********************0");
3062 assert(ios.width() == 0);
3063 }
3064 }
3065 ios.imbue(lg);
3066 {
3067 ios.width(0);
3068 {
3069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3070 std::string ex(str, iter.base());
3071 assert(ex == "-0");
3072 assert(ios.width() == 0);
3073 }
3074 ios.width(25);
3075 left(ios);
3076 {
3077 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3078 std::string ex(str, iter.base());
3079 assert(ex == "-0***********************");
3080 assert(ios.width() == 0);
3081 }
3082 ios.width(25);
3083 right(ios);
3084 {
3085 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3086 std::string ex(str, iter.base());
3087 assert(ex == "***********************-0");
3088 assert(ios.width() == 0);
3089 }
3090 ios.width(25);
3091 internal(ios);
3092 {
3093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3094 std::string ex(str, iter.base());
3095 assert(ex == "-***********************0");
3096 assert(ios.width() == 0);
3097 }
3098 }
3099 }
3100 showpoint(ios);
3101 {
3102 ios.imbue(lc);
3103 {
3104 ios.width(0);
3105 {
3106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3107 std::string ex(str, iter.base());
3108 assert(ex == "-0.");
3109 assert(ios.width() == 0);
3110 }
3111 ios.width(25);
3112 left(ios);
3113 {
3114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3115 std::string ex(str, iter.base());
3116 assert(ex == "-0.**********************");
3117 assert(ios.width() == 0);
3118 }
3119 ios.width(25);
3120 right(ios);
3121 {
3122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3123 std::string ex(str, iter.base());
3124 assert(ex == "**********************-0.");
3125 assert(ios.width() == 0);
3126 }
3127 ios.width(25);
3128 internal(ios);
3129 {
3130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3131 std::string ex(str, iter.base());
3132 assert(ex == "-**********************0.");
3133 assert(ios.width() == 0);
3134 }
3135 }
3136 ios.imbue(lg);
3137 {
3138 ios.width(0);
3139 {
3140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3141 std::string ex(str, iter.base());
3142 assert(ex == "-0;");
3143 assert(ios.width() == 0);
3144 }
3145 ios.width(25);
3146 left(ios);
3147 {
3148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3149 std::string ex(str, iter.base());
3150 assert(ex == "-0;**********************");
3151 assert(ios.width() == 0);
3152 }
3153 ios.width(25);
3154 right(ios);
3155 {
3156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3157 std::string ex(str, iter.base());
3158 assert(ex == "**********************-0;");
3159 assert(ios.width() == 0);
3160 }
3161 ios.width(25);
3162 internal(ios);
3163 {
3164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3165 std::string ex(str, iter.base());
3166 assert(ex == "-**********************0;");
3167 assert(ios.width() == 0);
3168 }
3169 }
3170 }
3171 }
3172 showpos(ios);
3173 {
3174 noshowpoint(ios);
3175 {
3176 ios.imbue(lc);
3177 {
3178 ios.width(0);
3179 {
3180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3181 std::string ex(str, iter.base());
3182 assert(ex == "-0");
3183 assert(ios.width() == 0);
3184 }
3185 ios.width(25);
3186 left(ios);
3187 {
3188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3189 std::string ex(str, iter.base());
3190 assert(ex == "-0***********************");
3191 assert(ios.width() == 0);
3192 }
3193 ios.width(25);
3194 right(ios);
3195 {
3196 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3197 std::string ex(str, iter.base());
3198 assert(ex == "***********************-0");
3199 assert(ios.width() == 0);
3200 }
3201 ios.width(25);
3202 internal(ios);
3203 {
3204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3205 std::string ex(str, iter.base());
3206 assert(ex == "-***********************0");
3207 assert(ios.width() == 0);
3208 }
3209 }
3210 ios.imbue(lg);
3211 {
3212 ios.width(0);
3213 {
3214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3215 std::string ex(str, iter.base());
3216 assert(ex == "-0");
3217 assert(ios.width() == 0);
3218 }
3219 ios.width(25);
3220 left(ios);
3221 {
3222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3223 std::string ex(str, iter.base());
3224 assert(ex == "-0***********************");
3225 assert(ios.width() == 0);
3226 }
3227 ios.width(25);
3228 right(ios);
3229 {
3230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3231 std::string ex(str, iter.base());
3232 assert(ex == "***********************-0");
3233 assert(ios.width() == 0);
3234 }
3235 ios.width(25);
3236 internal(ios);
3237 {
3238 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3239 std::string ex(str, iter.base());
3240 assert(ex == "-***********************0");
3241 assert(ios.width() == 0);
3242 }
3243 }
3244 }
3245 showpoint(ios);
3246 {
3247 ios.imbue(lc);
3248 {
3249 ios.width(0);
3250 {
3251 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3252 std::string ex(str, iter.base());
3253 assert(ex == "-0.");
3254 assert(ios.width() == 0);
3255 }
3256 ios.width(25);
3257 left(ios);
3258 {
3259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3260 std::string ex(str, iter.base());
3261 assert(ex == "-0.**********************");
3262 assert(ios.width() == 0);
3263 }
3264 ios.width(25);
3265 right(ios);
3266 {
3267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3268 std::string ex(str, iter.base());
3269 assert(ex == "**********************-0.");
3270 assert(ios.width() == 0);
3271 }
3272 ios.width(25);
3273 internal(ios);
3274 {
3275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3276 std::string ex(str, iter.base());
3277 assert(ex == "-**********************0.");
3278 assert(ios.width() == 0);
3279 }
3280 }
3281 ios.imbue(lg);
3282 {
3283 ios.width(0);
3284 {
3285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3286 std::string ex(str, iter.base());
3287 assert(ex == "-0;");
3288 assert(ios.width() == 0);
3289 }
3290 ios.width(25);
3291 left(ios);
3292 {
3293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3294 std::string ex(str, iter.base());
3295 assert(ex == "-0;**********************");
3296 assert(ios.width() == 0);
3297 }
3298 ios.width(25);
3299 right(ios);
3300 {
3301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3302 std::string ex(str, iter.base());
3303 assert(ex == "**********************-0;");
3304 assert(ios.width() == 0);
3305 }
3306 ios.width(25);
3307 internal(ios);
3308 {
3309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3310 std::string ex(str, iter.base());
3311 assert(ex == "-**********************0;");
3312 assert(ios.width() == 0);
3313 }
3314 }
3315 }
3316 }
3317 }
3318 uppercase(ios);
3319 {
3320 noshowpos(ios);
3321 {
3322 noshowpoint(ios);
3323 {
3324 ios.imbue(lc);
3325 {
3326 ios.width(0);
3327 {
3328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3329 std::string ex(str, iter.base());
3330 assert(ex == "-0");
3331 assert(ios.width() == 0);
3332 }
3333 ios.width(25);
3334 left(ios);
3335 {
3336 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3337 std::string ex(str, iter.base());
3338 assert(ex == "-0***********************");
3339 assert(ios.width() == 0);
3340 }
3341 ios.width(25);
3342 right(ios);
3343 {
3344 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3345 std::string ex(str, iter.base());
3346 assert(ex == "***********************-0");
3347 assert(ios.width() == 0);
3348 }
3349 ios.width(25);
3350 internal(ios);
3351 {
3352 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3353 std::string ex(str, iter.base());
3354 assert(ex == "-***********************0");
3355 assert(ios.width() == 0);
3356 }
3357 }
3358 ios.imbue(lg);
3359 {
3360 ios.width(0);
3361 {
3362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3363 std::string ex(str, iter.base());
3364 assert(ex == "-0");
3365 assert(ios.width() == 0);
3366 }
3367 ios.width(25);
3368 left(ios);
3369 {
3370 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3371 std::string ex(str, iter.base());
3372 assert(ex == "-0***********************");
3373 assert(ios.width() == 0);
3374 }
3375 ios.width(25);
3376 right(ios);
3377 {
3378 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3379 std::string ex(str, iter.base());
3380 assert(ex == "***********************-0");
3381 assert(ios.width() == 0);
3382 }
3383 ios.width(25);
3384 internal(ios);
3385 {
3386 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3387 std::string ex(str, iter.base());
3388 assert(ex == "-***********************0");
3389 assert(ios.width() == 0);
3390 }
3391 }
3392 }
3393 showpoint(ios);
3394 {
3395 ios.imbue(lc);
3396 {
3397 ios.width(0);
3398 {
3399 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3400 std::string ex(str, iter.base());
3401 assert(ex == "-0.");
3402 assert(ios.width() == 0);
3403 }
3404 ios.width(25);
3405 left(ios);
3406 {
3407 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3408 std::string ex(str, iter.base());
3409 assert(ex == "-0.**********************");
3410 assert(ios.width() == 0);
3411 }
3412 ios.width(25);
3413 right(ios);
3414 {
3415 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3416 std::string ex(str, iter.base());
3417 assert(ex == "**********************-0.");
3418 assert(ios.width() == 0);
3419 }
3420 ios.width(25);
3421 internal(ios);
3422 {
3423 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3424 std::string ex(str, iter.base());
3425 assert(ex == "-**********************0.");
3426 assert(ios.width() == 0);
3427 }
3428 }
3429 ios.imbue(lg);
3430 {
3431 ios.width(0);
3432 {
3433 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3434 std::string ex(str, iter.base());
3435 assert(ex == "-0;");
3436 assert(ios.width() == 0);
3437 }
3438 ios.width(25);
3439 left(ios);
3440 {
3441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3442 std::string ex(str, iter.base());
3443 assert(ex == "-0;**********************");
3444 assert(ios.width() == 0);
3445 }
3446 ios.width(25);
3447 right(ios);
3448 {
3449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3450 std::string ex(str, iter.base());
3451 assert(ex == "**********************-0;");
3452 assert(ios.width() == 0);
3453 }
3454 ios.width(25);
3455 internal(ios);
3456 {
3457 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3458 std::string ex(str, iter.base());
3459 assert(ex == "-**********************0;");
3460 assert(ios.width() == 0);
3461 }
3462 }
3463 }
3464 }
3465 showpos(ios);
3466 {
3467 noshowpoint(ios);
3468 {
3469 ios.imbue(lc);
3470 {
3471 ios.width(0);
3472 {
3473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3474 std::string ex(str, iter.base());
3475 assert(ex == "-0");
3476 assert(ios.width() == 0);
3477 }
3478 ios.width(25);
3479 left(ios);
3480 {
3481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3482 std::string ex(str, iter.base());
3483 assert(ex == "-0***********************");
3484 assert(ios.width() == 0);
3485 }
3486 ios.width(25);
3487 right(ios);
3488 {
3489 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3490 std::string ex(str, iter.base());
3491 assert(ex == "***********************-0");
3492 assert(ios.width() == 0);
3493 }
3494 ios.width(25);
3495 internal(ios);
3496 {
3497 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3498 std::string ex(str, iter.base());
3499 assert(ex == "-***********************0");
3500 assert(ios.width() == 0);
3501 }
3502 }
3503 ios.imbue(lg);
3504 {
3505 ios.width(0);
3506 {
3507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3508 std::string ex(str, iter.base());
3509 assert(ex == "-0");
3510 assert(ios.width() == 0);
3511 }
3512 ios.width(25);
3513 left(ios);
3514 {
3515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3516 std::string ex(str, iter.base());
3517 assert(ex == "-0***********************");
3518 assert(ios.width() == 0);
3519 }
3520 ios.width(25);
3521 right(ios);
3522 {
3523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3524 std::string ex(str, iter.base());
3525 assert(ex == "***********************-0");
3526 assert(ios.width() == 0);
3527 }
3528 ios.width(25);
3529 internal(ios);
3530 {
3531 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3532 std::string ex(str, iter.base());
3533 assert(ex == "-***********************0");
3534 assert(ios.width() == 0);
3535 }
3536 }
3537 }
3538 showpoint(ios);
3539 {
3540 ios.imbue(lc);
3541 {
3542 ios.width(0);
3543 {
3544 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3545 std::string ex(str, iter.base());
3546 assert(ex == "-0.");
3547 assert(ios.width() == 0);
3548 }
3549 ios.width(25);
3550 left(ios);
3551 {
3552 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3553 std::string ex(str, iter.base());
3554 assert(ex == "-0.**********************");
3555 assert(ios.width() == 0);
3556 }
3557 ios.width(25);
3558 right(ios);
3559 {
3560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3561 std::string ex(str, iter.base());
3562 assert(ex == "**********************-0.");
3563 assert(ios.width() == 0);
3564 }
3565 ios.width(25);
3566 internal(ios);
3567 {
3568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3569 std::string ex(str, iter.base());
3570 assert(ex == "-**********************0.");
3571 assert(ios.width() == 0);
3572 }
3573 }
3574 ios.imbue(lg);
3575 {
3576 ios.width(0);
3577 {
3578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3579 std::string ex(str, iter.base());
3580 assert(ex == "-0;");
3581 assert(ios.width() == 0);
3582 }
3583 ios.width(25);
3584 left(ios);
3585 {
3586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3587 std::string ex(str, iter.base());
3588 assert(ex == "-0;**********************");
3589 assert(ios.width() == 0);
3590 }
3591 ios.width(25);
3592 right(ios);
3593 {
3594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3595 std::string ex(str, iter.base());
3596 assert(ex == "**********************-0;");
3597 assert(ios.width() == 0);
3598 }
3599 ios.width(25);
3600 internal(ios);
3601 {
3602 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3603 std::string ex(str, iter.base());
3604 assert(ex == "-**********************0;");
3605 assert(ios.width() == 0);
3606 }
3607 }
3608 }
3609 }
3610 }
3611 }
3612 ios.precision(1);
3613 {
3614 nouppercase(ios);
3615 {
3616 noshowpos(ios);
3617 {
3618 noshowpoint(ios);
3619 {
3620 ios.imbue(lc);
3621 {
3622 ios.width(0);
3623 {
3624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3625 std::string ex(str, iter.base());
3626 assert(ex == "-0");
3627 assert(ios.width() == 0);
3628 }
3629 ios.width(25);
3630 left(ios);
3631 {
3632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3633 std::string ex(str, iter.base());
3634 assert(ex == "-0***********************");
3635 assert(ios.width() == 0);
3636 }
3637 ios.width(25);
3638 right(ios);
3639 {
3640 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3641 std::string ex(str, iter.base());
3642 assert(ex == "***********************-0");
3643 assert(ios.width() == 0);
3644 }
3645 ios.width(25);
3646 internal(ios);
3647 {
3648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3649 std::string ex(str, iter.base());
3650 assert(ex == "-***********************0");
3651 assert(ios.width() == 0);
3652 }
3653 }
3654 ios.imbue(lg);
3655 {
3656 ios.width(0);
3657 {
3658 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3659 std::string ex(str, iter.base());
3660 assert(ex == "-0");
3661 assert(ios.width() == 0);
3662 }
3663 ios.width(25);
3664 left(ios);
3665 {
3666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3667 std::string ex(str, iter.base());
3668 assert(ex == "-0***********************");
3669 assert(ios.width() == 0);
3670 }
3671 ios.width(25);
3672 right(ios);
3673 {
3674 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3675 std::string ex(str, iter.base());
3676 assert(ex == "***********************-0");
3677 assert(ios.width() == 0);
3678 }
3679 ios.width(25);
3680 internal(ios);
3681 {
3682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3683 std::string ex(str, iter.base());
3684 assert(ex == "-***********************0");
3685 assert(ios.width() == 0);
3686 }
3687 }
3688 }
3689 showpoint(ios);
3690 {
3691 ios.imbue(lc);
3692 {
3693 ios.width(0);
3694 {
3695 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3696 std::string ex(str, iter.base());
3697 assert(ex == "-0.");
3698 assert(ios.width() == 0);
3699 }
3700 ios.width(25);
3701 left(ios);
3702 {
3703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3704 std::string ex(str, iter.base());
3705 assert(ex == "-0.**********************");
3706 assert(ios.width() == 0);
3707 }
3708 ios.width(25);
3709 right(ios);
3710 {
3711 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3712 std::string ex(str, iter.base());
3713 assert(ex == "**********************-0.");
3714 assert(ios.width() == 0);
3715 }
3716 ios.width(25);
3717 internal(ios);
3718 {
3719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3720 std::string ex(str, iter.base());
3721 assert(ex == "-**********************0.");
3722 assert(ios.width() == 0);
3723 }
3724 }
3725 ios.imbue(lg);
3726 {
3727 ios.width(0);
3728 {
3729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3730 std::string ex(str, iter.base());
3731 assert(ex == "-0;");
3732 assert(ios.width() == 0);
3733 }
3734 ios.width(25);
3735 left(ios);
3736 {
3737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3738 std::string ex(str, iter.base());
3739 assert(ex == "-0;**********************");
3740 assert(ios.width() == 0);
3741 }
3742 ios.width(25);
3743 right(ios);
3744 {
3745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3746 std::string ex(str, iter.base());
3747 assert(ex == "**********************-0;");
3748 assert(ios.width() == 0);
3749 }
3750 ios.width(25);
3751 internal(ios);
3752 {
3753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3754 std::string ex(str, iter.base());
3755 assert(ex == "-**********************0;");
3756 assert(ios.width() == 0);
3757 }
3758 }
3759 }
3760 }
3761 showpos(ios);
3762 {
3763 noshowpoint(ios);
3764 {
3765 ios.imbue(lc);
3766 {
3767 ios.width(0);
3768 {
3769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3770 std::string ex(str, iter.base());
3771 assert(ex == "-0");
3772 assert(ios.width() == 0);
3773 }
3774 ios.width(25);
3775 left(ios);
3776 {
3777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3778 std::string ex(str, iter.base());
3779 assert(ex == "-0***********************");
3780 assert(ios.width() == 0);
3781 }
3782 ios.width(25);
3783 right(ios);
3784 {
3785 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3786 std::string ex(str, iter.base());
3787 assert(ex == "***********************-0");
3788 assert(ios.width() == 0);
3789 }
3790 ios.width(25);
3791 internal(ios);
3792 {
3793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3794 std::string ex(str, iter.base());
3795 assert(ex == "-***********************0");
3796 assert(ios.width() == 0);
3797 }
3798 }
3799 ios.imbue(lg);
3800 {
3801 ios.width(0);
3802 {
3803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3804 std::string ex(str, iter.base());
3805 assert(ex == "-0");
3806 assert(ios.width() == 0);
3807 }
3808 ios.width(25);
3809 left(ios);
3810 {
3811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3812 std::string ex(str, iter.base());
3813 assert(ex == "-0***********************");
3814 assert(ios.width() == 0);
3815 }
3816 ios.width(25);
3817 right(ios);
3818 {
3819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3820 std::string ex(str, iter.base());
3821 assert(ex == "***********************-0");
3822 assert(ios.width() == 0);
3823 }
3824 ios.width(25);
3825 internal(ios);
3826 {
3827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3828 std::string ex(str, iter.base());
3829 assert(ex == "-***********************0");
3830 assert(ios.width() == 0);
3831 }
3832 }
3833 }
3834 showpoint(ios);
3835 {
3836 ios.imbue(lc);
3837 {
3838 ios.width(0);
3839 {
3840 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3841 std::string ex(str, iter.base());
3842 assert(ex == "-0.");
3843 assert(ios.width() == 0);
3844 }
3845 ios.width(25);
3846 left(ios);
3847 {
3848 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3849 std::string ex(str, iter.base());
3850 assert(ex == "-0.**********************");
3851 assert(ios.width() == 0);
3852 }
3853 ios.width(25);
3854 right(ios);
3855 {
3856 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3857 std::string ex(str, iter.base());
3858 assert(ex == "**********************-0.");
3859 assert(ios.width() == 0);
3860 }
3861 ios.width(25);
3862 internal(ios);
3863 {
3864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3865 std::string ex(str, iter.base());
3866 assert(ex == "-**********************0.");
3867 assert(ios.width() == 0);
3868 }
3869 }
3870 ios.imbue(lg);
3871 {
3872 ios.width(0);
3873 {
3874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3875 std::string ex(str, iter.base());
3876 assert(ex == "-0;");
3877 assert(ios.width() == 0);
3878 }
3879 ios.width(25);
3880 left(ios);
3881 {
3882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3883 std::string ex(str, iter.base());
3884 assert(ex == "-0;**********************");
3885 assert(ios.width() == 0);
3886 }
3887 ios.width(25);
3888 right(ios);
3889 {
3890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3891 std::string ex(str, iter.base());
3892 assert(ex == "**********************-0;");
3893 assert(ios.width() == 0);
3894 }
3895 ios.width(25);
3896 internal(ios);
3897 {
3898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3899 std::string ex(str, iter.base());
3900 assert(ex == "-**********************0;");
3901 assert(ios.width() == 0);
3902 }
3903 }
3904 }
3905 }
3906 }
3907 uppercase(ios);
3908 {
3909 noshowpos(ios);
3910 {
3911 noshowpoint(ios);
3912 {
3913 ios.imbue(lc);
3914 {
3915 ios.width(0);
3916 {
3917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3918 std::string ex(str, iter.base());
3919 assert(ex == "-0");
3920 assert(ios.width() == 0);
3921 }
3922 ios.width(25);
3923 left(ios);
3924 {
3925 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3926 std::string ex(str, iter.base());
3927 assert(ex == "-0***********************");
3928 assert(ios.width() == 0);
3929 }
3930 ios.width(25);
3931 right(ios);
3932 {
3933 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3934 std::string ex(str, iter.base());
3935 assert(ex == "***********************-0");
3936 assert(ios.width() == 0);
3937 }
3938 ios.width(25);
3939 internal(ios);
3940 {
3941 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3942 std::string ex(str, iter.base());
3943 assert(ex == "-***********************0");
3944 assert(ios.width() == 0);
3945 }
3946 }
3947 ios.imbue(lg);
3948 {
3949 ios.width(0);
3950 {
3951 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3952 std::string ex(str, iter.base());
3953 assert(ex == "-0");
3954 assert(ios.width() == 0);
3955 }
3956 ios.width(25);
3957 left(ios);
3958 {
3959 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3960 std::string ex(str, iter.base());
3961 assert(ex == "-0***********************");
3962 assert(ios.width() == 0);
3963 }
3964 ios.width(25);
3965 right(ios);
3966 {
3967 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3968 std::string ex(str, iter.base());
3969 assert(ex == "***********************-0");
3970 assert(ios.width() == 0);
3971 }
3972 ios.width(25);
3973 internal(ios);
3974 {
3975 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3976 std::string ex(str, iter.base());
3977 assert(ex == "-***********************0");
3978 assert(ios.width() == 0);
3979 }
3980 }
3981 }
3982 showpoint(ios);
3983 {
3984 ios.imbue(lc);
3985 {
3986 ios.width(0);
3987 {
3988 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3989 std::string ex(str, iter.base());
3990 assert(ex == "-0.");
3991 assert(ios.width() == 0);
3992 }
3993 ios.width(25);
3994 left(ios);
3995 {
3996 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3997 std::string ex(str, iter.base());
3998 assert(ex == "-0.**********************");
3999 assert(ios.width() == 0);
4000 }
4001 ios.width(25);
4002 right(ios);
4003 {
4004 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4005 std::string ex(str, iter.base());
4006 assert(ex == "**********************-0.");
4007 assert(ios.width() == 0);
4008 }
4009 ios.width(25);
4010 internal(ios);
4011 {
4012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4013 std::string ex(str, iter.base());
4014 assert(ex == "-**********************0.");
4015 assert(ios.width() == 0);
4016 }
4017 }
4018 ios.imbue(lg);
4019 {
4020 ios.width(0);
4021 {
4022 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4023 std::string ex(str, iter.base());
4024 assert(ex == "-0;");
4025 assert(ios.width() == 0);
4026 }
4027 ios.width(25);
4028 left(ios);
4029 {
4030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4031 std::string ex(str, iter.base());
4032 assert(ex == "-0;**********************");
4033 assert(ios.width() == 0);
4034 }
4035 ios.width(25);
4036 right(ios);
4037 {
4038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4039 std::string ex(str, iter.base());
4040 assert(ex == "**********************-0;");
4041 assert(ios.width() == 0);
4042 }
4043 ios.width(25);
4044 internal(ios);
4045 {
4046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4047 std::string ex(str, iter.base());
4048 assert(ex == "-**********************0;");
4049 assert(ios.width() == 0);
4050 }
4051 }
4052 }
4053 }
4054 showpos(ios);
4055 {
4056 noshowpoint(ios);
4057 {
4058 ios.imbue(lc);
4059 {
4060 ios.width(0);
4061 {
4062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4063 std::string ex(str, iter.base());
4064 assert(ex == "-0");
4065 assert(ios.width() == 0);
4066 }
4067 ios.width(25);
4068 left(ios);
4069 {
4070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4071 std::string ex(str, iter.base());
4072 assert(ex == "-0***********************");
4073 assert(ios.width() == 0);
4074 }
4075 ios.width(25);
4076 right(ios);
4077 {
4078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4079 std::string ex(str, iter.base());
4080 assert(ex == "***********************-0");
4081 assert(ios.width() == 0);
4082 }
4083 ios.width(25);
4084 internal(ios);
4085 {
4086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4087 std::string ex(str, iter.base());
4088 assert(ex == "-***********************0");
4089 assert(ios.width() == 0);
4090 }
4091 }
4092 ios.imbue(lg);
4093 {
4094 ios.width(0);
4095 {
4096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4097 std::string ex(str, iter.base());
4098 assert(ex == "-0");
4099 assert(ios.width() == 0);
4100 }
4101 ios.width(25);
4102 left(ios);
4103 {
4104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4105 std::string ex(str, iter.base());
4106 assert(ex == "-0***********************");
4107 assert(ios.width() == 0);
4108 }
4109 ios.width(25);
4110 right(ios);
4111 {
4112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4113 std::string ex(str, iter.base());
4114 assert(ex == "***********************-0");
4115 assert(ios.width() == 0);
4116 }
4117 ios.width(25);
4118 internal(ios);
4119 {
4120 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4121 std::string ex(str, iter.base());
4122 assert(ex == "-***********************0");
4123 assert(ios.width() == 0);
4124 }
4125 }
4126 }
4127 showpoint(ios);
4128 {
4129 ios.imbue(lc);
4130 {
4131 ios.width(0);
4132 {
4133 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4134 std::string ex(str, iter.base());
4135 assert(ex == "-0.");
4136 assert(ios.width() == 0);
4137 }
4138 ios.width(25);
4139 left(ios);
4140 {
4141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4142 std::string ex(str, iter.base());
4143 assert(ex == "-0.**********************");
4144 assert(ios.width() == 0);
4145 }
4146 ios.width(25);
4147 right(ios);
4148 {
4149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4150 std::string ex(str, iter.base());
4151 assert(ex == "**********************-0.");
4152 assert(ios.width() == 0);
4153 }
4154 ios.width(25);
4155 internal(ios);
4156 {
4157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4158 std::string ex(str, iter.base());
4159 assert(ex == "-**********************0.");
4160 assert(ios.width() == 0);
4161 }
4162 }
4163 ios.imbue(lg);
4164 {
4165 ios.width(0);
4166 {
4167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4168 std::string ex(str, iter.base());
4169 assert(ex == "-0;");
4170 assert(ios.width() == 0);
4171 }
4172 ios.width(25);
4173 left(ios);
4174 {
4175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4176 std::string ex(str, iter.base());
4177 assert(ex == "-0;**********************");
4178 assert(ios.width() == 0);
4179 }
4180 ios.width(25);
4181 right(ios);
4182 {
4183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4184 std::string ex(str, iter.base());
4185 assert(ex == "**********************-0;");
4186 assert(ios.width() == 0);
4187 }
4188 ios.width(25);
4189 internal(ios);
4190 {
4191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4192 std::string ex(str, iter.base());
4193 assert(ex == "-**********************0;");
4194 assert(ios.width() == 0);
4195 }
4196 }
4197 }
4198 }
4199 }
4200 }
4201 ios.precision(6);
4202 {
4203 nouppercase(ios);
4204 {
4205 noshowpos(ios);
4206 {
4207 noshowpoint(ios);
4208 {
4209 ios.imbue(lc);
4210 {
4211 ios.width(0);
4212 {
4213 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4214 std::string ex(str, iter.base());
4215 assert(ex == "-0");
4216 assert(ios.width() == 0);
4217 }
4218 ios.width(25);
4219 left(ios);
4220 {
4221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4222 std::string ex(str, iter.base());
4223 assert(ex == "-0***********************");
4224 assert(ios.width() == 0);
4225 }
4226 ios.width(25);
4227 right(ios);
4228 {
4229 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4230 std::string ex(str, iter.base());
4231 assert(ex == "***********************-0");
4232 assert(ios.width() == 0);
4233 }
4234 ios.width(25);
4235 internal(ios);
4236 {
4237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4238 std::string ex(str, iter.base());
4239 assert(ex == "-***********************0");
4240 assert(ios.width() == 0);
4241 }
4242 }
4243 ios.imbue(lg);
4244 {
4245 ios.width(0);
4246 {
4247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4248 std::string ex(str, iter.base());
4249 assert(ex == "-0");
4250 assert(ios.width() == 0);
4251 }
4252 ios.width(25);
4253 left(ios);
4254 {
4255 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4256 std::string ex(str, iter.base());
4257 assert(ex == "-0***********************");
4258 assert(ios.width() == 0);
4259 }
4260 ios.width(25);
4261 right(ios);
4262 {
4263 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4264 std::string ex(str, iter.base());
4265 assert(ex == "***********************-0");
4266 assert(ios.width() == 0);
4267 }
4268 ios.width(25);
4269 internal(ios);
4270 {
4271 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4272 std::string ex(str, iter.base());
4273 assert(ex == "-***********************0");
4274 assert(ios.width() == 0);
4275 }
4276 }
4277 }
4278 showpoint(ios);
4279 {
4280 ios.imbue(lc);
4281 {
4282 ios.width(0);
4283 {
4284 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4285 std::string ex(str, iter.base());
4286 assert(ex == "-0.00000");
4287 assert(ios.width() == 0);
4288 }
4289 ios.width(25);
4290 left(ios);
4291 {
4292 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4293 std::string ex(str, iter.base());
4294 assert(ex == "-0.00000*****************");
4295 assert(ios.width() == 0);
4296 }
4297 ios.width(25);
4298 right(ios);
4299 {
4300 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4301 std::string ex(str, iter.base());
4302 assert(ex == "*****************-0.00000");
4303 assert(ios.width() == 0);
4304 }
4305 ios.width(25);
4306 internal(ios);
4307 {
4308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4309 std::string ex(str, iter.base());
4310 assert(ex == "-*****************0.00000");
4311 assert(ios.width() == 0);
4312 }
4313 }
4314 ios.imbue(lg);
4315 {
4316 ios.width(0);
4317 {
4318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4319 std::string ex(str, iter.base());
4320 assert(ex == "-0;00000");
4321 assert(ios.width() == 0);
4322 }
4323 ios.width(25);
4324 left(ios);
4325 {
4326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4327 std::string ex(str, iter.base());
4328 assert(ex == "-0;00000*****************");
4329 assert(ios.width() == 0);
4330 }
4331 ios.width(25);
4332 right(ios);
4333 {
4334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4335 std::string ex(str, iter.base());
4336 assert(ex == "*****************-0;00000");
4337 assert(ios.width() == 0);
4338 }
4339 ios.width(25);
4340 internal(ios);
4341 {
4342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4343 std::string ex(str, iter.base());
4344 assert(ex == "-*****************0;00000");
4345 assert(ios.width() == 0);
4346 }
4347 }
4348 }
4349 }
4350 showpos(ios);
4351 {
4352 noshowpoint(ios);
4353 {
4354 ios.imbue(lc);
4355 {
4356 ios.width(0);
4357 {
4358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4359 std::string ex(str, iter.base());
4360 assert(ex == "-0");
4361 assert(ios.width() == 0);
4362 }
4363 ios.width(25);
4364 left(ios);
4365 {
4366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4367 std::string ex(str, iter.base());
4368 assert(ex == "-0***********************");
4369 assert(ios.width() == 0);
4370 }
4371 ios.width(25);
4372 right(ios);
4373 {
4374 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4375 std::string ex(str, iter.base());
4376 assert(ex == "***********************-0");
4377 assert(ios.width() == 0);
4378 }
4379 ios.width(25);
4380 internal(ios);
4381 {
4382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4383 std::string ex(str, iter.base());
4384 assert(ex == "-***********************0");
4385 assert(ios.width() == 0);
4386 }
4387 }
4388 ios.imbue(lg);
4389 {
4390 ios.width(0);
4391 {
4392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4393 std::string ex(str, iter.base());
4394 assert(ex == "-0");
4395 assert(ios.width() == 0);
4396 }
4397 ios.width(25);
4398 left(ios);
4399 {
4400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4401 std::string ex(str, iter.base());
4402 assert(ex == "-0***********************");
4403 assert(ios.width() == 0);
4404 }
4405 ios.width(25);
4406 right(ios);
4407 {
4408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4409 std::string ex(str, iter.base());
4410 assert(ex == "***********************-0");
4411 assert(ios.width() == 0);
4412 }
4413 ios.width(25);
4414 internal(ios);
4415 {
4416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4417 std::string ex(str, iter.base());
4418 assert(ex == "-***********************0");
4419 assert(ios.width() == 0);
4420 }
4421 }
4422 }
4423 showpoint(ios);
4424 {
4425 ios.imbue(lc);
4426 {
4427 ios.width(0);
4428 {
4429 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4430 std::string ex(str, iter.base());
4431 assert(ex == "-0.00000");
4432 assert(ios.width() == 0);
4433 }
4434 ios.width(25);
4435 left(ios);
4436 {
4437 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4438 std::string ex(str, iter.base());
4439 assert(ex == "-0.00000*****************");
4440 assert(ios.width() == 0);
4441 }
4442 ios.width(25);
4443 right(ios);
4444 {
4445 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4446 std::string ex(str, iter.base());
4447 assert(ex == "*****************-0.00000");
4448 assert(ios.width() == 0);
4449 }
4450 ios.width(25);
4451 internal(ios);
4452 {
4453 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4454 std::string ex(str, iter.base());
4455 assert(ex == "-*****************0.00000");
4456 assert(ios.width() == 0);
4457 }
4458 }
4459 ios.imbue(lg);
4460 {
4461 ios.width(0);
4462 {
4463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4464 std::string ex(str, iter.base());
4465 assert(ex == "-0;00000");
4466 assert(ios.width() == 0);
4467 }
4468 ios.width(25);
4469 left(ios);
4470 {
4471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4472 std::string ex(str, iter.base());
4473 assert(ex == "-0;00000*****************");
4474 assert(ios.width() == 0);
4475 }
4476 ios.width(25);
4477 right(ios);
4478 {
4479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4480 std::string ex(str, iter.base());
4481 assert(ex == "*****************-0;00000");
4482 assert(ios.width() == 0);
4483 }
4484 ios.width(25);
4485 internal(ios);
4486 {
4487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4488 std::string ex(str, iter.base());
4489 assert(ex == "-*****************0;00000");
4490 assert(ios.width() == 0);
4491 }
4492 }
4493 }
4494 }
4495 }
4496 uppercase(ios);
4497 {
4498 noshowpos(ios);
4499 {
4500 noshowpoint(ios);
4501 {
4502 ios.imbue(lc);
4503 {
4504 ios.width(0);
4505 {
4506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4507 std::string ex(str, iter.base());
4508 assert(ex == "-0");
4509 assert(ios.width() == 0);
4510 }
4511 ios.width(25);
4512 left(ios);
4513 {
4514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4515 std::string ex(str, iter.base());
4516 assert(ex == "-0***********************");
4517 assert(ios.width() == 0);
4518 }
4519 ios.width(25);
4520 right(ios);
4521 {
4522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4523 std::string ex(str, iter.base());
4524 assert(ex == "***********************-0");
4525 assert(ios.width() == 0);
4526 }
4527 ios.width(25);
4528 internal(ios);
4529 {
4530 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4531 std::string ex(str, iter.base());
4532 assert(ex == "-***********************0");
4533 assert(ios.width() == 0);
4534 }
4535 }
4536 ios.imbue(lg);
4537 {
4538 ios.width(0);
4539 {
4540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4541 std::string ex(str, iter.base());
4542 assert(ex == "-0");
4543 assert(ios.width() == 0);
4544 }
4545 ios.width(25);
4546 left(ios);
4547 {
4548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4549 std::string ex(str, iter.base());
4550 assert(ex == "-0***********************");
4551 assert(ios.width() == 0);
4552 }
4553 ios.width(25);
4554 right(ios);
4555 {
4556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4557 std::string ex(str, iter.base());
4558 assert(ex == "***********************-0");
4559 assert(ios.width() == 0);
4560 }
4561 ios.width(25);
4562 internal(ios);
4563 {
4564 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4565 std::string ex(str, iter.base());
4566 assert(ex == "-***********************0");
4567 assert(ios.width() == 0);
4568 }
4569 }
4570 }
4571 showpoint(ios);
4572 {
4573 ios.imbue(lc);
4574 {
4575 ios.width(0);
4576 {
4577 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4578 std::string ex(str, iter.base());
4579 assert(ex == "-0.00000");
4580 assert(ios.width() == 0);
4581 }
4582 ios.width(25);
4583 left(ios);
4584 {
4585 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4586 std::string ex(str, iter.base());
4587 assert(ex == "-0.00000*****************");
4588 assert(ios.width() == 0);
4589 }
4590 ios.width(25);
4591 right(ios);
4592 {
4593 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4594 std::string ex(str, iter.base());
4595 assert(ex == "*****************-0.00000");
4596 assert(ios.width() == 0);
4597 }
4598 ios.width(25);
4599 internal(ios);
4600 {
4601 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4602 std::string ex(str, iter.base());
4603 assert(ex == "-*****************0.00000");
4604 assert(ios.width() == 0);
4605 }
4606 }
4607 ios.imbue(lg);
4608 {
4609 ios.width(0);
4610 {
4611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4612 std::string ex(str, iter.base());
4613 assert(ex == "-0;00000");
4614 assert(ios.width() == 0);
4615 }
4616 ios.width(25);
4617 left(ios);
4618 {
4619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4620 std::string ex(str, iter.base());
4621 assert(ex == "-0;00000*****************");
4622 assert(ios.width() == 0);
4623 }
4624 ios.width(25);
4625 right(ios);
4626 {
4627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4628 std::string ex(str, iter.base());
4629 assert(ex == "*****************-0;00000");
4630 assert(ios.width() == 0);
4631 }
4632 ios.width(25);
4633 internal(ios);
4634 {
4635 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4636 std::string ex(str, iter.base());
4637 assert(ex == "-*****************0;00000");
4638 assert(ios.width() == 0);
4639 }
4640 }
4641 }
4642 }
4643 showpos(ios);
4644 {
4645 noshowpoint(ios);
4646 {
4647 ios.imbue(lc);
4648 {
4649 ios.width(0);
4650 {
4651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4652 std::string ex(str, iter.base());
4653 assert(ex == "-0");
4654 assert(ios.width() == 0);
4655 }
4656 ios.width(25);
4657 left(ios);
4658 {
4659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4660 std::string ex(str, iter.base());
4661 assert(ex == "-0***********************");
4662 assert(ios.width() == 0);
4663 }
4664 ios.width(25);
4665 right(ios);
4666 {
4667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4668 std::string ex(str, iter.base());
4669 assert(ex == "***********************-0");
4670 assert(ios.width() == 0);
4671 }
4672 ios.width(25);
4673 internal(ios);
4674 {
4675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4676 std::string ex(str, iter.base());
4677 assert(ex == "-***********************0");
4678 assert(ios.width() == 0);
4679 }
4680 }
4681 ios.imbue(lg);
4682 {
4683 ios.width(0);
4684 {
4685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4686 std::string ex(str, iter.base());
4687 assert(ex == "-0");
4688 assert(ios.width() == 0);
4689 }
4690 ios.width(25);
4691 left(ios);
4692 {
4693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4694 std::string ex(str, iter.base());
4695 assert(ex == "-0***********************");
4696 assert(ios.width() == 0);
4697 }
4698 ios.width(25);
4699 right(ios);
4700 {
4701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4702 std::string ex(str, iter.base());
4703 assert(ex == "***********************-0");
4704 assert(ios.width() == 0);
4705 }
4706 ios.width(25);
4707 internal(ios);
4708 {
4709 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4710 std::string ex(str, iter.base());
4711 assert(ex == "-***********************0");
4712 assert(ios.width() == 0);
4713 }
4714 }
4715 }
4716 showpoint(ios);
4717 {
4718 ios.imbue(lc);
4719 {
4720 ios.width(0);
4721 {
4722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4723 std::string ex(str, iter.base());
4724 assert(ex == "-0.00000");
4725 assert(ios.width() == 0);
4726 }
4727 ios.width(25);
4728 left(ios);
4729 {
4730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4731 std::string ex(str, iter.base());
4732 assert(ex == "-0.00000*****************");
4733 assert(ios.width() == 0);
4734 }
4735 ios.width(25);
4736 right(ios);
4737 {
4738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4739 std::string ex(str, iter.base());
4740 assert(ex == "*****************-0.00000");
4741 assert(ios.width() == 0);
4742 }
4743 ios.width(25);
4744 internal(ios);
4745 {
4746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4747 std::string ex(str, iter.base());
4748 assert(ex == "-*****************0.00000");
4749 assert(ios.width() == 0);
4750 }
4751 }
4752 ios.imbue(lg);
4753 {
4754 ios.width(0);
4755 {
4756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4757 std::string ex(str, iter.base());
4758 assert(ex == "-0;00000");
4759 assert(ios.width() == 0);
4760 }
4761 ios.width(25);
4762 left(ios);
4763 {
4764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4765 std::string ex(str, iter.base());
4766 assert(ex == "-0;00000*****************");
4767 assert(ios.width() == 0);
4768 }
4769 ios.width(25);
4770 right(ios);
4771 {
4772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4773 std::string ex(str, iter.base());
4774 assert(ex == "*****************-0;00000");
4775 assert(ios.width() == 0);
4776 }
4777 ios.width(25);
4778 internal(ios);
4779 {
4780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4781 std::string ex(str, iter.base());
4782 assert(ex == "-*****************0;00000");
4783 assert(ios.width() == 0);
4784 }
4785 }
4786 }
4787 }
4788 }
4789 }
4790 ios.precision(16);
4791 {
4792 nouppercase(ios);
4793 {
4794 noshowpos(ios);
4795 {
4796 noshowpoint(ios);
4797 {
4798 ios.imbue(lc);
4799 {
4800 ios.width(0);
4801 {
4802 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4803 std::string ex(str, iter.base());
4804 assert(ex == "-0");
4805 assert(ios.width() == 0);
4806 }
4807 ios.width(25);
4808 left(ios);
4809 {
4810 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4811 std::string ex(str, iter.base());
4812 assert(ex == "-0***********************");
4813 assert(ios.width() == 0);
4814 }
4815 ios.width(25);
4816 right(ios);
4817 {
4818 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4819 std::string ex(str, iter.base());
4820 assert(ex == "***********************-0");
4821 assert(ios.width() == 0);
4822 }
4823 ios.width(25);
4824 internal(ios);
4825 {
4826 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4827 std::string ex(str, iter.base());
4828 assert(ex == "-***********************0");
4829 assert(ios.width() == 0);
4830 }
4831 }
4832 ios.imbue(lg);
4833 {
4834 ios.width(0);
4835 {
4836 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4837 std::string ex(str, iter.base());
4838 assert(ex == "-0");
4839 assert(ios.width() == 0);
4840 }
4841 ios.width(25);
4842 left(ios);
4843 {
4844 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4845 std::string ex(str, iter.base());
4846 assert(ex == "-0***********************");
4847 assert(ios.width() == 0);
4848 }
4849 ios.width(25);
4850 right(ios);
4851 {
4852 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4853 std::string ex(str, iter.base());
4854 assert(ex == "***********************-0");
4855 assert(ios.width() == 0);
4856 }
4857 ios.width(25);
4858 internal(ios);
4859 {
4860 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4861 std::string ex(str, iter.base());
4862 assert(ex == "-***********************0");
4863 assert(ios.width() == 0);
4864 }
4865 }
4866 }
4867 showpoint(ios);
4868 {
4869 ios.imbue(lc);
4870 {
4871 ios.width(0);
4872 {
4873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4874 std::string ex(str, iter.base());
4875 assert(ex == "-0.000000000000000");
4876 assert(ios.width() == 0);
4877 }
4878 ios.width(25);
4879 left(ios);
4880 {
4881 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4882 std::string ex(str, iter.base());
4883 assert(ex == "-0.000000000000000*******");
4884 assert(ios.width() == 0);
4885 }
4886 ios.width(25);
4887 right(ios);
4888 {
4889 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4890 std::string ex(str, iter.base());
4891 assert(ex == "*******-0.000000000000000");
4892 assert(ios.width() == 0);
4893 }
4894 ios.width(25);
4895 internal(ios);
4896 {
4897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4898 std::string ex(str, iter.base());
4899 assert(ex == "-*******0.000000000000000");
4900 assert(ios.width() == 0);
4901 }
4902 }
4903 ios.imbue(lg);
4904 {
4905 ios.width(0);
4906 {
4907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4908 std::string ex(str, iter.base());
4909 assert(ex == "-0;000000000000000");
4910 assert(ios.width() == 0);
4911 }
4912 ios.width(25);
4913 left(ios);
4914 {
4915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4916 std::string ex(str, iter.base());
4917 assert(ex == "-0;000000000000000*******");
4918 assert(ios.width() == 0);
4919 }
4920 ios.width(25);
4921 right(ios);
4922 {
4923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4924 std::string ex(str, iter.base());
4925 assert(ex == "*******-0;000000000000000");
4926 assert(ios.width() == 0);
4927 }
4928 ios.width(25);
4929 internal(ios);
4930 {
4931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4932 std::string ex(str, iter.base());
4933 assert(ex == "-*******0;000000000000000");
4934 assert(ios.width() == 0);
4935 }
4936 }
4937 }
4938 }
4939 showpos(ios);
4940 {
4941 noshowpoint(ios);
4942 {
4943 ios.imbue(lc);
4944 {
4945 ios.width(0);
4946 {
4947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4948 std::string ex(str, iter.base());
4949 assert(ex == "-0");
4950 assert(ios.width() == 0);
4951 }
4952 ios.width(25);
4953 left(ios);
4954 {
4955 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4956 std::string ex(str, iter.base());
4957 assert(ex == "-0***********************");
4958 assert(ios.width() == 0);
4959 }
4960 ios.width(25);
4961 right(ios);
4962 {
4963 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4964 std::string ex(str, iter.base());
4965 assert(ex == "***********************-0");
4966 assert(ios.width() == 0);
4967 }
4968 ios.width(25);
4969 internal(ios);
4970 {
4971 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4972 std::string ex(str, iter.base());
4973 assert(ex == "-***********************0");
4974 assert(ios.width() == 0);
4975 }
4976 }
4977 ios.imbue(lg);
4978 {
4979 ios.width(0);
4980 {
4981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4982 std::string ex(str, iter.base());
4983 assert(ex == "-0");
4984 assert(ios.width() == 0);
4985 }
4986 ios.width(25);
4987 left(ios);
4988 {
4989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4990 std::string ex(str, iter.base());
4991 assert(ex == "-0***********************");
4992 assert(ios.width() == 0);
4993 }
4994 ios.width(25);
4995 right(ios);
4996 {
4997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4998 std::string ex(str, iter.base());
4999 assert(ex == "***********************-0");
5000 assert(ios.width() == 0);
5001 }
5002 ios.width(25);
5003 internal(ios);
5004 {
5005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5006 std::string ex(str, iter.base());
5007 assert(ex == "-***********************0");
5008 assert(ios.width() == 0);
5009 }
5010 }
5011 }
5012 showpoint(ios);
5013 {
5014 ios.imbue(lc);
5015 {
5016 ios.width(0);
5017 {
5018 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5019 std::string ex(str, iter.base());
5020 assert(ex == "-0.000000000000000");
5021 assert(ios.width() == 0);
5022 }
5023 ios.width(25);
5024 left(ios);
5025 {
5026 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5027 std::string ex(str, iter.base());
5028 assert(ex == "-0.000000000000000*******");
5029 assert(ios.width() == 0);
5030 }
5031 ios.width(25);
5032 right(ios);
5033 {
5034 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5035 std::string ex(str, iter.base());
5036 assert(ex == "*******-0.000000000000000");
5037 assert(ios.width() == 0);
5038 }
5039 ios.width(25);
5040 internal(ios);
5041 {
5042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5043 std::string ex(str, iter.base());
5044 assert(ex == "-*******0.000000000000000");
5045 assert(ios.width() == 0);
5046 }
5047 }
5048 ios.imbue(lg);
5049 {
5050 ios.width(0);
5051 {
5052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5053 std::string ex(str, iter.base());
5054 assert(ex == "-0;000000000000000");
5055 assert(ios.width() == 0);
5056 }
5057 ios.width(25);
5058 left(ios);
5059 {
5060 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5061 std::string ex(str, iter.base());
5062 assert(ex == "-0;000000000000000*******");
5063 assert(ios.width() == 0);
5064 }
5065 ios.width(25);
5066 right(ios);
5067 {
5068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5069 std::string ex(str, iter.base());
5070 assert(ex == "*******-0;000000000000000");
5071 assert(ios.width() == 0);
5072 }
5073 ios.width(25);
5074 internal(ios);
5075 {
5076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5077 std::string ex(str, iter.base());
5078 assert(ex == "-*******0;000000000000000");
5079 assert(ios.width() == 0);
5080 }
5081 }
5082 }
5083 }
5084 }
5085 uppercase(ios);
5086 {
5087 noshowpos(ios);
5088 {
5089 noshowpoint(ios);
5090 {
5091 ios.imbue(lc);
5092 {
5093 ios.width(0);
5094 {
5095 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5096 std::string ex(str, iter.base());
5097 assert(ex == "-0");
5098 assert(ios.width() == 0);
5099 }
5100 ios.width(25);
5101 left(ios);
5102 {
5103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5104 std::string ex(str, iter.base());
5105 assert(ex == "-0***********************");
5106 assert(ios.width() == 0);
5107 }
5108 ios.width(25);
5109 right(ios);
5110 {
5111 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5112 std::string ex(str, iter.base());
5113 assert(ex == "***********************-0");
5114 assert(ios.width() == 0);
5115 }
5116 ios.width(25);
5117 internal(ios);
5118 {
5119 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5120 std::string ex(str, iter.base());
5121 assert(ex == "-***********************0");
5122 assert(ios.width() == 0);
5123 }
5124 }
5125 ios.imbue(lg);
5126 {
5127 ios.width(0);
5128 {
5129 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5130 std::string ex(str, iter.base());
5131 assert(ex == "-0");
5132 assert(ios.width() == 0);
5133 }
5134 ios.width(25);
5135 left(ios);
5136 {
5137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5138 std::string ex(str, iter.base());
5139 assert(ex == "-0***********************");
5140 assert(ios.width() == 0);
5141 }
5142 ios.width(25);
5143 right(ios);
5144 {
5145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5146 std::string ex(str, iter.base());
5147 assert(ex == "***********************-0");
5148 assert(ios.width() == 0);
5149 }
5150 ios.width(25);
5151 internal(ios);
5152 {
5153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5154 std::string ex(str, iter.base());
5155 assert(ex == "-***********************0");
5156 assert(ios.width() == 0);
5157 }
5158 }
5159 }
5160 showpoint(ios);
5161 {
5162 ios.imbue(lc);
5163 {
5164 ios.width(0);
5165 {
5166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5167 std::string ex(str, iter.base());
5168 assert(ex == "-0.000000000000000");
5169 assert(ios.width() == 0);
5170 }
5171 ios.width(25);
5172 left(ios);
5173 {
5174 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5175 std::string ex(str, iter.base());
5176 assert(ex == "-0.000000000000000*******");
5177 assert(ios.width() == 0);
5178 }
5179 ios.width(25);
5180 right(ios);
5181 {
5182 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5183 std::string ex(str, iter.base());
5184 assert(ex == "*******-0.000000000000000");
5185 assert(ios.width() == 0);
5186 }
5187 ios.width(25);
5188 internal(ios);
5189 {
5190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5191 std::string ex(str, iter.base());
5192 assert(ex == "-*******0.000000000000000");
5193 assert(ios.width() == 0);
5194 }
5195 }
5196 ios.imbue(lg);
5197 {
5198 ios.width(0);
5199 {
5200 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5201 std::string ex(str, iter.base());
5202 assert(ex == "-0;000000000000000");
5203 assert(ios.width() == 0);
5204 }
5205 ios.width(25);
5206 left(ios);
5207 {
5208 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5209 std::string ex(str, iter.base());
5210 assert(ex == "-0;000000000000000*******");
5211 assert(ios.width() == 0);
5212 }
5213 ios.width(25);
5214 right(ios);
5215 {
5216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5217 std::string ex(str, iter.base());
5218 assert(ex == "*******-0;000000000000000");
5219 assert(ios.width() == 0);
5220 }
5221 ios.width(25);
5222 internal(ios);
5223 {
5224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5225 std::string ex(str, iter.base());
5226 assert(ex == "-*******0;000000000000000");
5227 assert(ios.width() == 0);
5228 }
5229 }
5230 }
5231 }
5232 showpos(ios);
5233 {
5234 noshowpoint(ios);
5235 {
5236 ios.imbue(lc);
5237 {
5238 ios.width(0);
5239 {
5240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5241 std::string ex(str, iter.base());
5242 assert(ex == "-0");
5243 assert(ios.width() == 0);
5244 }
5245 ios.width(25);
5246 left(ios);
5247 {
5248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5249 std::string ex(str, iter.base());
5250 assert(ex == "-0***********************");
5251 assert(ios.width() == 0);
5252 }
5253 ios.width(25);
5254 right(ios);
5255 {
5256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5257 std::string ex(str, iter.base());
5258 assert(ex == "***********************-0");
5259 assert(ios.width() == 0);
5260 }
5261 ios.width(25);
5262 internal(ios);
5263 {
5264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5265 std::string ex(str, iter.base());
5266 assert(ex == "-***********************0");
5267 assert(ios.width() == 0);
5268 }
5269 }
5270 ios.imbue(lg);
5271 {
5272 ios.width(0);
5273 {
5274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5275 std::string ex(str, iter.base());
5276 assert(ex == "-0");
5277 assert(ios.width() == 0);
5278 }
5279 ios.width(25);
5280 left(ios);
5281 {
5282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5283 std::string ex(str, iter.base());
5284 assert(ex == "-0***********************");
5285 assert(ios.width() == 0);
5286 }
5287 ios.width(25);
5288 right(ios);
5289 {
5290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5291 std::string ex(str, iter.base());
5292 assert(ex == "***********************-0");
5293 assert(ios.width() == 0);
5294 }
5295 ios.width(25);
5296 internal(ios);
5297 {
5298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5299 std::string ex(str, iter.base());
5300 assert(ex == "-***********************0");
5301 assert(ios.width() == 0);
5302 }
5303 }
5304 }
5305 showpoint(ios);
5306 {
5307 ios.imbue(lc);
5308 {
5309 ios.width(0);
5310 {
5311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5312 std::string ex(str, iter.base());
5313 assert(ex == "-0.000000000000000");
5314 assert(ios.width() == 0);
5315 }
5316 ios.width(25);
5317 left(ios);
5318 {
5319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5320 std::string ex(str, iter.base());
5321 assert(ex == "-0.000000000000000*******");
5322 assert(ios.width() == 0);
5323 }
5324 ios.width(25);
5325 right(ios);
5326 {
5327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5328 std::string ex(str, iter.base());
5329 assert(ex == "*******-0.000000000000000");
5330 assert(ios.width() == 0);
5331 }
5332 ios.width(25);
5333 internal(ios);
5334 {
5335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5336 std::string ex(str, iter.base());
5337 assert(ex == "-*******0.000000000000000");
5338 assert(ios.width() == 0);
5339 }
5340 }
5341 ios.imbue(lg);
5342 {
5343 ios.width(0);
5344 {
5345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5346 std::string ex(str, iter.base());
5347 assert(ex == "-0;000000000000000");
5348 assert(ios.width() == 0);
5349 }
5350 ios.width(25);
5351 left(ios);
5352 {
5353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5354 std::string ex(str, iter.base());
5355 assert(ex == "-0;000000000000000*******");
5356 assert(ios.width() == 0);
5357 }
5358 ios.width(25);
5359 right(ios);
5360 {
5361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5362 std::string ex(str, iter.base());
5363 assert(ex == "*******-0;000000000000000");
5364 assert(ios.width() == 0);
5365 }
5366 ios.width(25);
5367 internal(ios);
5368 {
5369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5370 std::string ex(str, iter.base());
5371 assert(ex == "-*******0;000000000000000");
5372 assert(ios.width() == 0);
5373 }
5374 }
5375 }
5376 }
5377 }
5378 }
5379 ios.precision(60);
5380 {
5381 nouppercase(ios);
5382 {
5383 noshowpos(ios);
5384 {
5385 noshowpoint(ios);
5386 {
5387 ios.imbue(lc);
5388 {
5389 ios.width(0);
5390 {
5391 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5392 std::string ex(str, iter.base());
5393 assert(ex == "-0");
5394 assert(ios.width() == 0);
5395 }
5396 ios.width(25);
5397 left(ios);
5398 {
5399 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5400 std::string ex(str, iter.base());
5401 assert(ex == "-0***********************");
5402 assert(ios.width() == 0);
5403 }
5404 ios.width(25);
5405 right(ios);
5406 {
5407 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5408 std::string ex(str, iter.base());
5409 assert(ex == "***********************-0");
5410 assert(ios.width() == 0);
5411 }
5412 ios.width(25);
5413 internal(ios);
5414 {
5415 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5416 std::string ex(str, iter.base());
5417 assert(ex == "-***********************0");
5418 assert(ios.width() == 0);
5419 }
5420 }
5421 ios.imbue(lg);
5422 {
5423 ios.width(0);
5424 {
5425 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5426 std::string ex(str, iter.base());
5427 assert(ex == "-0");
5428 assert(ios.width() == 0);
5429 }
5430 ios.width(25);
5431 left(ios);
5432 {
5433 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5434 std::string ex(str, iter.base());
5435 assert(ex == "-0***********************");
5436 assert(ios.width() == 0);
5437 }
5438 ios.width(25);
5439 right(ios);
5440 {
5441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5442 std::string ex(str, iter.base());
5443 assert(ex == "***********************-0");
5444 assert(ios.width() == 0);
5445 }
5446 ios.width(25);
5447 internal(ios);
5448 {
5449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5450 std::string ex(str, iter.base());
5451 assert(ex == "-***********************0");
5452 assert(ios.width() == 0);
5453 }
5454 }
5455 }
5456 showpoint(ios);
5457 {
5458 ios.imbue(lc);
5459 {
5460 ios.width(0);
5461 {
5462 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5463 std::string ex(str, iter.base());
5464 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5465 assert(ios.width() == 0);
5466 }
5467 ios.width(25);
5468 left(ios);
5469 {
5470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5471 std::string ex(str, iter.base());
5472 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5473 assert(ios.width() == 0);
5474 }
5475 ios.width(25);
5476 right(ios);
5477 {
5478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5479 std::string ex(str, iter.base());
5480 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5481 assert(ios.width() == 0);
5482 }
5483 ios.width(25);
5484 internal(ios);
5485 {
5486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5487 std::string ex(str, iter.base());
5488 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5489 assert(ios.width() == 0);
5490 }
5491 }
5492 ios.imbue(lg);
5493 {
5494 ios.width(0);
5495 {
5496 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5497 std::string ex(str, iter.base());
5498 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5499 assert(ios.width() == 0);
5500 }
5501 ios.width(25);
5502 left(ios);
5503 {
5504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5505 std::string ex(str, iter.base());
5506 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5507 assert(ios.width() == 0);
5508 }
5509 ios.width(25);
5510 right(ios);
5511 {
5512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5513 std::string ex(str, iter.base());
5514 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5515 assert(ios.width() == 0);
5516 }
5517 ios.width(25);
5518 internal(ios);
5519 {
5520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5521 std::string ex(str, iter.base());
5522 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5523 assert(ios.width() == 0);
5524 }
5525 }
5526 }
5527 }
5528 showpos(ios);
5529 {
5530 noshowpoint(ios);
5531 {
5532 ios.imbue(lc);
5533 {
5534 ios.width(0);
5535 {
5536 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5537 std::string ex(str, iter.base());
5538 assert(ex == "-0");
5539 assert(ios.width() == 0);
5540 }
5541 ios.width(25);
5542 left(ios);
5543 {
5544 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5545 std::string ex(str, iter.base());
5546 assert(ex == "-0***********************");
5547 assert(ios.width() == 0);
5548 }
5549 ios.width(25);
5550 right(ios);
5551 {
5552 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5553 std::string ex(str, iter.base());
5554 assert(ex == "***********************-0");
5555 assert(ios.width() == 0);
5556 }
5557 ios.width(25);
5558 internal(ios);
5559 {
5560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5561 std::string ex(str, iter.base());
5562 assert(ex == "-***********************0");
5563 assert(ios.width() == 0);
5564 }
5565 }
5566 ios.imbue(lg);
5567 {
5568 ios.width(0);
5569 {
5570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5571 std::string ex(str, iter.base());
5572 assert(ex == "-0");
5573 assert(ios.width() == 0);
5574 }
5575 ios.width(25);
5576 left(ios);
5577 {
5578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5579 std::string ex(str, iter.base());
5580 assert(ex == "-0***********************");
5581 assert(ios.width() == 0);
5582 }
5583 ios.width(25);
5584 right(ios);
5585 {
5586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5587 std::string ex(str, iter.base());
5588 assert(ex == "***********************-0");
5589 assert(ios.width() == 0);
5590 }
5591 ios.width(25);
5592 internal(ios);
5593 {
5594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5595 std::string ex(str, iter.base());
5596 assert(ex == "-***********************0");
5597 assert(ios.width() == 0);
5598 }
5599 }
5600 }
5601 showpoint(ios);
5602 {
5603 ios.imbue(lc);
5604 {
5605 ios.width(0);
5606 {
5607 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5608 std::string ex(str, iter.base());
5609 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5610 assert(ios.width() == 0);
5611 }
5612 ios.width(25);
5613 left(ios);
5614 {
5615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5616 std::string ex(str, iter.base());
5617 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5618 assert(ios.width() == 0);
5619 }
5620 ios.width(25);
5621 right(ios);
5622 {
5623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5624 std::string ex(str, iter.base());
5625 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5626 assert(ios.width() == 0);
5627 }
5628 ios.width(25);
5629 internal(ios);
5630 {
5631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5632 std::string ex(str, iter.base());
5633 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5634 assert(ios.width() == 0);
5635 }
5636 }
5637 ios.imbue(lg);
5638 {
5639 ios.width(0);
5640 {
5641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5642 std::string ex(str, iter.base());
5643 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5644 assert(ios.width() == 0);
5645 }
5646 ios.width(25);
5647 left(ios);
5648 {
5649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5650 std::string ex(str, iter.base());
5651 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5652 assert(ios.width() == 0);
5653 }
5654 ios.width(25);
5655 right(ios);
5656 {
5657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5658 std::string ex(str, iter.base());
5659 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5660 assert(ios.width() == 0);
5661 }
5662 ios.width(25);
5663 internal(ios);
5664 {
5665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5666 std::string ex(str, iter.base());
5667 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5668 assert(ios.width() == 0);
5669 }
5670 }
5671 }
5672 }
5673 }
5674 uppercase(ios);
5675 {
5676 noshowpos(ios);
5677 {
5678 noshowpoint(ios);
5679 {
5680 ios.imbue(lc);
5681 {
5682 ios.width(0);
5683 {
5684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5685 std::string ex(str, iter.base());
5686 assert(ex == "-0");
5687 assert(ios.width() == 0);
5688 }
5689 ios.width(25);
5690 left(ios);
5691 {
5692 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5693 std::string ex(str, iter.base());
5694 assert(ex == "-0***********************");
5695 assert(ios.width() == 0);
5696 }
5697 ios.width(25);
5698 right(ios);
5699 {
5700 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5701 std::string ex(str, iter.base());
5702 assert(ex == "***********************-0");
5703 assert(ios.width() == 0);
5704 }
5705 ios.width(25);
5706 internal(ios);
5707 {
5708 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5709 std::string ex(str, iter.base());
5710 assert(ex == "-***********************0");
5711 assert(ios.width() == 0);
5712 }
5713 }
5714 ios.imbue(lg);
5715 {
5716 ios.width(0);
5717 {
5718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5719 std::string ex(str, iter.base());
5720 assert(ex == "-0");
5721 assert(ios.width() == 0);
5722 }
5723 ios.width(25);
5724 left(ios);
5725 {
5726 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5727 std::string ex(str, iter.base());
5728 assert(ex == "-0***********************");
5729 assert(ios.width() == 0);
5730 }
5731 ios.width(25);
5732 right(ios);
5733 {
5734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5735 std::string ex(str, iter.base());
5736 assert(ex == "***********************-0");
5737 assert(ios.width() == 0);
5738 }
5739 ios.width(25);
5740 internal(ios);
5741 {
5742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5743 std::string ex(str, iter.base());
5744 assert(ex == "-***********************0");
5745 assert(ios.width() == 0);
5746 }
5747 }
5748 }
5749 showpoint(ios);
5750 {
5751 ios.imbue(lc);
5752 {
5753 ios.width(0);
5754 {
5755 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5756 std::string ex(str, iter.base());
5757 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5758 assert(ios.width() == 0);
5759 }
5760 ios.width(25);
5761 left(ios);
5762 {
5763 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5764 std::string ex(str, iter.base());
5765 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5766 assert(ios.width() == 0);
5767 }
5768 ios.width(25);
5769 right(ios);
5770 {
5771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5772 std::string ex(str, iter.base());
5773 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5774 assert(ios.width() == 0);
5775 }
5776 ios.width(25);
5777 internal(ios);
5778 {
5779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5780 std::string ex(str, iter.base());
5781 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5782 assert(ios.width() == 0);
5783 }
5784 }
5785 ios.imbue(lg);
5786 {
5787 ios.width(0);
5788 {
5789 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5790 std::string ex(str, iter.base());
5791 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5792 assert(ios.width() == 0);
5793 }
5794 ios.width(25);
5795 left(ios);
5796 {
5797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5798 std::string ex(str, iter.base());
5799 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5800 assert(ios.width() == 0);
5801 }
5802 ios.width(25);
5803 right(ios);
5804 {
5805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5806 std::string ex(str, iter.base());
5807 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5808 assert(ios.width() == 0);
5809 }
5810 ios.width(25);
5811 internal(ios);
5812 {
5813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5814 std::string ex(str, iter.base());
5815 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5816 assert(ios.width() == 0);
5817 }
5818 }
5819 }
5820 }
5821 showpos(ios);
5822 {
5823 noshowpoint(ios);
5824 {
5825 ios.imbue(lc);
5826 {
5827 ios.width(0);
5828 {
5829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5830 std::string ex(str, iter.base());
5831 assert(ex == "-0");
5832 assert(ios.width() == 0);
5833 }
5834 ios.width(25);
5835 left(ios);
5836 {
5837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5838 std::string ex(str, iter.base());
5839 assert(ex == "-0***********************");
5840 assert(ios.width() == 0);
5841 }
5842 ios.width(25);
5843 right(ios);
5844 {
5845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5846 std::string ex(str, iter.base());
5847 assert(ex == "***********************-0");
5848 assert(ios.width() == 0);
5849 }
5850 ios.width(25);
5851 internal(ios);
5852 {
5853 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5854 std::string ex(str, iter.base());
5855 assert(ex == "-***********************0");
5856 assert(ios.width() == 0);
5857 }
5858 }
5859 ios.imbue(lg);
5860 {
5861 ios.width(0);
5862 {
5863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5864 std::string ex(str, iter.base());
5865 assert(ex == "-0");
5866 assert(ios.width() == 0);
5867 }
5868 ios.width(25);
5869 left(ios);
5870 {
5871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5872 std::string ex(str, iter.base());
5873 assert(ex == "-0***********************");
5874 assert(ios.width() == 0);
5875 }
5876 ios.width(25);
5877 right(ios);
5878 {
5879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5880 std::string ex(str, iter.base());
5881 assert(ex == "***********************-0");
5882 assert(ios.width() == 0);
5883 }
5884 ios.width(25);
5885 internal(ios);
5886 {
5887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5888 std::string ex(str, iter.base());
5889 assert(ex == "-***********************0");
5890 assert(ios.width() == 0);
5891 }
5892 }
5893 }
5894 showpoint(ios);
5895 {
5896 ios.imbue(lc);
5897 {
5898 ios.width(0);
5899 {
5900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5901 std::string ex(str, iter.base());
5902 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5903 assert(ios.width() == 0);
5904 }
5905 ios.width(25);
5906 left(ios);
5907 {
5908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5909 std::string ex(str, iter.base());
5910 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5911 assert(ios.width() == 0);
5912 }
5913 ios.width(25);
5914 right(ios);
5915 {
5916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5917 std::string ex(str, iter.base());
5918 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5919 assert(ios.width() == 0);
5920 }
5921 ios.width(25);
5922 internal(ios);
5923 {
5924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5925 std::string ex(str, iter.base());
5926 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5927 assert(ios.width() == 0);
5928 }
5929 }
5930 ios.imbue(lg);
5931 {
5932 ios.width(0);
5933 {
5934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5935 std::string ex(str, iter.base());
5936 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5937 assert(ios.width() == 0);
5938 }
5939 ios.width(25);
5940 left(ios);
5941 {
5942 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5943 std::string ex(str, iter.base());
5944 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5945 assert(ios.width() == 0);
5946 }
5947 ios.width(25);
5948 right(ios);
5949 {
5950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5951 std::string ex(str, iter.base());
5952 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5953 assert(ios.width() == 0);
5954 }
5955 ios.width(25);
5956 internal(ios);
5957 {
5958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5959 std::string ex(str, iter.base());
5960 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5961 assert(ios.width() == 0);
5962 }
5963 }
5964 }
5965 }
5966 }
5967 }
5968 }
5969 }
5970 }
5971
test3()5972 void test3()
5973 {
5974 char str[200];
5975 output_iterator<char*> iter;
5976 std::locale lc = std::locale::classic();
5977 std::locale lg(lc, new my_numpunct);
5978 const my_facet f(1);
5979 {
5980 long double v = 1234567890.125;
5981 std::ios ios(0);
5982 // %g
5983 {
5984 ios.precision(0);
5985 {
5986 nouppercase(ios);
5987 {
5988 noshowpos(ios);
5989 {
5990 noshowpoint(ios);
5991 {
5992 ios.imbue(lc);
5993 {
5994 ios.width(0);
5995 {
5996 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5997 std::string ex(str, iter.base());
5998 assert(ex == "1e+09");
5999 assert(ios.width() == 0);
6000 }
6001 ios.width(25);
6002 left(ios);
6003 {
6004 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6005 std::string ex(str, iter.base());
6006 assert(ex == "1e+09********************");
6007 assert(ios.width() == 0);
6008 }
6009 ios.width(25);
6010 right(ios);
6011 {
6012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6013 std::string ex(str, iter.base());
6014 assert(ex == "********************1e+09");
6015 assert(ios.width() == 0);
6016 }
6017 ios.width(25);
6018 internal(ios);
6019 {
6020 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6021 std::string ex(str, iter.base());
6022 assert(ex == "********************1e+09");
6023 assert(ios.width() == 0);
6024 }
6025 }
6026 ios.imbue(lg);
6027 {
6028 ios.width(0);
6029 {
6030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6031 std::string ex(str, iter.base());
6032 assert(ex == "1e+09");
6033 assert(ios.width() == 0);
6034 }
6035 ios.width(25);
6036 left(ios);
6037 {
6038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6039 std::string ex(str, iter.base());
6040 assert(ex == "1e+09********************");
6041 assert(ios.width() == 0);
6042 }
6043 ios.width(25);
6044 right(ios);
6045 {
6046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6047 std::string ex(str, iter.base());
6048 assert(ex == "********************1e+09");
6049 assert(ios.width() == 0);
6050 }
6051 ios.width(25);
6052 internal(ios);
6053 {
6054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6055 std::string ex(str, iter.base());
6056 assert(ex == "********************1e+09");
6057 assert(ios.width() == 0);
6058 }
6059 }
6060 }
6061 showpoint(ios);
6062 {
6063 ios.imbue(lc);
6064 {
6065 ios.width(0);
6066 {
6067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6068 std::string ex(str, iter.base());
6069 assert(ex == "1.e+09");
6070 assert(ios.width() == 0);
6071 }
6072 ios.width(25);
6073 left(ios);
6074 {
6075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6076 std::string ex(str, iter.base());
6077 assert(ex == "1.e+09*******************");
6078 assert(ios.width() == 0);
6079 }
6080 ios.width(25);
6081 right(ios);
6082 {
6083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6084 std::string ex(str, iter.base());
6085 assert(ex == "*******************1.e+09");
6086 assert(ios.width() == 0);
6087 }
6088 ios.width(25);
6089 internal(ios);
6090 {
6091 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6092 std::string ex(str, iter.base());
6093 assert(ex == "*******************1.e+09");
6094 assert(ios.width() == 0);
6095 }
6096 }
6097 ios.imbue(lg);
6098 {
6099 ios.width(0);
6100 {
6101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6102 std::string ex(str, iter.base());
6103 assert(ex == "1;e+09");
6104 assert(ios.width() == 0);
6105 }
6106 ios.width(25);
6107 left(ios);
6108 {
6109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6110 std::string ex(str, iter.base());
6111 assert(ex == "1;e+09*******************");
6112 assert(ios.width() == 0);
6113 }
6114 ios.width(25);
6115 right(ios);
6116 {
6117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6118 std::string ex(str, iter.base());
6119 assert(ex == "*******************1;e+09");
6120 assert(ios.width() == 0);
6121 }
6122 ios.width(25);
6123 internal(ios);
6124 {
6125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6126 std::string ex(str, iter.base());
6127 assert(ex == "*******************1;e+09");
6128 assert(ios.width() == 0);
6129 }
6130 }
6131 }
6132 }
6133 showpos(ios);
6134 {
6135 noshowpoint(ios);
6136 {
6137 ios.imbue(lc);
6138 {
6139 ios.width(0);
6140 {
6141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6142 std::string ex(str, iter.base());
6143 assert(ex == "+1e+09");
6144 assert(ios.width() == 0);
6145 }
6146 ios.width(25);
6147 left(ios);
6148 {
6149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6150 std::string ex(str, iter.base());
6151 assert(ex == "+1e+09*******************");
6152 assert(ios.width() == 0);
6153 }
6154 ios.width(25);
6155 right(ios);
6156 {
6157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6158 std::string ex(str, iter.base());
6159 assert(ex == "*******************+1e+09");
6160 assert(ios.width() == 0);
6161 }
6162 ios.width(25);
6163 internal(ios);
6164 {
6165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6166 std::string ex(str, iter.base());
6167 assert(ex == "+*******************1e+09");
6168 assert(ios.width() == 0);
6169 }
6170 }
6171 ios.imbue(lg);
6172 {
6173 ios.width(0);
6174 {
6175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6176 std::string ex(str, iter.base());
6177 assert(ex == "+1e+09");
6178 assert(ios.width() == 0);
6179 }
6180 ios.width(25);
6181 left(ios);
6182 {
6183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6184 std::string ex(str, iter.base());
6185 assert(ex == "+1e+09*******************");
6186 assert(ios.width() == 0);
6187 }
6188 ios.width(25);
6189 right(ios);
6190 {
6191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6192 std::string ex(str, iter.base());
6193 assert(ex == "*******************+1e+09");
6194 assert(ios.width() == 0);
6195 }
6196 ios.width(25);
6197 internal(ios);
6198 {
6199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6200 std::string ex(str, iter.base());
6201 assert(ex == "+*******************1e+09");
6202 assert(ios.width() == 0);
6203 }
6204 }
6205 }
6206 showpoint(ios);
6207 {
6208 ios.imbue(lc);
6209 {
6210 ios.width(0);
6211 {
6212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6213 std::string ex(str, iter.base());
6214 assert(ex == "+1.e+09");
6215 assert(ios.width() == 0);
6216 }
6217 ios.width(25);
6218 left(ios);
6219 {
6220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6221 std::string ex(str, iter.base());
6222 assert(ex == "+1.e+09******************");
6223 assert(ios.width() == 0);
6224 }
6225 ios.width(25);
6226 right(ios);
6227 {
6228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6229 std::string ex(str, iter.base());
6230 assert(ex == "******************+1.e+09");
6231 assert(ios.width() == 0);
6232 }
6233 ios.width(25);
6234 internal(ios);
6235 {
6236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6237 std::string ex(str, iter.base());
6238 assert(ex == "+******************1.e+09");
6239 assert(ios.width() == 0);
6240 }
6241 }
6242 ios.imbue(lg);
6243 {
6244 ios.width(0);
6245 {
6246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6247 std::string ex(str, iter.base());
6248 assert(ex == "+1;e+09");
6249 assert(ios.width() == 0);
6250 }
6251 ios.width(25);
6252 left(ios);
6253 {
6254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6255 std::string ex(str, iter.base());
6256 assert(ex == "+1;e+09******************");
6257 assert(ios.width() == 0);
6258 }
6259 ios.width(25);
6260 right(ios);
6261 {
6262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6263 std::string ex(str, iter.base());
6264 assert(ex == "******************+1;e+09");
6265 assert(ios.width() == 0);
6266 }
6267 ios.width(25);
6268 internal(ios);
6269 {
6270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6271 std::string ex(str, iter.base());
6272 assert(ex == "+******************1;e+09");
6273 assert(ios.width() == 0);
6274 }
6275 }
6276 }
6277 }
6278 }
6279 uppercase(ios);
6280 {
6281 noshowpos(ios);
6282 {
6283 noshowpoint(ios);
6284 {
6285 ios.imbue(lc);
6286 {
6287 ios.width(0);
6288 {
6289 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6290 std::string ex(str, iter.base());
6291 assert(ex == "1E+09");
6292 assert(ios.width() == 0);
6293 }
6294 ios.width(25);
6295 left(ios);
6296 {
6297 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6298 std::string ex(str, iter.base());
6299 assert(ex == "1E+09********************");
6300 assert(ios.width() == 0);
6301 }
6302 ios.width(25);
6303 right(ios);
6304 {
6305 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6306 std::string ex(str, iter.base());
6307 assert(ex == "********************1E+09");
6308 assert(ios.width() == 0);
6309 }
6310 ios.width(25);
6311 internal(ios);
6312 {
6313 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6314 std::string ex(str, iter.base());
6315 assert(ex == "********************1E+09");
6316 assert(ios.width() == 0);
6317 }
6318 }
6319 ios.imbue(lg);
6320 {
6321 ios.width(0);
6322 {
6323 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6324 std::string ex(str, iter.base());
6325 assert(ex == "1E+09");
6326 assert(ios.width() == 0);
6327 }
6328 ios.width(25);
6329 left(ios);
6330 {
6331 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6332 std::string ex(str, iter.base());
6333 assert(ex == "1E+09********************");
6334 assert(ios.width() == 0);
6335 }
6336 ios.width(25);
6337 right(ios);
6338 {
6339 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6340 std::string ex(str, iter.base());
6341 assert(ex == "********************1E+09");
6342 assert(ios.width() == 0);
6343 }
6344 ios.width(25);
6345 internal(ios);
6346 {
6347 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6348 std::string ex(str, iter.base());
6349 assert(ex == "********************1E+09");
6350 assert(ios.width() == 0);
6351 }
6352 }
6353 }
6354 showpoint(ios);
6355 {
6356 ios.imbue(lc);
6357 {
6358 ios.width(0);
6359 {
6360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6361 std::string ex(str, iter.base());
6362 assert(ex == "1.E+09");
6363 assert(ios.width() == 0);
6364 }
6365 ios.width(25);
6366 left(ios);
6367 {
6368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6369 std::string ex(str, iter.base());
6370 assert(ex == "1.E+09*******************");
6371 assert(ios.width() == 0);
6372 }
6373 ios.width(25);
6374 right(ios);
6375 {
6376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6377 std::string ex(str, iter.base());
6378 assert(ex == "*******************1.E+09");
6379 assert(ios.width() == 0);
6380 }
6381 ios.width(25);
6382 internal(ios);
6383 {
6384 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6385 std::string ex(str, iter.base());
6386 assert(ex == "*******************1.E+09");
6387 assert(ios.width() == 0);
6388 }
6389 }
6390 ios.imbue(lg);
6391 {
6392 ios.width(0);
6393 {
6394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6395 std::string ex(str, iter.base());
6396 assert(ex == "1;E+09");
6397 assert(ios.width() == 0);
6398 }
6399 ios.width(25);
6400 left(ios);
6401 {
6402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6403 std::string ex(str, iter.base());
6404 assert(ex == "1;E+09*******************");
6405 assert(ios.width() == 0);
6406 }
6407 ios.width(25);
6408 right(ios);
6409 {
6410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6411 std::string ex(str, iter.base());
6412 assert(ex == "*******************1;E+09");
6413 assert(ios.width() == 0);
6414 }
6415 ios.width(25);
6416 internal(ios);
6417 {
6418 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6419 std::string ex(str, iter.base());
6420 assert(ex == "*******************1;E+09");
6421 assert(ios.width() == 0);
6422 }
6423 }
6424 }
6425 }
6426 showpos(ios);
6427 {
6428 noshowpoint(ios);
6429 {
6430 ios.imbue(lc);
6431 {
6432 ios.width(0);
6433 {
6434 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6435 std::string ex(str, iter.base());
6436 assert(ex == "+1E+09");
6437 assert(ios.width() == 0);
6438 }
6439 ios.width(25);
6440 left(ios);
6441 {
6442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6443 std::string ex(str, iter.base());
6444 assert(ex == "+1E+09*******************");
6445 assert(ios.width() == 0);
6446 }
6447 ios.width(25);
6448 right(ios);
6449 {
6450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6451 std::string ex(str, iter.base());
6452 assert(ex == "*******************+1E+09");
6453 assert(ios.width() == 0);
6454 }
6455 ios.width(25);
6456 internal(ios);
6457 {
6458 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6459 std::string ex(str, iter.base());
6460 assert(ex == "+*******************1E+09");
6461 assert(ios.width() == 0);
6462 }
6463 }
6464 ios.imbue(lg);
6465 {
6466 ios.width(0);
6467 {
6468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6469 std::string ex(str, iter.base());
6470 assert(ex == "+1E+09");
6471 assert(ios.width() == 0);
6472 }
6473 ios.width(25);
6474 left(ios);
6475 {
6476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6477 std::string ex(str, iter.base());
6478 assert(ex == "+1E+09*******************");
6479 assert(ios.width() == 0);
6480 }
6481 ios.width(25);
6482 right(ios);
6483 {
6484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6485 std::string ex(str, iter.base());
6486 assert(ex == "*******************+1E+09");
6487 assert(ios.width() == 0);
6488 }
6489 ios.width(25);
6490 internal(ios);
6491 {
6492 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6493 std::string ex(str, iter.base());
6494 assert(ex == "+*******************1E+09");
6495 assert(ios.width() == 0);
6496 }
6497 }
6498 }
6499 showpoint(ios);
6500 {
6501 ios.imbue(lc);
6502 {
6503 ios.width(0);
6504 {
6505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6506 std::string ex(str, iter.base());
6507 assert(ex == "+1.E+09");
6508 assert(ios.width() == 0);
6509 }
6510 ios.width(25);
6511 left(ios);
6512 {
6513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6514 std::string ex(str, iter.base());
6515 assert(ex == "+1.E+09******************");
6516 assert(ios.width() == 0);
6517 }
6518 ios.width(25);
6519 right(ios);
6520 {
6521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6522 std::string ex(str, iter.base());
6523 assert(ex == "******************+1.E+09");
6524 assert(ios.width() == 0);
6525 }
6526 ios.width(25);
6527 internal(ios);
6528 {
6529 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6530 std::string ex(str, iter.base());
6531 assert(ex == "+******************1.E+09");
6532 assert(ios.width() == 0);
6533 }
6534 }
6535 ios.imbue(lg);
6536 {
6537 ios.width(0);
6538 {
6539 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6540 std::string ex(str, iter.base());
6541 assert(ex == "+1;E+09");
6542 assert(ios.width() == 0);
6543 }
6544 ios.width(25);
6545 left(ios);
6546 {
6547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6548 std::string ex(str, iter.base());
6549 assert(ex == "+1;E+09******************");
6550 assert(ios.width() == 0);
6551 }
6552 ios.width(25);
6553 right(ios);
6554 {
6555 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6556 std::string ex(str, iter.base());
6557 assert(ex == "******************+1;E+09");
6558 assert(ios.width() == 0);
6559 }
6560 ios.width(25);
6561 internal(ios);
6562 {
6563 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6564 std::string ex(str, iter.base());
6565 assert(ex == "+******************1;E+09");
6566 assert(ios.width() == 0);
6567 }
6568 }
6569 }
6570 }
6571 }
6572 }
6573 ios.precision(1);
6574 {
6575 nouppercase(ios);
6576 {
6577 noshowpos(ios);
6578 {
6579 noshowpoint(ios);
6580 {
6581 ios.imbue(lc);
6582 {
6583 ios.width(0);
6584 {
6585 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6586 std::string ex(str, iter.base());
6587 assert(ex == "1e+09");
6588 assert(ios.width() == 0);
6589 }
6590 ios.width(25);
6591 left(ios);
6592 {
6593 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6594 std::string ex(str, iter.base());
6595 assert(ex == "1e+09********************");
6596 assert(ios.width() == 0);
6597 }
6598 ios.width(25);
6599 right(ios);
6600 {
6601 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6602 std::string ex(str, iter.base());
6603 assert(ex == "********************1e+09");
6604 assert(ios.width() == 0);
6605 }
6606 ios.width(25);
6607 internal(ios);
6608 {
6609 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6610 std::string ex(str, iter.base());
6611 assert(ex == "********************1e+09");
6612 assert(ios.width() == 0);
6613 }
6614 }
6615 ios.imbue(lg);
6616 {
6617 ios.width(0);
6618 {
6619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6620 std::string ex(str, iter.base());
6621 assert(ex == "1e+09");
6622 assert(ios.width() == 0);
6623 }
6624 ios.width(25);
6625 left(ios);
6626 {
6627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6628 std::string ex(str, iter.base());
6629 assert(ex == "1e+09********************");
6630 assert(ios.width() == 0);
6631 }
6632 ios.width(25);
6633 right(ios);
6634 {
6635 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6636 std::string ex(str, iter.base());
6637 assert(ex == "********************1e+09");
6638 assert(ios.width() == 0);
6639 }
6640 ios.width(25);
6641 internal(ios);
6642 {
6643 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6644 std::string ex(str, iter.base());
6645 assert(ex == "********************1e+09");
6646 assert(ios.width() == 0);
6647 }
6648 }
6649 }
6650 showpoint(ios);
6651 {
6652 ios.imbue(lc);
6653 {
6654 ios.width(0);
6655 {
6656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6657 std::string ex(str, iter.base());
6658 assert(ex == "1.e+09");
6659 assert(ios.width() == 0);
6660 }
6661 ios.width(25);
6662 left(ios);
6663 {
6664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6665 std::string ex(str, iter.base());
6666 assert(ex == "1.e+09*******************");
6667 assert(ios.width() == 0);
6668 }
6669 ios.width(25);
6670 right(ios);
6671 {
6672 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6673 std::string ex(str, iter.base());
6674 assert(ex == "*******************1.e+09");
6675 assert(ios.width() == 0);
6676 }
6677 ios.width(25);
6678 internal(ios);
6679 {
6680 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6681 std::string ex(str, iter.base());
6682 assert(ex == "*******************1.e+09");
6683 assert(ios.width() == 0);
6684 }
6685 }
6686 ios.imbue(lg);
6687 {
6688 ios.width(0);
6689 {
6690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6691 std::string ex(str, iter.base());
6692 assert(ex == "1;e+09");
6693 assert(ios.width() == 0);
6694 }
6695 ios.width(25);
6696 left(ios);
6697 {
6698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6699 std::string ex(str, iter.base());
6700 assert(ex == "1;e+09*******************");
6701 assert(ios.width() == 0);
6702 }
6703 ios.width(25);
6704 right(ios);
6705 {
6706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6707 std::string ex(str, iter.base());
6708 assert(ex == "*******************1;e+09");
6709 assert(ios.width() == 0);
6710 }
6711 ios.width(25);
6712 internal(ios);
6713 {
6714 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6715 std::string ex(str, iter.base());
6716 assert(ex == "*******************1;e+09");
6717 assert(ios.width() == 0);
6718 }
6719 }
6720 }
6721 }
6722 showpos(ios);
6723 {
6724 noshowpoint(ios);
6725 {
6726 ios.imbue(lc);
6727 {
6728 ios.width(0);
6729 {
6730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6731 std::string ex(str, iter.base());
6732 assert(ex == "+1e+09");
6733 assert(ios.width() == 0);
6734 }
6735 ios.width(25);
6736 left(ios);
6737 {
6738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6739 std::string ex(str, iter.base());
6740 assert(ex == "+1e+09*******************");
6741 assert(ios.width() == 0);
6742 }
6743 ios.width(25);
6744 right(ios);
6745 {
6746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6747 std::string ex(str, iter.base());
6748 assert(ex == "*******************+1e+09");
6749 assert(ios.width() == 0);
6750 }
6751 ios.width(25);
6752 internal(ios);
6753 {
6754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6755 std::string ex(str, iter.base());
6756 assert(ex == "+*******************1e+09");
6757 assert(ios.width() == 0);
6758 }
6759 }
6760 ios.imbue(lg);
6761 {
6762 ios.width(0);
6763 {
6764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6765 std::string ex(str, iter.base());
6766 assert(ex == "+1e+09");
6767 assert(ios.width() == 0);
6768 }
6769 ios.width(25);
6770 left(ios);
6771 {
6772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6773 std::string ex(str, iter.base());
6774 assert(ex == "+1e+09*******************");
6775 assert(ios.width() == 0);
6776 }
6777 ios.width(25);
6778 right(ios);
6779 {
6780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6781 std::string ex(str, iter.base());
6782 assert(ex == "*******************+1e+09");
6783 assert(ios.width() == 0);
6784 }
6785 ios.width(25);
6786 internal(ios);
6787 {
6788 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6789 std::string ex(str, iter.base());
6790 assert(ex == "+*******************1e+09");
6791 assert(ios.width() == 0);
6792 }
6793 }
6794 }
6795 showpoint(ios);
6796 {
6797 ios.imbue(lc);
6798 {
6799 ios.width(0);
6800 {
6801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6802 std::string ex(str, iter.base());
6803 assert(ex == "+1.e+09");
6804 assert(ios.width() == 0);
6805 }
6806 ios.width(25);
6807 left(ios);
6808 {
6809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6810 std::string ex(str, iter.base());
6811 assert(ex == "+1.e+09******************");
6812 assert(ios.width() == 0);
6813 }
6814 ios.width(25);
6815 right(ios);
6816 {
6817 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6818 std::string ex(str, iter.base());
6819 assert(ex == "******************+1.e+09");
6820 assert(ios.width() == 0);
6821 }
6822 ios.width(25);
6823 internal(ios);
6824 {
6825 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6826 std::string ex(str, iter.base());
6827 assert(ex == "+******************1.e+09");
6828 assert(ios.width() == 0);
6829 }
6830 }
6831 ios.imbue(lg);
6832 {
6833 ios.width(0);
6834 {
6835 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6836 std::string ex(str, iter.base());
6837 assert(ex == "+1;e+09");
6838 assert(ios.width() == 0);
6839 }
6840 ios.width(25);
6841 left(ios);
6842 {
6843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6844 std::string ex(str, iter.base());
6845 assert(ex == "+1;e+09******************");
6846 assert(ios.width() == 0);
6847 }
6848 ios.width(25);
6849 right(ios);
6850 {
6851 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6852 std::string ex(str, iter.base());
6853 assert(ex == "******************+1;e+09");
6854 assert(ios.width() == 0);
6855 }
6856 ios.width(25);
6857 internal(ios);
6858 {
6859 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6860 std::string ex(str, iter.base());
6861 assert(ex == "+******************1;e+09");
6862 assert(ios.width() == 0);
6863 }
6864 }
6865 }
6866 }
6867 }
6868 uppercase(ios);
6869 {
6870 noshowpos(ios);
6871 {
6872 noshowpoint(ios);
6873 {
6874 ios.imbue(lc);
6875 {
6876 ios.width(0);
6877 {
6878 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6879 std::string ex(str, iter.base());
6880 assert(ex == "1E+09");
6881 assert(ios.width() == 0);
6882 }
6883 ios.width(25);
6884 left(ios);
6885 {
6886 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6887 std::string ex(str, iter.base());
6888 assert(ex == "1E+09********************");
6889 assert(ios.width() == 0);
6890 }
6891 ios.width(25);
6892 right(ios);
6893 {
6894 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6895 std::string ex(str, iter.base());
6896 assert(ex == "********************1E+09");
6897 assert(ios.width() == 0);
6898 }
6899 ios.width(25);
6900 internal(ios);
6901 {
6902 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6903 std::string ex(str, iter.base());
6904 assert(ex == "********************1E+09");
6905 assert(ios.width() == 0);
6906 }
6907 }
6908 ios.imbue(lg);
6909 {
6910 ios.width(0);
6911 {
6912 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6913 std::string ex(str, iter.base());
6914 assert(ex == "1E+09");
6915 assert(ios.width() == 0);
6916 }
6917 ios.width(25);
6918 left(ios);
6919 {
6920 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6921 std::string ex(str, iter.base());
6922 assert(ex == "1E+09********************");
6923 assert(ios.width() == 0);
6924 }
6925 ios.width(25);
6926 right(ios);
6927 {
6928 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6929 std::string ex(str, iter.base());
6930 assert(ex == "********************1E+09");
6931 assert(ios.width() == 0);
6932 }
6933 ios.width(25);
6934 internal(ios);
6935 {
6936 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6937 std::string ex(str, iter.base());
6938 assert(ex == "********************1E+09");
6939 assert(ios.width() == 0);
6940 }
6941 }
6942 }
6943 showpoint(ios);
6944 {
6945 ios.imbue(lc);
6946 {
6947 ios.width(0);
6948 {
6949 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6950 std::string ex(str, iter.base());
6951 assert(ex == "1.E+09");
6952 assert(ios.width() == 0);
6953 }
6954 ios.width(25);
6955 left(ios);
6956 {
6957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6958 std::string ex(str, iter.base());
6959 assert(ex == "1.E+09*******************");
6960 assert(ios.width() == 0);
6961 }
6962 ios.width(25);
6963 right(ios);
6964 {
6965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6966 std::string ex(str, iter.base());
6967 assert(ex == "*******************1.E+09");
6968 assert(ios.width() == 0);
6969 }
6970 ios.width(25);
6971 internal(ios);
6972 {
6973 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6974 std::string ex(str, iter.base());
6975 assert(ex == "*******************1.E+09");
6976 assert(ios.width() == 0);
6977 }
6978 }
6979 ios.imbue(lg);
6980 {
6981 ios.width(0);
6982 {
6983 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6984 std::string ex(str, iter.base());
6985 assert(ex == "1;E+09");
6986 assert(ios.width() == 0);
6987 }
6988 ios.width(25);
6989 left(ios);
6990 {
6991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6992 std::string ex(str, iter.base());
6993 assert(ex == "1;E+09*******************");
6994 assert(ios.width() == 0);
6995 }
6996 ios.width(25);
6997 right(ios);
6998 {
6999 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7000 std::string ex(str, iter.base());
7001 assert(ex == "*******************1;E+09");
7002 assert(ios.width() == 0);
7003 }
7004 ios.width(25);
7005 internal(ios);
7006 {
7007 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7008 std::string ex(str, iter.base());
7009 assert(ex == "*******************1;E+09");
7010 assert(ios.width() == 0);
7011 }
7012 }
7013 }
7014 }
7015 showpos(ios);
7016 {
7017 noshowpoint(ios);
7018 {
7019 ios.imbue(lc);
7020 {
7021 ios.width(0);
7022 {
7023 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7024 std::string ex(str, iter.base());
7025 assert(ex == "+1E+09");
7026 assert(ios.width() == 0);
7027 }
7028 ios.width(25);
7029 left(ios);
7030 {
7031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7032 std::string ex(str, iter.base());
7033 assert(ex == "+1E+09*******************");
7034 assert(ios.width() == 0);
7035 }
7036 ios.width(25);
7037 right(ios);
7038 {
7039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7040 std::string ex(str, iter.base());
7041 assert(ex == "*******************+1E+09");
7042 assert(ios.width() == 0);
7043 }
7044 ios.width(25);
7045 internal(ios);
7046 {
7047 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7048 std::string ex(str, iter.base());
7049 assert(ex == "+*******************1E+09");
7050 assert(ios.width() == 0);
7051 }
7052 }
7053 ios.imbue(lg);
7054 {
7055 ios.width(0);
7056 {
7057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7058 std::string ex(str, iter.base());
7059 assert(ex == "+1E+09");
7060 assert(ios.width() == 0);
7061 }
7062 ios.width(25);
7063 left(ios);
7064 {
7065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7066 std::string ex(str, iter.base());
7067 assert(ex == "+1E+09*******************");
7068 assert(ios.width() == 0);
7069 }
7070 ios.width(25);
7071 right(ios);
7072 {
7073 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7074 std::string ex(str, iter.base());
7075 assert(ex == "*******************+1E+09");
7076 assert(ios.width() == 0);
7077 }
7078 ios.width(25);
7079 internal(ios);
7080 {
7081 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7082 std::string ex(str, iter.base());
7083 assert(ex == "+*******************1E+09");
7084 assert(ios.width() == 0);
7085 }
7086 }
7087 }
7088 showpoint(ios);
7089 {
7090 ios.imbue(lc);
7091 {
7092 ios.width(0);
7093 {
7094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7095 std::string ex(str, iter.base());
7096 assert(ex == "+1.E+09");
7097 assert(ios.width() == 0);
7098 }
7099 ios.width(25);
7100 left(ios);
7101 {
7102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7103 std::string ex(str, iter.base());
7104 assert(ex == "+1.E+09******************");
7105 assert(ios.width() == 0);
7106 }
7107 ios.width(25);
7108 right(ios);
7109 {
7110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7111 std::string ex(str, iter.base());
7112 assert(ex == "******************+1.E+09");
7113 assert(ios.width() == 0);
7114 }
7115 ios.width(25);
7116 internal(ios);
7117 {
7118 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7119 std::string ex(str, iter.base());
7120 assert(ex == "+******************1.E+09");
7121 assert(ios.width() == 0);
7122 }
7123 }
7124 ios.imbue(lg);
7125 {
7126 ios.width(0);
7127 {
7128 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7129 std::string ex(str, iter.base());
7130 assert(ex == "+1;E+09");
7131 assert(ios.width() == 0);
7132 }
7133 ios.width(25);
7134 left(ios);
7135 {
7136 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7137 std::string ex(str, iter.base());
7138 assert(ex == "+1;E+09******************");
7139 assert(ios.width() == 0);
7140 }
7141 ios.width(25);
7142 right(ios);
7143 {
7144 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7145 std::string ex(str, iter.base());
7146 assert(ex == "******************+1;E+09");
7147 assert(ios.width() == 0);
7148 }
7149 ios.width(25);
7150 internal(ios);
7151 {
7152 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7153 std::string ex(str, iter.base());
7154 assert(ex == "+******************1;E+09");
7155 assert(ios.width() == 0);
7156 }
7157 }
7158 }
7159 }
7160 }
7161 }
7162 ios.precision(6);
7163 {
7164 nouppercase(ios);
7165 {
7166 noshowpos(ios);
7167 {
7168 noshowpoint(ios);
7169 {
7170 ios.imbue(lc);
7171 {
7172 ios.width(0);
7173 {
7174 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7175 std::string ex(str, iter.base());
7176 assert(ex == "1.23457e+09");
7177 assert(ios.width() == 0);
7178 }
7179 ios.width(25);
7180 left(ios);
7181 {
7182 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7183 std::string ex(str, iter.base());
7184 assert(ex == "1.23457e+09**************");
7185 assert(ios.width() == 0);
7186 }
7187 ios.width(25);
7188 right(ios);
7189 {
7190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7191 std::string ex(str, iter.base());
7192 assert(ex == "**************1.23457e+09");
7193 assert(ios.width() == 0);
7194 }
7195 ios.width(25);
7196 internal(ios);
7197 {
7198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7199 std::string ex(str, iter.base());
7200 assert(ex == "**************1.23457e+09");
7201 assert(ios.width() == 0);
7202 }
7203 }
7204 ios.imbue(lg);
7205 {
7206 ios.width(0);
7207 {
7208 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7209 std::string ex(str, iter.base());
7210 assert(ex == "1;23457e+09");
7211 assert(ios.width() == 0);
7212 }
7213 ios.width(25);
7214 left(ios);
7215 {
7216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7217 std::string ex(str, iter.base());
7218 assert(ex == "1;23457e+09**************");
7219 assert(ios.width() == 0);
7220 }
7221 ios.width(25);
7222 right(ios);
7223 {
7224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7225 std::string ex(str, iter.base());
7226 assert(ex == "**************1;23457e+09");
7227 assert(ios.width() == 0);
7228 }
7229 ios.width(25);
7230 internal(ios);
7231 {
7232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7233 std::string ex(str, iter.base());
7234 assert(ex == "**************1;23457e+09");
7235 assert(ios.width() == 0);
7236 }
7237 }
7238 }
7239 showpoint(ios);
7240 {
7241 ios.imbue(lc);
7242 {
7243 ios.width(0);
7244 {
7245 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7246 std::string ex(str, iter.base());
7247 assert(ex == "1.23457e+09");
7248 assert(ios.width() == 0);
7249 }
7250 ios.width(25);
7251 left(ios);
7252 {
7253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7254 std::string ex(str, iter.base());
7255 assert(ex == "1.23457e+09**************");
7256 assert(ios.width() == 0);
7257 }
7258 ios.width(25);
7259 right(ios);
7260 {
7261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7262 std::string ex(str, iter.base());
7263 assert(ex == "**************1.23457e+09");
7264 assert(ios.width() == 0);
7265 }
7266 ios.width(25);
7267 internal(ios);
7268 {
7269 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7270 std::string ex(str, iter.base());
7271 assert(ex == "**************1.23457e+09");
7272 assert(ios.width() == 0);
7273 }
7274 }
7275 ios.imbue(lg);
7276 {
7277 ios.width(0);
7278 {
7279 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7280 std::string ex(str, iter.base());
7281 assert(ex == "1;23457e+09");
7282 assert(ios.width() == 0);
7283 }
7284 ios.width(25);
7285 left(ios);
7286 {
7287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7288 std::string ex(str, iter.base());
7289 assert(ex == "1;23457e+09**************");
7290 assert(ios.width() == 0);
7291 }
7292 ios.width(25);
7293 right(ios);
7294 {
7295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7296 std::string ex(str, iter.base());
7297 assert(ex == "**************1;23457e+09");
7298 assert(ios.width() == 0);
7299 }
7300 ios.width(25);
7301 internal(ios);
7302 {
7303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7304 std::string ex(str, iter.base());
7305 assert(ex == "**************1;23457e+09");
7306 assert(ios.width() == 0);
7307 }
7308 }
7309 }
7310 }
7311 showpos(ios);
7312 {
7313 noshowpoint(ios);
7314 {
7315 ios.imbue(lc);
7316 {
7317 ios.width(0);
7318 {
7319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7320 std::string ex(str, iter.base());
7321 assert(ex == "+1.23457e+09");
7322 assert(ios.width() == 0);
7323 }
7324 ios.width(25);
7325 left(ios);
7326 {
7327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7328 std::string ex(str, iter.base());
7329 assert(ex == "+1.23457e+09*************");
7330 assert(ios.width() == 0);
7331 }
7332 ios.width(25);
7333 right(ios);
7334 {
7335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7336 std::string ex(str, iter.base());
7337 assert(ex == "*************+1.23457e+09");
7338 assert(ios.width() == 0);
7339 }
7340 ios.width(25);
7341 internal(ios);
7342 {
7343 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7344 std::string ex(str, iter.base());
7345 assert(ex == "+*************1.23457e+09");
7346 assert(ios.width() == 0);
7347 }
7348 }
7349 ios.imbue(lg);
7350 {
7351 ios.width(0);
7352 {
7353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7354 std::string ex(str, iter.base());
7355 assert(ex == "+1;23457e+09");
7356 assert(ios.width() == 0);
7357 }
7358 ios.width(25);
7359 left(ios);
7360 {
7361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7362 std::string ex(str, iter.base());
7363 assert(ex == "+1;23457e+09*************");
7364 assert(ios.width() == 0);
7365 }
7366 ios.width(25);
7367 right(ios);
7368 {
7369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7370 std::string ex(str, iter.base());
7371 assert(ex == "*************+1;23457e+09");
7372 assert(ios.width() == 0);
7373 }
7374 ios.width(25);
7375 internal(ios);
7376 {
7377 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7378 std::string ex(str, iter.base());
7379 assert(ex == "+*************1;23457e+09");
7380 assert(ios.width() == 0);
7381 }
7382 }
7383 }
7384 showpoint(ios);
7385 {
7386 ios.imbue(lc);
7387 {
7388 ios.width(0);
7389 {
7390 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7391 std::string ex(str, iter.base());
7392 assert(ex == "+1.23457e+09");
7393 assert(ios.width() == 0);
7394 }
7395 ios.width(25);
7396 left(ios);
7397 {
7398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7399 std::string ex(str, iter.base());
7400 assert(ex == "+1.23457e+09*************");
7401 assert(ios.width() == 0);
7402 }
7403 ios.width(25);
7404 right(ios);
7405 {
7406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7407 std::string ex(str, iter.base());
7408 assert(ex == "*************+1.23457e+09");
7409 assert(ios.width() == 0);
7410 }
7411 ios.width(25);
7412 internal(ios);
7413 {
7414 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7415 std::string ex(str, iter.base());
7416 assert(ex == "+*************1.23457e+09");
7417 assert(ios.width() == 0);
7418 }
7419 }
7420 ios.imbue(lg);
7421 {
7422 ios.width(0);
7423 {
7424 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7425 std::string ex(str, iter.base());
7426 assert(ex == "+1;23457e+09");
7427 assert(ios.width() == 0);
7428 }
7429 ios.width(25);
7430 left(ios);
7431 {
7432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7433 std::string ex(str, iter.base());
7434 assert(ex == "+1;23457e+09*************");
7435 assert(ios.width() == 0);
7436 }
7437 ios.width(25);
7438 right(ios);
7439 {
7440 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7441 std::string ex(str, iter.base());
7442 assert(ex == "*************+1;23457e+09");
7443 assert(ios.width() == 0);
7444 }
7445 ios.width(25);
7446 internal(ios);
7447 {
7448 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7449 std::string ex(str, iter.base());
7450 assert(ex == "+*************1;23457e+09");
7451 assert(ios.width() == 0);
7452 }
7453 }
7454 }
7455 }
7456 }
7457 uppercase(ios);
7458 {
7459 noshowpos(ios);
7460 {
7461 noshowpoint(ios);
7462 {
7463 ios.imbue(lc);
7464 {
7465 ios.width(0);
7466 {
7467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7468 std::string ex(str, iter.base());
7469 assert(ex == "1.23457E+09");
7470 assert(ios.width() == 0);
7471 }
7472 ios.width(25);
7473 left(ios);
7474 {
7475 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7476 std::string ex(str, iter.base());
7477 assert(ex == "1.23457E+09**************");
7478 assert(ios.width() == 0);
7479 }
7480 ios.width(25);
7481 right(ios);
7482 {
7483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7484 std::string ex(str, iter.base());
7485 assert(ex == "**************1.23457E+09");
7486 assert(ios.width() == 0);
7487 }
7488 ios.width(25);
7489 internal(ios);
7490 {
7491 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7492 std::string ex(str, iter.base());
7493 assert(ex == "**************1.23457E+09");
7494 assert(ios.width() == 0);
7495 }
7496 }
7497 ios.imbue(lg);
7498 {
7499 ios.width(0);
7500 {
7501 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7502 std::string ex(str, iter.base());
7503 assert(ex == "1;23457E+09");
7504 assert(ios.width() == 0);
7505 }
7506 ios.width(25);
7507 left(ios);
7508 {
7509 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7510 std::string ex(str, iter.base());
7511 assert(ex == "1;23457E+09**************");
7512 assert(ios.width() == 0);
7513 }
7514 ios.width(25);
7515 right(ios);
7516 {
7517 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7518 std::string ex(str, iter.base());
7519 assert(ex == "**************1;23457E+09");
7520 assert(ios.width() == 0);
7521 }
7522 ios.width(25);
7523 internal(ios);
7524 {
7525 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7526 std::string ex(str, iter.base());
7527 assert(ex == "**************1;23457E+09");
7528 assert(ios.width() == 0);
7529 }
7530 }
7531 }
7532 showpoint(ios);
7533 {
7534 ios.imbue(lc);
7535 {
7536 ios.width(0);
7537 {
7538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7539 std::string ex(str, iter.base());
7540 assert(ex == "1.23457E+09");
7541 assert(ios.width() == 0);
7542 }
7543 ios.width(25);
7544 left(ios);
7545 {
7546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7547 std::string ex(str, iter.base());
7548 assert(ex == "1.23457E+09**************");
7549 assert(ios.width() == 0);
7550 }
7551 ios.width(25);
7552 right(ios);
7553 {
7554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7555 std::string ex(str, iter.base());
7556 assert(ex == "**************1.23457E+09");
7557 assert(ios.width() == 0);
7558 }
7559 ios.width(25);
7560 internal(ios);
7561 {
7562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7563 std::string ex(str, iter.base());
7564 assert(ex == "**************1.23457E+09");
7565 assert(ios.width() == 0);
7566 }
7567 }
7568 ios.imbue(lg);
7569 {
7570 ios.width(0);
7571 {
7572 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7573 std::string ex(str, iter.base());
7574 assert(ex == "1;23457E+09");
7575 assert(ios.width() == 0);
7576 }
7577 ios.width(25);
7578 left(ios);
7579 {
7580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7581 std::string ex(str, iter.base());
7582 assert(ex == "1;23457E+09**************");
7583 assert(ios.width() == 0);
7584 }
7585 ios.width(25);
7586 right(ios);
7587 {
7588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7589 std::string ex(str, iter.base());
7590 assert(ex == "**************1;23457E+09");
7591 assert(ios.width() == 0);
7592 }
7593 ios.width(25);
7594 internal(ios);
7595 {
7596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7597 std::string ex(str, iter.base());
7598 assert(ex == "**************1;23457E+09");
7599 assert(ios.width() == 0);
7600 }
7601 }
7602 }
7603 }
7604 showpos(ios);
7605 {
7606 noshowpoint(ios);
7607 {
7608 ios.imbue(lc);
7609 {
7610 ios.width(0);
7611 {
7612 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7613 std::string ex(str, iter.base());
7614 assert(ex == "+1.23457E+09");
7615 assert(ios.width() == 0);
7616 }
7617 ios.width(25);
7618 left(ios);
7619 {
7620 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7621 std::string ex(str, iter.base());
7622 assert(ex == "+1.23457E+09*************");
7623 assert(ios.width() == 0);
7624 }
7625 ios.width(25);
7626 right(ios);
7627 {
7628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7629 std::string ex(str, iter.base());
7630 assert(ex == "*************+1.23457E+09");
7631 assert(ios.width() == 0);
7632 }
7633 ios.width(25);
7634 internal(ios);
7635 {
7636 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7637 std::string ex(str, iter.base());
7638 assert(ex == "+*************1.23457E+09");
7639 assert(ios.width() == 0);
7640 }
7641 }
7642 ios.imbue(lg);
7643 {
7644 ios.width(0);
7645 {
7646 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7647 std::string ex(str, iter.base());
7648 assert(ex == "+1;23457E+09");
7649 assert(ios.width() == 0);
7650 }
7651 ios.width(25);
7652 left(ios);
7653 {
7654 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7655 std::string ex(str, iter.base());
7656 assert(ex == "+1;23457E+09*************");
7657 assert(ios.width() == 0);
7658 }
7659 ios.width(25);
7660 right(ios);
7661 {
7662 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7663 std::string ex(str, iter.base());
7664 assert(ex == "*************+1;23457E+09");
7665 assert(ios.width() == 0);
7666 }
7667 ios.width(25);
7668 internal(ios);
7669 {
7670 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7671 std::string ex(str, iter.base());
7672 assert(ex == "+*************1;23457E+09");
7673 assert(ios.width() == 0);
7674 }
7675 }
7676 }
7677 showpoint(ios);
7678 {
7679 ios.imbue(lc);
7680 {
7681 ios.width(0);
7682 {
7683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7684 std::string ex(str, iter.base());
7685 assert(ex == "+1.23457E+09");
7686 assert(ios.width() == 0);
7687 }
7688 ios.width(25);
7689 left(ios);
7690 {
7691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7692 std::string ex(str, iter.base());
7693 assert(ex == "+1.23457E+09*************");
7694 assert(ios.width() == 0);
7695 }
7696 ios.width(25);
7697 right(ios);
7698 {
7699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7700 std::string ex(str, iter.base());
7701 assert(ex == "*************+1.23457E+09");
7702 assert(ios.width() == 0);
7703 }
7704 ios.width(25);
7705 internal(ios);
7706 {
7707 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7708 std::string ex(str, iter.base());
7709 assert(ex == "+*************1.23457E+09");
7710 assert(ios.width() == 0);
7711 }
7712 }
7713 ios.imbue(lg);
7714 {
7715 ios.width(0);
7716 {
7717 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7718 std::string ex(str, iter.base());
7719 assert(ex == "+1;23457E+09");
7720 assert(ios.width() == 0);
7721 }
7722 ios.width(25);
7723 left(ios);
7724 {
7725 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7726 std::string ex(str, iter.base());
7727 assert(ex == "+1;23457E+09*************");
7728 assert(ios.width() == 0);
7729 }
7730 ios.width(25);
7731 right(ios);
7732 {
7733 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7734 std::string ex(str, iter.base());
7735 assert(ex == "*************+1;23457E+09");
7736 assert(ios.width() == 0);
7737 }
7738 ios.width(25);
7739 internal(ios);
7740 {
7741 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7742 std::string ex(str, iter.base());
7743 assert(ex == "+*************1;23457E+09");
7744 assert(ios.width() == 0);
7745 }
7746 }
7747 }
7748 }
7749 }
7750 }
7751 ios.precision(16);
7752 {
7753 nouppercase(ios);
7754 {
7755 noshowpos(ios);
7756 {
7757 noshowpoint(ios);
7758 {
7759 ios.imbue(lc);
7760 {
7761 ios.width(0);
7762 {
7763 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7764 std::string ex(str, iter.base());
7765 assert(ex == "1234567890.125");
7766 assert(ios.width() == 0);
7767 }
7768 ios.width(25);
7769 left(ios);
7770 {
7771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7772 std::string ex(str, iter.base());
7773 assert(ex == "1234567890.125***********");
7774 assert(ios.width() == 0);
7775 }
7776 ios.width(25);
7777 right(ios);
7778 {
7779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7780 std::string ex(str, iter.base());
7781 assert(ex == "***********1234567890.125");
7782 assert(ios.width() == 0);
7783 }
7784 ios.width(25);
7785 internal(ios);
7786 {
7787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7788 std::string ex(str, iter.base());
7789 assert(ex == "***********1234567890.125");
7790 assert(ios.width() == 0);
7791 }
7792 }
7793 ios.imbue(lg);
7794 {
7795 ios.width(0);
7796 {
7797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7798 std::string ex(str, iter.base());
7799 assert(ex == "1_234_567_89_0;125");
7800 assert(ios.width() == 0);
7801 }
7802 ios.width(25);
7803 left(ios);
7804 {
7805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7806 std::string ex(str, iter.base());
7807 assert(ex == "1_234_567_89_0;125*******");
7808 assert(ios.width() == 0);
7809 }
7810 ios.width(25);
7811 right(ios);
7812 {
7813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7814 std::string ex(str, iter.base());
7815 assert(ex == "*******1_234_567_89_0;125");
7816 assert(ios.width() == 0);
7817 }
7818 ios.width(25);
7819 internal(ios);
7820 {
7821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7822 std::string ex(str, iter.base());
7823 assert(ex == "*******1_234_567_89_0;125");
7824 assert(ios.width() == 0);
7825 }
7826 }
7827 }
7828 showpoint(ios);
7829 {
7830 ios.imbue(lc);
7831 {
7832 ios.width(0);
7833 {
7834 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7835 std::string ex(str, iter.base());
7836 assert(ex == "1234567890.125000");
7837 assert(ios.width() == 0);
7838 }
7839 ios.width(25);
7840 left(ios);
7841 {
7842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7843 std::string ex(str, iter.base());
7844 assert(ex == "1234567890.125000********");
7845 assert(ios.width() == 0);
7846 }
7847 ios.width(25);
7848 right(ios);
7849 {
7850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7851 std::string ex(str, iter.base());
7852 assert(ex == "********1234567890.125000");
7853 assert(ios.width() == 0);
7854 }
7855 ios.width(25);
7856 internal(ios);
7857 {
7858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7859 std::string ex(str, iter.base());
7860 assert(ex == "********1234567890.125000");
7861 assert(ios.width() == 0);
7862 }
7863 }
7864 ios.imbue(lg);
7865 {
7866 ios.width(0);
7867 {
7868 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7869 std::string ex(str, iter.base());
7870 assert(ex == "1_234_567_89_0;125000");
7871 assert(ios.width() == 0);
7872 }
7873 ios.width(25);
7874 left(ios);
7875 {
7876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7877 std::string ex(str, iter.base());
7878 assert(ex == "1_234_567_89_0;125000****");
7879 assert(ios.width() == 0);
7880 }
7881 ios.width(25);
7882 right(ios);
7883 {
7884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7885 std::string ex(str, iter.base());
7886 assert(ex == "****1_234_567_89_0;125000");
7887 assert(ios.width() == 0);
7888 }
7889 ios.width(25);
7890 internal(ios);
7891 {
7892 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7893 std::string ex(str, iter.base());
7894 assert(ex == "****1_234_567_89_0;125000");
7895 assert(ios.width() == 0);
7896 }
7897 }
7898 }
7899 }
7900 showpos(ios);
7901 {
7902 noshowpoint(ios);
7903 {
7904 ios.imbue(lc);
7905 {
7906 ios.width(0);
7907 {
7908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7909 std::string ex(str, iter.base());
7910 assert(ex == "+1234567890.125");
7911 assert(ios.width() == 0);
7912 }
7913 ios.width(25);
7914 left(ios);
7915 {
7916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7917 std::string ex(str, iter.base());
7918 assert(ex == "+1234567890.125**********");
7919 assert(ios.width() == 0);
7920 }
7921 ios.width(25);
7922 right(ios);
7923 {
7924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7925 std::string ex(str, iter.base());
7926 assert(ex == "**********+1234567890.125");
7927 assert(ios.width() == 0);
7928 }
7929 ios.width(25);
7930 internal(ios);
7931 {
7932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7933 std::string ex(str, iter.base());
7934 assert(ex == "+**********1234567890.125");
7935 assert(ios.width() == 0);
7936 }
7937 }
7938 ios.imbue(lg);
7939 {
7940 ios.width(0);
7941 {
7942 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7943 std::string ex(str, iter.base());
7944 assert(ex == "+1_234_567_89_0;125");
7945 assert(ios.width() == 0);
7946 }
7947 ios.width(25);
7948 left(ios);
7949 {
7950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7951 std::string ex(str, iter.base());
7952 assert(ex == "+1_234_567_89_0;125******");
7953 assert(ios.width() == 0);
7954 }
7955 ios.width(25);
7956 right(ios);
7957 {
7958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7959 std::string ex(str, iter.base());
7960 assert(ex == "******+1_234_567_89_0;125");
7961 assert(ios.width() == 0);
7962 }
7963 ios.width(25);
7964 internal(ios);
7965 {
7966 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7967 std::string ex(str, iter.base());
7968 assert(ex == "+******1_234_567_89_0;125");
7969 assert(ios.width() == 0);
7970 }
7971 }
7972 }
7973 showpoint(ios);
7974 {
7975 ios.imbue(lc);
7976 {
7977 ios.width(0);
7978 {
7979 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7980 std::string ex(str, iter.base());
7981 assert(ex == "+1234567890.125000");
7982 assert(ios.width() == 0);
7983 }
7984 ios.width(25);
7985 left(ios);
7986 {
7987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7988 std::string ex(str, iter.base());
7989 assert(ex == "+1234567890.125000*******");
7990 assert(ios.width() == 0);
7991 }
7992 ios.width(25);
7993 right(ios);
7994 {
7995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7996 std::string ex(str, iter.base());
7997 assert(ex == "*******+1234567890.125000");
7998 assert(ios.width() == 0);
7999 }
8000 ios.width(25);
8001 internal(ios);
8002 {
8003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8004 std::string ex(str, iter.base());
8005 assert(ex == "+*******1234567890.125000");
8006 assert(ios.width() == 0);
8007 }
8008 }
8009 ios.imbue(lg);
8010 {
8011 ios.width(0);
8012 {
8013 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8014 std::string ex(str, iter.base());
8015 assert(ex == "+1_234_567_89_0;125000");
8016 assert(ios.width() == 0);
8017 }
8018 ios.width(25);
8019 left(ios);
8020 {
8021 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8022 std::string ex(str, iter.base());
8023 assert(ex == "+1_234_567_89_0;125000***");
8024 assert(ios.width() == 0);
8025 }
8026 ios.width(25);
8027 right(ios);
8028 {
8029 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8030 std::string ex(str, iter.base());
8031 assert(ex == "***+1_234_567_89_0;125000");
8032 assert(ios.width() == 0);
8033 }
8034 ios.width(25);
8035 internal(ios);
8036 {
8037 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8038 std::string ex(str, iter.base());
8039 assert(ex == "+***1_234_567_89_0;125000");
8040 assert(ios.width() == 0);
8041 }
8042 }
8043 }
8044 }
8045 }
8046 uppercase(ios);
8047 {
8048 noshowpos(ios);
8049 {
8050 noshowpoint(ios);
8051 {
8052 ios.imbue(lc);
8053 {
8054 ios.width(0);
8055 {
8056 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8057 std::string ex(str, iter.base());
8058 assert(ex == "1234567890.125");
8059 assert(ios.width() == 0);
8060 }
8061 ios.width(25);
8062 left(ios);
8063 {
8064 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8065 std::string ex(str, iter.base());
8066 assert(ex == "1234567890.125***********");
8067 assert(ios.width() == 0);
8068 }
8069 ios.width(25);
8070 right(ios);
8071 {
8072 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8073 std::string ex(str, iter.base());
8074 assert(ex == "***********1234567890.125");
8075 assert(ios.width() == 0);
8076 }
8077 ios.width(25);
8078 internal(ios);
8079 {
8080 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8081 std::string ex(str, iter.base());
8082 assert(ex == "***********1234567890.125");
8083 assert(ios.width() == 0);
8084 }
8085 }
8086 ios.imbue(lg);
8087 {
8088 ios.width(0);
8089 {
8090 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8091 std::string ex(str, iter.base());
8092 assert(ex == "1_234_567_89_0;125");
8093 assert(ios.width() == 0);
8094 }
8095 ios.width(25);
8096 left(ios);
8097 {
8098 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8099 std::string ex(str, iter.base());
8100 assert(ex == "1_234_567_89_0;125*******");
8101 assert(ios.width() == 0);
8102 }
8103 ios.width(25);
8104 right(ios);
8105 {
8106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8107 std::string ex(str, iter.base());
8108 assert(ex == "*******1_234_567_89_0;125");
8109 assert(ios.width() == 0);
8110 }
8111 ios.width(25);
8112 internal(ios);
8113 {
8114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8115 std::string ex(str, iter.base());
8116 assert(ex == "*******1_234_567_89_0;125");
8117 assert(ios.width() == 0);
8118 }
8119 }
8120 }
8121 showpoint(ios);
8122 {
8123 ios.imbue(lc);
8124 {
8125 ios.width(0);
8126 {
8127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8128 std::string ex(str, iter.base());
8129 assert(ex == "1234567890.125000");
8130 assert(ios.width() == 0);
8131 }
8132 ios.width(25);
8133 left(ios);
8134 {
8135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8136 std::string ex(str, iter.base());
8137 assert(ex == "1234567890.125000********");
8138 assert(ios.width() == 0);
8139 }
8140 ios.width(25);
8141 right(ios);
8142 {
8143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8144 std::string ex(str, iter.base());
8145 assert(ex == "********1234567890.125000");
8146 assert(ios.width() == 0);
8147 }
8148 ios.width(25);
8149 internal(ios);
8150 {
8151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8152 std::string ex(str, iter.base());
8153 assert(ex == "********1234567890.125000");
8154 assert(ios.width() == 0);
8155 }
8156 }
8157 ios.imbue(lg);
8158 {
8159 ios.width(0);
8160 {
8161 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8162 std::string ex(str, iter.base());
8163 assert(ex == "1_234_567_89_0;125000");
8164 assert(ios.width() == 0);
8165 }
8166 ios.width(25);
8167 left(ios);
8168 {
8169 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8170 std::string ex(str, iter.base());
8171 assert(ex == "1_234_567_89_0;125000****");
8172 assert(ios.width() == 0);
8173 }
8174 ios.width(25);
8175 right(ios);
8176 {
8177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8178 std::string ex(str, iter.base());
8179 assert(ex == "****1_234_567_89_0;125000");
8180 assert(ios.width() == 0);
8181 }
8182 ios.width(25);
8183 internal(ios);
8184 {
8185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8186 std::string ex(str, iter.base());
8187 assert(ex == "****1_234_567_89_0;125000");
8188 assert(ios.width() == 0);
8189 }
8190 }
8191 }
8192 }
8193 showpos(ios);
8194 {
8195 noshowpoint(ios);
8196 {
8197 ios.imbue(lc);
8198 {
8199 ios.width(0);
8200 {
8201 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8202 std::string ex(str, iter.base());
8203 assert(ex == "+1234567890.125");
8204 assert(ios.width() == 0);
8205 }
8206 ios.width(25);
8207 left(ios);
8208 {
8209 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8210 std::string ex(str, iter.base());
8211 assert(ex == "+1234567890.125**********");
8212 assert(ios.width() == 0);
8213 }
8214 ios.width(25);
8215 right(ios);
8216 {
8217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8218 std::string ex(str, iter.base());
8219 assert(ex == "**********+1234567890.125");
8220 assert(ios.width() == 0);
8221 }
8222 ios.width(25);
8223 internal(ios);
8224 {
8225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8226 std::string ex(str, iter.base());
8227 assert(ex == "+**********1234567890.125");
8228 assert(ios.width() == 0);
8229 }
8230 }
8231 ios.imbue(lg);
8232 {
8233 ios.width(0);
8234 {
8235 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8236 std::string ex(str, iter.base());
8237 assert(ex == "+1_234_567_89_0;125");
8238 assert(ios.width() == 0);
8239 }
8240 ios.width(25);
8241 left(ios);
8242 {
8243 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8244 std::string ex(str, iter.base());
8245 assert(ex == "+1_234_567_89_0;125******");
8246 assert(ios.width() == 0);
8247 }
8248 ios.width(25);
8249 right(ios);
8250 {
8251 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8252 std::string ex(str, iter.base());
8253 assert(ex == "******+1_234_567_89_0;125");
8254 assert(ios.width() == 0);
8255 }
8256 ios.width(25);
8257 internal(ios);
8258 {
8259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8260 std::string ex(str, iter.base());
8261 assert(ex == "+******1_234_567_89_0;125");
8262 assert(ios.width() == 0);
8263 }
8264 }
8265 }
8266 showpoint(ios);
8267 {
8268 ios.imbue(lc);
8269 {
8270 ios.width(0);
8271 {
8272 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8273 std::string ex(str, iter.base());
8274 assert(ex == "+1234567890.125000");
8275 assert(ios.width() == 0);
8276 }
8277 ios.width(25);
8278 left(ios);
8279 {
8280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8281 std::string ex(str, iter.base());
8282 assert(ex == "+1234567890.125000*******");
8283 assert(ios.width() == 0);
8284 }
8285 ios.width(25);
8286 right(ios);
8287 {
8288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8289 std::string ex(str, iter.base());
8290 assert(ex == "*******+1234567890.125000");
8291 assert(ios.width() == 0);
8292 }
8293 ios.width(25);
8294 internal(ios);
8295 {
8296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8297 std::string ex(str, iter.base());
8298 assert(ex == "+*******1234567890.125000");
8299 assert(ios.width() == 0);
8300 }
8301 }
8302 ios.imbue(lg);
8303 {
8304 ios.width(0);
8305 {
8306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8307 std::string ex(str, iter.base());
8308 assert(ex == "+1_234_567_89_0;125000");
8309 assert(ios.width() == 0);
8310 }
8311 ios.width(25);
8312 left(ios);
8313 {
8314 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8315 std::string ex(str, iter.base());
8316 assert(ex == "+1_234_567_89_0;125000***");
8317 assert(ios.width() == 0);
8318 }
8319 ios.width(25);
8320 right(ios);
8321 {
8322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8323 std::string ex(str, iter.base());
8324 assert(ex == "***+1_234_567_89_0;125000");
8325 assert(ios.width() == 0);
8326 }
8327 ios.width(25);
8328 internal(ios);
8329 {
8330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8331 std::string ex(str, iter.base());
8332 assert(ex == "+***1_234_567_89_0;125000");
8333 assert(ios.width() == 0);
8334 }
8335 }
8336 }
8337 }
8338 }
8339 }
8340 ios.precision(60);
8341 {
8342 nouppercase(ios);
8343 {
8344 noshowpos(ios);
8345 {
8346 noshowpoint(ios);
8347 {
8348 ios.imbue(lc);
8349 {
8350 ios.width(0);
8351 {
8352 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8353 std::string ex(str, iter.base());
8354 assert(ex == "1234567890.125");
8355 assert(ios.width() == 0);
8356 }
8357 ios.width(25);
8358 left(ios);
8359 {
8360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8361 std::string ex(str, iter.base());
8362 assert(ex == "1234567890.125***********");
8363 assert(ios.width() == 0);
8364 }
8365 ios.width(25);
8366 right(ios);
8367 {
8368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8369 std::string ex(str, iter.base());
8370 assert(ex == "***********1234567890.125");
8371 assert(ios.width() == 0);
8372 }
8373 ios.width(25);
8374 internal(ios);
8375 {
8376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8377 std::string ex(str, iter.base());
8378 assert(ex == "***********1234567890.125");
8379 assert(ios.width() == 0);
8380 }
8381 }
8382 ios.imbue(lg);
8383 {
8384 ios.width(0);
8385 {
8386 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8387 std::string ex(str, iter.base());
8388 assert(ex == "1_234_567_89_0;125");
8389 assert(ios.width() == 0);
8390 }
8391 ios.width(25);
8392 left(ios);
8393 {
8394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8395 std::string ex(str, iter.base());
8396 assert(ex == "1_234_567_89_0;125*******");
8397 assert(ios.width() == 0);
8398 }
8399 ios.width(25);
8400 right(ios);
8401 {
8402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8403 std::string ex(str, iter.base());
8404 assert(ex == "*******1_234_567_89_0;125");
8405 assert(ios.width() == 0);
8406 }
8407 ios.width(25);
8408 internal(ios);
8409 {
8410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8411 std::string ex(str, iter.base());
8412 assert(ex == "*******1_234_567_89_0;125");
8413 assert(ios.width() == 0);
8414 }
8415 }
8416 }
8417 showpoint(ios);
8418 {
8419 ios.imbue(lc);
8420 {
8421 ios.width(0);
8422 {
8423 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8424 std::string ex(str, iter.base());
8425 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8426 assert(ios.width() == 0);
8427 }
8428 ios.width(25);
8429 left(ios);
8430 {
8431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8432 std::string ex(str, iter.base());
8433 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8434 assert(ios.width() == 0);
8435 }
8436 ios.width(25);
8437 right(ios);
8438 {
8439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8440 std::string ex(str, iter.base());
8441 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8442 assert(ios.width() == 0);
8443 }
8444 ios.width(25);
8445 internal(ios);
8446 {
8447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8448 std::string ex(str, iter.base());
8449 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8450 assert(ios.width() == 0);
8451 }
8452 }
8453 ios.imbue(lg);
8454 {
8455 ios.width(0);
8456 {
8457 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8458 std::string ex(str, iter.base());
8459 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8460 assert(ios.width() == 0);
8461 }
8462 ios.width(25);
8463 left(ios);
8464 {
8465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8466 std::string ex(str, iter.base());
8467 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8468 assert(ios.width() == 0);
8469 }
8470 ios.width(25);
8471 right(ios);
8472 {
8473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8474 std::string ex(str, iter.base());
8475 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8476 assert(ios.width() == 0);
8477 }
8478 ios.width(25);
8479 internal(ios);
8480 {
8481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8482 std::string ex(str, iter.base());
8483 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8484 assert(ios.width() == 0);
8485 }
8486 }
8487 }
8488 }
8489 showpos(ios);
8490 {
8491 noshowpoint(ios);
8492 {
8493 ios.imbue(lc);
8494 {
8495 ios.width(0);
8496 {
8497 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8498 std::string ex(str, iter.base());
8499 assert(ex == "+1234567890.125");
8500 assert(ios.width() == 0);
8501 }
8502 ios.width(25);
8503 left(ios);
8504 {
8505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8506 std::string ex(str, iter.base());
8507 assert(ex == "+1234567890.125**********");
8508 assert(ios.width() == 0);
8509 }
8510 ios.width(25);
8511 right(ios);
8512 {
8513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8514 std::string ex(str, iter.base());
8515 assert(ex == "**********+1234567890.125");
8516 assert(ios.width() == 0);
8517 }
8518 ios.width(25);
8519 internal(ios);
8520 {
8521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8522 std::string ex(str, iter.base());
8523 assert(ex == "+**********1234567890.125");
8524 assert(ios.width() == 0);
8525 }
8526 }
8527 ios.imbue(lg);
8528 {
8529 ios.width(0);
8530 {
8531 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8532 std::string ex(str, iter.base());
8533 assert(ex == "+1_234_567_89_0;125");
8534 assert(ios.width() == 0);
8535 }
8536 ios.width(25);
8537 left(ios);
8538 {
8539 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8540 std::string ex(str, iter.base());
8541 assert(ex == "+1_234_567_89_0;125******");
8542 assert(ios.width() == 0);
8543 }
8544 ios.width(25);
8545 right(ios);
8546 {
8547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8548 std::string ex(str, iter.base());
8549 assert(ex == "******+1_234_567_89_0;125");
8550 assert(ios.width() == 0);
8551 }
8552 ios.width(25);
8553 internal(ios);
8554 {
8555 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8556 std::string ex(str, iter.base());
8557 assert(ex == "+******1_234_567_89_0;125");
8558 assert(ios.width() == 0);
8559 }
8560 }
8561 }
8562 showpoint(ios);
8563 {
8564 ios.imbue(lc);
8565 {
8566 ios.width(0);
8567 {
8568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8569 std::string ex(str, iter.base());
8570 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8571 assert(ios.width() == 0);
8572 }
8573 ios.width(25);
8574 left(ios);
8575 {
8576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8577 std::string ex(str, iter.base());
8578 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8579 assert(ios.width() == 0);
8580 }
8581 ios.width(25);
8582 right(ios);
8583 {
8584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8585 std::string ex(str, iter.base());
8586 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8587 assert(ios.width() == 0);
8588 }
8589 ios.width(25);
8590 internal(ios);
8591 {
8592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8593 std::string ex(str, iter.base());
8594 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8595 assert(ios.width() == 0);
8596 }
8597 }
8598 ios.imbue(lg);
8599 {
8600 ios.width(0);
8601 {
8602 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8603 std::string ex(str, iter.base());
8604 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8605 assert(ios.width() == 0);
8606 }
8607 ios.width(25);
8608 left(ios);
8609 {
8610 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8611 std::string ex(str, iter.base());
8612 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8613 assert(ios.width() == 0);
8614 }
8615 ios.width(25);
8616 right(ios);
8617 {
8618 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8619 std::string ex(str, iter.base());
8620 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8621 assert(ios.width() == 0);
8622 }
8623 ios.width(25);
8624 internal(ios);
8625 {
8626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8627 std::string ex(str, iter.base());
8628 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8629 assert(ios.width() == 0);
8630 }
8631 }
8632 }
8633 }
8634 }
8635 uppercase(ios);
8636 {
8637 noshowpos(ios);
8638 {
8639 noshowpoint(ios);
8640 {
8641 ios.imbue(lc);
8642 {
8643 ios.width(0);
8644 {
8645 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8646 std::string ex(str, iter.base());
8647 assert(ex == "1234567890.125");
8648 assert(ios.width() == 0);
8649 }
8650 ios.width(25);
8651 left(ios);
8652 {
8653 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8654 std::string ex(str, iter.base());
8655 assert(ex == "1234567890.125***********");
8656 assert(ios.width() == 0);
8657 }
8658 ios.width(25);
8659 right(ios);
8660 {
8661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8662 std::string ex(str, iter.base());
8663 assert(ex == "***********1234567890.125");
8664 assert(ios.width() == 0);
8665 }
8666 ios.width(25);
8667 internal(ios);
8668 {
8669 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8670 std::string ex(str, iter.base());
8671 assert(ex == "***********1234567890.125");
8672 assert(ios.width() == 0);
8673 }
8674 }
8675 ios.imbue(lg);
8676 {
8677 ios.width(0);
8678 {
8679 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8680 std::string ex(str, iter.base());
8681 assert(ex == "1_234_567_89_0;125");
8682 assert(ios.width() == 0);
8683 }
8684 ios.width(25);
8685 left(ios);
8686 {
8687 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8688 std::string ex(str, iter.base());
8689 assert(ex == "1_234_567_89_0;125*******");
8690 assert(ios.width() == 0);
8691 }
8692 ios.width(25);
8693 right(ios);
8694 {
8695 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8696 std::string ex(str, iter.base());
8697 assert(ex == "*******1_234_567_89_0;125");
8698 assert(ios.width() == 0);
8699 }
8700 ios.width(25);
8701 internal(ios);
8702 {
8703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8704 std::string ex(str, iter.base());
8705 assert(ex == "*******1_234_567_89_0;125");
8706 assert(ios.width() == 0);
8707 }
8708 }
8709 }
8710 showpoint(ios);
8711 {
8712 ios.imbue(lc);
8713 {
8714 ios.width(0);
8715 {
8716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8717 std::string ex(str, iter.base());
8718 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8719 assert(ios.width() == 0);
8720 }
8721 ios.width(25);
8722 left(ios);
8723 {
8724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8725 std::string ex(str, iter.base());
8726 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8727 assert(ios.width() == 0);
8728 }
8729 ios.width(25);
8730 right(ios);
8731 {
8732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8733 std::string ex(str, iter.base());
8734 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8735 assert(ios.width() == 0);
8736 }
8737 ios.width(25);
8738 internal(ios);
8739 {
8740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8741 std::string ex(str, iter.base());
8742 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8743 assert(ios.width() == 0);
8744 }
8745 }
8746 ios.imbue(lg);
8747 {
8748 ios.width(0);
8749 {
8750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8751 std::string ex(str, iter.base());
8752 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8753 assert(ios.width() == 0);
8754 }
8755 ios.width(25);
8756 left(ios);
8757 {
8758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8759 std::string ex(str, iter.base());
8760 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8761 assert(ios.width() == 0);
8762 }
8763 ios.width(25);
8764 right(ios);
8765 {
8766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8767 std::string ex(str, iter.base());
8768 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8769 assert(ios.width() == 0);
8770 }
8771 ios.width(25);
8772 internal(ios);
8773 {
8774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8775 std::string ex(str, iter.base());
8776 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8777 assert(ios.width() == 0);
8778 }
8779 }
8780 }
8781 }
8782 showpos(ios);
8783 {
8784 noshowpoint(ios);
8785 {
8786 ios.imbue(lc);
8787 {
8788 ios.width(0);
8789 {
8790 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8791 std::string ex(str, iter.base());
8792 assert(ex == "+1234567890.125");
8793 assert(ios.width() == 0);
8794 }
8795 ios.width(25);
8796 left(ios);
8797 {
8798 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8799 std::string ex(str, iter.base());
8800 assert(ex == "+1234567890.125**********");
8801 assert(ios.width() == 0);
8802 }
8803 ios.width(25);
8804 right(ios);
8805 {
8806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8807 std::string ex(str, iter.base());
8808 assert(ex == "**********+1234567890.125");
8809 assert(ios.width() == 0);
8810 }
8811 ios.width(25);
8812 internal(ios);
8813 {
8814 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8815 std::string ex(str, iter.base());
8816 assert(ex == "+**********1234567890.125");
8817 assert(ios.width() == 0);
8818 }
8819 }
8820 ios.imbue(lg);
8821 {
8822 ios.width(0);
8823 {
8824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8825 std::string ex(str, iter.base());
8826 assert(ex == "+1_234_567_89_0;125");
8827 assert(ios.width() == 0);
8828 }
8829 ios.width(25);
8830 left(ios);
8831 {
8832 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8833 std::string ex(str, iter.base());
8834 assert(ex == "+1_234_567_89_0;125******");
8835 assert(ios.width() == 0);
8836 }
8837 ios.width(25);
8838 right(ios);
8839 {
8840 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8841 std::string ex(str, iter.base());
8842 assert(ex == "******+1_234_567_89_0;125");
8843 assert(ios.width() == 0);
8844 }
8845 ios.width(25);
8846 internal(ios);
8847 {
8848 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8849 std::string ex(str, iter.base());
8850 assert(ex == "+******1_234_567_89_0;125");
8851 assert(ios.width() == 0);
8852 }
8853 }
8854 }
8855 showpoint(ios);
8856 {
8857 ios.imbue(lc);
8858 {
8859 ios.width(0);
8860 {
8861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8862 std::string ex(str, iter.base());
8863 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8864 assert(ios.width() == 0);
8865 }
8866 ios.width(25);
8867 left(ios);
8868 {
8869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8870 std::string ex(str, iter.base());
8871 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8872 assert(ios.width() == 0);
8873 }
8874 ios.width(25);
8875 right(ios);
8876 {
8877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8878 std::string ex(str, iter.base());
8879 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8880 assert(ios.width() == 0);
8881 }
8882 ios.width(25);
8883 internal(ios);
8884 {
8885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8886 std::string ex(str, iter.base());
8887 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8888 assert(ios.width() == 0);
8889 }
8890 }
8891 ios.imbue(lg);
8892 {
8893 ios.width(0);
8894 {
8895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8896 std::string ex(str, iter.base());
8897 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8898 assert(ios.width() == 0);
8899 }
8900 ios.width(25);
8901 left(ios);
8902 {
8903 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8904 std::string ex(str, iter.base());
8905 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8906 assert(ios.width() == 0);
8907 }
8908 ios.width(25);
8909 right(ios);
8910 {
8911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8912 std::string ex(str, iter.base());
8913 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8914 assert(ios.width() == 0);
8915 }
8916 ios.width(25);
8917 internal(ios);
8918 {
8919 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8920 std::string ex(str, iter.base());
8921 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8922 assert(ios.width() == 0);
8923 }
8924 }
8925 }
8926 }
8927 }
8928 }
8929 }
8930 }
8931 }
8932
test4()8933 void test4()
8934 {
8935 char str[200];
8936 output_iterator<char*> iter;
8937 std::locale lc = std::locale::classic();
8938 std::locale lg(lc, new my_numpunct);
8939 const my_facet f(1);
8940 {
8941 long double v = -INFINITY;
8942 std::ios ios(0);
8943 // %g
8944 {
8945 ios.precision(0);
8946 {
8947 nouppercase(ios);
8948 {
8949 noshowpos(ios);
8950 {
8951 noshowpoint(ios);
8952 {
8953 ios.imbue(lc);
8954 {
8955 ios.width(0);
8956 {
8957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8958 std::string ex(str, iter.base());
8959 assert(ex == "-inf");
8960 assert(ios.width() == 0);
8961 }
8962 ios.width(25);
8963 left(ios);
8964 {
8965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8966 std::string ex(str, iter.base());
8967 assert(ex == "-inf*********************");
8968 assert(ios.width() == 0);
8969 }
8970 ios.width(25);
8971 right(ios);
8972 {
8973 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8974 std::string ex(str, iter.base());
8975 assert(ex == "*********************-inf");
8976 assert(ios.width() == 0);
8977 }
8978 ios.width(25);
8979 internal(ios);
8980 {
8981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8982 std::string ex(str, iter.base());
8983 assert(ex == "-*********************inf");
8984 assert(ios.width() == 0);
8985 }
8986 }
8987 ios.imbue(lg);
8988 {
8989 ios.width(0);
8990 {
8991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8992 std::string ex(str, iter.base());
8993 assert(ex == "-inf");
8994 assert(ios.width() == 0);
8995 }
8996 ios.width(25);
8997 left(ios);
8998 {
8999 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9000 std::string ex(str, iter.base());
9001 assert(ex == "-inf*********************");
9002 assert(ios.width() == 0);
9003 }
9004 ios.width(25);
9005 right(ios);
9006 {
9007 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9008 std::string ex(str, iter.base());
9009 assert(ex == "*********************-inf");
9010 assert(ios.width() == 0);
9011 }
9012 ios.width(25);
9013 internal(ios);
9014 {
9015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9016 std::string ex(str, iter.base());
9017 assert(ex == "-*********************inf");
9018 assert(ios.width() == 0);
9019 }
9020 }
9021 }
9022 showpoint(ios);
9023 {
9024 ios.imbue(lc);
9025 {
9026 ios.width(0);
9027 {
9028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9029 std::string ex(str, iter.base());
9030 assert(ex == "-inf");
9031 assert(ios.width() == 0);
9032 }
9033 ios.width(25);
9034 left(ios);
9035 {
9036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9037 std::string ex(str, iter.base());
9038 assert(ex == "-inf*********************");
9039 assert(ios.width() == 0);
9040 }
9041 ios.width(25);
9042 right(ios);
9043 {
9044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9045 std::string ex(str, iter.base());
9046 assert(ex == "*********************-inf");
9047 assert(ios.width() == 0);
9048 }
9049 ios.width(25);
9050 internal(ios);
9051 {
9052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9053 std::string ex(str, iter.base());
9054 assert(ex == "-*********************inf");
9055 assert(ios.width() == 0);
9056 }
9057 }
9058 ios.imbue(lg);
9059 {
9060 ios.width(0);
9061 {
9062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9063 std::string ex(str, iter.base());
9064 assert(ex == "-inf");
9065 assert(ios.width() == 0);
9066 }
9067 ios.width(25);
9068 left(ios);
9069 {
9070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9071 std::string ex(str, iter.base());
9072 assert(ex == "-inf*********************");
9073 assert(ios.width() == 0);
9074 }
9075 ios.width(25);
9076 right(ios);
9077 {
9078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9079 std::string ex(str, iter.base());
9080 assert(ex == "*********************-inf");
9081 assert(ios.width() == 0);
9082 }
9083 ios.width(25);
9084 internal(ios);
9085 {
9086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9087 std::string ex(str, iter.base());
9088 assert(ex == "-*********************inf");
9089 assert(ios.width() == 0);
9090 }
9091 }
9092 }
9093 }
9094 showpos(ios);
9095 {
9096 noshowpoint(ios);
9097 {
9098 ios.imbue(lc);
9099 {
9100 ios.width(0);
9101 {
9102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9103 std::string ex(str, iter.base());
9104 assert(ex == "-inf");
9105 assert(ios.width() == 0);
9106 }
9107 ios.width(25);
9108 left(ios);
9109 {
9110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9111 std::string ex(str, iter.base());
9112 assert(ex == "-inf*********************");
9113 assert(ios.width() == 0);
9114 }
9115 ios.width(25);
9116 right(ios);
9117 {
9118 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9119 std::string ex(str, iter.base());
9120 assert(ex == "*********************-inf");
9121 assert(ios.width() == 0);
9122 }
9123 ios.width(25);
9124 internal(ios);
9125 {
9126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9127 std::string ex(str, iter.base());
9128 assert(ex == "-*********************inf");
9129 assert(ios.width() == 0);
9130 }
9131 }
9132 ios.imbue(lg);
9133 {
9134 ios.width(0);
9135 {
9136 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9137 std::string ex(str, iter.base());
9138 assert(ex == "-inf");
9139 assert(ios.width() == 0);
9140 }
9141 ios.width(25);
9142 left(ios);
9143 {
9144 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9145 std::string ex(str, iter.base());
9146 assert(ex == "-inf*********************");
9147 assert(ios.width() == 0);
9148 }
9149 ios.width(25);
9150 right(ios);
9151 {
9152 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9153 std::string ex(str, iter.base());
9154 assert(ex == "*********************-inf");
9155 assert(ios.width() == 0);
9156 }
9157 ios.width(25);
9158 internal(ios);
9159 {
9160 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9161 std::string ex(str, iter.base());
9162 assert(ex == "-*********************inf");
9163 assert(ios.width() == 0);
9164 }
9165 }
9166 }
9167 showpoint(ios);
9168 {
9169 ios.imbue(lc);
9170 {
9171 ios.width(0);
9172 {
9173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9174 std::string ex(str, iter.base());
9175 assert(ex == "-inf");
9176 assert(ios.width() == 0);
9177 }
9178 ios.width(25);
9179 left(ios);
9180 {
9181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9182 std::string ex(str, iter.base());
9183 assert(ex == "-inf*********************");
9184 assert(ios.width() == 0);
9185 }
9186 ios.width(25);
9187 right(ios);
9188 {
9189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9190 std::string ex(str, iter.base());
9191 assert(ex == "*********************-inf");
9192 assert(ios.width() == 0);
9193 }
9194 ios.width(25);
9195 internal(ios);
9196 {
9197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9198 std::string ex(str, iter.base());
9199 assert(ex == "-*********************inf");
9200 assert(ios.width() == 0);
9201 }
9202 }
9203 ios.imbue(lg);
9204 {
9205 ios.width(0);
9206 {
9207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9208 std::string ex(str, iter.base());
9209 assert(ex == "-inf");
9210 assert(ios.width() == 0);
9211 }
9212 ios.width(25);
9213 left(ios);
9214 {
9215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9216 std::string ex(str, iter.base());
9217 assert(ex == "-inf*********************");
9218 assert(ios.width() == 0);
9219 }
9220 ios.width(25);
9221 right(ios);
9222 {
9223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9224 std::string ex(str, iter.base());
9225 assert(ex == "*********************-inf");
9226 assert(ios.width() == 0);
9227 }
9228 ios.width(25);
9229 internal(ios);
9230 {
9231 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9232 std::string ex(str, iter.base());
9233 assert(ex == "-*********************inf");
9234 assert(ios.width() == 0);
9235 }
9236 }
9237 }
9238 }
9239 }
9240 uppercase(ios);
9241 {
9242 noshowpos(ios);
9243 {
9244 noshowpoint(ios);
9245 {
9246 ios.imbue(lc);
9247 {
9248 ios.width(0);
9249 {
9250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9251 std::string ex(str, iter.base());
9252 assert(ex == "-INF");
9253 assert(ios.width() == 0);
9254 }
9255 ios.width(25);
9256 left(ios);
9257 {
9258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9259 std::string ex(str, iter.base());
9260 assert(ex == "-INF*********************");
9261 assert(ios.width() == 0);
9262 }
9263 ios.width(25);
9264 right(ios);
9265 {
9266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9267 std::string ex(str, iter.base());
9268 assert(ex == "*********************-INF");
9269 assert(ios.width() == 0);
9270 }
9271 ios.width(25);
9272 internal(ios);
9273 {
9274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9275 std::string ex(str, iter.base());
9276 assert(ex == "-*********************INF");
9277 assert(ios.width() == 0);
9278 }
9279 }
9280 ios.imbue(lg);
9281 {
9282 ios.width(0);
9283 {
9284 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9285 std::string ex(str, iter.base());
9286 assert(ex == "-INF");
9287 assert(ios.width() == 0);
9288 }
9289 ios.width(25);
9290 left(ios);
9291 {
9292 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9293 std::string ex(str, iter.base());
9294 assert(ex == "-INF*********************");
9295 assert(ios.width() == 0);
9296 }
9297 ios.width(25);
9298 right(ios);
9299 {
9300 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9301 std::string ex(str, iter.base());
9302 assert(ex == "*********************-INF");
9303 assert(ios.width() == 0);
9304 }
9305 ios.width(25);
9306 internal(ios);
9307 {
9308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9309 std::string ex(str, iter.base());
9310 assert(ex == "-*********************INF");
9311 assert(ios.width() == 0);
9312 }
9313 }
9314 }
9315 showpoint(ios);
9316 {
9317 ios.imbue(lc);
9318 {
9319 ios.width(0);
9320 {
9321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9322 std::string ex(str, iter.base());
9323 assert(ex == "-INF");
9324 assert(ios.width() == 0);
9325 }
9326 ios.width(25);
9327 left(ios);
9328 {
9329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9330 std::string ex(str, iter.base());
9331 assert(ex == "-INF*********************");
9332 assert(ios.width() == 0);
9333 }
9334 ios.width(25);
9335 right(ios);
9336 {
9337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9338 std::string ex(str, iter.base());
9339 assert(ex == "*********************-INF");
9340 assert(ios.width() == 0);
9341 }
9342 ios.width(25);
9343 internal(ios);
9344 {
9345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9346 std::string ex(str, iter.base());
9347 assert(ex == "-*********************INF");
9348 assert(ios.width() == 0);
9349 }
9350 }
9351 ios.imbue(lg);
9352 {
9353 ios.width(0);
9354 {
9355 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9356 std::string ex(str, iter.base());
9357 assert(ex == "-INF");
9358 assert(ios.width() == 0);
9359 }
9360 ios.width(25);
9361 left(ios);
9362 {
9363 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9364 std::string ex(str, iter.base());
9365 assert(ex == "-INF*********************");
9366 assert(ios.width() == 0);
9367 }
9368 ios.width(25);
9369 right(ios);
9370 {
9371 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9372 std::string ex(str, iter.base());
9373 assert(ex == "*********************-INF");
9374 assert(ios.width() == 0);
9375 }
9376 ios.width(25);
9377 internal(ios);
9378 {
9379 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9380 std::string ex(str, iter.base());
9381 assert(ex == "-*********************INF");
9382 assert(ios.width() == 0);
9383 }
9384 }
9385 }
9386 }
9387 showpos(ios);
9388 {
9389 noshowpoint(ios);
9390 {
9391 ios.imbue(lc);
9392 {
9393 ios.width(0);
9394 {
9395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9396 std::string ex(str, iter.base());
9397 assert(ex == "-INF");
9398 assert(ios.width() == 0);
9399 }
9400 ios.width(25);
9401 left(ios);
9402 {
9403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9404 std::string ex(str, iter.base());
9405 assert(ex == "-INF*********************");
9406 assert(ios.width() == 0);
9407 }
9408 ios.width(25);
9409 right(ios);
9410 {
9411 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9412 std::string ex(str, iter.base());
9413 assert(ex == "*********************-INF");
9414 assert(ios.width() == 0);
9415 }
9416 ios.width(25);
9417 internal(ios);
9418 {
9419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9420 std::string ex(str, iter.base());
9421 assert(ex == "-*********************INF");
9422 assert(ios.width() == 0);
9423 }
9424 }
9425 ios.imbue(lg);
9426 {
9427 ios.width(0);
9428 {
9429 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9430 std::string ex(str, iter.base());
9431 assert(ex == "-INF");
9432 assert(ios.width() == 0);
9433 }
9434 ios.width(25);
9435 left(ios);
9436 {
9437 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9438 std::string ex(str, iter.base());
9439 assert(ex == "-INF*********************");
9440 assert(ios.width() == 0);
9441 }
9442 ios.width(25);
9443 right(ios);
9444 {
9445 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9446 std::string ex(str, iter.base());
9447 assert(ex == "*********************-INF");
9448 assert(ios.width() == 0);
9449 }
9450 ios.width(25);
9451 internal(ios);
9452 {
9453 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9454 std::string ex(str, iter.base());
9455 assert(ex == "-*********************INF");
9456 assert(ios.width() == 0);
9457 }
9458 }
9459 }
9460 showpoint(ios);
9461 {
9462 ios.imbue(lc);
9463 {
9464 ios.width(0);
9465 {
9466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9467 std::string ex(str, iter.base());
9468 assert(ex == "-INF");
9469 assert(ios.width() == 0);
9470 }
9471 ios.width(25);
9472 left(ios);
9473 {
9474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9475 std::string ex(str, iter.base());
9476 assert(ex == "-INF*********************");
9477 assert(ios.width() == 0);
9478 }
9479 ios.width(25);
9480 right(ios);
9481 {
9482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9483 std::string ex(str, iter.base());
9484 assert(ex == "*********************-INF");
9485 assert(ios.width() == 0);
9486 }
9487 ios.width(25);
9488 internal(ios);
9489 {
9490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9491 std::string ex(str, iter.base());
9492 assert(ex == "-*********************INF");
9493 assert(ios.width() == 0);
9494 }
9495 }
9496 ios.imbue(lg);
9497 {
9498 ios.width(0);
9499 {
9500 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9501 std::string ex(str, iter.base());
9502 assert(ex == "-INF");
9503 assert(ios.width() == 0);
9504 }
9505 ios.width(25);
9506 left(ios);
9507 {
9508 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9509 std::string ex(str, iter.base());
9510 assert(ex == "-INF*********************");
9511 assert(ios.width() == 0);
9512 }
9513 ios.width(25);
9514 right(ios);
9515 {
9516 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9517 std::string ex(str, iter.base());
9518 assert(ex == "*********************-INF");
9519 assert(ios.width() == 0);
9520 }
9521 ios.width(25);
9522 internal(ios);
9523 {
9524 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9525 std::string ex(str, iter.base());
9526 assert(ex == "-*********************INF");
9527 assert(ios.width() == 0);
9528 }
9529 }
9530 }
9531 }
9532 }
9533 }
9534 ios.precision(1);
9535 {
9536 nouppercase(ios);
9537 {
9538 noshowpos(ios);
9539 {
9540 noshowpoint(ios);
9541 {
9542 ios.imbue(lc);
9543 {
9544 ios.width(0);
9545 {
9546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9547 std::string ex(str, iter.base());
9548 assert(ex == "-inf");
9549 assert(ios.width() == 0);
9550 }
9551 ios.width(25);
9552 left(ios);
9553 {
9554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9555 std::string ex(str, iter.base());
9556 assert(ex == "-inf*********************");
9557 assert(ios.width() == 0);
9558 }
9559 ios.width(25);
9560 right(ios);
9561 {
9562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9563 std::string ex(str, iter.base());
9564 assert(ex == "*********************-inf");
9565 assert(ios.width() == 0);
9566 }
9567 ios.width(25);
9568 internal(ios);
9569 {
9570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9571 std::string ex(str, iter.base());
9572 assert(ex == "-*********************inf");
9573 assert(ios.width() == 0);
9574 }
9575 }
9576 ios.imbue(lg);
9577 {
9578 ios.width(0);
9579 {
9580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9581 std::string ex(str, iter.base());
9582 assert(ex == "-inf");
9583 assert(ios.width() == 0);
9584 }
9585 ios.width(25);
9586 left(ios);
9587 {
9588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9589 std::string ex(str, iter.base());
9590 assert(ex == "-inf*********************");
9591 assert(ios.width() == 0);
9592 }
9593 ios.width(25);
9594 right(ios);
9595 {
9596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9597 std::string ex(str, iter.base());
9598 assert(ex == "*********************-inf");
9599 assert(ios.width() == 0);
9600 }
9601 ios.width(25);
9602 internal(ios);
9603 {
9604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9605 std::string ex(str, iter.base());
9606 assert(ex == "-*********************inf");
9607 assert(ios.width() == 0);
9608 }
9609 }
9610 }
9611 showpoint(ios);
9612 {
9613 ios.imbue(lc);
9614 {
9615 ios.width(0);
9616 {
9617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9618 std::string ex(str, iter.base());
9619 assert(ex == "-inf");
9620 assert(ios.width() == 0);
9621 }
9622 ios.width(25);
9623 left(ios);
9624 {
9625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9626 std::string ex(str, iter.base());
9627 assert(ex == "-inf*********************");
9628 assert(ios.width() == 0);
9629 }
9630 ios.width(25);
9631 right(ios);
9632 {
9633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9634 std::string ex(str, iter.base());
9635 assert(ex == "*********************-inf");
9636 assert(ios.width() == 0);
9637 }
9638 ios.width(25);
9639 internal(ios);
9640 {
9641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9642 std::string ex(str, iter.base());
9643 assert(ex == "-*********************inf");
9644 assert(ios.width() == 0);
9645 }
9646 }
9647 ios.imbue(lg);
9648 {
9649 ios.width(0);
9650 {
9651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9652 std::string ex(str, iter.base());
9653 assert(ex == "-inf");
9654 assert(ios.width() == 0);
9655 }
9656 ios.width(25);
9657 left(ios);
9658 {
9659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9660 std::string ex(str, iter.base());
9661 assert(ex == "-inf*********************");
9662 assert(ios.width() == 0);
9663 }
9664 ios.width(25);
9665 right(ios);
9666 {
9667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9668 std::string ex(str, iter.base());
9669 assert(ex == "*********************-inf");
9670 assert(ios.width() == 0);
9671 }
9672 ios.width(25);
9673 internal(ios);
9674 {
9675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9676 std::string ex(str, iter.base());
9677 assert(ex == "-*********************inf");
9678 assert(ios.width() == 0);
9679 }
9680 }
9681 }
9682 }
9683 showpos(ios);
9684 {
9685 noshowpoint(ios);
9686 {
9687 ios.imbue(lc);
9688 {
9689 ios.width(0);
9690 {
9691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9692 std::string ex(str, iter.base());
9693 assert(ex == "-inf");
9694 assert(ios.width() == 0);
9695 }
9696 ios.width(25);
9697 left(ios);
9698 {
9699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9700 std::string ex(str, iter.base());
9701 assert(ex == "-inf*********************");
9702 assert(ios.width() == 0);
9703 }
9704 ios.width(25);
9705 right(ios);
9706 {
9707 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9708 std::string ex(str, iter.base());
9709 assert(ex == "*********************-inf");
9710 assert(ios.width() == 0);
9711 }
9712 ios.width(25);
9713 internal(ios);
9714 {
9715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9716 std::string ex(str, iter.base());
9717 assert(ex == "-*********************inf");
9718 assert(ios.width() == 0);
9719 }
9720 }
9721 ios.imbue(lg);
9722 {
9723 ios.width(0);
9724 {
9725 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9726 std::string ex(str, iter.base());
9727 assert(ex == "-inf");
9728 assert(ios.width() == 0);
9729 }
9730 ios.width(25);
9731 left(ios);
9732 {
9733 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9734 std::string ex(str, iter.base());
9735 assert(ex == "-inf*********************");
9736 assert(ios.width() == 0);
9737 }
9738 ios.width(25);
9739 right(ios);
9740 {
9741 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9742 std::string ex(str, iter.base());
9743 assert(ex == "*********************-inf");
9744 assert(ios.width() == 0);
9745 }
9746 ios.width(25);
9747 internal(ios);
9748 {
9749 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9750 std::string ex(str, iter.base());
9751 assert(ex == "-*********************inf");
9752 assert(ios.width() == 0);
9753 }
9754 }
9755 }
9756 showpoint(ios);
9757 {
9758 ios.imbue(lc);
9759 {
9760 ios.width(0);
9761 {
9762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9763 std::string ex(str, iter.base());
9764 assert(ex == "-inf");
9765 assert(ios.width() == 0);
9766 }
9767 ios.width(25);
9768 left(ios);
9769 {
9770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9771 std::string ex(str, iter.base());
9772 assert(ex == "-inf*********************");
9773 assert(ios.width() == 0);
9774 }
9775 ios.width(25);
9776 right(ios);
9777 {
9778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9779 std::string ex(str, iter.base());
9780 assert(ex == "*********************-inf");
9781 assert(ios.width() == 0);
9782 }
9783 ios.width(25);
9784 internal(ios);
9785 {
9786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9787 std::string ex(str, iter.base());
9788 assert(ex == "-*********************inf");
9789 assert(ios.width() == 0);
9790 }
9791 }
9792 ios.imbue(lg);
9793 {
9794 ios.width(0);
9795 {
9796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9797 std::string ex(str, iter.base());
9798 assert(ex == "-inf");
9799 assert(ios.width() == 0);
9800 }
9801 ios.width(25);
9802 left(ios);
9803 {
9804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9805 std::string ex(str, iter.base());
9806 assert(ex == "-inf*********************");
9807 assert(ios.width() == 0);
9808 }
9809 ios.width(25);
9810 right(ios);
9811 {
9812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9813 std::string ex(str, iter.base());
9814 assert(ex == "*********************-inf");
9815 assert(ios.width() == 0);
9816 }
9817 ios.width(25);
9818 internal(ios);
9819 {
9820 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9821 std::string ex(str, iter.base());
9822 assert(ex == "-*********************inf");
9823 assert(ios.width() == 0);
9824 }
9825 }
9826 }
9827 }
9828 }
9829 uppercase(ios);
9830 {
9831 noshowpos(ios);
9832 {
9833 noshowpoint(ios);
9834 {
9835 ios.imbue(lc);
9836 {
9837 ios.width(0);
9838 {
9839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9840 std::string ex(str, iter.base());
9841 assert(ex == "-INF");
9842 assert(ios.width() == 0);
9843 }
9844 ios.width(25);
9845 left(ios);
9846 {
9847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9848 std::string ex(str, iter.base());
9849 assert(ex == "-INF*********************");
9850 assert(ios.width() == 0);
9851 }
9852 ios.width(25);
9853 right(ios);
9854 {
9855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9856 std::string ex(str, iter.base());
9857 assert(ex == "*********************-INF");
9858 assert(ios.width() == 0);
9859 }
9860 ios.width(25);
9861 internal(ios);
9862 {
9863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9864 std::string ex(str, iter.base());
9865 assert(ex == "-*********************INF");
9866 assert(ios.width() == 0);
9867 }
9868 }
9869 ios.imbue(lg);
9870 {
9871 ios.width(0);
9872 {
9873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9874 std::string ex(str, iter.base());
9875 assert(ex == "-INF");
9876 assert(ios.width() == 0);
9877 }
9878 ios.width(25);
9879 left(ios);
9880 {
9881 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9882 std::string ex(str, iter.base());
9883 assert(ex == "-INF*********************");
9884 assert(ios.width() == 0);
9885 }
9886 ios.width(25);
9887 right(ios);
9888 {
9889 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9890 std::string ex(str, iter.base());
9891 assert(ex == "*********************-INF");
9892 assert(ios.width() == 0);
9893 }
9894 ios.width(25);
9895 internal(ios);
9896 {
9897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9898 std::string ex(str, iter.base());
9899 assert(ex == "-*********************INF");
9900 assert(ios.width() == 0);
9901 }
9902 }
9903 }
9904 showpoint(ios);
9905 {
9906 ios.imbue(lc);
9907 {
9908 ios.width(0);
9909 {
9910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9911 std::string ex(str, iter.base());
9912 assert(ex == "-INF");
9913 assert(ios.width() == 0);
9914 }
9915 ios.width(25);
9916 left(ios);
9917 {
9918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9919 std::string ex(str, iter.base());
9920 assert(ex == "-INF*********************");
9921 assert(ios.width() == 0);
9922 }
9923 ios.width(25);
9924 right(ios);
9925 {
9926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9927 std::string ex(str, iter.base());
9928 assert(ex == "*********************-INF");
9929 assert(ios.width() == 0);
9930 }
9931 ios.width(25);
9932 internal(ios);
9933 {
9934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9935 std::string ex(str, iter.base());
9936 assert(ex == "-*********************INF");
9937 assert(ios.width() == 0);
9938 }
9939 }
9940 ios.imbue(lg);
9941 {
9942 ios.width(0);
9943 {
9944 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9945 std::string ex(str, iter.base());
9946 assert(ex == "-INF");
9947 assert(ios.width() == 0);
9948 }
9949 ios.width(25);
9950 left(ios);
9951 {
9952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9953 std::string ex(str, iter.base());
9954 assert(ex == "-INF*********************");
9955 assert(ios.width() == 0);
9956 }
9957 ios.width(25);
9958 right(ios);
9959 {
9960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9961 std::string ex(str, iter.base());
9962 assert(ex == "*********************-INF");
9963 assert(ios.width() == 0);
9964 }
9965 ios.width(25);
9966 internal(ios);
9967 {
9968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9969 std::string ex(str, iter.base());
9970 assert(ex == "-*********************INF");
9971 assert(ios.width() == 0);
9972 }
9973 }
9974 }
9975 }
9976 showpos(ios);
9977 {
9978 noshowpoint(ios);
9979 {
9980 ios.imbue(lc);
9981 {
9982 ios.width(0);
9983 {
9984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9985 std::string ex(str, iter.base());
9986 assert(ex == "-INF");
9987 assert(ios.width() == 0);
9988 }
9989 ios.width(25);
9990 left(ios);
9991 {
9992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9993 std::string ex(str, iter.base());
9994 assert(ex == "-INF*********************");
9995 assert(ios.width() == 0);
9996 }
9997 ios.width(25);
9998 right(ios);
9999 {
10000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10001 std::string ex(str, iter.base());
10002 assert(ex == "*********************-INF");
10003 assert(ios.width() == 0);
10004 }
10005 ios.width(25);
10006 internal(ios);
10007 {
10008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10009 std::string ex(str, iter.base());
10010 assert(ex == "-*********************INF");
10011 assert(ios.width() == 0);
10012 }
10013 }
10014 ios.imbue(lg);
10015 {
10016 ios.width(0);
10017 {
10018 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10019 std::string ex(str, iter.base());
10020 assert(ex == "-INF");
10021 assert(ios.width() == 0);
10022 }
10023 ios.width(25);
10024 left(ios);
10025 {
10026 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10027 std::string ex(str, iter.base());
10028 assert(ex == "-INF*********************");
10029 assert(ios.width() == 0);
10030 }
10031 ios.width(25);
10032 right(ios);
10033 {
10034 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10035 std::string ex(str, iter.base());
10036 assert(ex == "*********************-INF");
10037 assert(ios.width() == 0);
10038 }
10039 ios.width(25);
10040 internal(ios);
10041 {
10042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10043 std::string ex(str, iter.base());
10044 assert(ex == "-*********************INF");
10045 assert(ios.width() == 0);
10046 }
10047 }
10048 }
10049 showpoint(ios);
10050 {
10051 ios.imbue(lc);
10052 {
10053 ios.width(0);
10054 {
10055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10056 std::string ex(str, iter.base());
10057 assert(ex == "-INF");
10058 assert(ios.width() == 0);
10059 }
10060 ios.width(25);
10061 left(ios);
10062 {
10063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10064 std::string ex(str, iter.base());
10065 assert(ex == "-INF*********************");
10066 assert(ios.width() == 0);
10067 }
10068 ios.width(25);
10069 right(ios);
10070 {
10071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10072 std::string ex(str, iter.base());
10073 assert(ex == "*********************-INF");
10074 assert(ios.width() == 0);
10075 }
10076 ios.width(25);
10077 internal(ios);
10078 {
10079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10080 std::string ex(str, iter.base());
10081 assert(ex == "-*********************INF");
10082 assert(ios.width() == 0);
10083 }
10084 }
10085 ios.imbue(lg);
10086 {
10087 ios.width(0);
10088 {
10089 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10090 std::string ex(str, iter.base());
10091 assert(ex == "-INF");
10092 assert(ios.width() == 0);
10093 }
10094 ios.width(25);
10095 left(ios);
10096 {
10097 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10098 std::string ex(str, iter.base());
10099 assert(ex == "-INF*********************");
10100 assert(ios.width() == 0);
10101 }
10102 ios.width(25);
10103 right(ios);
10104 {
10105 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10106 std::string ex(str, iter.base());
10107 assert(ex == "*********************-INF");
10108 assert(ios.width() == 0);
10109 }
10110 ios.width(25);
10111 internal(ios);
10112 {
10113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10114 std::string ex(str, iter.base());
10115 assert(ex == "-*********************INF");
10116 assert(ios.width() == 0);
10117 }
10118 }
10119 }
10120 }
10121 }
10122 }
10123 ios.precision(6);
10124 {
10125 nouppercase(ios);
10126 {
10127 noshowpos(ios);
10128 {
10129 noshowpoint(ios);
10130 {
10131 ios.imbue(lc);
10132 {
10133 ios.width(0);
10134 {
10135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10136 std::string ex(str, iter.base());
10137 assert(ex == "-inf");
10138 assert(ios.width() == 0);
10139 }
10140 ios.width(25);
10141 left(ios);
10142 {
10143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10144 std::string ex(str, iter.base());
10145 assert(ex == "-inf*********************");
10146 assert(ios.width() == 0);
10147 }
10148 ios.width(25);
10149 right(ios);
10150 {
10151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10152 std::string ex(str, iter.base());
10153 assert(ex == "*********************-inf");
10154 assert(ios.width() == 0);
10155 }
10156 ios.width(25);
10157 internal(ios);
10158 {
10159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10160 std::string ex(str, iter.base());
10161 assert(ex == "-*********************inf");
10162 assert(ios.width() == 0);
10163 }
10164 }
10165 ios.imbue(lg);
10166 {
10167 ios.width(0);
10168 {
10169 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10170 std::string ex(str, iter.base());
10171 assert(ex == "-inf");
10172 assert(ios.width() == 0);
10173 }
10174 ios.width(25);
10175 left(ios);
10176 {
10177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10178 std::string ex(str, iter.base());
10179 assert(ex == "-inf*********************");
10180 assert(ios.width() == 0);
10181 }
10182 ios.width(25);
10183 right(ios);
10184 {
10185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10186 std::string ex(str, iter.base());
10187 assert(ex == "*********************-inf");
10188 assert(ios.width() == 0);
10189 }
10190 ios.width(25);
10191 internal(ios);
10192 {
10193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10194 std::string ex(str, iter.base());
10195 assert(ex == "-*********************inf");
10196 assert(ios.width() == 0);
10197 }
10198 }
10199 }
10200 showpoint(ios);
10201 {
10202 ios.imbue(lc);
10203 {
10204 ios.width(0);
10205 {
10206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10207 std::string ex(str, iter.base());
10208 assert(ex == "-inf");
10209 assert(ios.width() == 0);
10210 }
10211 ios.width(25);
10212 left(ios);
10213 {
10214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10215 std::string ex(str, iter.base());
10216 assert(ex == "-inf*********************");
10217 assert(ios.width() == 0);
10218 }
10219 ios.width(25);
10220 right(ios);
10221 {
10222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10223 std::string ex(str, iter.base());
10224 assert(ex == "*********************-inf");
10225 assert(ios.width() == 0);
10226 }
10227 ios.width(25);
10228 internal(ios);
10229 {
10230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10231 std::string ex(str, iter.base());
10232 assert(ex == "-*********************inf");
10233 assert(ios.width() == 0);
10234 }
10235 }
10236 ios.imbue(lg);
10237 {
10238 ios.width(0);
10239 {
10240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10241 std::string ex(str, iter.base());
10242 assert(ex == "-inf");
10243 assert(ios.width() == 0);
10244 }
10245 ios.width(25);
10246 left(ios);
10247 {
10248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10249 std::string ex(str, iter.base());
10250 assert(ex == "-inf*********************");
10251 assert(ios.width() == 0);
10252 }
10253 ios.width(25);
10254 right(ios);
10255 {
10256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10257 std::string ex(str, iter.base());
10258 assert(ex == "*********************-inf");
10259 assert(ios.width() == 0);
10260 }
10261 ios.width(25);
10262 internal(ios);
10263 {
10264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10265 std::string ex(str, iter.base());
10266 assert(ex == "-*********************inf");
10267 assert(ios.width() == 0);
10268 }
10269 }
10270 }
10271 }
10272 showpos(ios);
10273 {
10274 noshowpoint(ios);
10275 {
10276 ios.imbue(lc);
10277 {
10278 ios.width(0);
10279 {
10280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10281 std::string ex(str, iter.base());
10282 assert(ex == "-inf");
10283 assert(ios.width() == 0);
10284 }
10285 ios.width(25);
10286 left(ios);
10287 {
10288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10289 std::string ex(str, iter.base());
10290 assert(ex == "-inf*********************");
10291 assert(ios.width() == 0);
10292 }
10293 ios.width(25);
10294 right(ios);
10295 {
10296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10297 std::string ex(str, iter.base());
10298 assert(ex == "*********************-inf");
10299 assert(ios.width() == 0);
10300 }
10301 ios.width(25);
10302 internal(ios);
10303 {
10304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10305 std::string ex(str, iter.base());
10306 assert(ex == "-*********************inf");
10307 assert(ios.width() == 0);
10308 }
10309 }
10310 ios.imbue(lg);
10311 {
10312 ios.width(0);
10313 {
10314 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10315 std::string ex(str, iter.base());
10316 assert(ex == "-inf");
10317 assert(ios.width() == 0);
10318 }
10319 ios.width(25);
10320 left(ios);
10321 {
10322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10323 std::string ex(str, iter.base());
10324 assert(ex == "-inf*********************");
10325 assert(ios.width() == 0);
10326 }
10327 ios.width(25);
10328 right(ios);
10329 {
10330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10331 std::string ex(str, iter.base());
10332 assert(ex == "*********************-inf");
10333 assert(ios.width() == 0);
10334 }
10335 ios.width(25);
10336 internal(ios);
10337 {
10338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10339 std::string ex(str, iter.base());
10340 assert(ex == "-*********************inf");
10341 assert(ios.width() == 0);
10342 }
10343 }
10344 }
10345 showpoint(ios);
10346 {
10347 ios.imbue(lc);
10348 {
10349 ios.width(0);
10350 {
10351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10352 std::string ex(str, iter.base());
10353 assert(ex == "-inf");
10354 assert(ios.width() == 0);
10355 }
10356 ios.width(25);
10357 left(ios);
10358 {
10359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10360 std::string ex(str, iter.base());
10361 assert(ex == "-inf*********************");
10362 assert(ios.width() == 0);
10363 }
10364 ios.width(25);
10365 right(ios);
10366 {
10367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10368 std::string ex(str, iter.base());
10369 assert(ex == "*********************-inf");
10370 assert(ios.width() == 0);
10371 }
10372 ios.width(25);
10373 internal(ios);
10374 {
10375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10376 std::string ex(str, iter.base());
10377 assert(ex == "-*********************inf");
10378 assert(ios.width() == 0);
10379 }
10380 }
10381 ios.imbue(lg);
10382 {
10383 ios.width(0);
10384 {
10385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10386 std::string ex(str, iter.base());
10387 assert(ex == "-inf");
10388 assert(ios.width() == 0);
10389 }
10390 ios.width(25);
10391 left(ios);
10392 {
10393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10394 std::string ex(str, iter.base());
10395 assert(ex == "-inf*********************");
10396 assert(ios.width() == 0);
10397 }
10398 ios.width(25);
10399 right(ios);
10400 {
10401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10402 std::string ex(str, iter.base());
10403 assert(ex == "*********************-inf");
10404 assert(ios.width() == 0);
10405 }
10406 ios.width(25);
10407 internal(ios);
10408 {
10409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10410 std::string ex(str, iter.base());
10411 assert(ex == "-*********************inf");
10412 assert(ios.width() == 0);
10413 }
10414 }
10415 }
10416 }
10417 }
10418 uppercase(ios);
10419 {
10420 noshowpos(ios);
10421 {
10422 noshowpoint(ios);
10423 {
10424 ios.imbue(lc);
10425 {
10426 ios.width(0);
10427 {
10428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10429 std::string ex(str, iter.base());
10430 assert(ex == "-INF");
10431 assert(ios.width() == 0);
10432 }
10433 ios.width(25);
10434 left(ios);
10435 {
10436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10437 std::string ex(str, iter.base());
10438 assert(ex == "-INF*********************");
10439 assert(ios.width() == 0);
10440 }
10441 ios.width(25);
10442 right(ios);
10443 {
10444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10445 std::string ex(str, iter.base());
10446 assert(ex == "*********************-INF");
10447 assert(ios.width() == 0);
10448 }
10449 ios.width(25);
10450 internal(ios);
10451 {
10452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10453 std::string ex(str, iter.base());
10454 assert(ex == "-*********************INF");
10455 assert(ios.width() == 0);
10456 }
10457 }
10458 ios.imbue(lg);
10459 {
10460 ios.width(0);
10461 {
10462 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10463 std::string ex(str, iter.base());
10464 assert(ex == "-INF");
10465 assert(ios.width() == 0);
10466 }
10467 ios.width(25);
10468 left(ios);
10469 {
10470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10471 std::string ex(str, iter.base());
10472 assert(ex == "-INF*********************");
10473 assert(ios.width() == 0);
10474 }
10475 ios.width(25);
10476 right(ios);
10477 {
10478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10479 std::string ex(str, iter.base());
10480 assert(ex == "*********************-INF");
10481 assert(ios.width() == 0);
10482 }
10483 ios.width(25);
10484 internal(ios);
10485 {
10486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10487 std::string ex(str, iter.base());
10488 assert(ex == "-*********************INF");
10489 assert(ios.width() == 0);
10490 }
10491 }
10492 }
10493 showpoint(ios);
10494 {
10495 ios.imbue(lc);
10496 {
10497 ios.width(0);
10498 {
10499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10500 std::string ex(str, iter.base());
10501 assert(ex == "-INF");
10502 assert(ios.width() == 0);
10503 }
10504 ios.width(25);
10505 left(ios);
10506 {
10507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10508 std::string ex(str, iter.base());
10509 assert(ex == "-INF*********************");
10510 assert(ios.width() == 0);
10511 }
10512 ios.width(25);
10513 right(ios);
10514 {
10515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10516 std::string ex(str, iter.base());
10517 assert(ex == "*********************-INF");
10518 assert(ios.width() == 0);
10519 }
10520 ios.width(25);
10521 internal(ios);
10522 {
10523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10524 std::string ex(str, iter.base());
10525 assert(ex == "-*********************INF");
10526 assert(ios.width() == 0);
10527 }
10528 }
10529 ios.imbue(lg);
10530 {
10531 ios.width(0);
10532 {
10533 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10534 std::string ex(str, iter.base());
10535 assert(ex == "-INF");
10536 assert(ios.width() == 0);
10537 }
10538 ios.width(25);
10539 left(ios);
10540 {
10541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10542 std::string ex(str, iter.base());
10543 assert(ex == "-INF*********************");
10544 assert(ios.width() == 0);
10545 }
10546 ios.width(25);
10547 right(ios);
10548 {
10549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10550 std::string ex(str, iter.base());
10551 assert(ex == "*********************-INF");
10552 assert(ios.width() == 0);
10553 }
10554 ios.width(25);
10555 internal(ios);
10556 {
10557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10558 std::string ex(str, iter.base());
10559 assert(ex == "-*********************INF");
10560 assert(ios.width() == 0);
10561 }
10562 }
10563 }
10564 }
10565 showpos(ios);
10566 {
10567 noshowpoint(ios);
10568 {
10569 ios.imbue(lc);
10570 {
10571 ios.width(0);
10572 {
10573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10574 std::string ex(str, iter.base());
10575 assert(ex == "-INF");
10576 assert(ios.width() == 0);
10577 }
10578 ios.width(25);
10579 left(ios);
10580 {
10581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10582 std::string ex(str, iter.base());
10583 assert(ex == "-INF*********************");
10584 assert(ios.width() == 0);
10585 }
10586 ios.width(25);
10587 right(ios);
10588 {
10589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10590 std::string ex(str, iter.base());
10591 assert(ex == "*********************-INF");
10592 assert(ios.width() == 0);
10593 }
10594 ios.width(25);
10595 internal(ios);
10596 {
10597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10598 std::string ex(str, iter.base());
10599 assert(ex == "-*********************INF");
10600 assert(ios.width() == 0);
10601 }
10602 }
10603 ios.imbue(lg);
10604 {
10605 ios.width(0);
10606 {
10607 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10608 std::string ex(str, iter.base());
10609 assert(ex == "-INF");
10610 assert(ios.width() == 0);
10611 }
10612 ios.width(25);
10613 left(ios);
10614 {
10615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10616 std::string ex(str, iter.base());
10617 assert(ex == "-INF*********************");
10618 assert(ios.width() == 0);
10619 }
10620 ios.width(25);
10621 right(ios);
10622 {
10623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10624 std::string ex(str, iter.base());
10625 assert(ex == "*********************-INF");
10626 assert(ios.width() == 0);
10627 }
10628 ios.width(25);
10629 internal(ios);
10630 {
10631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10632 std::string ex(str, iter.base());
10633 assert(ex == "-*********************INF");
10634 assert(ios.width() == 0);
10635 }
10636 }
10637 }
10638 showpoint(ios);
10639 {
10640 ios.imbue(lc);
10641 {
10642 ios.width(0);
10643 {
10644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10645 std::string ex(str, iter.base());
10646 assert(ex == "-INF");
10647 assert(ios.width() == 0);
10648 }
10649 ios.width(25);
10650 left(ios);
10651 {
10652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10653 std::string ex(str, iter.base());
10654 assert(ex == "-INF*********************");
10655 assert(ios.width() == 0);
10656 }
10657 ios.width(25);
10658 right(ios);
10659 {
10660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10661 std::string ex(str, iter.base());
10662 assert(ex == "*********************-INF");
10663 assert(ios.width() == 0);
10664 }
10665 ios.width(25);
10666 internal(ios);
10667 {
10668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10669 std::string ex(str, iter.base());
10670 assert(ex == "-*********************INF");
10671 assert(ios.width() == 0);
10672 }
10673 }
10674 ios.imbue(lg);
10675 {
10676 ios.width(0);
10677 {
10678 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10679 std::string ex(str, iter.base());
10680 assert(ex == "-INF");
10681 assert(ios.width() == 0);
10682 }
10683 ios.width(25);
10684 left(ios);
10685 {
10686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10687 std::string ex(str, iter.base());
10688 assert(ex == "-INF*********************");
10689 assert(ios.width() == 0);
10690 }
10691 ios.width(25);
10692 right(ios);
10693 {
10694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10695 std::string ex(str, iter.base());
10696 assert(ex == "*********************-INF");
10697 assert(ios.width() == 0);
10698 }
10699 ios.width(25);
10700 internal(ios);
10701 {
10702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10703 std::string ex(str, iter.base());
10704 assert(ex == "-*********************INF");
10705 assert(ios.width() == 0);
10706 }
10707 }
10708 }
10709 }
10710 }
10711 }
10712 ios.precision(16);
10713 {}
10714 ios.precision(60);
10715 {}
10716 }
10717 }
10718 }
10719
test5()10720 void test5()
10721 {
10722 char str[200];
10723 output_iterator<char*> iter;
10724 std::locale lc = std::locale::classic();
10725 std::locale lg(lc, new my_numpunct);
10726 const my_facet f(1);
10727 {
10728 long double v = std::nan("");
10729 std::ios ios(0);
10730 // %g
10731 {
10732 ios.precision(0);
10733 {
10734 nouppercase(ios);
10735 {
10736 noshowpos(ios);
10737 {
10738 noshowpoint(ios);
10739 {
10740 ios.imbue(lc);
10741 {
10742 ios.width(0);
10743 {
10744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10745 std::string ex(str, iter.base());
10746 assert(ex == "nan");
10747 assert(ios.width() == 0);
10748 }
10749 ios.width(25);
10750 left(ios);
10751 {
10752 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10753 std::string ex(str, iter.base());
10754 assert(ex == "nan**********************");
10755 assert(ios.width() == 0);
10756 }
10757 ios.width(25);
10758 right(ios);
10759 {
10760 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10761 std::string ex(str, iter.base());
10762 assert(ex == "**********************nan");
10763 assert(ios.width() == 0);
10764 }
10765 ios.width(25);
10766 internal(ios);
10767 {
10768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10769 std::string ex(str, iter.base());
10770 assert(ex == "**********************nan");
10771 assert(ios.width() == 0);
10772 }
10773 }
10774 ios.imbue(lg);
10775 {
10776 ios.width(0);
10777 {
10778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10779 std::string ex(str, iter.base());
10780 assert(ex == "nan");
10781 assert(ios.width() == 0);
10782 }
10783 ios.width(25);
10784 left(ios);
10785 {
10786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10787 std::string ex(str, iter.base());
10788 assert(ex == "nan**********************");
10789 assert(ios.width() == 0);
10790 }
10791 ios.width(25);
10792 right(ios);
10793 {
10794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10795 std::string ex(str, iter.base());
10796 assert(ex == "**********************nan");
10797 assert(ios.width() == 0);
10798 }
10799 ios.width(25);
10800 internal(ios);
10801 {
10802 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10803 std::string ex(str, iter.base());
10804 assert(ex == "**********************nan");
10805 assert(ios.width() == 0);
10806 }
10807 }
10808 }
10809 showpoint(ios);
10810 {
10811 ios.imbue(lc);
10812 {
10813 ios.width(0);
10814 {
10815 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10816 std::string ex(str, iter.base());
10817 assert(ex == "nan");
10818 assert(ios.width() == 0);
10819 }
10820 ios.width(25);
10821 left(ios);
10822 {
10823 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10824 std::string ex(str, iter.base());
10825 assert(ex == "nan**********************");
10826 assert(ios.width() == 0);
10827 }
10828 ios.width(25);
10829 right(ios);
10830 {
10831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10832 std::string ex(str, iter.base());
10833 assert(ex == "**********************nan");
10834 assert(ios.width() == 0);
10835 }
10836 ios.width(25);
10837 internal(ios);
10838 {
10839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10840 std::string ex(str, iter.base());
10841 assert(ex == "**********************nan");
10842 assert(ios.width() == 0);
10843 }
10844 }
10845 ios.imbue(lg);
10846 {
10847 ios.width(0);
10848 {
10849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10850 std::string ex(str, iter.base());
10851 assert(ex == "nan");
10852 assert(ios.width() == 0);
10853 }
10854 ios.width(25);
10855 left(ios);
10856 {
10857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10858 std::string ex(str, iter.base());
10859 assert(ex == "nan**********************");
10860 assert(ios.width() == 0);
10861 }
10862 ios.width(25);
10863 right(ios);
10864 {
10865 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10866 std::string ex(str, iter.base());
10867 assert(ex == "**********************nan");
10868 assert(ios.width() == 0);
10869 }
10870 ios.width(25);
10871 internal(ios);
10872 {
10873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10874 std::string ex(str, iter.base());
10875 assert(ex == "**********************nan");
10876 assert(ios.width() == 0);
10877 }
10878 }
10879 }
10880 }
10881 showpos(ios);
10882 {
10883 noshowpoint(ios);
10884 {
10885 ios.imbue(lc);
10886 {
10887 ios.width(0);
10888 {
10889 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10890 std::string ex(str, iter.base());
10891 assert(ex == "nan");
10892 assert(ios.width() == 0);
10893 }
10894 ios.width(25);
10895 left(ios);
10896 {
10897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10898 std::string ex(str, iter.base());
10899 assert(ex == "nan**********************");
10900 assert(ios.width() == 0);
10901 }
10902 ios.width(25);
10903 right(ios);
10904 {
10905 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10906 std::string ex(str, iter.base());
10907 assert(ex == "**********************nan");
10908 assert(ios.width() == 0);
10909 }
10910 ios.width(25);
10911 internal(ios);
10912 {
10913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10914 std::string ex(str, iter.base());
10915 assert(ex == "**********************nan");
10916 assert(ios.width() == 0);
10917 }
10918 }
10919 ios.imbue(lg);
10920 {
10921 ios.width(0);
10922 {
10923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10924 std::string ex(str, iter.base());
10925 assert(ex == "nan");
10926 assert(ios.width() == 0);
10927 }
10928 ios.width(25);
10929 left(ios);
10930 {
10931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10932 std::string ex(str, iter.base());
10933 assert(ex == "nan**********************");
10934 assert(ios.width() == 0);
10935 }
10936 ios.width(25);
10937 right(ios);
10938 {
10939 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10940 std::string ex(str, iter.base());
10941 assert(ex == "**********************nan");
10942 assert(ios.width() == 0);
10943 }
10944 ios.width(25);
10945 internal(ios);
10946 {
10947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10948 std::string ex(str, iter.base());
10949 assert(ex == "**********************nan");
10950 assert(ios.width() == 0);
10951 }
10952 }
10953 }
10954 showpoint(ios);
10955 {
10956 ios.imbue(lc);
10957 {
10958 ios.width(0);
10959 {
10960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10961 std::string ex(str, iter.base());
10962 assert(ex == "nan");
10963 assert(ios.width() == 0);
10964 }
10965 ios.width(25);
10966 left(ios);
10967 {
10968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10969 std::string ex(str, iter.base());
10970 assert(ex == "nan**********************");
10971 assert(ios.width() == 0);
10972 }
10973 ios.width(25);
10974 right(ios);
10975 {
10976 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10977 std::string ex(str, iter.base());
10978 assert(ex == "**********************nan");
10979 assert(ios.width() == 0);
10980 }
10981 ios.width(25);
10982 internal(ios);
10983 {
10984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10985 std::string ex(str, iter.base());
10986 assert(ex == "**********************nan");
10987 assert(ios.width() == 0);
10988 }
10989 }
10990 ios.imbue(lg);
10991 {
10992 ios.width(0);
10993 {
10994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10995 std::string ex(str, iter.base());
10996 assert(ex == "nan");
10997 assert(ios.width() == 0);
10998 }
10999 ios.width(25);
11000 left(ios);
11001 {
11002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11003 std::string ex(str, iter.base());
11004 assert(ex == "nan**********************");
11005 assert(ios.width() == 0);
11006 }
11007 ios.width(25);
11008 right(ios);
11009 {
11010 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11011 std::string ex(str, iter.base());
11012 assert(ex == "**********************nan");
11013 assert(ios.width() == 0);
11014 }
11015 ios.width(25);
11016 internal(ios);
11017 {
11018 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11019 std::string ex(str, iter.base());
11020 assert(ex == "**********************nan");
11021 assert(ios.width() == 0);
11022 }
11023 }
11024 }
11025 }
11026 }
11027 uppercase(ios);
11028 {
11029 noshowpos(ios);
11030 {
11031 noshowpoint(ios);
11032 {
11033 ios.imbue(lc);
11034 {
11035 ios.width(0);
11036 {
11037 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11038 std::string ex(str, iter.base());
11039 assert(ex == "NAN");
11040 assert(ios.width() == 0);
11041 }
11042 ios.width(25);
11043 left(ios);
11044 {
11045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11046 std::string ex(str, iter.base());
11047 assert(ex == "NAN**********************");
11048 assert(ios.width() == 0);
11049 }
11050 ios.width(25);
11051 right(ios);
11052 {
11053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11054 std::string ex(str, iter.base());
11055 assert(ex == "**********************NAN");
11056 assert(ios.width() == 0);
11057 }
11058 ios.width(25);
11059 internal(ios);
11060 {
11061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11062 std::string ex(str, iter.base());
11063 assert(ex == "**********************NAN");
11064 assert(ios.width() == 0);
11065 }
11066 }
11067 ios.imbue(lg);
11068 {
11069 ios.width(0);
11070 {
11071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11072 std::string ex(str, iter.base());
11073 assert(ex == "NAN");
11074 assert(ios.width() == 0);
11075 }
11076 ios.width(25);
11077 left(ios);
11078 {
11079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11080 std::string ex(str, iter.base());
11081 assert(ex == "NAN**********************");
11082 assert(ios.width() == 0);
11083 }
11084 ios.width(25);
11085 right(ios);
11086 {
11087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11088 std::string ex(str, iter.base());
11089 assert(ex == "**********************NAN");
11090 assert(ios.width() == 0);
11091 }
11092 ios.width(25);
11093 internal(ios);
11094 {
11095 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11096 std::string ex(str, iter.base());
11097 assert(ex == "**********************NAN");
11098 assert(ios.width() == 0);
11099 }
11100 }
11101 }
11102 showpoint(ios);
11103 {
11104 ios.imbue(lc);
11105 {
11106 ios.width(0);
11107 {
11108 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11109 std::string ex(str, iter.base());
11110 assert(ex == "NAN");
11111 assert(ios.width() == 0);
11112 }
11113 ios.width(25);
11114 left(ios);
11115 {
11116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11117 std::string ex(str, iter.base());
11118 assert(ex == "NAN**********************");
11119 assert(ios.width() == 0);
11120 }
11121 ios.width(25);
11122 right(ios);
11123 {
11124 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11125 std::string ex(str, iter.base());
11126 assert(ex == "**********************NAN");
11127 assert(ios.width() == 0);
11128 }
11129 ios.width(25);
11130 internal(ios);
11131 {
11132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11133 std::string ex(str, iter.base());
11134 assert(ex == "**********************NAN");
11135 assert(ios.width() == 0);
11136 }
11137 }
11138 ios.imbue(lg);
11139 {
11140 ios.width(0);
11141 {
11142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11143 std::string ex(str, iter.base());
11144 assert(ex == "NAN");
11145 assert(ios.width() == 0);
11146 }
11147 ios.width(25);
11148 left(ios);
11149 {
11150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11151 std::string ex(str, iter.base());
11152 assert(ex == "NAN**********************");
11153 assert(ios.width() == 0);
11154 }
11155 ios.width(25);
11156 right(ios);
11157 {
11158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11159 std::string ex(str, iter.base());
11160 assert(ex == "**********************NAN");
11161 assert(ios.width() == 0);
11162 }
11163 ios.width(25);
11164 internal(ios);
11165 {
11166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11167 std::string ex(str, iter.base());
11168 assert(ex == "**********************NAN");
11169 assert(ios.width() == 0);
11170 }
11171 }
11172 }
11173 }
11174 showpos(ios);
11175 {
11176 noshowpoint(ios);
11177 {
11178 ios.imbue(lc);
11179 {
11180 ios.width(0);
11181 {
11182 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11183 std::string ex(str, iter.base());
11184 assert(ex == "NAN");
11185 assert(ios.width() == 0);
11186 }
11187 ios.width(25);
11188 left(ios);
11189 {
11190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11191 std::string ex(str, iter.base());
11192 assert(ex == "NAN**********************");
11193 assert(ios.width() == 0);
11194 }
11195 ios.width(25);
11196 right(ios);
11197 {
11198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11199 std::string ex(str, iter.base());
11200 assert(ex == "**********************NAN");
11201 assert(ios.width() == 0);
11202 }
11203 ios.width(25);
11204 internal(ios);
11205 {
11206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11207 std::string ex(str, iter.base());
11208 assert(ex == "**********************NAN");
11209 assert(ios.width() == 0);
11210 }
11211 }
11212 ios.imbue(lg);
11213 {
11214 ios.width(0);
11215 {
11216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11217 std::string ex(str, iter.base());
11218 assert(ex == "NAN");
11219 assert(ios.width() == 0);
11220 }
11221 ios.width(25);
11222 left(ios);
11223 {
11224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11225 std::string ex(str, iter.base());
11226 assert(ex == "NAN**********************");
11227 assert(ios.width() == 0);
11228 }
11229 ios.width(25);
11230 right(ios);
11231 {
11232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11233 std::string ex(str, iter.base());
11234 assert(ex == "**********************NAN");
11235 assert(ios.width() == 0);
11236 }
11237 ios.width(25);
11238 internal(ios);
11239 {
11240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11241 std::string ex(str, iter.base());
11242 assert(ex == "**********************NAN");
11243 assert(ios.width() == 0);
11244 }
11245 }
11246 }
11247 showpoint(ios);
11248 {
11249 ios.imbue(lc);
11250 {
11251 ios.width(0);
11252 {
11253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11254 std::string ex(str, iter.base());
11255 assert(ex == "NAN");
11256 assert(ios.width() == 0);
11257 }
11258 ios.width(25);
11259 left(ios);
11260 {
11261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11262 std::string ex(str, iter.base());
11263 assert(ex == "NAN**********************");
11264 assert(ios.width() == 0);
11265 }
11266 ios.width(25);
11267 right(ios);
11268 {
11269 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11270 std::string ex(str, iter.base());
11271 assert(ex == "**********************NAN");
11272 assert(ios.width() == 0);
11273 }
11274 ios.width(25);
11275 internal(ios);
11276 {
11277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11278 std::string ex(str, iter.base());
11279 assert(ex == "**********************NAN");
11280 assert(ios.width() == 0);
11281 }
11282 }
11283 ios.imbue(lg);
11284 {
11285 ios.width(0);
11286 {
11287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11288 std::string ex(str, iter.base());
11289 assert(ex == "NAN");
11290 assert(ios.width() == 0);
11291 }
11292 ios.width(25);
11293 left(ios);
11294 {
11295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11296 std::string ex(str, iter.base());
11297 assert(ex == "NAN**********************");
11298 assert(ios.width() == 0);
11299 }
11300 ios.width(25);
11301 right(ios);
11302 {
11303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11304 std::string ex(str, iter.base());
11305 assert(ex == "**********************NAN");
11306 assert(ios.width() == 0);
11307 }
11308 ios.width(25);
11309 internal(ios);
11310 {
11311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11312 std::string ex(str, iter.base());
11313 assert(ex == "**********************NAN");
11314 assert(ios.width() == 0);
11315 }
11316 }
11317 }
11318 }
11319 }
11320 }
11321 ios.precision(1);
11322 {}
11323 ios.precision(6);
11324 {}
11325 ios.precision(16);
11326 {}
11327 ios.precision(60);
11328 {}
11329 }
11330 }
11331 }
11332
test6()11333 void test6()
11334 {
11335 char str[200];
11336 output_iterator<char*> iter;
11337 std::locale lc = std::locale::classic();
11338 std::locale lg(lc, new my_numpunct);
11339 const my_facet f(1);
11340 {
11341 long double v = +0.;
11342 std::ios ios(0);
11343 fixed(ios);
11344 // %f
11345 {
11346 ios.precision(0);
11347 {
11348 nouppercase(ios);
11349 {
11350 noshowpos(ios);
11351 {
11352 noshowpoint(ios);
11353 {
11354 ios.imbue(lc);
11355 {
11356 ios.width(0);
11357 {
11358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11359 std::string ex(str, iter.base());
11360 assert(ex == "0");
11361 assert(ios.width() == 0);
11362 }
11363 ios.width(25);
11364 left(ios);
11365 {
11366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11367 std::string ex(str, iter.base());
11368 assert(ex == "0************************");
11369 assert(ios.width() == 0);
11370 }
11371 ios.width(25);
11372 right(ios);
11373 {
11374 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11375 std::string ex(str, iter.base());
11376 assert(ex == "************************0");
11377 assert(ios.width() == 0);
11378 }
11379 ios.width(25);
11380 internal(ios);
11381 {
11382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11383 std::string ex(str, iter.base());
11384 assert(ex == "************************0");
11385 assert(ios.width() == 0);
11386 }
11387 }
11388 ios.imbue(lg);
11389 {
11390 ios.width(0);
11391 {
11392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11393 std::string ex(str, iter.base());
11394 assert(ex == "0");
11395 assert(ios.width() == 0);
11396 }
11397 ios.width(25);
11398 left(ios);
11399 {
11400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11401 std::string ex(str, iter.base());
11402 assert(ex == "0************************");
11403 assert(ios.width() == 0);
11404 }
11405 ios.width(25);
11406 right(ios);
11407 {
11408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11409 std::string ex(str, iter.base());
11410 assert(ex == "************************0");
11411 assert(ios.width() == 0);
11412 }
11413 ios.width(25);
11414 internal(ios);
11415 {
11416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11417 std::string ex(str, iter.base());
11418 assert(ex == "************************0");
11419 assert(ios.width() == 0);
11420 }
11421 }
11422 }
11423 showpoint(ios);
11424 {
11425 ios.imbue(lc);
11426 {
11427 ios.width(0);
11428 {
11429 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11430 std::string ex(str, iter.base());
11431 assert(ex == "0.");
11432 assert(ios.width() == 0);
11433 }
11434 ios.width(25);
11435 left(ios);
11436 {
11437 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11438 std::string ex(str, iter.base());
11439 assert(ex == "0.***********************");
11440 assert(ios.width() == 0);
11441 }
11442 ios.width(25);
11443 right(ios);
11444 {
11445 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11446 std::string ex(str, iter.base());
11447 assert(ex == "***********************0.");
11448 assert(ios.width() == 0);
11449 }
11450 ios.width(25);
11451 internal(ios);
11452 {
11453 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11454 std::string ex(str, iter.base());
11455 assert(ex == "***********************0.");
11456 assert(ios.width() == 0);
11457 }
11458 }
11459 ios.imbue(lg);
11460 {
11461 ios.width(0);
11462 {
11463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11464 std::string ex(str, iter.base());
11465 assert(ex == "0;");
11466 assert(ios.width() == 0);
11467 }
11468 ios.width(25);
11469 left(ios);
11470 {
11471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11472 std::string ex(str, iter.base());
11473 assert(ex == "0;***********************");
11474 assert(ios.width() == 0);
11475 }
11476 ios.width(25);
11477 right(ios);
11478 {
11479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11480 std::string ex(str, iter.base());
11481 assert(ex == "***********************0;");
11482 assert(ios.width() == 0);
11483 }
11484 ios.width(25);
11485 internal(ios);
11486 {
11487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11488 std::string ex(str, iter.base());
11489 assert(ex == "***********************0;");
11490 assert(ios.width() == 0);
11491 }
11492 }
11493 }
11494 }
11495 showpos(ios);
11496 {
11497 noshowpoint(ios);
11498 {
11499 ios.imbue(lc);
11500 {
11501 ios.width(0);
11502 {
11503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11504 std::string ex(str, iter.base());
11505 assert(ex == "+0");
11506 assert(ios.width() == 0);
11507 }
11508 ios.width(25);
11509 left(ios);
11510 {
11511 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11512 std::string ex(str, iter.base());
11513 assert(ex == "+0***********************");
11514 assert(ios.width() == 0);
11515 }
11516 ios.width(25);
11517 right(ios);
11518 {
11519 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11520 std::string ex(str, iter.base());
11521 assert(ex == "***********************+0");
11522 assert(ios.width() == 0);
11523 }
11524 ios.width(25);
11525 internal(ios);
11526 {
11527 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11528 std::string ex(str, iter.base());
11529 assert(ex == "+***********************0");
11530 assert(ios.width() == 0);
11531 }
11532 }
11533 ios.imbue(lg);
11534 {
11535 ios.width(0);
11536 {
11537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11538 std::string ex(str, iter.base());
11539 assert(ex == "+0");
11540 assert(ios.width() == 0);
11541 }
11542 ios.width(25);
11543 left(ios);
11544 {
11545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11546 std::string ex(str, iter.base());
11547 assert(ex == "+0***********************");
11548 assert(ios.width() == 0);
11549 }
11550 ios.width(25);
11551 right(ios);
11552 {
11553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11554 std::string ex(str, iter.base());
11555 assert(ex == "***********************+0");
11556 assert(ios.width() == 0);
11557 }
11558 ios.width(25);
11559 internal(ios);
11560 {
11561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11562 std::string ex(str, iter.base());
11563 assert(ex == "+***********************0");
11564 assert(ios.width() == 0);
11565 }
11566 }
11567 }
11568 showpoint(ios);
11569 {
11570 ios.imbue(lc);
11571 {
11572 ios.width(0);
11573 {
11574 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11575 std::string ex(str, iter.base());
11576 assert(ex == "+0.");
11577 assert(ios.width() == 0);
11578 }
11579 ios.width(25);
11580 left(ios);
11581 {
11582 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11583 std::string ex(str, iter.base());
11584 assert(ex == "+0.**********************");
11585 assert(ios.width() == 0);
11586 }
11587 ios.width(25);
11588 right(ios);
11589 {
11590 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11591 std::string ex(str, iter.base());
11592 assert(ex == "**********************+0.");
11593 assert(ios.width() == 0);
11594 }
11595 ios.width(25);
11596 internal(ios);
11597 {
11598 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11599 std::string ex(str, iter.base());
11600 assert(ex == "+**********************0.");
11601 assert(ios.width() == 0);
11602 }
11603 }
11604 ios.imbue(lg);
11605 {
11606 ios.width(0);
11607 {
11608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11609 std::string ex(str, iter.base());
11610 assert(ex == "+0;");
11611 assert(ios.width() == 0);
11612 }
11613 ios.width(25);
11614 left(ios);
11615 {
11616 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11617 std::string ex(str, iter.base());
11618 assert(ex == "+0;**********************");
11619 assert(ios.width() == 0);
11620 }
11621 ios.width(25);
11622 right(ios);
11623 {
11624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11625 std::string ex(str, iter.base());
11626 assert(ex == "**********************+0;");
11627 assert(ios.width() == 0);
11628 }
11629 ios.width(25);
11630 internal(ios);
11631 {
11632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11633 std::string ex(str, iter.base());
11634 assert(ex == "+**********************0;");
11635 assert(ios.width() == 0);
11636 }
11637 }
11638 }
11639 }
11640 }
11641 uppercase(ios);
11642 {
11643 noshowpos(ios);
11644 {
11645 noshowpoint(ios);
11646 {
11647 ios.imbue(lc);
11648 {
11649 ios.width(0);
11650 {
11651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11652 std::string ex(str, iter.base());
11653 assert(ex == "0");
11654 assert(ios.width() == 0);
11655 }
11656 ios.width(25);
11657 left(ios);
11658 {
11659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11660 std::string ex(str, iter.base());
11661 assert(ex == "0************************");
11662 assert(ios.width() == 0);
11663 }
11664 ios.width(25);
11665 right(ios);
11666 {
11667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11668 std::string ex(str, iter.base());
11669 assert(ex == "************************0");
11670 assert(ios.width() == 0);
11671 }
11672 ios.width(25);
11673 internal(ios);
11674 {
11675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11676 std::string ex(str, iter.base());
11677 assert(ex == "************************0");
11678 assert(ios.width() == 0);
11679 }
11680 }
11681 ios.imbue(lg);
11682 {
11683 ios.width(0);
11684 {
11685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11686 std::string ex(str, iter.base());
11687 assert(ex == "0");
11688 assert(ios.width() == 0);
11689 }
11690 ios.width(25);
11691 left(ios);
11692 {
11693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11694 std::string ex(str, iter.base());
11695 assert(ex == "0************************");
11696 assert(ios.width() == 0);
11697 }
11698 ios.width(25);
11699 right(ios);
11700 {
11701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11702 std::string ex(str, iter.base());
11703 assert(ex == "************************0");
11704 assert(ios.width() == 0);
11705 }
11706 ios.width(25);
11707 internal(ios);
11708 {
11709 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11710 std::string ex(str, iter.base());
11711 assert(ex == "************************0");
11712 assert(ios.width() == 0);
11713 }
11714 }
11715 }
11716 showpoint(ios);
11717 {
11718 ios.imbue(lc);
11719 {
11720 ios.width(0);
11721 {
11722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11723 std::string ex(str, iter.base());
11724 assert(ex == "0.");
11725 assert(ios.width() == 0);
11726 }
11727 ios.width(25);
11728 left(ios);
11729 {
11730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11731 std::string ex(str, iter.base());
11732 assert(ex == "0.***********************");
11733 assert(ios.width() == 0);
11734 }
11735 ios.width(25);
11736 right(ios);
11737 {
11738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11739 std::string ex(str, iter.base());
11740 assert(ex == "***********************0.");
11741 assert(ios.width() == 0);
11742 }
11743 ios.width(25);
11744 internal(ios);
11745 {
11746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11747 std::string ex(str, iter.base());
11748 assert(ex == "***********************0.");
11749 assert(ios.width() == 0);
11750 }
11751 }
11752 ios.imbue(lg);
11753 {
11754 ios.width(0);
11755 {
11756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11757 std::string ex(str, iter.base());
11758 assert(ex == "0;");
11759 assert(ios.width() == 0);
11760 }
11761 ios.width(25);
11762 left(ios);
11763 {
11764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11765 std::string ex(str, iter.base());
11766 assert(ex == "0;***********************");
11767 assert(ios.width() == 0);
11768 }
11769 ios.width(25);
11770 right(ios);
11771 {
11772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11773 std::string ex(str, iter.base());
11774 assert(ex == "***********************0;");
11775 assert(ios.width() == 0);
11776 }
11777 ios.width(25);
11778 internal(ios);
11779 {
11780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11781 std::string ex(str, iter.base());
11782 assert(ex == "***********************0;");
11783 assert(ios.width() == 0);
11784 }
11785 }
11786 }
11787 }
11788 showpos(ios);
11789 {
11790 noshowpoint(ios);
11791 {
11792 ios.imbue(lc);
11793 {
11794 ios.width(0);
11795 {
11796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11797 std::string ex(str, iter.base());
11798 assert(ex == "+0");
11799 assert(ios.width() == 0);
11800 }
11801 ios.width(25);
11802 left(ios);
11803 {
11804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11805 std::string ex(str, iter.base());
11806 assert(ex == "+0***********************");
11807 assert(ios.width() == 0);
11808 }
11809 ios.width(25);
11810 right(ios);
11811 {
11812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11813 std::string ex(str, iter.base());
11814 assert(ex == "***********************+0");
11815 assert(ios.width() == 0);
11816 }
11817 ios.width(25);
11818 internal(ios);
11819 {
11820 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11821 std::string ex(str, iter.base());
11822 assert(ex == "+***********************0");
11823 assert(ios.width() == 0);
11824 }
11825 }
11826 ios.imbue(lg);
11827 {
11828 ios.width(0);
11829 {
11830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11831 std::string ex(str, iter.base());
11832 assert(ex == "+0");
11833 assert(ios.width() == 0);
11834 }
11835 ios.width(25);
11836 left(ios);
11837 {
11838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11839 std::string ex(str, iter.base());
11840 assert(ex == "+0***********************");
11841 assert(ios.width() == 0);
11842 }
11843 ios.width(25);
11844 right(ios);
11845 {
11846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11847 std::string ex(str, iter.base());
11848 assert(ex == "***********************+0");
11849 assert(ios.width() == 0);
11850 }
11851 ios.width(25);
11852 internal(ios);
11853 {
11854 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11855 std::string ex(str, iter.base());
11856 assert(ex == "+***********************0");
11857 assert(ios.width() == 0);
11858 }
11859 }
11860 }
11861 showpoint(ios);
11862 {
11863 ios.imbue(lc);
11864 {
11865 ios.width(0);
11866 {
11867 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11868 std::string ex(str, iter.base());
11869 assert(ex == "+0.");
11870 assert(ios.width() == 0);
11871 }
11872 ios.width(25);
11873 left(ios);
11874 {
11875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11876 std::string ex(str, iter.base());
11877 assert(ex == "+0.**********************");
11878 assert(ios.width() == 0);
11879 }
11880 ios.width(25);
11881 right(ios);
11882 {
11883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11884 std::string ex(str, iter.base());
11885 assert(ex == "**********************+0.");
11886 assert(ios.width() == 0);
11887 }
11888 ios.width(25);
11889 internal(ios);
11890 {
11891 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11892 std::string ex(str, iter.base());
11893 assert(ex == "+**********************0.");
11894 assert(ios.width() == 0);
11895 }
11896 }
11897 ios.imbue(lg);
11898 {
11899 ios.width(0);
11900 {
11901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11902 std::string ex(str, iter.base());
11903 assert(ex == "+0;");
11904 assert(ios.width() == 0);
11905 }
11906 ios.width(25);
11907 left(ios);
11908 {
11909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11910 std::string ex(str, iter.base());
11911 assert(ex == "+0;**********************");
11912 assert(ios.width() == 0);
11913 }
11914 ios.width(25);
11915 right(ios);
11916 {
11917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11918 std::string ex(str, iter.base());
11919 assert(ex == "**********************+0;");
11920 assert(ios.width() == 0);
11921 }
11922 ios.width(25);
11923 internal(ios);
11924 {
11925 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11926 std::string ex(str, iter.base());
11927 assert(ex == "+**********************0;");
11928 assert(ios.width() == 0);
11929 }
11930 }
11931 }
11932 }
11933 }
11934 }
11935 ios.precision(1);
11936 {
11937 nouppercase(ios);
11938 {
11939 noshowpos(ios);
11940 {
11941 noshowpoint(ios);
11942 {
11943 ios.imbue(lc);
11944 {
11945 ios.width(0);
11946 {
11947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11948 std::string ex(str, iter.base());
11949 assert(ex == "0.0");
11950 assert(ios.width() == 0);
11951 }
11952 ios.width(25);
11953 left(ios);
11954 {
11955 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11956 std::string ex(str, iter.base());
11957 assert(ex == "0.0**********************");
11958 assert(ios.width() == 0);
11959 }
11960 ios.width(25);
11961 right(ios);
11962 {
11963 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11964 std::string ex(str, iter.base());
11965 assert(ex == "**********************0.0");
11966 assert(ios.width() == 0);
11967 }
11968 ios.width(25);
11969 internal(ios);
11970 {
11971 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11972 std::string ex(str, iter.base());
11973 assert(ex == "**********************0.0");
11974 assert(ios.width() == 0);
11975 }
11976 }
11977 ios.imbue(lg);
11978 {
11979 ios.width(0);
11980 {
11981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11982 std::string ex(str, iter.base());
11983 assert(ex == "0;0");
11984 assert(ios.width() == 0);
11985 }
11986 ios.width(25);
11987 left(ios);
11988 {
11989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11990 std::string ex(str, iter.base());
11991 assert(ex == "0;0**********************");
11992 assert(ios.width() == 0);
11993 }
11994 ios.width(25);
11995 right(ios);
11996 {
11997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11998 std::string ex(str, iter.base());
11999 assert(ex == "**********************0;0");
12000 assert(ios.width() == 0);
12001 }
12002 ios.width(25);
12003 internal(ios);
12004 {
12005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12006 std::string ex(str, iter.base());
12007 assert(ex == "**********************0;0");
12008 assert(ios.width() == 0);
12009 }
12010 }
12011 }
12012 showpoint(ios);
12013 {
12014 ios.imbue(lc);
12015 {
12016 ios.width(0);
12017 {
12018 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12019 std::string ex(str, iter.base());
12020 assert(ex == "0.0");
12021 assert(ios.width() == 0);
12022 }
12023 ios.width(25);
12024 left(ios);
12025 {
12026 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12027 std::string ex(str, iter.base());
12028 assert(ex == "0.0**********************");
12029 assert(ios.width() == 0);
12030 }
12031 ios.width(25);
12032 right(ios);
12033 {
12034 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12035 std::string ex(str, iter.base());
12036 assert(ex == "**********************0.0");
12037 assert(ios.width() == 0);
12038 }
12039 ios.width(25);
12040 internal(ios);
12041 {
12042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12043 std::string ex(str, iter.base());
12044 assert(ex == "**********************0.0");
12045 assert(ios.width() == 0);
12046 }
12047 }
12048 ios.imbue(lg);
12049 {
12050 ios.width(0);
12051 {
12052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12053 std::string ex(str, iter.base());
12054 assert(ex == "0;0");
12055 assert(ios.width() == 0);
12056 }
12057 ios.width(25);
12058 left(ios);
12059 {
12060 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12061 std::string ex(str, iter.base());
12062 assert(ex == "0;0**********************");
12063 assert(ios.width() == 0);
12064 }
12065 ios.width(25);
12066 right(ios);
12067 {
12068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12069 std::string ex(str, iter.base());
12070 assert(ex == "**********************0;0");
12071 assert(ios.width() == 0);
12072 }
12073 ios.width(25);
12074 internal(ios);
12075 {
12076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12077 std::string ex(str, iter.base());
12078 assert(ex == "**********************0;0");
12079 assert(ios.width() == 0);
12080 }
12081 }
12082 }
12083 }
12084 showpos(ios);
12085 {
12086 noshowpoint(ios);
12087 {
12088 ios.imbue(lc);
12089 {
12090 ios.width(0);
12091 {
12092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12093 std::string ex(str, iter.base());
12094 assert(ex == "+0.0");
12095 assert(ios.width() == 0);
12096 }
12097 ios.width(25);
12098 left(ios);
12099 {
12100 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12101 std::string ex(str, iter.base());
12102 assert(ex == "+0.0*********************");
12103 assert(ios.width() == 0);
12104 }
12105 ios.width(25);
12106 right(ios);
12107 {
12108 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12109 std::string ex(str, iter.base());
12110 assert(ex == "*********************+0.0");
12111 assert(ios.width() == 0);
12112 }
12113 ios.width(25);
12114 internal(ios);
12115 {
12116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12117 std::string ex(str, iter.base());
12118 assert(ex == "+*********************0.0");
12119 assert(ios.width() == 0);
12120 }
12121 }
12122 ios.imbue(lg);
12123 {
12124 ios.width(0);
12125 {
12126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12127 std::string ex(str, iter.base());
12128 assert(ex == "+0;0");
12129 assert(ios.width() == 0);
12130 }
12131 ios.width(25);
12132 left(ios);
12133 {
12134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12135 std::string ex(str, iter.base());
12136 assert(ex == "+0;0*********************");
12137 assert(ios.width() == 0);
12138 }
12139 ios.width(25);
12140 right(ios);
12141 {
12142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12143 std::string ex(str, iter.base());
12144 assert(ex == "*********************+0;0");
12145 assert(ios.width() == 0);
12146 }
12147 ios.width(25);
12148 internal(ios);
12149 {
12150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12151 std::string ex(str, iter.base());
12152 assert(ex == "+*********************0;0");
12153 assert(ios.width() == 0);
12154 }
12155 }
12156 }
12157 showpoint(ios);
12158 {
12159 ios.imbue(lc);
12160 {
12161 ios.width(0);
12162 {
12163 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12164 std::string ex(str, iter.base());
12165 assert(ex == "+0.0");
12166 assert(ios.width() == 0);
12167 }
12168 ios.width(25);
12169 left(ios);
12170 {
12171 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12172 std::string ex(str, iter.base());
12173 assert(ex == "+0.0*********************");
12174 assert(ios.width() == 0);
12175 }
12176 ios.width(25);
12177 right(ios);
12178 {
12179 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12180 std::string ex(str, iter.base());
12181 assert(ex == "*********************+0.0");
12182 assert(ios.width() == 0);
12183 }
12184 ios.width(25);
12185 internal(ios);
12186 {
12187 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12188 std::string ex(str, iter.base());
12189 assert(ex == "+*********************0.0");
12190 assert(ios.width() == 0);
12191 }
12192 }
12193 ios.imbue(lg);
12194 {
12195 ios.width(0);
12196 {
12197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12198 std::string ex(str, iter.base());
12199 assert(ex == "+0;0");
12200 assert(ios.width() == 0);
12201 }
12202 ios.width(25);
12203 left(ios);
12204 {
12205 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12206 std::string ex(str, iter.base());
12207 assert(ex == "+0;0*********************");
12208 assert(ios.width() == 0);
12209 }
12210 ios.width(25);
12211 right(ios);
12212 {
12213 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12214 std::string ex(str, iter.base());
12215 assert(ex == "*********************+0;0");
12216 assert(ios.width() == 0);
12217 }
12218 ios.width(25);
12219 internal(ios);
12220 {
12221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12222 std::string ex(str, iter.base());
12223 assert(ex == "+*********************0;0");
12224 assert(ios.width() == 0);
12225 }
12226 }
12227 }
12228 }
12229 }
12230 uppercase(ios);
12231 {
12232 noshowpos(ios);
12233 {
12234 noshowpoint(ios);
12235 {
12236 ios.imbue(lc);
12237 {
12238 ios.width(0);
12239 {
12240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12241 std::string ex(str, iter.base());
12242 assert(ex == "0.0");
12243 assert(ios.width() == 0);
12244 }
12245 ios.width(25);
12246 left(ios);
12247 {
12248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12249 std::string ex(str, iter.base());
12250 assert(ex == "0.0**********************");
12251 assert(ios.width() == 0);
12252 }
12253 ios.width(25);
12254 right(ios);
12255 {
12256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12257 std::string ex(str, iter.base());
12258 assert(ex == "**********************0.0");
12259 assert(ios.width() == 0);
12260 }
12261 ios.width(25);
12262 internal(ios);
12263 {
12264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12265 std::string ex(str, iter.base());
12266 assert(ex == "**********************0.0");
12267 assert(ios.width() == 0);
12268 }
12269 }
12270 ios.imbue(lg);
12271 {
12272 ios.width(0);
12273 {
12274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12275 std::string ex(str, iter.base());
12276 assert(ex == "0;0");
12277 assert(ios.width() == 0);
12278 }
12279 ios.width(25);
12280 left(ios);
12281 {
12282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12283 std::string ex(str, iter.base());
12284 assert(ex == "0;0**********************");
12285 assert(ios.width() == 0);
12286 }
12287 ios.width(25);
12288 right(ios);
12289 {
12290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12291 std::string ex(str, iter.base());
12292 assert(ex == "**********************0;0");
12293 assert(ios.width() == 0);
12294 }
12295 ios.width(25);
12296 internal(ios);
12297 {
12298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12299 std::string ex(str, iter.base());
12300 assert(ex == "**********************0;0");
12301 assert(ios.width() == 0);
12302 }
12303 }
12304 }
12305 showpoint(ios);
12306 {
12307 ios.imbue(lc);
12308 {
12309 ios.width(0);
12310 {
12311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12312 std::string ex(str, iter.base());
12313 assert(ex == "0.0");
12314 assert(ios.width() == 0);
12315 }
12316 ios.width(25);
12317 left(ios);
12318 {
12319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12320 std::string ex(str, iter.base());
12321 assert(ex == "0.0**********************");
12322 assert(ios.width() == 0);
12323 }
12324 ios.width(25);
12325 right(ios);
12326 {
12327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12328 std::string ex(str, iter.base());
12329 assert(ex == "**********************0.0");
12330 assert(ios.width() == 0);
12331 }
12332 ios.width(25);
12333 internal(ios);
12334 {
12335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12336 std::string ex(str, iter.base());
12337 assert(ex == "**********************0.0");
12338 assert(ios.width() == 0);
12339 }
12340 }
12341 ios.imbue(lg);
12342 {
12343 ios.width(0);
12344 {
12345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12346 std::string ex(str, iter.base());
12347 assert(ex == "0;0");
12348 assert(ios.width() == 0);
12349 }
12350 ios.width(25);
12351 left(ios);
12352 {
12353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12354 std::string ex(str, iter.base());
12355 assert(ex == "0;0**********************");
12356 assert(ios.width() == 0);
12357 }
12358 ios.width(25);
12359 right(ios);
12360 {
12361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12362 std::string ex(str, iter.base());
12363 assert(ex == "**********************0;0");
12364 assert(ios.width() == 0);
12365 }
12366 ios.width(25);
12367 internal(ios);
12368 {
12369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12370 std::string ex(str, iter.base());
12371 assert(ex == "**********************0;0");
12372 assert(ios.width() == 0);
12373 }
12374 }
12375 }
12376 }
12377 showpos(ios);
12378 {
12379 noshowpoint(ios);
12380 {
12381 ios.imbue(lc);
12382 {
12383 ios.width(0);
12384 {
12385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12386 std::string ex(str, iter.base());
12387 assert(ex == "+0.0");
12388 assert(ios.width() == 0);
12389 }
12390 ios.width(25);
12391 left(ios);
12392 {
12393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12394 std::string ex(str, iter.base());
12395 assert(ex == "+0.0*********************");
12396 assert(ios.width() == 0);
12397 }
12398 ios.width(25);
12399 right(ios);
12400 {
12401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12402 std::string ex(str, iter.base());
12403 assert(ex == "*********************+0.0");
12404 assert(ios.width() == 0);
12405 }
12406 ios.width(25);
12407 internal(ios);
12408 {
12409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12410 std::string ex(str, iter.base());
12411 assert(ex == "+*********************0.0");
12412 assert(ios.width() == 0);
12413 }
12414 }
12415 ios.imbue(lg);
12416 {
12417 ios.width(0);
12418 {
12419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12420 std::string ex(str, iter.base());
12421 assert(ex == "+0;0");
12422 assert(ios.width() == 0);
12423 }
12424 ios.width(25);
12425 left(ios);
12426 {
12427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12428 std::string ex(str, iter.base());
12429 assert(ex == "+0;0*********************");
12430 assert(ios.width() == 0);
12431 }
12432 ios.width(25);
12433 right(ios);
12434 {
12435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12436 std::string ex(str, iter.base());
12437 assert(ex == "*********************+0;0");
12438 assert(ios.width() == 0);
12439 }
12440 ios.width(25);
12441 internal(ios);
12442 {
12443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12444 std::string ex(str, iter.base());
12445 assert(ex == "+*********************0;0");
12446 assert(ios.width() == 0);
12447 }
12448 }
12449 }
12450 showpoint(ios);
12451 {
12452 ios.imbue(lc);
12453 {
12454 ios.width(0);
12455 {
12456 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12457 std::string ex(str, iter.base());
12458 assert(ex == "+0.0");
12459 assert(ios.width() == 0);
12460 }
12461 ios.width(25);
12462 left(ios);
12463 {
12464 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12465 std::string ex(str, iter.base());
12466 assert(ex == "+0.0*********************");
12467 assert(ios.width() == 0);
12468 }
12469 ios.width(25);
12470 right(ios);
12471 {
12472 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12473 std::string ex(str, iter.base());
12474 assert(ex == "*********************+0.0");
12475 assert(ios.width() == 0);
12476 }
12477 ios.width(25);
12478 internal(ios);
12479 {
12480 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12481 std::string ex(str, iter.base());
12482 assert(ex == "+*********************0.0");
12483 assert(ios.width() == 0);
12484 }
12485 }
12486 ios.imbue(lg);
12487 {
12488 ios.width(0);
12489 {
12490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12491 std::string ex(str, iter.base());
12492 assert(ex == "+0;0");
12493 assert(ios.width() == 0);
12494 }
12495 ios.width(25);
12496 left(ios);
12497 {
12498 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12499 std::string ex(str, iter.base());
12500 assert(ex == "+0;0*********************");
12501 assert(ios.width() == 0);
12502 }
12503 ios.width(25);
12504 right(ios);
12505 {
12506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12507 std::string ex(str, iter.base());
12508 assert(ex == "*********************+0;0");
12509 assert(ios.width() == 0);
12510 }
12511 ios.width(25);
12512 internal(ios);
12513 {
12514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12515 std::string ex(str, iter.base());
12516 assert(ex == "+*********************0;0");
12517 assert(ios.width() == 0);
12518 }
12519 }
12520 }
12521 }
12522 }
12523 }
12524 ios.precision(6);
12525 {
12526 nouppercase(ios);
12527 {
12528 noshowpos(ios);
12529 {
12530 noshowpoint(ios);
12531 {
12532 ios.imbue(lc);
12533 {
12534 ios.width(0);
12535 {
12536 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12537 std::string ex(str, iter.base());
12538 assert(ex == "0.000000");
12539 assert(ios.width() == 0);
12540 }
12541 ios.width(25);
12542 left(ios);
12543 {
12544 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12545 std::string ex(str, iter.base());
12546 assert(ex == "0.000000*****************");
12547 assert(ios.width() == 0);
12548 }
12549 ios.width(25);
12550 right(ios);
12551 {
12552 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12553 std::string ex(str, iter.base());
12554 assert(ex == "*****************0.000000");
12555 assert(ios.width() == 0);
12556 }
12557 ios.width(25);
12558 internal(ios);
12559 {
12560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12561 std::string ex(str, iter.base());
12562 assert(ex == "*****************0.000000");
12563 assert(ios.width() == 0);
12564 }
12565 }
12566 ios.imbue(lg);
12567 {
12568 ios.width(0);
12569 {
12570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12571 std::string ex(str, iter.base());
12572 assert(ex == "0;000000");
12573 assert(ios.width() == 0);
12574 }
12575 ios.width(25);
12576 left(ios);
12577 {
12578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12579 std::string ex(str, iter.base());
12580 assert(ex == "0;000000*****************");
12581 assert(ios.width() == 0);
12582 }
12583 ios.width(25);
12584 right(ios);
12585 {
12586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12587 std::string ex(str, iter.base());
12588 assert(ex == "*****************0;000000");
12589 assert(ios.width() == 0);
12590 }
12591 ios.width(25);
12592 internal(ios);
12593 {
12594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12595 std::string ex(str, iter.base());
12596 assert(ex == "*****************0;000000");
12597 assert(ios.width() == 0);
12598 }
12599 }
12600 }
12601 showpoint(ios);
12602 {
12603 ios.imbue(lc);
12604 {
12605 ios.width(0);
12606 {
12607 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12608 std::string ex(str, iter.base());
12609 assert(ex == "0.000000");
12610 assert(ios.width() == 0);
12611 }
12612 ios.width(25);
12613 left(ios);
12614 {
12615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12616 std::string ex(str, iter.base());
12617 assert(ex == "0.000000*****************");
12618 assert(ios.width() == 0);
12619 }
12620 ios.width(25);
12621 right(ios);
12622 {
12623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12624 std::string ex(str, iter.base());
12625 assert(ex == "*****************0.000000");
12626 assert(ios.width() == 0);
12627 }
12628 ios.width(25);
12629 internal(ios);
12630 {
12631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12632 std::string ex(str, iter.base());
12633 assert(ex == "*****************0.000000");
12634 assert(ios.width() == 0);
12635 }
12636 }
12637 ios.imbue(lg);
12638 {
12639 ios.width(0);
12640 {
12641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12642 std::string ex(str, iter.base());
12643 assert(ex == "0;000000");
12644 assert(ios.width() == 0);
12645 }
12646 ios.width(25);
12647 left(ios);
12648 {
12649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12650 std::string ex(str, iter.base());
12651 assert(ex == "0;000000*****************");
12652 assert(ios.width() == 0);
12653 }
12654 ios.width(25);
12655 right(ios);
12656 {
12657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12658 std::string ex(str, iter.base());
12659 assert(ex == "*****************0;000000");
12660 assert(ios.width() == 0);
12661 }
12662 ios.width(25);
12663 internal(ios);
12664 {
12665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12666 std::string ex(str, iter.base());
12667 assert(ex == "*****************0;000000");
12668 assert(ios.width() == 0);
12669 }
12670 }
12671 }
12672 }
12673 showpos(ios);
12674 {
12675 noshowpoint(ios);
12676 {
12677 ios.imbue(lc);
12678 {
12679 ios.width(0);
12680 {
12681 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12682 std::string ex(str, iter.base());
12683 assert(ex == "+0.000000");
12684 assert(ios.width() == 0);
12685 }
12686 ios.width(25);
12687 left(ios);
12688 {
12689 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12690 std::string ex(str, iter.base());
12691 assert(ex == "+0.000000****************");
12692 assert(ios.width() == 0);
12693 }
12694 ios.width(25);
12695 right(ios);
12696 {
12697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12698 std::string ex(str, iter.base());
12699 assert(ex == "****************+0.000000");
12700 assert(ios.width() == 0);
12701 }
12702 ios.width(25);
12703 internal(ios);
12704 {
12705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12706 std::string ex(str, iter.base());
12707 assert(ex == "+****************0.000000");
12708 assert(ios.width() == 0);
12709 }
12710 }
12711 ios.imbue(lg);
12712 {
12713 ios.width(0);
12714 {
12715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12716 std::string ex(str, iter.base());
12717 assert(ex == "+0;000000");
12718 assert(ios.width() == 0);
12719 }
12720 ios.width(25);
12721 left(ios);
12722 {
12723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12724 std::string ex(str, iter.base());
12725 assert(ex == "+0;000000****************");
12726 assert(ios.width() == 0);
12727 }
12728 ios.width(25);
12729 right(ios);
12730 {
12731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12732 std::string ex(str, iter.base());
12733 assert(ex == "****************+0;000000");
12734 assert(ios.width() == 0);
12735 }
12736 ios.width(25);
12737 internal(ios);
12738 {
12739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12740 std::string ex(str, iter.base());
12741 assert(ex == "+****************0;000000");
12742 assert(ios.width() == 0);
12743 }
12744 }
12745 }
12746 showpoint(ios);
12747 {
12748 ios.imbue(lc);
12749 {
12750 ios.width(0);
12751 {
12752 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12753 std::string ex(str, iter.base());
12754 assert(ex == "+0.000000");
12755 assert(ios.width() == 0);
12756 }
12757 ios.width(25);
12758 left(ios);
12759 {
12760 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12761 std::string ex(str, iter.base());
12762 assert(ex == "+0.000000****************");
12763 assert(ios.width() == 0);
12764 }
12765 ios.width(25);
12766 right(ios);
12767 {
12768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12769 std::string ex(str, iter.base());
12770 assert(ex == "****************+0.000000");
12771 assert(ios.width() == 0);
12772 }
12773 ios.width(25);
12774 internal(ios);
12775 {
12776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12777 std::string ex(str, iter.base());
12778 assert(ex == "+****************0.000000");
12779 assert(ios.width() == 0);
12780 }
12781 }
12782 ios.imbue(lg);
12783 {
12784 ios.width(0);
12785 {
12786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12787 std::string ex(str, iter.base());
12788 assert(ex == "+0;000000");
12789 assert(ios.width() == 0);
12790 }
12791 ios.width(25);
12792 left(ios);
12793 {
12794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12795 std::string ex(str, iter.base());
12796 assert(ex == "+0;000000****************");
12797 assert(ios.width() == 0);
12798 }
12799 ios.width(25);
12800 right(ios);
12801 {
12802 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12803 std::string ex(str, iter.base());
12804 assert(ex == "****************+0;000000");
12805 assert(ios.width() == 0);
12806 }
12807 ios.width(25);
12808 internal(ios);
12809 {
12810 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12811 std::string ex(str, iter.base());
12812 assert(ex == "+****************0;000000");
12813 assert(ios.width() == 0);
12814 }
12815 }
12816 }
12817 }
12818 }
12819 uppercase(ios);
12820 {
12821 noshowpos(ios);
12822 {
12823 noshowpoint(ios);
12824 {
12825 ios.imbue(lc);
12826 {
12827 ios.width(0);
12828 {
12829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12830 std::string ex(str, iter.base());
12831 assert(ex == "0.000000");
12832 assert(ios.width() == 0);
12833 }
12834 ios.width(25);
12835 left(ios);
12836 {
12837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12838 std::string ex(str, iter.base());
12839 assert(ex == "0.000000*****************");
12840 assert(ios.width() == 0);
12841 }
12842 ios.width(25);
12843 right(ios);
12844 {
12845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12846 std::string ex(str, iter.base());
12847 assert(ex == "*****************0.000000");
12848 assert(ios.width() == 0);
12849 }
12850 ios.width(25);
12851 internal(ios);
12852 {
12853 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12854 std::string ex(str, iter.base());
12855 assert(ex == "*****************0.000000");
12856 assert(ios.width() == 0);
12857 }
12858 }
12859 ios.imbue(lg);
12860 {
12861 ios.width(0);
12862 {
12863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12864 std::string ex(str, iter.base());
12865 assert(ex == "0;000000");
12866 assert(ios.width() == 0);
12867 }
12868 ios.width(25);
12869 left(ios);
12870 {
12871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12872 std::string ex(str, iter.base());
12873 assert(ex == "0;000000*****************");
12874 assert(ios.width() == 0);
12875 }
12876 ios.width(25);
12877 right(ios);
12878 {
12879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12880 std::string ex(str, iter.base());
12881 assert(ex == "*****************0;000000");
12882 assert(ios.width() == 0);
12883 }
12884 ios.width(25);
12885 internal(ios);
12886 {
12887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12888 std::string ex(str, iter.base());
12889 assert(ex == "*****************0;000000");
12890 assert(ios.width() == 0);
12891 }
12892 }
12893 }
12894 showpoint(ios);
12895 {
12896 ios.imbue(lc);
12897 {
12898 ios.width(0);
12899 {
12900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12901 std::string ex(str, iter.base());
12902 assert(ex == "0.000000");
12903 assert(ios.width() == 0);
12904 }
12905 ios.width(25);
12906 left(ios);
12907 {
12908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12909 std::string ex(str, iter.base());
12910 assert(ex == "0.000000*****************");
12911 assert(ios.width() == 0);
12912 }
12913 ios.width(25);
12914 right(ios);
12915 {
12916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12917 std::string ex(str, iter.base());
12918 assert(ex == "*****************0.000000");
12919 assert(ios.width() == 0);
12920 }
12921 ios.width(25);
12922 internal(ios);
12923 {
12924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12925 std::string ex(str, iter.base());
12926 assert(ex == "*****************0.000000");
12927 assert(ios.width() == 0);
12928 }
12929 }
12930 ios.imbue(lg);
12931 {
12932 ios.width(0);
12933 {
12934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12935 std::string ex(str, iter.base());
12936 assert(ex == "0;000000");
12937 assert(ios.width() == 0);
12938 }
12939 ios.width(25);
12940 left(ios);
12941 {
12942 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12943 std::string ex(str, iter.base());
12944 assert(ex == "0;000000*****************");
12945 assert(ios.width() == 0);
12946 }
12947 ios.width(25);
12948 right(ios);
12949 {
12950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12951 std::string ex(str, iter.base());
12952 assert(ex == "*****************0;000000");
12953 assert(ios.width() == 0);
12954 }
12955 ios.width(25);
12956 internal(ios);
12957 {
12958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12959 std::string ex(str, iter.base());
12960 assert(ex == "*****************0;000000");
12961 assert(ios.width() == 0);
12962 }
12963 }
12964 }
12965 }
12966 showpos(ios);
12967 {
12968 noshowpoint(ios);
12969 {
12970 ios.imbue(lc);
12971 {
12972 ios.width(0);
12973 {
12974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12975 std::string ex(str, iter.base());
12976 assert(ex == "+0.000000");
12977 assert(ios.width() == 0);
12978 }
12979 ios.width(25);
12980 left(ios);
12981 {
12982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12983 std::string ex(str, iter.base());
12984 assert(ex == "+0.000000****************");
12985 assert(ios.width() == 0);
12986 }
12987 ios.width(25);
12988 right(ios);
12989 {
12990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12991 std::string ex(str, iter.base());
12992 assert(ex == "****************+0.000000");
12993 assert(ios.width() == 0);
12994 }
12995 ios.width(25);
12996 internal(ios);
12997 {
12998 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12999 std::string ex(str, iter.base());
13000 assert(ex == "+****************0.000000");
13001 assert(ios.width() == 0);
13002 }
13003 }
13004 ios.imbue(lg);
13005 {
13006 ios.width(0);
13007 {
13008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13009 std::string ex(str, iter.base());
13010 assert(ex == "+0;000000");
13011 assert(ios.width() == 0);
13012 }
13013 ios.width(25);
13014 left(ios);
13015 {
13016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13017 std::string ex(str, iter.base());
13018 assert(ex == "+0;000000****************");
13019 assert(ios.width() == 0);
13020 }
13021 ios.width(25);
13022 right(ios);
13023 {
13024 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13025 std::string ex(str, iter.base());
13026 assert(ex == "****************+0;000000");
13027 assert(ios.width() == 0);
13028 }
13029 ios.width(25);
13030 internal(ios);
13031 {
13032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13033 std::string ex(str, iter.base());
13034 assert(ex == "+****************0;000000");
13035 assert(ios.width() == 0);
13036 }
13037 }
13038 }
13039 showpoint(ios);
13040 {
13041 ios.imbue(lc);
13042 {
13043 ios.width(0);
13044 {
13045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13046 std::string ex(str, iter.base());
13047 assert(ex == "+0.000000");
13048 assert(ios.width() == 0);
13049 }
13050 ios.width(25);
13051 left(ios);
13052 {
13053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13054 std::string ex(str, iter.base());
13055 assert(ex == "+0.000000****************");
13056 assert(ios.width() == 0);
13057 }
13058 ios.width(25);
13059 right(ios);
13060 {
13061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13062 std::string ex(str, iter.base());
13063 assert(ex == "****************+0.000000");
13064 assert(ios.width() == 0);
13065 }
13066 ios.width(25);
13067 internal(ios);
13068 {
13069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13070 std::string ex(str, iter.base());
13071 assert(ex == "+****************0.000000");
13072 assert(ios.width() == 0);
13073 }
13074 }
13075 ios.imbue(lg);
13076 {
13077 ios.width(0);
13078 {
13079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13080 std::string ex(str, iter.base());
13081 assert(ex == "+0;000000");
13082 assert(ios.width() == 0);
13083 }
13084 ios.width(25);
13085 left(ios);
13086 {
13087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13088 std::string ex(str, iter.base());
13089 assert(ex == "+0;000000****************");
13090 assert(ios.width() == 0);
13091 }
13092 ios.width(25);
13093 right(ios);
13094 {
13095 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13096 std::string ex(str, iter.base());
13097 assert(ex == "****************+0;000000");
13098 assert(ios.width() == 0);
13099 }
13100 ios.width(25);
13101 internal(ios);
13102 {
13103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13104 std::string ex(str, iter.base());
13105 assert(ex == "+****************0;000000");
13106 assert(ios.width() == 0);
13107 }
13108 }
13109 }
13110 }
13111 }
13112 }
13113 ios.precision(16);
13114 {
13115 nouppercase(ios);
13116 {
13117 noshowpos(ios);
13118 {
13119 noshowpoint(ios);
13120 {
13121 ios.imbue(lc);
13122 {
13123 ios.width(0);
13124 {
13125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13126 std::string ex(str, iter.base());
13127 assert(ex == "0.0000000000000000");
13128 assert(ios.width() == 0);
13129 }
13130 ios.width(25);
13131 left(ios);
13132 {
13133 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13134 std::string ex(str, iter.base());
13135 assert(ex == "0.0000000000000000*******");
13136 assert(ios.width() == 0);
13137 }
13138 ios.width(25);
13139 right(ios);
13140 {
13141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13142 std::string ex(str, iter.base());
13143 assert(ex == "*******0.0000000000000000");
13144 assert(ios.width() == 0);
13145 }
13146 ios.width(25);
13147 internal(ios);
13148 {
13149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13150 std::string ex(str, iter.base());
13151 assert(ex == "*******0.0000000000000000");
13152 assert(ios.width() == 0);
13153 }
13154 }
13155 ios.imbue(lg);
13156 {
13157 ios.width(0);
13158 {
13159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13160 std::string ex(str, iter.base());
13161 assert(ex == "0;0000000000000000");
13162 assert(ios.width() == 0);
13163 }
13164 ios.width(25);
13165 left(ios);
13166 {
13167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13168 std::string ex(str, iter.base());
13169 assert(ex == "0;0000000000000000*******");
13170 assert(ios.width() == 0);
13171 }
13172 ios.width(25);
13173 right(ios);
13174 {
13175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13176 std::string ex(str, iter.base());
13177 assert(ex == "*******0;0000000000000000");
13178 assert(ios.width() == 0);
13179 }
13180 ios.width(25);
13181 internal(ios);
13182 {
13183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13184 std::string ex(str, iter.base());
13185 assert(ex == "*******0;0000000000000000");
13186 assert(ios.width() == 0);
13187 }
13188 }
13189 }
13190 showpoint(ios);
13191 {
13192 ios.imbue(lc);
13193 {
13194 ios.width(0);
13195 {
13196 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13197 std::string ex(str, iter.base());
13198 assert(ex == "0.0000000000000000");
13199 assert(ios.width() == 0);
13200 }
13201 ios.width(25);
13202 left(ios);
13203 {
13204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13205 std::string ex(str, iter.base());
13206 assert(ex == "0.0000000000000000*******");
13207 assert(ios.width() == 0);
13208 }
13209 ios.width(25);
13210 right(ios);
13211 {
13212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13213 std::string ex(str, iter.base());
13214 assert(ex == "*******0.0000000000000000");
13215 assert(ios.width() == 0);
13216 }
13217 ios.width(25);
13218 internal(ios);
13219 {
13220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13221 std::string ex(str, iter.base());
13222 assert(ex == "*******0.0000000000000000");
13223 assert(ios.width() == 0);
13224 }
13225 }
13226 ios.imbue(lg);
13227 {
13228 ios.width(0);
13229 {
13230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13231 std::string ex(str, iter.base());
13232 assert(ex == "0;0000000000000000");
13233 assert(ios.width() == 0);
13234 }
13235 ios.width(25);
13236 left(ios);
13237 {
13238 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13239 std::string ex(str, iter.base());
13240 assert(ex == "0;0000000000000000*******");
13241 assert(ios.width() == 0);
13242 }
13243 ios.width(25);
13244 right(ios);
13245 {
13246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13247 std::string ex(str, iter.base());
13248 assert(ex == "*******0;0000000000000000");
13249 assert(ios.width() == 0);
13250 }
13251 ios.width(25);
13252 internal(ios);
13253 {
13254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13255 std::string ex(str, iter.base());
13256 assert(ex == "*******0;0000000000000000");
13257 assert(ios.width() == 0);
13258 }
13259 }
13260 }
13261 }
13262 showpos(ios);
13263 {
13264 noshowpoint(ios);
13265 {
13266 ios.imbue(lc);
13267 {
13268 ios.width(0);
13269 {
13270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13271 std::string ex(str, iter.base());
13272 assert(ex == "+0.0000000000000000");
13273 assert(ios.width() == 0);
13274 }
13275 ios.width(25);
13276 left(ios);
13277 {
13278 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13279 std::string ex(str, iter.base());
13280 assert(ex == "+0.0000000000000000******");
13281 assert(ios.width() == 0);
13282 }
13283 ios.width(25);
13284 right(ios);
13285 {
13286 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13287 std::string ex(str, iter.base());
13288 assert(ex == "******+0.0000000000000000");
13289 assert(ios.width() == 0);
13290 }
13291 ios.width(25);
13292 internal(ios);
13293 {
13294 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13295 std::string ex(str, iter.base());
13296 assert(ex == "+******0.0000000000000000");
13297 assert(ios.width() == 0);
13298 }
13299 }
13300 ios.imbue(lg);
13301 {
13302 ios.width(0);
13303 {
13304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13305 std::string ex(str, iter.base());
13306 assert(ex == "+0;0000000000000000");
13307 assert(ios.width() == 0);
13308 }
13309 ios.width(25);
13310 left(ios);
13311 {
13312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13313 std::string ex(str, iter.base());
13314 assert(ex == "+0;0000000000000000******");
13315 assert(ios.width() == 0);
13316 }
13317 ios.width(25);
13318 right(ios);
13319 {
13320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13321 std::string ex(str, iter.base());
13322 assert(ex == "******+0;0000000000000000");
13323 assert(ios.width() == 0);
13324 }
13325 ios.width(25);
13326 internal(ios);
13327 {
13328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13329 std::string ex(str, iter.base());
13330 assert(ex == "+******0;0000000000000000");
13331 assert(ios.width() == 0);
13332 }
13333 }
13334 }
13335 showpoint(ios);
13336 {
13337 ios.imbue(lc);
13338 {
13339 ios.width(0);
13340 {
13341 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13342 std::string ex(str, iter.base());
13343 assert(ex == "+0.0000000000000000");
13344 assert(ios.width() == 0);
13345 }
13346 ios.width(25);
13347 left(ios);
13348 {
13349 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13350 std::string ex(str, iter.base());
13351 assert(ex == "+0.0000000000000000******");
13352 assert(ios.width() == 0);
13353 }
13354 ios.width(25);
13355 right(ios);
13356 {
13357 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13358 std::string ex(str, iter.base());
13359 assert(ex == "******+0.0000000000000000");
13360 assert(ios.width() == 0);
13361 }
13362 ios.width(25);
13363 internal(ios);
13364 {
13365 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13366 std::string ex(str, iter.base());
13367 assert(ex == "+******0.0000000000000000");
13368 assert(ios.width() == 0);
13369 }
13370 }
13371 ios.imbue(lg);
13372 {
13373 ios.width(0);
13374 {
13375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13376 std::string ex(str, iter.base());
13377 assert(ex == "+0;0000000000000000");
13378 assert(ios.width() == 0);
13379 }
13380 ios.width(25);
13381 left(ios);
13382 {
13383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13384 std::string ex(str, iter.base());
13385 assert(ex == "+0;0000000000000000******");
13386 assert(ios.width() == 0);
13387 }
13388 ios.width(25);
13389 right(ios);
13390 {
13391 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13392 std::string ex(str, iter.base());
13393 assert(ex == "******+0;0000000000000000");
13394 assert(ios.width() == 0);
13395 }
13396 ios.width(25);
13397 internal(ios);
13398 {
13399 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13400 std::string ex(str, iter.base());
13401 assert(ex == "+******0;0000000000000000");
13402 assert(ios.width() == 0);
13403 }
13404 }
13405 }
13406 }
13407 }
13408 uppercase(ios);
13409 {
13410 noshowpos(ios);
13411 {
13412 noshowpoint(ios);
13413 {
13414 ios.imbue(lc);
13415 {
13416 ios.width(0);
13417 {
13418 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13419 std::string ex(str, iter.base());
13420 assert(ex == "0.0000000000000000");
13421 assert(ios.width() == 0);
13422 }
13423 ios.width(25);
13424 left(ios);
13425 {
13426 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13427 std::string ex(str, iter.base());
13428 assert(ex == "0.0000000000000000*******");
13429 assert(ios.width() == 0);
13430 }
13431 ios.width(25);
13432 right(ios);
13433 {
13434 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13435 std::string ex(str, iter.base());
13436 assert(ex == "*******0.0000000000000000");
13437 assert(ios.width() == 0);
13438 }
13439 ios.width(25);
13440 internal(ios);
13441 {
13442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13443 std::string ex(str, iter.base());
13444 assert(ex == "*******0.0000000000000000");
13445 assert(ios.width() == 0);
13446 }
13447 }
13448 ios.imbue(lg);
13449 {
13450 ios.width(0);
13451 {
13452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13453 std::string ex(str, iter.base());
13454 assert(ex == "0;0000000000000000");
13455 assert(ios.width() == 0);
13456 }
13457 ios.width(25);
13458 left(ios);
13459 {
13460 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13461 std::string ex(str, iter.base());
13462 assert(ex == "0;0000000000000000*******");
13463 assert(ios.width() == 0);
13464 }
13465 ios.width(25);
13466 right(ios);
13467 {
13468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13469 std::string ex(str, iter.base());
13470 assert(ex == "*******0;0000000000000000");
13471 assert(ios.width() == 0);
13472 }
13473 ios.width(25);
13474 internal(ios);
13475 {
13476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13477 std::string ex(str, iter.base());
13478 assert(ex == "*******0;0000000000000000");
13479 assert(ios.width() == 0);
13480 }
13481 }
13482 }
13483 showpoint(ios);
13484 {
13485 ios.imbue(lc);
13486 {
13487 ios.width(0);
13488 {
13489 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13490 std::string ex(str, iter.base());
13491 assert(ex == "0.0000000000000000");
13492 assert(ios.width() == 0);
13493 }
13494 ios.width(25);
13495 left(ios);
13496 {
13497 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13498 std::string ex(str, iter.base());
13499 assert(ex == "0.0000000000000000*******");
13500 assert(ios.width() == 0);
13501 }
13502 ios.width(25);
13503 right(ios);
13504 {
13505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13506 std::string ex(str, iter.base());
13507 assert(ex == "*******0.0000000000000000");
13508 assert(ios.width() == 0);
13509 }
13510 ios.width(25);
13511 internal(ios);
13512 {
13513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13514 std::string ex(str, iter.base());
13515 assert(ex == "*******0.0000000000000000");
13516 assert(ios.width() == 0);
13517 }
13518 }
13519 ios.imbue(lg);
13520 {
13521 ios.width(0);
13522 {
13523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13524 std::string ex(str, iter.base());
13525 assert(ex == "0;0000000000000000");
13526 assert(ios.width() == 0);
13527 }
13528 ios.width(25);
13529 left(ios);
13530 {
13531 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13532 std::string ex(str, iter.base());
13533 assert(ex == "0;0000000000000000*******");
13534 assert(ios.width() == 0);
13535 }
13536 ios.width(25);
13537 right(ios);
13538 {
13539 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13540 std::string ex(str, iter.base());
13541 assert(ex == "*******0;0000000000000000");
13542 assert(ios.width() == 0);
13543 }
13544 ios.width(25);
13545 internal(ios);
13546 {
13547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13548 std::string ex(str, iter.base());
13549 assert(ex == "*******0;0000000000000000");
13550 assert(ios.width() == 0);
13551 }
13552 }
13553 }
13554 }
13555 showpos(ios);
13556 {
13557 noshowpoint(ios);
13558 {
13559 ios.imbue(lc);
13560 {
13561 ios.width(0);
13562 {
13563 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13564 std::string ex(str, iter.base());
13565 assert(ex == "+0.0000000000000000");
13566 assert(ios.width() == 0);
13567 }
13568 ios.width(25);
13569 left(ios);
13570 {
13571 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13572 std::string ex(str, iter.base());
13573 assert(ex == "+0.0000000000000000******");
13574 assert(ios.width() == 0);
13575 }
13576 ios.width(25);
13577 right(ios);
13578 {
13579 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13580 std::string ex(str, iter.base());
13581 assert(ex == "******+0.0000000000000000");
13582 assert(ios.width() == 0);
13583 }
13584 ios.width(25);
13585 internal(ios);
13586 {
13587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13588 std::string ex(str, iter.base());
13589 assert(ex == "+******0.0000000000000000");
13590 assert(ios.width() == 0);
13591 }
13592 }
13593 ios.imbue(lg);
13594 {
13595 ios.width(0);
13596 {
13597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13598 std::string ex(str, iter.base());
13599 assert(ex == "+0;0000000000000000");
13600 assert(ios.width() == 0);
13601 }
13602 ios.width(25);
13603 left(ios);
13604 {
13605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13606 std::string ex(str, iter.base());
13607 assert(ex == "+0;0000000000000000******");
13608 assert(ios.width() == 0);
13609 }
13610 ios.width(25);
13611 right(ios);
13612 {
13613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13614 std::string ex(str, iter.base());
13615 assert(ex == "******+0;0000000000000000");
13616 assert(ios.width() == 0);
13617 }
13618 ios.width(25);
13619 internal(ios);
13620 {
13621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13622 std::string ex(str, iter.base());
13623 assert(ex == "+******0;0000000000000000");
13624 assert(ios.width() == 0);
13625 }
13626 }
13627 }
13628 showpoint(ios);
13629 {
13630 ios.imbue(lc);
13631 {
13632 ios.width(0);
13633 {
13634 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13635 std::string ex(str, iter.base());
13636 assert(ex == "+0.0000000000000000");
13637 assert(ios.width() == 0);
13638 }
13639 ios.width(25);
13640 left(ios);
13641 {
13642 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13643 std::string ex(str, iter.base());
13644 assert(ex == "+0.0000000000000000******");
13645 assert(ios.width() == 0);
13646 }
13647 ios.width(25);
13648 right(ios);
13649 {
13650 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13651 std::string ex(str, iter.base());
13652 assert(ex == "******+0.0000000000000000");
13653 assert(ios.width() == 0);
13654 }
13655 ios.width(25);
13656 internal(ios);
13657 {
13658 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13659 std::string ex(str, iter.base());
13660 assert(ex == "+******0.0000000000000000");
13661 assert(ios.width() == 0);
13662 }
13663 }
13664 ios.imbue(lg);
13665 {
13666 ios.width(0);
13667 {
13668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13669 std::string ex(str, iter.base());
13670 assert(ex == "+0;0000000000000000");
13671 assert(ios.width() == 0);
13672 }
13673 ios.width(25);
13674 left(ios);
13675 {
13676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13677 std::string ex(str, iter.base());
13678 assert(ex == "+0;0000000000000000******");
13679 assert(ios.width() == 0);
13680 }
13681 ios.width(25);
13682 right(ios);
13683 {
13684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13685 std::string ex(str, iter.base());
13686 assert(ex == "******+0;0000000000000000");
13687 assert(ios.width() == 0);
13688 }
13689 ios.width(25);
13690 internal(ios);
13691 {
13692 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13693 std::string ex(str, iter.base());
13694 assert(ex == "+******0;0000000000000000");
13695 assert(ios.width() == 0);
13696 }
13697 }
13698 }
13699 }
13700 }
13701 }
13702 ios.precision(60);
13703 {
13704 nouppercase(ios);
13705 {
13706 noshowpos(ios);
13707 {
13708 noshowpoint(ios);
13709 {
13710 ios.imbue(lc);
13711 {
13712 ios.width(0);
13713 {
13714 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13715 std::string ex(str, iter.base());
13716 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13717 assert(ios.width() == 0);
13718 }
13719 ios.width(25);
13720 left(ios);
13721 {
13722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13723 std::string ex(str, iter.base());
13724 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13725 assert(ios.width() == 0);
13726 }
13727 ios.width(25);
13728 right(ios);
13729 {
13730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13731 std::string ex(str, iter.base());
13732 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13733 assert(ios.width() == 0);
13734 }
13735 ios.width(25);
13736 internal(ios);
13737 {
13738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13739 std::string ex(str, iter.base());
13740 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13741 assert(ios.width() == 0);
13742 }
13743 }
13744 ios.imbue(lg);
13745 {
13746 ios.width(0);
13747 {
13748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13749 std::string ex(str, iter.base());
13750 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13751 assert(ios.width() == 0);
13752 }
13753 ios.width(25);
13754 left(ios);
13755 {
13756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13757 std::string ex(str, iter.base());
13758 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13759 assert(ios.width() == 0);
13760 }
13761 ios.width(25);
13762 right(ios);
13763 {
13764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13765 std::string ex(str, iter.base());
13766 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13767 assert(ios.width() == 0);
13768 }
13769 ios.width(25);
13770 internal(ios);
13771 {
13772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13773 std::string ex(str, iter.base());
13774 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13775 assert(ios.width() == 0);
13776 }
13777 }
13778 }
13779 showpoint(ios);
13780 {
13781 ios.imbue(lc);
13782 {
13783 ios.width(0);
13784 {
13785 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13786 std::string ex(str, iter.base());
13787 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13788 assert(ios.width() == 0);
13789 }
13790 ios.width(25);
13791 left(ios);
13792 {
13793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13794 std::string ex(str, iter.base());
13795 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13796 assert(ios.width() == 0);
13797 }
13798 ios.width(25);
13799 right(ios);
13800 {
13801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13802 std::string ex(str, iter.base());
13803 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13804 assert(ios.width() == 0);
13805 }
13806 ios.width(25);
13807 internal(ios);
13808 {
13809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13810 std::string ex(str, iter.base());
13811 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13812 assert(ios.width() == 0);
13813 }
13814 }
13815 ios.imbue(lg);
13816 {
13817 ios.width(0);
13818 {
13819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13820 std::string ex(str, iter.base());
13821 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13822 assert(ios.width() == 0);
13823 }
13824 ios.width(25);
13825 left(ios);
13826 {
13827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13828 std::string ex(str, iter.base());
13829 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13830 assert(ios.width() == 0);
13831 }
13832 ios.width(25);
13833 right(ios);
13834 {
13835 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13836 std::string ex(str, iter.base());
13837 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13838 assert(ios.width() == 0);
13839 }
13840 ios.width(25);
13841 internal(ios);
13842 {
13843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13844 std::string ex(str, iter.base());
13845 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13846 assert(ios.width() == 0);
13847 }
13848 }
13849 }
13850 }
13851 showpos(ios);
13852 {
13853 noshowpoint(ios);
13854 {
13855 ios.imbue(lc);
13856 {
13857 ios.width(0);
13858 {
13859 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13860 std::string ex(str, iter.base());
13861 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13862 assert(ios.width() == 0);
13863 }
13864 ios.width(25);
13865 left(ios);
13866 {
13867 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13868 std::string ex(str, iter.base());
13869 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13870 assert(ios.width() == 0);
13871 }
13872 ios.width(25);
13873 right(ios);
13874 {
13875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13876 std::string ex(str, iter.base());
13877 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13878 assert(ios.width() == 0);
13879 }
13880 ios.width(25);
13881 internal(ios);
13882 {
13883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13884 std::string ex(str, iter.base());
13885 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13886 assert(ios.width() == 0);
13887 }
13888 }
13889 ios.imbue(lg);
13890 {
13891 ios.width(0);
13892 {
13893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13894 std::string ex(str, iter.base());
13895 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13896 assert(ios.width() == 0);
13897 }
13898 ios.width(25);
13899 left(ios);
13900 {
13901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13902 std::string ex(str, iter.base());
13903 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13904 assert(ios.width() == 0);
13905 }
13906 ios.width(25);
13907 right(ios);
13908 {
13909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13910 std::string ex(str, iter.base());
13911 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13912 assert(ios.width() == 0);
13913 }
13914 ios.width(25);
13915 internal(ios);
13916 {
13917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13918 std::string ex(str, iter.base());
13919 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13920 assert(ios.width() == 0);
13921 }
13922 }
13923 }
13924 showpoint(ios);
13925 {
13926 ios.imbue(lc);
13927 {
13928 ios.width(0);
13929 {
13930 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13931 std::string ex(str, iter.base());
13932 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13933 assert(ios.width() == 0);
13934 }
13935 ios.width(25);
13936 left(ios);
13937 {
13938 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13939 std::string ex(str, iter.base());
13940 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13941 assert(ios.width() == 0);
13942 }
13943 ios.width(25);
13944 right(ios);
13945 {
13946 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13947 std::string ex(str, iter.base());
13948 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13949 assert(ios.width() == 0);
13950 }
13951 ios.width(25);
13952 internal(ios);
13953 {
13954 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13955 std::string ex(str, iter.base());
13956 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13957 assert(ios.width() == 0);
13958 }
13959 }
13960 ios.imbue(lg);
13961 {
13962 ios.width(0);
13963 {
13964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13965 std::string ex(str, iter.base());
13966 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13967 assert(ios.width() == 0);
13968 }
13969 ios.width(25);
13970 left(ios);
13971 {
13972 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13973 std::string ex(str, iter.base());
13974 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13975 assert(ios.width() == 0);
13976 }
13977 ios.width(25);
13978 right(ios);
13979 {
13980 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13981 std::string ex(str, iter.base());
13982 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13983 assert(ios.width() == 0);
13984 }
13985 ios.width(25);
13986 internal(ios);
13987 {
13988 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13989 std::string ex(str, iter.base());
13990 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13991 assert(ios.width() == 0);
13992 }
13993 }
13994 }
13995 }
13996 }
13997 uppercase(ios);
13998 {
13999 noshowpos(ios);
14000 {
14001 noshowpoint(ios);
14002 {
14003 ios.imbue(lc);
14004 {
14005 ios.width(0);
14006 {
14007 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14008 std::string ex(str, iter.base());
14009 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14010 assert(ios.width() == 0);
14011 }
14012 ios.width(25);
14013 left(ios);
14014 {
14015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14016 std::string ex(str, iter.base());
14017 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14018 assert(ios.width() == 0);
14019 }
14020 ios.width(25);
14021 right(ios);
14022 {
14023 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14024 std::string ex(str, iter.base());
14025 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14026 assert(ios.width() == 0);
14027 }
14028 ios.width(25);
14029 internal(ios);
14030 {
14031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14032 std::string ex(str, iter.base());
14033 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14034 assert(ios.width() == 0);
14035 }
14036 }
14037 ios.imbue(lg);
14038 {
14039 ios.width(0);
14040 {
14041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14042 std::string ex(str, iter.base());
14043 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14044 assert(ios.width() == 0);
14045 }
14046 ios.width(25);
14047 left(ios);
14048 {
14049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14050 std::string ex(str, iter.base());
14051 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14052 assert(ios.width() == 0);
14053 }
14054 ios.width(25);
14055 right(ios);
14056 {
14057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14058 std::string ex(str, iter.base());
14059 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14060 assert(ios.width() == 0);
14061 }
14062 ios.width(25);
14063 internal(ios);
14064 {
14065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14066 std::string ex(str, iter.base());
14067 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14068 assert(ios.width() == 0);
14069 }
14070 }
14071 }
14072 showpoint(ios);
14073 {
14074 ios.imbue(lc);
14075 {
14076 ios.width(0);
14077 {
14078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14079 std::string ex(str, iter.base());
14080 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14081 assert(ios.width() == 0);
14082 }
14083 ios.width(25);
14084 left(ios);
14085 {
14086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14087 std::string ex(str, iter.base());
14088 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14089 assert(ios.width() == 0);
14090 }
14091 ios.width(25);
14092 right(ios);
14093 {
14094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14095 std::string ex(str, iter.base());
14096 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14097 assert(ios.width() == 0);
14098 }
14099 ios.width(25);
14100 internal(ios);
14101 {
14102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14103 std::string ex(str, iter.base());
14104 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14105 assert(ios.width() == 0);
14106 }
14107 }
14108 ios.imbue(lg);
14109 {
14110 ios.width(0);
14111 {
14112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14113 std::string ex(str, iter.base());
14114 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14115 assert(ios.width() == 0);
14116 }
14117 ios.width(25);
14118 left(ios);
14119 {
14120 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14121 std::string ex(str, iter.base());
14122 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14123 assert(ios.width() == 0);
14124 }
14125 ios.width(25);
14126 right(ios);
14127 {
14128 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14129 std::string ex(str, iter.base());
14130 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14131 assert(ios.width() == 0);
14132 }
14133 ios.width(25);
14134 internal(ios);
14135 {
14136 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14137 std::string ex(str, iter.base());
14138 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14139 assert(ios.width() == 0);
14140 }
14141 }
14142 }
14143 }
14144 showpos(ios);
14145 {
14146 noshowpoint(ios);
14147 {
14148 ios.imbue(lc);
14149 {
14150 ios.width(0);
14151 {
14152 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14153 std::string ex(str, iter.base());
14154 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14155 assert(ios.width() == 0);
14156 }
14157 ios.width(25);
14158 left(ios);
14159 {
14160 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14161 std::string ex(str, iter.base());
14162 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14163 assert(ios.width() == 0);
14164 }
14165 ios.width(25);
14166 right(ios);
14167 {
14168 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14169 std::string ex(str, iter.base());
14170 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14171 assert(ios.width() == 0);
14172 }
14173 ios.width(25);
14174 internal(ios);
14175 {
14176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14177 std::string ex(str, iter.base());
14178 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14179 assert(ios.width() == 0);
14180 }
14181 }
14182 ios.imbue(lg);
14183 {
14184 ios.width(0);
14185 {
14186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14187 std::string ex(str, iter.base());
14188 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14189 assert(ios.width() == 0);
14190 }
14191 ios.width(25);
14192 left(ios);
14193 {
14194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14195 std::string ex(str, iter.base());
14196 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14197 assert(ios.width() == 0);
14198 }
14199 ios.width(25);
14200 right(ios);
14201 {
14202 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14203 std::string ex(str, iter.base());
14204 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14205 assert(ios.width() == 0);
14206 }
14207 ios.width(25);
14208 internal(ios);
14209 {
14210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14211 std::string ex(str, iter.base());
14212 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14213 assert(ios.width() == 0);
14214 }
14215 }
14216 }
14217 showpoint(ios);
14218 {
14219 ios.imbue(lc);
14220 {
14221 ios.width(0);
14222 {
14223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14224 std::string ex(str, iter.base());
14225 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14226 assert(ios.width() == 0);
14227 }
14228 ios.width(25);
14229 left(ios);
14230 {
14231 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14232 std::string ex(str, iter.base());
14233 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14234 assert(ios.width() == 0);
14235 }
14236 ios.width(25);
14237 right(ios);
14238 {
14239 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14240 std::string ex(str, iter.base());
14241 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14242 assert(ios.width() == 0);
14243 }
14244 ios.width(25);
14245 internal(ios);
14246 {
14247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14248 std::string ex(str, iter.base());
14249 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14250 assert(ios.width() == 0);
14251 }
14252 }
14253 ios.imbue(lg);
14254 {
14255 ios.width(0);
14256 {
14257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14258 std::string ex(str, iter.base());
14259 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14260 assert(ios.width() == 0);
14261 }
14262 ios.width(25);
14263 left(ios);
14264 {
14265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14266 std::string ex(str, iter.base());
14267 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14268 assert(ios.width() == 0);
14269 }
14270 ios.width(25);
14271 right(ios);
14272 {
14273 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14274 std::string ex(str, iter.base());
14275 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14276 assert(ios.width() == 0);
14277 }
14278 ios.width(25);
14279 internal(ios);
14280 {
14281 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14282 std::string ex(str, iter.base());
14283 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14284 assert(ios.width() == 0);
14285 }
14286 }
14287 }
14288 }
14289 }
14290 }
14291 }
14292 }
14293 }
14294
test7()14295 void test7()
14296 {
14297 char str[200];
14298 output_iterator<char*> iter;
14299 std::locale lc = std::locale::classic();
14300 std::locale lg(lc, new my_numpunct);
14301 const my_facet f(1);
14302 {
14303 long double v = -0.;
14304 std::ios ios(0);
14305 fixed(ios);
14306 // %f
14307 {
14308 ios.precision(0);
14309 {
14310 nouppercase(ios);
14311 {
14312 noshowpos(ios);
14313 {
14314 noshowpoint(ios);
14315 {
14316 ios.imbue(lc);
14317 {
14318 ios.width(0);
14319 {
14320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14321 std::string ex(str, iter.base());
14322 assert(ex == "-0");
14323 assert(ios.width() == 0);
14324 }
14325 ios.width(25);
14326 left(ios);
14327 {
14328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14329 std::string ex(str, iter.base());
14330 assert(ex == "-0***********************");
14331 assert(ios.width() == 0);
14332 }
14333 ios.width(25);
14334 right(ios);
14335 {
14336 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14337 std::string ex(str, iter.base());
14338 assert(ex == "***********************-0");
14339 assert(ios.width() == 0);
14340 }
14341 ios.width(25);
14342 internal(ios);
14343 {
14344 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14345 std::string ex(str, iter.base());
14346 assert(ex == "-***********************0");
14347 assert(ios.width() == 0);
14348 }
14349 }
14350 ios.imbue(lg);
14351 {
14352 ios.width(0);
14353 {
14354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14355 std::string ex(str, iter.base());
14356 assert(ex == "-0");
14357 assert(ios.width() == 0);
14358 }
14359 ios.width(25);
14360 left(ios);
14361 {
14362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14363 std::string ex(str, iter.base());
14364 assert(ex == "-0***********************");
14365 assert(ios.width() == 0);
14366 }
14367 ios.width(25);
14368 right(ios);
14369 {
14370 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14371 std::string ex(str, iter.base());
14372 assert(ex == "***********************-0");
14373 assert(ios.width() == 0);
14374 }
14375 ios.width(25);
14376 internal(ios);
14377 {
14378 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14379 std::string ex(str, iter.base());
14380 assert(ex == "-***********************0");
14381 assert(ios.width() == 0);
14382 }
14383 }
14384 }
14385 showpoint(ios);
14386 {
14387 ios.imbue(lc);
14388 {
14389 ios.width(0);
14390 {
14391 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14392 std::string ex(str, iter.base());
14393 assert(ex == "-0.");
14394 assert(ios.width() == 0);
14395 }
14396 ios.width(25);
14397 left(ios);
14398 {
14399 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14400 std::string ex(str, iter.base());
14401 assert(ex == "-0.**********************");
14402 assert(ios.width() == 0);
14403 }
14404 ios.width(25);
14405 right(ios);
14406 {
14407 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14408 std::string ex(str, iter.base());
14409 assert(ex == "**********************-0.");
14410 assert(ios.width() == 0);
14411 }
14412 ios.width(25);
14413 internal(ios);
14414 {
14415 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14416 std::string ex(str, iter.base());
14417 assert(ex == "-**********************0.");
14418 assert(ios.width() == 0);
14419 }
14420 }
14421 ios.imbue(lg);
14422 {
14423 ios.width(0);
14424 {
14425 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14426 std::string ex(str, iter.base());
14427 assert(ex == "-0;");
14428 assert(ios.width() == 0);
14429 }
14430 ios.width(25);
14431 left(ios);
14432 {
14433 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14434 std::string ex(str, iter.base());
14435 assert(ex == "-0;**********************");
14436 assert(ios.width() == 0);
14437 }
14438 ios.width(25);
14439 right(ios);
14440 {
14441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14442 std::string ex(str, iter.base());
14443 assert(ex == "**********************-0;");
14444 assert(ios.width() == 0);
14445 }
14446 ios.width(25);
14447 internal(ios);
14448 {
14449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14450 std::string ex(str, iter.base());
14451 assert(ex == "-**********************0;");
14452 assert(ios.width() == 0);
14453 }
14454 }
14455 }
14456 }
14457 showpos(ios);
14458 {
14459 noshowpoint(ios);
14460 {
14461 ios.imbue(lc);
14462 {
14463 ios.width(0);
14464 {
14465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14466 std::string ex(str, iter.base());
14467 assert(ex == "-0");
14468 assert(ios.width() == 0);
14469 }
14470 ios.width(25);
14471 left(ios);
14472 {
14473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14474 std::string ex(str, iter.base());
14475 assert(ex == "-0***********************");
14476 assert(ios.width() == 0);
14477 }
14478 ios.width(25);
14479 right(ios);
14480 {
14481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14482 std::string ex(str, iter.base());
14483 assert(ex == "***********************-0");
14484 assert(ios.width() == 0);
14485 }
14486 ios.width(25);
14487 internal(ios);
14488 {
14489 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14490 std::string ex(str, iter.base());
14491 assert(ex == "-***********************0");
14492 assert(ios.width() == 0);
14493 }
14494 }
14495 ios.imbue(lg);
14496 {
14497 ios.width(0);
14498 {
14499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14500 std::string ex(str, iter.base());
14501 assert(ex == "-0");
14502 assert(ios.width() == 0);
14503 }
14504 ios.width(25);
14505 left(ios);
14506 {
14507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14508 std::string ex(str, iter.base());
14509 assert(ex == "-0***********************");
14510 assert(ios.width() == 0);
14511 }
14512 ios.width(25);
14513 right(ios);
14514 {
14515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14516 std::string ex(str, iter.base());
14517 assert(ex == "***********************-0");
14518 assert(ios.width() == 0);
14519 }
14520 ios.width(25);
14521 internal(ios);
14522 {
14523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14524 std::string ex(str, iter.base());
14525 assert(ex == "-***********************0");
14526 assert(ios.width() == 0);
14527 }
14528 }
14529 }
14530 showpoint(ios);
14531 {
14532 ios.imbue(lc);
14533 {
14534 ios.width(0);
14535 {
14536 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14537 std::string ex(str, iter.base());
14538 assert(ex == "-0.");
14539 assert(ios.width() == 0);
14540 }
14541 ios.width(25);
14542 left(ios);
14543 {
14544 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14545 std::string ex(str, iter.base());
14546 assert(ex == "-0.**********************");
14547 assert(ios.width() == 0);
14548 }
14549 ios.width(25);
14550 right(ios);
14551 {
14552 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14553 std::string ex(str, iter.base());
14554 assert(ex == "**********************-0.");
14555 assert(ios.width() == 0);
14556 }
14557 ios.width(25);
14558 internal(ios);
14559 {
14560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14561 std::string ex(str, iter.base());
14562 assert(ex == "-**********************0.");
14563 assert(ios.width() == 0);
14564 }
14565 }
14566 ios.imbue(lg);
14567 {
14568 ios.width(0);
14569 {
14570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14571 std::string ex(str, iter.base());
14572 assert(ex == "-0;");
14573 assert(ios.width() == 0);
14574 }
14575 ios.width(25);
14576 left(ios);
14577 {
14578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14579 std::string ex(str, iter.base());
14580 assert(ex == "-0;**********************");
14581 assert(ios.width() == 0);
14582 }
14583 ios.width(25);
14584 right(ios);
14585 {
14586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14587 std::string ex(str, iter.base());
14588 assert(ex == "**********************-0;");
14589 assert(ios.width() == 0);
14590 }
14591 ios.width(25);
14592 internal(ios);
14593 {
14594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14595 std::string ex(str, iter.base());
14596 assert(ex == "-**********************0;");
14597 assert(ios.width() == 0);
14598 }
14599 }
14600 }
14601 }
14602 }
14603 uppercase(ios);
14604 {
14605 noshowpos(ios);
14606 {
14607 noshowpoint(ios);
14608 {
14609 ios.imbue(lc);
14610 {
14611 ios.width(0);
14612 {
14613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14614 std::string ex(str, iter.base());
14615 assert(ex == "-0");
14616 assert(ios.width() == 0);
14617 }
14618 ios.width(25);
14619 left(ios);
14620 {
14621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14622 std::string ex(str, iter.base());
14623 assert(ex == "-0***********************");
14624 assert(ios.width() == 0);
14625 }
14626 ios.width(25);
14627 right(ios);
14628 {
14629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14630 std::string ex(str, iter.base());
14631 assert(ex == "***********************-0");
14632 assert(ios.width() == 0);
14633 }
14634 ios.width(25);
14635 internal(ios);
14636 {
14637 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14638 std::string ex(str, iter.base());
14639 assert(ex == "-***********************0");
14640 assert(ios.width() == 0);
14641 }
14642 }
14643 ios.imbue(lg);
14644 {
14645 ios.width(0);
14646 {
14647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14648 std::string ex(str, iter.base());
14649 assert(ex == "-0");
14650 assert(ios.width() == 0);
14651 }
14652 ios.width(25);
14653 left(ios);
14654 {
14655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14656 std::string ex(str, iter.base());
14657 assert(ex == "-0***********************");
14658 assert(ios.width() == 0);
14659 }
14660 ios.width(25);
14661 right(ios);
14662 {
14663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14664 std::string ex(str, iter.base());
14665 assert(ex == "***********************-0");
14666 assert(ios.width() == 0);
14667 }
14668 ios.width(25);
14669 internal(ios);
14670 {
14671 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14672 std::string ex(str, iter.base());
14673 assert(ex == "-***********************0");
14674 assert(ios.width() == 0);
14675 }
14676 }
14677 }
14678 showpoint(ios);
14679 {
14680 ios.imbue(lc);
14681 {
14682 ios.width(0);
14683 {
14684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14685 std::string ex(str, iter.base());
14686 assert(ex == "-0.");
14687 assert(ios.width() == 0);
14688 }
14689 ios.width(25);
14690 left(ios);
14691 {
14692 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14693 std::string ex(str, iter.base());
14694 assert(ex == "-0.**********************");
14695 assert(ios.width() == 0);
14696 }
14697 ios.width(25);
14698 right(ios);
14699 {
14700 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14701 std::string ex(str, iter.base());
14702 assert(ex == "**********************-0.");
14703 assert(ios.width() == 0);
14704 }
14705 ios.width(25);
14706 internal(ios);
14707 {
14708 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14709 std::string ex(str, iter.base());
14710 assert(ex == "-**********************0.");
14711 assert(ios.width() == 0);
14712 }
14713 }
14714 ios.imbue(lg);
14715 {
14716 ios.width(0);
14717 {
14718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14719 std::string ex(str, iter.base());
14720 assert(ex == "-0;");
14721 assert(ios.width() == 0);
14722 }
14723 ios.width(25);
14724 left(ios);
14725 {
14726 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14727 std::string ex(str, iter.base());
14728 assert(ex == "-0;**********************");
14729 assert(ios.width() == 0);
14730 }
14731 ios.width(25);
14732 right(ios);
14733 {
14734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14735 std::string ex(str, iter.base());
14736 assert(ex == "**********************-0;");
14737 assert(ios.width() == 0);
14738 }
14739 ios.width(25);
14740 internal(ios);
14741 {
14742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14743 std::string ex(str, iter.base());
14744 assert(ex == "-**********************0;");
14745 assert(ios.width() == 0);
14746 }
14747 }
14748 }
14749 }
14750 showpos(ios);
14751 {
14752 noshowpoint(ios);
14753 {
14754 ios.imbue(lc);
14755 {
14756 ios.width(0);
14757 {
14758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14759 std::string ex(str, iter.base());
14760 assert(ex == "-0");
14761 assert(ios.width() == 0);
14762 }
14763 ios.width(25);
14764 left(ios);
14765 {
14766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14767 std::string ex(str, iter.base());
14768 assert(ex == "-0***********************");
14769 assert(ios.width() == 0);
14770 }
14771 ios.width(25);
14772 right(ios);
14773 {
14774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14775 std::string ex(str, iter.base());
14776 assert(ex == "***********************-0");
14777 assert(ios.width() == 0);
14778 }
14779 ios.width(25);
14780 internal(ios);
14781 {
14782 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14783 std::string ex(str, iter.base());
14784 assert(ex == "-***********************0");
14785 assert(ios.width() == 0);
14786 }
14787 }
14788 ios.imbue(lg);
14789 {
14790 ios.width(0);
14791 {
14792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14793 std::string ex(str, iter.base());
14794 assert(ex == "-0");
14795 assert(ios.width() == 0);
14796 }
14797 ios.width(25);
14798 left(ios);
14799 {
14800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14801 std::string ex(str, iter.base());
14802 assert(ex == "-0***********************");
14803 assert(ios.width() == 0);
14804 }
14805 ios.width(25);
14806 right(ios);
14807 {
14808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14809 std::string ex(str, iter.base());
14810 assert(ex == "***********************-0");
14811 assert(ios.width() == 0);
14812 }
14813 ios.width(25);
14814 internal(ios);
14815 {
14816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14817 std::string ex(str, iter.base());
14818 assert(ex == "-***********************0");
14819 assert(ios.width() == 0);
14820 }
14821 }
14822 }
14823 showpoint(ios);
14824 {
14825 ios.imbue(lc);
14826 {
14827 ios.width(0);
14828 {
14829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14830 std::string ex(str, iter.base());
14831 assert(ex == "-0.");
14832 assert(ios.width() == 0);
14833 }
14834 ios.width(25);
14835 left(ios);
14836 {
14837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14838 std::string ex(str, iter.base());
14839 assert(ex == "-0.**********************");
14840 assert(ios.width() == 0);
14841 }
14842 ios.width(25);
14843 right(ios);
14844 {
14845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14846 std::string ex(str, iter.base());
14847 assert(ex == "**********************-0.");
14848 assert(ios.width() == 0);
14849 }
14850 ios.width(25);
14851 internal(ios);
14852 {
14853 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14854 std::string ex(str, iter.base());
14855 assert(ex == "-**********************0.");
14856 assert(ios.width() == 0);
14857 }
14858 }
14859 ios.imbue(lg);
14860 {
14861 ios.width(0);
14862 {
14863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14864 std::string ex(str, iter.base());
14865 assert(ex == "-0;");
14866 assert(ios.width() == 0);
14867 }
14868 ios.width(25);
14869 left(ios);
14870 {
14871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14872 std::string ex(str, iter.base());
14873 assert(ex == "-0;**********************");
14874 assert(ios.width() == 0);
14875 }
14876 ios.width(25);
14877 right(ios);
14878 {
14879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14880 std::string ex(str, iter.base());
14881 assert(ex == "**********************-0;");
14882 assert(ios.width() == 0);
14883 }
14884 ios.width(25);
14885 internal(ios);
14886 {
14887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14888 std::string ex(str, iter.base());
14889 assert(ex == "-**********************0;");
14890 assert(ios.width() == 0);
14891 }
14892 }
14893 }
14894 }
14895 }
14896 }
14897 ios.precision(1);
14898 {
14899 nouppercase(ios);
14900 {
14901 noshowpos(ios);
14902 {
14903 noshowpoint(ios);
14904 {
14905 ios.imbue(lc);
14906 {
14907 ios.width(0);
14908 {
14909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14910 std::string ex(str, iter.base());
14911 assert(ex == "-0.0");
14912 assert(ios.width() == 0);
14913 }
14914 ios.width(25);
14915 left(ios);
14916 {
14917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14918 std::string ex(str, iter.base());
14919 assert(ex == "-0.0*********************");
14920 assert(ios.width() == 0);
14921 }
14922 ios.width(25);
14923 right(ios);
14924 {
14925 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14926 std::string ex(str, iter.base());
14927 assert(ex == "*********************-0.0");
14928 assert(ios.width() == 0);
14929 }
14930 ios.width(25);
14931 internal(ios);
14932 {
14933 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14934 std::string ex(str, iter.base());
14935 assert(ex == "-*********************0.0");
14936 assert(ios.width() == 0);
14937 }
14938 }
14939 ios.imbue(lg);
14940 {
14941 ios.width(0);
14942 {
14943 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14944 std::string ex(str, iter.base());
14945 assert(ex == "-0;0");
14946 assert(ios.width() == 0);
14947 }
14948 ios.width(25);
14949 left(ios);
14950 {
14951 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14952 std::string ex(str, iter.base());
14953 assert(ex == "-0;0*********************");
14954 assert(ios.width() == 0);
14955 }
14956 ios.width(25);
14957 right(ios);
14958 {
14959 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14960 std::string ex(str, iter.base());
14961 assert(ex == "*********************-0;0");
14962 assert(ios.width() == 0);
14963 }
14964 ios.width(25);
14965 internal(ios);
14966 {
14967 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14968 std::string ex(str, iter.base());
14969 assert(ex == "-*********************0;0");
14970 assert(ios.width() == 0);
14971 }
14972 }
14973 }
14974 showpoint(ios);
14975 {
14976 ios.imbue(lc);
14977 {
14978 ios.width(0);
14979 {
14980 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14981 std::string ex(str, iter.base());
14982 assert(ex == "-0.0");
14983 assert(ios.width() == 0);
14984 }
14985 ios.width(25);
14986 left(ios);
14987 {
14988 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14989 std::string ex(str, iter.base());
14990 assert(ex == "-0.0*********************");
14991 assert(ios.width() == 0);
14992 }
14993 ios.width(25);
14994 right(ios);
14995 {
14996 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14997 std::string ex(str, iter.base());
14998 assert(ex == "*********************-0.0");
14999 assert(ios.width() == 0);
15000 }
15001 ios.width(25);
15002 internal(ios);
15003 {
15004 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15005 std::string ex(str, iter.base());
15006 assert(ex == "-*********************0.0");
15007 assert(ios.width() == 0);
15008 }
15009 }
15010 ios.imbue(lg);
15011 {
15012 ios.width(0);
15013 {
15014 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15015 std::string ex(str, iter.base());
15016 assert(ex == "-0;0");
15017 assert(ios.width() == 0);
15018 }
15019 ios.width(25);
15020 left(ios);
15021 {
15022 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15023 std::string ex(str, iter.base());
15024 assert(ex == "-0;0*********************");
15025 assert(ios.width() == 0);
15026 }
15027 ios.width(25);
15028 right(ios);
15029 {
15030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15031 std::string ex(str, iter.base());
15032 assert(ex == "*********************-0;0");
15033 assert(ios.width() == 0);
15034 }
15035 ios.width(25);
15036 internal(ios);
15037 {
15038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15039 std::string ex(str, iter.base());
15040 assert(ex == "-*********************0;0");
15041 assert(ios.width() == 0);
15042 }
15043 }
15044 }
15045 }
15046 showpos(ios);
15047 {
15048 noshowpoint(ios);
15049 {
15050 ios.imbue(lc);
15051 {
15052 ios.width(0);
15053 {
15054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15055 std::string ex(str, iter.base());
15056 assert(ex == "-0.0");
15057 assert(ios.width() == 0);
15058 }
15059 ios.width(25);
15060 left(ios);
15061 {
15062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15063 std::string ex(str, iter.base());
15064 assert(ex == "-0.0*********************");
15065 assert(ios.width() == 0);
15066 }
15067 ios.width(25);
15068 right(ios);
15069 {
15070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15071 std::string ex(str, iter.base());
15072 assert(ex == "*********************-0.0");
15073 assert(ios.width() == 0);
15074 }
15075 ios.width(25);
15076 internal(ios);
15077 {
15078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15079 std::string ex(str, iter.base());
15080 assert(ex == "-*********************0.0");
15081 assert(ios.width() == 0);
15082 }
15083 }
15084 ios.imbue(lg);
15085 {
15086 ios.width(0);
15087 {
15088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15089 std::string ex(str, iter.base());
15090 assert(ex == "-0;0");
15091 assert(ios.width() == 0);
15092 }
15093 ios.width(25);
15094 left(ios);
15095 {
15096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15097 std::string ex(str, iter.base());
15098 assert(ex == "-0;0*********************");
15099 assert(ios.width() == 0);
15100 }
15101 ios.width(25);
15102 right(ios);
15103 {
15104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15105 std::string ex(str, iter.base());
15106 assert(ex == "*********************-0;0");
15107 assert(ios.width() == 0);
15108 }
15109 ios.width(25);
15110 internal(ios);
15111 {
15112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15113 std::string ex(str, iter.base());
15114 assert(ex == "-*********************0;0");
15115 assert(ios.width() == 0);
15116 }
15117 }
15118 }
15119 showpoint(ios);
15120 {
15121 ios.imbue(lc);
15122 {
15123 ios.width(0);
15124 {
15125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15126 std::string ex(str, iter.base());
15127 assert(ex == "-0.0");
15128 assert(ios.width() == 0);
15129 }
15130 ios.width(25);
15131 left(ios);
15132 {
15133 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15134 std::string ex(str, iter.base());
15135 assert(ex == "-0.0*********************");
15136 assert(ios.width() == 0);
15137 }
15138 ios.width(25);
15139 right(ios);
15140 {
15141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15142 std::string ex(str, iter.base());
15143 assert(ex == "*********************-0.0");
15144 assert(ios.width() == 0);
15145 }
15146 ios.width(25);
15147 internal(ios);
15148 {
15149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15150 std::string ex(str, iter.base());
15151 assert(ex == "-*********************0.0");
15152 assert(ios.width() == 0);
15153 }
15154 }
15155 ios.imbue(lg);
15156 {
15157 ios.width(0);
15158 {
15159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15160 std::string ex(str, iter.base());
15161 assert(ex == "-0;0");
15162 assert(ios.width() == 0);
15163 }
15164 ios.width(25);
15165 left(ios);
15166 {
15167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15168 std::string ex(str, iter.base());
15169 assert(ex == "-0;0*********************");
15170 assert(ios.width() == 0);
15171 }
15172 ios.width(25);
15173 right(ios);
15174 {
15175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15176 std::string ex(str, iter.base());
15177 assert(ex == "*********************-0;0");
15178 assert(ios.width() == 0);
15179 }
15180 ios.width(25);
15181 internal(ios);
15182 {
15183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15184 std::string ex(str, iter.base());
15185 assert(ex == "-*********************0;0");
15186 assert(ios.width() == 0);
15187 }
15188 }
15189 }
15190 }
15191 }
15192 uppercase(ios);
15193 {
15194 noshowpos(ios);
15195 {
15196 noshowpoint(ios);
15197 {
15198 ios.imbue(lc);
15199 {
15200 ios.width(0);
15201 {
15202 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15203 std::string ex(str, iter.base());
15204 assert(ex == "-0.0");
15205 assert(ios.width() == 0);
15206 }
15207 ios.width(25);
15208 left(ios);
15209 {
15210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15211 std::string ex(str, iter.base());
15212 assert(ex == "-0.0*********************");
15213 assert(ios.width() == 0);
15214 }
15215 ios.width(25);
15216 right(ios);
15217 {
15218 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15219 std::string ex(str, iter.base());
15220 assert(ex == "*********************-0.0");
15221 assert(ios.width() == 0);
15222 }
15223 ios.width(25);
15224 internal(ios);
15225 {
15226 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15227 std::string ex(str, iter.base());
15228 assert(ex == "-*********************0.0");
15229 assert(ios.width() == 0);
15230 }
15231 }
15232 ios.imbue(lg);
15233 {
15234 ios.width(0);
15235 {
15236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15237 std::string ex(str, iter.base());
15238 assert(ex == "-0;0");
15239 assert(ios.width() == 0);
15240 }
15241 ios.width(25);
15242 left(ios);
15243 {
15244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15245 std::string ex(str, iter.base());
15246 assert(ex == "-0;0*********************");
15247 assert(ios.width() == 0);
15248 }
15249 ios.width(25);
15250 right(ios);
15251 {
15252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15253 std::string ex(str, iter.base());
15254 assert(ex == "*********************-0;0");
15255 assert(ios.width() == 0);
15256 }
15257 ios.width(25);
15258 internal(ios);
15259 {
15260 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15261 std::string ex(str, iter.base());
15262 assert(ex == "-*********************0;0");
15263 assert(ios.width() == 0);
15264 }
15265 }
15266 }
15267 showpoint(ios);
15268 {
15269 ios.imbue(lc);
15270 {
15271 ios.width(0);
15272 {
15273 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15274 std::string ex(str, iter.base());
15275 assert(ex == "-0.0");
15276 assert(ios.width() == 0);
15277 }
15278 ios.width(25);
15279 left(ios);
15280 {
15281 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15282 std::string ex(str, iter.base());
15283 assert(ex == "-0.0*********************");
15284 assert(ios.width() == 0);
15285 }
15286 ios.width(25);
15287 right(ios);
15288 {
15289 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15290 std::string ex(str, iter.base());
15291 assert(ex == "*********************-0.0");
15292 assert(ios.width() == 0);
15293 }
15294 ios.width(25);
15295 internal(ios);
15296 {
15297 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15298 std::string ex(str, iter.base());
15299 assert(ex == "-*********************0.0");
15300 assert(ios.width() == 0);
15301 }
15302 }
15303 ios.imbue(lg);
15304 {
15305 ios.width(0);
15306 {
15307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15308 std::string ex(str, iter.base());
15309 assert(ex == "-0;0");
15310 assert(ios.width() == 0);
15311 }
15312 ios.width(25);
15313 left(ios);
15314 {
15315 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15316 std::string ex(str, iter.base());
15317 assert(ex == "-0;0*********************");
15318 assert(ios.width() == 0);
15319 }
15320 ios.width(25);
15321 right(ios);
15322 {
15323 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15324 std::string ex(str, iter.base());
15325 assert(ex == "*********************-0;0");
15326 assert(ios.width() == 0);
15327 }
15328 ios.width(25);
15329 internal(ios);
15330 {
15331 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15332 std::string ex(str, iter.base());
15333 assert(ex == "-*********************0;0");
15334 assert(ios.width() == 0);
15335 }
15336 }
15337 }
15338 }
15339 showpos(ios);
15340 {
15341 noshowpoint(ios);
15342 {
15343 ios.imbue(lc);
15344 {
15345 ios.width(0);
15346 {
15347 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15348 std::string ex(str, iter.base());
15349 assert(ex == "-0.0");
15350 assert(ios.width() == 0);
15351 }
15352 ios.width(25);
15353 left(ios);
15354 {
15355 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15356 std::string ex(str, iter.base());
15357 assert(ex == "-0.0*********************");
15358 assert(ios.width() == 0);
15359 }
15360 ios.width(25);
15361 right(ios);
15362 {
15363 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15364 std::string ex(str, iter.base());
15365 assert(ex == "*********************-0.0");
15366 assert(ios.width() == 0);
15367 }
15368 ios.width(25);
15369 internal(ios);
15370 {
15371 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15372 std::string ex(str, iter.base());
15373 assert(ex == "-*********************0.0");
15374 assert(ios.width() == 0);
15375 }
15376 }
15377 ios.imbue(lg);
15378 {
15379 ios.width(0);
15380 {
15381 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15382 std::string ex(str, iter.base());
15383 assert(ex == "-0;0");
15384 assert(ios.width() == 0);
15385 }
15386 ios.width(25);
15387 left(ios);
15388 {
15389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15390 std::string ex(str, iter.base());
15391 assert(ex == "-0;0*********************");
15392 assert(ios.width() == 0);
15393 }
15394 ios.width(25);
15395 right(ios);
15396 {
15397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15398 std::string ex(str, iter.base());
15399 assert(ex == "*********************-0;0");
15400 assert(ios.width() == 0);
15401 }
15402 ios.width(25);
15403 internal(ios);
15404 {
15405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15406 std::string ex(str, iter.base());
15407 assert(ex == "-*********************0;0");
15408 assert(ios.width() == 0);
15409 }
15410 }
15411 }
15412 showpoint(ios);
15413 {
15414 ios.imbue(lc);
15415 {
15416 ios.width(0);
15417 {
15418 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15419 std::string ex(str, iter.base());
15420 assert(ex == "-0.0");
15421 assert(ios.width() == 0);
15422 }
15423 ios.width(25);
15424 left(ios);
15425 {
15426 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15427 std::string ex(str, iter.base());
15428 assert(ex == "-0.0*********************");
15429 assert(ios.width() == 0);
15430 }
15431 ios.width(25);
15432 right(ios);
15433 {
15434 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15435 std::string ex(str, iter.base());
15436 assert(ex == "*********************-0.0");
15437 assert(ios.width() == 0);
15438 }
15439 ios.width(25);
15440 internal(ios);
15441 {
15442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15443 std::string ex(str, iter.base());
15444 assert(ex == "-*********************0.0");
15445 assert(ios.width() == 0);
15446 }
15447 }
15448 ios.imbue(lg);
15449 {
15450 ios.width(0);
15451 {
15452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15453 std::string ex(str, iter.base());
15454 assert(ex == "-0;0");
15455 assert(ios.width() == 0);
15456 }
15457 ios.width(25);
15458 left(ios);
15459 {
15460 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15461 std::string ex(str, iter.base());
15462 assert(ex == "-0;0*********************");
15463 assert(ios.width() == 0);
15464 }
15465 ios.width(25);
15466 right(ios);
15467 {
15468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15469 std::string ex(str, iter.base());
15470 assert(ex == "*********************-0;0");
15471 assert(ios.width() == 0);
15472 }
15473 ios.width(25);
15474 internal(ios);
15475 {
15476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15477 std::string ex(str, iter.base());
15478 assert(ex == "-*********************0;0");
15479 assert(ios.width() == 0);
15480 }
15481 }
15482 }
15483 }
15484 }
15485 }
15486 ios.precision(6);
15487 {
15488 nouppercase(ios);
15489 {
15490 noshowpos(ios);
15491 {
15492 noshowpoint(ios);
15493 {
15494 ios.imbue(lc);
15495 {
15496 ios.width(0);
15497 {
15498 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15499 std::string ex(str, iter.base());
15500 assert(ex == "-0.000000");
15501 assert(ios.width() == 0);
15502 }
15503 ios.width(25);
15504 left(ios);
15505 {
15506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15507 std::string ex(str, iter.base());
15508 assert(ex == "-0.000000****************");
15509 assert(ios.width() == 0);
15510 }
15511 ios.width(25);
15512 right(ios);
15513 {
15514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15515 std::string ex(str, iter.base());
15516 assert(ex == "****************-0.000000");
15517 assert(ios.width() == 0);
15518 }
15519 ios.width(25);
15520 internal(ios);
15521 {
15522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15523 std::string ex(str, iter.base());
15524 assert(ex == "-****************0.000000");
15525 assert(ios.width() == 0);
15526 }
15527 }
15528 ios.imbue(lg);
15529 {
15530 ios.width(0);
15531 {
15532 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15533 std::string ex(str, iter.base());
15534 assert(ex == "-0;000000");
15535 assert(ios.width() == 0);
15536 }
15537 ios.width(25);
15538 left(ios);
15539 {
15540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15541 std::string ex(str, iter.base());
15542 assert(ex == "-0;000000****************");
15543 assert(ios.width() == 0);
15544 }
15545 ios.width(25);
15546 right(ios);
15547 {
15548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15549 std::string ex(str, iter.base());
15550 assert(ex == "****************-0;000000");
15551 assert(ios.width() == 0);
15552 }
15553 ios.width(25);
15554 internal(ios);
15555 {
15556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15557 std::string ex(str, iter.base());
15558 assert(ex == "-****************0;000000");
15559 assert(ios.width() == 0);
15560 }
15561 }
15562 }
15563 showpoint(ios);
15564 {
15565 ios.imbue(lc);
15566 {
15567 ios.width(0);
15568 {
15569 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15570 std::string ex(str, iter.base());
15571 assert(ex == "-0.000000");
15572 assert(ios.width() == 0);
15573 }
15574 ios.width(25);
15575 left(ios);
15576 {
15577 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15578 std::string ex(str, iter.base());
15579 assert(ex == "-0.000000****************");
15580 assert(ios.width() == 0);
15581 }
15582 ios.width(25);
15583 right(ios);
15584 {
15585 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15586 std::string ex(str, iter.base());
15587 assert(ex == "****************-0.000000");
15588 assert(ios.width() == 0);
15589 }
15590 ios.width(25);
15591 internal(ios);
15592 {
15593 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15594 std::string ex(str, iter.base());
15595 assert(ex == "-****************0.000000");
15596 assert(ios.width() == 0);
15597 }
15598 }
15599 ios.imbue(lg);
15600 {
15601 ios.width(0);
15602 {
15603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15604 std::string ex(str, iter.base());
15605 assert(ex == "-0;000000");
15606 assert(ios.width() == 0);
15607 }
15608 ios.width(25);
15609 left(ios);
15610 {
15611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15612 std::string ex(str, iter.base());
15613 assert(ex == "-0;000000****************");
15614 assert(ios.width() == 0);
15615 }
15616 ios.width(25);
15617 right(ios);
15618 {
15619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15620 std::string ex(str, iter.base());
15621 assert(ex == "****************-0;000000");
15622 assert(ios.width() == 0);
15623 }
15624 ios.width(25);
15625 internal(ios);
15626 {
15627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15628 std::string ex(str, iter.base());
15629 assert(ex == "-****************0;000000");
15630 assert(ios.width() == 0);
15631 }
15632 }
15633 }
15634 }
15635 showpos(ios);
15636 {
15637 noshowpoint(ios);
15638 {
15639 ios.imbue(lc);
15640 {
15641 ios.width(0);
15642 {
15643 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15644 std::string ex(str, iter.base());
15645 assert(ex == "-0.000000");
15646 assert(ios.width() == 0);
15647 }
15648 ios.width(25);
15649 left(ios);
15650 {
15651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15652 std::string ex(str, iter.base());
15653 assert(ex == "-0.000000****************");
15654 assert(ios.width() == 0);
15655 }
15656 ios.width(25);
15657 right(ios);
15658 {
15659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15660 std::string ex(str, iter.base());
15661 assert(ex == "****************-0.000000");
15662 assert(ios.width() == 0);
15663 }
15664 ios.width(25);
15665 internal(ios);
15666 {
15667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15668 std::string ex(str, iter.base());
15669 assert(ex == "-****************0.000000");
15670 assert(ios.width() == 0);
15671 }
15672 }
15673 ios.imbue(lg);
15674 {
15675 ios.width(0);
15676 {
15677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15678 std::string ex(str, iter.base());
15679 assert(ex == "-0;000000");
15680 assert(ios.width() == 0);
15681 }
15682 ios.width(25);
15683 left(ios);
15684 {
15685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15686 std::string ex(str, iter.base());
15687 assert(ex == "-0;000000****************");
15688 assert(ios.width() == 0);
15689 }
15690 ios.width(25);
15691 right(ios);
15692 {
15693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15694 std::string ex(str, iter.base());
15695 assert(ex == "****************-0;000000");
15696 assert(ios.width() == 0);
15697 }
15698 ios.width(25);
15699 internal(ios);
15700 {
15701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15702 std::string ex(str, iter.base());
15703 assert(ex == "-****************0;000000");
15704 assert(ios.width() == 0);
15705 }
15706 }
15707 }
15708 showpoint(ios);
15709 {
15710 ios.imbue(lc);
15711 {
15712 ios.width(0);
15713 {
15714 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15715 std::string ex(str, iter.base());
15716 assert(ex == "-0.000000");
15717 assert(ios.width() == 0);
15718 }
15719 ios.width(25);
15720 left(ios);
15721 {
15722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15723 std::string ex(str, iter.base());
15724 assert(ex == "-0.000000****************");
15725 assert(ios.width() == 0);
15726 }
15727 ios.width(25);
15728 right(ios);
15729 {
15730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15731 std::string ex(str, iter.base());
15732 assert(ex == "****************-0.000000");
15733 assert(ios.width() == 0);
15734 }
15735 ios.width(25);
15736 internal(ios);
15737 {
15738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15739 std::string ex(str, iter.base());
15740 assert(ex == "-****************0.000000");
15741 assert(ios.width() == 0);
15742 }
15743 }
15744 ios.imbue(lg);
15745 {
15746 ios.width(0);
15747 {
15748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15749 std::string ex(str, iter.base());
15750 assert(ex == "-0;000000");
15751 assert(ios.width() == 0);
15752 }
15753 ios.width(25);
15754 left(ios);
15755 {
15756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15757 std::string ex(str, iter.base());
15758 assert(ex == "-0;000000****************");
15759 assert(ios.width() == 0);
15760 }
15761 ios.width(25);
15762 right(ios);
15763 {
15764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15765 std::string ex(str, iter.base());
15766 assert(ex == "****************-0;000000");
15767 assert(ios.width() == 0);
15768 }
15769 ios.width(25);
15770 internal(ios);
15771 {
15772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15773 std::string ex(str, iter.base());
15774 assert(ex == "-****************0;000000");
15775 assert(ios.width() == 0);
15776 }
15777 }
15778 }
15779 }
15780 }
15781 uppercase(ios);
15782 {
15783 noshowpos(ios);
15784 {
15785 noshowpoint(ios);
15786 {
15787 ios.imbue(lc);
15788 {
15789 ios.width(0);
15790 {
15791 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15792 std::string ex(str, iter.base());
15793 assert(ex == "-0.000000");
15794 assert(ios.width() == 0);
15795 }
15796 ios.width(25);
15797 left(ios);
15798 {
15799 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15800 std::string ex(str, iter.base());
15801 assert(ex == "-0.000000****************");
15802 assert(ios.width() == 0);
15803 }
15804 ios.width(25);
15805 right(ios);
15806 {
15807 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15808 std::string ex(str, iter.base());
15809 assert(ex == "****************-0.000000");
15810 assert(ios.width() == 0);
15811 }
15812 ios.width(25);
15813 internal(ios);
15814 {
15815 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15816 std::string ex(str, iter.base());
15817 assert(ex == "-****************0.000000");
15818 assert(ios.width() == 0);
15819 }
15820 }
15821 ios.imbue(lg);
15822 {
15823 ios.width(0);
15824 {
15825 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15826 std::string ex(str, iter.base());
15827 assert(ex == "-0;000000");
15828 assert(ios.width() == 0);
15829 }
15830 ios.width(25);
15831 left(ios);
15832 {
15833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15834 std::string ex(str, iter.base());
15835 assert(ex == "-0;000000****************");
15836 assert(ios.width() == 0);
15837 }
15838 ios.width(25);
15839 right(ios);
15840 {
15841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15842 std::string ex(str, iter.base());
15843 assert(ex == "****************-0;000000");
15844 assert(ios.width() == 0);
15845 }
15846 ios.width(25);
15847 internal(ios);
15848 {
15849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15850 std::string ex(str, iter.base());
15851 assert(ex == "-****************0;000000");
15852 assert(ios.width() == 0);
15853 }
15854 }
15855 }
15856 showpoint(ios);
15857 {
15858 ios.imbue(lc);
15859 {
15860 ios.width(0);
15861 {
15862 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15863 std::string ex(str, iter.base());
15864 assert(ex == "-0.000000");
15865 assert(ios.width() == 0);
15866 }
15867 ios.width(25);
15868 left(ios);
15869 {
15870 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15871 std::string ex(str, iter.base());
15872 assert(ex == "-0.000000****************");
15873 assert(ios.width() == 0);
15874 }
15875 ios.width(25);
15876 right(ios);
15877 {
15878 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15879 std::string ex(str, iter.base());
15880 assert(ex == "****************-0.000000");
15881 assert(ios.width() == 0);
15882 }
15883 ios.width(25);
15884 internal(ios);
15885 {
15886 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15887 std::string ex(str, iter.base());
15888 assert(ex == "-****************0.000000");
15889 assert(ios.width() == 0);
15890 }
15891 }
15892 ios.imbue(lg);
15893 {
15894 ios.width(0);
15895 {
15896 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15897 std::string ex(str, iter.base());
15898 assert(ex == "-0;000000");
15899 assert(ios.width() == 0);
15900 }
15901 ios.width(25);
15902 left(ios);
15903 {
15904 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15905 std::string ex(str, iter.base());
15906 assert(ex == "-0;000000****************");
15907 assert(ios.width() == 0);
15908 }
15909 ios.width(25);
15910 right(ios);
15911 {
15912 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15913 std::string ex(str, iter.base());
15914 assert(ex == "****************-0;000000");
15915 assert(ios.width() == 0);
15916 }
15917 ios.width(25);
15918 internal(ios);
15919 {
15920 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15921 std::string ex(str, iter.base());
15922 assert(ex == "-****************0;000000");
15923 assert(ios.width() == 0);
15924 }
15925 }
15926 }
15927 }
15928 showpos(ios);
15929 {
15930 noshowpoint(ios);
15931 {
15932 ios.imbue(lc);
15933 {
15934 ios.width(0);
15935 {
15936 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15937 std::string ex(str, iter.base());
15938 assert(ex == "-0.000000");
15939 assert(ios.width() == 0);
15940 }
15941 ios.width(25);
15942 left(ios);
15943 {
15944 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15945 std::string ex(str, iter.base());
15946 assert(ex == "-0.000000****************");
15947 assert(ios.width() == 0);
15948 }
15949 ios.width(25);
15950 right(ios);
15951 {
15952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15953 std::string ex(str, iter.base());
15954 assert(ex == "****************-0.000000");
15955 assert(ios.width() == 0);
15956 }
15957 ios.width(25);
15958 internal(ios);
15959 {
15960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15961 std::string ex(str, iter.base());
15962 assert(ex == "-****************0.000000");
15963 assert(ios.width() == 0);
15964 }
15965 }
15966 ios.imbue(lg);
15967 {
15968 ios.width(0);
15969 {
15970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15971 std::string ex(str, iter.base());
15972 assert(ex == "-0;000000");
15973 assert(ios.width() == 0);
15974 }
15975 ios.width(25);
15976 left(ios);
15977 {
15978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15979 std::string ex(str, iter.base());
15980 assert(ex == "-0;000000****************");
15981 assert(ios.width() == 0);
15982 }
15983 ios.width(25);
15984 right(ios);
15985 {
15986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15987 std::string ex(str, iter.base());
15988 assert(ex == "****************-0;000000");
15989 assert(ios.width() == 0);
15990 }
15991 ios.width(25);
15992 internal(ios);
15993 {
15994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15995 std::string ex(str, iter.base());
15996 assert(ex == "-****************0;000000");
15997 assert(ios.width() == 0);
15998 }
15999 }
16000 }
16001 showpoint(ios);
16002 {
16003 ios.imbue(lc);
16004 {
16005 ios.width(0);
16006 {
16007 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16008 std::string ex(str, iter.base());
16009 assert(ex == "-0.000000");
16010 assert(ios.width() == 0);
16011 }
16012 ios.width(25);
16013 left(ios);
16014 {
16015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16016 std::string ex(str, iter.base());
16017 assert(ex == "-0.000000****************");
16018 assert(ios.width() == 0);
16019 }
16020 ios.width(25);
16021 right(ios);
16022 {
16023 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16024 std::string ex(str, iter.base());
16025 assert(ex == "****************-0.000000");
16026 assert(ios.width() == 0);
16027 }
16028 ios.width(25);
16029 internal(ios);
16030 {
16031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16032 std::string ex(str, iter.base());
16033 assert(ex == "-****************0.000000");
16034 assert(ios.width() == 0);
16035 }
16036 }
16037 ios.imbue(lg);
16038 {
16039 ios.width(0);
16040 {
16041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16042 std::string ex(str, iter.base());
16043 assert(ex == "-0;000000");
16044 assert(ios.width() == 0);
16045 }
16046 ios.width(25);
16047 left(ios);
16048 {
16049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16050 std::string ex(str, iter.base());
16051 assert(ex == "-0;000000****************");
16052 assert(ios.width() == 0);
16053 }
16054 ios.width(25);
16055 right(ios);
16056 {
16057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16058 std::string ex(str, iter.base());
16059 assert(ex == "****************-0;000000");
16060 assert(ios.width() == 0);
16061 }
16062 ios.width(25);
16063 internal(ios);
16064 {
16065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16066 std::string ex(str, iter.base());
16067 assert(ex == "-****************0;000000");
16068 assert(ios.width() == 0);
16069 }
16070 }
16071 }
16072 }
16073 }
16074 }
16075 ios.precision(16);
16076 {
16077 nouppercase(ios);
16078 {
16079 noshowpos(ios);
16080 {
16081 noshowpoint(ios);
16082 {
16083 ios.imbue(lc);
16084 {
16085 ios.width(0);
16086 {
16087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16088 std::string ex(str, iter.base());
16089 assert(ex == "-0.0000000000000000");
16090 assert(ios.width() == 0);
16091 }
16092 ios.width(25);
16093 left(ios);
16094 {
16095 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16096 std::string ex(str, iter.base());
16097 assert(ex == "-0.0000000000000000******");
16098 assert(ios.width() == 0);
16099 }
16100 ios.width(25);
16101 right(ios);
16102 {
16103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16104 std::string ex(str, iter.base());
16105 assert(ex == "******-0.0000000000000000");
16106 assert(ios.width() == 0);
16107 }
16108 ios.width(25);
16109 internal(ios);
16110 {
16111 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16112 std::string ex(str, iter.base());
16113 assert(ex == "-******0.0000000000000000");
16114 assert(ios.width() == 0);
16115 }
16116 }
16117 ios.imbue(lg);
16118 {
16119 ios.width(0);
16120 {
16121 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16122 std::string ex(str, iter.base());
16123 assert(ex == "-0;0000000000000000");
16124 assert(ios.width() == 0);
16125 }
16126 ios.width(25);
16127 left(ios);
16128 {
16129 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16130 std::string ex(str, iter.base());
16131 assert(ex == "-0;0000000000000000******");
16132 assert(ios.width() == 0);
16133 }
16134 ios.width(25);
16135 right(ios);
16136 {
16137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16138 std::string ex(str, iter.base());
16139 assert(ex == "******-0;0000000000000000");
16140 assert(ios.width() == 0);
16141 }
16142 ios.width(25);
16143 internal(ios);
16144 {
16145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16146 std::string ex(str, iter.base());
16147 assert(ex == "-******0;0000000000000000");
16148 assert(ios.width() == 0);
16149 }
16150 }
16151 }
16152 showpoint(ios);
16153 {
16154 ios.imbue(lc);
16155 {
16156 ios.width(0);
16157 {
16158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16159 std::string ex(str, iter.base());
16160 assert(ex == "-0.0000000000000000");
16161 assert(ios.width() == 0);
16162 }
16163 ios.width(25);
16164 left(ios);
16165 {
16166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16167 std::string ex(str, iter.base());
16168 assert(ex == "-0.0000000000000000******");
16169 assert(ios.width() == 0);
16170 }
16171 ios.width(25);
16172 right(ios);
16173 {
16174 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16175 std::string ex(str, iter.base());
16176 assert(ex == "******-0.0000000000000000");
16177 assert(ios.width() == 0);
16178 }
16179 ios.width(25);
16180 internal(ios);
16181 {
16182 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16183 std::string ex(str, iter.base());
16184 assert(ex == "-******0.0000000000000000");
16185 assert(ios.width() == 0);
16186 }
16187 }
16188 ios.imbue(lg);
16189 {
16190 ios.width(0);
16191 {
16192 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16193 std::string ex(str, iter.base());
16194 assert(ex == "-0;0000000000000000");
16195 assert(ios.width() == 0);
16196 }
16197 ios.width(25);
16198 left(ios);
16199 {
16200 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16201 std::string ex(str, iter.base());
16202 assert(ex == "-0;0000000000000000******");
16203 assert(ios.width() == 0);
16204 }
16205 ios.width(25);
16206 right(ios);
16207 {
16208 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16209 std::string ex(str, iter.base());
16210 assert(ex == "******-0;0000000000000000");
16211 assert(ios.width() == 0);
16212 }
16213 ios.width(25);
16214 internal(ios);
16215 {
16216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16217 std::string ex(str, iter.base());
16218 assert(ex == "-******0;0000000000000000");
16219 assert(ios.width() == 0);
16220 }
16221 }
16222 }
16223 }
16224 showpos(ios);
16225 {
16226 noshowpoint(ios);
16227 {
16228 ios.imbue(lc);
16229 {
16230 ios.width(0);
16231 {
16232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16233 std::string ex(str, iter.base());
16234 assert(ex == "-0.0000000000000000");
16235 assert(ios.width() == 0);
16236 }
16237 ios.width(25);
16238 left(ios);
16239 {
16240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16241 std::string ex(str, iter.base());
16242 assert(ex == "-0.0000000000000000******");
16243 assert(ios.width() == 0);
16244 }
16245 ios.width(25);
16246 right(ios);
16247 {
16248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16249 std::string ex(str, iter.base());
16250 assert(ex == "******-0.0000000000000000");
16251 assert(ios.width() == 0);
16252 }
16253 ios.width(25);
16254 internal(ios);
16255 {
16256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16257 std::string ex(str, iter.base());
16258 assert(ex == "-******0.0000000000000000");
16259 assert(ios.width() == 0);
16260 }
16261 }
16262 ios.imbue(lg);
16263 {
16264 ios.width(0);
16265 {
16266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16267 std::string ex(str, iter.base());
16268 assert(ex == "-0;0000000000000000");
16269 assert(ios.width() == 0);
16270 }
16271 ios.width(25);
16272 left(ios);
16273 {
16274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16275 std::string ex(str, iter.base());
16276 assert(ex == "-0;0000000000000000******");
16277 assert(ios.width() == 0);
16278 }
16279 ios.width(25);
16280 right(ios);
16281 {
16282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16283 std::string ex(str, iter.base());
16284 assert(ex == "******-0;0000000000000000");
16285 assert(ios.width() == 0);
16286 }
16287 ios.width(25);
16288 internal(ios);
16289 {
16290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16291 std::string ex(str, iter.base());
16292 assert(ex == "-******0;0000000000000000");
16293 assert(ios.width() == 0);
16294 }
16295 }
16296 }
16297 showpoint(ios);
16298 {
16299 ios.imbue(lc);
16300 {
16301 ios.width(0);
16302 {
16303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16304 std::string ex(str, iter.base());
16305 assert(ex == "-0.0000000000000000");
16306 assert(ios.width() == 0);
16307 }
16308 ios.width(25);
16309 left(ios);
16310 {
16311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16312 std::string ex(str, iter.base());
16313 assert(ex == "-0.0000000000000000******");
16314 assert(ios.width() == 0);
16315 }
16316 ios.width(25);
16317 right(ios);
16318 {
16319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16320 std::string ex(str, iter.base());
16321 assert(ex == "******-0.0000000000000000");
16322 assert(ios.width() == 0);
16323 }
16324 ios.width(25);
16325 internal(ios);
16326 {
16327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16328 std::string ex(str, iter.base());
16329 assert(ex == "-******0.0000000000000000");
16330 assert(ios.width() == 0);
16331 }
16332 }
16333 ios.imbue(lg);
16334 {
16335 ios.width(0);
16336 {
16337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16338 std::string ex(str, iter.base());
16339 assert(ex == "-0;0000000000000000");
16340 assert(ios.width() == 0);
16341 }
16342 ios.width(25);
16343 left(ios);
16344 {
16345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16346 std::string ex(str, iter.base());
16347 assert(ex == "-0;0000000000000000******");
16348 assert(ios.width() == 0);
16349 }
16350 ios.width(25);
16351 right(ios);
16352 {
16353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16354 std::string ex(str, iter.base());
16355 assert(ex == "******-0;0000000000000000");
16356 assert(ios.width() == 0);
16357 }
16358 ios.width(25);
16359 internal(ios);
16360 {
16361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16362 std::string ex(str, iter.base());
16363 assert(ex == "-******0;0000000000000000");
16364 assert(ios.width() == 0);
16365 }
16366 }
16367 }
16368 }
16369 }
16370 uppercase(ios);
16371 {
16372 noshowpos(ios);
16373 {
16374 noshowpoint(ios);
16375 {
16376 ios.imbue(lc);
16377 {
16378 ios.width(0);
16379 {
16380 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16381 std::string ex(str, iter.base());
16382 assert(ex == "-0.0000000000000000");
16383 assert(ios.width() == 0);
16384 }
16385 ios.width(25);
16386 left(ios);
16387 {
16388 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16389 std::string ex(str, iter.base());
16390 assert(ex == "-0.0000000000000000******");
16391 assert(ios.width() == 0);
16392 }
16393 ios.width(25);
16394 right(ios);
16395 {
16396 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16397 std::string ex(str, iter.base());
16398 assert(ex == "******-0.0000000000000000");
16399 assert(ios.width() == 0);
16400 }
16401 ios.width(25);
16402 internal(ios);
16403 {
16404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16405 std::string ex(str, iter.base());
16406 assert(ex == "-******0.0000000000000000");
16407 assert(ios.width() == 0);
16408 }
16409 }
16410 ios.imbue(lg);
16411 {
16412 ios.width(0);
16413 {
16414 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16415 std::string ex(str, iter.base());
16416 assert(ex == "-0;0000000000000000");
16417 assert(ios.width() == 0);
16418 }
16419 ios.width(25);
16420 left(ios);
16421 {
16422 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16423 std::string ex(str, iter.base());
16424 assert(ex == "-0;0000000000000000******");
16425 assert(ios.width() == 0);
16426 }
16427 ios.width(25);
16428 right(ios);
16429 {
16430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16431 std::string ex(str, iter.base());
16432 assert(ex == "******-0;0000000000000000");
16433 assert(ios.width() == 0);
16434 }
16435 ios.width(25);
16436 internal(ios);
16437 {
16438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16439 std::string ex(str, iter.base());
16440 assert(ex == "-******0;0000000000000000");
16441 assert(ios.width() == 0);
16442 }
16443 }
16444 }
16445 showpoint(ios);
16446 {
16447 ios.imbue(lc);
16448 {
16449 ios.width(0);
16450 {
16451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16452 std::string ex(str, iter.base());
16453 assert(ex == "-0.0000000000000000");
16454 assert(ios.width() == 0);
16455 }
16456 ios.width(25);
16457 left(ios);
16458 {
16459 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16460 std::string ex(str, iter.base());
16461 assert(ex == "-0.0000000000000000******");
16462 assert(ios.width() == 0);
16463 }
16464 ios.width(25);
16465 right(ios);
16466 {
16467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16468 std::string ex(str, iter.base());
16469 assert(ex == "******-0.0000000000000000");
16470 assert(ios.width() == 0);
16471 }
16472 ios.width(25);
16473 internal(ios);
16474 {
16475 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16476 std::string ex(str, iter.base());
16477 assert(ex == "-******0.0000000000000000");
16478 assert(ios.width() == 0);
16479 }
16480 }
16481 ios.imbue(lg);
16482 {
16483 ios.width(0);
16484 {
16485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16486 std::string ex(str, iter.base());
16487 assert(ex == "-0;0000000000000000");
16488 assert(ios.width() == 0);
16489 }
16490 ios.width(25);
16491 left(ios);
16492 {
16493 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16494 std::string ex(str, iter.base());
16495 assert(ex == "-0;0000000000000000******");
16496 assert(ios.width() == 0);
16497 }
16498 ios.width(25);
16499 right(ios);
16500 {
16501 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16502 std::string ex(str, iter.base());
16503 assert(ex == "******-0;0000000000000000");
16504 assert(ios.width() == 0);
16505 }
16506 ios.width(25);
16507 internal(ios);
16508 {
16509 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16510 std::string ex(str, iter.base());
16511 assert(ex == "-******0;0000000000000000");
16512 assert(ios.width() == 0);
16513 }
16514 }
16515 }
16516 }
16517 showpos(ios);
16518 {
16519 noshowpoint(ios);
16520 {
16521 ios.imbue(lc);
16522 {
16523 ios.width(0);
16524 {
16525 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16526 std::string ex(str, iter.base());
16527 assert(ex == "-0.0000000000000000");
16528 assert(ios.width() == 0);
16529 }
16530 ios.width(25);
16531 left(ios);
16532 {
16533 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16534 std::string ex(str, iter.base());
16535 assert(ex == "-0.0000000000000000******");
16536 assert(ios.width() == 0);
16537 }
16538 ios.width(25);
16539 right(ios);
16540 {
16541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16542 std::string ex(str, iter.base());
16543 assert(ex == "******-0.0000000000000000");
16544 assert(ios.width() == 0);
16545 }
16546 ios.width(25);
16547 internal(ios);
16548 {
16549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16550 std::string ex(str, iter.base());
16551 assert(ex == "-******0.0000000000000000");
16552 assert(ios.width() == 0);
16553 }
16554 }
16555 ios.imbue(lg);
16556 {
16557 ios.width(0);
16558 {
16559 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16560 std::string ex(str, iter.base());
16561 assert(ex == "-0;0000000000000000");
16562 assert(ios.width() == 0);
16563 }
16564 ios.width(25);
16565 left(ios);
16566 {
16567 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16568 std::string ex(str, iter.base());
16569 assert(ex == "-0;0000000000000000******");
16570 assert(ios.width() == 0);
16571 }
16572 ios.width(25);
16573 right(ios);
16574 {
16575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16576 std::string ex(str, iter.base());
16577 assert(ex == "******-0;0000000000000000");
16578 assert(ios.width() == 0);
16579 }
16580 ios.width(25);
16581 internal(ios);
16582 {
16583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16584 std::string ex(str, iter.base());
16585 assert(ex == "-******0;0000000000000000");
16586 assert(ios.width() == 0);
16587 }
16588 }
16589 }
16590 showpoint(ios);
16591 {
16592 ios.imbue(lc);
16593 {
16594 ios.width(0);
16595 {
16596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16597 std::string ex(str, iter.base());
16598 assert(ex == "-0.0000000000000000");
16599 assert(ios.width() == 0);
16600 }
16601 ios.width(25);
16602 left(ios);
16603 {
16604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16605 std::string ex(str, iter.base());
16606 assert(ex == "-0.0000000000000000******");
16607 assert(ios.width() == 0);
16608 }
16609 ios.width(25);
16610 right(ios);
16611 {
16612 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16613 std::string ex(str, iter.base());
16614 assert(ex == "******-0.0000000000000000");
16615 assert(ios.width() == 0);
16616 }
16617 ios.width(25);
16618 internal(ios);
16619 {
16620 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16621 std::string ex(str, iter.base());
16622 assert(ex == "-******0.0000000000000000");
16623 assert(ios.width() == 0);
16624 }
16625 }
16626 ios.imbue(lg);
16627 {
16628 ios.width(0);
16629 {
16630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16631 std::string ex(str, iter.base());
16632 assert(ex == "-0;0000000000000000");
16633 assert(ios.width() == 0);
16634 }
16635 ios.width(25);
16636 left(ios);
16637 {
16638 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16639 std::string ex(str, iter.base());
16640 assert(ex == "-0;0000000000000000******");
16641 assert(ios.width() == 0);
16642 }
16643 ios.width(25);
16644 right(ios);
16645 {
16646 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16647 std::string ex(str, iter.base());
16648 assert(ex == "******-0;0000000000000000");
16649 assert(ios.width() == 0);
16650 }
16651 ios.width(25);
16652 internal(ios);
16653 {
16654 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16655 std::string ex(str, iter.base());
16656 assert(ex == "-******0;0000000000000000");
16657 assert(ios.width() == 0);
16658 }
16659 }
16660 }
16661 }
16662 }
16663 }
16664 ios.precision(60);
16665 {
16666 nouppercase(ios);
16667 {
16668 noshowpos(ios);
16669 {
16670 noshowpoint(ios);
16671 {
16672 ios.imbue(lc);
16673 {
16674 ios.width(0);
16675 {
16676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16677 std::string ex(str, iter.base());
16678 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16679 assert(ios.width() == 0);
16680 }
16681 ios.width(25);
16682 left(ios);
16683 {
16684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16685 std::string ex(str, iter.base());
16686 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16687 assert(ios.width() == 0);
16688 }
16689 ios.width(25);
16690 right(ios);
16691 {
16692 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16693 std::string ex(str, iter.base());
16694 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16695 assert(ios.width() == 0);
16696 }
16697 ios.width(25);
16698 internal(ios);
16699 {
16700 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16701 std::string ex(str, iter.base());
16702 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16703 assert(ios.width() == 0);
16704 }
16705 }
16706 ios.imbue(lg);
16707 {
16708 ios.width(0);
16709 {
16710 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16711 std::string ex(str, iter.base());
16712 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16713 assert(ios.width() == 0);
16714 }
16715 ios.width(25);
16716 left(ios);
16717 {
16718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16719 std::string ex(str, iter.base());
16720 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16721 assert(ios.width() == 0);
16722 }
16723 ios.width(25);
16724 right(ios);
16725 {
16726 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16727 std::string ex(str, iter.base());
16728 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16729 assert(ios.width() == 0);
16730 }
16731 ios.width(25);
16732 internal(ios);
16733 {
16734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16735 std::string ex(str, iter.base());
16736 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16737 assert(ios.width() == 0);
16738 }
16739 }
16740 }
16741 showpoint(ios);
16742 {
16743 ios.imbue(lc);
16744 {
16745 ios.width(0);
16746 {
16747 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16748 std::string ex(str, iter.base());
16749 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16750 assert(ios.width() == 0);
16751 }
16752 ios.width(25);
16753 left(ios);
16754 {
16755 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16756 std::string ex(str, iter.base());
16757 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16758 assert(ios.width() == 0);
16759 }
16760 ios.width(25);
16761 right(ios);
16762 {
16763 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16764 std::string ex(str, iter.base());
16765 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16766 assert(ios.width() == 0);
16767 }
16768 ios.width(25);
16769 internal(ios);
16770 {
16771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16772 std::string ex(str, iter.base());
16773 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16774 assert(ios.width() == 0);
16775 }
16776 }
16777 ios.imbue(lg);
16778 {
16779 ios.width(0);
16780 {
16781 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16782 std::string ex(str, iter.base());
16783 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16784 assert(ios.width() == 0);
16785 }
16786 ios.width(25);
16787 left(ios);
16788 {
16789 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16790 std::string ex(str, iter.base());
16791 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16792 assert(ios.width() == 0);
16793 }
16794 ios.width(25);
16795 right(ios);
16796 {
16797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16798 std::string ex(str, iter.base());
16799 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16800 assert(ios.width() == 0);
16801 }
16802 ios.width(25);
16803 internal(ios);
16804 {
16805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16806 std::string ex(str, iter.base());
16807 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16808 assert(ios.width() == 0);
16809 }
16810 }
16811 }
16812 }
16813 showpos(ios);
16814 {
16815 noshowpoint(ios);
16816 {
16817 ios.imbue(lc);
16818 {
16819 ios.width(0);
16820 {
16821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16822 std::string ex(str, iter.base());
16823 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16824 assert(ios.width() == 0);
16825 }
16826 ios.width(25);
16827 left(ios);
16828 {
16829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16830 std::string ex(str, iter.base());
16831 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16832 assert(ios.width() == 0);
16833 }
16834 ios.width(25);
16835 right(ios);
16836 {
16837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16838 std::string ex(str, iter.base());
16839 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16840 assert(ios.width() == 0);
16841 }
16842 ios.width(25);
16843 internal(ios);
16844 {
16845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16846 std::string ex(str, iter.base());
16847 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16848 assert(ios.width() == 0);
16849 }
16850 }
16851 ios.imbue(lg);
16852 {
16853 ios.width(0);
16854 {
16855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16856 std::string ex(str, iter.base());
16857 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16858 assert(ios.width() == 0);
16859 }
16860 ios.width(25);
16861 left(ios);
16862 {
16863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16864 std::string ex(str, iter.base());
16865 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16866 assert(ios.width() == 0);
16867 }
16868 ios.width(25);
16869 right(ios);
16870 {
16871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16872 std::string ex(str, iter.base());
16873 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16874 assert(ios.width() == 0);
16875 }
16876 ios.width(25);
16877 internal(ios);
16878 {
16879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16880 std::string ex(str, iter.base());
16881 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16882 assert(ios.width() == 0);
16883 }
16884 }
16885 }
16886 showpoint(ios);
16887 {
16888 ios.imbue(lc);
16889 {
16890 ios.width(0);
16891 {
16892 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16893 std::string ex(str, iter.base());
16894 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16895 assert(ios.width() == 0);
16896 }
16897 ios.width(25);
16898 left(ios);
16899 {
16900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16901 std::string ex(str, iter.base());
16902 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16903 assert(ios.width() == 0);
16904 }
16905 ios.width(25);
16906 right(ios);
16907 {
16908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16909 std::string ex(str, iter.base());
16910 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16911 assert(ios.width() == 0);
16912 }
16913 ios.width(25);
16914 internal(ios);
16915 {
16916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16917 std::string ex(str, iter.base());
16918 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16919 assert(ios.width() == 0);
16920 }
16921 }
16922 ios.imbue(lg);
16923 {
16924 ios.width(0);
16925 {
16926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16927 std::string ex(str, iter.base());
16928 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16929 assert(ios.width() == 0);
16930 }
16931 ios.width(25);
16932 left(ios);
16933 {
16934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16935 std::string ex(str, iter.base());
16936 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16937 assert(ios.width() == 0);
16938 }
16939 ios.width(25);
16940 right(ios);
16941 {
16942 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16943 std::string ex(str, iter.base());
16944 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16945 assert(ios.width() == 0);
16946 }
16947 ios.width(25);
16948 internal(ios);
16949 {
16950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16951 std::string ex(str, iter.base());
16952 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16953 assert(ios.width() == 0);
16954 }
16955 }
16956 }
16957 }
16958 }
16959 uppercase(ios);
16960 {
16961 noshowpos(ios);
16962 {
16963 noshowpoint(ios);
16964 {
16965 ios.imbue(lc);
16966 {
16967 ios.width(0);
16968 {
16969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16970 std::string ex(str, iter.base());
16971 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16972 assert(ios.width() == 0);
16973 }
16974 ios.width(25);
16975 left(ios);
16976 {
16977 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16978 std::string ex(str, iter.base());
16979 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16980 assert(ios.width() == 0);
16981 }
16982 ios.width(25);
16983 right(ios);
16984 {
16985 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16986 std::string ex(str, iter.base());
16987 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16988 assert(ios.width() == 0);
16989 }
16990 ios.width(25);
16991 internal(ios);
16992 {
16993 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16994 std::string ex(str, iter.base());
16995 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16996 assert(ios.width() == 0);
16997 }
16998 }
16999 ios.imbue(lg);
17000 {
17001 ios.width(0);
17002 {
17003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17004 std::string ex(str, iter.base());
17005 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17006 assert(ios.width() == 0);
17007 }
17008 ios.width(25);
17009 left(ios);
17010 {
17011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17012 std::string ex(str, iter.base());
17013 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17014 assert(ios.width() == 0);
17015 }
17016 ios.width(25);
17017 right(ios);
17018 {
17019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17020 std::string ex(str, iter.base());
17021 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17022 assert(ios.width() == 0);
17023 }
17024 ios.width(25);
17025 internal(ios);
17026 {
17027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17028 std::string ex(str, iter.base());
17029 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17030 assert(ios.width() == 0);
17031 }
17032 }
17033 }
17034 showpoint(ios);
17035 {
17036 ios.imbue(lc);
17037 {
17038 ios.width(0);
17039 {
17040 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17041 std::string ex(str, iter.base());
17042 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17043 assert(ios.width() == 0);
17044 }
17045 ios.width(25);
17046 left(ios);
17047 {
17048 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17049 std::string ex(str, iter.base());
17050 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17051 assert(ios.width() == 0);
17052 }
17053 ios.width(25);
17054 right(ios);
17055 {
17056 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17057 std::string ex(str, iter.base());
17058 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17059 assert(ios.width() == 0);
17060 }
17061 ios.width(25);
17062 internal(ios);
17063 {
17064 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17065 std::string ex(str, iter.base());
17066 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17067 assert(ios.width() == 0);
17068 }
17069 }
17070 ios.imbue(lg);
17071 {
17072 ios.width(0);
17073 {
17074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17075 std::string ex(str, iter.base());
17076 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17077 assert(ios.width() == 0);
17078 }
17079 ios.width(25);
17080 left(ios);
17081 {
17082 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17083 std::string ex(str, iter.base());
17084 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17085 assert(ios.width() == 0);
17086 }
17087 ios.width(25);
17088 right(ios);
17089 {
17090 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17091 std::string ex(str, iter.base());
17092 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17093 assert(ios.width() == 0);
17094 }
17095 ios.width(25);
17096 internal(ios);
17097 {
17098 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17099 std::string ex(str, iter.base());
17100 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17101 assert(ios.width() == 0);
17102 }
17103 }
17104 }
17105 }
17106 showpos(ios);
17107 {
17108 noshowpoint(ios);
17109 {
17110 ios.imbue(lc);
17111 {
17112 ios.width(0);
17113 {
17114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17115 std::string ex(str, iter.base());
17116 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17117 assert(ios.width() == 0);
17118 }
17119 ios.width(25);
17120 left(ios);
17121 {
17122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17123 std::string ex(str, iter.base());
17124 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17125 assert(ios.width() == 0);
17126 }
17127 ios.width(25);
17128 right(ios);
17129 {
17130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17131 std::string ex(str, iter.base());
17132 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17133 assert(ios.width() == 0);
17134 }
17135 ios.width(25);
17136 internal(ios);
17137 {
17138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17139 std::string ex(str, iter.base());
17140 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17141 assert(ios.width() == 0);
17142 }
17143 }
17144 ios.imbue(lg);
17145 {
17146 ios.width(0);
17147 {
17148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17149 std::string ex(str, iter.base());
17150 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17151 assert(ios.width() == 0);
17152 }
17153 ios.width(25);
17154 left(ios);
17155 {
17156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17157 std::string ex(str, iter.base());
17158 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17159 assert(ios.width() == 0);
17160 }
17161 ios.width(25);
17162 right(ios);
17163 {
17164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17165 std::string ex(str, iter.base());
17166 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17167 assert(ios.width() == 0);
17168 }
17169 ios.width(25);
17170 internal(ios);
17171 {
17172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17173 std::string ex(str, iter.base());
17174 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17175 assert(ios.width() == 0);
17176 }
17177 }
17178 }
17179 showpoint(ios);
17180 {
17181 ios.imbue(lc);
17182 {
17183 ios.width(0);
17184 {
17185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17186 std::string ex(str, iter.base());
17187 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17188 assert(ios.width() == 0);
17189 }
17190 ios.width(25);
17191 left(ios);
17192 {
17193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17194 std::string ex(str, iter.base());
17195 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17196 assert(ios.width() == 0);
17197 }
17198 ios.width(25);
17199 right(ios);
17200 {
17201 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17202 std::string ex(str, iter.base());
17203 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17204 assert(ios.width() == 0);
17205 }
17206 ios.width(25);
17207 internal(ios);
17208 {
17209 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17210 std::string ex(str, iter.base());
17211 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17212 assert(ios.width() == 0);
17213 }
17214 }
17215 ios.imbue(lg);
17216 {
17217 ios.width(0);
17218 {
17219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17220 std::string ex(str, iter.base());
17221 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17222 assert(ios.width() == 0);
17223 }
17224 ios.width(25);
17225 left(ios);
17226 {
17227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17228 std::string ex(str, iter.base());
17229 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17230 assert(ios.width() == 0);
17231 }
17232 ios.width(25);
17233 right(ios);
17234 {
17235 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17236 std::string ex(str, iter.base());
17237 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17238 assert(ios.width() == 0);
17239 }
17240 ios.width(25);
17241 internal(ios);
17242 {
17243 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17244 std::string ex(str, iter.base());
17245 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17246 assert(ios.width() == 0);
17247 }
17248 }
17249 }
17250 }
17251 }
17252 }
17253 }
17254 }
17255 }
17256
test8()17257 void test8()
17258 {
17259 char str[200];
17260 output_iterator<char*> iter;
17261 std::locale lc = std::locale::classic();
17262 std::locale lg(lc, new my_numpunct);
17263 const my_facet f(1);
17264 {
17265 long double v = 1234567890.125;
17266 std::ios ios(0);
17267 fixed(ios);
17268 // %f
17269 {
17270 ios.precision(0);
17271 {
17272 nouppercase(ios);
17273 {
17274 noshowpos(ios);
17275 {
17276 noshowpoint(ios);
17277 {
17278 ios.imbue(lc);
17279 {
17280 ios.width(0);
17281 {
17282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17283 std::string ex(str, iter.base());
17284 assert(ex == "1234567890");
17285 assert(ios.width() == 0);
17286 }
17287 ios.width(25);
17288 left(ios);
17289 {
17290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17291 std::string ex(str, iter.base());
17292 assert(ex == "1234567890***************");
17293 assert(ios.width() == 0);
17294 }
17295 ios.width(25);
17296 right(ios);
17297 {
17298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17299 std::string ex(str, iter.base());
17300 assert(ex == "***************1234567890");
17301 assert(ios.width() == 0);
17302 }
17303 ios.width(25);
17304 internal(ios);
17305 {
17306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17307 std::string ex(str, iter.base());
17308 assert(ex == "***************1234567890");
17309 assert(ios.width() == 0);
17310 }
17311 }
17312 ios.imbue(lg);
17313 {
17314 ios.width(0);
17315 {
17316 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17317 std::string ex(str, iter.base());
17318 assert(ex == "1_234_567_89_0");
17319 assert(ios.width() == 0);
17320 }
17321 ios.width(25);
17322 left(ios);
17323 {
17324 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17325 std::string ex(str, iter.base());
17326 assert(ex == "1_234_567_89_0***********");
17327 assert(ios.width() == 0);
17328 }
17329 ios.width(25);
17330 right(ios);
17331 {
17332 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17333 std::string ex(str, iter.base());
17334 assert(ex == "***********1_234_567_89_0");
17335 assert(ios.width() == 0);
17336 }
17337 ios.width(25);
17338 internal(ios);
17339 {
17340 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17341 std::string ex(str, iter.base());
17342 assert(ex == "***********1_234_567_89_0");
17343 assert(ios.width() == 0);
17344 }
17345 }
17346 }
17347 showpoint(ios);
17348 {
17349 ios.imbue(lc);
17350 {
17351 ios.width(0);
17352 {
17353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17354 std::string ex(str, iter.base());
17355 assert(ex == "1234567890.");
17356 assert(ios.width() == 0);
17357 }
17358 ios.width(25);
17359 left(ios);
17360 {
17361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17362 std::string ex(str, iter.base());
17363 assert(ex == "1234567890.**************");
17364 assert(ios.width() == 0);
17365 }
17366 ios.width(25);
17367 right(ios);
17368 {
17369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17370 std::string ex(str, iter.base());
17371 assert(ex == "**************1234567890.");
17372 assert(ios.width() == 0);
17373 }
17374 ios.width(25);
17375 internal(ios);
17376 {
17377 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17378 std::string ex(str, iter.base());
17379 assert(ex == "**************1234567890.");
17380 assert(ios.width() == 0);
17381 }
17382 }
17383 ios.imbue(lg);
17384 {
17385 ios.width(0);
17386 {
17387 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17388 std::string ex(str, iter.base());
17389 assert(ex == "1_234_567_89_0;");
17390 assert(ios.width() == 0);
17391 }
17392 ios.width(25);
17393 left(ios);
17394 {
17395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17396 std::string ex(str, iter.base());
17397 assert(ex == "1_234_567_89_0;**********");
17398 assert(ios.width() == 0);
17399 }
17400 ios.width(25);
17401 right(ios);
17402 {
17403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17404 std::string ex(str, iter.base());
17405 assert(ex == "**********1_234_567_89_0;");
17406 assert(ios.width() == 0);
17407 }
17408 ios.width(25);
17409 internal(ios);
17410 {
17411 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17412 std::string ex(str, iter.base());
17413 assert(ex == "**********1_234_567_89_0;");
17414 assert(ios.width() == 0);
17415 }
17416 }
17417 }
17418 }
17419 showpos(ios);
17420 {
17421 noshowpoint(ios);
17422 {
17423 ios.imbue(lc);
17424 {
17425 ios.width(0);
17426 {
17427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17428 std::string ex(str, iter.base());
17429 assert(ex == "+1234567890");
17430 assert(ios.width() == 0);
17431 }
17432 ios.width(25);
17433 left(ios);
17434 {
17435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17436 std::string ex(str, iter.base());
17437 assert(ex == "+1234567890**************");
17438 assert(ios.width() == 0);
17439 }
17440 ios.width(25);
17441 right(ios);
17442 {
17443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17444 std::string ex(str, iter.base());
17445 assert(ex == "**************+1234567890");
17446 assert(ios.width() == 0);
17447 }
17448 ios.width(25);
17449 internal(ios);
17450 {
17451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17452 std::string ex(str, iter.base());
17453 assert(ex == "+**************1234567890");
17454 assert(ios.width() == 0);
17455 }
17456 }
17457 ios.imbue(lg);
17458 {
17459 ios.width(0);
17460 {
17461 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17462 std::string ex(str, iter.base());
17463 assert(ex == "+1_234_567_89_0");
17464 assert(ios.width() == 0);
17465 }
17466 ios.width(25);
17467 left(ios);
17468 {
17469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17470 std::string ex(str, iter.base());
17471 assert(ex == "+1_234_567_89_0**********");
17472 assert(ios.width() == 0);
17473 }
17474 ios.width(25);
17475 right(ios);
17476 {
17477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17478 std::string ex(str, iter.base());
17479 assert(ex == "**********+1_234_567_89_0");
17480 assert(ios.width() == 0);
17481 }
17482 ios.width(25);
17483 internal(ios);
17484 {
17485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17486 std::string ex(str, iter.base());
17487 assert(ex == "+**********1_234_567_89_0");
17488 assert(ios.width() == 0);
17489 }
17490 }
17491 }
17492 showpoint(ios);
17493 {
17494 ios.imbue(lc);
17495 {
17496 ios.width(0);
17497 {
17498 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17499 std::string ex(str, iter.base());
17500 assert(ex == "+1234567890.");
17501 assert(ios.width() == 0);
17502 }
17503 ios.width(25);
17504 left(ios);
17505 {
17506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17507 std::string ex(str, iter.base());
17508 assert(ex == "+1234567890.*************");
17509 assert(ios.width() == 0);
17510 }
17511 ios.width(25);
17512 right(ios);
17513 {
17514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17515 std::string ex(str, iter.base());
17516 assert(ex == "*************+1234567890.");
17517 assert(ios.width() == 0);
17518 }
17519 ios.width(25);
17520 internal(ios);
17521 {
17522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17523 std::string ex(str, iter.base());
17524 assert(ex == "+*************1234567890.");
17525 assert(ios.width() == 0);
17526 }
17527 }
17528 ios.imbue(lg);
17529 {
17530 ios.width(0);
17531 {
17532 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17533 std::string ex(str, iter.base());
17534 assert(ex == "+1_234_567_89_0;");
17535 assert(ios.width() == 0);
17536 }
17537 ios.width(25);
17538 left(ios);
17539 {
17540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17541 std::string ex(str, iter.base());
17542 assert(ex == "+1_234_567_89_0;*********");
17543 assert(ios.width() == 0);
17544 }
17545 ios.width(25);
17546 right(ios);
17547 {
17548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17549 std::string ex(str, iter.base());
17550 assert(ex == "*********+1_234_567_89_0;");
17551 assert(ios.width() == 0);
17552 }
17553 ios.width(25);
17554 internal(ios);
17555 {
17556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17557 std::string ex(str, iter.base());
17558 assert(ex == "+*********1_234_567_89_0;");
17559 assert(ios.width() == 0);
17560 }
17561 }
17562 }
17563 }
17564 }
17565 uppercase(ios);
17566 {
17567 noshowpos(ios);
17568 {
17569 noshowpoint(ios);
17570 {
17571 ios.imbue(lc);
17572 {
17573 ios.width(0);
17574 {
17575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17576 std::string ex(str, iter.base());
17577 assert(ex == "1234567890");
17578 assert(ios.width() == 0);
17579 }
17580 ios.width(25);
17581 left(ios);
17582 {
17583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17584 std::string ex(str, iter.base());
17585 assert(ex == "1234567890***************");
17586 assert(ios.width() == 0);
17587 }
17588 ios.width(25);
17589 right(ios);
17590 {
17591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17592 std::string ex(str, iter.base());
17593 assert(ex == "***************1234567890");
17594 assert(ios.width() == 0);
17595 }
17596 ios.width(25);
17597 internal(ios);
17598 {
17599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17600 std::string ex(str, iter.base());
17601 assert(ex == "***************1234567890");
17602 assert(ios.width() == 0);
17603 }
17604 }
17605 ios.imbue(lg);
17606 {
17607 ios.width(0);
17608 {
17609 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17610 std::string ex(str, iter.base());
17611 assert(ex == "1_234_567_89_0");
17612 assert(ios.width() == 0);
17613 }
17614 ios.width(25);
17615 left(ios);
17616 {
17617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17618 std::string ex(str, iter.base());
17619 assert(ex == "1_234_567_89_0***********");
17620 assert(ios.width() == 0);
17621 }
17622 ios.width(25);
17623 right(ios);
17624 {
17625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17626 std::string ex(str, iter.base());
17627 assert(ex == "***********1_234_567_89_0");
17628 assert(ios.width() == 0);
17629 }
17630 ios.width(25);
17631 internal(ios);
17632 {
17633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17634 std::string ex(str, iter.base());
17635 assert(ex == "***********1_234_567_89_0");
17636 assert(ios.width() == 0);
17637 }
17638 }
17639 }
17640 showpoint(ios);
17641 {
17642 ios.imbue(lc);
17643 {
17644 ios.width(0);
17645 {
17646 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17647 std::string ex(str, iter.base());
17648 assert(ex == "1234567890.");
17649 assert(ios.width() == 0);
17650 }
17651 ios.width(25);
17652 left(ios);
17653 {
17654 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17655 std::string ex(str, iter.base());
17656 assert(ex == "1234567890.**************");
17657 assert(ios.width() == 0);
17658 }
17659 ios.width(25);
17660 right(ios);
17661 {
17662 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17663 std::string ex(str, iter.base());
17664 assert(ex == "**************1234567890.");
17665 assert(ios.width() == 0);
17666 }
17667 ios.width(25);
17668 internal(ios);
17669 {
17670 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17671 std::string ex(str, iter.base());
17672 assert(ex == "**************1234567890.");
17673 assert(ios.width() == 0);
17674 }
17675 }
17676 ios.imbue(lg);
17677 {
17678 ios.width(0);
17679 {
17680 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17681 std::string ex(str, iter.base());
17682 assert(ex == "1_234_567_89_0;");
17683 assert(ios.width() == 0);
17684 }
17685 ios.width(25);
17686 left(ios);
17687 {
17688 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17689 std::string ex(str, iter.base());
17690 assert(ex == "1_234_567_89_0;**********");
17691 assert(ios.width() == 0);
17692 }
17693 ios.width(25);
17694 right(ios);
17695 {
17696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17697 std::string ex(str, iter.base());
17698 assert(ex == "**********1_234_567_89_0;");
17699 assert(ios.width() == 0);
17700 }
17701 ios.width(25);
17702 internal(ios);
17703 {
17704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17705 std::string ex(str, iter.base());
17706 assert(ex == "**********1_234_567_89_0;");
17707 assert(ios.width() == 0);
17708 }
17709 }
17710 }
17711 }
17712 showpos(ios);
17713 {
17714 noshowpoint(ios);
17715 {
17716 ios.imbue(lc);
17717 {
17718 ios.width(0);
17719 {
17720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17721 std::string ex(str, iter.base());
17722 assert(ex == "+1234567890");
17723 assert(ios.width() == 0);
17724 }
17725 ios.width(25);
17726 left(ios);
17727 {
17728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17729 std::string ex(str, iter.base());
17730 assert(ex == "+1234567890**************");
17731 assert(ios.width() == 0);
17732 }
17733 ios.width(25);
17734 right(ios);
17735 {
17736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17737 std::string ex(str, iter.base());
17738 assert(ex == "**************+1234567890");
17739 assert(ios.width() == 0);
17740 }
17741 ios.width(25);
17742 internal(ios);
17743 {
17744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17745 std::string ex(str, iter.base());
17746 assert(ex == "+**************1234567890");
17747 assert(ios.width() == 0);
17748 }
17749 }
17750 ios.imbue(lg);
17751 {
17752 ios.width(0);
17753 {
17754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17755 std::string ex(str, iter.base());
17756 assert(ex == "+1_234_567_89_0");
17757 assert(ios.width() == 0);
17758 }
17759 ios.width(25);
17760 left(ios);
17761 {
17762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17763 std::string ex(str, iter.base());
17764 assert(ex == "+1_234_567_89_0**********");
17765 assert(ios.width() == 0);
17766 }
17767 ios.width(25);
17768 right(ios);
17769 {
17770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17771 std::string ex(str, iter.base());
17772 assert(ex == "**********+1_234_567_89_0");
17773 assert(ios.width() == 0);
17774 }
17775 ios.width(25);
17776 internal(ios);
17777 {
17778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17779 std::string ex(str, iter.base());
17780 assert(ex == "+**********1_234_567_89_0");
17781 assert(ios.width() == 0);
17782 }
17783 }
17784 }
17785 showpoint(ios);
17786 {
17787 ios.imbue(lc);
17788 {
17789 ios.width(0);
17790 {
17791 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17792 std::string ex(str, iter.base());
17793 assert(ex == "+1234567890.");
17794 assert(ios.width() == 0);
17795 }
17796 ios.width(25);
17797 left(ios);
17798 {
17799 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17800 std::string ex(str, iter.base());
17801 assert(ex == "+1234567890.*************");
17802 assert(ios.width() == 0);
17803 }
17804 ios.width(25);
17805 right(ios);
17806 {
17807 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17808 std::string ex(str, iter.base());
17809 assert(ex == "*************+1234567890.");
17810 assert(ios.width() == 0);
17811 }
17812 ios.width(25);
17813 internal(ios);
17814 {
17815 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17816 std::string ex(str, iter.base());
17817 assert(ex == "+*************1234567890.");
17818 assert(ios.width() == 0);
17819 }
17820 }
17821 ios.imbue(lg);
17822 {
17823 ios.width(0);
17824 {
17825 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17826 std::string ex(str, iter.base());
17827 assert(ex == "+1_234_567_89_0;");
17828 assert(ios.width() == 0);
17829 }
17830 ios.width(25);
17831 left(ios);
17832 {
17833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17834 std::string ex(str, iter.base());
17835 assert(ex == "+1_234_567_89_0;*********");
17836 assert(ios.width() == 0);
17837 }
17838 ios.width(25);
17839 right(ios);
17840 {
17841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17842 std::string ex(str, iter.base());
17843 assert(ex == "*********+1_234_567_89_0;");
17844 assert(ios.width() == 0);
17845 }
17846 ios.width(25);
17847 internal(ios);
17848 {
17849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17850 std::string ex(str, iter.base());
17851 assert(ex == "+*********1_234_567_89_0;");
17852 assert(ios.width() == 0);
17853 }
17854 }
17855 }
17856 }
17857 }
17858 }
17859 ios.precision(1);
17860 {
17861 nouppercase(ios);
17862 {
17863 noshowpos(ios);
17864 {
17865 noshowpoint(ios);
17866 {
17867 ios.imbue(lc);
17868 {
17869 ios.width(0);
17870 {
17871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17872 std::string ex(str, iter.base());
17873 assert(ex == "1234567890.1");
17874 assert(ios.width() == 0);
17875 }
17876 ios.width(25);
17877 left(ios);
17878 {
17879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17880 std::string ex(str, iter.base());
17881 assert(ex == "1234567890.1*************");
17882 assert(ios.width() == 0);
17883 }
17884 ios.width(25);
17885 right(ios);
17886 {
17887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17888 std::string ex(str, iter.base());
17889 assert(ex == "*************1234567890.1");
17890 assert(ios.width() == 0);
17891 }
17892 ios.width(25);
17893 internal(ios);
17894 {
17895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17896 std::string ex(str, iter.base());
17897 assert(ex == "*************1234567890.1");
17898 assert(ios.width() == 0);
17899 }
17900 }
17901 ios.imbue(lg);
17902 {
17903 ios.width(0);
17904 {
17905 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17906 std::string ex(str, iter.base());
17907 assert(ex == "1_234_567_89_0;1");
17908 assert(ios.width() == 0);
17909 }
17910 ios.width(25);
17911 left(ios);
17912 {
17913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17914 std::string ex(str, iter.base());
17915 assert(ex == "1_234_567_89_0;1*********");
17916 assert(ios.width() == 0);
17917 }
17918 ios.width(25);
17919 right(ios);
17920 {
17921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17922 std::string ex(str, iter.base());
17923 assert(ex == "*********1_234_567_89_0;1");
17924 assert(ios.width() == 0);
17925 }
17926 ios.width(25);
17927 internal(ios);
17928 {
17929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17930 std::string ex(str, iter.base());
17931 assert(ex == "*********1_234_567_89_0;1");
17932 assert(ios.width() == 0);
17933 }
17934 }
17935 }
17936 showpoint(ios);
17937 {
17938 ios.imbue(lc);
17939 {
17940 ios.width(0);
17941 {
17942 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17943 std::string ex(str, iter.base());
17944 assert(ex == "1234567890.1");
17945 assert(ios.width() == 0);
17946 }
17947 ios.width(25);
17948 left(ios);
17949 {
17950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17951 std::string ex(str, iter.base());
17952 assert(ex == "1234567890.1*************");
17953 assert(ios.width() == 0);
17954 }
17955 ios.width(25);
17956 right(ios);
17957 {
17958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17959 std::string ex(str, iter.base());
17960 assert(ex == "*************1234567890.1");
17961 assert(ios.width() == 0);
17962 }
17963 ios.width(25);
17964 internal(ios);
17965 {
17966 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17967 std::string ex(str, iter.base());
17968 assert(ex == "*************1234567890.1");
17969 assert(ios.width() == 0);
17970 }
17971 }
17972 ios.imbue(lg);
17973 {
17974 ios.width(0);
17975 {
17976 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17977 std::string ex(str, iter.base());
17978 assert(ex == "1_234_567_89_0;1");
17979 assert(ios.width() == 0);
17980 }
17981 ios.width(25);
17982 left(ios);
17983 {
17984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17985 std::string ex(str, iter.base());
17986 assert(ex == "1_234_567_89_0;1*********");
17987 assert(ios.width() == 0);
17988 }
17989 ios.width(25);
17990 right(ios);
17991 {
17992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17993 std::string ex(str, iter.base());
17994 assert(ex == "*********1_234_567_89_0;1");
17995 assert(ios.width() == 0);
17996 }
17997 ios.width(25);
17998 internal(ios);
17999 {
18000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18001 std::string ex(str, iter.base());
18002 assert(ex == "*********1_234_567_89_0;1");
18003 assert(ios.width() == 0);
18004 }
18005 }
18006 }
18007 }
18008 showpos(ios);
18009 {
18010 noshowpoint(ios);
18011 {
18012 ios.imbue(lc);
18013 {
18014 ios.width(0);
18015 {
18016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18017 std::string ex(str, iter.base());
18018 assert(ex == "+1234567890.1");
18019 assert(ios.width() == 0);
18020 }
18021 ios.width(25);
18022 left(ios);
18023 {
18024 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18025 std::string ex(str, iter.base());
18026 assert(ex == "+1234567890.1************");
18027 assert(ios.width() == 0);
18028 }
18029 ios.width(25);
18030 right(ios);
18031 {
18032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18033 std::string ex(str, iter.base());
18034 assert(ex == "************+1234567890.1");
18035 assert(ios.width() == 0);
18036 }
18037 ios.width(25);
18038 internal(ios);
18039 {
18040 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18041 std::string ex(str, iter.base());
18042 assert(ex == "+************1234567890.1");
18043 assert(ios.width() == 0);
18044 }
18045 }
18046 ios.imbue(lg);
18047 {
18048 ios.width(0);
18049 {
18050 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18051 std::string ex(str, iter.base());
18052 assert(ex == "+1_234_567_89_0;1");
18053 assert(ios.width() == 0);
18054 }
18055 ios.width(25);
18056 left(ios);
18057 {
18058 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18059 std::string ex(str, iter.base());
18060 assert(ex == "+1_234_567_89_0;1********");
18061 assert(ios.width() == 0);
18062 }
18063 ios.width(25);
18064 right(ios);
18065 {
18066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18067 std::string ex(str, iter.base());
18068 assert(ex == "********+1_234_567_89_0;1");
18069 assert(ios.width() == 0);
18070 }
18071 ios.width(25);
18072 internal(ios);
18073 {
18074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18075 std::string ex(str, iter.base());
18076 assert(ex == "+********1_234_567_89_0;1");
18077 assert(ios.width() == 0);
18078 }
18079 }
18080 }
18081 showpoint(ios);
18082 {
18083 ios.imbue(lc);
18084 {
18085 ios.width(0);
18086 {
18087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18088 std::string ex(str, iter.base());
18089 assert(ex == "+1234567890.1");
18090 assert(ios.width() == 0);
18091 }
18092 ios.width(25);
18093 left(ios);
18094 {
18095 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18096 std::string ex(str, iter.base());
18097 assert(ex == "+1234567890.1************");
18098 assert(ios.width() == 0);
18099 }
18100 ios.width(25);
18101 right(ios);
18102 {
18103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18104 std::string ex(str, iter.base());
18105 assert(ex == "************+1234567890.1");
18106 assert(ios.width() == 0);
18107 }
18108 ios.width(25);
18109 internal(ios);
18110 {
18111 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18112 std::string ex(str, iter.base());
18113 assert(ex == "+************1234567890.1");
18114 assert(ios.width() == 0);
18115 }
18116 }
18117 ios.imbue(lg);
18118 {
18119 ios.width(0);
18120 {
18121 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18122 std::string ex(str, iter.base());
18123 assert(ex == "+1_234_567_89_0;1");
18124 assert(ios.width() == 0);
18125 }
18126 ios.width(25);
18127 left(ios);
18128 {
18129 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18130 std::string ex(str, iter.base());
18131 assert(ex == "+1_234_567_89_0;1********");
18132 assert(ios.width() == 0);
18133 }
18134 ios.width(25);
18135 right(ios);
18136 {
18137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18138 std::string ex(str, iter.base());
18139 assert(ex == "********+1_234_567_89_0;1");
18140 assert(ios.width() == 0);
18141 }
18142 ios.width(25);
18143 internal(ios);
18144 {
18145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18146 std::string ex(str, iter.base());
18147 assert(ex == "+********1_234_567_89_0;1");
18148 assert(ios.width() == 0);
18149 }
18150 }
18151 }
18152 }
18153 }
18154 uppercase(ios);
18155 {
18156 noshowpos(ios);
18157 {
18158 noshowpoint(ios);
18159 {
18160 ios.imbue(lc);
18161 {
18162 ios.width(0);
18163 {
18164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18165 std::string ex(str, iter.base());
18166 assert(ex == "1234567890.1");
18167 assert(ios.width() == 0);
18168 }
18169 ios.width(25);
18170 left(ios);
18171 {
18172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18173 std::string ex(str, iter.base());
18174 assert(ex == "1234567890.1*************");
18175 assert(ios.width() == 0);
18176 }
18177 ios.width(25);
18178 right(ios);
18179 {
18180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18181 std::string ex(str, iter.base());
18182 assert(ex == "*************1234567890.1");
18183 assert(ios.width() == 0);
18184 }
18185 ios.width(25);
18186 internal(ios);
18187 {
18188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18189 std::string ex(str, iter.base());
18190 assert(ex == "*************1234567890.1");
18191 assert(ios.width() == 0);
18192 }
18193 }
18194 ios.imbue(lg);
18195 {
18196 ios.width(0);
18197 {
18198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18199 std::string ex(str, iter.base());
18200 assert(ex == "1_234_567_89_0;1");
18201 assert(ios.width() == 0);
18202 }
18203 ios.width(25);
18204 left(ios);
18205 {
18206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18207 std::string ex(str, iter.base());
18208 assert(ex == "1_234_567_89_0;1*********");
18209 assert(ios.width() == 0);
18210 }
18211 ios.width(25);
18212 right(ios);
18213 {
18214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18215 std::string ex(str, iter.base());
18216 assert(ex == "*********1_234_567_89_0;1");
18217 assert(ios.width() == 0);
18218 }
18219 ios.width(25);
18220 internal(ios);
18221 {
18222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18223 std::string ex(str, iter.base());
18224 assert(ex == "*********1_234_567_89_0;1");
18225 assert(ios.width() == 0);
18226 }
18227 }
18228 }
18229 showpoint(ios);
18230 {
18231 ios.imbue(lc);
18232 {
18233 ios.width(0);
18234 {
18235 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18236 std::string ex(str, iter.base());
18237 assert(ex == "1234567890.1");
18238 assert(ios.width() == 0);
18239 }
18240 ios.width(25);
18241 left(ios);
18242 {
18243 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18244 std::string ex(str, iter.base());
18245 assert(ex == "1234567890.1*************");
18246 assert(ios.width() == 0);
18247 }
18248 ios.width(25);
18249 right(ios);
18250 {
18251 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18252 std::string ex(str, iter.base());
18253 assert(ex == "*************1234567890.1");
18254 assert(ios.width() == 0);
18255 }
18256 ios.width(25);
18257 internal(ios);
18258 {
18259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18260 std::string ex(str, iter.base());
18261 assert(ex == "*************1234567890.1");
18262 assert(ios.width() == 0);
18263 }
18264 }
18265 ios.imbue(lg);
18266 {
18267 ios.width(0);
18268 {
18269 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18270 std::string ex(str, iter.base());
18271 assert(ex == "1_234_567_89_0;1");
18272 assert(ios.width() == 0);
18273 }
18274 ios.width(25);
18275 left(ios);
18276 {
18277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18278 std::string ex(str, iter.base());
18279 assert(ex == "1_234_567_89_0;1*********");
18280 assert(ios.width() == 0);
18281 }
18282 ios.width(25);
18283 right(ios);
18284 {
18285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18286 std::string ex(str, iter.base());
18287 assert(ex == "*********1_234_567_89_0;1");
18288 assert(ios.width() == 0);
18289 }
18290 ios.width(25);
18291 internal(ios);
18292 {
18293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18294 std::string ex(str, iter.base());
18295 assert(ex == "*********1_234_567_89_0;1");
18296 assert(ios.width() == 0);
18297 }
18298 }
18299 }
18300 }
18301 showpos(ios);
18302 {
18303 noshowpoint(ios);
18304 {
18305 ios.imbue(lc);
18306 {
18307 ios.width(0);
18308 {
18309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18310 std::string ex(str, iter.base());
18311 assert(ex == "+1234567890.1");
18312 assert(ios.width() == 0);
18313 }
18314 ios.width(25);
18315 left(ios);
18316 {
18317 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18318 std::string ex(str, iter.base());
18319 assert(ex == "+1234567890.1************");
18320 assert(ios.width() == 0);
18321 }
18322 ios.width(25);
18323 right(ios);
18324 {
18325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18326 std::string ex(str, iter.base());
18327 assert(ex == "************+1234567890.1");
18328 assert(ios.width() == 0);
18329 }
18330 ios.width(25);
18331 internal(ios);
18332 {
18333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18334 std::string ex(str, iter.base());
18335 assert(ex == "+************1234567890.1");
18336 assert(ios.width() == 0);
18337 }
18338 }
18339 ios.imbue(lg);
18340 {
18341 ios.width(0);
18342 {
18343 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18344 std::string ex(str, iter.base());
18345 assert(ex == "+1_234_567_89_0;1");
18346 assert(ios.width() == 0);
18347 }
18348 ios.width(25);
18349 left(ios);
18350 {
18351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18352 std::string ex(str, iter.base());
18353 assert(ex == "+1_234_567_89_0;1********");
18354 assert(ios.width() == 0);
18355 }
18356 ios.width(25);
18357 right(ios);
18358 {
18359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18360 std::string ex(str, iter.base());
18361 assert(ex == "********+1_234_567_89_0;1");
18362 assert(ios.width() == 0);
18363 }
18364 ios.width(25);
18365 internal(ios);
18366 {
18367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18368 std::string ex(str, iter.base());
18369 assert(ex == "+********1_234_567_89_0;1");
18370 assert(ios.width() == 0);
18371 }
18372 }
18373 }
18374 showpoint(ios);
18375 {
18376 ios.imbue(lc);
18377 {
18378 ios.width(0);
18379 {
18380 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18381 std::string ex(str, iter.base());
18382 assert(ex == "+1234567890.1");
18383 assert(ios.width() == 0);
18384 }
18385 ios.width(25);
18386 left(ios);
18387 {
18388 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18389 std::string ex(str, iter.base());
18390 assert(ex == "+1234567890.1************");
18391 assert(ios.width() == 0);
18392 }
18393 ios.width(25);
18394 right(ios);
18395 {
18396 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18397 std::string ex(str, iter.base());
18398 assert(ex == "************+1234567890.1");
18399 assert(ios.width() == 0);
18400 }
18401 ios.width(25);
18402 internal(ios);
18403 {
18404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18405 std::string ex(str, iter.base());
18406 assert(ex == "+************1234567890.1");
18407 assert(ios.width() == 0);
18408 }
18409 }
18410 ios.imbue(lg);
18411 {
18412 ios.width(0);
18413 {
18414 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18415 std::string ex(str, iter.base());
18416 assert(ex == "+1_234_567_89_0;1");
18417 assert(ios.width() == 0);
18418 }
18419 ios.width(25);
18420 left(ios);
18421 {
18422 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18423 std::string ex(str, iter.base());
18424 assert(ex == "+1_234_567_89_0;1********");
18425 assert(ios.width() == 0);
18426 }
18427 ios.width(25);
18428 right(ios);
18429 {
18430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18431 std::string ex(str, iter.base());
18432 assert(ex == "********+1_234_567_89_0;1");
18433 assert(ios.width() == 0);
18434 }
18435 ios.width(25);
18436 internal(ios);
18437 {
18438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18439 std::string ex(str, iter.base());
18440 assert(ex == "+********1_234_567_89_0;1");
18441 assert(ios.width() == 0);
18442 }
18443 }
18444 }
18445 }
18446 }
18447 }
18448 ios.precision(6);
18449 {
18450 nouppercase(ios);
18451 {
18452 noshowpos(ios);
18453 {
18454 noshowpoint(ios);
18455 {
18456 ios.imbue(lc);
18457 {
18458 ios.width(0);
18459 {
18460 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18461 std::string ex(str, iter.base());
18462 assert(ex == "1234567890.125000");
18463 assert(ios.width() == 0);
18464 }
18465 ios.width(25);
18466 left(ios);
18467 {
18468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18469 std::string ex(str, iter.base());
18470 assert(ex == "1234567890.125000********");
18471 assert(ios.width() == 0);
18472 }
18473 ios.width(25);
18474 right(ios);
18475 {
18476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18477 std::string ex(str, iter.base());
18478 assert(ex == "********1234567890.125000");
18479 assert(ios.width() == 0);
18480 }
18481 ios.width(25);
18482 internal(ios);
18483 {
18484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18485 std::string ex(str, iter.base());
18486 assert(ex == "********1234567890.125000");
18487 assert(ios.width() == 0);
18488 }
18489 }
18490 ios.imbue(lg);
18491 {
18492 ios.width(0);
18493 {
18494 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18495 std::string ex(str, iter.base());
18496 assert(ex == "1_234_567_89_0;125000");
18497 assert(ios.width() == 0);
18498 }
18499 ios.width(25);
18500 left(ios);
18501 {
18502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18503 std::string ex(str, iter.base());
18504 assert(ex == "1_234_567_89_0;125000****");
18505 assert(ios.width() == 0);
18506 }
18507 ios.width(25);
18508 right(ios);
18509 {
18510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18511 std::string ex(str, iter.base());
18512 assert(ex == "****1_234_567_89_0;125000");
18513 assert(ios.width() == 0);
18514 }
18515 ios.width(25);
18516 internal(ios);
18517 {
18518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18519 std::string ex(str, iter.base());
18520 assert(ex == "****1_234_567_89_0;125000");
18521 assert(ios.width() == 0);
18522 }
18523 }
18524 }
18525 showpoint(ios);
18526 {
18527 ios.imbue(lc);
18528 {
18529 ios.width(0);
18530 {
18531 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18532 std::string ex(str, iter.base());
18533 assert(ex == "1234567890.125000");
18534 assert(ios.width() == 0);
18535 }
18536 ios.width(25);
18537 left(ios);
18538 {
18539 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18540 std::string ex(str, iter.base());
18541 assert(ex == "1234567890.125000********");
18542 assert(ios.width() == 0);
18543 }
18544 ios.width(25);
18545 right(ios);
18546 {
18547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18548 std::string ex(str, iter.base());
18549 assert(ex == "********1234567890.125000");
18550 assert(ios.width() == 0);
18551 }
18552 ios.width(25);
18553 internal(ios);
18554 {
18555 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18556 std::string ex(str, iter.base());
18557 assert(ex == "********1234567890.125000");
18558 assert(ios.width() == 0);
18559 }
18560 }
18561 ios.imbue(lg);
18562 {
18563 ios.width(0);
18564 {
18565 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18566 std::string ex(str, iter.base());
18567 assert(ex == "1_234_567_89_0;125000");
18568 assert(ios.width() == 0);
18569 }
18570 ios.width(25);
18571 left(ios);
18572 {
18573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18574 std::string ex(str, iter.base());
18575 assert(ex == "1_234_567_89_0;125000****");
18576 assert(ios.width() == 0);
18577 }
18578 ios.width(25);
18579 right(ios);
18580 {
18581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18582 std::string ex(str, iter.base());
18583 assert(ex == "****1_234_567_89_0;125000");
18584 assert(ios.width() == 0);
18585 }
18586 ios.width(25);
18587 internal(ios);
18588 {
18589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18590 std::string ex(str, iter.base());
18591 assert(ex == "****1_234_567_89_0;125000");
18592 assert(ios.width() == 0);
18593 }
18594 }
18595 }
18596 }
18597 showpos(ios);
18598 {
18599 noshowpoint(ios);
18600 {
18601 ios.imbue(lc);
18602 {
18603 ios.width(0);
18604 {
18605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18606 std::string ex(str, iter.base());
18607 assert(ex == "+1234567890.125000");
18608 assert(ios.width() == 0);
18609 }
18610 ios.width(25);
18611 left(ios);
18612 {
18613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18614 std::string ex(str, iter.base());
18615 assert(ex == "+1234567890.125000*******");
18616 assert(ios.width() == 0);
18617 }
18618 ios.width(25);
18619 right(ios);
18620 {
18621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18622 std::string ex(str, iter.base());
18623 assert(ex == "*******+1234567890.125000");
18624 assert(ios.width() == 0);
18625 }
18626 ios.width(25);
18627 internal(ios);
18628 {
18629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18630 std::string ex(str, iter.base());
18631 assert(ex == "+*******1234567890.125000");
18632 assert(ios.width() == 0);
18633 }
18634 }
18635 ios.imbue(lg);
18636 {
18637 ios.width(0);
18638 {
18639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18640 std::string ex(str, iter.base());
18641 assert(ex == "+1_234_567_89_0;125000");
18642 assert(ios.width() == 0);
18643 }
18644 ios.width(25);
18645 left(ios);
18646 {
18647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18648 std::string ex(str, iter.base());
18649 assert(ex == "+1_234_567_89_0;125000***");
18650 assert(ios.width() == 0);
18651 }
18652 ios.width(25);
18653 right(ios);
18654 {
18655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18656 std::string ex(str, iter.base());
18657 assert(ex == "***+1_234_567_89_0;125000");
18658 assert(ios.width() == 0);
18659 }
18660 ios.width(25);
18661 internal(ios);
18662 {
18663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18664 std::string ex(str, iter.base());
18665 assert(ex == "+***1_234_567_89_0;125000");
18666 assert(ios.width() == 0);
18667 }
18668 }
18669 }
18670 showpoint(ios);
18671 {
18672 ios.imbue(lc);
18673 {
18674 ios.width(0);
18675 {
18676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18677 std::string ex(str, iter.base());
18678 assert(ex == "+1234567890.125000");
18679 assert(ios.width() == 0);
18680 }
18681 ios.width(25);
18682 left(ios);
18683 {
18684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18685 std::string ex(str, iter.base());
18686 assert(ex == "+1234567890.125000*******");
18687 assert(ios.width() == 0);
18688 }
18689 ios.width(25);
18690 right(ios);
18691 {
18692 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18693 std::string ex(str, iter.base());
18694 assert(ex == "*******+1234567890.125000");
18695 assert(ios.width() == 0);
18696 }
18697 ios.width(25);
18698 internal(ios);
18699 {
18700 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18701 std::string ex(str, iter.base());
18702 assert(ex == "+*******1234567890.125000");
18703 assert(ios.width() == 0);
18704 }
18705 }
18706 ios.imbue(lg);
18707 {
18708 ios.width(0);
18709 {
18710 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18711 std::string ex(str, iter.base());
18712 assert(ex == "+1_234_567_89_0;125000");
18713 assert(ios.width() == 0);
18714 }
18715 ios.width(25);
18716 left(ios);
18717 {
18718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18719 std::string ex(str, iter.base());
18720 assert(ex == "+1_234_567_89_0;125000***");
18721 assert(ios.width() == 0);
18722 }
18723 ios.width(25);
18724 right(ios);
18725 {
18726 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18727 std::string ex(str, iter.base());
18728 assert(ex == "***+1_234_567_89_0;125000");
18729 assert(ios.width() == 0);
18730 }
18731 ios.width(25);
18732 internal(ios);
18733 {
18734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18735 std::string ex(str, iter.base());
18736 assert(ex == "+***1_234_567_89_0;125000");
18737 assert(ios.width() == 0);
18738 }
18739 }
18740 }
18741 }
18742 }
18743 uppercase(ios);
18744 {
18745 noshowpos(ios);
18746 {
18747 noshowpoint(ios);
18748 {
18749 ios.imbue(lc);
18750 {
18751 ios.width(0);
18752 {
18753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18754 std::string ex(str, iter.base());
18755 assert(ex == "1234567890.125000");
18756 assert(ios.width() == 0);
18757 }
18758 ios.width(25);
18759 left(ios);
18760 {
18761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18762 std::string ex(str, iter.base());
18763 assert(ex == "1234567890.125000********");
18764 assert(ios.width() == 0);
18765 }
18766 ios.width(25);
18767 right(ios);
18768 {
18769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18770 std::string ex(str, iter.base());
18771 assert(ex == "********1234567890.125000");
18772 assert(ios.width() == 0);
18773 }
18774 ios.width(25);
18775 internal(ios);
18776 {
18777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18778 std::string ex(str, iter.base());
18779 assert(ex == "********1234567890.125000");
18780 assert(ios.width() == 0);
18781 }
18782 }
18783 ios.imbue(lg);
18784 {
18785 ios.width(0);
18786 {
18787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18788 std::string ex(str, iter.base());
18789 assert(ex == "1_234_567_89_0;125000");
18790 assert(ios.width() == 0);
18791 }
18792 ios.width(25);
18793 left(ios);
18794 {
18795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18796 std::string ex(str, iter.base());
18797 assert(ex == "1_234_567_89_0;125000****");
18798 assert(ios.width() == 0);
18799 }
18800 ios.width(25);
18801 right(ios);
18802 {
18803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18804 std::string ex(str, iter.base());
18805 assert(ex == "****1_234_567_89_0;125000");
18806 assert(ios.width() == 0);
18807 }
18808 ios.width(25);
18809 internal(ios);
18810 {
18811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18812 std::string ex(str, iter.base());
18813 assert(ex == "****1_234_567_89_0;125000");
18814 assert(ios.width() == 0);
18815 }
18816 }
18817 }
18818 showpoint(ios);
18819 {
18820 ios.imbue(lc);
18821 {
18822 ios.width(0);
18823 {
18824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18825 std::string ex(str, iter.base());
18826 assert(ex == "1234567890.125000");
18827 assert(ios.width() == 0);
18828 }
18829 ios.width(25);
18830 left(ios);
18831 {
18832 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18833 std::string ex(str, iter.base());
18834 assert(ex == "1234567890.125000********");
18835 assert(ios.width() == 0);
18836 }
18837 ios.width(25);
18838 right(ios);
18839 {
18840 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18841 std::string ex(str, iter.base());
18842 assert(ex == "********1234567890.125000");
18843 assert(ios.width() == 0);
18844 }
18845 ios.width(25);
18846 internal(ios);
18847 {
18848 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18849 std::string ex(str, iter.base());
18850 assert(ex == "********1234567890.125000");
18851 assert(ios.width() == 0);
18852 }
18853 }
18854 ios.imbue(lg);
18855 {
18856 ios.width(0);
18857 {
18858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18859 std::string ex(str, iter.base());
18860 assert(ex == "1_234_567_89_0;125000");
18861 assert(ios.width() == 0);
18862 }
18863 ios.width(25);
18864 left(ios);
18865 {
18866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18867 std::string ex(str, iter.base());
18868 assert(ex == "1_234_567_89_0;125000****");
18869 assert(ios.width() == 0);
18870 }
18871 ios.width(25);
18872 right(ios);
18873 {
18874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18875 std::string ex(str, iter.base());
18876 assert(ex == "****1_234_567_89_0;125000");
18877 assert(ios.width() == 0);
18878 }
18879 ios.width(25);
18880 internal(ios);
18881 {
18882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18883 std::string ex(str, iter.base());
18884 assert(ex == "****1_234_567_89_0;125000");
18885 assert(ios.width() == 0);
18886 }
18887 }
18888 }
18889 }
18890 showpos(ios);
18891 {
18892 noshowpoint(ios);
18893 {
18894 ios.imbue(lc);
18895 {
18896 ios.width(0);
18897 {
18898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18899 std::string ex(str, iter.base());
18900 assert(ex == "+1234567890.125000");
18901 assert(ios.width() == 0);
18902 }
18903 ios.width(25);
18904 left(ios);
18905 {
18906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18907 std::string ex(str, iter.base());
18908 assert(ex == "+1234567890.125000*******");
18909 assert(ios.width() == 0);
18910 }
18911 ios.width(25);
18912 right(ios);
18913 {
18914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18915 std::string ex(str, iter.base());
18916 assert(ex == "*******+1234567890.125000");
18917 assert(ios.width() == 0);
18918 }
18919 ios.width(25);
18920 internal(ios);
18921 {
18922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18923 std::string ex(str, iter.base());
18924 assert(ex == "+*******1234567890.125000");
18925 assert(ios.width() == 0);
18926 }
18927 }
18928 ios.imbue(lg);
18929 {
18930 ios.width(0);
18931 {
18932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18933 std::string ex(str, iter.base());
18934 assert(ex == "+1_234_567_89_0;125000");
18935 assert(ios.width() == 0);
18936 }
18937 ios.width(25);
18938 left(ios);
18939 {
18940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18941 std::string ex(str, iter.base());
18942 assert(ex == "+1_234_567_89_0;125000***");
18943 assert(ios.width() == 0);
18944 }
18945 ios.width(25);
18946 right(ios);
18947 {
18948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18949 std::string ex(str, iter.base());
18950 assert(ex == "***+1_234_567_89_0;125000");
18951 assert(ios.width() == 0);
18952 }
18953 ios.width(25);
18954 internal(ios);
18955 {
18956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18957 std::string ex(str, iter.base());
18958 assert(ex == "+***1_234_567_89_0;125000");
18959 assert(ios.width() == 0);
18960 }
18961 }
18962 }
18963 showpoint(ios);
18964 {
18965 ios.imbue(lc);
18966 {
18967 ios.width(0);
18968 {
18969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18970 std::string ex(str, iter.base());
18971 assert(ex == "+1234567890.125000");
18972 assert(ios.width() == 0);
18973 }
18974 ios.width(25);
18975 left(ios);
18976 {
18977 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18978 std::string ex(str, iter.base());
18979 assert(ex == "+1234567890.125000*******");
18980 assert(ios.width() == 0);
18981 }
18982 ios.width(25);
18983 right(ios);
18984 {
18985 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18986 std::string ex(str, iter.base());
18987 assert(ex == "*******+1234567890.125000");
18988 assert(ios.width() == 0);
18989 }
18990 ios.width(25);
18991 internal(ios);
18992 {
18993 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18994 std::string ex(str, iter.base());
18995 assert(ex == "+*******1234567890.125000");
18996 assert(ios.width() == 0);
18997 }
18998 }
18999 ios.imbue(lg);
19000 {
19001 ios.width(0);
19002 {
19003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19004 std::string ex(str, iter.base());
19005 assert(ex == "+1_234_567_89_0;125000");
19006 assert(ios.width() == 0);
19007 }
19008 ios.width(25);
19009 left(ios);
19010 {
19011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19012 std::string ex(str, iter.base());
19013 assert(ex == "+1_234_567_89_0;125000***");
19014 assert(ios.width() == 0);
19015 }
19016 ios.width(25);
19017 right(ios);
19018 {
19019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19020 std::string ex(str, iter.base());
19021 assert(ex == "***+1_234_567_89_0;125000");
19022 assert(ios.width() == 0);
19023 }
19024 ios.width(25);
19025 internal(ios);
19026 {
19027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19028 std::string ex(str, iter.base());
19029 assert(ex == "+***1_234_567_89_0;125000");
19030 assert(ios.width() == 0);
19031 }
19032 }
19033 }
19034 }
19035 }
19036 }
19037 ios.precision(16);
19038 {}
19039 ios.precision(60);
19040 {}
19041 }
19042 }
19043 }
19044
test9()19045 void test9()
19046 {
19047 char str[200];
19048 output_iterator<char*> iter;
19049 std::locale lc = std::locale::classic();
19050 std::locale lg(lc, new my_numpunct);
19051 const my_facet f(1);
19052 {
19053 long double v = -0.;
19054 std::ios ios(0);
19055 scientific(ios);
19056 // %e
19057 {
19058 ios.precision(0);
19059 {
19060 nouppercase(ios);
19061 {
19062 noshowpos(ios);
19063 {
19064 noshowpoint(ios);
19065 {
19066 ios.imbue(lc);
19067 {
19068 ios.width(0);
19069 {
19070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19071 std::string ex(str, iter.base());
19072 assert(ex == "-0e+00");
19073 assert(ios.width() == 0);
19074 }
19075 ios.width(25);
19076 left(ios);
19077 {
19078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19079 std::string ex(str, iter.base());
19080 assert(ex == "-0e+00*******************");
19081 assert(ios.width() == 0);
19082 }
19083 ios.width(25);
19084 right(ios);
19085 {
19086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19087 std::string ex(str, iter.base());
19088 assert(ex == "*******************-0e+00");
19089 assert(ios.width() == 0);
19090 }
19091 ios.width(25);
19092 internal(ios);
19093 {
19094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19095 std::string ex(str, iter.base());
19096 assert(ex == "-*******************0e+00");
19097 assert(ios.width() == 0);
19098 }
19099 }
19100 ios.imbue(lg);
19101 {
19102 ios.width(0);
19103 {
19104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19105 std::string ex(str, iter.base());
19106 assert(ex == "-0e+00");
19107 assert(ios.width() == 0);
19108 }
19109 ios.width(25);
19110 left(ios);
19111 {
19112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19113 std::string ex(str, iter.base());
19114 assert(ex == "-0e+00*******************");
19115 assert(ios.width() == 0);
19116 }
19117 ios.width(25);
19118 right(ios);
19119 {
19120 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19121 std::string ex(str, iter.base());
19122 assert(ex == "*******************-0e+00");
19123 assert(ios.width() == 0);
19124 }
19125 ios.width(25);
19126 internal(ios);
19127 {
19128 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19129 std::string ex(str, iter.base());
19130 assert(ex == "-*******************0e+00");
19131 assert(ios.width() == 0);
19132 }
19133 }
19134 }
19135 showpoint(ios);
19136 {
19137 ios.imbue(lc);
19138 {
19139 ios.width(0);
19140 {
19141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19142 std::string ex(str, iter.base());
19143 assert(ex == "-0.e+00");
19144 assert(ios.width() == 0);
19145 }
19146 ios.width(25);
19147 left(ios);
19148 {
19149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19150 std::string ex(str, iter.base());
19151 assert(ex == "-0.e+00******************");
19152 assert(ios.width() == 0);
19153 }
19154 ios.width(25);
19155 right(ios);
19156 {
19157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19158 std::string ex(str, iter.base());
19159 assert(ex == "******************-0.e+00");
19160 assert(ios.width() == 0);
19161 }
19162 ios.width(25);
19163 internal(ios);
19164 {
19165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19166 std::string ex(str, iter.base());
19167 assert(ex == "-******************0.e+00");
19168 assert(ios.width() == 0);
19169 }
19170 }
19171 ios.imbue(lg);
19172 {
19173 ios.width(0);
19174 {
19175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19176 std::string ex(str, iter.base());
19177 assert(ex == "-0;e+00");
19178 assert(ios.width() == 0);
19179 }
19180 ios.width(25);
19181 left(ios);
19182 {
19183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19184 std::string ex(str, iter.base());
19185 assert(ex == "-0;e+00******************");
19186 assert(ios.width() == 0);
19187 }
19188 ios.width(25);
19189 right(ios);
19190 {
19191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19192 std::string ex(str, iter.base());
19193 assert(ex == "******************-0;e+00");
19194 assert(ios.width() == 0);
19195 }
19196 ios.width(25);
19197 internal(ios);
19198 {
19199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19200 std::string ex(str, iter.base());
19201 assert(ex == "-******************0;e+00");
19202 assert(ios.width() == 0);
19203 }
19204 }
19205 }
19206 }
19207 showpos(ios);
19208 {
19209 noshowpoint(ios);
19210 {
19211 ios.imbue(lc);
19212 {
19213 ios.width(0);
19214 {
19215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19216 std::string ex(str, iter.base());
19217 assert(ex == "-0e+00");
19218 assert(ios.width() == 0);
19219 }
19220 ios.width(25);
19221 left(ios);
19222 {
19223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19224 std::string ex(str, iter.base());
19225 assert(ex == "-0e+00*******************");
19226 assert(ios.width() == 0);
19227 }
19228 ios.width(25);
19229 right(ios);
19230 {
19231 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19232 std::string ex(str, iter.base());
19233 assert(ex == "*******************-0e+00");
19234 assert(ios.width() == 0);
19235 }
19236 ios.width(25);
19237 internal(ios);
19238 {
19239 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19240 std::string ex(str, iter.base());
19241 assert(ex == "-*******************0e+00");
19242 assert(ios.width() == 0);
19243 }
19244 }
19245 ios.imbue(lg);
19246 {
19247 ios.width(0);
19248 {
19249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19250 std::string ex(str, iter.base());
19251 assert(ex == "-0e+00");
19252 assert(ios.width() == 0);
19253 }
19254 ios.width(25);
19255 left(ios);
19256 {
19257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19258 std::string ex(str, iter.base());
19259 assert(ex == "-0e+00*******************");
19260 assert(ios.width() == 0);
19261 }
19262 ios.width(25);
19263 right(ios);
19264 {
19265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19266 std::string ex(str, iter.base());
19267 assert(ex == "*******************-0e+00");
19268 assert(ios.width() == 0);
19269 }
19270 ios.width(25);
19271 internal(ios);
19272 {
19273 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19274 std::string ex(str, iter.base());
19275 assert(ex == "-*******************0e+00");
19276 assert(ios.width() == 0);
19277 }
19278 }
19279 }
19280 showpoint(ios);
19281 {
19282 ios.imbue(lc);
19283 {
19284 ios.width(0);
19285 {
19286 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19287 std::string ex(str, iter.base());
19288 assert(ex == "-0.e+00");
19289 assert(ios.width() == 0);
19290 }
19291 ios.width(25);
19292 left(ios);
19293 {
19294 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19295 std::string ex(str, iter.base());
19296 assert(ex == "-0.e+00******************");
19297 assert(ios.width() == 0);
19298 }
19299 ios.width(25);
19300 right(ios);
19301 {
19302 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19303 std::string ex(str, iter.base());
19304 assert(ex == "******************-0.e+00");
19305 assert(ios.width() == 0);
19306 }
19307 ios.width(25);
19308 internal(ios);
19309 {
19310 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19311 std::string ex(str, iter.base());
19312 assert(ex == "-******************0.e+00");
19313 assert(ios.width() == 0);
19314 }
19315 }
19316 ios.imbue(lg);
19317 {
19318 ios.width(0);
19319 {
19320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19321 std::string ex(str, iter.base());
19322 assert(ex == "-0;e+00");
19323 assert(ios.width() == 0);
19324 }
19325 ios.width(25);
19326 left(ios);
19327 {
19328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19329 std::string ex(str, iter.base());
19330 assert(ex == "-0;e+00******************");
19331 assert(ios.width() == 0);
19332 }
19333 ios.width(25);
19334 right(ios);
19335 {
19336 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19337 std::string ex(str, iter.base());
19338 assert(ex == "******************-0;e+00");
19339 assert(ios.width() == 0);
19340 }
19341 ios.width(25);
19342 internal(ios);
19343 {
19344 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19345 std::string ex(str, iter.base());
19346 assert(ex == "-******************0;e+00");
19347 assert(ios.width() == 0);
19348 }
19349 }
19350 }
19351 }
19352 }
19353 uppercase(ios);
19354 {
19355 noshowpos(ios);
19356 {
19357 noshowpoint(ios);
19358 {
19359 ios.imbue(lc);
19360 {
19361 ios.width(0);
19362 {
19363 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19364 std::string ex(str, iter.base());
19365 assert(ex == "-0E+00");
19366 assert(ios.width() == 0);
19367 }
19368 ios.width(25);
19369 left(ios);
19370 {
19371 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19372 std::string ex(str, iter.base());
19373 assert(ex == "-0E+00*******************");
19374 assert(ios.width() == 0);
19375 }
19376 ios.width(25);
19377 right(ios);
19378 {
19379 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19380 std::string ex(str, iter.base());
19381 assert(ex == "*******************-0E+00");
19382 assert(ios.width() == 0);
19383 }
19384 ios.width(25);
19385 internal(ios);
19386 {
19387 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19388 std::string ex(str, iter.base());
19389 assert(ex == "-*******************0E+00");
19390 assert(ios.width() == 0);
19391 }
19392 }
19393 ios.imbue(lg);
19394 {
19395 ios.width(0);
19396 {
19397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19398 std::string ex(str, iter.base());
19399 assert(ex == "-0E+00");
19400 assert(ios.width() == 0);
19401 }
19402 ios.width(25);
19403 left(ios);
19404 {
19405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19406 std::string ex(str, iter.base());
19407 assert(ex == "-0E+00*******************");
19408 assert(ios.width() == 0);
19409 }
19410 ios.width(25);
19411 right(ios);
19412 {
19413 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19414 std::string ex(str, iter.base());
19415 assert(ex == "*******************-0E+00");
19416 assert(ios.width() == 0);
19417 }
19418 ios.width(25);
19419 internal(ios);
19420 {
19421 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19422 std::string ex(str, iter.base());
19423 assert(ex == "-*******************0E+00");
19424 assert(ios.width() == 0);
19425 }
19426 }
19427 }
19428 showpoint(ios);
19429 {
19430 ios.imbue(lc);
19431 {
19432 ios.width(0);
19433 {
19434 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19435 std::string ex(str, iter.base());
19436 assert(ex == "-0.E+00");
19437 assert(ios.width() == 0);
19438 }
19439 ios.width(25);
19440 left(ios);
19441 {
19442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19443 std::string ex(str, iter.base());
19444 assert(ex == "-0.E+00******************");
19445 assert(ios.width() == 0);
19446 }
19447 ios.width(25);
19448 right(ios);
19449 {
19450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19451 std::string ex(str, iter.base());
19452 assert(ex == "******************-0.E+00");
19453 assert(ios.width() == 0);
19454 }
19455 ios.width(25);
19456 internal(ios);
19457 {
19458 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19459 std::string ex(str, iter.base());
19460 assert(ex == "-******************0.E+00");
19461 assert(ios.width() == 0);
19462 }
19463 }
19464 ios.imbue(lg);
19465 {
19466 ios.width(0);
19467 {
19468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19469 std::string ex(str, iter.base());
19470 assert(ex == "-0;E+00");
19471 assert(ios.width() == 0);
19472 }
19473 ios.width(25);
19474 left(ios);
19475 {
19476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19477 std::string ex(str, iter.base());
19478 assert(ex == "-0;E+00******************");
19479 assert(ios.width() == 0);
19480 }
19481 ios.width(25);
19482 right(ios);
19483 {
19484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19485 std::string ex(str, iter.base());
19486 assert(ex == "******************-0;E+00");
19487 assert(ios.width() == 0);
19488 }
19489 ios.width(25);
19490 internal(ios);
19491 {
19492 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19493 std::string ex(str, iter.base());
19494 assert(ex == "-******************0;E+00");
19495 assert(ios.width() == 0);
19496 }
19497 }
19498 }
19499 }
19500 showpos(ios);
19501 {
19502 noshowpoint(ios);
19503 {
19504 ios.imbue(lc);
19505 {
19506 ios.width(0);
19507 {
19508 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19509 std::string ex(str, iter.base());
19510 assert(ex == "-0E+00");
19511 assert(ios.width() == 0);
19512 }
19513 ios.width(25);
19514 left(ios);
19515 {
19516 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19517 std::string ex(str, iter.base());
19518 assert(ex == "-0E+00*******************");
19519 assert(ios.width() == 0);
19520 }
19521 ios.width(25);
19522 right(ios);
19523 {
19524 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19525 std::string ex(str, iter.base());
19526 assert(ex == "*******************-0E+00");
19527 assert(ios.width() == 0);
19528 }
19529 ios.width(25);
19530 internal(ios);
19531 {
19532 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19533 std::string ex(str, iter.base());
19534 assert(ex == "-*******************0E+00");
19535 assert(ios.width() == 0);
19536 }
19537 }
19538 ios.imbue(lg);
19539 {
19540 ios.width(0);
19541 {
19542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19543 std::string ex(str, iter.base());
19544 assert(ex == "-0E+00");
19545 assert(ios.width() == 0);
19546 }
19547 ios.width(25);
19548 left(ios);
19549 {
19550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19551 std::string ex(str, iter.base());
19552 assert(ex == "-0E+00*******************");
19553 assert(ios.width() == 0);
19554 }
19555 ios.width(25);
19556 right(ios);
19557 {
19558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19559 std::string ex(str, iter.base());
19560 assert(ex == "*******************-0E+00");
19561 assert(ios.width() == 0);
19562 }
19563 ios.width(25);
19564 internal(ios);
19565 {
19566 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19567 std::string ex(str, iter.base());
19568 assert(ex == "-*******************0E+00");
19569 assert(ios.width() == 0);
19570 }
19571 }
19572 }
19573 showpoint(ios);
19574 {
19575 ios.imbue(lc);
19576 {
19577 ios.width(0);
19578 {
19579 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19580 std::string ex(str, iter.base());
19581 assert(ex == "-0.E+00");
19582 assert(ios.width() == 0);
19583 }
19584 ios.width(25);
19585 left(ios);
19586 {
19587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19588 std::string ex(str, iter.base());
19589 assert(ex == "-0.E+00******************");
19590 assert(ios.width() == 0);
19591 }
19592 ios.width(25);
19593 right(ios);
19594 {
19595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19596 std::string ex(str, iter.base());
19597 assert(ex == "******************-0.E+00");
19598 assert(ios.width() == 0);
19599 }
19600 ios.width(25);
19601 internal(ios);
19602 {
19603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19604 std::string ex(str, iter.base());
19605 assert(ex == "-******************0.E+00");
19606 assert(ios.width() == 0);
19607 }
19608 }
19609 ios.imbue(lg);
19610 {
19611 ios.width(0);
19612 {
19613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19614 std::string ex(str, iter.base());
19615 assert(ex == "-0;E+00");
19616 assert(ios.width() == 0);
19617 }
19618 ios.width(25);
19619 left(ios);
19620 {
19621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19622 std::string ex(str, iter.base());
19623 assert(ex == "-0;E+00******************");
19624 assert(ios.width() == 0);
19625 }
19626 ios.width(25);
19627 right(ios);
19628 {
19629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19630 std::string ex(str, iter.base());
19631 assert(ex == "******************-0;E+00");
19632 assert(ios.width() == 0);
19633 }
19634 ios.width(25);
19635 internal(ios);
19636 {
19637 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19638 std::string ex(str, iter.base());
19639 assert(ex == "-******************0;E+00");
19640 assert(ios.width() == 0);
19641 }
19642 }
19643 }
19644 }
19645 }
19646 }
19647 ios.precision(1);
19648 {
19649 nouppercase(ios);
19650 {
19651 noshowpos(ios);
19652 {
19653 noshowpoint(ios);
19654 {
19655 ios.imbue(lc);
19656 {
19657 ios.width(0);
19658 {
19659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19660 std::string ex(str, iter.base());
19661 assert(ex == "-0.0e+00");
19662 assert(ios.width() == 0);
19663 }
19664 ios.width(25);
19665 left(ios);
19666 {
19667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19668 std::string ex(str, iter.base());
19669 assert(ex == "-0.0e+00*****************");
19670 assert(ios.width() == 0);
19671 }
19672 ios.width(25);
19673 right(ios);
19674 {
19675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19676 std::string ex(str, iter.base());
19677 assert(ex == "*****************-0.0e+00");
19678 assert(ios.width() == 0);
19679 }
19680 ios.width(25);
19681 internal(ios);
19682 {
19683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19684 std::string ex(str, iter.base());
19685 assert(ex == "-*****************0.0e+00");
19686 assert(ios.width() == 0);
19687 }
19688 }
19689 ios.imbue(lg);
19690 {
19691 ios.width(0);
19692 {
19693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19694 std::string ex(str, iter.base());
19695 assert(ex == "-0;0e+00");
19696 assert(ios.width() == 0);
19697 }
19698 ios.width(25);
19699 left(ios);
19700 {
19701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19702 std::string ex(str, iter.base());
19703 assert(ex == "-0;0e+00*****************");
19704 assert(ios.width() == 0);
19705 }
19706 ios.width(25);
19707 right(ios);
19708 {
19709 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19710 std::string ex(str, iter.base());
19711 assert(ex == "*****************-0;0e+00");
19712 assert(ios.width() == 0);
19713 }
19714 ios.width(25);
19715 internal(ios);
19716 {
19717 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19718 std::string ex(str, iter.base());
19719 assert(ex == "-*****************0;0e+00");
19720 assert(ios.width() == 0);
19721 }
19722 }
19723 }
19724 showpoint(ios);
19725 {
19726 ios.imbue(lc);
19727 {
19728 ios.width(0);
19729 {
19730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19731 std::string ex(str, iter.base());
19732 assert(ex == "-0.0e+00");
19733 assert(ios.width() == 0);
19734 }
19735 ios.width(25);
19736 left(ios);
19737 {
19738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19739 std::string ex(str, iter.base());
19740 assert(ex == "-0.0e+00*****************");
19741 assert(ios.width() == 0);
19742 }
19743 ios.width(25);
19744 right(ios);
19745 {
19746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19747 std::string ex(str, iter.base());
19748 assert(ex == "*****************-0.0e+00");
19749 assert(ios.width() == 0);
19750 }
19751 ios.width(25);
19752 internal(ios);
19753 {
19754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19755 std::string ex(str, iter.base());
19756 assert(ex == "-*****************0.0e+00");
19757 assert(ios.width() == 0);
19758 }
19759 }
19760 ios.imbue(lg);
19761 {
19762 ios.width(0);
19763 {
19764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19765 std::string ex(str, iter.base());
19766 assert(ex == "-0;0e+00");
19767 assert(ios.width() == 0);
19768 }
19769 ios.width(25);
19770 left(ios);
19771 {
19772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19773 std::string ex(str, iter.base());
19774 assert(ex == "-0;0e+00*****************");
19775 assert(ios.width() == 0);
19776 }
19777 ios.width(25);
19778 right(ios);
19779 {
19780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19781 std::string ex(str, iter.base());
19782 assert(ex == "*****************-0;0e+00");
19783 assert(ios.width() == 0);
19784 }
19785 ios.width(25);
19786 internal(ios);
19787 {
19788 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19789 std::string ex(str, iter.base());
19790 assert(ex == "-*****************0;0e+00");
19791 assert(ios.width() == 0);
19792 }
19793 }
19794 }
19795 }
19796 showpos(ios);
19797 {
19798 noshowpoint(ios);
19799 {
19800 ios.imbue(lc);
19801 {
19802 ios.width(0);
19803 {
19804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19805 std::string ex(str, iter.base());
19806 assert(ex == "-0.0e+00");
19807 assert(ios.width() == 0);
19808 }
19809 ios.width(25);
19810 left(ios);
19811 {
19812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19813 std::string ex(str, iter.base());
19814 assert(ex == "-0.0e+00*****************");
19815 assert(ios.width() == 0);
19816 }
19817 ios.width(25);
19818 right(ios);
19819 {
19820 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19821 std::string ex(str, iter.base());
19822 assert(ex == "*****************-0.0e+00");
19823 assert(ios.width() == 0);
19824 }
19825 ios.width(25);
19826 internal(ios);
19827 {
19828 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19829 std::string ex(str, iter.base());
19830 assert(ex == "-*****************0.0e+00");
19831 assert(ios.width() == 0);
19832 }
19833 }
19834 ios.imbue(lg);
19835 {
19836 ios.width(0);
19837 {
19838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19839 std::string ex(str, iter.base());
19840 assert(ex == "-0;0e+00");
19841 assert(ios.width() == 0);
19842 }
19843 ios.width(25);
19844 left(ios);
19845 {
19846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19847 std::string ex(str, iter.base());
19848 assert(ex == "-0;0e+00*****************");
19849 assert(ios.width() == 0);
19850 }
19851 ios.width(25);
19852 right(ios);
19853 {
19854 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19855 std::string ex(str, iter.base());
19856 assert(ex == "*****************-0;0e+00");
19857 assert(ios.width() == 0);
19858 }
19859 ios.width(25);
19860 internal(ios);
19861 {
19862 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19863 std::string ex(str, iter.base());
19864 assert(ex == "-*****************0;0e+00");
19865 assert(ios.width() == 0);
19866 }
19867 }
19868 }
19869 showpoint(ios);
19870 {
19871 ios.imbue(lc);
19872 {
19873 ios.width(0);
19874 {
19875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19876 std::string ex(str, iter.base());
19877 assert(ex == "-0.0e+00");
19878 assert(ios.width() == 0);
19879 }
19880 ios.width(25);
19881 left(ios);
19882 {
19883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19884 std::string ex(str, iter.base());
19885 assert(ex == "-0.0e+00*****************");
19886 assert(ios.width() == 0);
19887 }
19888 ios.width(25);
19889 right(ios);
19890 {
19891 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19892 std::string ex(str, iter.base());
19893 assert(ex == "*****************-0.0e+00");
19894 assert(ios.width() == 0);
19895 }
19896 ios.width(25);
19897 internal(ios);
19898 {
19899 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19900 std::string ex(str, iter.base());
19901 assert(ex == "-*****************0.0e+00");
19902 assert(ios.width() == 0);
19903 }
19904 }
19905 ios.imbue(lg);
19906 {
19907 ios.width(0);
19908 {
19909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19910 std::string ex(str, iter.base());
19911 assert(ex == "-0;0e+00");
19912 assert(ios.width() == 0);
19913 }
19914 ios.width(25);
19915 left(ios);
19916 {
19917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19918 std::string ex(str, iter.base());
19919 assert(ex == "-0;0e+00*****************");
19920 assert(ios.width() == 0);
19921 }
19922 ios.width(25);
19923 right(ios);
19924 {
19925 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19926 std::string ex(str, iter.base());
19927 assert(ex == "*****************-0;0e+00");
19928 assert(ios.width() == 0);
19929 }
19930 ios.width(25);
19931 internal(ios);
19932 {
19933 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19934 std::string ex(str, iter.base());
19935 assert(ex == "-*****************0;0e+00");
19936 assert(ios.width() == 0);
19937 }
19938 }
19939 }
19940 }
19941 }
19942 uppercase(ios);
19943 {
19944 noshowpos(ios);
19945 {
19946 noshowpoint(ios);
19947 {
19948 ios.imbue(lc);
19949 {
19950 ios.width(0);
19951 {
19952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19953 std::string ex(str, iter.base());
19954 assert(ex == "-0.0E+00");
19955 assert(ios.width() == 0);
19956 }
19957 ios.width(25);
19958 left(ios);
19959 {
19960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19961 std::string ex(str, iter.base());
19962 assert(ex == "-0.0E+00*****************");
19963 assert(ios.width() == 0);
19964 }
19965 ios.width(25);
19966 right(ios);
19967 {
19968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19969 std::string ex(str, iter.base());
19970 assert(ex == "*****************-0.0E+00");
19971 assert(ios.width() == 0);
19972 }
19973 ios.width(25);
19974 internal(ios);
19975 {
19976 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19977 std::string ex(str, iter.base());
19978 assert(ex == "-*****************0.0E+00");
19979 assert(ios.width() == 0);
19980 }
19981 }
19982 ios.imbue(lg);
19983 {
19984 ios.width(0);
19985 {
19986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19987 std::string ex(str, iter.base());
19988 assert(ex == "-0;0E+00");
19989 assert(ios.width() == 0);
19990 }
19991 ios.width(25);
19992 left(ios);
19993 {
19994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19995 std::string ex(str, iter.base());
19996 assert(ex == "-0;0E+00*****************");
19997 assert(ios.width() == 0);
19998 }
19999 ios.width(25);
20000 right(ios);
20001 {
20002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20003 std::string ex(str, iter.base());
20004 assert(ex == "*****************-0;0E+00");
20005 assert(ios.width() == 0);
20006 }
20007 ios.width(25);
20008 internal(ios);
20009 {
20010 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20011 std::string ex(str, iter.base());
20012 assert(ex == "-*****************0;0E+00");
20013 assert(ios.width() == 0);
20014 }
20015 }
20016 }
20017 showpoint(ios);
20018 {
20019 ios.imbue(lc);
20020 {
20021 ios.width(0);
20022 {
20023 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20024 std::string ex(str, iter.base());
20025 assert(ex == "-0.0E+00");
20026 assert(ios.width() == 0);
20027 }
20028 ios.width(25);
20029 left(ios);
20030 {
20031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20032 std::string ex(str, iter.base());
20033 assert(ex == "-0.0E+00*****************");
20034 assert(ios.width() == 0);
20035 }
20036 ios.width(25);
20037 right(ios);
20038 {
20039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20040 std::string ex(str, iter.base());
20041 assert(ex == "*****************-0.0E+00");
20042 assert(ios.width() == 0);
20043 }
20044 ios.width(25);
20045 internal(ios);
20046 {
20047 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20048 std::string ex(str, iter.base());
20049 assert(ex == "-*****************0.0E+00");
20050 assert(ios.width() == 0);
20051 }
20052 }
20053 ios.imbue(lg);
20054 {
20055 ios.width(0);
20056 {
20057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20058 std::string ex(str, iter.base());
20059 assert(ex == "-0;0E+00");
20060 assert(ios.width() == 0);
20061 }
20062 ios.width(25);
20063 left(ios);
20064 {
20065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20066 std::string ex(str, iter.base());
20067 assert(ex == "-0;0E+00*****************");
20068 assert(ios.width() == 0);
20069 }
20070 ios.width(25);
20071 right(ios);
20072 {
20073 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20074 std::string ex(str, iter.base());
20075 assert(ex == "*****************-0;0E+00");
20076 assert(ios.width() == 0);
20077 }
20078 ios.width(25);
20079 internal(ios);
20080 {
20081 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20082 std::string ex(str, iter.base());
20083 assert(ex == "-*****************0;0E+00");
20084 assert(ios.width() == 0);
20085 }
20086 }
20087 }
20088 }
20089 showpos(ios);
20090 {
20091 noshowpoint(ios);
20092 {
20093 ios.imbue(lc);
20094 {
20095 ios.width(0);
20096 {
20097 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20098 std::string ex(str, iter.base());
20099 assert(ex == "-0.0E+00");
20100 assert(ios.width() == 0);
20101 }
20102 ios.width(25);
20103 left(ios);
20104 {
20105 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20106 std::string ex(str, iter.base());
20107 assert(ex == "-0.0E+00*****************");
20108 assert(ios.width() == 0);
20109 }
20110 ios.width(25);
20111 right(ios);
20112 {
20113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20114 std::string ex(str, iter.base());
20115 assert(ex == "*****************-0.0E+00");
20116 assert(ios.width() == 0);
20117 }
20118 ios.width(25);
20119 internal(ios);
20120 {
20121 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20122 std::string ex(str, iter.base());
20123 assert(ex == "-*****************0.0E+00");
20124 assert(ios.width() == 0);
20125 }
20126 }
20127 ios.imbue(lg);
20128 {
20129 ios.width(0);
20130 {
20131 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20132 std::string ex(str, iter.base());
20133 assert(ex == "-0;0E+00");
20134 assert(ios.width() == 0);
20135 }
20136 ios.width(25);
20137 left(ios);
20138 {
20139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20140 std::string ex(str, iter.base());
20141 assert(ex == "-0;0E+00*****************");
20142 assert(ios.width() == 0);
20143 }
20144 ios.width(25);
20145 right(ios);
20146 {
20147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20148 std::string ex(str, iter.base());
20149 assert(ex == "*****************-0;0E+00");
20150 assert(ios.width() == 0);
20151 }
20152 ios.width(25);
20153 internal(ios);
20154 {
20155 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20156 std::string ex(str, iter.base());
20157 assert(ex == "-*****************0;0E+00");
20158 assert(ios.width() == 0);
20159 }
20160 }
20161 }
20162 showpoint(ios);
20163 {
20164 ios.imbue(lc);
20165 {
20166 ios.width(0);
20167 {
20168 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20169 std::string ex(str, iter.base());
20170 assert(ex == "-0.0E+00");
20171 assert(ios.width() == 0);
20172 }
20173 ios.width(25);
20174 left(ios);
20175 {
20176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20177 std::string ex(str, iter.base());
20178 assert(ex == "-0.0E+00*****************");
20179 assert(ios.width() == 0);
20180 }
20181 ios.width(25);
20182 right(ios);
20183 {
20184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20185 std::string ex(str, iter.base());
20186 assert(ex == "*****************-0.0E+00");
20187 assert(ios.width() == 0);
20188 }
20189 ios.width(25);
20190 internal(ios);
20191 {
20192 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20193 std::string ex(str, iter.base());
20194 assert(ex == "-*****************0.0E+00");
20195 assert(ios.width() == 0);
20196 }
20197 }
20198 ios.imbue(lg);
20199 {
20200 ios.width(0);
20201 {
20202 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20203 std::string ex(str, iter.base());
20204 assert(ex == "-0;0E+00");
20205 assert(ios.width() == 0);
20206 }
20207 ios.width(25);
20208 left(ios);
20209 {
20210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20211 std::string ex(str, iter.base());
20212 assert(ex == "-0;0E+00*****************");
20213 assert(ios.width() == 0);
20214 }
20215 ios.width(25);
20216 right(ios);
20217 {
20218 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20219 std::string ex(str, iter.base());
20220 assert(ex == "*****************-0;0E+00");
20221 assert(ios.width() == 0);
20222 }
20223 ios.width(25);
20224 internal(ios);
20225 {
20226 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20227 std::string ex(str, iter.base());
20228 assert(ex == "-*****************0;0E+00");
20229 assert(ios.width() == 0);
20230 }
20231 }
20232 }
20233 }
20234 }
20235 }
20236 ios.precision(6);
20237 {
20238 nouppercase(ios);
20239 {
20240 noshowpos(ios);
20241 {
20242 noshowpoint(ios);
20243 {
20244 ios.imbue(lc);
20245 {
20246 ios.width(0);
20247 {
20248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20249 std::string ex(str, iter.base());
20250 assert(ex == "-0.000000e+00");
20251 assert(ios.width() == 0);
20252 }
20253 ios.width(25);
20254 left(ios);
20255 {
20256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20257 std::string ex(str, iter.base());
20258 assert(ex == "-0.000000e+00************");
20259 assert(ios.width() == 0);
20260 }
20261 ios.width(25);
20262 right(ios);
20263 {
20264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20265 std::string ex(str, iter.base());
20266 assert(ex == "************-0.000000e+00");
20267 assert(ios.width() == 0);
20268 }
20269 ios.width(25);
20270 internal(ios);
20271 {
20272 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20273 std::string ex(str, iter.base());
20274 assert(ex == "-************0.000000e+00");
20275 assert(ios.width() == 0);
20276 }
20277 }
20278 ios.imbue(lg);
20279 {
20280 ios.width(0);
20281 {
20282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20283 std::string ex(str, iter.base());
20284 assert(ex == "-0;000000e+00");
20285 assert(ios.width() == 0);
20286 }
20287 ios.width(25);
20288 left(ios);
20289 {
20290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20291 std::string ex(str, iter.base());
20292 assert(ex == "-0;000000e+00************");
20293 assert(ios.width() == 0);
20294 }
20295 ios.width(25);
20296 right(ios);
20297 {
20298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20299 std::string ex(str, iter.base());
20300 assert(ex == "************-0;000000e+00");
20301 assert(ios.width() == 0);
20302 }
20303 ios.width(25);
20304 internal(ios);
20305 {
20306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20307 std::string ex(str, iter.base());
20308 assert(ex == "-************0;000000e+00");
20309 assert(ios.width() == 0);
20310 }
20311 }
20312 }
20313 showpoint(ios);
20314 {
20315 ios.imbue(lc);
20316 {
20317 ios.width(0);
20318 {
20319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20320 std::string ex(str, iter.base());
20321 assert(ex == "-0.000000e+00");
20322 assert(ios.width() == 0);
20323 }
20324 ios.width(25);
20325 left(ios);
20326 {
20327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20328 std::string ex(str, iter.base());
20329 assert(ex == "-0.000000e+00************");
20330 assert(ios.width() == 0);
20331 }
20332 ios.width(25);
20333 right(ios);
20334 {
20335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20336 std::string ex(str, iter.base());
20337 assert(ex == "************-0.000000e+00");
20338 assert(ios.width() == 0);
20339 }
20340 ios.width(25);
20341 internal(ios);
20342 {
20343 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20344 std::string ex(str, iter.base());
20345 assert(ex == "-************0.000000e+00");
20346 assert(ios.width() == 0);
20347 }
20348 }
20349 ios.imbue(lg);
20350 {
20351 ios.width(0);
20352 {
20353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20354 std::string ex(str, iter.base());
20355 assert(ex == "-0;000000e+00");
20356 assert(ios.width() == 0);
20357 }
20358 ios.width(25);
20359 left(ios);
20360 {
20361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20362 std::string ex(str, iter.base());
20363 assert(ex == "-0;000000e+00************");
20364 assert(ios.width() == 0);
20365 }
20366 ios.width(25);
20367 right(ios);
20368 {
20369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20370 std::string ex(str, iter.base());
20371 assert(ex == "************-0;000000e+00");
20372 assert(ios.width() == 0);
20373 }
20374 ios.width(25);
20375 internal(ios);
20376 {
20377 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20378 std::string ex(str, iter.base());
20379 assert(ex == "-************0;000000e+00");
20380 assert(ios.width() == 0);
20381 }
20382 }
20383 }
20384 }
20385 showpos(ios);
20386 {
20387 noshowpoint(ios);
20388 {
20389 ios.imbue(lc);
20390 {
20391 ios.width(0);
20392 {
20393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20394 std::string ex(str, iter.base());
20395 assert(ex == "-0.000000e+00");
20396 assert(ios.width() == 0);
20397 }
20398 ios.width(25);
20399 left(ios);
20400 {
20401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20402 std::string ex(str, iter.base());
20403 assert(ex == "-0.000000e+00************");
20404 assert(ios.width() == 0);
20405 }
20406 ios.width(25);
20407 right(ios);
20408 {
20409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20410 std::string ex(str, iter.base());
20411 assert(ex == "************-0.000000e+00");
20412 assert(ios.width() == 0);
20413 }
20414 ios.width(25);
20415 internal(ios);
20416 {
20417 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20418 std::string ex(str, iter.base());
20419 assert(ex == "-************0.000000e+00");
20420 assert(ios.width() == 0);
20421 }
20422 }
20423 ios.imbue(lg);
20424 {
20425 ios.width(0);
20426 {
20427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20428 std::string ex(str, iter.base());
20429 assert(ex == "-0;000000e+00");
20430 assert(ios.width() == 0);
20431 }
20432 ios.width(25);
20433 left(ios);
20434 {
20435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20436 std::string ex(str, iter.base());
20437 assert(ex == "-0;000000e+00************");
20438 assert(ios.width() == 0);
20439 }
20440 ios.width(25);
20441 right(ios);
20442 {
20443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20444 std::string ex(str, iter.base());
20445 assert(ex == "************-0;000000e+00");
20446 assert(ios.width() == 0);
20447 }
20448 ios.width(25);
20449 internal(ios);
20450 {
20451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20452 std::string ex(str, iter.base());
20453 assert(ex == "-************0;000000e+00");
20454 assert(ios.width() == 0);
20455 }
20456 }
20457 }
20458 showpoint(ios);
20459 {
20460 ios.imbue(lc);
20461 {
20462 ios.width(0);
20463 {
20464 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20465 std::string ex(str, iter.base());
20466 assert(ex == "-0.000000e+00");
20467 assert(ios.width() == 0);
20468 }
20469 ios.width(25);
20470 left(ios);
20471 {
20472 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20473 std::string ex(str, iter.base());
20474 assert(ex == "-0.000000e+00************");
20475 assert(ios.width() == 0);
20476 }
20477 ios.width(25);
20478 right(ios);
20479 {
20480 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20481 std::string ex(str, iter.base());
20482 assert(ex == "************-0.000000e+00");
20483 assert(ios.width() == 0);
20484 }
20485 ios.width(25);
20486 internal(ios);
20487 {
20488 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20489 std::string ex(str, iter.base());
20490 assert(ex == "-************0.000000e+00");
20491 assert(ios.width() == 0);
20492 }
20493 }
20494 ios.imbue(lg);
20495 {
20496 ios.width(0);
20497 {
20498 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20499 std::string ex(str, iter.base());
20500 assert(ex == "-0;000000e+00");
20501 assert(ios.width() == 0);
20502 }
20503 ios.width(25);
20504 left(ios);
20505 {
20506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20507 std::string ex(str, iter.base());
20508 assert(ex == "-0;000000e+00************");
20509 assert(ios.width() == 0);
20510 }
20511 ios.width(25);
20512 right(ios);
20513 {
20514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20515 std::string ex(str, iter.base());
20516 assert(ex == "************-0;000000e+00");
20517 assert(ios.width() == 0);
20518 }
20519 ios.width(25);
20520 internal(ios);
20521 {
20522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20523 std::string ex(str, iter.base());
20524 assert(ex == "-************0;000000e+00");
20525 assert(ios.width() == 0);
20526 }
20527 }
20528 }
20529 }
20530 }
20531 uppercase(ios);
20532 {
20533 noshowpos(ios);
20534 {
20535 noshowpoint(ios);
20536 {
20537 ios.imbue(lc);
20538 {
20539 ios.width(0);
20540 {
20541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20542 std::string ex(str, iter.base());
20543 assert(ex == "-0.000000E+00");
20544 assert(ios.width() == 0);
20545 }
20546 ios.width(25);
20547 left(ios);
20548 {
20549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20550 std::string ex(str, iter.base());
20551 assert(ex == "-0.000000E+00************");
20552 assert(ios.width() == 0);
20553 }
20554 ios.width(25);
20555 right(ios);
20556 {
20557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20558 std::string ex(str, iter.base());
20559 assert(ex == "************-0.000000E+00");
20560 assert(ios.width() == 0);
20561 }
20562 ios.width(25);
20563 internal(ios);
20564 {
20565 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20566 std::string ex(str, iter.base());
20567 assert(ex == "-************0.000000E+00");
20568 assert(ios.width() == 0);
20569 }
20570 }
20571 ios.imbue(lg);
20572 {
20573 ios.width(0);
20574 {
20575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20576 std::string ex(str, iter.base());
20577 assert(ex == "-0;000000E+00");
20578 assert(ios.width() == 0);
20579 }
20580 ios.width(25);
20581 left(ios);
20582 {
20583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20584 std::string ex(str, iter.base());
20585 assert(ex == "-0;000000E+00************");
20586 assert(ios.width() == 0);
20587 }
20588 ios.width(25);
20589 right(ios);
20590 {
20591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20592 std::string ex(str, iter.base());
20593 assert(ex == "************-0;000000E+00");
20594 assert(ios.width() == 0);
20595 }
20596 ios.width(25);
20597 internal(ios);
20598 {
20599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20600 std::string ex(str, iter.base());
20601 assert(ex == "-************0;000000E+00");
20602 assert(ios.width() == 0);
20603 }
20604 }
20605 }
20606 showpoint(ios);
20607 {
20608 ios.imbue(lc);
20609 {
20610 ios.width(0);
20611 {
20612 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20613 std::string ex(str, iter.base());
20614 assert(ex == "-0.000000E+00");
20615 assert(ios.width() == 0);
20616 }
20617 ios.width(25);
20618 left(ios);
20619 {
20620 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20621 std::string ex(str, iter.base());
20622 assert(ex == "-0.000000E+00************");
20623 assert(ios.width() == 0);
20624 }
20625 ios.width(25);
20626 right(ios);
20627 {
20628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20629 std::string ex(str, iter.base());
20630 assert(ex == "************-0.000000E+00");
20631 assert(ios.width() == 0);
20632 }
20633 ios.width(25);
20634 internal(ios);
20635 {
20636 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20637 std::string ex(str, iter.base());
20638 assert(ex == "-************0.000000E+00");
20639 assert(ios.width() == 0);
20640 }
20641 }
20642 ios.imbue(lg);
20643 {
20644 ios.width(0);
20645 {
20646 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20647 std::string ex(str, iter.base());
20648 assert(ex == "-0;000000E+00");
20649 assert(ios.width() == 0);
20650 }
20651 ios.width(25);
20652 left(ios);
20653 {
20654 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20655 std::string ex(str, iter.base());
20656 assert(ex == "-0;000000E+00************");
20657 assert(ios.width() == 0);
20658 }
20659 ios.width(25);
20660 right(ios);
20661 {
20662 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20663 std::string ex(str, iter.base());
20664 assert(ex == "************-0;000000E+00");
20665 assert(ios.width() == 0);
20666 }
20667 ios.width(25);
20668 internal(ios);
20669 {
20670 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20671 std::string ex(str, iter.base());
20672 assert(ex == "-************0;000000E+00");
20673 assert(ios.width() == 0);
20674 }
20675 }
20676 }
20677 }
20678 showpos(ios);
20679 {
20680 noshowpoint(ios);
20681 {
20682 ios.imbue(lc);
20683 {
20684 ios.width(0);
20685 {
20686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20687 std::string ex(str, iter.base());
20688 assert(ex == "-0.000000E+00");
20689 assert(ios.width() == 0);
20690 }
20691 ios.width(25);
20692 left(ios);
20693 {
20694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20695 std::string ex(str, iter.base());
20696 assert(ex == "-0.000000E+00************");
20697 assert(ios.width() == 0);
20698 }
20699 ios.width(25);
20700 right(ios);
20701 {
20702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20703 std::string ex(str, iter.base());
20704 assert(ex == "************-0.000000E+00");
20705 assert(ios.width() == 0);
20706 }
20707 ios.width(25);
20708 internal(ios);
20709 {
20710 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20711 std::string ex(str, iter.base());
20712 assert(ex == "-************0.000000E+00");
20713 assert(ios.width() == 0);
20714 }
20715 }
20716 ios.imbue(lg);
20717 {
20718 ios.width(0);
20719 {
20720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20721 std::string ex(str, iter.base());
20722 assert(ex == "-0;000000E+00");
20723 assert(ios.width() == 0);
20724 }
20725 ios.width(25);
20726 left(ios);
20727 {
20728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20729 std::string ex(str, iter.base());
20730 assert(ex == "-0;000000E+00************");
20731 assert(ios.width() == 0);
20732 }
20733 ios.width(25);
20734 right(ios);
20735 {
20736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20737 std::string ex(str, iter.base());
20738 assert(ex == "************-0;000000E+00");
20739 assert(ios.width() == 0);
20740 }
20741 ios.width(25);
20742 internal(ios);
20743 {
20744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20745 std::string ex(str, iter.base());
20746 assert(ex == "-************0;000000E+00");
20747 assert(ios.width() == 0);
20748 }
20749 }
20750 }
20751 showpoint(ios);
20752 {
20753 ios.imbue(lc);
20754 {
20755 ios.width(0);
20756 {
20757 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20758 std::string ex(str, iter.base());
20759 assert(ex == "-0.000000E+00");
20760 assert(ios.width() == 0);
20761 }
20762 ios.width(25);
20763 left(ios);
20764 {
20765 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20766 std::string ex(str, iter.base());
20767 assert(ex == "-0.000000E+00************");
20768 assert(ios.width() == 0);
20769 }
20770 ios.width(25);
20771 right(ios);
20772 {
20773 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20774 std::string ex(str, iter.base());
20775 assert(ex == "************-0.000000E+00");
20776 assert(ios.width() == 0);
20777 }
20778 ios.width(25);
20779 internal(ios);
20780 {
20781 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20782 std::string ex(str, iter.base());
20783 assert(ex == "-************0.000000E+00");
20784 assert(ios.width() == 0);
20785 }
20786 }
20787 ios.imbue(lg);
20788 {
20789 ios.width(0);
20790 {
20791 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20792 std::string ex(str, iter.base());
20793 assert(ex == "-0;000000E+00");
20794 assert(ios.width() == 0);
20795 }
20796 ios.width(25);
20797 left(ios);
20798 {
20799 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20800 std::string ex(str, iter.base());
20801 assert(ex == "-0;000000E+00************");
20802 assert(ios.width() == 0);
20803 }
20804 ios.width(25);
20805 right(ios);
20806 {
20807 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20808 std::string ex(str, iter.base());
20809 assert(ex == "************-0;000000E+00");
20810 assert(ios.width() == 0);
20811 }
20812 ios.width(25);
20813 internal(ios);
20814 {
20815 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20816 std::string ex(str, iter.base());
20817 assert(ex == "-************0;000000E+00");
20818 assert(ios.width() == 0);
20819 }
20820 }
20821 }
20822 }
20823 }
20824 }
20825 ios.precision(16);
20826 {
20827 }
20828 ios.precision(60);
20829 {
20830 }
20831 }
20832 }
20833 }
20834
test10()20835 void test10()
20836 {
20837 char str[200];
20838 output_iterator<char*> iter;
20839 std::locale lc = std::locale::classic();
20840 std::locale lg(lc, new my_numpunct);
20841 const my_facet f(1);
20842 {
20843 long double v = 1234567890.125;
20844 std::ios ios(0);
20845 scientific(ios);
20846 // %e
20847 {
20848 ios.precision(0);
20849 {
20850 nouppercase(ios);
20851 {
20852 noshowpos(ios);
20853 {
20854 noshowpoint(ios);
20855 {
20856 ios.imbue(lc);
20857 {
20858 ios.width(0);
20859 {
20860 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20861 std::string ex(str, iter.base());
20862 assert(ex == "1e+09");
20863 assert(ios.width() == 0);
20864 }
20865 ios.width(25);
20866 left(ios);
20867 {
20868 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20869 std::string ex(str, iter.base());
20870 assert(ex == "1e+09********************");
20871 assert(ios.width() == 0);
20872 }
20873 ios.width(25);
20874 right(ios);
20875 {
20876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20877 std::string ex(str, iter.base());
20878 assert(ex == "********************1e+09");
20879 assert(ios.width() == 0);
20880 }
20881 ios.width(25);
20882 internal(ios);
20883 {
20884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20885 std::string ex(str, iter.base());
20886 assert(ex == "********************1e+09");
20887 assert(ios.width() == 0);
20888 }
20889 }
20890 ios.imbue(lg);
20891 {
20892 ios.width(0);
20893 {
20894 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20895 std::string ex(str, iter.base());
20896 assert(ex == "1e+09");
20897 assert(ios.width() == 0);
20898 }
20899 ios.width(25);
20900 left(ios);
20901 {
20902 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20903 std::string ex(str, iter.base());
20904 assert(ex == "1e+09********************");
20905 assert(ios.width() == 0);
20906 }
20907 ios.width(25);
20908 right(ios);
20909 {
20910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20911 std::string ex(str, iter.base());
20912 assert(ex == "********************1e+09");
20913 assert(ios.width() == 0);
20914 }
20915 ios.width(25);
20916 internal(ios);
20917 {
20918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20919 std::string ex(str, iter.base());
20920 assert(ex == "********************1e+09");
20921 assert(ios.width() == 0);
20922 }
20923 }
20924 }
20925 showpoint(ios);
20926 {
20927 ios.imbue(lc);
20928 {
20929 ios.width(0);
20930 {
20931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20932 std::string ex(str, iter.base());
20933 assert(ex == "1.e+09");
20934 assert(ios.width() == 0);
20935 }
20936 ios.width(25);
20937 left(ios);
20938 {
20939 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20940 std::string ex(str, iter.base());
20941 assert(ex == "1.e+09*******************");
20942 assert(ios.width() == 0);
20943 }
20944 ios.width(25);
20945 right(ios);
20946 {
20947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20948 std::string ex(str, iter.base());
20949 assert(ex == "*******************1.e+09");
20950 assert(ios.width() == 0);
20951 }
20952 ios.width(25);
20953 internal(ios);
20954 {
20955 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20956 std::string ex(str, iter.base());
20957 assert(ex == "*******************1.e+09");
20958 assert(ios.width() == 0);
20959 }
20960 }
20961 ios.imbue(lg);
20962 {
20963 ios.width(0);
20964 {
20965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20966 std::string ex(str, iter.base());
20967 assert(ex == "1;e+09");
20968 assert(ios.width() == 0);
20969 }
20970 ios.width(25);
20971 left(ios);
20972 {
20973 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20974 std::string ex(str, iter.base());
20975 assert(ex == "1;e+09*******************");
20976 assert(ios.width() == 0);
20977 }
20978 ios.width(25);
20979 right(ios);
20980 {
20981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20982 std::string ex(str, iter.base());
20983 assert(ex == "*******************1;e+09");
20984 assert(ios.width() == 0);
20985 }
20986 ios.width(25);
20987 internal(ios);
20988 {
20989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20990 std::string ex(str, iter.base());
20991 assert(ex == "*******************1;e+09");
20992 assert(ios.width() == 0);
20993 }
20994 }
20995 }
20996 }
20997 showpos(ios);
20998 {
20999 noshowpoint(ios);
21000 {
21001 ios.imbue(lc);
21002 {
21003 ios.width(0);
21004 {
21005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21006 std::string ex(str, iter.base());
21007 assert(ex == "+1e+09");
21008 assert(ios.width() == 0);
21009 }
21010 ios.width(25);
21011 left(ios);
21012 {
21013 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21014 std::string ex(str, iter.base());
21015 assert(ex == "+1e+09*******************");
21016 assert(ios.width() == 0);
21017 }
21018 ios.width(25);
21019 right(ios);
21020 {
21021 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21022 std::string ex(str, iter.base());
21023 assert(ex == "*******************+1e+09");
21024 assert(ios.width() == 0);
21025 }
21026 ios.width(25);
21027 internal(ios);
21028 {
21029 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21030 std::string ex(str, iter.base());
21031 assert(ex == "+*******************1e+09");
21032 assert(ios.width() == 0);
21033 }
21034 }
21035 ios.imbue(lg);
21036 {
21037 ios.width(0);
21038 {
21039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21040 std::string ex(str, iter.base());
21041 assert(ex == "+1e+09");
21042 assert(ios.width() == 0);
21043 }
21044 ios.width(25);
21045 left(ios);
21046 {
21047 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21048 std::string ex(str, iter.base());
21049 assert(ex == "+1e+09*******************");
21050 assert(ios.width() == 0);
21051 }
21052 ios.width(25);
21053 right(ios);
21054 {
21055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21056 std::string ex(str, iter.base());
21057 assert(ex == "*******************+1e+09");
21058 assert(ios.width() == 0);
21059 }
21060 ios.width(25);
21061 internal(ios);
21062 {
21063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21064 std::string ex(str, iter.base());
21065 assert(ex == "+*******************1e+09");
21066 assert(ios.width() == 0);
21067 }
21068 }
21069 }
21070 showpoint(ios);
21071 {
21072 ios.imbue(lc);
21073 {
21074 ios.width(0);
21075 {
21076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21077 std::string ex(str, iter.base());
21078 assert(ex == "+1.e+09");
21079 assert(ios.width() == 0);
21080 }
21081 ios.width(25);
21082 left(ios);
21083 {
21084 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21085 std::string ex(str, iter.base());
21086 assert(ex == "+1.e+09******************");
21087 assert(ios.width() == 0);
21088 }
21089 ios.width(25);
21090 right(ios);
21091 {
21092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21093 std::string ex(str, iter.base());
21094 assert(ex == "******************+1.e+09");
21095 assert(ios.width() == 0);
21096 }
21097 ios.width(25);
21098 internal(ios);
21099 {
21100 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21101 std::string ex(str, iter.base());
21102 assert(ex == "+******************1.e+09");
21103 assert(ios.width() == 0);
21104 }
21105 }
21106 ios.imbue(lg);
21107 {
21108 ios.width(0);
21109 {
21110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21111 std::string ex(str, iter.base());
21112 assert(ex == "+1;e+09");
21113 assert(ios.width() == 0);
21114 }
21115 ios.width(25);
21116 left(ios);
21117 {
21118 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21119 std::string ex(str, iter.base());
21120 assert(ex == "+1;e+09******************");
21121 assert(ios.width() == 0);
21122 }
21123 ios.width(25);
21124 right(ios);
21125 {
21126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21127 std::string ex(str, iter.base());
21128 assert(ex == "******************+1;e+09");
21129 assert(ios.width() == 0);
21130 }
21131 ios.width(25);
21132 internal(ios);
21133 {
21134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21135 std::string ex(str, iter.base());
21136 assert(ex == "+******************1;e+09");
21137 assert(ios.width() == 0);
21138 }
21139 }
21140 }
21141 }
21142 }
21143 uppercase(ios);
21144 {
21145 noshowpos(ios);
21146 {
21147 noshowpoint(ios);
21148 {
21149 ios.imbue(lc);
21150 {
21151 ios.width(0);
21152 {
21153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21154 std::string ex(str, iter.base());
21155 assert(ex == "1E+09");
21156 assert(ios.width() == 0);
21157 }
21158 ios.width(25);
21159 left(ios);
21160 {
21161 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21162 std::string ex(str, iter.base());
21163 assert(ex == "1E+09********************");
21164 assert(ios.width() == 0);
21165 }
21166 ios.width(25);
21167 right(ios);
21168 {
21169 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21170 std::string ex(str, iter.base());
21171 assert(ex == "********************1E+09");
21172 assert(ios.width() == 0);
21173 }
21174 ios.width(25);
21175 internal(ios);
21176 {
21177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21178 std::string ex(str, iter.base());
21179 assert(ex == "********************1E+09");
21180 assert(ios.width() == 0);
21181 }
21182 }
21183 ios.imbue(lg);
21184 {
21185 ios.width(0);
21186 {
21187 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21188 std::string ex(str, iter.base());
21189 assert(ex == "1E+09");
21190 assert(ios.width() == 0);
21191 }
21192 ios.width(25);
21193 left(ios);
21194 {
21195 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21196 std::string ex(str, iter.base());
21197 assert(ex == "1E+09********************");
21198 assert(ios.width() == 0);
21199 }
21200 ios.width(25);
21201 right(ios);
21202 {
21203 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21204 std::string ex(str, iter.base());
21205 assert(ex == "********************1E+09");
21206 assert(ios.width() == 0);
21207 }
21208 ios.width(25);
21209 internal(ios);
21210 {
21211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21212 std::string ex(str, iter.base());
21213 assert(ex == "********************1E+09");
21214 assert(ios.width() == 0);
21215 }
21216 }
21217 }
21218 showpoint(ios);
21219 {
21220 ios.imbue(lc);
21221 {
21222 ios.width(0);
21223 {
21224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21225 std::string ex(str, iter.base());
21226 assert(ex == "1.E+09");
21227 assert(ios.width() == 0);
21228 }
21229 ios.width(25);
21230 left(ios);
21231 {
21232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21233 std::string ex(str, iter.base());
21234 assert(ex == "1.E+09*******************");
21235 assert(ios.width() == 0);
21236 }
21237 ios.width(25);
21238 right(ios);
21239 {
21240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21241 std::string ex(str, iter.base());
21242 assert(ex == "*******************1.E+09");
21243 assert(ios.width() == 0);
21244 }
21245 ios.width(25);
21246 internal(ios);
21247 {
21248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21249 std::string ex(str, iter.base());
21250 assert(ex == "*******************1.E+09");
21251 assert(ios.width() == 0);
21252 }
21253 }
21254 ios.imbue(lg);
21255 {
21256 ios.width(0);
21257 {
21258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21259 std::string ex(str, iter.base());
21260 assert(ex == "1;E+09");
21261 assert(ios.width() == 0);
21262 }
21263 ios.width(25);
21264 left(ios);
21265 {
21266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21267 std::string ex(str, iter.base());
21268 assert(ex == "1;E+09*******************");
21269 assert(ios.width() == 0);
21270 }
21271 ios.width(25);
21272 right(ios);
21273 {
21274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21275 std::string ex(str, iter.base());
21276 assert(ex == "*******************1;E+09");
21277 assert(ios.width() == 0);
21278 }
21279 ios.width(25);
21280 internal(ios);
21281 {
21282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21283 std::string ex(str, iter.base());
21284 assert(ex == "*******************1;E+09");
21285 assert(ios.width() == 0);
21286 }
21287 }
21288 }
21289 }
21290 showpos(ios);
21291 {
21292 noshowpoint(ios);
21293 {
21294 ios.imbue(lc);
21295 {
21296 ios.width(0);
21297 {
21298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21299 std::string ex(str, iter.base());
21300 assert(ex == "+1E+09");
21301 assert(ios.width() == 0);
21302 }
21303 ios.width(25);
21304 left(ios);
21305 {
21306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21307 std::string ex(str, iter.base());
21308 assert(ex == "+1E+09*******************");
21309 assert(ios.width() == 0);
21310 }
21311 ios.width(25);
21312 right(ios);
21313 {
21314 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21315 std::string ex(str, iter.base());
21316 assert(ex == "*******************+1E+09");
21317 assert(ios.width() == 0);
21318 }
21319 ios.width(25);
21320 internal(ios);
21321 {
21322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21323 std::string ex(str, iter.base());
21324 assert(ex == "+*******************1E+09");
21325 assert(ios.width() == 0);
21326 }
21327 }
21328 ios.imbue(lg);
21329 {
21330 ios.width(0);
21331 {
21332 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21333 std::string ex(str, iter.base());
21334 assert(ex == "+1E+09");
21335 assert(ios.width() == 0);
21336 }
21337 ios.width(25);
21338 left(ios);
21339 {
21340 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21341 std::string ex(str, iter.base());
21342 assert(ex == "+1E+09*******************");
21343 assert(ios.width() == 0);
21344 }
21345 ios.width(25);
21346 right(ios);
21347 {
21348 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21349 std::string ex(str, iter.base());
21350 assert(ex == "*******************+1E+09");
21351 assert(ios.width() == 0);
21352 }
21353 ios.width(25);
21354 internal(ios);
21355 {
21356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21357 std::string ex(str, iter.base());
21358 assert(ex == "+*******************1E+09");
21359 assert(ios.width() == 0);
21360 }
21361 }
21362 }
21363 showpoint(ios);
21364 {
21365 ios.imbue(lc);
21366 {
21367 ios.width(0);
21368 {
21369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21370 std::string ex(str, iter.base());
21371 assert(ex == "+1.E+09");
21372 assert(ios.width() == 0);
21373 }
21374 ios.width(25);
21375 left(ios);
21376 {
21377 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21378 std::string ex(str, iter.base());
21379 assert(ex == "+1.E+09******************");
21380 assert(ios.width() == 0);
21381 }
21382 ios.width(25);
21383 right(ios);
21384 {
21385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21386 std::string ex(str, iter.base());
21387 assert(ex == "******************+1.E+09");
21388 assert(ios.width() == 0);
21389 }
21390 ios.width(25);
21391 internal(ios);
21392 {
21393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21394 std::string ex(str, iter.base());
21395 assert(ex == "+******************1.E+09");
21396 assert(ios.width() == 0);
21397 }
21398 }
21399 ios.imbue(lg);
21400 {
21401 ios.width(0);
21402 {
21403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21404 std::string ex(str, iter.base());
21405 assert(ex == "+1;E+09");
21406 assert(ios.width() == 0);
21407 }
21408 ios.width(25);
21409 left(ios);
21410 {
21411 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21412 std::string ex(str, iter.base());
21413 assert(ex == "+1;E+09******************");
21414 assert(ios.width() == 0);
21415 }
21416 ios.width(25);
21417 right(ios);
21418 {
21419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21420 std::string ex(str, iter.base());
21421 assert(ex == "******************+1;E+09");
21422 assert(ios.width() == 0);
21423 }
21424 ios.width(25);
21425 internal(ios);
21426 {
21427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21428 std::string ex(str, iter.base());
21429 assert(ex == "+******************1;E+09");
21430 assert(ios.width() == 0);
21431 }
21432 }
21433 }
21434 }
21435 }
21436 }
21437 ios.precision(1);
21438 {
21439 nouppercase(ios);
21440 {
21441 noshowpos(ios);
21442 {
21443 noshowpoint(ios);
21444 {
21445 ios.imbue(lc);
21446 {
21447 ios.width(0);
21448 {
21449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21450 std::string ex(str, iter.base());
21451 assert(ex == "1.2e+09");
21452 assert(ios.width() == 0);
21453 }
21454 ios.width(25);
21455 left(ios);
21456 {
21457 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21458 std::string ex(str, iter.base());
21459 assert(ex == "1.2e+09******************");
21460 assert(ios.width() == 0);
21461 }
21462 ios.width(25);
21463 right(ios);
21464 {
21465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21466 std::string ex(str, iter.base());
21467 assert(ex == "******************1.2e+09");
21468 assert(ios.width() == 0);
21469 }
21470 ios.width(25);
21471 internal(ios);
21472 {
21473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21474 std::string ex(str, iter.base());
21475 assert(ex == "******************1.2e+09");
21476 assert(ios.width() == 0);
21477 }
21478 }
21479 ios.imbue(lg);
21480 {
21481 ios.width(0);
21482 {
21483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21484 std::string ex(str, iter.base());
21485 assert(ex == "1;2e+09");
21486 assert(ios.width() == 0);
21487 }
21488 ios.width(25);
21489 left(ios);
21490 {
21491 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21492 std::string ex(str, iter.base());
21493 assert(ex == "1;2e+09******************");
21494 assert(ios.width() == 0);
21495 }
21496 ios.width(25);
21497 right(ios);
21498 {
21499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21500 std::string ex(str, iter.base());
21501 assert(ex == "******************1;2e+09");
21502 assert(ios.width() == 0);
21503 }
21504 ios.width(25);
21505 internal(ios);
21506 {
21507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21508 std::string ex(str, iter.base());
21509 assert(ex == "******************1;2e+09");
21510 assert(ios.width() == 0);
21511 }
21512 }
21513 }
21514 showpoint(ios);
21515 {
21516 ios.imbue(lc);
21517 {
21518 ios.width(0);
21519 {
21520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21521 std::string ex(str, iter.base());
21522 assert(ex == "1.2e+09");
21523 assert(ios.width() == 0);
21524 }
21525 ios.width(25);
21526 left(ios);
21527 {
21528 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21529 std::string ex(str, iter.base());
21530 assert(ex == "1.2e+09******************");
21531 assert(ios.width() == 0);
21532 }
21533 ios.width(25);
21534 right(ios);
21535 {
21536 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21537 std::string ex(str, iter.base());
21538 assert(ex == "******************1.2e+09");
21539 assert(ios.width() == 0);
21540 }
21541 ios.width(25);
21542 internal(ios);
21543 {
21544 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21545 std::string ex(str, iter.base());
21546 assert(ex == "******************1.2e+09");
21547 assert(ios.width() == 0);
21548 }
21549 }
21550 ios.imbue(lg);
21551 {
21552 ios.width(0);
21553 {
21554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21555 std::string ex(str, iter.base());
21556 assert(ex == "1;2e+09");
21557 assert(ios.width() == 0);
21558 }
21559 ios.width(25);
21560 left(ios);
21561 {
21562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21563 std::string ex(str, iter.base());
21564 assert(ex == "1;2e+09******************");
21565 assert(ios.width() == 0);
21566 }
21567 ios.width(25);
21568 right(ios);
21569 {
21570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21571 std::string ex(str, iter.base());
21572 assert(ex == "******************1;2e+09");
21573 assert(ios.width() == 0);
21574 }
21575 ios.width(25);
21576 internal(ios);
21577 {
21578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21579 std::string ex(str, iter.base());
21580 assert(ex == "******************1;2e+09");
21581 assert(ios.width() == 0);
21582 }
21583 }
21584 }
21585 }
21586 showpos(ios);
21587 {
21588 noshowpoint(ios);
21589 {
21590 ios.imbue(lc);
21591 {
21592 ios.width(0);
21593 {
21594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21595 std::string ex(str, iter.base());
21596 assert(ex == "+1.2e+09");
21597 assert(ios.width() == 0);
21598 }
21599 ios.width(25);
21600 left(ios);
21601 {
21602 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21603 std::string ex(str, iter.base());
21604 assert(ex == "+1.2e+09*****************");
21605 assert(ios.width() == 0);
21606 }
21607 ios.width(25);
21608 right(ios);
21609 {
21610 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21611 std::string ex(str, iter.base());
21612 assert(ex == "*****************+1.2e+09");
21613 assert(ios.width() == 0);
21614 }
21615 ios.width(25);
21616 internal(ios);
21617 {
21618 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21619 std::string ex(str, iter.base());
21620 assert(ex == "+*****************1.2e+09");
21621 assert(ios.width() == 0);
21622 }
21623 }
21624 ios.imbue(lg);
21625 {
21626 ios.width(0);
21627 {
21628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21629 std::string ex(str, iter.base());
21630 assert(ex == "+1;2e+09");
21631 assert(ios.width() == 0);
21632 }
21633 ios.width(25);
21634 left(ios);
21635 {
21636 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21637 std::string ex(str, iter.base());
21638 assert(ex == "+1;2e+09*****************");
21639 assert(ios.width() == 0);
21640 }
21641 ios.width(25);
21642 right(ios);
21643 {
21644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21645 std::string ex(str, iter.base());
21646 assert(ex == "*****************+1;2e+09");
21647 assert(ios.width() == 0);
21648 }
21649 ios.width(25);
21650 internal(ios);
21651 {
21652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21653 std::string ex(str, iter.base());
21654 assert(ex == "+*****************1;2e+09");
21655 assert(ios.width() == 0);
21656 }
21657 }
21658 }
21659 showpoint(ios);
21660 {
21661 ios.imbue(lc);
21662 {
21663 ios.width(0);
21664 {
21665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21666 std::string ex(str, iter.base());
21667 assert(ex == "+1.2e+09");
21668 assert(ios.width() == 0);
21669 }
21670 ios.width(25);
21671 left(ios);
21672 {
21673 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21674 std::string ex(str, iter.base());
21675 assert(ex == "+1.2e+09*****************");
21676 assert(ios.width() == 0);
21677 }
21678 ios.width(25);
21679 right(ios);
21680 {
21681 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21682 std::string ex(str, iter.base());
21683 assert(ex == "*****************+1.2e+09");
21684 assert(ios.width() == 0);
21685 }
21686 ios.width(25);
21687 internal(ios);
21688 {
21689 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21690 std::string ex(str, iter.base());
21691 assert(ex == "+*****************1.2e+09");
21692 assert(ios.width() == 0);
21693 }
21694 }
21695 ios.imbue(lg);
21696 {
21697 ios.width(0);
21698 {
21699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21700 std::string ex(str, iter.base());
21701 assert(ex == "+1;2e+09");
21702 assert(ios.width() == 0);
21703 }
21704 ios.width(25);
21705 left(ios);
21706 {
21707 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21708 std::string ex(str, iter.base());
21709 assert(ex == "+1;2e+09*****************");
21710 assert(ios.width() == 0);
21711 }
21712 ios.width(25);
21713 right(ios);
21714 {
21715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21716 std::string ex(str, iter.base());
21717 assert(ex == "*****************+1;2e+09");
21718 assert(ios.width() == 0);
21719 }
21720 ios.width(25);
21721 internal(ios);
21722 {
21723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21724 std::string ex(str, iter.base());
21725 assert(ex == "+*****************1;2e+09");
21726 assert(ios.width() == 0);
21727 }
21728 }
21729 }
21730 }
21731 }
21732 uppercase(ios);
21733 {
21734 noshowpos(ios);
21735 {
21736 noshowpoint(ios);
21737 {
21738 ios.imbue(lc);
21739 {
21740 ios.width(0);
21741 {
21742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21743 std::string ex(str, iter.base());
21744 assert(ex == "1.2E+09");
21745 assert(ios.width() == 0);
21746 }
21747 ios.width(25);
21748 left(ios);
21749 {
21750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21751 std::string ex(str, iter.base());
21752 assert(ex == "1.2E+09******************");
21753 assert(ios.width() == 0);
21754 }
21755 ios.width(25);
21756 right(ios);
21757 {
21758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21759 std::string ex(str, iter.base());
21760 assert(ex == "******************1.2E+09");
21761 assert(ios.width() == 0);
21762 }
21763 ios.width(25);
21764 internal(ios);
21765 {
21766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21767 std::string ex(str, iter.base());
21768 assert(ex == "******************1.2E+09");
21769 assert(ios.width() == 0);
21770 }
21771 }
21772 ios.imbue(lg);
21773 {
21774 ios.width(0);
21775 {
21776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21777 std::string ex(str, iter.base());
21778 assert(ex == "1;2E+09");
21779 assert(ios.width() == 0);
21780 }
21781 ios.width(25);
21782 left(ios);
21783 {
21784 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21785 std::string ex(str, iter.base());
21786 assert(ex == "1;2E+09******************");
21787 assert(ios.width() == 0);
21788 }
21789 ios.width(25);
21790 right(ios);
21791 {
21792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21793 std::string ex(str, iter.base());
21794 assert(ex == "******************1;2E+09");
21795 assert(ios.width() == 0);
21796 }
21797 ios.width(25);
21798 internal(ios);
21799 {
21800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21801 std::string ex(str, iter.base());
21802 assert(ex == "******************1;2E+09");
21803 assert(ios.width() == 0);
21804 }
21805 }
21806 }
21807 showpoint(ios);
21808 {
21809 ios.imbue(lc);
21810 {
21811 ios.width(0);
21812 {
21813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21814 std::string ex(str, iter.base());
21815 assert(ex == "1.2E+09");
21816 assert(ios.width() == 0);
21817 }
21818 ios.width(25);
21819 left(ios);
21820 {
21821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21822 std::string ex(str, iter.base());
21823 assert(ex == "1.2E+09******************");
21824 assert(ios.width() == 0);
21825 }
21826 ios.width(25);
21827 right(ios);
21828 {
21829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21830 std::string ex(str, iter.base());
21831 assert(ex == "******************1.2E+09");
21832 assert(ios.width() == 0);
21833 }
21834 ios.width(25);
21835 internal(ios);
21836 {
21837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21838 std::string ex(str, iter.base());
21839 assert(ex == "******************1.2E+09");
21840 assert(ios.width() == 0);
21841 }
21842 }
21843 ios.imbue(lg);
21844 {
21845 ios.width(0);
21846 {
21847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21848 std::string ex(str, iter.base());
21849 assert(ex == "1;2E+09");
21850 assert(ios.width() == 0);
21851 }
21852 ios.width(25);
21853 left(ios);
21854 {
21855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21856 std::string ex(str, iter.base());
21857 assert(ex == "1;2E+09******************");
21858 assert(ios.width() == 0);
21859 }
21860 ios.width(25);
21861 right(ios);
21862 {
21863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21864 std::string ex(str, iter.base());
21865 assert(ex == "******************1;2E+09");
21866 assert(ios.width() == 0);
21867 }
21868 ios.width(25);
21869 internal(ios);
21870 {
21871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21872 std::string ex(str, iter.base());
21873 assert(ex == "******************1;2E+09");
21874 assert(ios.width() == 0);
21875 }
21876 }
21877 }
21878 }
21879 showpos(ios);
21880 {
21881 noshowpoint(ios);
21882 {
21883 ios.imbue(lc);
21884 {
21885 ios.width(0);
21886 {
21887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21888 std::string ex(str, iter.base());
21889 assert(ex == "+1.2E+09");
21890 assert(ios.width() == 0);
21891 }
21892 ios.width(25);
21893 left(ios);
21894 {
21895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21896 std::string ex(str, iter.base());
21897 assert(ex == "+1.2E+09*****************");
21898 assert(ios.width() == 0);
21899 }
21900 ios.width(25);
21901 right(ios);
21902 {
21903 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21904 std::string ex(str, iter.base());
21905 assert(ex == "*****************+1.2E+09");
21906 assert(ios.width() == 0);
21907 }
21908 ios.width(25);
21909 internal(ios);
21910 {
21911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21912 std::string ex(str, iter.base());
21913 assert(ex == "+*****************1.2E+09");
21914 assert(ios.width() == 0);
21915 }
21916 }
21917 ios.imbue(lg);
21918 {
21919 ios.width(0);
21920 {
21921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21922 std::string ex(str, iter.base());
21923 assert(ex == "+1;2E+09");
21924 assert(ios.width() == 0);
21925 }
21926 ios.width(25);
21927 left(ios);
21928 {
21929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21930 std::string ex(str, iter.base());
21931 assert(ex == "+1;2E+09*****************");
21932 assert(ios.width() == 0);
21933 }
21934 ios.width(25);
21935 right(ios);
21936 {
21937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21938 std::string ex(str, iter.base());
21939 assert(ex == "*****************+1;2E+09");
21940 assert(ios.width() == 0);
21941 }
21942 ios.width(25);
21943 internal(ios);
21944 {
21945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21946 std::string ex(str, iter.base());
21947 assert(ex == "+*****************1;2E+09");
21948 assert(ios.width() == 0);
21949 }
21950 }
21951 }
21952 showpoint(ios);
21953 {
21954 ios.imbue(lc);
21955 {
21956 ios.width(0);
21957 {
21958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21959 std::string ex(str, iter.base());
21960 assert(ex == "+1.2E+09");
21961 assert(ios.width() == 0);
21962 }
21963 ios.width(25);
21964 left(ios);
21965 {
21966 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21967 std::string ex(str, iter.base());
21968 assert(ex == "+1.2E+09*****************");
21969 assert(ios.width() == 0);
21970 }
21971 ios.width(25);
21972 right(ios);
21973 {
21974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21975 std::string ex(str, iter.base());
21976 assert(ex == "*****************+1.2E+09");
21977 assert(ios.width() == 0);
21978 }
21979 ios.width(25);
21980 internal(ios);
21981 {
21982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21983 std::string ex(str, iter.base());
21984 assert(ex == "+*****************1.2E+09");
21985 assert(ios.width() == 0);
21986 }
21987 }
21988 ios.imbue(lg);
21989 {
21990 ios.width(0);
21991 {
21992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21993 std::string ex(str, iter.base());
21994 assert(ex == "+1;2E+09");
21995 assert(ios.width() == 0);
21996 }
21997 ios.width(25);
21998 left(ios);
21999 {
22000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22001 std::string ex(str, iter.base());
22002 assert(ex == "+1;2E+09*****************");
22003 assert(ios.width() == 0);
22004 }
22005 ios.width(25);
22006 right(ios);
22007 {
22008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22009 std::string ex(str, iter.base());
22010 assert(ex == "*****************+1;2E+09");
22011 assert(ios.width() == 0);
22012 }
22013 ios.width(25);
22014 internal(ios);
22015 {
22016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22017 std::string ex(str, iter.base());
22018 assert(ex == "+*****************1;2E+09");
22019 assert(ios.width() == 0);
22020 }
22021 }
22022 }
22023 }
22024 }
22025 }
22026 ios.precision(6);
22027 {
22028 }
22029 ios.precision(16);
22030 {
22031 }
22032 ios.precision(60);
22033 {
22034 nouppercase(ios);
22035 {
22036 noshowpos(ios);
22037 {
22038 noshowpoint(ios);
22039 {
22040 ios.imbue(lc);
22041 {
22042 ios.width(0);
22043 {
22044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22045 std::string ex(str, iter.base());
22046 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22047 assert(ios.width() == 0);
22048 }
22049 ios.width(25);
22050 left(ios);
22051 {
22052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22053 std::string ex(str, iter.base());
22054 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22055 assert(ios.width() == 0);
22056 }
22057 ios.width(25);
22058 right(ios);
22059 {
22060 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22061 std::string ex(str, iter.base());
22062 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22063 assert(ios.width() == 0);
22064 }
22065 ios.width(25);
22066 internal(ios);
22067 {
22068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22069 std::string ex(str, iter.base());
22070 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22071 assert(ios.width() == 0);
22072 }
22073 }
22074 ios.imbue(lg);
22075 {
22076 ios.width(0);
22077 {
22078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22079 std::string ex(str, iter.base());
22080 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22081 assert(ios.width() == 0);
22082 }
22083 ios.width(25);
22084 left(ios);
22085 {
22086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22087 std::string ex(str, iter.base());
22088 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22089 assert(ios.width() == 0);
22090 }
22091 ios.width(25);
22092 right(ios);
22093 {
22094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22095 std::string ex(str, iter.base());
22096 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22097 assert(ios.width() == 0);
22098 }
22099 ios.width(25);
22100 internal(ios);
22101 {
22102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22103 std::string ex(str, iter.base());
22104 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22105 assert(ios.width() == 0);
22106 }
22107 }
22108 }
22109 showpoint(ios);
22110 {
22111 ios.imbue(lc);
22112 {
22113 ios.width(0);
22114 {
22115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22116 std::string ex(str, iter.base());
22117 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22118 assert(ios.width() == 0);
22119 }
22120 ios.width(25);
22121 left(ios);
22122 {
22123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22124 std::string ex(str, iter.base());
22125 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22126 assert(ios.width() == 0);
22127 }
22128 ios.width(25);
22129 right(ios);
22130 {
22131 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22132 std::string ex(str, iter.base());
22133 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22134 assert(ios.width() == 0);
22135 }
22136 ios.width(25);
22137 internal(ios);
22138 {
22139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22140 std::string ex(str, iter.base());
22141 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22142 assert(ios.width() == 0);
22143 }
22144 }
22145 ios.imbue(lg);
22146 {
22147 ios.width(0);
22148 {
22149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22150 std::string ex(str, iter.base());
22151 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22152 assert(ios.width() == 0);
22153 }
22154 ios.width(25);
22155 left(ios);
22156 {
22157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22158 std::string ex(str, iter.base());
22159 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22160 assert(ios.width() == 0);
22161 }
22162 ios.width(25);
22163 right(ios);
22164 {
22165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22166 std::string ex(str, iter.base());
22167 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22168 assert(ios.width() == 0);
22169 }
22170 ios.width(25);
22171 internal(ios);
22172 {
22173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22174 std::string ex(str, iter.base());
22175 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22176 assert(ios.width() == 0);
22177 }
22178 }
22179 }
22180 }
22181 showpos(ios);
22182 {
22183 noshowpoint(ios);
22184 {
22185 ios.imbue(lc);
22186 {
22187 ios.width(0);
22188 {
22189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22190 std::string ex(str, iter.base());
22191 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22192 assert(ios.width() == 0);
22193 }
22194 ios.width(25);
22195 left(ios);
22196 {
22197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22198 std::string ex(str, iter.base());
22199 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22200 assert(ios.width() == 0);
22201 }
22202 ios.width(25);
22203 right(ios);
22204 {
22205 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22206 std::string ex(str, iter.base());
22207 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22208 assert(ios.width() == 0);
22209 }
22210 ios.width(25);
22211 internal(ios);
22212 {
22213 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22214 std::string ex(str, iter.base());
22215 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22216 assert(ios.width() == 0);
22217 }
22218 }
22219 ios.imbue(lg);
22220 {
22221 ios.width(0);
22222 {
22223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22224 std::string ex(str, iter.base());
22225 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22226 assert(ios.width() == 0);
22227 }
22228 ios.width(25);
22229 left(ios);
22230 {
22231 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22232 std::string ex(str, iter.base());
22233 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22234 assert(ios.width() == 0);
22235 }
22236 ios.width(25);
22237 right(ios);
22238 {
22239 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22240 std::string ex(str, iter.base());
22241 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22242 assert(ios.width() == 0);
22243 }
22244 ios.width(25);
22245 internal(ios);
22246 {
22247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22248 std::string ex(str, iter.base());
22249 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22250 assert(ios.width() == 0);
22251 }
22252 }
22253 }
22254 showpoint(ios);
22255 {
22256 ios.imbue(lc);
22257 {
22258 ios.width(0);
22259 {
22260 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22261 std::string ex(str, iter.base());
22262 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22263 assert(ios.width() == 0);
22264 }
22265 ios.width(25);
22266 left(ios);
22267 {
22268 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22269 std::string ex(str, iter.base());
22270 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22271 assert(ios.width() == 0);
22272 }
22273 ios.width(25);
22274 right(ios);
22275 {
22276 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22277 std::string ex(str, iter.base());
22278 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22279 assert(ios.width() == 0);
22280 }
22281 ios.width(25);
22282 internal(ios);
22283 {
22284 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22285 std::string ex(str, iter.base());
22286 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22287 assert(ios.width() == 0);
22288 }
22289 }
22290 ios.imbue(lg);
22291 {
22292 ios.width(0);
22293 {
22294 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22295 std::string ex(str, iter.base());
22296 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22297 assert(ios.width() == 0);
22298 }
22299 ios.width(25);
22300 left(ios);
22301 {
22302 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22303 std::string ex(str, iter.base());
22304 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22305 assert(ios.width() == 0);
22306 }
22307 ios.width(25);
22308 right(ios);
22309 {
22310 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22311 std::string ex(str, iter.base());
22312 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22313 assert(ios.width() == 0);
22314 }
22315 ios.width(25);
22316 internal(ios);
22317 {
22318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22319 std::string ex(str, iter.base());
22320 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22321 assert(ios.width() == 0);
22322 }
22323 }
22324 }
22325 }
22326 }
22327 uppercase(ios);
22328 {
22329 noshowpos(ios);
22330 {
22331 noshowpoint(ios);
22332 {
22333 ios.imbue(lc);
22334 {
22335 ios.width(0);
22336 {
22337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22338 std::string ex(str, iter.base());
22339 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22340 assert(ios.width() == 0);
22341 }
22342 ios.width(25);
22343 left(ios);
22344 {
22345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22346 std::string ex(str, iter.base());
22347 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22348 assert(ios.width() == 0);
22349 }
22350 ios.width(25);
22351 right(ios);
22352 {
22353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22354 std::string ex(str, iter.base());
22355 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22356 assert(ios.width() == 0);
22357 }
22358 ios.width(25);
22359 internal(ios);
22360 {
22361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22362 std::string ex(str, iter.base());
22363 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22364 assert(ios.width() == 0);
22365 }
22366 }
22367 ios.imbue(lg);
22368 {
22369 ios.width(0);
22370 {
22371 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22372 std::string ex(str, iter.base());
22373 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22374 assert(ios.width() == 0);
22375 }
22376 ios.width(25);
22377 left(ios);
22378 {
22379 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22380 std::string ex(str, iter.base());
22381 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22382 assert(ios.width() == 0);
22383 }
22384 ios.width(25);
22385 right(ios);
22386 {
22387 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22388 std::string ex(str, iter.base());
22389 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22390 assert(ios.width() == 0);
22391 }
22392 ios.width(25);
22393 internal(ios);
22394 {
22395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22396 std::string ex(str, iter.base());
22397 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22398 assert(ios.width() == 0);
22399 }
22400 }
22401 }
22402 showpoint(ios);
22403 {
22404 ios.imbue(lc);
22405 {
22406 ios.width(0);
22407 {
22408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22409 std::string ex(str, iter.base());
22410 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22411 assert(ios.width() == 0);
22412 }
22413 ios.width(25);
22414 left(ios);
22415 {
22416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22417 std::string ex(str, iter.base());
22418 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22419 assert(ios.width() == 0);
22420 }
22421 ios.width(25);
22422 right(ios);
22423 {
22424 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22425 std::string ex(str, iter.base());
22426 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22427 assert(ios.width() == 0);
22428 }
22429 ios.width(25);
22430 internal(ios);
22431 {
22432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22433 std::string ex(str, iter.base());
22434 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22435 assert(ios.width() == 0);
22436 }
22437 }
22438 ios.imbue(lg);
22439 {
22440 ios.width(0);
22441 {
22442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22443 std::string ex(str, iter.base());
22444 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22445 assert(ios.width() == 0);
22446 }
22447 ios.width(25);
22448 left(ios);
22449 {
22450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22451 std::string ex(str, iter.base());
22452 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22453 assert(ios.width() == 0);
22454 }
22455 ios.width(25);
22456 right(ios);
22457 {
22458 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22459 std::string ex(str, iter.base());
22460 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22461 assert(ios.width() == 0);
22462 }
22463 ios.width(25);
22464 internal(ios);
22465 {
22466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22467 std::string ex(str, iter.base());
22468 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22469 assert(ios.width() == 0);
22470 }
22471 }
22472 }
22473 }
22474 showpos(ios);
22475 {
22476 noshowpoint(ios);
22477 {
22478 ios.imbue(lc);
22479 {
22480 ios.width(0);
22481 {
22482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22483 std::string ex(str, iter.base());
22484 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22485 assert(ios.width() == 0);
22486 }
22487 ios.width(25);
22488 left(ios);
22489 {
22490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22491 std::string ex(str, iter.base());
22492 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22493 assert(ios.width() == 0);
22494 }
22495 ios.width(25);
22496 right(ios);
22497 {
22498 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22499 std::string ex(str, iter.base());
22500 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22501 assert(ios.width() == 0);
22502 }
22503 ios.width(25);
22504 internal(ios);
22505 {
22506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22507 std::string ex(str, iter.base());
22508 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22509 assert(ios.width() == 0);
22510 }
22511 }
22512 ios.imbue(lg);
22513 {
22514 ios.width(0);
22515 {
22516 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22517 std::string ex(str, iter.base());
22518 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22519 assert(ios.width() == 0);
22520 }
22521 ios.width(25);
22522 left(ios);
22523 {
22524 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22525 std::string ex(str, iter.base());
22526 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22527 assert(ios.width() == 0);
22528 }
22529 ios.width(25);
22530 right(ios);
22531 {
22532 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22533 std::string ex(str, iter.base());
22534 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22535 assert(ios.width() == 0);
22536 }
22537 ios.width(25);
22538 internal(ios);
22539 {
22540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22541 std::string ex(str, iter.base());
22542 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22543 assert(ios.width() == 0);
22544 }
22545 }
22546 }
22547 showpoint(ios);
22548 {
22549 ios.imbue(lc);
22550 {
22551 ios.width(0);
22552 {
22553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22554 std::string ex(str, iter.base());
22555 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22556 assert(ios.width() == 0);
22557 }
22558 ios.width(25);
22559 left(ios);
22560 {
22561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22562 std::string ex(str, iter.base());
22563 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22564 assert(ios.width() == 0);
22565 }
22566 ios.width(25);
22567 right(ios);
22568 {
22569 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22570 std::string ex(str, iter.base());
22571 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22572 assert(ios.width() == 0);
22573 }
22574 ios.width(25);
22575 internal(ios);
22576 {
22577 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22578 std::string ex(str, iter.base());
22579 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22580 assert(ios.width() == 0);
22581 }
22582 }
22583 ios.imbue(lg);
22584 {
22585 ios.width(0);
22586 {
22587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22588 std::string ex(str, iter.base());
22589 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22590 assert(ios.width() == 0);
22591 }
22592 ios.width(25);
22593 left(ios);
22594 {
22595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22596 std::string ex(str, iter.base());
22597 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22598 assert(ios.width() == 0);
22599 }
22600 ios.width(25);
22601 right(ios);
22602 {
22603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22604 std::string ex(str, iter.base());
22605 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22606 assert(ios.width() == 0);
22607 }
22608 ios.width(25);
22609 internal(ios);
22610 {
22611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22612 std::string ex(str, iter.base());
22613 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22614 assert(ios.width() == 0);
22615 }
22616 }
22617 }
22618 }
22619 }
22620 }
22621 }
22622 }
22623 }
22624
test11()22625 void test11()
22626 {
22627 char str[200];
22628 output_iterator<char*> iter;
22629 std::locale lc = std::locale::classic();
22630 std::locale lg(lc, new my_numpunct);
22631 const my_facet f(1);
22632 {
22633 long double v = -0.;
22634 std::ios ios(0);
22635 hexfloat(ios);
22636 // %a
22637 {
22638 ios.precision(0);
22639 {
22640 nouppercase(ios);
22641 {
22642 noshowpos(ios);
22643 {
22644 noshowpoint(ios);
22645 {
22646 ios.imbue(lc);
22647 {
22648 ios.width(0);
22649 {
22650 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22651 std::string ex(str, iter.base());
22652 assert(ex == "-0x0p+0");
22653 assert(ios.width() == 0);
22654 }
22655 ios.width(25);
22656 left(ios);
22657 {
22658 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22659 std::string ex(str, iter.base());
22660 assert(ex == "-0x0p+0******************");
22661 assert(ios.width() == 0);
22662 }
22663 ios.width(25);
22664 right(ios);
22665 {
22666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22667 std::string ex(str, iter.base());
22668 assert(ex == "******************-0x0p+0");
22669 assert(ios.width() == 0);
22670 }
22671 ios.width(25);
22672 internal(ios);
22673 {
22674 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22675 std::string ex(str, iter.base());
22676 assert(ex == "-******************0x0p+0");
22677 assert(ios.width() == 0);
22678 }
22679 }
22680 ios.imbue(lg);
22681 {
22682 ios.width(0);
22683 {
22684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22685 std::string ex(str, iter.base());
22686 assert(ex == "-0x0p+0");
22687 assert(ios.width() == 0);
22688 }
22689 ios.width(25);
22690 left(ios);
22691 {
22692 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22693 std::string ex(str, iter.base());
22694 assert(ex == "-0x0p+0******************");
22695 assert(ios.width() == 0);
22696 }
22697 ios.width(25);
22698 right(ios);
22699 {
22700 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22701 std::string ex(str, iter.base());
22702 assert(ex == "******************-0x0p+0");
22703 assert(ios.width() == 0);
22704 }
22705 ios.width(25);
22706 internal(ios);
22707 {
22708 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22709 std::string ex(str, iter.base());
22710 assert(ex == "-******************0x0p+0");
22711 assert(ios.width() == 0);
22712 }
22713 }
22714 }
22715 showpoint(ios);
22716 {
22717 ios.imbue(lc);
22718 {
22719 ios.width(0);
22720 {
22721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22722 std::string ex(str, iter.base());
22723 assert(ex == "-0x0.p+0");
22724 assert(ios.width() == 0);
22725 }
22726 ios.width(25);
22727 left(ios);
22728 {
22729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22730 std::string ex(str, iter.base());
22731 assert(ex == "-0x0.p+0*****************");
22732 assert(ios.width() == 0);
22733 }
22734 ios.width(25);
22735 right(ios);
22736 {
22737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22738 std::string ex(str, iter.base());
22739 assert(ex == "*****************-0x0.p+0");
22740 assert(ios.width() == 0);
22741 }
22742 ios.width(25);
22743 internal(ios);
22744 {
22745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22746 std::string ex(str, iter.base());
22747 assert(ex == "-*****************0x0.p+0");
22748 assert(ios.width() == 0);
22749 }
22750 }
22751 ios.imbue(lg);
22752 {
22753 ios.width(0);
22754 {
22755 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22756 std::string ex(str, iter.base());
22757 assert(ex == "-0x0;p+0");
22758 assert(ios.width() == 0);
22759 }
22760 ios.width(25);
22761 left(ios);
22762 {
22763 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22764 std::string ex(str, iter.base());
22765 assert(ex == "-0x0;p+0*****************");
22766 assert(ios.width() == 0);
22767 }
22768 ios.width(25);
22769 right(ios);
22770 {
22771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22772 std::string ex(str, iter.base());
22773 assert(ex == "*****************-0x0;p+0");
22774 assert(ios.width() == 0);
22775 }
22776 ios.width(25);
22777 internal(ios);
22778 {
22779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22780 std::string ex(str, iter.base());
22781 assert(ex == "-*****************0x0;p+0");
22782 assert(ios.width() == 0);
22783 }
22784 }
22785 }
22786 }
22787 showpos(ios);
22788 {
22789 noshowpoint(ios);
22790 {
22791 ios.imbue(lc);
22792 {
22793 ios.width(0);
22794 {
22795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22796 std::string ex(str, iter.base());
22797 assert(ex == "-0x0p+0");
22798 assert(ios.width() == 0);
22799 }
22800 ios.width(25);
22801 left(ios);
22802 {
22803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22804 std::string ex(str, iter.base());
22805 assert(ex == "-0x0p+0******************");
22806 assert(ios.width() == 0);
22807 }
22808 ios.width(25);
22809 right(ios);
22810 {
22811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22812 std::string ex(str, iter.base());
22813 assert(ex == "******************-0x0p+0");
22814 assert(ios.width() == 0);
22815 }
22816 ios.width(25);
22817 internal(ios);
22818 {
22819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22820 std::string ex(str, iter.base());
22821 assert(ex == "-******************0x0p+0");
22822 assert(ios.width() == 0);
22823 }
22824 }
22825 ios.imbue(lg);
22826 {
22827 ios.width(0);
22828 {
22829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22830 std::string ex(str, iter.base());
22831 assert(ex == "-0x0p+0");
22832 assert(ios.width() == 0);
22833 }
22834 ios.width(25);
22835 left(ios);
22836 {
22837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22838 std::string ex(str, iter.base());
22839 assert(ex == "-0x0p+0******************");
22840 assert(ios.width() == 0);
22841 }
22842 ios.width(25);
22843 right(ios);
22844 {
22845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22846 std::string ex(str, iter.base());
22847 assert(ex == "******************-0x0p+0");
22848 assert(ios.width() == 0);
22849 }
22850 ios.width(25);
22851 internal(ios);
22852 {
22853 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22854 std::string ex(str, iter.base());
22855 assert(ex == "-******************0x0p+0");
22856 assert(ios.width() == 0);
22857 }
22858 }
22859 }
22860 showpoint(ios);
22861 {
22862 ios.imbue(lc);
22863 {
22864 ios.width(0);
22865 {
22866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22867 std::string ex(str, iter.base());
22868 assert(ex == "-0x0.p+0");
22869 assert(ios.width() == 0);
22870 }
22871 ios.width(25);
22872 left(ios);
22873 {
22874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22875 std::string ex(str, iter.base());
22876 assert(ex == "-0x0.p+0*****************");
22877 assert(ios.width() == 0);
22878 }
22879 ios.width(25);
22880 right(ios);
22881 {
22882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22883 std::string ex(str, iter.base());
22884 assert(ex == "*****************-0x0.p+0");
22885 assert(ios.width() == 0);
22886 }
22887 ios.width(25);
22888 internal(ios);
22889 {
22890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22891 std::string ex(str, iter.base());
22892 assert(ex == "-*****************0x0.p+0");
22893 assert(ios.width() == 0);
22894 }
22895 }
22896 ios.imbue(lg);
22897 {
22898 ios.width(0);
22899 {
22900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22901 std::string ex(str, iter.base());
22902 assert(ex == "-0x0;p+0");
22903 assert(ios.width() == 0);
22904 }
22905 ios.width(25);
22906 left(ios);
22907 {
22908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22909 std::string ex(str, iter.base());
22910 assert(ex == "-0x0;p+0*****************");
22911 assert(ios.width() == 0);
22912 }
22913 ios.width(25);
22914 right(ios);
22915 {
22916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22917 std::string ex(str, iter.base());
22918 assert(ex == "*****************-0x0;p+0");
22919 assert(ios.width() == 0);
22920 }
22921 ios.width(25);
22922 internal(ios);
22923 {
22924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22925 std::string ex(str, iter.base());
22926 assert(ex == "-*****************0x0;p+0");
22927 assert(ios.width() == 0);
22928 }
22929 }
22930 }
22931 }
22932 }
22933 uppercase(ios);
22934 {
22935 noshowpos(ios);
22936 {
22937 noshowpoint(ios);
22938 {
22939 ios.imbue(lc);
22940 {
22941 ios.width(0);
22942 {
22943 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22944 std::string ex(str, iter.base());
22945 assert(ex == "-0X0P+0");
22946 assert(ios.width() == 0);
22947 }
22948 ios.width(25);
22949 left(ios);
22950 {
22951 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22952 std::string ex(str, iter.base());
22953 assert(ex == "-0X0P+0******************");
22954 assert(ios.width() == 0);
22955 }
22956 ios.width(25);
22957 right(ios);
22958 {
22959 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22960 std::string ex(str, iter.base());
22961 assert(ex == "******************-0X0P+0");
22962 assert(ios.width() == 0);
22963 }
22964 ios.width(25);
22965 internal(ios);
22966 {
22967 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22968 std::string ex(str, iter.base());
22969 assert(ex == "-******************0X0P+0");
22970 assert(ios.width() == 0);
22971 }
22972 }
22973 ios.imbue(lg);
22974 {
22975 ios.width(0);
22976 {
22977 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22978 std::string ex(str, iter.base());
22979 assert(ex == "-0X0P+0");
22980 assert(ios.width() == 0);
22981 }
22982 ios.width(25);
22983 left(ios);
22984 {
22985 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22986 std::string ex(str, iter.base());
22987 assert(ex == "-0X0P+0******************");
22988 assert(ios.width() == 0);
22989 }
22990 ios.width(25);
22991 right(ios);
22992 {
22993 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22994 std::string ex(str, iter.base());
22995 assert(ex == "******************-0X0P+0");
22996 assert(ios.width() == 0);
22997 }
22998 ios.width(25);
22999 internal(ios);
23000 {
23001 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23002 std::string ex(str, iter.base());
23003 assert(ex == "-******************0X0P+0");
23004 assert(ios.width() == 0);
23005 }
23006 }
23007 }
23008 showpoint(ios);
23009 {
23010 ios.imbue(lc);
23011 {
23012 ios.width(0);
23013 {
23014 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23015 std::string ex(str, iter.base());
23016 assert(ex == "-0X0.P+0");
23017 assert(ios.width() == 0);
23018 }
23019 ios.width(25);
23020 left(ios);
23021 {
23022 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23023 std::string ex(str, iter.base());
23024 assert(ex == "-0X0.P+0*****************");
23025 assert(ios.width() == 0);
23026 }
23027 ios.width(25);
23028 right(ios);
23029 {
23030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23031 std::string ex(str, iter.base());
23032 assert(ex == "*****************-0X0.P+0");
23033 assert(ios.width() == 0);
23034 }
23035 ios.width(25);
23036 internal(ios);
23037 {
23038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23039 std::string ex(str, iter.base());
23040 assert(ex == "-*****************0X0.P+0");
23041 assert(ios.width() == 0);
23042 }
23043 }
23044 ios.imbue(lg);
23045 {
23046 ios.width(0);
23047 {
23048 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23049 std::string ex(str, iter.base());
23050 assert(ex == "-0X0;P+0");
23051 assert(ios.width() == 0);
23052 }
23053 ios.width(25);
23054 left(ios);
23055 {
23056 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23057 std::string ex(str, iter.base());
23058 assert(ex == "-0X0;P+0*****************");
23059 assert(ios.width() == 0);
23060 }
23061 ios.width(25);
23062 right(ios);
23063 {
23064 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23065 std::string ex(str, iter.base());
23066 assert(ex == "*****************-0X0;P+0");
23067 assert(ios.width() == 0);
23068 }
23069 ios.width(25);
23070 internal(ios);
23071 {
23072 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23073 std::string ex(str, iter.base());
23074 assert(ex == "-*****************0X0;P+0");
23075 assert(ios.width() == 0);
23076 }
23077 }
23078 }
23079 }
23080 showpos(ios);
23081 {
23082 noshowpoint(ios);
23083 {
23084 ios.imbue(lc);
23085 {
23086 ios.width(0);
23087 {
23088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23089 std::string ex(str, iter.base());
23090 assert(ex == "-0X0P+0");
23091 assert(ios.width() == 0);
23092 }
23093 ios.width(25);
23094 left(ios);
23095 {
23096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23097 std::string ex(str, iter.base());
23098 assert(ex == "-0X0P+0******************");
23099 assert(ios.width() == 0);
23100 }
23101 ios.width(25);
23102 right(ios);
23103 {
23104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23105 std::string ex(str, iter.base());
23106 assert(ex == "******************-0X0P+0");
23107 assert(ios.width() == 0);
23108 }
23109 ios.width(25);
23110 internal(ios);
23111 {
23112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23113 std::string ex(str, iter.base());
23114 assert(ex == "-******************0X0P+0");
23115 assert(ios.width() == 0);
23116 }
23117 }
23118 ios.imbue(lg);
23119 {
23120 ios.width(0);
23121 {
23122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23123 std::string ex(str, iter.base());
23124 assert(ex == "-0X0P+0");
23125 assert(ios.width() == 0);
23126 }
23127 ios.width(25);
23128 left(ios);
23129 {
23130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23131 std::string ex(str, iter.base());
23132 assert(ex == "-0X0P+0******************");
23133 assert(ios.width() == 0);
23134 }
23135 ios.width(25);
23136 right(ios);
23137 {
23138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23139 std::string ex(str, iter.base());
23140 assert(ex == "******************-0X0P+0");
23141 assert(ios.width() == 0);
23142 }
23143 ios.width(25);
23144 internal(ios);
23145 {
23146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23147 std::string ex(str, iter.base());
23148 assert(ex == "-******************0X0P+0");
23149 assert(ios.width() == 0);
23150 }
23151 }
23152 }
23153 showpoint(ios);
23154 {
23155 ios.imbue(lc);
23156 {
23157 ios.width(0);
23158 {
23159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23160 std::string ex(str, iter.base());
23161 assert(ex == "-0X0.P+0");
23162 assert(ios.width() == 0);
23163 }
23164 ios.width(25);
23165 left(ios);
23166 {
23167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23168 std::string ex(str, iter.base());
23169 assert(ex == "-0X0.P+0*****************");
23170 assert(ios.width() == 0);
23171 }
23172 ios.width(25);
23173 right(ios);
23174 {
23175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23176 std::string ex(str, iter.base());
23177 assert(ex == "*****************-0X0.P+0");
23178 assert(ios.width() == 0);
23179 }
23180 ios.width(25);
23181 internal(ios);
23182 {
23183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23184 std::string ex(str, iter.base());
23185 assert(ex == "-*****************0X0.P+0");
23186 assert(ios.width() == 0);
23187 }
23188 }
23189 ios.imbue(lg);
23190 {
23191 ios.width(0);
23192 {
23193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23194 std::string ex(str, iter.base());
23195 assert(ex == "-0X0;P+0");
23196 assert(ios.width() == 0);
23197 }
23198 ios.width(25);
23199 left(ios);
23200 {
23201 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23202 std::string ex(str, iter.base());
23203 assert(ex == "-0X0;P+0*****************");
23204 assert(ios.width() == 0);
23205 }
23206 ios.width(25);
23207 right(ios);
23208 {
23209 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23210 std::string ex(str, iter.base());
23211 assert(ex == "*****************-0X0;P+0");
23212 assert(ios.width() == 0);
23213 }
23214 ios.width(25);
23215 internal(ios);
23216 {
23217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23218 std::string ex(str, iter.base());
23219 assert(ex == "-*****************0X0;P+0");
23220 assert(ios.width() == 0);
23221 }
23222 }
23223 }
23224 }
23225 }
23226 }
23227 ios.precision(1);
23228 {
23229 nouppercase(ios);
23230 {
23231 noshowpos(ios);
23232 {
23233 noshowpoint(ios);
23234 {
23235 ios.imbue(lc);
23236 {
23237 ios.width(0);
23238 {
23239 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23240 std::string ex(str, iter.base());
23241 assert(ex == "-0x0p+0");
23242 assert(ios.width() == 0);
23243 }
23244 ios.width(25);
23245 left(ios);
23246 {
23247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23248 std::string ex(str, iter.base());
23249 assert(ex == "-0x0p+0******************");
23250 assert(ios.width() == 0);
23251 }
23252 ios.width(25);
23253 right(ios);
23254 {
23255 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23256 std::string ex(str, iter.base());
23257 assert(ex == "******************-0x0p+0");
23258 assert(ios.width() == 0);
23259 }
23260 ios.width(25);
23261 internal(ios);
23262 {
23263 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23264 std::string ex(str, iter.base());
23265 assert(ex == "-******************0x0p+0");
23266 assert(ios.width() == 0);
23267 }
23268 }
23269 ios.imbue(lg);
23270 {
23271 ios.width(0);
23272 {
23273 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23274 std::string ex(str, iter.base());
23275 assert(ex == "-0x0p+0");
23276 assert(ios.width() == 0);
23277 }
23278 ios.width(25);
23279 left(ios);
23280 {
23281 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23282 std::string ex(str, iter.base());
23283 assert(ex == "-0x0p+0******************");
23284 assert(ios.width() == 0);
23285 }
23286 ios.width(25);
23287 right(ios);
23288 {
23289 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23290 std::string ex(str, iter.base());
23291 assert(ex == "******************-0x0p+0");
23292 assert(ios.width() == 0);
23293 }
23294 ios.width(25);
23295 internal(ios);
23296 {
23297 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23298 std::string ex(str, iter.base());
23299 assert(ex == "-******************0x0p+0");
23300 assert(ios.width() == 0);
23301 }
23302 }
23303 }
23304 showpoint(ios);
23305 {
23306 ios.imbue(lc);
23307 {
23308 ios.width(0);
23309 {
23310 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23311 std::string ex(str, iter.base());
23312 assert(ex == "-0x0.p+0");
23313 assert(ios.width() == 0);
23314 }
23315 ios.width(25);
23316 left(ios);
23317 {
23318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23319 std::string ex(str, iter.base());
23320 assert(ex == "-0x0.p+0*****************");
23321 assert(ios.width() == 0);
23322 }
23323 ios.width(25);
23324 right(ios);
23325 {
23326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23327 std::string ex(str, iter.base());
23328 assert(ex == "*****************-0x0.p+0");
23329 assert(ios.width() == 0);
23330 }
23331 ios.width(25);
23332 internal(ios);
23333 {
23334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23335 std::string ex(str, iter.base());
23336 assert(ex == "-*****************0x0.p+0");
23337 assert(ios.width() == 0);
23338 }
23339 }
23340 ios.imbue(lg);
23341 {
23342 ios.width(0);
23343 {
23344 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23345 std::string ex(str, iter.base());
23346 assert(ex == "-0x0;p+0");
23347 assert(ios.width() == 0);
23348 }
23349 ios.width(25);
23350 left(ios);
23351 {
23352 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23353 std::string ex(str, iter.base());
23354 assert(ex == "-0x0;p+0*****************");
23355 assert(ios.width() == 0);
23356 }
23357 ios.width(25);
23358 right(ios);
23359 {
23360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23361 std::string ex(str, iter.base());
23362 assert(ex == "*****************-0x0;p+0");
23363 assert(ios.width() == 0);
23364 }
23365 ios.width(25);
23366 internal(ios);
23367 {
23368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23369 std::string ex(str, iter.base());
23370 assert(ex == "-*****************0x0;p+0");
23371 assert(ios.width() == 0);
23372 }
23373 }
23374 }
23375 }
23376 showpos(ios);
23377 {
23378 noshowpoint(ios);
23379 {
23380 ios.imbue(lc);
23381 {
23382 ios.width(0);
23383 {
23384 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23385 std::string ex(str, iter.base());
23386 assert(ex == "-0x0p+0");
23387 assert(ios.width() == 0);
23388 }
23389 ios.width(25);
23390 left(ios);
23391 {
23392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23393 std::string ex(str, iter.base());
23394 assert(ex == "-0x0p+0******************");
23395 assert(ios.width() == 0);
23396 }
23397 ios.width(25);
23398 right(ios);
23399 {
23400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23401 std::string ex(str, iter.base());
23402 assert(ex == "******************-0x0p+0");
23403 assert(ios.width() == 0);
23404 }
23405 ios.width(25);
23406 internal(ios);
23407 {
23408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23409 std::string ex(str, iter.base());
23410 assert(ex == "-******************0x0p+0");
23411 assert(ios.width() == 0);
23412 }
23413 }
23414 ios.imbue(lg);
23415 {
23416 ios.width(0);
23417 {
23418 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23419 std::string ex(str, iter.base());
23420 assert(ex == "-0x0p+0");
23421 assert(ios.width() == 0);
23422 }
23423 ios.width(25);
23424 left(ios);
23425 {
23426 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23427 std::string ex(str, iter.base());
23428 assert(ex == "-0x0p+0******************");
23429 assert(ios.width() == 0);
23430 }
23431 ios.width(25);
23432 right(ios);
23433 {
23434 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23435 std::string ex(str, iter.base());
23436 assert(ex == "******************-0x0p+0");
23437 assert(ios.width() == 0);
23438 }
23439 ios.width(25);
23440 internal(ios);
23441 {
23442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23443 std::string ex(str, iter.base());
23444 assert(ex == "-******************0x0p+0");
23445 assert(ios.width() == 0);
23446 }
23447 }
23448 }
23449 showpoint(ios);
23450 {
23451 ios.imbue(lc);
23452 {
23453 ios.width(0);
23454 {
23455 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23456 std::string ex(str, iter.base());
23457 assert(ex == "-0x0.p+0");
23458 assert(ios.width() == 0);
23459 }
23460 ios.width(25);
23461 left(ios);
23462 {
23463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23464 std::string ex(str, iter.base());
23465 assert(ex == "-0x0.p+0*****************");
23466 assert(ios.width() == 0);
23467 }
23468 ios.width(25);
23469 right(ios);
23470 {
23471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23472 std::string ex(str, iter.base());
23473 assert(ex == "*****************-0x0.p+0");
23474 assert(ios.width() == 0);
23475 }
23476 ios.width(25);
23477 internal(ios);
23478 {
23479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23480 std::string ex(str, iter.base());
23481 assert(ex == "-*****************0x0.p+0");
23482 assert(ios.width() == 0);
23483 }
23484 }
23485 ios.imbue(lg);
23486 {
23487 ios.width(0);
23488 {
23489 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23490 std::string ex(str, iter.base());
23491 assert(ex == "-0x0;p+0");
23492 assert(ios.width() == 0);
23493 }
23494 ios.width(25);
23495 left(ios);
23496 {
23497 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23498 std::string ex(str, iter.base());
23499 assert(ex == "-0x0;p+0*****************");
23500 assert(ios.width() == 0);
23501 }
23502 ios.width(25);
23503 right(ios);
23504 {
23505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23506 std::string ex(str, iter.base());
23507 assert(ex == "*****************-0x0;p+0");
23508 assert(ios.width() == 0);
23509 }
23510 ios.width(25);
23511 internal(ios);
23512 {
23513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23514 std::string ex(str, iter.base());
23515 assert(ex == "-*****************0x0;p+0");
23516 assert(ios.width() == 0);
23517 }
23518 }
23519 }
23520 }
23521 }
23522 uppercase(ios);
23523 {
23524 noshowpos(ios);
23525 {
23526 noshowpoint(ios);
23527 {
23528 ios.imbue(lc);
23529 {
23530 ios.width(0);
23531 {
23532 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23533 std::string ex(str, iter.base());
23534 assert(ex == "-0X0P+0");
23535 assert(ios.width() == 0);
23536 }
23537 ios.width(25);
23538 left(ios);
23539 {
23540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23541 std::string ex(str, iter.base());
23542 assert(ex == "-0X0P+0******************");
23543 assert(ios.width() == 0);
23544 }
23545 ios.width(25);
23546 right(ios);
23547 {
23548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23549 std::string ex(str, iter.base());
23550 assert(ex == "******************-0X0P+0");
23551 assert(ios.width() == 0);
23552 }
23553 ios.width(25);
23554 internal(ios);
23555 {
23556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23557 std::string ex(str, iter.base());
23558 assert(ex == "-******************0X0P+0");
23559 assert(ios.width() == 0);
23560 }
23561 }
23562 ios.imbue(lg);
23563 {
23564 ios.width(0);
23565 {
23566 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23567 std::string ex(str, iter.base());
23568 assert(ex == "-0X0P+0");
23569 assert(ios.width() == 0);
23570 }
23571 ios.width(25);
23572 left(ios);
23573 {
23574 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23575 std::string ex(str, iter.base());
23576 assert(ex == "-0X0P+0******************");
23577 assert(ios.width() == 0);
23578 }
23579 ios.width(25);
23580 right(ios);
23581 {
23582 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23583 std::string ex(str, iter.base());
23584 assert(ex == "******************-0X0P+0");
23585 assert(ios.width() == 0);
23586 }
23587 ios.width(25);
23588 internal(ios);
23589 {
23590 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23591 std::string ex(str, iter.base());
23592 assert(ex == "-******************0X0P+0");
23593 assert(ios.width() == 0);
23594 }
23595 }
23596 }
23597 showpoint(ios);
23598 {
23599 ios.imbue(lc);
23600 {
23601 ios.width(0);
23602 {
23603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23604 std::string ex(str, iter.base());
23605 assert(ex == "-0X0.P+0");
23606 assert(ios.width() == 0);
23607 }
23608 ios.width(25);
23609 left(ios);
23610 {
23611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23612 std::string ex(str, iter.base());
23613 assert(ex == "-0X0.P+0*****************");
23614 assert(ios.width() == 0);
23615 }
23616 ios.width(25);
23617 right(ios);
23618 {
23619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23620 std::string ex(str, iter.base());
23621 assert(ex == "*****************-0X0.P+0");
23622 assert(ios.width() == 0);
23623 }
23624 ios.width(25);
23625 internal(ios);
23626 {
23627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23628 std::string ex(str, iter.base());
23629 assert(ex == "-*****************0X0.P+0");
23630 assert(ios.width() == 0);
23631 }
23632 }
23633 ios.imbue(lg);
23634 {
23635 ios.width(0);
23636 {
23637 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23638 std::string ex(str, iter.base());
23639 assert(ex == "-0X0;P+0");
23640 assert(ios.width() == 0);
23641 }
23642 ios.width(25);
23643 left(ios);
23644 {
23645 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23646 std::string ex(str, iter.base());
23647 assert(ex == "-0X0;P+0*****************");
23648 assert(ios.width() == 0);
23649 }
23650 ios.width(25);
23651 right(ios);
23652 {
23653 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23654 std::string ex(str, iter.base());
23655 assert(ex == "*****************-0X0;P+0");
23656 assert(ios.width() == 0);
23657 }
23658 ios.width(25);
23659 internal(ios);
23660 {
23661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23662 std::string ex(str, iter.base());
23663 assert(ex == "-*****************0X0;P+0");
23664 assert(ios.width() == 0);
23665 }
23666 }
23667 }
23668 }
23669 showpos(ios);
23670 {
23671 noshowpoint(ios);
23672 {
23673 ios.imbue(lc);
23674 {
23675 ios.width(0);
23676 {
23677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23678 std::string ex(str, iter.base());
23679 assert(ex == "-0X0P+0");
23680 assert(ios.width() == 0);
23681 }
23682 ios.width(25);
23683 left(ios);
23684 {
23685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23686 std::string ex(str, iter.base());
23687 assert(ex == "-0X0P+0******************");
23688 assert(ios.width() == 0);
23689 }
23690 ios.width(25);
23691 right(ios);
23692 {
23693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23694 std::string ex(str, iter.base());
23695 assert(ex == "******************-0X0P+0");
23696 assert(ios.width() == 0);
23697 }
23698 ios.width(25);
23699 internal(ios);
23700 {
23701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23702 std::string ex(str, iter.base());
23703 assert(ex == "-******************0X0P+0");
23704 assert(ios.width() == 0);
23705 }
23706 }
23707 ios.imbue(lg);
23708 {
23709 ios.width(0);
23710 {
23711 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23712 std::string ex(str, iter.base());
23713 assert(ex == "-0X0P+0");
23714 assert(ios.width() == 0);
23715 }
23716 ios.width(25);
23717 left(ios);
23718 {
23719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23720 std::string ex(str, iter.base());
23721 assert(ex == "-0X0P+0******************");
23722 assert(ios.width() == 0);
23723 }
23724 ios.width(25);
23725 right(ios);
23726 {
23727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23728 std::string ex(str, iter.base());
23729 assert(ex == "******************-0X0P+0");
23730 assert(ios.width() == 0);
23731 }
23732 ios.width(25);
23733 internal(ios);
23734 {
23735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23736 std::string ex(str, iter.base());
23737 assert(ex == "-******************0X0P+0");
23738 assert(ios.width() == 0);
23739 }
23740 }
23741 }
23742 showpoint(ios);
23743 {
23744 ios.imbue(lc);
23745 {
23746 ios.width(0);
23747 {
23748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23749 std::string ex(str, iter.base());
23750 assert(ex == "-0X0.P+0");
23751 assert(ios.width() == 0);
23752 }
23753 ios.width(25);
23754 left(ios);
23755 {
23756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23757 std::string ex(str, iter.base());
23758 assert(ex == "-0X0.P+0*****************");
23759 assert(ios.width() == 0);
23760 }
23761 ios.width(25);
23762 right(ios);
23763 {
23764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23765 std::string ex(str, iter.base());
23766 assert(ex == "*****************-0X0.P+0");
23767 assert(ios.width() == 0);
23768 }
23769 ios.width(25);
23770 internal(ios);
23771 {
23772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23773 std::string ex(str, iter.base());
23774 assert(ex == "-*****************0X0.P+0");
23775 assert(ios.width() == 0);
23776 }
23777 }
23778 ios.imbue(lg);
23779 {
23780 ios.width(0);
23781 {
23782 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23783 std::string ex(str, iter.base());
23784 assert(ex == "-0X0;P+0");
23785 assert(ios.width() == 0);
23786 }
23787 ios.width(25);
23788 left(ios);
23789 {
23790 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23791 std::string ex(str, iter.base());
23792 assert(ex == "-0X0;P+0*****************");
23793 assert(ios.width() == 0);
23794 }
23795 ios.width(25);
23796 right(ios);
23797 {
23798 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23799 std::string ex(str, iter.base());
23800 assert(ex == "*****************-0X0;P+0");
23801 assert(ios.width() == 0);
23802 }
23803 ios.width(25);
23804 internal(ios);
23805 {
23806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23807 std::string ex(str, iter.base());
23808 assert(ex == "-*****************0X0;P+0");
23809 assert(ios.width() == 0);
23810 }
23811 }
23812 }
23813 }
23814 }
23815 }
23816 ios.precision(6);
23817 {
23818 nouppercase(ios);
23819 {
23820 noshowpos(ios);
23821 {
23822 noshowpoint(ios);
23823 {
23824 ios.imbue(lc);
23825 {
23826 ios.width(0);
23827 {
23828 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23829 std::string ex(str, iter.base());
23830 assert(ex == "-0x0p+0");
23831 assert(ios.width() == 0);
23832 }
23833 ios.width(25);
23834 left(ios);
23835 {
23836 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23837 std::string ex(str, iter.base());
23838 assert(ex == "-0x0p+0******************");
23839 assert(ios.width() == 0);
23840 }
23841 ios.width(25);
23842 right(ios);
23843 {
23844 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23845 std::string ex(str, iter.base());
23846 assert(ex == "******************-0x0p+0");
23847 assert(ios.width() == 0);
23848 }
23849 ios.width(25);
23850 internal(ios);
23851 {
23852 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23853 std::string ex(str, iter.base());
23854 assert(ex == "-******************0x0p+0");
23855 assert(ios.width() == 0);
23856 }
23857 }
23858 ios.imbue(lg);
23859 {
23860 ios.width(0);
23861 {
23862 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23863 std::string ex(str, iter.base());
23864 assert(ex == "-0x0p+0");
23865 assert(ios.width() == 0);
23866 }
23867 ios.width(25);
23868 left(ios);
23869 {
23870 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23871 std::string ex(str, iter.base());
23872 assert(ex == "-0x0p+0******************");
23873 assert(ios.width() == 0);
23874 }
23875 ios.width(25);
23876 right(ios);
23877 {
23878 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23879 std::string ex(str, iter.base());
23880 assert(ex == "******************-0x0p+0");
23881 assert(ios.width() == 0);
23882 }
23883 ios.width(25);
23884 internal(ios);
23885 {
23886 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23887 std::string ex(str, iter.base());
23888 assert(ex == "-******************0x0p+0");
23889 assert(ios.width() == 0);
23890 }
23891 }
23892 }
23893 showpoint(ios);
23894 {
23895 ios.imbue(lc);
23896 {
23897 ios.width(0);
23898 {
23899 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23900 std::string ex(str, iter.base());
23901 assert(ex == "-0x0.p+0");
23902 assert(ios.width() == 0);
23903 }
23904 ios.width(25);
23905 left(ios);
23906 {
23907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23908 std::string ex(str, iter.base());
23909 assert(ex == "-0x0.p+0*****************");
23910 assert(ios.width() == 0);
23911 }
23912 ios.width(25);
23913 right(ios);
23914 {
23915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23916 std::string ex(str, iter.base());
23917 assert(ex == "*****************-0x0.p+0");
23918 assert(ios.width() == 0);
23919 }
23920 ios.width(25);
23921 internal(ios);
23922 {
23923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23924 std::string ex(str, iter.base());
23925 assert(ex == "-*****************0x0.p+0");
23926 assert(ios.width() == 0);
23927 }
23928 }
23929 ios.imbue(lg);
23930 {
23931 ios.width(0);
23932 {
23933 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23934 std::string ex(str, iter.base());
23935 assert(ex == "-0x0;p+0");
23936 assert(ios.width() == 0);
23937 }
23938 ios.width(25);
23939 left(ios);
23940 {
23941 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23942 std::string ex(str, iter.base());
23943 assert(ex == "-0x0;p+0*****************");
23944 assert(ios.width() == 0);
23945 }
23946 ios.width(25);
23947 right(ios);
23948 {
23949 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23950 std::string ex(str, iter.base());
23951 assert(ex == "*****************-0x0;p+0");
23952 assert(ios.width() == 0);
23953 }
23954 ios.width(25);
23955 internal(ios);
23956 {
23957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23958 std::string ex(str, iter.base());
23959 assert(ex == "-*****************0x0;p+0");
23960 assert(ios.width() == 0);
23961 }
23962 }
23963 }
23964 }
23965 showpos(ios);
23966 {
23967 noshowpoint(ios);
23968 {
23969 ios.imbue(lc);
23970 {
23971 ios.width(0);
23972 {
23973 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23974 std::string ex(str, iter.base());
23975 assert(ex == "-0x0p+0");
23976 assert(ios.width() == 0);
23977 }
23978 ios.width(25);
23979 left(ios);
23980 {
23981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23982 std::string ex(str, iter.base());
23983 assert(ex == "-0x0p+0******************");
23984 assert(ios.width() == 0);
23985 }
23986 ios.width(25);
23987 right(ios);
23988 {
23989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23990 std::string ex(str, iter.base());
23991 assert(ex == "******************-0x0p+0");
23992 assert(ios.width() == 0);
23993 }
23994 ios.width(25);
23995 internal(ios);
23996 {
23997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23998 std::string ex(str, iter.base());
23999 assert(ex == "-******************0x0p+0");
24000 assert(ios.width() == 0);
24001 }
24002 }
24003 ios.imbue(lg);
24004 {
24005 ios.width(0);
24006 {
24007 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24008 std::string ex(str, iter.base());
24009 assert(ex == "-0x0p+0");
24010 assert(ios.width() == 0);
24011 }
24012 ios.width(25);
24013 left(ios);
24014 {
24015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24016 std::string ex(str, iter.base());
24017 assert(ex == "-0x0p+0******************");
24018 assert(ios.width() == 0);
24019 }
24020 ios.width(25);
24021 right(ios);
24022 {
24023 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24024 std::string ex(str, iter.base());
24025 assert(ex == "******************-0x0p+0");
24026 assert(ios.width() == 0);
24027 }
24028 ios.width(25);
24029 internal(ios);
24030 {
24031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24032 std::string ex(str, iter.base());
24033 assert(ex == "-******************0x0p+0");
24034 assert(ios.width() == 0);
24035 }
24036 }
24037 }
24038 showpoint(ios);
24039 {
24040 ios.imbue(lc);
24041 {
24042 ios.width(0);
24043 {
24044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24045 std::string ex(str, iter.base());
24046 assert(ex == "-0x0.p+0");
24047 assert(ios.width() == 0);
24048 }
24049 ios.width(25);
24050 left(ios);
24051 {
24052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24053 std::string ex(str, iter.base());
24054 assert(ex == "-0x0.p+0*****************");
24055 assert(ios.width() == 0);
24056 }
24057 ios.width(25);
24058 right(ios);
24059 {
24060 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24061 std::string ex(str, iter.base());
24062 assert(ex == "*****************-0x0.p+0");
24063 assert(ios.width() == 0);
24064 }
24065 ios.width(25);
24066 internal(ios);
24067 {
24068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24069 std::string ex(str, iter.base());
24070 assert(ex == "-*****************0x0.p+0");
24071 assert(ios.width() == 0);
24072 }
24073 }
24074 ios.imbue(lg);
24075 {
24076 ios.width(0);
24077 {
24078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24079 std::string ex(str, iter.base());
24080 assert(ex == "-0x0;p+0");
24081 assert(ios.width() == 0);
24082 }
24083 ios.width(25);
24084 left(ios);
24085 {
24086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24087 std::string ex(str, iter.base());
24088 assert(ex == "-0x0;p+0*****************");
24089 assert(ios.width() == 0);
24090 }
24091 ios.width(25);
24092 right(ios);
24093 {
24094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24095 std::string ex(str, iter.base());
24096 assert(ex == "*****************-0x0;p+0");
24097 assert(ios.width() == 0);
24098 }
24099 ios.width(25);
24100 internal(ios);
24101 {
24102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24103 std::string ex(str, iter.base());
24104 assert(ex == "-*****************0x0;p+0");
24105 assert(ios.width() == 0);
24106 }
24107 }
24108 }
24109 }
24110 }
24111 uppercase(ios);
24112 {
24113 noshowpos(ios);
24114 {
24115 noshowpoint(ios);
24116 {
24117 ios.imbue(lc);
24118 {
24119 ios.width(0);
24120 {
24121 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24122 std::string ex(str, iter.base());
24123 assert(ex == "-0X0P+0");
24124 assert(ios.width() == 0);
24125 }
24126 ios.width(25);
24127 left(ios);
24128 {
24129 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24130 std::string ex(str, iter.base());
24131 assert(ex == "-0X0P+0******************");
24132 assert(ios.width() == 0);
24133 }
24134 ios.width(25);
24135 right(ios);
24136 {
24137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24138 std::string ex(str, iter.base());
24139 assert(ex == "******************-0X0P+0");
24140 assert(ios.width() == 0);
24141 }
24142 ios.width(25);
24143 internal(ios);
24144 {
24145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24146 std::string ex(str, iter.base());
24147 assert(ex == "-******************0X0P+0");
24148 assert(ios.width() == 0);
24149 }
24150 }
24151 ios.imbue(lg);
24152 {
24153 ios.width(0);
24154 {
24155 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24156 std::string ex(str, iter.base());
24157 assert(ex == "-0X0P+0");
24158 assert(ios.width() == 0);
24159 }
24160 ios.width(25);
24161 left(ios);
24162 {
24163 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24164 std::string ex(str, iter.base());
24165 assert(ex == "-0X0P+0******************");
24166 assert(ios.width() == 0);
24167 }
24168 ios.width(25);
24169 right(ios);
24170 {
24171 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24172 std::string ex(str, iter.base());
24173 assert(ex == "******************-0X0P+0");
24174 assert(ios.width() == 0);
24175 }
24176 ios.width(25);
24177 internal(ios);
24178 {
24179 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24180 std::string ex(str, iter.base());
24181 assert(ex == "-******************0X0P+0");
24182 assert(ios.width() == 0);
24183 }
24184 }
24185 }
24186 showpoint(ios);
24187 {
24188 ios.imbue(lc);
24189 {
24190 ios.width(0);
24191 {
24192 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24193 std::string ex(str, iter.base());
24194 assert(ex == "-0X0.P+0");
24195 assert(ios.width() == 0);
24196 }
24197 ios.width(25);
24198 left(ios);
24199 {
24200 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24201 std::string ex(str, iter.base());
24202 assert(ex == "-0X0.P+0*****************");
24203 assert(ios.width() == 0);
24204 }
24205 ios.width(25);
24206 right(ios);
24207 {
24208 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24209 std::string ex(str, iter.base());
24210 assert(ex == "*****************-0X0.P+0");
24211 assert(ios.width() == 0);
24212 }
24213 ios.width(25);
24214 internal(ios);
24215 {
24216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24217 std::string ex(str, iter.base());
24218 assert(ex == "-*****************0X0.P+0");
24219 assert(ios.width() == 0);
24220 }
24221 }
24222 ios.imbue(lg);
24223 {
24224 ios.width(0);
24225 {
24226 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24227 std::string ex(str, iter.base());
24228 assert(ex == "-0X0;P+0");
24229 assert(ios.width() == 0);
24230 }
24231 ios.width(25);
24232 left(ios);
24233 {
24234 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24235 std::string ex(str, iter.base());
24236 assert(ex == "-0X0;P+0*****************");
24237 assert(ios.width() == 0);
24238 }
24239 ios.width(25);
24240 right(ios);
24241 {
24242 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24243 std::string ex(str, iter.base());
24244 assert(ex == "*****************-0X0;P+0");
24245 assert(ios.width() == 0);
24246 }
24247 ios.width(25);
24248 internal(ios);
24249 {
24250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24251 std::string ex(str, iter.base());
24252 assert(ex == "-*****************0X0;P+0");
24253 assert(ios.width() == 0);
24254 }
24255 }
24256 }
24257 }
24258 showpos(ios);
24259 {
24260 noshowpoint(ios);
24261 {
24262 ios.imbue(lc);
24263 {
24264 ios.width(0);
24265 {
24266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24267 std::string ex(str, iter.base());
24268 assert(ex == "-0X0P+0");
24269 assert(ios.width() == 0);
24270 }
24271 ios.width(25);
24272 left(ios);
24273 {
24274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24275 std::string ex(str, iter.base());
24276 assert(ex == "-0X0P+0******************");
24277 assert(ios.width() == 0);
24278 }
24279 ios.width(25);
24280 right(ios);
24281 {
24282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24283 std::string ex(str, iter.base());
24284 assert(ex == "******************-0X0P+0");
24285 assert(ios.width() == 0);
24286 }
24287 ios.width(25);
24288 internal(ios);
24289 {
24290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24291 std::string ex(str, iter.base());
24292 assert(ex == "-******************0X0P+0");
24293 assert(ios.width() == 0);
24294 }
24295 }
24296 ios.imbue(lg);
24297 {
24298 ios.width(0);
24299 {
24300 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24301 std::string ex(str, iter.base());
24302 assert(ex == "-0X0P+0");
24303 assert(ios.width() == 0);
24304 }
24305 ios.width(25);
24306 left(ios);
24307 {
24308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24309 std::string ex(str, iter.base());
24310 assert(ex == "-0X0P+0******************");
24311 assert(ios.width() == 0);
24312 }
24313 ios.width(25);
24314 right(ios);
24315 {
24316 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24317 std::string ex(str, iter.base());
24318 assert(ex == "******************-0X0P+0");
24319 assert(ios.width() == 0);
24320 }
24321 ios.width(25);
24322 internal(ios);
24323 {
24324 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24325 std::string ex(str, iter.base());
24326 assert(ex == "-******************0X0P+0");
24327 assert(ios.width() == 0);
24328 }
24329 }
24330 }
24331 showpoint(ios);
24332 {
24333 ios.imbue(lc);
24334 {
24335 ios.width(0);
24336 {
24337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24338 std::string ex(str, iter.base());
24339 assert(ex == "-0X0.P+0");
24340 assert(ios.width() == 0);
24341 }
24342 ios.width(25);
24343 left(ios);
24344 {
24345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24346 std::string ex(str, iter.base());
24347 assert(ex == "-0X0.P+0*****************");
24348 assert(ios.width() == 0);
24349 }
24350 ios.width(25);
24351 right(ios);
24352 {
24353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24354 std::string ex(str, iter.base());
24355 assert(ex == "*****************-0X0.P+0");
24356 assert(ios.width() == 0);
24357 }
24358 ios.width(25);
24359 internal(ios);
24360 {
24361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24362 std::string ex(str, iter.base());
24363 assert(ex == "-*****************0X0.P+0");
24364 assert(ios.width() == 0);
24365 }
24366 }
24367 ios.imbue(lg);
24368 {
24369 ios.width(0);
24370 {
24371 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24372 std::string ex(str, iter.base());
24373 assert(ex == "-0X0;P+0");
24374 assert(ios.width() == 0);
24375 }
24376 ios.width(25);
24377 left(ios);
24378 {
24379 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24380 std::string ex(str, iter.base());
24381 assert(ex == "-0X0;P+0*****************");
24382 assert(ios.width() == 0);
24383 }
24384 ios.width(25);
24385 right(ios);
24386 {
24387 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24388 std::string ex(str, iter.base());
24389 assert(ex == "*****************-0X0;P+0");
24390 assert(ios.width() == 0);
24391 }
24392 ios.width(25);
24393 internal(ios);
24394 {
24395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24396 std::string ex(str, iter.base());
24397 assert(ex == "-*****************0X0;P+0");
24398 assert(ios.width() == 0);
24399 }
24400 }
24401 }
24402 }
24403 }
24404 }
24405 ios.precision(16);
24406 {
24407 }
24408 ios.precision(60);
24409 {
24410 }
24411 }
24412 }
24413 }
24414
test12()24415 void test12()
24416 {
24417 output_iterator<char*> iter;
24418 std::locale lc = std::locale::classic();
24419 std::locale lg(lc, new my_numpunct);
24420 #if defined(__APPLE__) && defined(__x86_64__)
24421 // This test is failing on FreeBSD, possibly due to different representations
24422 // of the floating point numbers.
24423 const my_facet f(1);
24424 char str[200];
24425 {
24426 long double v = 1234567890.125;
24427 std::ios ios(0);
24428 hexfloat(ios);
24429 // %a
24430 {
24431 ios.precision(0);
24432 {
24433 nouppercase(ios);
24434 {
24435 noshowpos(ios);
24436 {
24437 noshowpoint(ios);
24438 {
24439 ios.width(0);
24440 ios.imbue(lc);
24441 {
24442 {
24443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24444 std::string ex(str, iter.base());
24445 assert(ex == "0x9.32c05a44p+27");
24446 assert(ios.width() == 0);
24447 }
24448 ios.width(25);
24449 left(ios);
24450 {
24451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24452 std::string ex(str, iter.base());
24453 assert(ex == "0x9.32c05a44p+27*********");
24454 assert(ios.width() == 0);
24455 }
24456 ios.width(25);
24457 right(ios);
24458 {
24459 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24460 std::string ex(str, iter.base());
24461 assert(ex == "*********0x9.32c05a44p+27");
24462 assert(ios.width() == 0);
24463 }
24464 ios.width(25);
24465 internal(ios);
24466 {
24467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24468 std::string ex(str, iter.base());
24469 assert(ex == "0x*********9.32c05a44p+27");
24470 assert(ios.width() == 0);
24471 }
24472 }
24473 ios.imbue(lg);
24474 {
24475 ios.width(0);
24476 {
24477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24478 std::string ex(str, iter.base());
24479 assert(ex == "0x9;32c05a44p+27");
24480 assert(ios.width() == 0);
24481 }
24482 ios.width(25);
24483 left(ios);
24484 {
24485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24486 std::string ex(str, iter.base());
24487 assert(ex == "0x9;32c05a44p+27*********");
24488 assert(ios.width() == 0);
24489 }
24490 ios.width(25);
24491 right(ios);
24492 {
24493 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24494 std::string ex(str, iter.base());
24495 assert(ex == "*********0x9;32c05a44p+27");
24496 assert(ios.width() == 0);
24497 }
24498 ios.width(25);
24499 internal(ios);
24500 {
24501 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24502 std::string ex(str, iter.base());
24503 assert(ex == "0x*********9;32c05a44p+27");
24504 assert(ios.width() == 0);
24505 }
24506 }
24507 }
24508 showpoint(ios);
24509 {
24510 ios.imbue(lc);
24511 {
24512 ios.width(0);
24513 {
24514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24515 std::string ex(str, iter.base());
24516 assert(ex == "0x9.32c05a44p+27");
24517 assert(ios.width() == 0);
24518 }
24519 ios.width(25);
24520 left(ios);
24521 {
24522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24523 std::string ex(str, iter.base());
24524 assert(ex == "0x9.32c05a44p+27*********");
24525 assert(ios.width() == 0);
24526 }
24527 ios.width(25);
24528 right(ios);
24529 {
24530 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24531 std::string ex(str, iter.base());
24532 assert(ex == "*********0x9.32c05a44p+27");
24533 assert(ios.width() == 0);
24534 }
24535 ios.width(25);
24536 internal(ios);
24537 {
24538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24539 std::string ex(str, iter.base());
24540 assert(ex == "0x*********9.32c05a44p+27");
24541 assert(ios.width() == 0);
24542 }
24543 }
24544 ios.imbue(lg);
24545 {
24546 ios.width(0);
24547 {
24548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24549 std::string ex(str, iter.base());
24550 assert(ex == "0x9;32c05a44p+27");
24551 assert(ios.width() == 0);
24552 }
24553 ios.width(25);
24554 left(ios);
24555 {
24556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24557 std::string ex(str, iter.base());
24558 assert(ex == "0x9;32c05a44p+27*********");
24559 assert(ios.width() == 0);
24560 }
24561 ios.width(25);
24562 right(ios);
24563 {
24564 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24565 std::string ex(str, iter.base());
24566 assert(ex == "*********0x9;32c05a44p+27");
24567 assert(ios.width() == 0);
24568 }
24569 ios.width(25);
24570 internal(ios);
24571 {
24572 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24573 std::string ex(str, iter.base());
24574 assert(ex == "0x*********9;32c05a44p+27");
24575 assert(ios.width() == 0);
24576 }
24577 }
24578 }
24579 }
24580 showpos(ios);
24581 {
24582 noshowpoint(ios);
24583 {
24584 ios.imbue(lc);
24585 {
24586 ios.width(0);
24587 {
24588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24589 std::string ex(str, iter.base());
24590 assert(ex == "+0x9.32c05a44p+27");
24591 assert(ios.width() == 0);
24592 }
24593 ios.width(25);
24594 left(ios);
24595 {
24596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24597 std::string ex(str, iter.base());
24598 assert(ex == "+0x9.32c05a44p+27********");
24599 assert(ios.width() == 0);
24600 }
24601 ios.width(25);
24602 right(ios);
24603 {
24604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24605 std::string ex(str, iter.base());
24606 assert(ex == "********+0x9.32c05a44p+27");
24607 assert(ios.width() == 0);
24608 }
24609 ios.width(25);
24610 internal(ios);
24611 {
24612 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24613 std::string ex(str, iter.base());
24614 assert(ex == "+********0x9.32c05a44p+27");
24615 assert(ios.width() == 0);
24616 }
24617 }
24618 ios.imbue(lg);
24619 {
24620 ios.width(0);
24621 {
24622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24623 std::string ex(str, iter.base());
24624 assert(ex == "+0x9;32c05a44p+27");
24625 assert(ios.width() == 0);
24626 }
24627 ios.width(25);
24628 left(ios);
24629 {
24630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24631 std::string ex(str, iter.base());
24632 assert(ex == "+0x9;32c05a44p+27********");
24633 assert(ios.width() == 0);
24634 }
24635 ios.width(25);
24636 right(ios);
24637 {
24638 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24639 std::string ex(str, iter.base());
24640 assert(ex == "********+0x9;32c05a44p+27");
24641 assert(ios.width() == 0);
24642 }
24643 ios.width(25);
24644 internal(ios);
24645 {
24646 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24647 std::string ex(str, iter.base());
24648 assert(ex == "+********0x9;32c05a44p+27");
24649 assert(ios.width() == 0);
24650 }
24651 }
24652 }
24653 showpoint(ios);
24654 {
24655 ios.imbue(lc);
24656 {
24657 ios.width(0);
24658 {
24659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24660 std::string ex(str, iter.base());
24661 assert(ex == "+0x9.32c05a44p+27");
24662 assert(ios.width() == 0);
24663 }
24664 ios.width(25);
24665 left(ios);
24666 {
24667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24668 std::string ex(str, iter.base());
24669 assert(ex == "+0x9.32c05a44p+27********");
24670 assert(ios.width() == 0);
24671 }
24672 ios.width(25);
24673 right(ios);
24674 {
24675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24676 std::string ex(str, iter.base());
24677 assert(ex == "********+0x9.32c05a44p+27");
24678 assert(ios.width() == 0);
24679 }
24680 ios.width(25);
24681 internal(ios);
24682 {
24683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24684 std::string ex(str, iter.base());
24685 assert(ex == "+********0x9.32c05a44p+27");
24686 assert(ios.width() == 0);
24687 }
24688 }
24689 ios.imbue(lg);
24690 {
24691 ios.width(0);
24692 {
24693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24694 std::string ex(str, iter.base());
24695 assert(ex == "+0x9;32c05a44p+27");
24696 assert(ios.width() == 0);
24697 }
24698 ios.width(25);
24699 left(ios);
24700 {
24701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24702 std::string ex(str, iter.base());
24703 assert(ex == "+0x9;32c05a44p+27********");
24704 assert(ios.width() == 0);
24705 }
24706 ios.width(25);
24707 right(ios);
24708 {
24709 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24710 std::string ex(str, iter.base());
24711 assert(ex == "********+0x9;32c05a44p+27");
24712 assert(ios.width() == 0);
24713 }
24714 ios.width(25);
24715 internal(ios);
24716 {
24717 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24718 std::string ex(str, iter.base());
24719 assert(ex == "+********0x9;32c05a44p+27");
24720 assert(ios.width() == 0);
24721 }
24722 }
24723 }
24724 }
24725 }
24726 uppercase(ios);
24727 {
24728 noshowpos(ios);
24729 {
24730 noshowpoint(ios);
24731 {
24732 ios.imbue(lc);
24733 {
24734 ios.width(0);
24735 {
24736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24737 std::string ex(str, iter.base());
24738 assert(ex == "0X9.32C05A44P+27");
24739 assert(ios.width() == 0);
24740 }
24741 ios.width(25);
24742 left(ios);
24743 {
24744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24745 std::string ex(str, iter.base());
24746 assert(ex == "0X9.32C05A44P+27*********");
24747 assert(ios.width() == 0);
24748 }
24749 ios.width(25);
24750 right(ios);
24751 {
24752 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24753 std::string ex(str, iter.base());
24754 assert(ex == "*********0X9.32C05A44P+27");
24755 assert(ios.width() == 0);
24756 }
24757 ios.width(25);
24758 internal(ios);
24759 {
24760 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24761 std::string ex(str, iter.base());
24762 assert(ex == "0X*********9.32C05A44P+27");
24763 assert(ios.width() == 0);
24764 }
24765 }
24766 ios.imbue(lg);
24767 {
24768 ios.width(0);
24769 {
24770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24771 std::string ex(str, iter.base());
24772 assert(ex == "0X9;32C05A44P+27");
24773 assert(ios.width() == 0);
24774 }
24775 ios.width(25);
24776 left(ios);
24777 {
24778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24779 std::string ex(str, iter.base());
24780 assert(ex == "0X9;32C05A44P+27*********");
24781 assert(ios.width() == 0);
24782 }
24783 ios.width(25);
24784 right(ios);
24785 {
24786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24787 std::string ex(str, iter.base());
24788 assert(ex == "*********0X9;32C05A44P+27");
24789 assert(ios.width() == 0);
24790 }
24791 ios.width(25);
24792 internal(ios);
24793 {
24794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24795 std::string ex(str, iter.base());
24796 assert(ex == "0X*********9;32C05A44P+27");
24797 assert(ios.width() == 0);
24798 }
24799 }
24800 }
24801 showpoint(ios);
24802 {
24803 ios.imbue(lc);
24804 {
24805 ios.width(0);
24806 {
24807 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24808 std::string ex(str, iter.base());
24809 assert(ex == "0X9.32C05A44P+27");
24810 assert(ios.width() == 0);
24811 }
24812 ios.width(25);
24813 left(ios);
24814 {
24815 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24816 std::string ex(str, iter.base());
24817 assert(ex == "0X9.32C05A44P+27*********");
24818 assert(ios.width() == 0);
24819 }
24820 ios.width(25);
24821 right(ios);
24822 {
24823 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24824 std::string ex(str, iter.base());
24825 assert(ex == "*********0X9.32C05A44P+27");
24826 assert(ios.width() == 0);
24827 }
24828 ios.width(25);
24829 internal(ios);
24830 {
24831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24832 std::string ex(str, iter.base());
24833 assert(ex == "0X*********9.32C05A44P+27");
24834 assert(ios.width() == 0);
24835 }
24836 }
24837 ios.imbue(lg);
24838 {
24839 ios.width(0);
24840 {
24841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24842 std::string ex(str, iter.base());
24843 assert(ex == "0X9;32C05A44P+27");
24844 assert(ios.width() == 0);
24845 }
24846 ios.width(25);
24847 left(ios);
24848 {
24849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24850 std::string ex(str, iter.base());
24851 assert(ex == "0X9;32C05A44P+27*********");
24852 assert(ios.width() == 0);
24853 }
24854 ios.width(25);
24855 right(ios);
24856 {
24857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24858 std::string ex(str, iter.base());
24859 assert(ex == "*********0X9;32C05A44P+27");
24860 assert(ios.width() == 0);
24861 }
24862 ios.width(25);
24863 internal(ios);
24864 {
24865 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24866 std::string ex(str, iter.base());
24867 assert(ex == "0X*********9;32C05A44P+27");
24868 assert(ios.width() == 0);
24869 }
24870 }
24871 }
24872 }
24873 showpos(ios);
24874 {
24875 noshowpoint(ios);
24876 {
24877 ios.imbue(lc);
24878 {
24879 ios.width(0);
24880 {
24881 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24882 std::string ex(str, iter.base());
24883 assert(ex == "+0X9.32C05A44P+27");
24884 assert(ios.width() == 0);
24885 }
24886 ios.width(25);
24887 left(ios);
24888 {
24889 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24890 std::string ex(str, iter.base());
24891 assert(ex == "+0X9.32C05A44P+27********");
24892 assert(ios.width() == 0);
24893 }
24894 ios.width(25);
24895 right(ios);
24896 {
24897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24898 std::string ex(str, iter.base());
24899 assert(ex == "********+0X9.32C05A44P+27");
24900 assert(ios.width() == 0);
24901 }
24902 ios.width(25);
24903 internal(ios);
24904 {
24905 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24906 std::string ex(str, iter.base());
24907 assert(ex == "+********0X9.32C05A44P+27");
24908 assert(ios.width() == 0);
24909 }
24910 }
24911 ios.imbue(lg);
24912 {
24913 ios.width(0);
24914 {
24915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24916 std::string ex(str, iter.base());
24917 assert(ex == "+0X9;32C05A44P+27");
24918 assert(ios.width() == 0);
24919 }
24920 ios.width(25);
24921 left(ios);
24922 {
24923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24924 std::string ex(str, iter.base());
24925 assert(ex == "+0X9;32C05A44P+27********");
24926 assert(ios.width() == 0);
24927 }
24928 ios.width(25);
24929 right(ios);
24930 {
24931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24932 std::string ex(str, iter.base());
24933 assert(ex == "********+0X9;32C05A44P+27");
24934 assert(ios.width() == 0);
24935 }
24936 ios.width(25);
24937 internal(ios);
24938 {
24939 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24940 std::string ex(str, iter.base());
24941 assert(ex == "+********0X9;32C05A44P+27");
24942 assert(ios.width() == 0);
24943 }
24944 }
24945 }
24946 showpoint(ios);
24947 {
24948 ios.imbue(lc);
24949 {
24950 ios.width(0);
24951 {
24952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24953 std::string ex(str, iter.base());
24954 assert(ex == "+0X9.32C05A44P+27");
24955 assert(ios.width() == 0);
24956 }
24957 ios.width(25);
24958 left(ios);
24959 {
24960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24961 std::string ex(str, iter.base());
24962 assert(ex == "+0X9.32C05A44P+27********");
24963 assert(ios.width() == 0);
24964 }
24965 ios.width(25);
24966 right(ios);
24967 {
24968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24969 std::string ex(str, iter.base());
24970 assert(ex == "********+0X9.32C05A44P+27");
24971 assert(ios.width() == 0);
24972 }
24973 ios.width(25);
24974 internal(ios);
24975 {
24976 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24977 std::string ex(str, iter.base());
24978 assert(ex == "+********0X9.32C05A44P+27");
24979 assert(ios.width() == 0);
24980 }
24981 }
24982 ios.imbue(lg);
24983 {
24984 ios.width(0);
24985 {
24986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24987 std::string ex(str, iter.base());
24988 assert(ex == "+0X9;32C05A44P+27");
24989 assert(ios.width() == 0);
24990 }
24991 ios.width(25);
24992 left(ios);
24993 {
24994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24995 std::string ex(str, iter.base());
24996 assert(ex == "+0X9;32C05A44P+27********");
24997 assert(ios.width() == 0);
24998 }
24999 ios.width(25);
25000 right(ios);
25001 {
25002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25003 std::string ex(str, iter.base());
25004 assert(ex == "********+0X9;32C05A44P+27");
25005 assert(ios.width() == 0);
25006 }
25007 ios.width(25);
25008 internal(ios);
25009 {
25010 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25011 std::string ex(str, iter.base());
25012 assert(ex == "+********0X9;32C05A44P+27");
25013 assert(ios.width() == 0);
25014 }
25015 }
25016 }
25017 }
25018 }
25019 }
25020 ios.precision(1);
25021 {
25022 nouppercase(ios);
25023 {
25024 noshowpos(ios);
25025 {
25026 noshowpoint(ios);
25027 {
25028 ios.imbue(lc);
25029 {
25030 ios.width(0);
25031 {
25032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25033 std::string ex(str, iter.base());
25034 assert(ex == "0x9.32c05a44p+27");
25035 assert(ios.width() == 0);
25036 }
25037 ios.width(25);
25038 left(ios);
25039 {
25040 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25041 std::string ex(str, iter.base());
25042 assert(ex == "0x9.32c05a44p+27*********");
25043 assert(ios.width() == 0);
25044 }
25045 ios.width(25);
25046 right(ios);
25047 {
25048 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25049 std::string ex(str, iter.base());
25050 assert(ex == "*********0x9.32c05a44p+27");
25051 assert(ios.width() == 0);
25052 }
25053 ios.width(25);
25054 internal(ios);
25055 {
25056 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25057 std::string ex(str, iter.base());
25058 assert(ex == "0x*********9.32c05a44p+27");
25059 assert(ios.width() == 0);
25060 }
25061 }
25062 ios.imbue(lg);
25063 {
25064 ios.width(0);
25065 {
25066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25067 std::string ex(str, iter.base());
25068 assert(ex == "0x9;32c05a44p+27");
25069 assert(ios.width() == 0);
25070 }
25071 ios.width(25);
25072 left(ios);
25073 {
25074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25075 std::string ex(str, iter.base());
25076 assert(ex == "0x9;32c05a44p+27*********");
25077 assert(ios.width() == 0);
25078 }
25079 ios.width(25);
25080 right(ios);
25081 {
25082 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25083 std::string ex(str, iter.base());
25084 assert(ex == "*********0x9;32c05a44p+27");
25085 assert(ios.width() == 0);
25086 }
25087 ios.width(25);
25088 internal(ios);
25089 {
25090 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25091 std::string ex(str, iter.base());
25092 assert(ex == "0x*********9;32c05a44p+27");
25093 assert(ios.width() == 0);
25094 }
25095 }
25096 }
25097 showpoint(ios);
25098 {
25099 ios.imbue(lc);
25100 {
25101 ios.width(0);
25102 {
25103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25104 std::string ex(str, iter.base());
25105 assert(ex == "0x9.32c05a44p+27");
25106 assert(ios.width() == 0);
25107 }
25108 ios.width(25);
25109 left(ios);
25110 {
25111 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25112 std::string ex(str, iter.base());
25113 assert(ex == "0x9.32c05a44p+27*********");
25114 assert(ios.width() == 0);
25115 }
25116 ios.width(25);
25117 right(ios);
25118 {
25119 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25120 std::string ex(str, iter.base());
25121 assert(ex == "*********0x9.32c05a44p+27");
25122 assert(ios.width() == 0);
25123 }
25124 ios.width(25);
25125 internal(ios);
25126 {
25127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25128 std::string ex(str, iter.base());
25129 assert(ex == "0x*********9.32c05a44p+27");
25130 assert(ios.width() == 0);
25131 }
25132 }
25133 ios.imbue(lg);
25134 {
25135 ios.width(0);
25136 {
25137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25138 std::string ex(str, iter.base());
25139 assert(ex == "0x9;32c05a44p+27");
25140 assert(ios.width() == 0);
25141 }
25142 ios.width(25);
25143 left(ios);
25144 {
25145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25146 std::string ex(str, iter.base());
25147 assert(ex == "0x9;32c05a44p+27*********");
25148 assert(ios.width() == 0);
25149 }
25150 ios.width(25);
25151 right(ios);
25152 {
25153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25154 std::string ex(str, iter.base());
25155 assert(ex == "*********0x9;32c05a44p+27");
25156 assert(ios.width() == 0);
25157 }
25158 ios.width(25);
25159 internal(ios);
25160 {
25161 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25162 std::string ex(str, iter.base());
25163 assert(ex == "0x*********9;32c05a44p+27");
25164 assert(ios.width() == 0);
25165 }
25166 }
25167 }
25168 }
25169 showpos(ios);
25170 {
25171 noshowpoint(ios);
25172 {
25173 ios.imbue(lc);
25174 {
25175 ios.width(0);
25176 {
25177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25178 std::string ex(str, iter.base());
25179 assert(ex == "+0x9.32c05a44p+27");
25180 assert(ios.width() == 0);
25181 }
25182 ios.width(25);
25183 left(ios);
25184 {
25185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25186 std::string ex(str, iter.base());
25187 assert(ex == "+0x9.32c05a44p+27********");
25188 assert(ios.width() == 0);
25189 }
25190 ios.width(25);
25191 right(ios);
25192 {
25193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25194 std::string ex(str, iter.base());
25195 assert(ex == "********+0x9.32c05a44p+27");
25196 assert(ios.width() == 0);
25197 }
25198 ios.width(25);
25199 internal(ios);
25200 {
25201 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25202 std::string ex(str, iter.base());
25203 assert(ex == "+********0x9.32c05a44p+27");
25204 assert(ios.width() == 0);
25205 }
25206 }
25207 ios.imbue(lg);
25208 {
25209 ios.width(0);
25210 {
25211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25212 std::string ex(str, iter.base());
25213 assert(ex == "+0x9;32c05a44p+27");
25214 assert(ios.width() == 0);
25215 }
25216 ios.width(25);
25217 left(ios);
25218 {
25219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25220 std::string ex(str, iter.base());
25221 assert(ex == "+0x9;32c05a44p+27********");
25222 assert(ios.width() == 0);
25223 }
25224 ios.width(25);
25225 right(ios);
25226 {
25227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25228 std::string ex(str, iter.base());
25229 assert(ex == "********+0x9;32c05a44p+27");
25230 assert(ios.width() == 0);
25231 }
25232 ios.width(25);
25233 internal(ios);
25234 {
25235 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25236 std::string ex(str, iter.base());
25237 assert(ex == "+********0x9;32c05a44p+27");
25238 assert(ios.width() == 0);
25239 }
25240 }
25241 }
25242 showpoint(ios);
25243 {
25244 ios.imbue(lc);
25245 {
25246 ios.width(0);
25247 {
25248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25249 std::string ex(str, iter.base());
25250 assert(ex == "+0x9.32c05a44p+27");
25251 assert(ios.width() == 0);
25252 }
25253 ios.width(25);
25254 left(ios);
25255 {
25256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25257 std::string ex(str, iter.base());
25258 assert(ex == "+0x9.32c05a44p+27********");
25259 assert(ios.width() == 0);
25260 }
25261 ios.width(25);
25262 right(ios);
25263 {
25264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25265 std::string ex(str, iter.base());
25266 assert(ex == "********+0x9.32c05a44p+27");
25267 assert(ios.width() == 0);
25268 }
25269 ios.width(25);
25270 internal(ios);
25271 {
25272 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25273 std::string ex(str, iter.base());
25274 assert(ex == "+********0x9.32c05a44p+27");
25275 assert(ios.width() == 0);
25276 }
25277 }
25278 ios.imbue(lg);
25279 {
25280 ios.width(0);
25281 {
25282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25283 std::string ex(str, iter.base());
25284 assert(ex == "+0x9;32c05a44p+27");
25285 assert(ios.width() == 0);
25286 }
25287 ios.width(25);
25288 left(ios);
25289 {
25290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25291 std::string ex(str, iter.base());
25292 assert(ex == "+0x9;32c05a44p+27********");
25293 assert(ios.width() == 0);
25294 }
25295 ios.width(25);
25296 right(ios);
25297 {
25298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25299 std::string ex(str, iter.base());
25300 assert(ex == "********+0x9;32c05a44p+27");
25301 assert(ios.width() == 0);
25302 }
25303 ios.width(25);
25304 internal(ios);
25305 {
25306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25307 std::string ex(str, iter.base());
25308 assert(ex == "+********0x9;32c05a44p+27");
25309 assert(ios.width() == 0);
25310 }
25311 }
25312 }
25313 }
25314 }
25315 uppercase(ios);
25316 {
25317 noshowpos(ios);
25318 {
25319 noshowpoint(ios);
25320 {
25321 ios.imbue(lc);
25322 {
25323 ios.width(0);
25324 {
25325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25326 std::string ex(str, iter.base());
25327 assert(ex == "0X9.32C05A44P+27");
25328 assert(ios.width() == 0);
25329 }
25330 ios.width(25);
25331 left(ios);
25332 {
25333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25334 std::string ex(str, iter.base());
25335 assert(ex == "0X9.32C05A44P+27*********");
25336 assert(ios.width() == 0);
25337 }
25338 ios.width(25);
25339 right(ios);
25340 {
25341 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25342 std::string ex(str, iter.base());
25343 assert(ex == "*********0X9.32C05A44P+27");
25344 assert(ios.width() == 0);
25345 }
25346 ios.width(25);
25347 internal(ios);
25348 {
25349 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25350 std::string ex(str, iter.base());
25351 assert(ex == "0X*********9.32C05A44P+27");
25352 assert(ios.width() == 0);
25353 }
25354 }
25355 ios.imbue(lg);
25356 {
25357 ios.width(0);
25358 {
25359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25360 std::string ex(str, iter.base());
25361 assert(ex == "0X9;32C05A44P+27");
25362 assert(ios.width() == 0);
25363 }
25364 ios.width(25);
25365 left(ios);
25366 {
25367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25368 std::string ex(str, iter.base());
25369 assert(ex == "0X9;32C05A44P+27*********");
25370 assert(ios.width() == 0);
25371 }
25372 ios.width(25);
25373 right(ios);
25374 {
25375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25376 std::string ex(str, iter.base());
25377 assert(ex == "*********0X9;32C05A44P+27");
25378 assert(ios.width() == 0);
25379 }
25380 ios.width(25);
25381 internal(ios);
25382 {
25383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25384 std::string ex(str, iter.base());
25385 assert(ex == "0X*********9;32C05A44P+27");
25386 assert(ios.width() == 0);
25387 }
25388 }
25389 }
25390 showpoint(ios);
25391 {
25392 ios.imbue(lc);
25393 {
25394 ios.width(0);
25395 {
25396 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25397 std::string ex(str, iter.base());
25398 assert(ex == "0X9.32C05A44P+27");
25399 assert(ios.width() == 0);
25400 }
25401 ios.width(25);
25402 left(ios);
25403 {
25404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25405 std::string ex(str, iter.base());
25406 assert(ex == "0X9.32C05A44P+27*********");
25407 assert(ios.width() == 0);
25408 }
25409 ios.width(25);
25410 right(ios);
25411 {
25412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25413 std::string ex(str, iter.base());
25414 assert(ex == "*********0X9.32C05A44P+27");
25415 assert(ios.width() == 0);
25416 }
25417 ios.width(25);
25418 internal(ios);
25419 {
25420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25421 std::string ex(str, iter.base());
25422 assert(ex == "0X*********9.32C05A44P+27");
25423 assert(ios.width() == 0);
25424 }
25425 }
25426 ios.imbue(lg);
25427 {
25428 ios.width(0);
25429 {
25430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25431 std::string ex(str, iter.base());
25432 assert(ex == "0X9;32C05A44P+27");
25433 assert(ios.width() == 0);
25434 }
25435 ios.width(25);
25436 left(ios);
25437 {
25438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25439 std::string ex(str, iter.base());
25440 assert(ex == "0X9;32C05A44P+27*********");
25441 assert(ios.width() == 0);
25442 }
25443 ios.width(25);
25444 right(ios);
25445 {
25446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25447 std::string ex(str, iter.base());
25448 assert(ex == "*********0X9;32C05A44P+27");
25449 assert(ios.width() == 0);
25450 }
25451 ios.width(25);
25452 internal(ios);
25453 {
25454 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25455 std::string ex(str, iter.base());
25456 assert(ex == "0X*********9;32C05A44P+27");
25457 assert(ios.width() == 0);
25458 }
25459 }
25460 }
25461 }
25462 showpos(ios);
25463 {
25464 noshowpoint(ios);
25465 {
25466 ios.imbue(lc);
25467 {
25468 ios.width(0);
25469 {
25470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25471 std::string ex(str, iter.base());
25472 assert(ex == "+0X9.32C05A44P+27");
25473 assert(ios.width() == 0);
25474 }
25475 ios.width(25);
25476 left(ios);
25477 {
25478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25479 std::string ex(str, iter.base());
25480 assert(ex == "+0X9.32C05A44P+27********");
25481 assert(ios.width() == 0);
25482 }
25483 ios.width(25);
25484 right(ios);
25485 {
25486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25487 std::string ex(str, iter.base());
25488 assert(ex == "********+0X9.32C05A44P+27");
25489 assert(ios.width() == 0);
25490 }
25491 ios.width(25);
25492 internal(ios);
25493 {
25494 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25495 std::string ex(str, iter.base());
25496 assert(ex == "+********0X9.32C05A44P+27");
25497 assert(ios.width() == 0);
25498 }
25499 }
25500 ios.imbue(lg);
25501 {
25502 ios.width(0);
25503 {
25504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25505 std::string ex(str, iter.base());
25506 assert(ex == "+0X9;32C05A44P+27");
25507 assert(ios.width() == 0);
25508 }
25509 ios.width(25);
25510 left(ios);
25511 {
25512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25513 std::string ex(str, iter.base());
25514 assert(ex == "+0X9;32C05A44P+27********");
25515 assert(ios.width() == 0);
25516 }
25517 ios.width(25);
25518 right(ios);
25519 {
25520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25521 std::string ex(str, iter.base());
25522 assert(ex == "********+0X9;32C05A44P+27");
25523 assert(ios.width() == 0);
25524 }
25525 ios.width(25);
25526 internal(ios);
25527 {
25528 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25529 std::string ex(str, iter.base());
25530 assert(ex == "+********0X9;32C05A44P+27");
25531 assert(ios.width() == 0);
25532 }
25533 }
25534 }
25535 showpoint(ios);
25536 {
25537 ios.imbue(lc);
25538 {
25539 ios.width(0);
25540 {
25541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25542 std::string ex(str, iter.base());
25543 assert(ex == "+0X9.32C05A44P+27");
25544 assert(ios.width() == 0);
25545 }
25546 ios.width(25);
25547 left(ios);
25548 {
25549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25550 std::string ex(str, iter.base());
25551 assert(ex == "+0X9.32C05A44P+27********");
25552 assert(ios.width() == 0);
25553 }
25554 ios.width(25);
25555 right(ios);
25556 {
25557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25558 std::string ex(str, iter.base());
25559 assert(ex == "********+0X9.32C05A44P+27");
25560 assert(ios.width() == 0);
25561 }
25562 ios.width(25);
25563 internal(ios);
25564 {
25565 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25566 std::string ex(str, iter.base());
25567 assert(ex == "+********0X9.32C05A44P+27");
25568 assert(ios.width() == 0);
25569 }
25570 }
25571 ios.imbue(lg);
25572 {
25573 ios.width(0);
25574 {
25575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25576 std::string ex(str, iter.base());
25577 assert(ex == "+0X9;32C05A44P+27");
25578 assert(ios.width() == 0);
25579 }
25580 ios.width(25);
25581 left(ios);
25582 {
25583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25584 std::string ex(str, iter.base());
25585 assert(ex == "+0X9;32C05A44P+27********");
25586 assert(ios.width() == 0);
25587 }
25588 ios.width(25);
25589 right(ios);
25590 {
25591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25592 std::string ex(str, iter.base());
25593 assert(ex == "********+0X9;32C05A44P+27");
25594 assert(ios.width() == 0);
25595 }
25596 ios.width(25);
25597 internal(ios);
25598 {
25599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25600 std::string ex(str, iter.base());
25601 assert(ex == "+********0X9;32C05A44P+27");
25602 assert(ios.width() == 0);
25603 }
25604 }
25605 }
25606 }
25607 }
25608 }
25609 ios.precision(6);
25610 {
25611 }
25612 ios.precision(16);
25613 {
25614 }
25615 ios.precision(60);
25616 {
25617 nouppercase(ios);
25618 {
25619 noshowpos(ios);
25620 {
25621 noshowpoint(ios);
25622 {
25623 ios.imbue(lc);
25624 {
25625 ios.width(0);
25626 {
25627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25628 std::string ex(str, iter.base());
25629 assert(ex == "0x9.32c05a44p+27");
25630 assert(ios.width() == 0);
25631 }
25632 ios.width(25);
25633 left(ios);
25634 {
25635 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25636 std::string ex(str, iter.base());
25637 assert(ex == "0x9.32c05a44p+27*********");
25638 assert(ios.width() == 0);
25639 }
25640 ios.width(25);
25641 right(ios);
25642 {
25643 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25644 std::string ex(str, iter.base());
25645 assert(ex == "*********0x9.32c05a44p+27");
25646 assert(ios.width() == 0);
25647 }
25648 ios.width(25);
25649 internal(ios);
25650 {
25651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25652 std::string ex(str, iter.base());
25653 assert(ex == "0x*********9.32c05a44p+27");
25654 assert(ios.width() == 0);
25655 }
25656 }
25657 ios.imbue(lg);
25658 {
25659 ios.width(0);
25660 {
25661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25662 std::string ex(str, iter.base());
25663 assert(ex == "0x9;32c05a44p+27");
25664 assert(ios.width() == 0);
25665 }
25666 ios.width(25);
25667 left(ios);
25668 {
25669 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25670 std::string ex(str, iter.base());
25671 assert(ex == "0x9;32c05a44p+27*********");
25672 assert(ios.width() == 0);
25673 }
25674 ios.width(25);
25675 right(ios);
25676 {
25677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25678 std::string ex(str, iter.base());
25679 assert(ex == "*********0x9;32c05a44p+27");
25680 assert(ios.width() == 0);
25681 }
25682 ios.width(25);
25683 internal(ios);
25684 {
25685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25686 std::string ex(str, iter.base());
25687 assert(ex == "0x*********9;32c05a44p+27");
25688 assert(ios.width() == 0);
25689 }
25690 }
25691 }
25692 showpoint(ios);
25693 {
25694 ios.imbue(lc);
25695 {
25696 ios.width(0);
25697 {
25698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25699 std::string ex(str, iter.base());
25700 assert(ex == "0x9.32c05a44p+27");
25701 assert(ios.width() == 0);
25702 }
25703 ios.width(25);
25704 left(ios);
25705 {
25706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25707 std::string ex(str, iter.base());
25708 assert(ex == "0x9.32c05a44p+27*********");
25709 assert(ios.width() == 0);
25710 }
25711 ios.width(25);
25712 right(ios);
25713 {
25714 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25715 std::string ex(str, iter.base());
25716 assert(ex == "*********0x9.32c05a44p+27");
25717 assert(ios.width() == 0);
25718 }
25719 ios.width(25);
25720 internal(ios);
25721 {
25722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25723 std::string ex(str, iter.base());
25724 assert(ex == "0x*********9.32c05a44p+27");
25725 assert(ios.width() == 0);
25726 }
25727 }
25728 ios.imbue(lg);
25729 {
25730 ios.width(0);
25731 {
25732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25733 std::string ex(str, iter.base());
25734 assert(ex == "0x9;32c05a44p+27");
25735 assert(ios.width() == 0);
25736 }
25737 ios.width(25);
25738 left(ios);
25739 {
25740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25741 std::string ex(str, iter.base());
25742 assert(ex == "0x9;32c05a44p+27*********");
25743 assert(ios.width() == 0);
25744 }
25745 ios.width(25);
25746 right(ios);
25747 {
25748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25749 std::string ex(str, iter.base());
25750 assert(ex == "*********0x9;32c05a44p+27");
25751 assert(ios.width() == 0);
25752 }
25753 ios.width(25);
25754 internal(ios);
25755 {
25756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25757 std::string ex(str, iter.base());
25758 assert(ex == "0x*********9;32c05a44p+27");
25759 assert(ios.width() == 0);
25760 }
25761 }
25762 }
25763 }
25764 showpos(ios);
25765 {
25766 noshowpoint(ios);
25767 {
25768 ios.imbue(lc);
25769 {
25770 ios.width(0);
25771 {
25772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25773 std::string ex(str, iter.base());
25774 assert(ex == "+0x9.32c05a44p+27");
25775 assert(ios.width() == 0);
25776 }
25777 ios.width(25);
25778 left(ios);
25779 {
25780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25781 std::string ex(str, iter.base());
25782 assert(ex == "+0x9.32c05a44p+27********");
25783 assert(ios.width() == 0);
25784 }
25785 ios.width(25);
25786 right(ios);
25787 {
25788 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25789 std::string ex(str, iter.base());
25790 assert(ex == "********+0x9.32c05a44p+27");
25791 assert(ios.width() == 0);
25792 }
25793 ios.width(25);
25794 internal(ios);
25795 {
25796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25797 std::string ex(str, iter.base());
25798 assert(ex == "+********0x9.32c05a44p+27");
25799 assert(ios.width() == 0);
25800 }
25801 }
25802 ios.imbue(lg);
25803 {
25804 ios.width(0);
25805 {
25806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25807 std::string ex(str, iter.base());
25808 assert(ex == "+0x9;32c05a44p+27");
25809 assert(ios.width() == 0);
25810 }
25811 ios.width(25);
25812 left(ios);
25813 {
25814 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25815 std::string ex(str, iter.base());
25816 assert(ex == "+0x9;32c05a44p+27********");
25817 assert(ios.width() == 0);
25818 }
25819 ios.width(25);
25820 right(ios);
25821 {
25822 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25823 std::string ex(str, iter.base());
25824 assert(ex == "********+0x9;32c05a44p+27");
25825 assert(ios.width() == 0);
25826 }
25827 ios.width(25);
25828 internal(ios);
25829 {
25830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25831 std::string ex(str, iter.base());
25832 assert(ex == "+********0x9;32c05a44p+27");
25833 assert(ios.width() == 0);
25834 }
25835 }
25836 }
25837 showpoint(ios);
25838 {
25839 ios.imbue(lc);
25840 {
25841 ios.width(0);
25842 {
25843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25844 std::string ex(str, iter.base());
25845 assert(ex == "+0x9.32c05a44p+27");
25846 assert(ios.width() == 0);
25847 }
25848 ios.width(25);
25849 left(ios);
25850 {
25851 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25852 std::string ex(str, iter.base());
25853 assert(ex == "+0x9.32c05a44p+27********");
25854 assert(ios.width() == 0);
25855 }
25856 ios.width(25);
25857 right(ios);
25858 {
25859 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25860 std::string ex(str, iter.base());
25861 assert(ex == "********+0x9.32c05a44p+27");
25862 assert(ios.width() == 0);
25863 }
25864 ios.width(25);
25865 internal(ios);
25866 {
25867 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25868 std::string ex(str, iter.base());
25869 assert(ex == "+********0x9.32c05a44p+27");
25870 assert(ios.width() == 0);
25871 }
25872 }
25873 ios.imbue(lg);
25874 {
25875 ios.width(0);
25876 {
25877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25878 std::string ex(str, iter.base());
25879 assert(ex == "+0x9;32c05a44p+27");
25880 assert(ios.width() == 0);
25881 }
25882 ios.width(25);
25883 left(ios);
25884 {
25885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25886 std::string ex(str, iter.base());
25887 assert(ex == "+0x9;32c05a44p+27********");
25888 assert(ios.width() == 0);
25889 }
25890 ios.width(25);
25891 right(ios);
25892 {
25893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25894 std::string ex(str, iter.base());
25895 assert(ex == "********+0x9;32c05a44p+27");
25896 assert(ios.width() == 0);
25897 }
25898 ios.width(25);
25899 internal(ios);
25900 {
25901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25902 std::string ex(str, iter.base());
25903 assert(ex == "+********0x9;32c05a44p+27");
25904 assert(ios.width() == 0);
25905 }
25906 }
25907 }
25908 }
25909 }
25910 uppercase(ios);
25911 {
25912 noshowpos(ios);
25913 {
25914 noshowpoint(ios);
25915 {
25916 ios.imbue(lc);
25917 {
25918 ios.width(0);
25919 {
25920 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25921 std::string ex(str, iter.base());
25922 assert(ex == "0X9.32C05A44P+27");
25923 assert(ios.width() == 0);
25924 }
25925 ios.width(25);
25926 left(ios);
25927 {
25928 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25929 std::string ex(str, iter.base());
25930 assert(ex == "0X9.32C05A44P+27*********");
25931 assert(ios.width() == 0);
25932 }
25933 ios.width(25);
25934 right(ios);
25935 {
25936 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25937 std::string ex(str, iter.base());
25938 assert(ex == "*********0X9.32C05A44P+27");
25939 assert(ios.width() == 0);
25940 }
25941 ios.width(25);
25942 internal(ios);
25943 {
25944 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25945 std::string ex(str, iter.base());
25946 assert(ex == "0X*********9.32C05A44P+27");
25947 assert(ios.width() == 0);
25948 }
25949 }
25950 ios.imbue(lg);
25951 {
25952 ios.width(0);
25953 {
25954 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25955 std::string ex(str, iter.base());
25956 assert(ex == "0X9;32C05A44P+27");
25957 assert(ios.width() == 0);
25958 }
25959 ios.width(25);
25960 left(ios);
25961 {
25962 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25963 std::string ex(str, iter.base());
25964 assert(ex == "0X9;32C05A44P+27*********");
25965 assert(ios.width() == 0);
25966 }
25967 ios.width(25);
25968 right(ios);
25969 {
25970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25971 std::string ex(str, iter.base());
25972 assert(ex == "*********0X9;32C05A44P+27");
25973 assert(ios.width() == 0);
25974 }
25975 ios.width(25);
25976 internal(ios);
25977 {
25978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25979 std::string ex(str, iter.base());
25980 assert(ex == "0X*********9;32C05A44P+27");
25981 assert(ios.width() == 0);
25982 }
25983 }
25984 }
25985 showpoint(ios);
25986 {
25987 ios.imbue(lc);
25988 {
25989 ios.width(0);
25990 {
25991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25992 std::string ex(str, iter.base());
25993 assert(ex == "0X9.32C05A44P+27");
25994 assert(ios.width() == 0);
25995 }
25996 ios.width(25);
25997 left(ios);
25998 {
25999 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26000 std::string ex(str, iter.base());
26001 assert(ex == "0X9.32C05A44P+27*********");
26002 assert(ios.width() == 0);
26003 }
26004 ios.width(25);
26005 right(ios);
26006 {
26007 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26008 std::string ex(str, iter.base());
26009 assert(ex == "*********0X9.32C05A44P+27");
26010 assert(ios.width() == 0);
26011 }
26012 ios.width(25);
26013 internal(ios);
26014 {
26015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26016 std::string ex(str, iter.base());
26017 assert(ex == "0X*********9.32C05A44P+27");
26018 assert(ios.width() == 0);
26019 }
26020 }
26021 ios.imbue(lg);
26022 {
26023 ios.width(0);
26024 {
26025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26026 std::string ex(str, iter.base());
26027 assert(ex == "0X9;32C05A44P+27");
26028 assert(ios.width() == 0);
26029 }
26030 ios.width(25);
26031 left(ios);
26032 {
26033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26034 std::string ex(str, iter.base());
26035 assert(ex == "0X9;32C05A44P+27*********");
26036 assert(ios.width() == 0);
26037 }
26038 ios.width(25);
26039 right(ios);
26040 {
26041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26042 std::string ex(str, iter.base());
26043 assert(ex == "*********0X9;32C05A44P+27");
26044 assert(ios.width() == 0);
26045 }
26046 ios.width(25);
26047 internal(ios);
26048 {
26049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26050 std::string ex(str, iter.base());
26051 assert(ex == "0X*********9;32C05A44P+27");
26052 assert(ios.width() == 0);
26053 }
26054 }
26055 }
26056 }
26057 showpos(ios);
26058 {
26059 noshowpoint(ios);
26060 {
26061 ios.imbue(lc);
26062 {
26063 ios.width(0);
26064 {
26065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26066 std::string ex(str, iter.base());
26067 assert(ex == "+0X9.32C05A44P+27");
26068 assert(ios.width() == 0);
26069 }
26070 ios.width(25);
26071 left(ios);
26072 {
26073 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26074 std::string ex(str, iter.base());
26075 assert(ex == "+0X9.32C05A44P+27********");
26076 assert(ios.width() == 0);
26077 }
26078 ios.width(25);
26079 right(ios);
26080 {
26081 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26082 std::string ex(str, iter.base());
26083 assert(ex == "********+0X9.32C05A44P+27");
26084 assert(ios.width() == 0);
26085 }
26086 ios.width(25);
26087 internal(ios);
26088 {
26089 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26090 std::string ex(str, iter.base());
26091 assert(ex == "+********0X9.32C05A44P+27");
26092 assert(ios.width() == 0);
26093 }
26094 }
26095 ios.imbue(lg);
26096 {
26097 ios.width(0);
26098 {
26099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26100 std::string ex(str, iter.base());
26101 assert(ex == "+0X9;32C05A44P+27");
26102 assert(ios.width() == 0);
26103 }
26104 ios.width(25);
26105 left(ios);
26106 {
26107 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26108 std::string ex(str, iter.base());
26109 assert(ex == "+0X9;32C05A44P+27********");
26110 assert(ios.width() == 0);
26111 }
26112 ios.width(25);
26113 right(ios);
26114 {
26115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26116 std::string ex(str, iter.base());
26117 assert(ex == "********+0X9;32C05A44P+27");
26118 assert(ios.width() == 0);
26119 }
26120 ios.width(25);
26121 internal(ios);
26122 {
26123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26124 std::string ex(str, iter.base());
26125 assert(ex == "+********0X9;32C05A44P+27");
26126 assert(ios.width() == 0);
26127 }
26128 }
26129 }
26130 showpoint(ios);
26131 {
26132 ios.imbue(lc);
26133 {
26134 ios.width(0);
26135 {
26136 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26137 std::string ex(str, iter.base());
26138 assert(ex == "+0X9.32C05A44P+27");
26139 assert(ios.width() == 0);
26140 }
26141 ios.width(25);
26142 left(ios);
26143 {
26144 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26145 std::string ex(str, iter.base());
26146 assert(ex == "+0X9.32C05A44P+27********");
26147 assert(ios.width() == 0);
26148 }
26149 ios.width(25);
26150 right(ios);
26151 {
26152 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26153 std::string ex(str, iter.base());
26154 assert(ex == "********+0X9.32C05A44P+27");
26155 assert(ios.width() == 0);
26156 }
26157 ios.width(25);
26158 internal(ios);
26159 {
26160 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26161 std::string ex(str, iter.base());
26162 assert(ex == "+********0X9.32C05A44P+27");
26163 assert(ios.width() == 0);
26164 }
26165 }
26166 ios.imbue(lg);
26167 {
26168 ios.width(0);
26169 {
26170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26171 std::string ex(str, iter.base());
26172 assert(ex == "+0X9;32C05A44P+27");
26173 assert(ios.width() == 0);
26174 }
26175 ios.width(25);
26176 left(ios);
26177 {
26178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26179 std::string ex(str, iter.base());
26180 assert(ex == "+0X9;32C05A44P+27********");
26181 assert(ios.width() == 0);
26182 }
26183 ios.width(25);
26184 right(ios);
26185 {
26186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26187 std::string ex(str, iter.base());
26188 assert(ex == "********+0X9;32C05A44P+27");
26189 assert(ios.width() == 0);
26190 }
26191 ios.width(25);
26192 internal(ios);
26193 {
26194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26195 std::string ex(str, iter.base());
26196 assert(ex == "+********0X9;32C05A44P+27");
26197 assert(ios.width() == 0);
26198 }
26199 }
26200 }
26201 }
26202 }
26203 }
26204 }
26205 }
26206 #endif
26207 }
26208
main(int,char **)26209 int main(int, char**)
26210 {
26211 test1();
26212 test2();
26213 test3();
26214 test4();
26215 test5();
26216 test6();
26217 test7();
26218 test8();
26219 test9();
26220 test10();
26221 test11();
26222 test12();
26223 output_iterator<char*> iter;
26224 std::locale lc = std::locale::classic();
26225 std::locale lg(lc, new my_numpunct);
26226 const my_facet f(1);
26227 {
26228 long double v = -INFINITY; ((void)v);
26229 }
26230 {
26231 long double v = std::nan(""); ((void)v);
26232 }
26233
26234 {
26235 long double v = +0.; ((void)v);
26236 }
26237 {
26238 long double v = -INFINITY; ((void)v);
26239 }
26240 {
26241 long double v = std::nan(""); ((void)v);
26242 }
26243 {
26244 long double v = -INFINITY; ((void)v);
26245 }
26246 {
26247 long double v = std::nan(""); ((void)v);
26248 }
26249
26250 return 0;
26251 }
26252