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(EricWF): This test takes 40+ minutes to build with Clang 3.8 under ASAN or MSAN.
16 // UNSUPPORTED: asan, msan
17
18 // TODO GLIBC uses a different string for positive and negative NAN numbers.
19 // XFAIL: linux-gnu
20
21 #include <locale>
22 #include <ios>
23 #include <cassert>
24 #include <streambuf>
25 #include <cmath>
26 #include "test_macros.h"
27 #include "test_iterators.h"
28
29 typedef std::num_put<char, output_iterator<char*> > F;
30
31 class my_facet
32 : public F
33 {
34 public:
my_facet(std::size_t refs=0)35 explicit my_facet(std::size_t refs = 0)
36 : F(refs) {}
37 };
38
39 class my_numpunct
40 : public std::numpunct<char>
41 {
42 public:
my_numpunct()43 my_numpunct() : std::numpunct<char>() {}
44
45 protected:
do_decimal_point() const46 virtual char_type do_decimal_point() const {return ';';}
do_thousands_sep() const47 virtual char_type do_thousands_sep() const {return '_';}
do_grouping() const48 virtual std::string do_grouping() const {return std::string("\1\2\3");}
49 };
50
test1()51 void test1()
52 {
53 char str[200];
54 output_iterator<char*> iter;
55 std::locale lc = std::locale::classic();
56 std::locale lg(lc, new my_numpunct);
57 const my_facet f(1);
58 {
59 long double v = +0.;
60 std::ios ios(0);
61 // %g
62 {
63 ios.precision(0);
64 {
65 nouppercase(ios);
66 {
67 noshowpos(ios);
68 {
69 noshowpoint(ios);
70 {
71 ios.imbue(lc);
72 {
73 ios.width(0);
74 {
75 iter = f.put(output_iterator<char*>(str), ios, '*', v);
76 std::string ex(str, iter.base());
77 assert(ex == "0");
78 assert(ios.width() == 0);
79 }
80 ios.width(25);
81 left(ios);
82 {
83 iter = f.put(output_iterator<char*>(str), ios, '*', v);
84 std::string ex(str, iter.base());
85 assert(ex == "0************************");
86 assert(ios.width() == 0);
87 }
88 ios.width(25);
89 right(ios);
90 {
91 iter = f.put(output_iterator<char*>(str), ios, '*', v);
92 std::string ex(str, iter.base());
93 assert(ex == "************************0");
94 assert(ios.width() == 0);
95 }
96 ios.width(25);
97 internal(ios);
98 {
99 iter = f.put(output_iterator<char*>(str), ios, '*', v);
100 std::string ex(str, iter.base());
101 assert(ex == "************************0");
102 assert(ios.width() == 0);
103 }
104 }
105 ios.imbue(lg);
106 {
107 ios.width(0);
108 {
109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
110 std::string ex(str, iter.base());
111 assert(ex == "0");
112 assert(ios.width() == 0);
113 }
114 ios.width(25);
115 left(ios);
116 {
117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
118 std::string ex(str, iter.base());
119 assert(ex == "0************************");
120 assert(ios.width() == 0);
121 }
122 ios.width(25);
123 right(ios);
124 {
125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
126 std::string ex(str, iter.base());
127 assert(ex == "************************0");
128 assert(ios.width() == 0);
129 }
130 ios.width(25);
131 internal(ios);
132 {
133 iter = f.put(output_iterator<char*>(str), ios, '*', v);
134 std::string ex(str, iter.base());
135 assert(ex == "************************0");
136 assert(ios.width() == 0);
137 }
138 }
139 }
140 showpoint(ios);
141 {
142 ios.imbue(lc);
143 {
144 ios.width(0);
145 {
146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
147 std::string ex(str, iter.base());
148 assert(ex == "0.");
149 assert(ios.width() == 0);
150 }
151 ios.width(25);
152 left(ios);
153 {
154 iter = f.put(output_iterator<char*>(str), ios, '*', v);
155 std::string ex(str, iter.base());
156 assert(ex == "0.***********************");
157 assert(ios.width() == 0);
158 }
159 ios.width(25);
160 right(ios);
161 {
162 iter = f.put(output_iterator<char*>(str), ios, '*', v);
163 std::string ex(str, iter.base());
164 assert(ex == "***********************0.");
165 assert(ios.width() == 0);
166 }
167 ios.width(25);
168 internal(ios);
169 {
170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
171 std::string ex(str, iter.base());
172 assert(ex == "***********************0.");
173 assert(ios.width() == 0);
174 }
175 }
176 ios.imbue(lg);
177 {
178 ios.width(0);
179 {
180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
181 std::string ex(str, iter.base());
182 assert(ex == "0;");
183 assert(ios.width() == 0);
184 }
185 ios.width(25);
186 left(ios);
187 {
188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
189 std::string ex(str, iter.base());
190 assert(ex == "0;***********************");
191 assert(ios.width() == 0);
192 }
193 ios.width(25);
194 right(ios);
195 {
196 iter = f.put(output_iterator<char*>(str), ios, '*', v);
197 std::string ex(str, iter.base());
198 assert(ex == "***********************0;");
199 assert(ios.width() == 0);
200 }
201 ios.width(25);
202 internal(ios);
203 {
204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
205 std::string ex(str, iter.base());
206 assert(ex == "***********************0;");
207 assert(ios.width() == 0);
208 }
209 }
210 }
211 }
212 showpos(ios);
213 {
214 noshowpoint(ios);
215 {
216 ios.imbue(lc);
217 {
218 ios.width(0);
219 {
220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
221 std::string ex(str, iter.base());
222 assert(ex == "+0");
223 assert(ios.width() == 0);
224 }
225 ios.width(25);
226 left(ios);
227 {
228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
229 std::string ex(str, iter.base());
230 assert(ex == "+0***********************");
231 assert(ios.width() == 0);
232 }
233 ios.width(25);
234 right(ios);
235 {
236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
237 std::string ex(str, iter.base());
238 assert(ex == "***********************+0");
239 assert(ios.width() == 0);
240 }
241 ios.width(25);
242 internal(ios);
243 {
244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
245 std::string ex(str, iter.base());
246 assert(ex == "+***********************0");
247 assert(ios.width() == 0);
248 }
249 }
250 ios.imbue(lg);
251 {
252 ios.width(0);
253 {
254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
255 std::string ex(str, iter.base());
256 assert(ex == "+0");
257 assert(ios.width() == 0);
258 }
259 ios.width(25);
260 left(ios);
261 {
262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
263 std::string ex(str, iter.base());
264 assert(ex == "+0***********************");
265 assert(ios.width() == 0);
266 }
267 ios.width(25);
268 right(ios);
269 {
270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
271 std::string ex(str, iter.base());
272 assert(ex == "***********************+0");
273 assert(ios.width() == 0);
274 }
275 ios.width(25);
276 internal(ios);
277 {
278 iter = f.put(output_iterator<char*>(str), ios, '*', v);
279 std::string ex(str, iter.base());
280 assert(ex == "+***********************0");
281 assert(ios.width() == 0);
282 }
283 }
284 }
285 showpoint(ios);
286 {
287 ios.imbue(lc);
288 {
289 ios.width(0);
290 {
291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
292 std::string ex(str, iter.base());
293 assert(ex == "+0.");
294 assert(ios.width() == 0);
295 }
296 ios.width(25);
297 left(ios);
298 {
299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
300 std::string ex(str, iter.base());
301 assert(ex == "+0.**********************");
302 assert(ios.width() == 0);
303 }
304 ios.width(25);
305 right(ios);
306 {
307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
308 std::string ex(str, iter.base());
309 assert(ex == "**********************+0.");
310 assert(ios.width() == 0);
311 }
312 ios.width(25);
313 internal(ios);
314 {
315 iter = f.put(output_iterator<char*>(str), ios, '*', v);
316 std::string ex(str, iter.base());
317 assert(ex == "+**********************0.");
318 assert(ios.width() == 0);
319 }
320 }
321 ios.imbue(lg);
322 {
323 ios.width(0);
324 {
325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
326 std::string ex(str, iter.base());
327 assert(ex == "+0;");
328 assert(ios.width() == 0);
329 }
330 ios.width(25);
331 left(ios);
332 {
333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
334 std::string ex(str, iter.base());
335 assert(ex == "+0;**********************");
336 assert(ios.width() == 0);
337 }
338 ios.width(25);
339 right(ios);
340 {
341 iter = f.put(output_iterator<char*>(str), ios, '*', v);
342 std::string ex(str, iter.base());
343 assert(ex == "**********************+0;");
344 assert(ios.width() == 0);
345 }
346 ios.width(25);
347 internal(ios);
348 {
349 iter = f.put(output_iterator<char*>(str), ios, '*', v);
350 std::string ex(str, iter.base());
351 assert(ex == "+**********************0;");
352 assert(ios.width() == 0);
353 }
354 }
355 }
356 }
357 }
358 uppercase(ios);
359 {
360 noshowpos(ios);
361 {
362 noshowpoint(ios);
363 {
364 ios.imbue(lc);
365 {
366 ios.width(0);
367 {
368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
369 std::string ex(str, iter.base());
370 assert(ex == "0");
371 assert(ios.width() == 0);
372 }
373 ios.width(25);
374 left(ios);
375 {
376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
377 std::string ex(str, iter.base());
378 assert(ex == "0************************");
379 assert(ios.width() == 0);
380 }
381 ios.width(25);
382 right(ios);
383 {
384 iter = f.put(output_iterator<char*>(str), ios, '*', v);
385 std::string ex(str, iter.base());
386 assert(ex == "************************0");
387 assert(ios.width() == 0);
388 }
389 ios.width(25);
390 internal(ios);
391 {
392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
393 std::string ex(str, iter.base());
394 assert(ex == "************************0");
395 assert(ios.width() == 0);
396 }
397 }
398 ios.imbue(lg);
399 {
400 ios.width(0);
401 {
402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
403 std::string ex(str, iter.base());
404 assert(ex == "0");
405 assert(ios.width() == 0);
406 }
407 ios.width(25);
408 left(ios);
409 {
410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
411 std::string ex(str, iter.base());
412 assert(ex == "0************************");
413 assert(ios.width() == 0);
414 }
415 ios.width(25);
416 right(ios);
417 {
418 iter = f.put(output_iterator<char*>(str), ios, '*', v);
419 std::string ex(str, iter.base());
420 assert(ex == "************************0");
421 assert(ios.width() == 0);
422 }
423 ios.width(25);
424 internal(ios);
425 {
426 iter = f.put(output_iterator<char*>(str), ios, '*', v);
427 std::string ex(str, iter.base());
428 assert(ex == "************************0");
429 assert(ios.width() == 0);
430 }
431 }
432 }
433 showpoint(ios);
434 {
435 ios.imbue(lc);
436 {
437 ios.width(0);
438 {
439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
440 std::string ex(str, iter.base());
441 assert(ex == "0.");
442 assert(ios.width() == 0);
443 }
444 ios.width(25);
445 left(ios);
446 {
447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
448 std::string ex(str, iter.base());
449 assert(ex == "0.***********************");
450 assert(ios.width() == 0);
451 }
452 ios.width(25);
453 right(ios);
454 {
455 iter = f.put(output_iterator<char*>(str), ios, '*', v);
456 std::string ex(str, iter.base());
457 assert(ex == "***********************0.");
458 assert(ios.width() == 0);
459 }
460 ios.width(25);
461 internal(ios);
462 {
463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
464 std::string ex(str, iter.base());
465 assert(ex == "***********************0.");
466 assert(ios.width() == 0);
467 }
468 }
469 ios.imbue(lg);
470 {
471 ios.width(0);
472 {
473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
474 std::string ex(str, iter.base());
475 assert(ex == "0;");
476 assert(ios.width() == 0);
477 }
478 ios.width(25);
479 left(ios);
480 {
481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
482 std::string ex(str, iter.base());
483 assert(ex == "0;***********************");
484 assert(ios.width() == 0);
485 }
486 ios.width(25);
487 right(ios);
488 {
489 iter = f.put(output_iterator<char*>(str), ios, '*', v);
490 std::string ex(str, iter.base());
491 assert(ex == "***********************0;");
492 assert(ios.width() == 0);
493 }
494 ios.width(25);
495 internal(ios);
496 {
497 iter = f.put(output_iterator<char*>(str), ios, '*', v);
498 std::string ex(str, iter.base());
499 assert(ex == "***********************0;");
500 assert(ios.width() == 0);
501 }
502 }
503 }
504 }
505 showpos(ios);
506 {
507 noshowpoint(ios);
508 {
509 ios.imbue(lc);
510 {
511 ios.width(0);
512 {
513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
514 std::string ex(str, iter.base());
515 assert(ex == "+0");
516 assert(ios.width() == 0);
517 }
518 ios.width(25);
519 left(ios);
520 {
521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
522 std::string ex(str, iter.base());
523 assert(ex == "+0***********************");
524 assert(ios.width() == 0);
525 }
526 ios.width(25);
527 right(ios);
528 {
529 iter = f.put(output_iterator<char*>(str), ios, '*', v);
530 std::string ex(str, iter.base());
531 assert(ex == "***********************+0");
532 assert(ios.width() == 0);
533 }
534 ios.width(25);
535 internal(ios);
536 {
537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
538 std::string ex(str, iter.base());
539 assert(ex == "+***********************0");
540 assert(ios.width() == 0);
541 }
542 }
543 ios.imbue(lg);
544 {
545 ios.width(0);
546 {
547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
548 std::string ex(str, iter.base());
549 assert(ex == "+0");
550 assert(ios.width() == 0);
551 }
552 ios.width(25);
553 left(ios);
554 {
555 iter = f.put(output_iterator<char*>(str), ios, '*', v);
556 std::string ex(str, iter.base());
557 assert(ex == "+0***********************");
558 assert(ios.width() == 0);
559 }
560 ios.width(25);
561 right(ios);
562 {
563 iter = f.put(output_iterator<char*>(str), ios, '*', v);
564 std::string ex(str, iter.base());
565 assert(ex == "***********************+0");
566 assert(ios.width() == 0);
567 }
568 ios.width(25);
569 internal(ios);
570 {
571 iter = f.put(output_iterator<char*>(str), ios, '*', v);
572 std::string ex(str, iter.base());
573 assert(ex == "+***********************0");
574 assert(ios.width() == 0);
575 }
576 }
577 }
578 showpoint(ios);
579 {
580 ios.imbue(lc);
581 {
582 ios.width(0);
583 {
584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
585 std::string ex(str, iter.base());
586 assert(ex == "+0.");
587 assert(ios.width() == 0);
588 }
589 ios.width(25);
590 left(ios);
591 {
592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
593 std::string ex(str, iter.base());
594 assert(ex == "+0.**********************");
595 assert(ios.width() == 0);
596 }
597 ios.width(25);
598 right(ios);
599 {
600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
601 std::string ex(str, iter.base());
602 assert(ex == "**********************+0.");
603 assert(ios.width() == 0);
604 }
605 ios.width(25);
606 internal(ios);
607 {
608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
609 std::string ex(str, iter.base());
610 assert(ex == "+**********************0.");
611 assert(ios.width() == 0);
612 }
613 }
614 ios.imbue(lg);
615 {
616 ios.width(0);
617 {
618 iter = f.put(output_iterator<char*>(str), ios, '*', v);
619 std::string ex(str, iter.base());
620 assert(ex == "+0;");
621 assert(ios.width() == 0);
622 }
623 ios.width(25);
624 left(ios);
625 {
626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
627 std::string ex(str, iter.base());
628 assert(ex == "+0;**********************");
629 assert(ios.width() == 0);
630 }
631 ios.width(25);
632 right(ios);
633 {
634 iter = f.put(output_iterator<char*>(str), ios, '*', v);
635 std::string ex(str, iter.base());
636 assert(ex == "**********************+0;");
637 assert(ios.width() == 0);
638 }
639 ios.width(25);
640 internal(ios);
641 {
642 iter = f.put(output_iterator<char*>(str), ios, '*', v);
643 std::string ex(str, iter.base());
644 assert(ex == "+**********************0;");
645 assert(ios.width() == 0);
646 }
647 }
648 }
649 }
650 }
651 }
652 ios.precision(1);
653 {
654 nouppercase(ios);
655 {
656 noshowpos(ios);
657 {
658 noshowpoint(ios);
659 {
660 ios.imbue(lc);
661 {
662 ios.width(0);
663 {
664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
665 std::string ex(str, iter.base());
666 assert(ex == "0");
667 assert(ios.width() == 0);
668 }
669 ios.width(25);
670 left(ios);
671 {
672 iter = f.put(output_iterator<char*>(str), ios, '*', v);
673 std::string ex(str, iter.base());
674 assert(ex == "0************************");
675 assert(ios.width() == 0);
676 }
677 ios.width(25);
678 right(ios);
679 {
680 iter = f.put(output_iterator<char*>(str), ios, '*', v);
681 std::string ex(str, iter.base());
682 assert(ex == "************************0");
683 assert(ios.width() == 0);
684 }
685 ios.width(25);
686 internal(ios);
687 {
688 iter = f.put(output_iterator<char*>(str), ios, '*', v);
689 std::string ex(str, iter.base());
690 assert(ex == "************************0");
691 assert(ios.width() == 0);
692 }
693 }
694 ios.imbue(lg);
695 {
696 ios.width(0);
697 {
698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
699 std::string ex(str, iter.base());
700 assert(ex == "0");
701 assert(ios.width() == 0);
702 }
703 ios.width(25);
704 left(ios);
705 {
706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
707 std::string ex(str, iter.base());
708 assert(ex == "0************************");
709 assert(ios.width() == 0);
710 }
711 ios.width(25);
712 right(ios);
713 {
714 iter = f.put(output_iterator<char*>(str), ios, '*', v);
715 std::string ex(str, iter.base());
716 assert(ex == "************************0");
717 assert(ios.width() == 0);
718 }
719 ios.width(25);
720 internal(ios);
721 {
722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
723 std::string ex(str, iter.base());
724 assert(ex == "************************0");
725 assert(ios.width() == 0);
726 }
727 }
728 }
729 showpoint(ios);
730 {
731 ios.imbue(lc);
732 {
733 ios.width(0);
734 {
735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
736 std::string ex(str, iter.base());
737 assert(ex == "0.");
738 assert(ios.width() == 0);
739 }
740 ios.width(25);
741 left(ios);
742 {
743 iter = f.put(output_iterator<char*>(str), ios, '*', v);
744 std::string ex(str, iter.base());
745 assert(ex == "0.***********************");
746 assert(ios.width() == 0);
747 }
748 ios.width(25);
749 right(ios);
750 {
751 iter = f.put(output_iterator<char*>(str), ios, '*', v);
752 std::string ex(str, iter.base());
753 assert(ex == "***********************0.");
754 assert(ios.width() == 0);
755 }
756 ios.width(25);
757 internal(ios);
758 {
759 iter = f.put(output_iterator<char*>(str), ios, '*', v);
760 std::string ex(str, iter.base());
761 assert(ex == "***********************0.");
762 assert(ios.width() == 0);
763 }
764 }
765 ios.imbue(lg);
766 {
767 ios.width(0);
768 {
769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
770 std::string ex(str, iter.base());
771 assert(ex == "0;");
772 assert(ios.width() == 0);
773 }
774 ios.width(25);
775 left(ios);
776 {
777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
778 std::string ex(str, iter.base());
779 assert(ex == "0;***********************");
780 assert(ios.width() == 0);
781 }
782 ios.width(25);
783 right(ios);
784 {
785 iter = f.put(output_iterator<char*>(str), ios, '*', v);
786 std::string ex(str, iter.base());
787 assert(ex == "***********************0;");
788 assert(ios.width() == 0);
789 }
790 ios.width(25);
791 internal(ios);
792 {
793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
794 std::string ex(str, iter.base());
795 assert(ex == "***********************0;");
796 assert(ios.width() == 0);
797 }
798 }
799 }
800 }
801 showpos(ios);
802 {
803 noshowpoint(ios);
804 {
805 ios.imbue(lc);
806 {
807 ios.width(0);
808 {
809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
810 std::string ex(str, iter.base());
811 assert(ex == "+0");
812 assert(ios.width() == 0);
813 }
814 ios.width(25);
815 left(ios);
816 {
817 iter = f.put(output_iterator<char*>(str), ios, '*', v);
818 std::string ex(str, iter.base());
819 assert(ex == "+0***********************");
820 assert(ios.width() == 0);
821 }
822 ios.width(25);
823 right(ios);
824 {
825 iter = f.put(output_iterator<char*>(str), ios, '*', v);
826 std::string ex(str, iter.base());
827 assert(ex == "***********************+0");
828 assert(ios.width() == 0);
829 }
830 ios.width(25);
831 internal(ios);
832 {
833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
834 std::string ex(str, iter.base());
835 assert(ex == "+***********************0");
836 assert(ios.width() == 0);
837 }
838 }
839 ios.imbue(lg);
840 {
841 ios.width(0);
842 {
843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
844 std::string ex(str, iter.base());
845 assert(ex == "+0");
846 assert(ios.width() == 0);
847 }
848 ios.width(25);
849 left(ios);
850 {
851 iter = f.put(output_iterator<char*>(str), ios, '*', v);
852 std::string ex(str, iter.base());
853 assert(ex == "+0***********************");
854 assert(ios.width() == 0);
855 }
856 ios.width(25);
857 right(ios);
858 {
859 iter = f.put(output_iterator<char*>(str), ios, '*', v);
860 std::string ex(str, iter.base());
861 assert(ex == "***********************+0");
862 assert(ios.width() == 0);
863 }
864 ios.width(25);
865 internal(ios);
866 {
867 iter = f.put(output_iterator<char*>(str), ios, '*', v);
868 std::string ex(str, iter.base());
869 assert(ex == "+***********************0");
870 assert(ios.width() == 0);
871 }
872 }
873 }
874 showpoint(ios);
875 {
876 ios.imbue(lc);
877 {
878 ios.width(0);
879 {
880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
881 std::string ex(str, iter.base());
882 assert(ex == "+0.");
883 assert(ios.width() == 0);
884 }
885 ios.width(25);
886 left(ios);
887 {
888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
889 std::string ex(str, iter.base());
890 assert(ex == "+0.**********************");
891 assert(ios.width() == 0);
892 }
893 ios.width(25);
894 right(ios);
895 {
896 iter = f.put(output_iterator<char*>(str), ios, '*', v);
897 std::string ex(str, iter.base());
898 assert(ex == "**********************+0.");
899 assert(ios.width() == 0);
900 }
901 ios.width(25);
902 internal(ios);
903 {
904 iter = f.put(output_iterator<char*>(str), ios, '*', v);
905 std::string ex(str, iter.base());
906 assert(ex == "+**********************0.");
907 assert(ios.width() == 0);
908 }
909 }
910 ios.imbue(lg);
911 {
912 ios.width(0);
913 {
914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
915 std::string ex(str, iter.base());
916 assert(ex == "+0;");
917 assert(ios.width() == 0);
918 }
919 ios.width(25);
920 left(ios);
921 {
922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
923 std::string ex(str, iter.base());
924 assert(ex == "+0;**********************");
925 assert(ios.width() == 0);
926 }
927 ios.width(25);
928 right(ios);
929 {
930 iter = f.put(output_iterator<char*>(str), ios, '*', v);
931 std::string ex(str, iter.base());
932 assert(ex == "**********************+0;");
933 assert(ios.width() == 0);
934 }
935 ios.width(25);
936 internal(ios);
937 {
938 iter = f.put(output_iterator<char*>(str), ios, '*', v);
939 std::string ex(str, iter.base());
940 assert(ex == "+**********************0;");
941 assert(ios.width() == 0);
942 }
943 }
944 }
945 }
946 }
947 uppercase(ios);
948 {
949 noshowpos(ios);
950 {
951 noshowpoint(ios);
952 {
953 ios.imbue(lc);
954 {
955 ios.width(0);
956 {
957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
958 std::string ex(str, iter.base());
959 assert(ex == "0");
960 assert(ios.width() == 0);
961 }
962 ios.width(25);
963 left(ios);
964 {
965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
966 std::string ex(str, iter.base());
967 assert(ex == "0************************");
968 assert(ios.width() == 0);
969 }
970 ios.width(25);
971 right(ios);
972 {
973 iter = f.put(output_iterator<char*>(str), ios, '*', v);
974 std::string ex(str, iter.base());
975 assert(ex == "************************0");
976 assert(ios.width() == 0);
977 }
978 ios.width(25);
979 internal(ios);
980 {
981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
982 std::string ex(str, iter.base());
983 assert(ex == "************************0");
984 assert(ios.width() == 0);
985 }
986 }
987 ios.imbue(lg);
988 {
989 ios.width(0);
990 {
991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
992 std::string ex(str, iter.base());
993 assert(ex == "0");
994 assert(ios.width() == 0);
995 }
996 ios.width(25);
997 left(ios);
998 {
999 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1000 std::string ex(str, iter.base());
1001 assert(ex == "0************************");
1002 assert(ios.width() == 0);
1003 }
1004 ios.width(25);
1005 right(ios);
1006 {
1007 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1008 std::string ex(str, iter.base());
1009 assert(ex == "************************0");
1010 assert(ios.width() == 0);
1011 }
1012 ios.width(25);
1013 internal(ios);
1014 {
1015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1016 std::string ex(str, iter.base());
1017 assert(ex == "************************0");
1018 assert(ios.width() == 0);
1019 }
1020 }
1021 }
1022 showpoint(ios);
1023 {
1024 ios.imbue(lc);
1025 {
1026 ios.width(0);
1027 {
1028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1029 std::string ex(str, iter.base());
1030 assert(ex == "0.");
1031 assert(ios.width() == 0);
1032 }
1033 ios.width(25);
1034 left(ios);
1035 {
1036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1037 std::string ex(str, iter.base());
1038 assert(ex == "0.***********************");
1039 assert(ios.width() == 0);
1040 }
1041 ios.width(25);
1042 right(ios);
1043 {
1044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1045 std::string ex(str, iter.base());
1046 assert(ex == "***********************0.");
1047 assert(ios.width() == 0);
1048 }
1049 ios.width(25);
1050 internal(ios);
1051 {
1052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1053 std::string ex(str, iter.base());
1054 assert(ex == "***********************0.");
1055 assert(ios.width() == 0);
1056 }
1057 }
1058 ios.imbue(lg);
1059 {
1060 ios.width(0);
1061 {
1062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1063 std::string ex(str, iter.base());
1064 assert(ex == "0;");
1065 assert(ios.width() == 0);
1066 }
1067 ios.width(25);
1068 left(ios);
1069 {
1070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1071 std::string ex(str, iter.base());
1072 assert(ex == "0;***********************");
1073 assert(ios.width() == 0);
1074 }
1075 ios.width(25);
1076 right(ios);
1077 {
1078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1079 std::string ex(str, iter.base());
1080 assert(ex == "***********************0;");
1081 assert(ios.width() == 0);
1082 }
1083 ios.width(25);
1084 internal(ios);
1085 {
1086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1087 std::string ex(str, iter.base());
1088 assert(ex == "***********************0;");
1089 assert(ios.width() == 0);
1090 }
1091 }
1092 }
1093 }
1094 showpos(ios);
1095 {
1096 noshowpoint(ios);
1097 {
1098 ios.imbue(lc);
1099 {
1100 ios.width(0);
1101 {
1102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1103 std::string ex(str, iter.base());
1104 assert(ex == "+0");
1105 assert(ios.width() == 0);
1106 }
1107 ios.width(25);
1108 left(ios);
1109 {
1110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1111 std::string ex(str, iter.base());
1112 assert(ex == "+0***********************");
1113 assert(ios.width() == 0);
1114 }
1115 ios.width(25);
1116 right(ios);
1117 {
1118 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1119 std::string ex(str, iter.base());
1120 assert(ex == "***********************+0");
1121 assert(ios.width() == 0);
1122 }
1123 ios.width(25);
1124 internal(ios);
1125 {
1126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1127 std::string ex(str, iter.base());
1128 assert(ex == "+***********************0");
1129 assert(ios.width() == 0);
1130 }
1131 }
1132 ios.imbue(lg);
1133 {
1134 ios.width(0);
1135 {
1136 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1137 std::string ex(str, iter.base());
1138 assert(ex == "+0");
1139 assert(ios.width() == 0);
1140 }
1141 ios.width(25);
1142 left(ios);
1143 {
1144 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1145 std::string ex(str, iter.base());
1146 assert(ex == "+0***********************");
1147 assert(ios.width() == 0);
1148 }
1149 ios.width(25);
1150 right(ios);
1151 {
1152 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1153 std::string ex(str, iter.base());
1154 assert(ex == "***********************+0");
1155 assert(ios.width() == 0);
1156 }
1157 ios.width(25);
1158 internal(ios);
1159 {
1160 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1161 std::string ex(str, iter.base());
1162 assert(ex == "+***********************0");
1163 assert(ios.width() == 0);
1164 }
1165 }
1166 }
1167 showpoint(ios);
1168 {
1169 ios.imbue(lc);
1170 {
1171 ios.width(0);
1172 {
1173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1174 std::string ex(str, iter.base());
1175 assert(ex == "+0.");
1176 assert(ios.width() == 0);
1177 }
1178 ios.width(25);
1179 left(ios);
1180 {
1181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1182 std::string ex(str, iter.base());
1183 assert(ex == "+0.**********************");
1184 assert(ios.width() == 0);
1185 }
1186 ios.width(25);
1187 right(ios);
1188 {
1189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1190 std::string ex(str, iter.base());
1191 assert(ex == "**********************+0.");
1192 assert(ios.width() == 0);
1193 }
1194 ios.width(25);
1195 internal(ios);
1196 {
1197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1198 std::string ex(str, iter.base());
1199 assert(ex == "+**********************0.");
1200 assert(ios.width() == 0);
1201 }
1202 }
1203 ios.imbue(lg);
1204 {
1205 ios.width(0);
1206 {
1207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1208 std::string ex(str, iter.base());
1209 assert(ex == "+0;");
1210 assert(ios.width() == 0);
1211 }
1212 ios.width(25);
1213 left(ios);
1214 {
1215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1216 std::string ex(str, iter.base());
1217 assert(ex == "+0;**********************");
1218 assert(ios.width() == 0);
1219 }
1220 ios.width(25);
1221 right(ios);
1222 {
1223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1224 std::string ex(str, iter.base());
1225 assert(ex == "**********************+0;");
1226 assert(ios.width() == 0);
1227 }
1228 ios.width(25);
1229 internal(ios);
1230 {
1231 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1232 std::string ex(str, iter.base());
1233 assert(ex == "+**********************0;");
1234 assert(ios.width() == 0);
1235 }
1236 }
1237 }
1238 }
1239 }
1240 }
1241 ios.precision(6);
1242 {
1243 nouppercase(ios);
1244 {
1245 noshowpos(ios);
1246 {
1247 noshowpoint(ios);
1248 {
1249 ios.imbue(lc);
1250 {
1251 ios.width(0);
1252 {
1253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1254 std::string ex(str, iter.base());
1255 assert(ex == "0");
1256 assert(ios.width() == 0);
1257 }
1258 ios.width(25);
1259 left(ios);
1260 {
1261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1262 std::string ex(str, iter.base());
1263 assert(ex == "0************************");
1264 assert(ios.width() == 0);
1265 }
1266 ios.width(25);
1267 right(ios);
1268 {
1269 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1270 std::string ex(str, iter.base());
1271 assert(ex == "************************0");
1272 assert(ios.width() == 0);
1273 }
1274 ios.width(25);
1275 internal(ios);
1276 {
1277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1278 std::string ex(str, iter.base());
1279 assert(ex == "************************0");
1280 assert(ios.width() == 0);
1281 }
1282 }
1283 ios.imbue(lg);
1284 {
1285 ios.width(0);
1286 {
1287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1288 std::string ex(str, iter.base());
1289 assert(ex == "0");
1290 assert(ios.width() == 0);
1291 }
1292 ios.width(25);
1293 left(ios);
1294 {
1295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1296 std::string ex(str, iter.base());
1297 assert(ex == "0************************");
1298 assert(ios.width() == 0);
1299 }
1300 ios.width(25);
1301 right(ios);
1302 {
1303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1304 std::string ex(str, iter.base());
1305 assert(ex == "************************0");
1306 assert(ios.width() == 0);
1307 }
1308 ios.width(25);
1309 internal(ios);
1310 {
1311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1312 std::string ex(str, iter.base());
1313 assert(ex == "************************0");
1314 assert(ios.width() == 0);
1315 }
1316 }
1317 }
1318 showpoint(ios);
1319 {
1320 ios.imbue(lc);
1321 {
1322 ios.width(0);
1323 {
1324 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1325 std::string ex(str, iter.base());
1326 assert(ex == "0.00000");
1327 assert(ios.width() == 0);
1328 }
1329 ios.width(25);
1330 left(ios);
1331 {
1332 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1333 std::string ex(str, iter.base());
1334 assert(ex == "0.00000******************");
1335 assert(ios.width() == 0);
1336 }
1337 ios.width(25);
1338 right(ios);
1339 {
1340 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1341 std::string ex(str, iter.base());
1342 assert(ex == "******************0.00000");
1343 assert(ios.width() == 0);
1344 }
1345 ios.width(25);
1346 internal(ios);
1347 {
1348 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1349 std::string ex(str, iter.base());
1350 assert(ex == "******************0.00000");
1351 assert(ios.width() == 0);
1352 }
1353 }
1354 ios.imbue(lg);
1355 {
1356 ios.width(0);
1357 {
1358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1359 std::string ex(str, iter.base());
1360 assert(ex == "0;00000");
1361 assert(ios.width() == 0);
1362 }
1363 ios.width(25);
1364 left(ios);
1365 {
1366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1367 std::string ex(str, iter.base());
1368 assert(ex == "0;00000******************");
1369 assert(ios.width() == 0);
1370 }
1371 ios.width(25);
1372 right(ios);
1373 {
1374 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1375 std::string ex(str, iter.base());
1376 assert(ex == "******************0;00000");
1377 assert(ios.width() == 0);
1378 }
1379 ios.width(25);
1380 internal(ios);
1381 {
1382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1383 std::string ex(str, iter.base());
1384 assert(ex == "******************0;00000");
1385 assert(ios.width() == 0);
1386 }
1387 }
1388 }
1389 }
1390 showpos(ios);
1391 {
1392 noshowpoint(ios);
1393 {
1394 ios.imbue(lc);
1395 {
1396 ios.width(0);
1397 {
1398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1399 std::string ex(str, iter.base());
1400 assert(ex == "+0");
1401 assert(ios.width() == 0);
1402 }
1403 ios.width(25);
1404 left(ios);
1405 {
1406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1407 std::string ex(str, iter.base());
1408 assert(ex == "+0***********************");
1409 assert(ios.width() == 0);
1410 }
1411 ios.width(25);
1412 right(ios);
1413 {
1414 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1415 std::string ex(str, iter.base());
1416 assert(ex == "***********************+0");
1417 assert(ios.width() == 0);
1418 }
1419 ios.width(25);
1420 internal(ios);
1421 {
1422 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1423 std::string ex(str, iter.base());
1424 assert(ex == "+***********************0");
1425 assert(ios.width() == 0);
1426 }
1427 }
1428 ios.imbue(lg);
1429 {
1430 ios.width(0);
1431 {
1432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1433 std::string ex(str, iter.base());
1434 assert(ex == "+0");
1435 assert(ios.width() == 0);
1436 }
1437 ios.width(25);
1438 left(ios);
1439 {
1440 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1441 std::string ex(str, iter.base());
1442 assert(ex == "+0***********************");
1443 assert(ios.width() == 0);
1444 }
1445 ios.width(25);
1446 right(ios);
1447 {
1448 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1449 std::string ex(str, iter.base());
1450 assert(ex == "***********************+0");
1451 assert(ios.width() == 0);
1452 }
1453 ios.width(25);
1454 internal(ios);
1455 {
1456 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1457 std::string ex(str, iter.base());
1458 assert(ex == "+***********************0");
1459 assert(ios.width() == 0);
1460 }
1461 }
1462 }
1463 showpoint(ios);
1464 {
1465 ios.imbue(lc);
1466 {
1467 ios.width(0);
1468 {
1469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1470 std::string ex(str, iter.base());
1471 assert(ex == "+0.00000");
1472 assert(ios.width() == 0);
1473 }
1474 ios.width(25);
1475 left(ios);
1476 {
1477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1478 std::string ex(str, iter.base());
1479 assert(ex == "+0.00000*****************");
1480 assert(ios.width() == 0);
1481 }
1482 ios.width(25);
1483 right(ios);
1484 {
1485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1486 std::string ex(str, iter.base());
1487 assert(ex == "*****************+0.00000");
1488 assert(ios.width() == 0);
1489 }
1490 ios.width(25);
1491 internal(ios);
1492 {
1493 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1494 std::string ex(str, iter.base());
1495 assert(ex == "+*****************0.00000");
1496 assert(ios.width() == 0);
1497 }
1498 }
1499 ios.imbue(lg);
1500 {
1501 ios.width(0);
1502 {
1503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1504 std::string ex(str, iter.base());
1505 assert(ex == "+0;00000");
1506 assert(ios.width() == 0);
1507 }
1508 ios.width(25);
1509 left(ios);
1510 {
1511 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1512 std::string ex(str, iter.base());
1513 assert(ex == "+0;00000*****************");
1514 assert(ios.width() == 0);
1515 }
1516 ios.width(25);
1517 right(ios);
1518 {
1519 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1520 std::string ex(str, iter.base());
1521 assert(ex == "*****************+0;00000");
1522 assert(ios.width() == 0);
1523 }
1524 ios.width(25);
1525 internal(ios);
1526 {
1527 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1528 std::string ex(str, iter.base());
1529 assert(ex == "+*****************0;00000");
1530 assert(ios.width() == 0);
1531 }
1532 }
1533 }
1534 }
1535 }
1536 uppercase(ios);
1537 {
1538 noshowpos(ios);
1539 {
1540 noshowpoint(ios);
1541 {
1542 ios.imbue(lc);
1543 {
1544 ios.width(0);
1545 {
1546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1547 std::string ex(str, iter.base());
1548 assert(ex == "0");
1549 assert(ios.width() == 0);
1550 }
1551 ios.width(25);
1552 left(ios);
1553 {
1554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1555 std::string ex(str, iter.base());
1556 assert(ex == "0************************");
1557 assert(ios.width() == 0);
1558 }
1559 ios.width(25);
1560 right(ios);
1561 {
1562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1563 std::string ex(str, iter.base());
1564 assert(ex == "************************0");
1565 assert(ios.width() == 0);
1566 }
1567 ios.width(25);
1568 internal(ios);
1569 {
1570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1571 std::string ex(str, iter.base());
1572 assert(ex == "************************0");
1573 assert(ios.width() == 0);
1574 }
1575 }
1576 ios.imbue(lg);
1577 {
1578 ios.width(0);
1579 {
1580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1581 std::string ex(str, iter.base());
1582 assert(ex == "0");
1583 assert(ios.width() == 0);
1584 }
1585 ios.width(25);
1586 left(ios);
1587 {
1588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1589 std::string ex(str, iter.base());
1590 assert(ex == "0************************");
1591 assert(ios.width() == 0);
1592 }
1593 ios.width(25);
1594 right(ios);
1595 {
1596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1597 std::string ex(str, iter.base());
1598 assert(ex == "************************0");
1599 assert(ios.width() == 0);
1600 }
1601 ios.width(25);
1602 internal(ios);
1603 {
1604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1605 std::string ex(str, iter.base());
1606 assert(ex == "************************0");
1607 assert(ios.width() == 0);
1608 }
1609 }
1610 }
1611 showpoint(ios);
1612 {
1613 ios.imbue(lc);
1614 {
1615 ios.width(0);
1616 {
1617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1618 std::string ex(str, iter.base());
1619 assert(ex == "0.00000");
1620 assert(ios.width() == 0);
1621 }
1622 ios.width(25);
1623 left(ios);
1624 {
1625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1626 std::string ex(str, iter.base());
1627 assert(ex == "0.00000******************");
1628 assert(ios.width() == 0);
1629 }
1630 ios.width(25);
1631 right(ios);
1632 {
1633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1634 std::string ex(str, iter.base());
1635 assert(ex == "******************0.00000");
1636 assert(ios.width() == 0);
1637 }
1638 ios.width(25);
1639 internal(ios);
1640 {
1641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1642 std::string ex(str, iter.base());
1643 assert(ex == "******************0.00000");
1644 assert(ios.width() == 0);
1645 }
1646 }
1647 ios.imbue(lg);
1648 {
1649 ios.width(0);
1650 {
1651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1652 std::string ex(str, iter.base());
1653 assert(ex == "0;00000");
1654 assert(ios.width() == 0);
1655 }
1656 ios.width(25);
1657 left(ios);
1658 {
1659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1660 std::string ex(str, iter.base());
1661 assert(ex == "0;00000******************");
1662 assert(ios.width() == 0);
1663 }
1664 ios.width(25);
1665 right(ios);
1666 {
1667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1668 std::string ex(str, iter.base());
1669 assert(ex == "******************0;00000");
1670 assert(ios.width() == 0);
1671 }
1672 ios.width(25);
1673 internal(ios);
1674 {
1675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1676 std::string ex(str, iter.base());
1677 assert(ex == "******************0;00000");
1678 assert(ios.width() == 0);
1679 }
1680 }
1681 }
1682 }
1683 showpos(ios);
1684 {
1685 noshowpoint(ios);
1686 {
1687 ios.imbue(lc);
1688 {
1689 ios.width(0);
1690 {
1691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1692 std::string ex(str, iter.base());
1693 assert(ex == "+0");
1694 assert(ios.width() == 0);
1695 }
1696 ios.width(25);
1697 left(ios);
1698 {
1699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1700 std::string ex(str, iter.base());
1701 assert(ex == "+0***********************");
1702 assert(ios.width() == 0);
1703 }
1704 ios.width(25);
1705 right(ios);
1706 {
1707 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1708 std::string ex(str, iter.base());
1709 assert(ex == "***********************+0");
1710 assert(ios.width() == 0);
1711 }
1712 ios.width(25);
1713 internal(ios);
1714 {
1715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1716 std::string ex(str, iter.base());
1717 assert(ex == "+***********************0");
1718 assert(ios.width() == 0);
1719 }
1720 }
1721 ios.imbue(lg);
1722 {
1723 ios.width(0);
1724 {
1725 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1726 std::string ex(str, iter.base());
1727 assert(ex == "+0");
1728 assert(ios.width() == 0);
1729 }
1730 ios.width(25);
1731 left(ios);
1732 {
1733 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1734 std::string ex(str, iter.base());
1735 assert(ex == "+0***********************");
1736 assert(ios.width() == 0);
1737 }
1738 ios.width(25);
1739 right(ios);
1740 {
1741 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1742 std::string ex(str, iter.base());
1743 assert(ex == "***********************+0");
1744 assert(ios.width() == 0);
1745 }
1746 ios.width(25);
1747 internal(ios);
1748 {
1749 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1750 std::string ex(str, iter.base());
1751 assert(ex == "+***********************0");
1752 assert(ios.width() == 0);
1753 }
1754 }
1755 }
1756 showpoint(ios);
1757 {
1758 ios.imbue(lc);
1759 {
1760 ios.width(0);
1761 {
1762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1763 std::string ex(str, iter.base());
1764 assert(ex == "+0.00000");
1765 assert(ios.width() == 0);
1766 }
1767 ios.width(25);
1768 left(ios);
1769 {
1770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1771 std::string ex(str, iter.base());
1772 assert(ex == "+0.00000*****************");
1773 assert(ios.width() == 0);
1774 }
1775 ios.width(25);
1776 right(ios);
1777 {
1778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1779 std::string ex(str, iter.base());
1780 assert(ex == "*****************+0.00000");
1781 assert(ios.width() == 0);
1782 }
1783 ios.width(25);
1784 internal(ios);
1785 {
1786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1787 std::string ex(str, iter.base());
1788 assert(ex == "+*****************0.00000");
1789 assert(ios.width() == 0);
1790 }
1791 }
1792 ios.imbue(lg);
1793 {
1794 ios.width(0);
1795 {
1796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1797 std::string ex(str, iter.base());
1798 assert(ex == "+0;00000");
1799 assert(ios.width() == 0);
1800 }
1801 ios.width(25);
1802 left(ios);
1803 {
1804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1805 std::string ex(str, iter.base());
1806 assert(ex == "+0;00000*****************");
1807 assert(ios.width() == 0);
1808 }
1809 ios.width(25);
1810 right(ios);
1811 {
1812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1813 std::string ex(str, iter.base());
1814 assert(ex == "*****************+0;00000");
1815 assert(ios.width() == 0);
1816 }
1817 ios.width(25);
1818 internal(ios);
1819 {
1820 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1821 std::string ex(str, iter.base());
1822 assert(ex == "+*****************0;00000");
1823 assert(ios.width() == 0);
1824 }
1825 }
1826 }
1827 }
1828 }
1829 }
1830 ios.precision(16);
1831 {
1832 nouppercase(ios);
1833 {
1834 noshowpos(ios);
1835 {
1836 noshowpoint(ios);
1837 {
1838 ios.imbue(lc);
1839 {
1840 ios.width(0);
1841 {
1842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1843 std::string ex(str, iter.base());
1844 assert(ex == "0");
1845 assert(ios.width() == 0);
1846 }
1847 ios.width(25);
1848 left(ios);
1849 {
1850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1851 std::string ex(str, iter.base());
1852 assert(ex == "0************************");
1853 assert(ios.width() == 0);
1854 }
1855 ios.width(25);
1856 right(ios);
1857 {
1858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1859 std::string ex(str, iter.base());
1860 assert(ex == "************************0");
1861 assert(ios.width() == 0);
1862 }
1863 ios.width(25);
1864 internal(ios);
1865 {
1866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1867 std::string ex(str, iter.base());
1868 assert(ex == "************************0");
1869 assert(ios.width() == 0);
1870 }
1871 }
1872 ios.imbue(lg);
1873 {
1874 ios.width(0);
1875 {
1876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1877 std::string ex(str, iter.base());
1878 assert(ex == "0");
1879 assert(ios.width() == 0);
1880 }
1881 ios.width(25);
1882 left(ios);
1883 {
1884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1885 std::string ex(str, iter.base());
1886 assert(ex == "0************************");
1887 assert(ios.width() == 0);
1888 }
1889 ios.width(25);
1890 right(ios);
1891 {
1892 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1893 std::string ex(str, iter.base());
1894 assert(ex == "************************0");
1895 assert(ios.width() == 0);
1896 }
1897 ios.width(25);
1898 internal(ios);
1899 {
1900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1901 std::string ex(str, iter.base());
1902 assert(ex == "************************0");
1903 assert(ios.width() == 0);
1904 }
1905 }
1906 }
1907 showpoint(ios);
1908 {
1909 ios.imbue(lc);
1910 {
1911 ios.width(0);
1912 {
1913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1914 std::string ex(str, iter.base());
1915 assert(ex == "0.000000000000000");
1916 assert(ios.width() == 0);
1917 }
1918 ios.width(25);
1919 left(ios);
1920 {
1921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1922 std::string ex(str, iter.base());
1923 assert(ex == "0.000000000000000********");
1924 assert(ios.width() == 0);
1925 }
1926 ios.width(25);
1927 right(ios);
1928 {
1929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1930 std::string ex(str, iter.base());
1931 assert(ex == "********0.000000000000000");
1932 assert(ios.width() == 0);
1933 }
1934 ios.width(25);
1935 internal(ios);
1936 {
1937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1938 std::string ex(str, iter.base());
1939 assert(ex == "********0.000000000000000");
1940 assert(ios.width() == 0);
1941 }
1942 }
1943 ios.imbue(lg);
1944 {
1945 ios.width(0);
1946 {
1947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1948 std::string ex(str, iter.base());
1949 assert(ex == "0;000000000000000");
1950 assert(ios.width() == 0);
1951 }
1952 ios.width(25);
1953 left(ios);
1954 {
1955 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1956 std::string ex(str, iter.base());
1957 assert(ex == "0;000000000000000********");
1958 assert(ios.width() == 0);
1959 }
1960 ios.width(25);
1961 right(ios);
1962 {
1963 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1964 std::string ex(str, iter.base());
1965 assert(ex == "********0;000000000000000");
1966 assert(ios.width() == 0);
1967 }
1968 ios.width(25);
1969 internal(ios);
1970 {
1971 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1972 std::string ex(str, iter.base());
1973 assert(ex == "********0;000000000000000");
1974 assert(ios.width() == 0);
1975 }
1976 }
1977 }
1978 }
1979 showpos(ios);
1980 {
1981 noshowpoint(ios);
1982 {
1983 ios.imbue(lc);
1984 {
1985 ios.width(0);
1986 {
1987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1988 std::string ex(str, iter.base());
1989 assert(ex == "+0");
1990 assert(ios.width() == 0);
1991 }
1992 ios.width(25);
1993 left(ios);
1994 {
1995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1996 std::string ex(str, iter.base());
1997 assert(ex == "+0***********************");
1998 assert(ios.width() == 0);
1999 }
2000 ios.width(25);
2001 right(ios);
2002 {
2003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2004 std::string ex(str, iter.base());
2005 assert(ex == "***********************+0");
2006 assert(ios.width() == 0);
2007 }
2008 ios.width(25);
2009 internal(ios);
2010 {
2011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2012 std::string ex(str, iter.base());
2013 assert(ex == "+***********************0");
2014 assert(ios.width() == 0);
2015 }
2016 }
2017 ios.imbue(lg);
2018 {
2019 ios.width(0);
2020 {
2021 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2022 std::string ex(str, iter.base());
2023 assert(ex == "+0");
2024 assert(ios.width() == 0);
2025 }
2026 ios.width(25);
2027 left(ios);
2028 {
2029 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2030 std::string ex(str, iter.base());
2031 assert(ex == "+0***********************");
2032 assert(ios.width() == 0);
2033 }
2034 ios.width(25);
2035 right(ios);
2036 {
2037 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2038 std::string ex(str, iter.base());
2039 assert(ex == "***********************+0");
2040 assert(ios.width() == 0);
2041 }
2042 ios.width(25);
2043 internal(ios);
2044 {
2045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2046 std::string ex(str, iter.base());
2047 assert(ex == "+***********************0");
2048 assert(ios.width() == 0);
2049 }
2050 }
2051 }
2052 showpoint(ios);
2053 {
2054 ios.imbue(lc);
2055 {
2056 ios.width(0);
2057 {
2058 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2059 std::string ex(str, iter.base());
2060 assert(ex == "+0.000000000000000");
2061 assert(ios.width() == 0);
2062 }
2063 ios.width(25);
2064 left(ios);
2065 {
2066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2067 std::string ex(str, iter.base());
2068 assert(ex == "+0.000000000000000*******");
2069 assert(ios.width() == 0);
2070 }
2071 ios.width(25);
2072 right(ios);
2073 {
2074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2075 std::string ex(str, iter.base());
2076 assert(ex == "*******+0.000000000000000");
2077 assert(ios.width() == 0);
2078 }
2079 ios.width(25);
2080 internal(ios);
2081 {
2082 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2083 std::string ex(str, iter.base());
2084 assert(ex == "+*******0.000000000000000");
2085 assert(ios.width() == 0);
2086 }
2087 }
2088 ios.imbue(lg);
2089 {
2090 ios.width(0);
2091 {
2092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2093 std::string ex(str, iter.base());
2094 assert(ex == "+0;000000000000000");
2095 assert(ios.width() == 0);
2096 }
2097 ios.width(25);
2098 left(ios);
2099 {
2100 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2101 std::string ex(str, iter.base());
2102 assert(ex == "+0;000000000000000*******");
2103 assert(ios.width() == 0);
2104 }
2105 ios.width(25);
2106 right(ios);
2107 {
2108 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2109 std::string ex(str, iter.base());
2110 assert(ex == "*******+0;000000000000000");
2111 assert(ios.width() == 0);
2112 }
2113 ios.width(25);
2114 internal(ios);
2115 {
2116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2117 std::string ex(str, iter.base());
2118 assert(ex == "+*******0;000000000000000");
2119 assert(ios.width() == 0);
2120 }
2121 }
2122 }
2123 }
2124 }
2125 uppercase(ios);
2126 {
2127 noshowpos(ios);
2128 {
2129 noshowpoint(ios);
2130 {
2131 ios.imbue(lc);
2132 {
2133 ios.width(0);
2134 {
2135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2136 std::string ex(str, iter.base());
2137 assert(ex == "0");
2138 assert(ios.width() == 0);
2139 }
2140 ios.width(25);
2141 left(ios);
2142 {
2143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2144 std::string ex(str, iter.base());
2145 assert(ex == "0************************");
2146 assert(ios.width() == 0);
2147 }
2148 ios.width(25);
2149 right(ios);
2150 {
2151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2152 std::string ex(str, iter.base());
2153 assert(ex == "************************0");
2154 assert(ios.width() == 0);
2155 }
2156 ios.width(25);
2157 internal(ios);
2158 {
2159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2160 std::string ex(str, iter.base());
2161 assert(ex == "************************0");
2162 assert(ios.width() == 0);
2163 }
2164 }
2165 ios.imbue(lg);
2166 {
2167 ios.width(0);
2168 {
2169 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2170 std::string ex(str, iter.base());
2171 assert(ex == "0");
2172 assert(ios.width() == 0);
2173 }
2174 ios.width(25);
2175 left(ios);
2176 {
2177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2178 std::string ex(str, iter.base());
2179 assert(ex == "0************************");
2180 assert(ios.width() == 0);
2181 }
2182 ios.width(25);
2183 right(ios);
2184 {
2185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2186 std::string ex(str, iter.base());
2187 assert(ex == "************************0");
2188 assert(ios.width() == 0);
2189 }
2190 ios.width(25);
2191 internal(ios);
2192 {
2193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2194 std::string ex(str, iter.base());
2195 assert(ex == "************************0");
2196 assert(ios.width() == 0);
2197 }
2198 }
2199 }
2200 showpoint(ios);
2201 {
2202 ios.imbue(lc);
2203 {
2204 ios.width(0);
2205 {
2206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2207 std::string ex(str, iter.base());
2208 assert(ex == "0.000000000000000");
2209 assert(ios.width() == 0);
2210 }
2211 ios.width(25);
2212 left(ios);
2213 {
2214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2215 std::string ex(str, iter.base());
2216 assert(ex == "0.000000000000000********");
2217 assert(ios.width() == 0);
2218 }
2219 ios.width(25);
2220 right(ios);
2221 {
2222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2223 std::string ex(str, iter.base());
2224 assert(ex == "********0.000000000000000");
2225 assert(ios.width() == 0);
2226 }
2227 ios.width(25);
2228 internal(ios);
2229 {
2230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2231 std::string ex(str, iter.base());
2232 assert(ex == "********0.000000000000000");
2233 assert(ios.width() == 0);
2234 }
2235 }
2236 ios.imbue(lg);
2237 {
2238 ios.width(0);
2239 {
2240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2241 std::string ex(str, iter.base());
2242 assert(ex == "0;000000000000000");
2243 assert(ios.width() == 0);
2244 }
2245 ios.width(25);
2246 left(ios);
2247 {
2248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2249 std::string ex(str, iter.base());
2250 assert(ex == "0;000000000000000********");
2251 assert(ios.width() == 0);
2252 }
2253 ios.width(25);
2254 right(ios);
2255 {
2256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2257 std::string ex(str, iter.base());
2258 assert(ex == "********0;000000000000000");
2259 assert(ios.width() == 0);
2260 }
2261 ios.width(25);
2262 internal(ios);
2263 {
2264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2265 std::string ex(str, iter.base());
2266 assert(ex == "********0;000000000000000");
2267 assert(ios.width() == 0);
2268 }
2269 }
2270 }
2271 }
2272 showpos(ios);
2273 {
2274 noshowpoint(ios);
2275 {
2276 ios.imbue(lc);
2277 {
2278 ios.width(0);
2279 {
2280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2281 std::string ex(str, iter.base());
2282 assert(ex == "+0");
2283 assert(ios.width() == 0);
2284 }
2285 ios.width(25);
2286 left(ios);
2287 {
2288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2289 std::string ex(str, iter.base());
2290 assert(ex == "+0***********************");
2291 assert(ios.width() == 0);
2292 }
2293 ios.width(25);
2294 right(ios);
2295 {
2296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2297 std::string ex(str, iter.base());
2298 assert(ex == "***********************+0");
2299 assert(ios.width() == 0);
2300 }
2301 ios.width(25);
2302 internal(ios);
2303 {
2304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2305 std::string ex(str, iter.base());
2306 assert(ex == "+***********************0");
2307 assert(ios.width() == 0);
2308 }
2309 }
2310 ios.imbue(lg);
2311 {
2312 ios.width(0);
2313 {
2314 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2315 std::string ex(str, iter.base());
2316 assert(ex == "+0");
2317 assert(ios.width() == 0);
2318 }
2319 ios.width(25);
2320 left(ios);
2321 {
2322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2323 std::string ex(str, iter.base());
2324 assert(ex == "+0***********************");
2325 assert(ios.width() == 0);
2326 }
2327 ios.width(25);
2328 right(ios);
2329 {
2330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2331 std::string ex(str, iter.base());
2332 assert(ex == "***********************+0");
2333 assert(ios.width() == 0);
2334 }
2335 ios.width(25);
2336 internal(ios);
2337 {
2338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2339 std::string ex(str, iter.base());
2340 assert(ex == "+***********************0");
2341 assert(ios.width() == 0);
2342 }
2343 }
2344 }
2345 showpoint(ios);
2346 {
2347 ios.imbue(lc);
2348 {
2349 ios.width(0);
2350 {
2351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2352 std::string ex(str, iter.base());
2353 assert(ex == "+0.000000000000000");
2354 assert(ios.width() == 0);
2355 }
2356 ios.width(25);
2357 left(ios);
2358 {
2359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2360 std::string ex(str, iter.base());
2361 assert(ex == "+0.000000000000000*******");
2362 assert(ios.width() == 0);
2363 }
2364 ios.width(25);
2365 right(ios);
2366 {
2367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2368 std::string ex(str, iter.base());
2369 assert(ex == "*******+0.000000000000000");
2370 assert(ios.width() == 0);
2371 }
2372 ios.width(25);
2373 internal(ios);
2374 {
2375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2376 std::string ex(str, iter.base());
2377 assert(ex == "+*******0.000000000000000");
2378 assert(ios.width() == 0);
2379 }
2380 }
2381 ios.imbue(lg);
2382 {
2383 ios.width(0);
2384 {
2385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2386 std::string ex(str, iter.base());
2387 assert(ex == "+0;000000000000000");
2388 assert(ios.width() == 0);
2389 }
2390 ios.width(25);
2391 left(ios);
2392 {
2393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2394 std::string ex(str, iter.base());
2395 assert(ex == "+0;000000000000000*******");
2396 assert(ios.width() == 0);
2397 }
2398 ios.width(25);
2399 right(ios);
2400 {
2401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2402 std::string ex(str, iter.base());
2403 assert(ex == "*******+0;000000000000000");
2404 assert(ios.width() == 0);
2405 }
2406 ios.width(25);
2407 internal(ios);
2408 {
2409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2410 std::string ex(str, iter.base());
2411 assert(ex == "+*******0;000000000000000");
2412 assert(ios.width() == 0);
2413 }
2414 }
2415 }
2416 }
2417 }
2418 }
2419 ios.precision(60);
2420 {
2421 nouppercase(ios);
2422 {
2423 noshowpos(ios);
2424 {
2425 noshowpoint(ios);
2426 {
2427 ios.imbue(lc);
2428 {
2429 ios.width(0);
2430 {
2431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2432 std::string ex(str, iter.base());
2433 assert(ex == "0");
2434 assert(ios.width() == 0);
2435 }
2436 ios.width(25);
2437 left(ios);
2438 {
2439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2440 std::string ex(str, iter.base());
2441 assert(ex == "0************************");
2442 assert(ios.width() == 0);
2443 }
2444 ios.width(25);
2445 right(ios);
2446 {
2447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2448 std::string ex(str, iter.base());
2449 assert(ex == "************************0");
2450 assert(ios.width() == 0);
2451 }
2452 ios.width(25);
2453 internal(ios);
2454 {
2455 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2456 std::string ex(str, iter.base());
2457 assert(ex == "************************0");
2458 assert(ios.width() == 0);
2459 }
2460 }
2461 ios.imbue(lg);
2462 {
2463 ios.width(0);
2464 {
2465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2466 std::string ex(str, iter.base());
2467 assert(ex == "0");
2468 assert(ios.width() == 0);
2469 }
2470 ios.width(25);
2471 left(ios);
2472 {
2473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2474 std::string ex(str, iter.base());
2475 assert(ex == "0************************");
2476 assert(ios.width() == 0);
2477 }
2478 ios.width(25);
2479 right(ios);
2480 {
2481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2482 std::string ex(str, iter.base());
2483 assert(ex == "************************0");
2484 assert(ios.width() == 0);
2485 }
2486 ios.width(25);
2487 internal(ios);
2488 {
2489 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2490 std::string ex(str, iter.base());
2491 assert(ex == "************************0");
2492 assert(ios.width() == 0);
2493 }
2494 }
2495 }
2496 showpoint(ios);
2497 {
2498 ios.imbue(lc);
2499 {
2500 ios.width(0);
2501 {
2502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2503 std::string ex(str, iter.base());
2504 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2505 assert(ios.width() == 0);
2506 }
2507 ios.width(25);
2508 left(ios);
2509 {
2510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2511 std::string ex(str, iter.base());
2512 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2513 assert(ios.width() == 0);
2514 }
2515 ios.width(25);
2516 right(ios);
2517 {
2518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2519 std::string ex(str, iter.base());
2520 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2521 assert(ios.width() == 0);
2522 }
2523 ios.width(25);
2524 internal(ios);
2525 {
2526 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2527 std::string ex(str, iter.base());
2528 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2529 assert(ios.width() == 0);
2530 }
2531 }
2532 ios.imbue(lg);
2533 {
2534 ios.width(0);
2535 {
2536 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2537 std::string ex(str, iter.base());
2538 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2539 assert(ios.width() == 0);
2540 }
2541 ios.width(25);
2542 left(ios);
2543 {
2544 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2545 std::string ex(str, iter.base());
2546 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2547 assert(ios.width() == 0);
2548 }
2549 ios.width(25);
2550 right(ios);
2551 {
2552 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2553 std::string ex(str, iter.base());
2554 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2555 assert(ios.width() == 0);
2556 }
2557 ios.width(25);
2558 internal(ios);
2559 {
2560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2561 std::string ex(str, iter.base());
2562 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2563 assert(ios.width() == 0);
2564 }
2565 }
2566 }
2567 }
2568 showpos(ios);
2569 {
2570 noshowpoint(ios);
2571 {
2572 ios.imbue(lc);
2573 {
2574 ios.width(0);
2575 {
2576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2577 std::string ex(str, iter.base());
2578 assert(ex == "+0");
2579 assert(ios.width() == 0);
2580 }
2581 ios.width(25);
2582 left(ios);
2583 {
2584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2585 std::string ex(str, iter.base());
2586 assert(ex == "+0***********************");
2587 assert(ios.width() == 0);
2588 }
2589 ios.width(25);
2590 right(ios);
2591 {
2592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2593 std::string ex(str, iter.base());
2594 assert(ex == "***********************+0");
2595 assert(ios.width() == 0);
2596 }
2597 ios.width(25);
2598 internal(ios);
2599 {
2600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2601 std::string ex(str, iter.base());
2602 assert(ex == "+***********************0");
2603 assert(ios.width() == 0);
2604 }
2605 }
2606 ios.imbue(lg);
2607 {
2608 ios.width(0);
2609 {
2610 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2611 std::string ex(str, iter.base());
2612 assert(ex == "+0");
2613 assert(ios.width() == 0);
2614 }
2615 ios.width(25);
2616 left(ios);
2617 {
2618 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2619 std::string ex(str, iter.base());
2620 assert(ex == "+0***********************");
2621 assert(ios.width() == 0);
2622 }
2623 ios.width(25);
2624 right(ios);
2625 {
2626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2627 std::string ex(str, iter.base());
2628 assert(ex == "***********************+0");
2629 assert(ios.width() == 0);
2630 }
2631 ios.width(25);
2632 internal(ios);
2633 {
2634 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2635 std::string ex(str, iter.base());
2636 assert(ex == "+***********************0");
2637 assert(ios.width() == 0);
2638 }
2639 }
2640 }
2641 showpoint(ios);
2642 {
2643 ios.imbue(lc);
2644 {
2645 ios.width(0);
2646 {
2647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2648 std::string ex(str, iter.base());
2649 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2650 assert(ios.width() == 0);
2651 }
2652 ios.width(25);
2653 left(ios);
2654 {
2655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2656 std::string ex(str, iter.base());
2657 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2658 assert(ios.width() == 0);
2659 }
2660 ios.width(25);
2661 right(ios);
2662 {
2663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2664 std::string ex(str, iter.base());
2665 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2666 assert(ios.width() == 0);
2667 }
2668 ios.width(25);
2669 internal(ios);
2670 {
2671 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2672 std::string ex(str, iter.base());
2673 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2674 assert(ios.width() == 0);
2675 }
2676 }
2677 ios.imbue(lg);
2678 {
2679 ios.width(0);
2680 {
2681 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2682 std::string ex(str, iter.base());
2683 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2684 assert(ios.width() == 0);
2685 }
2686 ios.width(25);
2687 left(ios);
2688 {
2689 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2690 std::string ex(str, iter.base());
2691 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2692 assert(ios.width() == 0);
2693 }
2694 ios.width(25);
2695 right(ios);
2696 {
2697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2698 std::string ex(str, iter.base());
2699 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2700 assert(ios.width() == 0);
2701 }
2702 ios.width(25);
2703 internal(ios);
2704 {
2705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2706 std::string ex(str, iter.base());
2707 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2708 assert(ios.width() == 0);
2709 }
2710 }
2711 }
2712 }
2713 }
2714 uppercase(ios);
2715 {
2716 noshowpos(ios);
2717 {
2718 noshowpoint(ios);
2719 {
2720 ios.imbue(lc);
2721 {
2722 ios.width(0);
2723 {
2724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2725 std::string ex(str, iter.base());
2726 assert(ex == "0");
2727 assert(ios.width() == 0);
2728 }
2729 ios.width(25);
2730 left(ios);
2731 {
2732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2733 std::string ex(str, iter.base());
2734 assert(ex == "0************************");
2735 assert(ios.width() == 0);
2736 }
2737 ios.width(25);
2738 right(ios);
2739 {
2740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2741 std::string ex(str, iter.base());
2742 assert(ex == "************************0");
2743 assert(ios.width() == 0);
2744 }
2745 ios.width(25);
2746 internal(ios);
2747 {
2748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2749 std::string ex(str, iter.base());
2750 assert(ex == "************************0");
2751 assert(ios.width() == 0);
2752 }
2753 }
2754 ios.imbue(lg);
2755 {
2756 ios.width(0);
2757 {
2758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2759 std::string ex(str, iter.base());
2760 assert(ex == "0");
2761 assert(ios.width() == 0);
2762 }
2763 ios.width(25);
2764 left(ios);
2765 {
2766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2767 std::string ex(str, iter.base());
2768 assert(ex == "0************************");
2769 assert(ios.width() == 0);
2770 }
2771 ios.width(25);
2772 right(ios);
2773 {
2774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2775 std::string ex(str, iter.base());
2776 assert(ex == "************************0");
2777 assert(ios.width() == 0);
2778 }
2779 ios.width(25);
2780 internal(ios);
2781 {
2782 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2783 std::string ex(str, iter.base());
2784 assert(ex == "************************0");
2785 assert(ios.width() == 0);
2786 }
2787 }
2788 }
2789 showpoint(ios);
2790 {
2791 ios.imbue(lc);
2792 {
2793 ios.width(0);
2794 {
2795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2796 std::string ex(str, iter.base());
2797 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2798 assert(ios.width() == 0);
2799 }
2800 ios.width(25);
2801 left(ios);
2802 {
2803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2804 std::string ex(str, iter.base());
2805 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2806 assert(ios.width() == 0);
2807 }
2808 ios.width(25);
2809 right(ios);
2810 {
2811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2812 std::string ex(str, iter.base());
2813 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2814 assert(ios.width() == 0);
2815 }
2816 ios.width(25);
2817 internal(ios);
2818 {
2819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2820 std::string ex(str, iter.base());
2821 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2822 assert(ios.width() == 0);
2823 }
2824 }
2825 ios.imbue(lg);
2826 {
2827 ios.width(0);
2828 {
2829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2830 std::string ex(str, iter.base());
2831 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2832 assert(ios.width() == 0);
2833 }
2834 ios.width(25);
2835 left(ios);
2836 {
2837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2838 std::string ex(str, iter.base());
2839 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2840 assert(ios.width() == 0);
2841 }
2842 ios.width(25);
2843 right(ios);
2844 {
2845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2846 std::string ex(str, iter.base());
2847 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2848 assert(ios.width() == 0);
2849 }
2850 ios.width(25);
2851 internal(ios);
2852 {
2853 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2854 std::string ex(str, iter.base());
2855 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2856 assert(ios.width() == 0);
2857 }
2858 }
2859 }
2860 }
2861 showpos(ios);
2862 {
2863 noshowpoint(ios);
2864 {
2865 ios.imbue(lc);
2866 {
2867 ios.width(0);
2868 {
2869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2870 std::string ex(str, iter.base());
2871 assert(ex == "+0");
2872 assert(ios.width() == 0);
2873 }
2874 ios.width(25);
2875 left(ios);
2876 {
2877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2878 std::string ex(str, iter.base());
2879 assert(ex == "+0***********************");
2880 assert(ios.width() == 0);
2881 }
2882 ios.width(25);
2883 right(ios);
2884 {
2885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2886 std::string ex(str, iter.base());
2887 assert(ex == "***********************+0");
2888 assert(ios.width() == 0);
2889 }
2890 ios.width(25);
2891 internal(ios);
2892 {
2893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2894 std::string ex(str, iter.base());
2895 assert(ex == "+***********************0");
2896 assert(ios.width() == 0);
2897 }
2898 }
2899 ios.imbue(lg);
2900 {
2901 ios.width(0);
2902 {
2903 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2904 std::string ex(str, iter.base());
2905 assert(ex == "+0");
2906 assert(ios.width() == 0);
2907 }
2908 ios.width(25);
2909 left(ios);
2910 {
2911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2912 std::string ex(str, iter.base());
2913 assert(ex == "+0***********************");
2914 assert(ios.width() == 0);
2915 }
2916 ios.width(25);
2917 right(ios);
2918 {
2919 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2920 std::string ex(str, iter.base());
2921 assert(ex == "***********************+0");
2922 assert(ios.width() == 0);
2923 }
2924 ios.width(25);
2925 internal(ios);
2926 {
2927 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2928 std::string ex(str, iter.base());
2929 assert(ex == "+***********************0");
2930 assert(ios.width() == 0);
2931 }
2932 }
2933 }
2934 showpoint(ios);
2935 {
2936 ios.imbue(lc);
2937 {
2938 ios.width(0);
2939 {
2940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2941 std::string ex(str, iter.base());
2942 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2943 assert(ios.width() == 0);
2944 }
2945 ios.width(25);
2946 left(ios);
2947 {
2948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2949 std::string ex(str, iter.base());
2950 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2951 assert(ios.width() == 0);
2952 }
2953 ios.width(25);
2954 right(ios);
2955 {
2956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2957 std::string ex(str, iter.base());
2958 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2959 assert(ios.width() == 0);
2960 }
2961 ios.width(25);
2962 internal(ios);
2963 {
2964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2965 std::string ex(str, iter.base());
2966 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2967 assert(ios.width() == 0);
2968 }
2969 }
2970 ios.imbue(lg);
2971 {
2972 ios.width(0);
2973 {
2974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2975 std::string ex(str, iter.base());
2976 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2977 assert(ios.width() == 0);
2978 }
2979 ios.width(25);
2980 left(ios);
2981 {
2982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2983 std::string ex(str, iter.base());
2984 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2985 assert(ios.width() == 0);
2986 }
2987 ios.width(25);
2988 right(ios);
2989 {
2990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2991 std::string ex(str, iter.base());
2992 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2993 assert(ios.width() == 0);
2994 }
2995 ios.width(25);
2996 internal(ios);
2997 {
2998 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2999 std::string ex(str, iter.base());
3000 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
3001 assert(ios.width() == 0);
3002 }
3003 }
3004 }
3005 }
3006 }
3007 }
3008 }
3009 }
3010 }
3011
test2()3012 void test2()
3013 {
3014 char str[200];
3015 output_iterator<char*> iter;
3016 std::locale lc = std::locale::classic();
3017 std::locale lg(lc, new my_numpunct);
3018 const my_facet f(1);
3019 {
3020 long double v = -0.;
3021 std::ios ios(0);
3022 // %g
3023 {
3024 ios.precision(0);
3025 {
3026 nouppercase(ios);
3027 {
3028 noshowpos(ios);
3029 {
3030 noshowpoint(ios);
3031 {
3032 ios.imbue(lc);
3033 {
3034 ios.width(0);
3035 {
3036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3037 std::string ex(str, iter.base());
3038 assert(ex == "-0");
3039 assert(ios.width() == 0);
3040 }
3041 ios.width(25);
3042 left(ios);
3043 {
3044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3045 std::string ex(str, iter.base());
3046 assert(ex == "-0***********************");
3047 assert(ios.width() == 0);
3048 }
3049 ios.width(25);
3050 right(ios);
3051 {
3052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3053 std::string ex(str, iter.base());
3054 assert(ex == "***********************-0");
3055 assert(ios.width() == 0);
3056 }
3057 ios.width(25);
3058 internal(ios);
3059 {
3060 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3061 std::string ex(str, iter.base());
3062 assert(ex == "-***********************0");
3063 assert(ios.width() == 0);
3064 }
3065 }
3066 ios.imbue(lg);
3067 {
3068 ios.width(0);
3069 {
3070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3071 std::string ex(str, iter.base());
3072 assert(ex == "-0");
3073 assert(ios.width() == 0);
3074 }
3075 ios.width(25);
3076 left(ios);
3077 {
3078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3079 std::string ex(str, iter.base());
3080 assert(ex == "-0***********************");
3081 assert(ios.width() == 0);
3082 }
3083 ios.width(25);
3084 right(ios);
3085 {
3086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3087 std::string ex(str, iter.base());
3088 assert(ex == "***********************-0");
3089 assert(ios.width() == 0);
3090 }
3091 ios.width(25);
3092 internal(ios);
3093 {
3094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3095 std::string ex(str, iter.base());
3096 assert(ex == "-***********************0");
3097 assert(ios.width() == 0);
3098 }
3099 }
3100 }
3101 showpoint(ios);
3102 {
3103 ios.imbue(lc);
3104 {
3105 ios.width(0);
3106 {
3107 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3108 std::string ex(str, iter.base());
3109 assert(ex == "-0.");
3110 assert(ios.width() == 0);
3111 }
3112 ios.width(25);
3113 left(ios);
3114 {
3115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3116 std::string ex(str, iter.base());
3117 assert(ex == "-0.**********************");
3118 assert(ios.width() == 0);
3119 }
3120 ios.width(25);
3121 right(ios);
3122 {
3123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3124 std::string ex(str, iter.base());
3125 assert(ex == "**********************-0.");
3126 assert(ios.width() == 0);
3127 }
3128 ios.width(25);
3129 internal(ios);
3130 {
3131 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3132 std::string ex(str, iter.base());
3133 assert(ex == "-**********************0.");
3134 assert(ios.width() == 0);
3135 }
3136 }
3137 ios.imbue(lg);
3138 {
3139 ios.width(0);
3140 {
3141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3142 std::string ex(str, iter.base());
3143 assert(ex == "-0;");
3144 assert(ios.width() == 0);
3145 }
3146 ios.width(25);
3147 left(ios);
3148 {
3149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3150 std::string ex(str, iter.base());
3151 assert(ex == "-0;**********************");
3152 assert(ios.width() == 0);
3153 }
3154 ios.width(25);
3155 right(ios);
3156 {
3157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3158 std::string ex(str, iter.base());
3159 assert(ex == "**********************-0;");
3160 assert(ios.width() == 0);
3161 }
3162 ios.width(25);
3163 internal(ios);
3164 {
3165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3166 std::string ex(str, iter.base());
3167 assert(ex == "-**********************0;");
3168 assert(ios.width() == 0);
3169 }
3170 }
3171 }
3172 }
3173 showpos(ios);
3174 {
3175 noshowpoint(ios);
3176 {
3177 ios.imbue(lc);
3178 {
3179 ios.width(0);
3180 {
3181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3182 std::string ex(str, iter.base());
3183 assert(ex == "-0");
3184 assert(ios.width() == 0);
3185 }
3186 ios.width(25);
3187 left(ios);
3188 {
3189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3190 std::string ex(str, iter.base());
3191 assert(ex == "-0***********************");
3192 assert(ios.width() == 0);
3193 }
3194 ios.width(25);
3195 right(ios);
3196 {
3197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3198 std::string ex(str, iter.base());
3199 assert(ex == "***********************-0");
3200 assert(ios.width() == 0);
3201 }
3202 ios.width(25);
3203 internal(ios);
3204 {
3205 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3206 std::string ex(str, iter.base());
3207 assert(ex == "-***********************0");
3208 assert(ios.width() == 0);
3209 }
3210 }
3211 ios.imbue(lg);
3212 {
3213 ios.width(0);
3214 {
3215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3216 std::string ex(str, iter.base());
3217 assert(ex == "-0");
3218 assert(ios.width() == 0);
3219 }
3220 ios.width(25);
3221 left(ios);
3222 {
3223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3224 std::string ex(str, iter.base());
3225 assert(ex == "-0***********************");
3226 assert(ios.width() == 0);
3227 }
3228 ios.width(25);
3229 right(ios);
3230 {
3231 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3232 std::string ex(str, iter.base());
3233 assert(ex == "***********************-0");
3234 assert(ios.width() == 0);
3235 }
3236 ios.width(25);
3237 internal(ios);
3238 {
3239 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3240 std::string ex(str, iter.base());
3241 assert(ex == "-***********************0");
3242 assert(ios.width() == 0);
3243 }
3244 }
3245 }
3246 showpoint(ios);
3247 {
3248 ios.imbue(lc);
3249 {
3250 ios.width(0);
3251 {
3252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3253 std::string ex(str, iter.base());
3254 assert(ex == "-0.");
3255 assert(ios.width() == 0);
3256 }
3257 ios.width(25);
3258 left(ios);
3259 {
3260 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3261 std::string ex(str, iter.base());
3262 assert(ex == "-0.**********************");
3263 assert(ios.width() == 0);
3264 }
3265 ios.width(25);
3266 right(ios);
3267 {
3268 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3269 std::string ex(str, iter.base());
3270 assert(ex == "**********************-0.");
3271 assert(ios.width() == 0);
3272 }
3273 ios.width(25);
3274 internal(ios);
3275 {
3276 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3277 std::string ex(str, iter.base());
3278 assert(ex == "-**********************0.");
3279 assert(ios.width() == 0);
3280 }
3281 }
3282 ios.imbue(lg);
3283 {
3284 ios.width(0);
3285 {
3286 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3287 std::string ex(str, iter.base());
3288 assert(ex == "-0;");
3289 assert(ios.width() == 0);
3290 }
3291 ios.width(25);
3292 left(ios);
3293 {
3294 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3295 std::string ex(str, iter.base());
3296 assert(ex == "-0;**********************");
3297 assert(ios.width() == 0);
3298 }
3299 ios.width(25);
3300 right(ios);
3301 {
3302 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3303 std::string ex(str, iter.base());
3304 assert(ex == "**********************-0;");
3305 assert(ios.width() == 0);
3306 }
3307 ios.width(25);
3308 internal(ios);
3309 {
3310 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3311 std::string ex(str, iter.base());
3312 assert(ex == "-**********************0;");
3313 assert(ios.width() == 0);
3314 }
3315 }
3316 }
3317 }
3318 }
3319 uppercase(ios);
3320 {
3321 noshowpos(ios);
3322 {
3323 noshowpoint(ios);
3324 {
3325 ios.imbue(lc);
3326 {
3327 ios.width(0);
3328 {
3329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3330 std::string ex(str, iter.base());
3331 assert(ex == "-0");
3332 assert(ios.width() == 0);
3333 }
3334 ios.width(25);
3335 left(ios);
3336 {
3337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3338 std::string ex(str, iter.base());
3339 assert(ex == "-0***********************");
3340 assert(ios.width() == 0);
3341 }
3342 ios.width(25);
3343 right(ios);
3344 {
3345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3346 std::string ex(str, iter.base());
3347 assert(ex == "***********************-0");
3348 assert(ios.width() == 0);
3349 }
3350 ios.width(25);
3351 internal(ios);
3352 {
3353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3354 std::string ex(str, iter.base());
3355 assert(ex == "-***********************0");
3356 assert(ios.width() == 0);
3357 }
3358 }
3359 ios.imbue(lg);
3360 {
3361 ios.width(0);
3362 {
3363 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3364 std::string ex(str, iter.base());
3365 assert(ex == "-0");
3366 assert(ios.width() == 0);
3367 }
3368 ios.width(25);
3369 left(ios);
3370 {
3371 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3372 std::string ex(str, iter.base());
3373 assert(ex == "-0***********************");
3374 assert(ios.width() == 0);
3375 }
3376 ios.width(25);
3377 right(ios);
3378 {
3379 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3380 std::string ex(str, iter.base());
3381 assert(ex == "***********************-0");
3382 assert(ios.width() == 0);
3383 }
3384 ios.width(25);
3385 internal(ios);
3386 {
3387 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3388 std::string ex(str, iter.base());
3389 assert(ex == "-***********************0");
3390 assert(ios.width() == 0);
3391 }
3392 }
3393 }
3394 showpoint(ios);
3395 {
3396 ios.imbue(lc);
3397 {
3398 ios.width(0);
3399 {
3400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3401 std::string ex(str, iter.base());
3402 assert(ex == "-0.");
3403 assert(ios.width() == 0);
3404 }
3405 ios.width(25);
3406 left(ios);
3407 {
3408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3409 std::string ex(str, iter.base());
3410 assert(ex == "-0.**********************");
3411 assert(ios.width() == 0);
3412 }
3413 ios.width(25);
3414 right(ios);
3415 {
3416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3417 std::string ex(str, iter.base());
3418 assert(ex == "**********************-0.");
3419 assert(ios.width() == 0);
3420 }
3421 ios.width(25);
3422 internal(ios);
3423 {
3424 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3425 std::string ex(str, iter.base());
3426 assert(ex == "-**********************0.");
3427 assert(ios.width() == 0);
3428 }
3429 }
3430 ios.imbue(lg);
3431 {
3432 ios.width(0);
3433 {
3434 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3435 std::string ex(str, iter.base());
3436 assert(ex == "-0;");
3437 assert(ios.width() == 0);
3438 }
3439 ios.width(25);
3440 left(ios);
3441 {
3442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3443 std::string ex(str, iter.base());
3444 assert(ex == "-0;**********************");
3445 assert(ios.width() == 0);
3446 }
3447 ios.width(25);
3448 right(ios);
3449 {
3450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3451 std::string ex(str, iter.base());
3452 assert(ex == "**********************-0;");
3453 assert(ios.width() == 0);
3454 }
3455 ios.width(25);
3456 internal(ios);
3457 {
3458 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3459 std::string ex(str, iter.base());
3460 assert(ex == "-**********************0;");
3461 assert(ios.width() == 0);
3462 }
3463 }
3464 }
3465 }
3466 showpos(ios);
3467 {
3468 noshowpoint(ios);
3469 {
3470 ios.imbue(lc);
3471 {
3472 ios.width(0);
3473 {
3474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3475 std::string ex(str, iter.base());
3476 assert(ex == "-0");
3477 assert(ios.width() == 0);
3478 }
3479 ios.width(25);
3480 left(ios);
3481 {
3482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3483 std::string ex(str, iter.base());
3484 assert(ex == "-0***********************");
3485 assert(ios.width() == 0);
3486 }
3487 ios.width(25);
3488 right(ios);
3489 {
3490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3491 std::string ex(str, iter.base());
3492 assert(ex == "***********************-0");
3493 assert(ios.width() == 0);
3494 }
3495 ios.width(25);
3496 internal(ios);
3497 {
3498 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3499 std::string ex(str, iter.base());
3500 assert(ex == "-***********************0");
3501 assert(ios.width() == 0);
3502 }
3503 }
3504 ios.imbue(lg);
3505 {
3506 ios.width(0);
3507 {
3508 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3509 std::string ex(str, iter.base());
3510 assert(ex == "-0");
3511 assert(ios.width() == 0);
3512 }
3513 ios.width(25);
3514 left(ios);
3515 {
3516 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3517 std::string ex(str, iter.base());
3518 assert(ex == "-0***********************");
3519 assert(ios.width() == 0);
3520 }
3521 ios.width(25);
3522 right(ios);
3523 {
3524 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3525 std::string ex(str, iter.base());
3526 assert(ex == "***********************-0");
3527 assert(ios.width() == 0);
3528 }
3529 ios.width(25);
3530 internal(ios);
3531 {
3532 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3533 std::string ex(str, iter.base());
3534 assert(ex == "-***********************0");
3535 assert(ios.width() == 0);
3536 }
3537 }
3538 }
3539 showpoint(ios);
3540 {
3541 ios.imbue(lc);
3542 {
3543 ios.width(0);
3544 {
3545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3546 std::string ex(str, iter.base());
3547 assert(ex == "-0.");
3548 assert(ios.width() == 0);
3549 }
3550 ios.width(25);
3551 left(ios);
3552 {
3553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3554 std::string ex(str, iter.base());
3555 assert(ex == "-0.**********************");
3556 assert(ios.width() == 0);
3557 }
3558 ios.width(25);
3559 right(ios);
3560 {
3561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3562 std::string ex(str, iter.base());
3563 assert(ex == "**********************-0.");
3564 assert(ios.width() == 0);
3565 }
3566 ios.width(25);
3567 internal(ios);
3568 {
3569 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3570 std::string ex(str, iter.base());
3571 assert(ex == "-**********************0.");
3572 assert(ios.width() == 0);
3573 }
3574 }
3575 ios.imbue(lg);
3576 {
3577 ios.width(0);
3578 {
3579 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3580 std::string ex(str, iter.base());
3581 assert(ex == "-0;");
3582 assert(ios.width() == 0);
3583 }
3584 ios.width(25);
3585 left(ios);
3586 {
3587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3588 std::string ex(str, iter.base());
3589 assert(ex == "-0;**********************");
3590 assert(ios.width() == 0);
3591 }
3592 ios.width(25);
3593 right(ios);
3594 {
3595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3596 std::string ex(str, iter.base());
3597 assert(ex == "**********************-0;");
3598 assert(ios.width() == 0);
3599 }
3600 ios.width(25);
3601 internal(ios);
3602 {
3603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3604 std::string ex(str, iter.base());
3605 assert(ex == "-**********************0;");
3606 assert(ios.width() == 0);
3607 }
3608 }
3609 }
3610 }
3611 }
3612 }
3613 ios.precision(1);
3614 {
3615 nouppercase(ios);
3616 {
3617 noshowpos(ios);
3618 {
3619 noshowpoint(ios);
3620 {
3621 ios.imbue(lc);
3622 {
3623 ios.width(0);
3624 {
3625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3626 std::string ex(str, iter.base());
3627 assert(ex == "-0");
3628 assert(ios.width() == 0);
3629 }
3630 ios.width(25);
3631 left(ios);
3632 {
3633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3634 std::string ex(str, iter.base());
3635 assert(ex == "-0***********************");
3636 assert(ios.width() == 0);
3637 }
3638 ios.width(25);
3639 right(ios);
3640 {
3641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3642 std::string ex(str, iter.base());
3643 assert(ex == "***********************-0");
3644 assert(ios.width() == 0);
3645 }
3646 ios.width(25);
3647 internal(ios);
3648 {
3649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3650 std::string ex(str, iter.base());
3651 assert(ex == "-***********************0");
3652 assert(ios.width() == 0);
3653 }
3654 }
3655 ios.imbue(lg);
3656 {
3657 ios.width(0);
3658 {
3659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3660 std::string ex(str, iter.base());
3661 assert(ex == "-0");
3662 assert(ios.width() == 0);
3663 }
3664 ios.width(25);
3665 left(ios);
3666 {
3667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3668 std::string ex(str, iter.base());
3669 assert(ex == "-0***********************");
3670 assert(ios.width() == 0);
3671 }
3672 ios.width(25);
3673 right(ios);
3674 {
3675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3676 std::string ex(str, iter.base());
3677 assert(ex == "***********************-0");
3678 assert(ios.width() == 0);
3679 }
3680 ios.width(25);
3681 internal(ios);
3682 {
3683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3684 std::string ex(str, iter.base());
3685 assert(ex == "-***********************0");
3686 assert(ios.width() == 0);
3687 }
3688 }
3689 }
3690 showpoint(ios);
3691 {
3692 ios.imbue(lc);
3693 {
3694 ios.width(0);
3695 {
3696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3697 std::string ex(str, iter.base());
3698 assert(ex == "-0.");
3699 assert(ios.width() == 0);
3700 }
3701 ios.width(25);
3702 left(ios);
3703 {
3704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3705 std::string ex(str, iter.base());
3706 assert(ex == "-0.**********************");
3707 assert(ios.width() == 0);
3708 }
3709 ios.width(25);
3710 right(ios);
3711 {
3712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3713 std::string ex(str, iter.base());
3714 assert(ex == "**********************-0.");
3715 assert(ios.width() == 0);
3716 }
3717 ios.width(25);
3718 internal(ios);
3719 {
3720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3721 std::string ex(str, iter.base());
3722 assert(ex == "-**********************0.");
3723 assert(ios.width() == 0);
3724 }
3725 }
3726 ios.imbue(lg);
3727 {
3728 ios.width(0);
3729 {
3730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3731 std::string ex(str, iter.base());
3732 assert(ex == "-0;");
3733 assert(ios.width() == 0);
3734 }
3735 ios.width(25);
3736 left(ios);
3737 {
3738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3739 std::string ex(str, iter.base());
3740 assert(ex == "-0;**********************");
3741 assert(ios.width() == 0);
3742 }
3743 ios.width(25);
3744 right(ios);
3745 {
3746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3747 std::string ex(str, iter.base());
3748 assert(ex == "**********************-0;");
3749 assert(ios.width() == 0);
3750 }
3751 ios.width(25);
3752 internal(ios);
3753 {
3754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3755 std::string ex(str, iter.base());
3756 assert(ex == "-**********************0;");
3757 assert(ios.width() == 0);
3758 }
3759 }
3760 }
3761 }
3762 showpos(ios);
3763 {
3764 noshowpoint(ios);
3765 {
3766 ios.imbue(lc);
3767 {
3768 ios.width(0);
3769 {
3770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3771 std::string ex(str, iter.base());
3772 assert(ex == "-0");
3773 assert(ios.width() == 0);
3774 }
3775 ios.width(25);
3776 left(ios);
3777 {
3778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3779 std::string ex(str, iter.base());
3780 assert(ex == "-0***********************");
3781 assert(ios.width() == 0);
3782 }
3783 ios.width(25);
3784 right(ios);
3785 {
3786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3787 std::string ex(str, iter.base());
3788 assert(ex == "***********************-0");
3789 assert(ios.width() == 0);
3790 }
3791 ios.width(25);
3792 internal(ios);
3793 {
3794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3795 std::string ex(str, iter.base());
3796 assert(ex == "-***********************0");
3797 assert(ios.width() == 0);
3798 }
3799 }
3800 ios.imbue(lg);
3801 {
3802 ios.width(0);
3803 {
3804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3805 std::string ex(str, iter.base());
3806 assert(ex == "-0");
3807 assert(ios.width() == 0);
3808 }
3809 ios.width(25);
3810 left(ios);
3811 {
3812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3813 std::string ex(str, iter.base());
3814 assert(ex == "-0***********************");
3815 assert(ios.width() == 0);
3816 }
3817 ios.width(25);
3818 right(ios);
3819 {
3820 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3821 std::string ex(str, iter.base());
3822 assert(ex == "***********************-0");
3823 assert(ios.width() == 0);
3824 }
3825 ios.width(25);
3826 internal(ios);
3827 {
3828 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3829 std::string ex(str, iter.base());
3830 assert(ex == "-***********************0");
3831 assert(ios.width() == 0);
3832 }
3833 }
3834 }
3835 showpoint(ios);
3836 {
3837 ios.imbue(lc);
3838 {
3839 ios.width(0);
3840 {
3841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3842 std::string ex(str, iter.base());
3843 assert(ex == "-0.");
3844 assert(ios.width() == 0);
3845 }
3846 ios.width(25);
3847 left(ios);
3848 {
3849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3850 std::string ex(str, iter.base());
3851 assert(ex == "-0.**********************");
3852 assert(ios.width() == 0);
3853 }
3854 ios.width(25);
3855 right(ios);
3856 {
3857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3858 std::string ex(str, iter.base());
3859 assert(ex == "**********************-0.");
3860 assert(ios.width() == 0);
3861 }
3862 ios.width(25);
3863 internal(ios);
3864 {
3865 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3866 std::string ex(str, iter.base());
3867 assert(ex == "-**********************0.");
3868 assert(ios.width() == 0);
3869 }
3870 }
3871 ios.imbue(lg);
3872 {
3873 ios.width(0);
3874 {
3875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3876 std::string ex(str, iter.base());
3877 assert(ex == "-0;");
3878 assert(ios.width() == 0);
3879 }
3880 ios.width(25);
3881 left(ios);
3882 {
3883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3884 std::string ex(str, iter.base());
3885 assert(ex == "-0;**********************");
3886 assert(ios.width() == 0);
3887 }
3888 ios.width(25);
3889 right(ios);
3890 {
3891 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3892 std::string ex(str, iter.base());
3893 assert(ex == "**********************-0;");
3894 assert(ios.width() == 0);
3895 }
3896 ios.width(25);
3897 internal(ios);
3898 {
3899 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3900 std::string ex(str, iter.base());
3901 assert(ex == "-**********************0;");
3902 assert(ios.width() == 0);
3903 }
3904 }
3905 }
3906 }
3907 }
3908 uppercase(ios);
3909 {
3910 noshowpos(ios);
3911 {
3912 noshowpoint(ios);
3913 {
3914 ios.imbue(lc);
3915 {
3916 ios.width(0);
3917 {
3918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3919 std::string ex(str, iter.base());
3920 assert(ex == "-0");
3921 assert(ios.width() == 0);
3922 }
3923 ios.width(25);
3924 left(ios);
3925 {
3926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3927 std::string ex(str, iter.base());
3928 assert(ex == "-0***********************");
3929 assert(ios.width() == 0);
3930 }
3931 ios.width(25);
3932 right(ios);
3933 {
3934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3935 std::string ex(str, iter.base());
3936 assert(ex == "***********************-0");
3937 assert(ios.width() == 0);
3938 }
3939 ios.width(25);
3940 internal(ios);
3941 {
3942 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3943 std::string ex(str, iter.base());
3944 assert(ex == "-***********************0");
3945 assert(ios.width() == 0);
3946 }
3947 }
3948 ios.imbue(lg);
3949 {
3950 ios.width(0);
3951 {
3952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3953 std::string ex(str, iter.base());
3954 assert(ex == "-0");
3955 assert(ios.width() == 0);
3956 }
3957 ios.width(25);
3958 left(ios);
3959 {
3960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3961 std::string ex(str, iter.base());
3962 assert(ex == "-0***********************");
3963 assert(ios.width() == 0);
3964 }
3965 ios.width(25);
3966 right(ios);
3967 {
3968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3969 std::string ex(str, iter.base());
3970 assert(ex == "***********************-0");
3971 assert(ios.width() == 0);
3972 }
3973 ios.width(25);
3974 internal(ios);
3975 {
3976 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3977 std::string ex(str, iter.base());
3978 assert(ex == "-***********************0");
3979 assert(ios.width() == 0);
3980 }
3981 }
3982 }
3983 showpoint(ios);
3984 {
3985 ios.imbue(lc);
3986 {
3987 ios.width(0);
3988 {
3989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3990 std::string ex(str, iter.base());
3991 assert(ex == "-0.");
3992 assert(ios.width() == 0);
3993 }
3994 ios.width(25);
3995 left(ios);
3996 {
3997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3998 std::string ex(str, iter.base());
3999 assert(ex == "-0.**********************");
4000 assert(ios.width() == 0);
4001 }
4002 ios.width(25);
4003 right(ios);
4004 {
4005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4006 std::string ex(str, iter.base());
4007 assert(ex == "**********************-0.");
4008 assert(ios.width() == 0);
4009 }
4010 ios.width(25);
4011 internal(ios);
4012 {
4013 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4014 std::string ex(str, iter.base());
4015 assert(ex == "-**********************0.");
4016 assert(ios.width() == 0);
4017 }
4018 }
4019 ios.imbue(lg);
4020 {
4021 ios.width(0);
4022 {
4023 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4024 std::string ex(str, iter.base());
4025 assert(ex == "-0;");
4026 assert(ios.width() == 0);
4027 }
4028 ios.width(25);
4029 left(ios);
4030 {
4031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4032 std::string ex(str, iter.base());
4033 assert(ex == "-0;**********************");
4034 assert(ios.width() == 0);
4035 }
4036 ios.width(25);
4037 right(ios);
4038 {
4039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4040 std::string ex(str, iter.base());
4041 assert(ex == "**********************-0;");
4042 assert(ios.width() == 0);
4043 }
4044 ios.width(25);
4045 internal(ios);
4046 {
4047 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4048 std::string ex(str, iter.base());
4049 assert(ex == "-**********************0;");
4050 assert(ios.width() == 0);
4051 }
4052 }
4053 }
4054 }
4055 showpos(ios);
4056 {
4057 noshowpoint(ios);
4058 {
4059 ios.imbue(lc);
4060 {
4061 ios.width(0);
4062 {
4063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4064 std::string ex(str, iter.base());
4065 assert(ex == "-0");
4066 assert(ios.width() == 0);
4067 }
4068 ios.width(25);
4069 left(ios);
4070 {
4071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4072 std::string ex(str, iter.base());
4073 assert(ex == "-0***********************");
4074 assert(ios.width() == 0);
4075 }
4076 ios.width(25);
4077 right(ios);
4078 {
4079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4080 std::string ex(str, iter.base());
4081 assert(ex == "***********************-0");
4082 assert(ios.width() == 0);
4083 }
4084 ios.width(25);
4085 internal(ios);
4086 {
4087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4088 std::string ex(str, iter.base());
4089 assert(ex == "-***********************0");
4090 assert(ios.width() == 0);
4091 }
4092 }
4093 ios.imbue(lg);
4094 {
4095 ios.width(0);
4096 {
4097 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4098 std::string ex(str, iter.base());
4099 assert(ex == "-0");
4100 assert(ios.width() == 0);
4101 }
4102 ios.width(25);
4103 left(ios);
4104 {
4105 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4106 std::string ex(str, iter.base());
4107 assert(ex == "-0***********************");
4108 assert(ios.width() == 0);
4109 }
4110 ios.width(25);
4111 right(ios);
4112 {
4113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4114 std::string ex(str, iter.base());
4115 assert(ex == "***********************-0");
4116 assert(ios.width() == 0);
4117 }
4118 ios.width(25);
4119 internal(ios);
4120 {
4121 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4122 std::string ex(str, iter.base());
4123 assert(ex == "-***********************0");
4124 assert(ios.width() == 0);
4125 }
4126 }
4127 }
4128 showpoint(ios);
4129 {
4130 ios.imbue(lc);
4131 {
4132 ios.width(0);
4133 {
4134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4135 std::string ex(str, iter.base());
4136 assert(ex == "-0.");
4137 assert(ios.width() == 0);
4138 }
4139 ios.width(25);
4140 left(ios);
4141 {
4142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4143 std::string ex(str, iter.base());
4144 assert(ex == "-0.**********************");
4145 assert(ios.width() == 0);
4146 }
4147 ios.width(25);
4148 right(ios);
4149 {
4150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4151 std::string ex(str, iter.base());
4152 assert(ex == "**********************-0.");
4153 assert(ios.width() == 0);
4154 }
4155 ios.width(25);
4156 internal(ios);
4157 {
4158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4159 std::string ex(str, iter.base());
4160 assert(ex == "-**********************0.");
4161 assert(ios.width() == 0);
4162 }
4163 }
4164 ios.imbue(lg);
4165 {
4166 ios.width(0);
4167 {
4168 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4169 std::string ex(str, iter.base());
4170 assert(ex == "-0;");
4171 assert(ios.width() == 0);
4172 }
4173 ios.width(25);
4174 left(ios);
4175 {
4176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4177 std::string ex(str, iter.base());
4178 assert(ex == "-0;**********************");
4179 assert(ios.width() == 0);
4180 }
4181 ios.width(25);
4182 right(ios);
4183 {
4184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4185 std::string ex(str, iter.base());
4186 assert(ex == "**********************-0;");
4187 assert(ios.width() == 0);
4188 }
4189 ios.width(25);
4190 internal(ios);
4191 {
4192 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4193 std::string ex(str, iter.base());
4194 assert(ex == "-**********************0;");
4195 assert(ios.width() == 0);
4196 }
4197 }
4198 }
4199 }
4200 }
4201 }
4202 ios.precision(6);
4203 {
4204 nouppercase(ios);
4205 {
4206 noshowpos(ios);
4207 {
4208 noshowpoint(ios);
4209 {
4210 ios.imbue(lc);
4211 {
4212 ios.width(0);
4213 {
4214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4215 std::string ex(str, iter.base());
4216 assert(ex == "-0");
4217 assert(ios.width() == 0);
4218 }
4219 ios.width(25);
4220 left(ios);
4221 {
4222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4223 std::string ex(str, iter.base());
4224 assert(ex == "-0***********************");
4225 assert(ios.width() == 0);
4226 }
4227 ios.width(25);
4228 right(ios);
4229 {
4230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4231 std::string ex(str, iter.base());
4232 assert(ex == "***********************-0");
4233 assert(ios.width() == 0);
4234 }
4235 ios.width(25);
4236 internal(ios);
4237 {
4238 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4239 std::string ex(str, iter.base());
4240 assert(ex == "-***********************0");
4241 assert(ios.width() == 0);
4242 }
4243 }
4244 ios.imbue(lg);
4245 {
4246 ios.width(0);
4247 {
4248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4249 std::string ex(str, iter.base());
4250 assert(ex == "-0");
4251 assert(ios.width() == 0);
4252 }
4253 ios.width(25);
4254 left(ios);
4255 {
4256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4257 std::string ex(str, iter.base());
4258 assert(ex == "-0***********************");
4259 assert(ios.width() == 0);
4260 }
4261 ios.width(25);
4262 right(ios);
4263 {
4264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4265 std::string ex(str, iter.base());
4266 assert(ex == "***********************-0");
4267 assert(ios.width() == 0);
4268 }
4269 ios.width(25);
4270 internal(ios);
4271 {
4272 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4273 std::string ex(str, iter.base());
4274 assert(ex == "-***********************0");
4275 assert(ios.width() == 0);
4276 }
4277 }
4278 }
4279 showpoint(ios);
4280 {
4281 ios.imbue(lc);
4282 {
4283 ios.width(0);
4284 {
4285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4286 std::string ex(str, iter.base());
4287 assert(ex == "-0.00000");
4288 assert(ios.width() == 0);
4289 }
4290 ios.width(25);
4291 left(ios);
4292 {
4293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4294 std::string ex(str, iter.base());
4295 assert(ex == "-0.00000*****************");
4296 assert(ios.width() == 0);
4297 }
4298 ios.width(25);
4299 right(ios);
4300 {
4301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4302 std::string ex(str, iter.base());
4303 assert(ex == "*****************-0.00000");
4304 assert(ios.width() == 0);
4305 }
4306 ios.width(25);
4307 internal(ios);
4308 {
4309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4310 std::string ex(str, iter.base());
4311 assert(ex == "-*****************0.00000");
4312 assert(ios.width() == 0);
4313 }
4314 }
4315 ios.imbue(lg);
4316 {
4317 ios.width(0);
4318 {
4319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4320 std::string ex(str, iter.base());
4321 assert(ex == "-0;00000");
4322 assert(ios.width() == 0);
4323 }
4324 ios.width(25);
4325 left(ios);
4326 {
4327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4328 std::string ex(str, iter.base());
4329 assert(ex == "-0;00000*****************");
4330 assert(ios.width() == 0);
4331 }
4332 ios.width(25);
4333 right(ios);
4334 {
4335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4336 std::string ex(str, iter.base());
4337 assert(ex == "*****************-0;00000");
4338 assert(ios.width() == 0);
4339 }
4340 ios.width(25);
4341 internal(ios);
4342 {
4343 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4344 std::string ex(str, iter.base());
4345 assert(ex == "-*****************0;00000");
4346 assert(ios.width() == 0);
4347 }
4348 }
4349 }
4350 }
4351 showpos(ios);
4352 {
4353 noshowpoint(ios);
4354 {
4355 ios.imbue(lc);
4356 {
4357 ios.width(0);
4358 {
4359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4360 std::string ex(str, iter.base());
4361 assert(ex == "-0");
4362 assert(ios.width() == 0);
4363 }
4364 ios.width(25);
4365 left(ios);
4366 {
4367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4368 std::string ex(str, iter.base());
4369 assert(ex == "-0***********************");
4370 assert(ios.width() == 0);
4371 }
4372 ios.width(25);
4373 right(ios);
4374 {
4375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4376 std::string ex(str, iter.base());
4377 assert(ex == "***********************-0");
4378 assert(ios.width() == 0);
4379 }
4380 ios.width(25);
4381 internal(ios);
4382 {
4383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4384 std::string ex(str, iter.base());
4385 assert(ex == "-***********************0");
4386 assert(ios.width() == 0);
4387 }
4388 }
4389 ios.imbue(lg);
4390 {
4391 ios.width(0);
4392 {
4393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4394 std::string ex(str, iter.base());
4395 assert(ex == "-0");
4396 assert(ios.width() == 0);
4397 }
4398 ios.width(25);
4399 left(ios);
4400 {
4401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4402 std::string ex(str, iter.base());
4403 assert(ex == "-0***********************");
4404 assert(ios.width() == 0);
4405 }
4406 ios.width(25);
4407 right(ios);
4408 {
4409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4410 std::string ex(str, iter.base());
4411 assert(ex == "***********************-0");
4412 assert(ios.width() == 0);
4413 }
4414 ios.width(25);
4415 internal(ios);
4416 {
4417 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4418 std::string ex(str, iter.base());
4419 assert(ex == "-***********************0");
4420 assert(ios.width() == 0);
4421 }
4422 }
4423 }
4424 showpoint(ios);
4425 {
4426 ios.imbue(lc);
4427 {
4428 ios.width(0);
4429 {
4430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4431 std::string ex(str, iter.base());
4432 assert(ex == "-0.00000");
4433 assert(ios.width() == 0);
4434 }
4435 ios.width(25);
4436 left(ios);
4437 {
4438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4439 std::string ex(str, iter.base());
4440 assert(ex == "-0.00000*****************");
4441 assert(ios.width() == 0);
4442 }
4443 ios.width(25);
4444 right(ios);
4445 {
4446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4447 std::string ex(str, iter.base());
4448 assert(ex == "*****************-0.00000");
4449 assert(ios.width() == 0);
4450 }
4451 ios.width(25);
4452 internal(ios);
4453 {
4454 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4455 std::string ex(str, iter.base());
4456 assert(ex == "-*****************0.00000");
4457 assert(ios.width() == 0);
4458 }
4459 }
4460 ios.imbue(lg);
4461 {
4462 ios.width(0);
4463 {
4464 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4465 std::string ex(str, iter.base());
4466 assert(ex == "-0;00000");
4467 assert(ios.width() == 0);
4468 }
4469 ios.width(25);
4470 left(ios);
4471 {
4472 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4473 std::string ex(str, iter.base());
4474 assert(ex == "-0;00000*****************");
4475 assert(ios.width() == 0);
4476 }
4477 ios.width(25);
4478 right(ios);
4479 {
4480 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4481 std::string ex(str, iter.base());
4482 assert(ex == "*****************-0;00000");
4483 assert(ios.width() == 0);
4484 }
4485 ios.width(25);
4486 internal(ios);
4487 {
4488 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4489 std::string ex(str, iter.base());
4490 assert(ex == "-*****************0;00000");
4491 assert(ios.width() == 0);
4492 }
4493 }
4494 }
4495 }
4496 }
4497 uppercase(ios);
4498 {
4499 noshowpos(ios);
4500 {
4501 noshowpoint(ios);
4502 {
4503 ios.imbue(lc);
4504 {
4505 ios.width(0);
4506 {
4507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4508 std::string ex(str, iter.base());
4509 assert(ex == "-0");
4510 assert(ios.width() == 0);
4511 }
4512 ios.width(25);
4513 left(ios);
4514 {
4515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4516 std::string ex(str, iter.base());
4517 assert(ex == "-0***********************");
4518 assert(ios.width() == 0);
4519 }
4520 ios.width(25);
4521 right(ios);
4522 {
4523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4524 std::string ex(str, iter.base());
4525 assert(ex == "***********************-0");
4526 assert(ios.width() == 0);
4527 }
4528 ios.width(25);
4529 internal(ios);
4530 {
4531 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4532 std::string ex(str, iter.base());
4533 assert(ex == "-***********************0");
4534 assert(ios.width() == 0);
4535 }
4536 }
4537 ios.imbue(lg);
4538 {
4539 ios.width(0);
4540 {
4541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4542 std::string ex(str, iter.base());
4543 assert(ex == "-0");
4544 assert(ios.width() == 0);
4545 }
4546 ios.width(25);
4547 left(ios);
4548 {
4549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4550 std::string ex(str, iter.base());
4551 assert(ex == "-0***********************");
4552 assert(ios.width() == 0);
4553 }
4554 ios.width(25);
4555 right(ios);
4556 {
4557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4558 std::string ex(str, iter.base());
4559 assert(ex == "***********************-0");
4560 assert(ios.width() == 0);
4561 }
4562 ios.width(25);
4563 internal(ios);
4564 {
4565 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4566 std::string ex(str, iter.base());
4567 assert(ex == "-***********************0");
4568 assert(ios.width() == 0);
4569 }
4570 }
4571 }
4572 showpoint(ios);
4573 {
4574 ios.imbue(lc);
4575 {
4576 ios.width(0);
4577 {
4578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4579 std::string ex(str, iter.base());
4580 assert(ex == "-0.00000");
4581 assert(ios.width() == 0);
4582 }
4583 ios.width(25);
4584 left(ios);
4585 {
4586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4587 std::string ex(str, iter.base());
4588 assert(ex == "-0.00000*****************");
4589 assert(ios.width() == 0);
4590 }
4591 ios.width(25);
4592 right(ios);
4593 {
4594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4595 std::string ex(str, iter.base());
4596 assert(ex == "*****************-0.00000");
4597 assert(ios.width() == 0);
4598 }
4599 ios.width(25);
4600 internal(ios);
4601 {
4602 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4603 std::string ex(str, iter.base());
4604 assert(ex == "-*****************0.00000");
4605 assert(ios.width() == 0);
4606 }
4607 }
4608 ios.imbue(lg);
4609 {
4610 ios.width(0);
4611 {
4612 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4613 std::string ex(str, iter.base());
4614 assert(ex == "-0;00000");
4615 assert(ios.width() == 0);
4616 }
4617 ios.width(25);
4618 left(ios);
4619 {
4620 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4621 std::string ex(str, iter.base());
4622 assert(ex == "-0;00000*****************");
4623 assert(ios.width() == 0);
4624 }
4625 ios.width(25);
4626 right(ios);
4627 {
4628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4629 std::string ex(str, iter.base());
4630 assert(ex == "*****************-0;00000");
4631 assert(ios.width() == 0);
4632 }
4633 ios.width(25);
4634 internal(ios);
4635 {
4636 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4637 std::string ex(str, iter.base());
4638 assert(ex == "-*****************0;00000");
4639 assert(ios.width() == 0);
4640 }
4641 }
4642 }
4643 }
4644 showpos(ios);
4645 {
4646 noshowpoint(ios);
4647 {
4648 ios.imbue(lc);
4649 {
4650 ios.width(0);
4651 {
4652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4653 std::string ex(str, iter.base());
4654 assert(ex == "-0");
4655 assert(ios.width() == 0);
4656 }
4657 ios.width(25);
4658 left(ios);
4659 {
4660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4661 std::string ex(str, iter.base());
4662 assert(ex == "-0***********************");
4663 assert(ios.width() == 0);
4664 }
4665 ios.width(25);
4666 right(ios);
4667 {
4668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4669 std::string ex(str, iter.base());
4670 assert(ex == "***********************-0");
4671 assert(ios.width() == 0);
4672 }
4673 ios.width(25);
4674 internal(ios);
4675 {
4676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4677 std::string ex(str, iter.base());
4678 assert(ex == "-***********************0");
4679 assert(ios.width() == 0);
4680 }
4681 }
4682 ios.imbue(lg);
4683 {
4684 ios.width(0);
4685 {
4686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4687 std::string ex(str, iter.base());
4688 assert(ex == "-0");
4689 assert(ios.width() == 0);
4690 }
4691 ios.width(25);
4692 left(ios);
4693 {
4694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4695 std::string ex(str, iter.base());
4696 assert(ex == "-0***********************");
4697 assert(ios.width() == 0);
4698 }
4699 ios.width(25);
4700 right(ios);
4701 {
4702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4703 std::string ex(str, iter.base());
4704 assert(ex == "***********************-0");
4705 assert(ios.width() == 0);
4706 }
4707 ios.width(25);
4708 internal(ios);
4709 {
4710 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4711 std::string ex(str, iter.base());
4712 assert(ex == "-***********************0");
4713 assert(ios.width() == 0);
4714 }
4715 }
4716 }
4717 showpoint(ios);
4718 {
4719 ios.imbue(lc);
4720 {
4721 ios.width(0);
4722 {
4723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4724 std::string ex(str, iter.base());
4725 assert(ex == "-0.00000");
4726 assert(ios.width() == 0);
4727 }
4728 ios.width(25);
4729 left(ios);
4730 {
4731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4732 std::string ex(str, iter.base());
4733 assert(ex == "-0.00000*****************");
4734 assert(ios.width() == 0);
4735 }
4736 ios.width(25);
4737 right(ios);
4738 {
4739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4740 std::string ex(str, iter.base());
4741 assert(ex == "*****************-0.00000");
4742 assert(ios.width() == 0);
4743 }
4744 ios.width(25);
4745 internal(ios);
4746 {
4747 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4748 std::string ex(str, iter.base());
4749 assert(ex == "-*****************0.00000");
4750 assert(ios.width() == 0);
4751 }
4752 }
4753 ios.imbue(lg);
4754 {
4755 ios.width(0);
4756 {
4757 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4758 std::string ex(str, iter.base());
4759 assert(ex == "-0;00000");
4760 assert(ios.width() == 0);
4761 }
4762 ios.width(25);
4763 left(ios);
4764 {
4765 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4766 std::string ex(str, iter.base());
4767 assert(ex == "-0;00000*****************");
4768 assert(ios.width() == 0);
4769 }
4770 ios.width(25);
4771 right(ios);
4772 {
4773 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4774 std::string ex(str, iter.base());
4775 assert(ex == "*****************-0;00000");
4776 assert(ios.width() == 0);
4777 }
4778 ios.width(25);
4779 internal(ios);
4780 {
4781 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4782 std::string ex(str, iter.base());
4783 assert(ex == "-*****************0;00000");
4784 assert(ios.width() == 0);
4785 }
4786 }
4787 }
4788 }
4789 }
4790 }
4791 ios.precision(16);
4792 {
4793 nouppercase(ios);
4794 {
4795 noshowpos(ios);
4796 {
4797 noshowpoint(ios);
4798 {
4799 ios.imbue(lc);
4800 {
4801 ios.width(0);
4802 {
4803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4804 std::string ex(str, iter.base());
4805 assert(ex == "-0");
4806 assert(ios.width() == 0);
4807 }
4808 ios.width(25);
4809 left(ios);
4810 {
4811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4812 std::string ex(str, iter.base());
4813 assert(ex == "-0***********************");
4814 assert(ios.width() == 0);
4815 }
4816 ios.width(25);
4817 right(ios);
4818 {
4819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4820 std::string ex(str, iter.base());
4821 assert(ex == "***********************-0");
4822 assert(ios.width() == 0);
4823 }
4824 ios.width(25);
4825 internal(ios);
4826 {
4827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4828 std::string ex(str, iter.base());
4829 assert(ex == "-***********************0");
4830 assert(ios.width() == 0);
4831 }
4832 }
4833 ios.imbue(lg);
4834 {
4835 ios.width(0);
4836 {
4837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4838 std::string ex(str, iter.base());
4839 assert(ex == "-0");
4840 assert(ios.width() == 0);
4841 }
4842 ios.width(25);
4843 left(ios);
4844 {
4845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4846 std::string ex(str, iter.base());
4847 assert(ex == "-0***********************");
4848 assert(ios.width() == 0);
4849 }
4850 ios.width(25);
4851 right(ios);
4852 {
4853 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4854 std::string ex(str, iter.base());
4855 assert(ex == "***********************-0");
4856 assert(ios.width() == 0);
4857 }
4858 ios.width(25);
4859 internal(ios);
4860 {
4861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4862 std::string ex(str, iter.base());
4863 assert(ex == "-***********************0");
4864 assert(ios.width() == 0);
4865 }
4866 }
4867 }
4868 showpoint(ios);
4869 {
4870 ios.imbue(lc);
4871 {
4872 ios.width(0);
4873 {
4874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4875 std::string ex(str, iter.base());
4876 assert(ex == "-0.000000000000000");
4877 assert(ios.width() == 0);
4878 }
4879 ios.width(25);
4880 left(ios);
4881 {
4882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4883 std::string ex(str, iter.base());
4884 assert(ex == "-0.000000000000000*******");
4885 assert(ios.width() == 0);
4886 }
4887 ios.width(25);
4888 right(ios);
4889 {
4890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4891 std::string ex(str, iter.base());
4892 assert(ex == "*******-0.000000000000000");
4893 assert(ios.width() == 0);
4894 }
4895 ios.width(25);
4896 internal(ios);
4897 {
4898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4899 std::string ex(str, iter.base());
4900 assert(ex == "-*******0.000000000000000");
4901 assert(ios.width() == 0);
4902 }
4903 }
4904 ios.imbue(lg);
4905 {
4906 ios.width(0);
4907 {
4908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4909 std::string ex(str, iter.base());
4910 assert(ex == "-0;000000000000000");
4911 assert(ios.width() == 0);
4912 }
4913 ios.width(25);
4914 left(ios);
4915 {
4916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4917 std::string ex(str, iter.base());
4918 assert(ex == "-0;000000000000000*******");
4919 assert(ios.width() == 0);
4920 }
4921 ios.width(25);
4922 right(ios);
4923 {
4924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4925 std::string ex(str, iter.base());
4926 assert(ex == "*******-0;000000000000000");
4927 assert(ios.width() == 0);
4928 }
4929 ios.width(25);
4930 internal(ios);
4931 {
4932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4933 std::string ex(str, iter.base());
4934 assert(ex == "-*******0;000000000000000");
4935 assert(ios.width() == 0);
4936 }
4937 }
4938 }
4939 }
4940 showpos(ios);
4941 {
4942 noshowpoint(ios);
4943 {
4944 ios.imbue(lc);
4945 {
4946 ios.width(0);
4947 {
4948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4949 std::string ex(str, iter.base());
4950 assert(ex == "-0");
4951 assert(ios.width() == 0);
4952 }
4953 ios.width(25);
4954 left(ios);
4955 {
4956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4957 std::string ex(str, iter.base());
4958 assert(ex == "-0***********************");
4959 assert(ios.width() == 0);
4960 }
4961 ios.width(25);
4962 right(ios);
4963 {
4964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4965 std::string ex(str, iter.base());
4966 assert(ex == "***********************-0");
4967 assert(ios.width() == 0);
4968 }
4969 ios.width(25);
4970 internal(ios);
4971 {
4972 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4973 std::string ex(str, iter.base());
4974 assert(ex == "-***********************0");
4975 assert(ios.width() == 0);
4976 }
4977 }
4978 ios.imbue(lg);
4979 {
4980 ios.width(0);
4981 {
4982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4983 std::string ex(str, iter.base());
4984 assert(ex == "-0");
4985 assert(ios.width() == 0);
4986 }
4987 ios.width(25);
4988 left(ios);
4989 {
4990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4991 std::string ex(str, iter.base());
4992 assert(ex == "-0***********************");
4993 assert(ios.width() == 0);
4994 }
4995 ios.width(25);
4996 right(ios);
4997 {
4998 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4999 std::string ex(str, iter.base());
5000 assert(ex == "***********************-0");
5001 assert(ios.width() == 0);
5002 }
5003 ios.width(25);
5004 internal(ios);
5005 {
5006 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5007 std::string ex(str, iter.base());
5008 assert(ex == "-***********************0");
5009 assert(ios.width() == 0);
5010 }
5011 }
5012 }
5013 showpoint(ios);
5014 {
5015 ios.imbue(lc);
5016 {
5017 ios.width(0);
5018 {
5019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5020 std::string ex(str, iter.base());
5021 assert(ex == "-0.000000000000000");
5022 assert(ios.width() == 0);
5023 }
5024 ios.width(25);
5025 left(ios);
5026 {
5027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5028 std::string ex(str, iter.base());
5029 assert(ex == "-0.000000000000000*******");
5030 assert(ios.width() == 0);
5031 }
5032 ios.width(25);
5033 right(ios);
5034 {
5035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5036 std::string ex(str, iter.base());
5037 assert(ex == "*******-0.000000000000000");
5038 assert(ios.width() == 0);
5039 }
5040 ios.width(25);
5041 internal(ios);
5042 {
5043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5044 std::string ex(str, iter.base());
5045 assert(ex == "-*******0.000000000000000");
5046 assert(ios.width() == 0);
5047 }
5048 }
5049 ios.imbue(lg);
5050 {
5051 ios.width(0);
5052 {
5053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5054 std::string ex(str, iter.base());
5055 assert(ex == "-0;000000000000000");
5056 assert(ios.width() == 0);
5057 }
5058 ios.width(25);
5059 left(ios);
5060 {
5061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5062 std::string ex(str, iter.base());
5063 assert(ex == "-0;000000000000000*******");
5064 assert(ios.width() == 0);
5065 }
5066 ios.width(25);
5067 right(ios);
5068 {
5069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5070 std::string ex(str, iter.base());
5071 assert(ex == "*******-0;000000000000000");
5072 assert(ios.width() == 0);
5073 }
5074 ios.width(25);
5075 internal(ios);
5076 {
5077 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5078 std::string ex(str, iter.base());
5079 assert(ex == "-*******0;000000000000000");
5080 assert(ios.width() == 0);
5081 }
5082 }
5083 }
5084 }
5085 }
5086 uppercase(ios);
5087 {
5088 noshowpos(ios);
5089 {
5090 noshowpoint(ios);
5091 {
5092 ios.imbue(lc);
5093 {
5094 ios.width(0);
5095 {
5096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5097 std::string ex(str, iter.base());
5098 assert(ex == "-0");
5099 assert(ios.width() == 0);
5100 }
5101 ios.width(25);
5102 left(ios);
5103 {
5104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5105 std::string ex(str, iter.base());
5106 assert(ex == "-0***********************");
5107 assert(ios.width() == 0);
5108 }
5109 ios.width(25);
5110 right(ios);
5111 {
5112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5113 std::string ex(str, iter.base());
5114 assert(ex == "***********************-0");
5115 assert(ios.width() == 0);
5116 }
5117 ios.width(25);
5118 internal(ios);
5119 {
5120 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5121 std::string ex(str, iter.base());
5122 assert(ex == "-***********************0");
5123 assert(ios.width() == 0);
5124 }
5125 }
5126 ios.imbue(lg);
5127 {
5128 ios.width(0);
5129 {
5130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5131 std::string ex(str, iter.base());
5132 assert(ex == "-0");
5133 assert(ios.width() == 0);
5134 }
5135 ios.width(25);
5136 left(ios);
5137 {
5138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5139 std::string ex(str, iter.base());
5140 assert(ex == "-0***********************");
5141 assert(ios.width() == 0);
5142 }
5143 ios.width(25);
5144 right(ios);
5145 {
5146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5147 std::string ex(str, iter.base());
5148 assert(ex == "***********************-0");
5149 assert(ios.width() == 0);
5150 }
5151 ios.width(25);
5152 internal(ios);
5153 {
5154 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5155 std::string ex(str, iter.base());
5156 assert(ex == "-***********************0");
5157 assert(ios.width() == 0);
5158 }
5159 }
5160 }
5161 showpoint(ios);
5162 {
5163 ios.imbue(lc);
5164 {
5165 ios.width(0);
5166 {
5167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5168 std::string ex(str, iter.base());
5169 assert(ex == "-0.000000000000000");
5170 assert(ios.width() == 0);
5171 }
5172 ios.width(25);
5173 left(ios);
5174 {
5175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5176 std::string ex(str, iter.base());
5177 assert(ex == "-0.000000000000000*******");
5178 assert(ios.width() == 0);
5179 }
5180 ios.width(25);
5181 right(ios);
5182 {
5183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5184 std::string ex(str, iter.base());
5185 assert(ex == "*******-0.000000000000000");
5186 assert(ios.width() == 0);
5187 }
5188 ios.width(25);
5189 internal(ios);
5190 {
5191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5192 std::string ex(str, iter.base());
5193 assert(ex == "-*******0.000000000000000");
5194 assert(ios.width() == 0);
5195 }
5196 }
5197 ios.imbue(lg);
5198 {
5199 ios.width(0);
5200 {
5201 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5202 std::string ex(str, iter.base());
5203 assert(ex == "-0;000000000000000");
5204 assert(ios.width() == 0);
5205 }
5206 ios.width(25);
5207 left(ios);
5208 {
5209 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5210 std::string ex(str, iter.base());
5211 assert(ex == "-0;000000000000000*******");
5212 assert(ios.width() == 0);
5213 }
5214 ios.width(25);
5215 right(ios);
5216 {
5217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5218 std::string ex(str, iter.base());
5219 assert(ex == "*******-0;000000000000000");
5220 assert(ios.width() == 0);
5221 }
5222 ios.width(25);
5223 internal(ios);
5224 {
5225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5226 std::string ex(str, iter.base());
5227 assert(ex == "-*******0;000000000000000");
5228 assert(ios.width() == 0);
5229 }
5230 }
5231 }
5232 }
5233 showpos(ios);
5234 {
5235 noshowpoint(ios);
5236 {
5237 ios.imbue(lc);
5238 {
5239 ios.width(0);
5240 {
5241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5242 std::string ex(str, iter.base());
5243 assert(ex == "-0");
5244 assert(ios.width() == 0);
5245 }
5246 ios.width(25);
5247 left(ios);
5248 {
5249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5250 std::string ex(str, iter.base());
5251 assert(ex == "-0***********************");
5252 assert(ios.width() == 0);
5253 }
5254 ios.width(25);
5255 right(ios);
5256 {
5257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5258 std::string ex(str, iter.base());
5259 assert(ex == "***********************-0");
5260 assert(ios.width() == 0);
5261 }
5262 ios.width(25);
5263 internal(ios);
5264 {
5265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5266 std::string ex(str, iter.base());
5267 assert(ex == "-***********************0");
5268 assert(ios.width() == 0);
5269 }
5270 }
5271 ios.imbue(lg);
5272 {
5273 ios.width(0);
5274 {
5275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5276 std::string ex(str, iter.base());
5277 assert(ex == "-0");
5278 assert(ios.width() == 0);
5279 }
5280 ios.width(25);
5281 left(ios);
5282 {
5283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5284 std::string ex(str, iter.base());
5285 assert(ex == "-0***********************");
5286 assert(ios.width() == 0);
5287 }
5288 ios.width(25);
5289 right(ios);
5290 {
5291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5292 std::string ex(str, iter.base());
5293 assert(ex == "***********************-0");
5294 assert(ios.width() == 0);
5295 }
5296 ios.width(25);
5297 internal(ios);
5298 {
5299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5300 std::string ex(str, iter.base());
5301 assert(ex == "-***********************0");
5302 assert(ios.width() == 0);
5303 }
5304 }
5305 }
5306 showpoint(ios);
5307 {
5308 ios.imbue(lc);
5309 {
5310 ios.width(0);
5311 {
5312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5313 std::string ex(str, iter.base());
5314 assert(ex == "-0.000000000000000");
5315 assert(ios.width() == 0);
5316 }
5317 ios.width(25);
5318 left(ios);
5319 {
5320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5321 std::string ex(str, iter.base());
5322 assert(ex == "-0.000000000000000*******");
5323 assert(ios.width() == 0);
5324 }
5325 ios.width(25);
5326 right(ios);
5327 {
5328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5329 std::string ex(str, iter.base());
5330 assert(ex == "*******-0.000000000000000");
5331 assert(ios.width() == 0);
5332 }
5333 ios.width(25);
5334 internal(ios);
5335 {
5336 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5337 std::string ex(str, iter.base());
5338 assert(ex == "-*******0.000000000000000");
5339 assert(ios.width() == 0);
5340 }
5341 }
5342 ios.imbue(lg);
5343 {
5344 ios.width(0);
5345 {
5346 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5347 std::string ex(str, iter.base());
5348 assert(ex == "-0;000000000000000");
5349 assert(ios.width() == 0);
5350 }
5351 ios.width(25);
5352 left(ios);
5353 {
5354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5355 std::string ex(str, iter.base());
5356 assert(ex == "-0;000000000000000*******");
5357 assert(ios.width() == 0);
5358 }
5359 ios.width(25);
5360 right(ios);
5361 {
5362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5363 std::string ex(str, iter.base());
5364 assert(ex == "*******-0;000000000000000");
5365 assert(ios.width() == 0);
5366 }
5367 ios.width(25);
5368 internal(ios);
5369 {
5370 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5371 std::string ex(str, iter.base());
5372 assert(ex == "-*******0;000000000000000");
5373 assert(ios.width() == 0);
5374 }
5375 }
5376 }
5377 }
5378 }
5379 }
5380 ios.precision(60);
5381 {
5382 nouppercase(ios);
5383 {
5384 noshowpos(ios);
5385 {
5386 noshowpoint(ios);
5387 {
5388 ios.imbue(lc);
5389 {
5390 ios.width(0);
5391 {
5392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5393 std::string ex(str, iter.base());
5394 assert(ex == "-0");
5395 assert(ios.width() == 0);
5396 }
5397 ios.width(25);
5398 left(ios);
5399 {
5400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5401 std::string ex(str, iter.base());
5402 assert(ex == "-0***********************");
5403 assert(ios.width() == 0);
5404 }
5405 ios.width(25);
5406 right(ios);
5407 {
5408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5409 std::string ex(str, iter.base());
5410 assert(ex == "***********************-0");
5411 assert(ios.width() == 0);
5412 }
5413 ios.width(25);
5414 internal(ios);
5415 {
5416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5417 std::string ex(str, iter.base());
5418 assert(ex == "-***********************0");
5419 assert(ios.width() == 0);
5420 }
5421 }
5422 ios.imbue(lg);
5423 {
5424 ios.width(0);
5425 {
5426 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5427 std::string ex(str, iter.base());
5428 assert(ex == "-0");
5429 assert(ios.width() == 0);
5430 }
5431 ios.width(25);
5432 left(ios);
5433 {
5434 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5435 std::string ex(str, iter.base());
5436 assert(ex == "-0***********************");
5437 assert(ios.width() == 0);
5438 }
5439 ios.width(25);
5440 right(ios);
5441 {
5442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5443 std::string ex(str, iter.base());
5444 assert(ex == "***********************-0");
5445 assert(ios.width() == 0);
5446 }
5447 ios.width(25);
5448 internal(ios);
5449 {
5450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5451 std::string ex(str, iter.base());
5452 assert(ex == "-***********************0");
5453 assert(ios.width() == 0);
5454 }
5455 }
5456 }
5457 showpoint(ios);
5458 {
5459 ios.imbue(lc);
5460 {
5461 ios.width(0);
5462 {
5463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5464 std::string ex(str, iter.base());
5465 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5466 assert(ios.width() == 0);
5467 }
5468 ios.width(25);
5469 left(ios);
5470 {
5471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5472 std::string ex(str, iter.base());
5473 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5474 assert(ios.width() == 0);
5475 }
5476 ios.width(25);
5477 right(ios);
5478 {
5479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5480 std::string ex(str, iter.base());
5481 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5482 assert(ios.width() == 0);
5483 }
5484 ios.width(25);
5485 internal(ios);
5486 {
5487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5488 std::string ex(str, iter.base());
5489 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5490 assert(ios.width() == 0);
5491 }
5492 }
5493 ios.imbue(lg);
5494 {
5495 ios.width(0);
5496 {
5497 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5498 std::string ex(str, iter.base());
5499 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5500 assert(ios.width() == 0);
5501 }
5502 ios.width(25);
5503 left(ios);
5504 {
5505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5506 std::string ex(str, iter.base());
5507 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5508 assert(ios.width() == 0);
5509 }
5510 ios.width(25);
5511 right(ios);
5512 {
5513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5514 std::string ex(str, iter.base());
5515 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5516 assert(ios.width() == 0);
5517 }
5518 ios.width(25);
5519 internal(ios);
5520 {
5521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5522 std::string ex(str, iter.base());
5523 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5524 assert(ios.width() == 0);
5525 }
5526 }
5527 }
5528 }
5529 showpos(ios);
5530 {
5531 noshowpoint(ios);
5532 {
5533 ios.imbue(lc);
5534 {
5535 ios.width(0);
5536 {
5537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5538 std::string ex(str, iter.base());
5539 assert(ex == "-0");
5540 assert(ios.width() == 0);
5541 }
5542 ios.width(25);
5543 left(ios);
5544 {
5545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5546 std::string ex(str, iter.base());
5547 assert(ex == "-0***********************");
5548 assert(ios.width() == 0);
5549 }
5550 ios.width(25);
5551 right(ios);
5552 {
5553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5554 std::string ex(str, iter.base());
5555 assert(ex == "***********************-0");
5556 assert(ios.width() == 0);
5557 }
5558 ios.width(25);
5559 internal(ios);
5560 {
5561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5562 std::string ex(str, iter.base());
5563 assert(ex == "-***********************0");
5564 assert(ios.width() == 0);
5565 }
5566 }
5567 ios.imbue(lg);
5568 {
5569 ios.width(0);
5570 {
5571 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5572 std::string ex(str, iter.base());
5573 assert(ex == "-0");
5574 assert(ios.width() == 0);
5575 }
5576 ios.width(25);
5577 left(ios);
5578 {
5579 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5580 std::string ex(str, iter.base());
5581 assert(ex == "-0***********************");
5582 assert(ios.width() == 0);
5583 }
5584 ios.width(25);
5585 right(ios);
5586 {
5587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5588 std::string ex(str, iter.base());
5589 assert(ex == "***********************-0");
5590 assert(ios.width() == 0);
5591 }
5592 ios.width(25);
5593 internal(ios);
5594 {
5595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5596 std::string ex(str, iter.base());
5597 assert(ex == "-***********************0");
5598 assert(ios.width() == 0);
5599 }
5600 }
5601 }
5602 showpoint(ios);
5603 {
5604 ios.imbue(lc);
5605 {
5606 ios.width(0);
5607 {
5608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5609 std::string ex(str, iter.base());
5610 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5611 assert(ios.width() == 0);
5612 }
5613 ios.width(25);
5614 left(ios);
5615 {
5616 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5617 std::string ex(str, iter.base());
5618 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5619 assert(ios.width() == 0);
5620 }
5621 ios.width(25);
5622 right(ios);
5623 {
5624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5625 std::string ex(str, iter.base());
5626 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5627 assert(ios.width() == 0);
5628 }
5629 ios.width(25);
5630 internal(ios);
5631 {
5632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5633 std::string ex(str, iter.base());
5634 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5635 assert(ios.width() == 0);
5636 }
5637 }
5638 ios.imbue(lg);
5639 {
5640 ios.width(0);
5641 {
5642 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5643 std::string ex(str, iter.base());
5644 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5645 assert(ios.width() == 0);
5646 }
5647 ios.width(25);
5648 left(ios);
5649 {
5650 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5651 std::string ex(str, iter.base());
5652 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5653 assert(ios.width() == 0);
5654 }
5655 ios.width(25);
5656 right(ios);
5657 {
5658 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5659 std::string ex(str, iter.base());
5660 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5661 assert(ios.width() == 0);
5662 }
5663 ios.width(25);
5664 internal(ios);
5665 {
5666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5667 std::string ex(str, iter.base());
5668 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5669 assert(ios.width() == 0);
5670 }
5671 }
5672 }
5673 }
5674 }
5675 uppercase(ios);
5676 {
5677 noshowpos(ios);
5678 {
5679 noshowpoint(ios);
5680 {
5681 ios.imbue(lc);
5682 {
5683 ios.width(0);
5684 {
5685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5686 std::string ex(str, iter.base());
5687 assert(ex == "-0");
5688 assert(ios.width() == 0);
5689 }
5690 ios.width(25);
5691 left(ios);
5692 {
5693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5694 std::string ex(str, iter.base());
5695 assert(ex == "-0***********************");
5696 assert(ios.width() == 0);
5697 }
5698 ios.width(25);
5699 right(ios);
5700 {
5701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5702 std::string ex(str, iter.base());
5703 assert(ex == "***********************-0");
5704 assert(ios.width() == 0);
5705 }
5706 ios.width(25);
5707 internal(ios);
5708 {
5709 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5710 std::string ex(str, iter.base());
5711 assert(ex == "-***********************0");
5712 assert(ios.width() == 0);
5713 }
5714 }
5715 ios.imbue(lg);
5716 {
5717 ios.width(0);
5718 {
5719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5720 std::string ex(str, iter.base());
5721 assert(ex == "-0");
5722 assert(ios.width() == 0);
5723 }
5724 ios.width(25);
5725 left(ios);
5726 {
5727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5728 std::string ex(str, iter.base());
5729 assert(ex == "-0***********************");
5730 assert(ios.width() == 0);
5731 }
5732 ios.width(25);
5733 right(ios);
5734 {
5735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5736 std::string ex(str, iter.base());
5737 assert(ex == "***********************-0");
5738 assert(ios.width() == 0);
5739 }
5740 ios.width(25);
5741 internal(ios);
5742 {
5743 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5744 std::string ex(str, iter.base());
5745 assert(ex == "-***********************0");
5746 assert(ios.width() == 0);
5747 }
5748 }
5749 }
5750 showpoint(ios);
5751 {
5752 ios.imbue(lc);
5753 {
5754 ios.width(0);
5755 {
5756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5757 std::string ex(str, iter.base());
5758 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5759 assert(ios.width() == 0);
5760 }
5761 ios.width(25);
5762 left(ios);
5763 {
5764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5765 std::string ex(str, iter.base());
5766 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5767 assert(ios.width() == 0);
5768 }
5769 ios.width(25);
5770 right(ios);
5771 {
5772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5773 std::string ex(str, iter.base());
5774 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5775 assert(ios.width() == 0);
5776 }
5777 ios.width(25);
5778 internal(ios);
5779 {
5780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5781 std::string ex(str, iter.base());
5782 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5783 assert(ios.width() == 0);
5784 }
5785 }
5786 ios.imbue(lg);
5787 {
5788 ios.width(0);
5789 {
5790 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5791 std::string ex(str, iter.base());
5792 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5793 assert(ios.width() == 0);
5794 }
5795 ios.width(25);
5796 left(ios);
5797 {
5798 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5799 std::string ex(str, iter.base());
5800 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5801 assert(ios.width() == 0);
5802 }
5803 ios.width(25);
5804 right(ios);
5805 {
5806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5807 std::string ex(str, iter.base());
5808 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5809 assert(ios.width() == 0);
5810 }
5811 ios.width(25);
5812 internal(ios);
5813 {
5814 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5815 std::string ex(str, iter.base());
5816 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5817 assert(ios.width() == 0);
5818 }
5819 }
5820 }
5821 }
5822 showpos(ios);
5823 {
5824 noshowpoint(ios);
5825 {
5826 ios.imbue(lc);
5827 {
5828 ios.width(0);
5829 {
5830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5831 std::string ex(str, iter.base());
5832 assert(ex == "-0");
5833 assert(ios.width() == 0);
5834 }
5835 ios.width(25);
5836 left(ios);
5837 {
5838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5839 std::string ex(str, iter.base());
5840 assert(ex == "-0***********************");
5841 assert(ios.width() == 0);
5842 }
5843 ios.width(25);
5844 right(ios);
5845 {
5846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5847 std::string ex(str, iter.base());
5848 assert(ex == "***********************-0");
5849 assert(ios.width() == 0);
5850 }
5851 ios.width(25);
5852 internal(ios);
5853 {
5854 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5855 std::string ex(str, iter.base());
5856 assert(ex == "-***********************0");
5857 assert(ios.width() == 0);
5858 }
5859 }
5860 ios.imbue(lg);
5861 {
5862 ios.width(0);
5863 {
5864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5865 std::string ex(str, iter.base());
5866 assert(ex == "-0");
5867 assert(ios.width() == 0);
5868 }
5869 ios.width(25);
5870 left(ios);
5871 {
5872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5873 std::string ex(str, iter.base());
5874 assert(ex == "-0***********************");
5875 assert(ios.width() == 0);
5876 }
5877 ios.width(25);
5878 right(ios);
5879 {
5880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5881 std::string ex(str, iter.base());
5882 assert(ex == "***********************-0");
5883 assert(ios.width() == 0);
5884 }
5885 ios.width(25);
5886 internal(ios);
5887 {
5888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5889 std::string ex(str, iter.base());
5890 assert(ex == "-***********************0");
5891 assert(ios.width() == 0);
5892 }
5893 }
5894 }
5895 showpoint(ios);
5896 {
5897 ios.imbue(lc);
5898 {
5899 ios.width(0);
5900 {
5901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5902 std::string ex(str, iter.base());
5903 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5904 assert(ios.width() == 0);
5905 }
5906 ios.width(25);
5907 left(ios);
5908 {
5909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5910 std::string ex(str, iter.base());
5911 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5912 assert(ios.width() == 0);
5913 }
5914 ios.width(25);
5915 right(ios);
5916 {
5917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5918 std::string ex(str, iter.base());
5919 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5920 assert(ios.width() == 0);
5921 }
5922 ios.width(25);
5923 internal(ios);
5924 {
5925 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5926 std::string ex(str, iter.base());
5927 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5928 assert(ios.width() == 0);
5929 }
5930 }
5931 ios.imbue(lg);
5932 {
5933 ios.width(0);
5934 {
5935 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5936 std::string ex(str, iter.base());
5937 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5938 assert(ios.width() == 0);
5939 }
5940 ios.width(25);
5941 left(ios);
5942 {
5943 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5944 std::string ex(str, iter.base());
5945 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5946 assert(ios.width() == 0);
5947 }
5948 ios.width(25);
5949 right(ios);
5950 {
5951 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5952 std::string ex(str, iter.base());
5953 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5954 assert(ios.width() == 0);
5955 }
5956 ios.width(25);
5957 internal(ios);
5958 {
5959 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5960 std::string ex(str, iter.base());
5961 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5962 assert(ios.width() == 0);
5963 }
5964 }
5965 }
5966 }
5967 }
5968 }
5969 }
5970 }
5971 }
5972
test3()5973 void test3()
5974 {
5975 char str[200];
5976 output_iterator<char*> iter;
5977 std::locale lc = std::locale::classic();
5978 std::locale lg(lc, new my_numpunct);
5979 const my_facet f(1);
5980 {
5981 long double v = 1234567890.125;
5982 std::ios ios(0);
5983 // %g
5984 {
5985 ios.precision(0);
5986 {
5987 nouppercase(ios);
5988 {
5989 noshowpos(ios);
5990 {
5991 noshowpoint(ios);
5992 {
5993 ios.imbue(lc);
5994 {
5995 ios.width(0);
5996 {
5997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5998 std::string ex(str, iter.base());
5999 assert(ex == "1e+09");
6000 assert(ios.width() == 0);
6001 }
6002 ios.width(25);
6003 left(ios);
6004 {
6005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6006 std::string ex(str, iter.base());
6007 assert(ex == "1e+09********************");
6008 assert(ios.width() == 0);
6009 }
6010 ios.width(25);
6011 right(ios);
6012 {
6013 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6014 std::string ex(str, iter.base());
6015 assert(ex == "********************1e+09");
6016 assert(ios.width() == 0);
6017 }
6018 ios.width(25);
6019 internal(ios);
6020 {
6021 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6022 std::string ex(str, iter.base());
6023 assert(ex == "********************1e+09");
6024 assert(ios.width() == 0);
6025 }
6026 }
6027 ios.imbue(lg);
6028 {
6029 ios.width(0);
6030 {
6031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6032 std::string ex(str, iter.base());
6033 assert(ex == "1e+09");
6034 assert(ios.width() == 0);
6035 }
6036 ios.width(25);
6037 left(ios);
6038 {
6039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6040 std::string ex(str, iter.base());
6041 assert(ex == "1e+09********************");
6042 assert(ios.width() == 0);
6043 }
6044 ios.width(25);
6045 right(ios);
6046 {
6047 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6048 std::string ex(str, iter.base());
6049 assert(ex == "********************1e+09");
6050 assert(ios.width() == 0);
6051 }
6052 ios.width(25);
6053 internal(ios);
6054 {
6055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6056 std::string ex(str, iter.base());
6057 assert(ex == "********************1e+09");
6058 assert(ios.width() == 0);
6059 }
6060 }
6061 }
6062 showpoint(ios);
6063 {
6064 ios.imbue(lc);
6065 {
6066 ios.width(0);
6067 {
6068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6069 std::string ex(str, iter.base());
6070 assert(ex == "1.e+09");
6071 assert(ios.width() == 0);
6072 }
6073 ios.width(25);
6074 left(ios);
6075 {
6076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6077 std::string ex(str, iter.base());
6078 assert(ex == "1.e+09*******************");
6079 assert(ios.width() == 0);
6080 }
6081 ios.width(25);
6082 right(ios);
6083 {
6084 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6085 std::string ex(str, iter.base());
6086 assert(ex == "*******************1.e+09");
6087 assert(ios.width() == 0);
6088 }
6089 ios.width(25);
6090 internal(ios);
6091 {
6092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6093 std::string ex(str, iter.base());
6094 assert(ex == "*******************1.e+09");
6095 assert(ios.width() == 0);
6096 }
6097 }
6098 ios.imbue(lg);
6099 {
6100 ios.width(0);
6101 {
6102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6103 std::string ex(str, iter.base());
6104 assert(ex == "1;e+09");
6105 assert(ios.width() == 0);
6106 }
6107 ios.width(25);
6108 left(ios);
6109 {
6110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6111 std::string ex(str, iter.base());
6112 assert(ex == "1;e+09*******************");
6113 assert(ios.width() == 0);
6114 }
6115 ios.width(25);
6116 right(ios);
6117 {
6118 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6119 std::string ex(str, iter.base());
6120 assert(ex == "*******************1;e+09");
6121 assert(ios.width() == 0);
6122 }
6123 ios.width(25);
6124 internal(ios);
6125 {
6126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6127 std::string ex(str, iter.base());
6128 assert(ex == "*******************1;e+09");
6129 assert(ios.width() == 0);
6130 }
6131 }
6132 }
6133 }
6134 showpos(ios);
6135 {
6136 noshowpoint(ios);
6137 {
6138 ios.imbue(lc);
6139 {
6140 ios.width(0);
6141 {
6142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6143 std::string ex(str, iter.base());
6144 assert(ex == "+1e+09");
6145 assert(ios.width() == 0);
6146 }
6147 ios.width(25);
6148 left(ios);
6149 {
6150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6151 std::string ex(str, iter.base());
6152 assert(ex == "+1e+09*******************");
6153 assert(ios.width() == 0);
6154 }
6155 ios.width(25);
6156 right(ios);
6157 {
6158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6159 std::string ex(str, iter.base());
6160 assert(ex == "*******************+1e+09");
6161 assert(ios.width() == 0);
6162 }
6163 ios.width(25);
6164 internal(ios);
6165 {
6166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6167 std::string ex(str, iter.base());
6168 assert(ex == "+*******************1e+09");
6169 assert(ios.width() == 0);
6170 }
6171 }
6172 ios.imbue(lg);
6173 {
6174 ios.width(0);
6175 {
6176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6177 std::string ex(str, iter.base());
6178 assert(ex == "+1e+09");
6179 assert(ios.width() == 0);
6180 }
6181 ios.width(25);
6182 left(ios);
6183 {
6184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6185 std::string ex(str, iter.base());
6186 assert(ex == "+1e+09*******************");
6187 assert(ios.width() == 0);
6188 }
6189 ios.width(25);
6190 right(ios);
6191 {
6192 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6193 std::string ex(str, iter.base());
6194 assert(ex == "*******************+1e+09");
6195 assert(ios.width() == 0);
6196 }
6197 ios.width(25);
6198 internal(ios);
6199 {
6200 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6201 std::string ex(str, iter.base());
6202 assert(ex == "+*******************1e+09");
6203 assert(ios.width() == 0);
6204 }
6205 }
6206 }
6207 showpoint(ios);
6208 {
6209 ios.imbue(lc);
6210 {
6211 ios.width(0);
6212 {
6213 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6214 std::string ex(str, iter.base());
6215 assert(ex == "+1.e+09");
6216 assert(ios.width() == 0);
6217 }
6218 ios.width(25);
6219 left(ios);
6220 {
6221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6222 std::string ex(str, iter.base());
6223 assert(ex == "+1.e+09******************");
6224 assert(ios.width() == 0);
6225 }
6226 ios.width(25);
6227 right(ios);
6228 {
6229 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6230 std::string ex(str, iter.base());
6231 assert(ex == "******************+1.e+09");
6232 assert(ios.width() == 0);
6233 }
6234 ios.width(25);
6235 internal(ios);
6236 {
6237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6238 std::string ex(str, iter.base());
6239 assert(ex == "+******************1.e+09");
6240 assert(ios.width() == 0);
6241 }
6242 }
6243 ios.imbue(lg);
6244 {
6245 ios.width(0);
6246 {
6247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6248 std::string ex(str, iter.base());
6249 assert(ex == "+1;e+09");
6250 assert(ios.width() == 0);
6251 }
6252 ios.width(25);
6253 left(ios);
6254 {
6255 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6256 std::string ex(str, iter.base());
6257 assert(ex == "+1;e+09******************");
6258 assert(ios.width() == 0);
6259 }
6260 ios.width(25);
6261 right(ios);
6262 {
6263 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6264 std::string ex(str, iter.base());
6265 assert(ex == "******************+1;e+09");
6266 assert(ios.width() == 0);
6267 }
6268 ios.width(25);
6269 internal(ios);
6270 {
6271 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6272 std::string ex(str, iter.base());
6273 assert(ex == "+******************1;e+09");
6274 assert(ios.width() == 0);
6275 }
6276 }
6277 }
6278 }
6279 }
6280 uppercase(ios);
6281 {
6282 noshowpos(ios);
6283 {
6284 noshowpoint(ios);
6285 {
6286 ios.imbue(lc);
6287 {
6288 ios.width(0);
6289 {
6290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6291 std::string ex(str, iter.base());
6292 assert(ex == "1E+09");
6293 assert(ios.width() == 0);
6294 }
6295 ios.width(25);
6296 left(ios);
6297 {
6298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6299 std::string ex(str, iter.base());
6300 assert(ex == "1E+09********************");
6301 assert(ios.width() == 0);
6302 }
6303 ios.width(25);
6304 right(ios);
6305 {
6306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6307 std::string ex(str, iter.base());
6308 assert(ex == "********************1E+09");
6309 assert(ios.width() == 0);
6310 }
6311 ios.width(25);
6312 internal(ios);
6313 {
6314 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6315 std::string ex(str, iter.base());
6316 assert(ex == "********************1E+09");
6317 assert(ios.width() == 0);
6318 }
6319 }
6320 ios.imbue(lg);
6321 {
6322 ios.width(0);
6323 {
6324 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6325 std::string ex(str, iter.base());
6326 assert(ex == "1E+09");
6327 assert(ios.width() == 0);
6328 }
6329 ios.width(25);
6330 left(ios);
6331 {
6332 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6333 std::string ex(str, iter.base());
6334 assert(ex == "1E+09********************");
6335 assert(ios.width() == 0);
6336 }
6337 ios.width(25);
6338 right(ios);
6339 {
6340 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6341 std::string ex(str, iter.base());
6342 assert(ex == "********************1E+09");
6343 assert(ios.width() == 0);
6344 }
6345 ios.width(25);
6346 internal(ios);
6347 {
6348 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6349 std::string ex(str, iter.base());
6350 assert(ex == "********************1E+09");
6351 assert(ios.width() == 0);
6352 }
6353 }
6354 }
6355 showpoint(ios);
6356 {
6357 ios.imbue(lc);
6358 {
6359 ios.width(0);
6360 {
6361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6362 std::string ex(str, iter.base());
6363 assert(ex == "1.E+09");
6364 assert(ios.width() == 0);
6365 }
6366 ios.width(25);
6367 left(ios);
6368 {
6369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6370 std::string ex(str, iter.base());
6371 assert(ex == "1.E+09*******************");
6372 assert(ios.width() == 0);
6373 }
6374 ios.width(25);
6375 right(ios);
6376 {
6377 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6378 std::string ex(str, iter.base());
6379 assert(ex == "*******************1.E+09");
6380 assert(ios.width() == 0);
6381 }
6382 ios.width(25);
6383 internal(ios);
6384 {
6385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6386 std::string ex(str, iter.base());
6387 assert(ex == "*******************1.E+09");
6388 assert(ios.width() == 0);
6389 }
6390 }
6391 ios.imbue(lg);
6392 {
6393 ios.width(0);
6394 {
6395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6396 std::string ex(str, iter.base());
6397 assert(ex == "1;E+09");
6398 assert(ios.width() == 0);
6399 }
6400 ios.width(25);
6401 left(ios);
6402 {
6403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6404 std::string ex(str, iter.base());
6405 assert(ex == "1;E+09*******************");
6406 assert(ios.width() == 0);
6407 }
6408 ios.width(25);
6409 right(ios);
6410 {
6411 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6412 std::string ex(str, iter.base());
6413 assert(ex == "*******************1;E+09");
6414 assert(ios.width() == 0);
6415 }
6416 ios.width(25);
6417 internal(ios);
6418 {
6419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6420 std::string ex(str, iter.base());
6421 assert(ex == "*******************1;E+09");
6422 assert(ios.width() == 0);
6423 }
6424 }
6425 }
6426 }
6427 showpos(ios);
6428 {
6429 noshowpoint(ios);
6430 {
6431 ios.imbue(lc);
6432 {
6433 ios.width(0);
6434 {
6435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6436 std::string ex(str, iter.base());
6437 assert(ex == "+1E+09");
6438 assert(ios.width() == 0);
6439 }
6440 ios.width(25);
6441 left(ios);
6442 {
6443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6444 std::string ex(str, iter.base());
6445 assert(ex == "+1E+09*******************");
6446 assert(ios.width() == 0);
6447 }
6448 ios.width(25);
6449 right(ios);
6450 {
6451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6452 std::string ex(str, iter.base());
6453 assert(ex == "*******************+1E+09");
6454 assert(ios.width() == 0);
6455 }
6456 ios.width(25);
6457 internal(ios);
6458 {
6459 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6460 std::string ex(str, iter.base());
6461 assert(ex == "+*******************1E+09");
6462 assert(ios.width() == 0);
6463 }
6464 }
6465 ios.imbue(lg);
6466 {
6467 ios.width(0);
6468 {
6469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6470 std::string ex(str, iter.base());
6471 assert(ex == "+1E+09");
6472 assert(ios.width() == 0);
6473 }
6474 ios.width(25);
6475 left(ios);
6476 {
6477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6478 std::string ex(str, iter.base());
6479 assert(ex == "+1E+09*******************");
6480 assert(ios.width() == 0);
6481 }
6482 ios.width(25);
6483 right(ios);
6484 {
6485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6486 std::string ex(str, iter.base());
6487 assert(ex == "*******************+1E+09");
6488 assert(ios.width() == 0);
6489 }
6490 ios.width(25);
6491 internal(ios);
6492 {
6493 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6494 std::string ex(str, iter.base());
6495 assert(ex == "+*******************1E+09");
6496 assert(ios.width() == 0);
6497 }
6498 }
6499 }
6500 showpoint(ios);
6501 {
6502 ios.imbue(lc);
6503 {
6504 ios.width(0);
6505 {
6506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6507 std::string ex(str, iter.base());
6508 assert(ex == "+1.E+09");
6509 assert(ios.width() == 0);
6510 }
6511 ios.width(25);
6512 left(ios);
6513 {
6514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6515 std::string ex(str, iter.base());
6516 assert(ex == "+1.E+09******************");
6517 assert(ios.width() == 0);
6518 }
6519 ios.width(25);
6520 right(ios);
6521 {
6522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6523 std::string ex(str, iter.base());
6524 assert(ex == "******************+1.E+09");
6525 assert(ios.width() == 0);
6526 }
6527 ios.width(25);
6528 internal(ios);
6529 {
6530 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6531 std::string ex(str, iter.base());
6532 assert(ex == "+******************1.E+09");
6533 assert(ios.width() == 0);
6534 }
6535 }
6536 ios.imbue(lg);
6537 {
6538 ios.width(0);
6539 {
6540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6541 std::string ex(str, iter.base());
6542 assert(ex == "+1;E+09");
6543 assert(ios.width() == 0);
6544 }
6545 ios.width(25);
6546 left(ios);
6547 {
6548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6549 std::string ex(str, iter.base());
6550 assert(ex == "+1;E+09******************");
6551 assert(ios.width() == 0);
6552 }
6553 ios.width(25);
6554 right(ios);
6555 {
6556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6557 std::string ex(str, iter.base());
6558 assert(ex == "******************+1;E+09");
6559 assert(ios.width() == 0);
6560 }
6561 ios.width(25);
6562 internal(ios);
6563 {
6564 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6565 std::string ex(str, iter.base());
6566 assert(ex == "+******************1;E+09");
6567 assert(ios.width() == 0);
6568 }
6569 }
6570 }
6571 }
6572 }
6573 }
6574 ios.precision(1);
6575 {
6576 nouppercase(ios);
6577 {
6578 noshowpos(ios);
6579 {
6580 noshowpoint(ios);
6581 {
6582 ios.imbue(lc);
6583 {
6584 ios.width(0);
6585 {
6586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6587 std::string ex(str, iter.base());
6588 assert(ex == "1e+09");
6589 assert(ios.width() == 0);
6590 }
6591 ios.width(25);
6592 left(ios);
6593 {
6594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6595 std::string ex(str, iter.base());
6596 assert(ex == "1e+09********************");
6597 assert(ios.width() == 0);
6598 }
6599 ios.width(25);
6600 right(ios);
6601 {
6602 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6603 std::string ex(str, iter.base());
6604 assert(ex == "********************1e+09");
6605 assert(ios.width() == 0);
6606 }
6607 ios.width(25);
6608 internal(ios);
6609 {
6610 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6611 std::string ex(str, iter.base());
6612 assert(ex == "********************1e+09");
6613 assert(ios.width() == 0);
6614 }
6615 }
6616 ios.imbue(lg);
6617 {
6618 ios.width(0);
6619 {
6620 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6621 std::string ex(str, iter.base());
6622 assert(ex == "1e+09");
6623 assert(ios.width() == 0);
6624 }
6625 ios.width(25);
6626 left(ios);
6627 {
6628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6629 std::string ex(str, iter.base());
6630 assert(ex == "1e+09********************");
6631 assert(ios.width() == 0);
6632 }
6633 ios.width(25);
6634 right(ios);
6635 {
6636 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6637 std::string ex(str, iter.base());
6638 assert(ex == "********************1e+09");
6639 assert(ios.width() == 0);
6640 }
6641 ios.width(25);
6642 internal(ios);
6643 {
6644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6645 std::string ex(str, iter.base());
6646 assert(ex == "********************1e+09");
6647 assert(ios.width() == 0);
6648 }
6649 }
6650 }
6651 showpoint(ios);
6652 {
6653 ios.imbue(lc);
6654 {
6655 ios.width(0);
6656 {
6657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6658 std::string ex(str, iter.base());
6659 assert(ex == "1.e+09");
6660 assert(ios.width() == 0);
6661 }
6662 ios.width(25);
6663 left(ios);
6664 {
6665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6666 std::string ex(str, iter.base());
6667 assert(ex == "1.e+09*******************");
6668 assert(ios.width() == 0);
6669 }
6670 ios.width(25);
6671 right(ios);
6672 {
6673 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6674 std::string ex(str, iter.base());
6675 assert(ex == "*******************1.e+09");
6676 assert(ios.width() == 0);
6677 }
6678 ios.width(25);
6679 internal(ios);
6680 {
6681 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6682 std::string ex(str, iter.base());
6683 assert(ex == "*******************1.e+09");
6684 assert(ios.width() == 0);
6685 }
6686 }
6687 ios.imbue(lg);
6688 {
6689 ios.width(0);
6690 {
6691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6692 std::string ex(str, iter.base());
6693 assert(ex == "1;e+09");
6694 assert(ios.width() == 0);
6695 }
6696 ios.width(25);
6697 left(ios);
6698 {
6699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6700 std::string ex(str, iter.base());
6701 assert(ex == "1;e+09*******************");
6702 assert(ios.width() == 0);
6703 }
6704 ios.width(25);
6705 right(ios);
6706 {
6707 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6708 std::string ex(str, iter.base());
6709 assert(ex == "*******************1;e+09");
6710 assert(ios.width() == 0);
6711 }
6712 ios.width(25);
6713 internal(ios);
6714 {
6715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6716 std::string ex(str, iter.base());
6717 assert(ex == "*******************1;e+09");
6718 assert(ios.width() == 0);
6719 }
6720 }
6721 }
6722 }
6723 showpos(ios);
6724 {
6725 noshowpoint(ios);
6726 {
6727 ios.imbue(lc);
6728 {
6729 ios.width(0);
6730 {
6731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6732 std::string ex(str, iter.base());
6733 assert(ex == "+1e+09");
6734 assert(ios.width() == 0);
6735 }
6736 ios.width(25);
6737 left(ios);
6738 {
6739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6740 std::string ex(str, iter.base());
6741 assert(ex == "+1e+09*******************");
6742 assert(ios.width() == 0);
6743 }
6744 ios.width(25);
6745 right(ios);
6746 {
6747 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6748 std::string ex(str, iter.base());
6749 assert(ex == "*******************+1e+09");
6750 assert(ios.width() == 0);
6751 }
6752 ios.width(25);
6753 internal(ios);
6754 {
6755 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6756 std::string ex(str, iter.base());
6757 assert(ex == "+*******************1e+09");
6758 assert(ios.width() == 0);
6759 }
6760 }
6761 ios.imbue(lg);
6762 {
6763 ios.width(0);
6764 {
6765 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6766 std::string ex(str, iter.base());
6767 assert(ex == "+1e+09");
6768 assert(ios.width() == 0);
6769 }
6770 ios.width(25);
6771 left(ios);
6772 {
6773 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6774 std::string ex(str, iter.base());
6775 assert(ex == "+1e+09*******************");
6776 assert(ios.width() == 0);
6777 }
6778 ios.width(25);
6779 right(ios);
6780 {
6781 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6782 std::string ex(str, iter.base());
6783 assert(ex == "*******************+1e+09");
6784 assert(ios.width() == 0);
6785 }
6786 ios.width(25);
6787 internal(ios);
6788 {
6789 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6790 std::string ex(str, iter.base());
6791 assert(ex == "+*******************1e+09");
6792 assert(ios.width() == 0);
6793 }
6794 }
6795 }
6796 showpoint(ios);
6797 {
6798 ios.imbue(lc);
6799 {
6800 ios.width(0);
6801 {
6802 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6803 std::string ex(str, iter.base());
6804 assert(ex == "+1.e+09");
6805 assert(ios.width() == 0);
6806 }
6807 ios.width(25);
6808 left(ios);
6809 {
6810 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6811 std::string ex(str, iter.base());
6812 assert(ex == "+1.e+09******************");
6813 assert(ios.width() == 0);
6814 }
6815 ios.width(25);
6816 right(ios);
6817 {
6818 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6819 std::string ex(str, iter.base());
6820 assert(ex == "******************+1.e+09");
6821 assert(ios.width() == 0);
6822 }
6823 ios.width(25);
6824 internal(ios);
6825 {
6826 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6827 std::string ex(str, iter.base());
6828 assert(ex == "+******************1.e+09");
6829 assert(ios.width() == 0);
6830 }
6831 }
6832 ios.imbue(lg);
6833 {
6834 ios.width(0);
6835 {
6836 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6837 std::string ex(str, iter.base());
6838 assert(ex == "+1;e+09");
6839 assert(ios.width() == 0);
6840 }
6841 ios.width(25);
6842 left(ios);
6843 {
6844 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6845 std::string ex(str, iter.base());
6846 assert(ex == "+1;e+09******************");
6847 assert(ios.width() == 0);
6848 }
6849 ios.width(25);
6850 right(ios);
6851 {
6852 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6853 std::string ex(str, iter.base());
6854 assert(ex == "******************+1;e+09");
6855 assert(ios.width() == 0);
6856 }
6857 ios.width(25);
6858 internal(ios);
6859 {
6860 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6861 std::string ex(str, iter.base());
6862 assert(ex == "+******************1;e+09");
6863 assert(ios.width() == 0);
6864 }
6865 }
6866 }
6867 }
6868 }
6869 uppercase(ios);
6870 {
6871 noshowpos(ios);
6872 {
6873 noshowpoint(ios);
6874 {
6875 ios.imbue(lc);
6876 {
6877 ios.width(0);
6878 {
6879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6880 std::string ex(str, iter.base());
6881 assert(ex == "1E+09");
6882 assert(ios.width() == 0);
6883 }
6884 ios.width(25);
6885 left(ios);
6886 {
6887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6888 std::string ex(str, iter.base());
6889 assert(ex == "1E+09********************");
6890 assert(ios.width() == 0);
6891 }
6892 ios.width(25);
6893 right(ios);
6894 {
6895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6896 std::string ex(str, iter.base());
6897 assert(ex == "********************1E+09");
6898 assert(ios.width() == 0);
6899 }
6900 ios.width(25);
6901 internal(ios);
6902 {
6903 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6904 std::string ex(str, iter.base());
6905 assert(ex == "********************1E+09");
6906 assert(ios.width() == 0);
6907 }
6908 }
6909 ios.imbue(lg);
6910 {
6911 ios.width(0);
6912 {
6913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6914 std::string ex(str, iter.base());
6915 assert(ex == "1E+09");
6916 assert(ios.width() == 0);
6917 }
6918 ios.width(25);
6919 left(ios);
6920 {
6921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6922 std::string ex(str, iter.base());
6923 assert(ex == "1E+09********************");
6924 assert(ios.width() == 0);
6925 }
6926 ios.width(25);
6927 right(ios);
6928 {
6929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6930 std::string ex(str, iter.base());
6931 assert(ex == "********************1E+09");
6932 assert(ios.width() == 0);
6933 }
6934 ios.width(25);
6935 internal(ios);
6936 {
6937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6938 std::string ex(str, iter.base());
6939 assert(ex == "********************1E+09");
6940 assert(ios.width() == 0);
6941 }
6942 }
6943 }
6944 showpoint(ios);
6945 {
6946 ios.imbue(lc);
6947 {
6948 ios.width(0);
6949 {
6950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6951 std::string ex(str, iter.base());
6952 assert(ex == "1.E+09");
6953 assert(ios.width() == 0);
6954 }
6955 ios.width(25);
6956 left(ios);
6957 {
6958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6959 std::string ex(str, iter.base());
6960 assert(ex == "1.E+09*******************");
6961 assert(ios.width() == 0);
6962 }
6963 ios.width(25);
6964 right(ios);
6965 {
6966 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6967 std::string ex(str, iter.base());
6968 assert(ex == "*******************1.E+09");
6969 assert(ios.width() == 0);
6970 }
6971 ios.width(25);
6972 internal(ios);
6973 {
6974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6975 std::string ex(str, iter.base());
6976 assert(ex == "*******************1.E+09");
6977 assert(ios.width() == 0);
6978 }
6979 }
6980 ios.imbue(lg);
6981 {
6982 ios.width(0);
6983 {
6984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6985 std::string ex(str, iter.base());
6986 assert(ex == "1;E+09");
6987 assert(ios.width() == 0);
6988 }
6989 ios.width(25);
6990 left(ios);
6991 {
6992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6993 std::string ex(str, iter.base());
6994 assert(ex == "1;E+09*******************");
6995 assert(ios.width() == 0);
6996 }
6997 ios.width(25);
6998 right(ios);
6999 {
7000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7001 std::string ex(str, iter.base());
7002 assert(ex == "*******************1;E+09");
7003 assert(ios.width() == 0);
7004 }
7005 ios.width(25);
7006 internal(ios);
7007 {
7008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7009 std::string ex(str, iter.base());
7010 assert(ex == "*******************1;E+09");
7011 assert(ios.width() == 0);
7012 }
7013 }
7014 }
7015 }
7016 showpos(ios);
7017 {
7018 noshowpoint(ios);
7019 {
7020 ios.imbue(lc);
7021 {
7022 ios.width(0);
7023 {
7024 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7025 std::string ex(str, iter.base());
7026 assert(ex == "+1E+09");
7027 assert(ios.width() == 0);
7028 }
7029 ios.width(25);
7030 left(ios);
7031 {
7032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7033 std::string ex(str, iter.base());
7034 assert(ex == "+1E+09*******************");
7035 assert(ios.width() == 0);
7036 }
7037 ios.width(25);
7038 right(ios);
7039 {
7040 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7041 std::string ex(str, iter.base());
7042 assert(ex == "*******************+1E+09");
7043 assert(ios.width() == 0);
7044 }
7045 ios.width(25);
7046 internal(ios);
7047 {
7048 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7049 std::string ex(str, iter.base());
7050 assert(ex == "+*******************1E+09");
7051 assert(ios.width() == 0);
7052 }
7053 }
7054 ios.imbue(lg);
7055 {
7056 ios.width(0);
7057 {
7058 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7059 std::string ex(str, iter.base());
7060 assert(ex == "+1E+09");
7061 assert(ios.width() == 0);
7062 }
7063 ios.width(25);
7064 left(ios);
7065 {
7066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7067 std::string ex(str, iter.base());
7068 assert(ex == "+1E+09*******************");
7069 assert(ios.width() == 0);
7070 }
7071 ios.width(25);
7072 right(ios);
7073 {
7074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7075 std::string ex(str, iter.base());
7076 assert(ex == "*******************+1E+09");
7077 assert(ios.width() == 0);
7078 }
7079 ios.width(25);
7080 internal(ios);
7081 {
7082 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7083 std::string ex(str, iter.base());
7084 assert(ex == "+*******************1E+09");
7085 assert(ios.width() == 0);
7086 }
7087 }
7088 }
7089 showpoint(ios);
7090 {
7091 ios.imbue(lc);
7092 {
7093 ios.width(0);
7094 {
7095 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7096 std::string ex(str, iter.base());
7097 assert(ex == "+1.E+09");
7098 assert(ios.width() == 0);
7099 }
7100 ios.width(25);
7101 left(ios);
7102 {
7103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7104 std::string ex(str, iter.base());
7105 assert(ex == "+1.E+09******************");
7106 assert(ios.width() == 0);
7107 }
7108 ios.width(25);
7109 right(ios);
7110 {
7111 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7112 std::string ex(str, iter.base());
7113 assert(ex == "******************+1.E+09");
7114 assert(ios.width() == 0);
7115 }
7116 ios.width(25);
7117 internal(ios);
7118 {
7119 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7120 std::string ex(str, iter.base());
7121 assert(ex == "+******************1.E+09");
7122 assert(ios.width() == 0);
7123 }
7124 }
7125 ios.imbue(lg);
7126 {
7127 ios.width(0);
7128 {
7129 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7130 std::string ex(str, iter.base());
7131 assert(ex == "+1;E+09");
7132 assert(ios.width() == 0);
7133 }
7134 ios.width(25);
7135 left(ios);
7136 {
7137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7138 std::string ex(str, iter.base());
7139 assert(ex == "+1;E+09******************");
7140 assert(ios.width() == 0);
7141 }
7142 ios.width(25);
7143 right(ios);
7144 {
7145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7146 std::string ex(str, iter.base());
7147 assert(ex == "******************+1;E+09");
7148 assert(ios.width() == 0);
7149 }
7150 ios.width(25);
7151 internal(ios);
7152 {
7153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7154 std::string ex(str, iter.base());
7155 assert(ex == "+******************1;E+09");
7156 assert(ios.width() == 0);
7157 }
7158 }
7159 }
7160 }
7161 }
7162 }
7163 ios.precision(6);
7164 {
7165 nouppercase(ios);
7166 {
7167 noshowpos(ios);
7168 {
7169 noshowpoint(ios);
7170 {
7171 ios.imbue(lc);
7172 {
7173 ios.width(0);
7174 {
7175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7176 std::string ex(str, iter.base());
7177 assert(ex == "1.23457e+09");
7178 assert(ios.width() == 0);
7179 }
7180 ios.width(25);
7181 left(ios);
7182 {
7183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7184 std::string ex(str, iter.base());
7185 assert(ex == "1.23457e+09**************");
7186 assert(ios.width() == 0);
7187 }
7188 ios.width(25);
7189 right(ios);
7190 {
7191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7192 std::string ex(str, iter.base());
7193 assert(ex == "**************1.23457e+09");
7194 assert(ios.width() == 0);
7195 }
7196 ios.width(25);
7197 internal(ios);
7198 {
7199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7200 std::string ex(str, iter.base());
7201 assert(ex == "**************1.23457e+09");
7202 assert(ios.width() == 0);
7203 }
7204 }
7205 ios.imbue(lg);
7206 {
7207 ios.width(0);
7208 {
7209 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7210 std::string ex(str, iter.base());
7211 assert(ex == "1;23457e+09");
7212 assert(ios.width() == 0);
7213 }
7214 ios.width(25);
7215 left(ios);
7216 {
7217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7218 std::string ex(str, iter.base());
7219 assert(ex == "1;23457e+09**************");
7220 assert(ios.width() == 0);
7221 }
7222 ios.width(25);
7223 right(ios);
7224 {
7225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7226 std::string ex(str, iter.base());
7227 assert(ex == "**************1;23457e+09");
7228 assert(ios.width() == 0);
7229 }
7230 ios.width(25);
7231 internal(ios);
7232 {
7233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7234 std::string ex(str, iter.base());
7235 assert(ex == "**************1;23457e+09");
7236 assert(ios.width() == 0);
7237 }
7238 }
7239 }
7240 showpoint(ios);
7241 {
7242 ios.imbue(lc);
7243 {
7244 ios.width(0);
7245 {
7246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7247 std::string ex(str, iter.base());
7248 assert(ex == "1.23457e+09");
7249 assert(ios.width() == 0);
7250 }
7251 ios.width(25);
7252 left(ios);
7253 {
7254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7255 std::string ex(str, iter.base());
7256 assert(ex == "1.23457e+09**************");
7257 assert(ios.width() == 0);
7258 }
7259 ios.width(25);
7260 right(ios);
7261 {
7262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7263 std::string ex(str, iter.base());
7264 assert(ex == "**************1.23457e+09");
7265 assert(ios.width() == 0);
7266 }
7267 ios.width(25);
7268 internal(ios);
7269 {
7270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7271 std::string ex(str, iter.base());
7272 assert(ex == "**************1.23457e+09");
7273 assert(ios.width() == 0);
7274 }
7275 }
7276 ios.imbue(lg);
7277 {
7278 ios.width(0);
7279 {
7280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7281 std::string ex(str, iter.base());
7282 assert(ex == "1;23457e+09");
7283 assert(ios.width() == 0);
7284 }
7285 ios.width(25);
7286 left(ios);
7287 {
7288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7289 std::string ex(str, iter.base());
7290 assert(ex == "1;23457e+09**************");
7291 assert(ios.width() == 0);
7292 }
7293 ios.width(25);
7294 right(ios);
7295 {
7296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7297 std::string ex(str, iter.base());
7298 assert(ex == "**************1;23457e+09");
7299 assert(ios.width() == 0);
7300 }
7301 ios.width(25);
7302 internal(ios);
7303 {
7304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7305 std::string ex(str, iter.base());
7306 assert(ex == "**************1;23457e+09");
7307 assert(ios.width() == 0);
7308 }
7309 }
7310 }
7311 }
7312 showpos(ios);
7313 {
7314 noshowpoint(ios);
7315 {
7316 ios.imbue(lc);
7317 {
7318 ios.width(0);
7319 {
7320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7321 std::string ex(str, iter.base());
7322 assert(ex == "+1.23457e+09");
7323 assert(ios.width() == 0);
7324 }
7325 ios.width(25);
7326 left(ios);
7327 {
7328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7329 std::string ex(str, iter.base());
7330 assert(ex == "+1.23457e+09*************");
7331 assert(ios.width() == 0);
7332 }
7333 ios.width(25);
7334 right(ios);
7335 {
7336 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7337 std::string ex(str, iter.base());
7338 assert(ex == "*************+1.23457e+09");
7339 assert(ios.width() == 0);
7340 }
7341 ios.width(25);
7342 internal(ios);
7343 {
7344 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7345 std::string ex(str, iter.base());
7346 assert(ex == "+*************1.23457e+09");
7347 assert(ios.width() == 0);
7348 }
7349 }
7350 ios.imbue(lg);
7351 {
7352 ios.width(0);
7353 {
7354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7355 std::string ex(str, iter.base());
7356 assert(ex == "+1;23457e+09");
7357 assert(ios.width() == 0);
7358 }
7359 ios.width(25);
7360 left(ios);
7361 {
7362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7363 std::string ex(str, iter.base());
7364 assert(ex == "+1;23457e+09*************");
7365 assert(ios.width() == 0);
7366 }
7367 ios.width(25);
7368 right(ios);
7369 {
7370 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7371 std::string ex(str, iter.base());
7372 assert(ex == "*************+1;23457e+09");
7373 assert(ios.width() == 0);
7374 }
7375 ios.width(25);
7376 internal(ios);
7377 {
7378 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7379 std::string ex(str, iter.base());
7380 assert(ex == "+*************1;23457e+09");
7381 assert(ios.width() == 0);
7382 }
7383 }
7384 }
7385 showpoint(ios);
7386 {
7387 ios.imbue(lc);
7388 {
7389 ios.width(0);
7390 {
7391 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7392 std::string ex(str, iter.base());
7393 assert(ex == "+1.23457e+09");
7394 assert(ios.width() == 0);
7395 }
7396 ios.width(25);
7397 left(ios);
7398 {
7399 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7400 std::string ex(str, iter.base());
7401 assert(ex == "+1.23457e+09*************");
7402 assert(ios.width() == 0);
7403 }
7404 ios.width(25);
7405 right(ios);
7406 {
7407 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7408 std::string ex(str, iter.base());
7409 assert(ex == "*************+1.23457e+09");
7410 assert(ios.width() == 0);
7411 }
7412 ios.width(25);
7413 internal(ios);
7414 {
7415 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7416 std::string ex(str, iter.base());
7417 assert(ex == "+*************1.23457e+09");
7418 assert(ios.width() == 0);
7419 }
7420 }
7421 ios.imbue(lg);
7422 {
7423 ios.width(0);
7424 {
7425 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7426 std::string ex(str, iter.base());
7427 assert(ex == "+1;23457e+09");
7428 assert(ios.width() == 0);
7429 }
7430 ios.width(25);
7431 left(ios);
7432 {
7433 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7434 std::string ex(str, iter.base());
7435 assert(ex == "+1;23457e+09*************");
7436 assert(ios.width() == 0);
7437 }
7438 ios.width(25);
7439 right(ios);
7440 {
7441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7442 std::string ex(str, iter.base());
7443 assert(ex == "*************+1;23457e+09");
7444 assert(ios.width() == 0);
7445 }
7446 ios.width(25);
7447 internal(ios);
7448 {
7449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7450 std::string ex(str, iter.base());
7451 assert(ex == "+*************1;23457e+09");
7452 assert(ios.width() == 0);
7453 }
7454 }
7455 }
7456 }
7457 }
7458 uppercase(ios);
7459 {
7460 noshowpos(ios);
7461 {
7462 noshowpoint(ios);
7463 {
7464 ios.imbue(lc);
7465 {
7466 ios.width(0);
7467 {
7468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7469 std::string ex(str, iter.base());
7470 assert(ex == "1.23457E+09");
7471 assert(ios.width() == 0);
7472 }
7473 ios.width(25);
7474 left(ios);
7475 {
7476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7477 std::string ex(str, iter.base());
7478 assert(ex == "1.23457E+09**************");
7479 assert(ios.width() == 0);
7480 }
7481 ios.width(25);
7482 right(ios);
7483 {
7484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7485 std::string ex(str, iter.base());
7486 assert(ex == "**************1.23457E+09");
7487 assert(ios.width() == 0);
7488 }
7489 ios.width(25);
7490 internal(ios);
7491 {
7492 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7493 std::string ex(str, iter.base());
7494 assert(ex == "**************1.23457E+09");
7495 assert(ios.width() == 0);
7496 }
7497 }
7498 ios.imbue(lg);
7499 {
7500 ios.width(0);
7501 {
7502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7503 std::string ex(str, iter.base());
7504 assert(ex == "1;23457E+09");
7505 assert(ios.width() == 0);
7506 }
7507 ios.width(25);
7508 left(ios);
7509 {
7510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7511 std::string ex(str, iter.base());
7512 assert(ex == "1;23457E+09**************");
7513 assert(ios.width() == 0);
7514 }
7515 ios.width(25);
7516 right(ios);
7517 {
7518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7519 std::string ex(str, iter.base());
7520 assert(ex == "**************1;23457E+09");
7521 assert(ios.width() == 0);
7522 }
7523 ios.width(25);
7524 internal(ios);
7525 {
7526 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7527 std::string ex(str, iter.base());
7528 assert(ex == "**************1;23457E+09");
7529 assert(ios.width() == 0);
7530 }
7531 }
7532 }
7533 showpoint(ios);
7534 {
7535 ios.imbue(lc);
7536 {
7537 ios.width(0);
7538 {
7539 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7540 std::string ex(str, iter.base());
7541 assert(ex == "1.23457E+09");
7542 assert(ios.width() == 0);
7543 }
7544 ios.width(25);
7545 left(ios);
7546 {
7547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7548 std::string ex(str, iter.base());
7549 assert(ex == "1.23457E+09**************");
7550 assert(ios.width() == 0);
7551 }
7552 ios.width(25);
7553 right(ios);
7554 {
7555 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7556 std::string ex(str, iter.base());
7557 assert(ex == "**************1.23457E+09");
7558 assert(ios.width() == 0);
7559 }
7560 ios.width(25);
7561 internal(ios);
7562 {
7563 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7564 std::string ex(str, iter.base());
7565 assert(ex == "**************1.23457E+09");
7566 assert(ios.width() == 0);
7567 }
7568 }
7569 ios.imbue(lg);
7570 {
7571 ios.width(0);
7572 {
7573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7574 std::string ex(str, iter.base());
7575 assert(ex == "1;23457E+09");
7576 assert(ios.width() == 0);
7577 }
7578 ios.width(25);
7579 left(ios);
7580 {
7581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7582 std::string ex(str, iter.base());
7583 assert(ex == "1;23457E+09**************");
7584 assert(ios.width() == 0);
7585 }
7586 ios.width(25);
7587 right(ios);
7588 {
7589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7590 std::string ex(str, iter.base());
7591 assert(ex == "**************1;23457E+09");
7592 assert(ios.width() == 0);
7593 }
7594 ios.width(25);
7595 internal(ios);
7596 {
7597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7598 std::string ex(str, iter.base());
7599 assert(ex == "**************1;23457E+09");
7600 assert(ios.width() == 0);
7601 }
7602 }
7603 }
7604 }
7605 showpos(ios);
7606 {
7607 noshowpoint(ios);
7608 {
7609 ios.imbue(lc);
7610 {
7611 ios.width(0);
7612 {
7613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7614 std::string ex(str, iter.base());
7615 assert(ex == "+1.23457E+09");
7616 assert(ios.width() == 0);
7617 }
7618 ios.width(25);
7619 left(ios);
7620 {
7621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7622 std::string ex(str, iter.base());
7623 assert(ex == "+1.23457E+09*************");
7624 assert(ios.width() == 0);
7625 }
7626 ios.width(25);
7627 right(ios);
7628 {
7629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7630 std::string ex(str, iter.base());
7631 assert(ex == "*************+1.23457E+09");
7632 assert(ios.width() == 0);
7633 }
7634 ios.width(25);
7635 internal(ios);
7636 {
7637 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7638 std::string ex(str, iter.base());
7639 assert(ex == "+*************1.23457E+09");
7640 assert(ios.width() == 0);
7641 }
7642 }
7643 ios.imbue(lg);
7644 {
7645 ios.width(0);
7646 {
7647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7648 std::string ex(str, iter.base());
7649 assert(ex == "+1;23457E+09");
7650 assert(ios.width() == 0);
7651 }
7652 ios.width(25);
7653 left(ios);
7654 {
7655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7656 std::string ex(str, iter.base());
7657 assert(ex == "+1;23457E+09*************");
7658 assert(ios.width() == 0);
7659 }
7660 ios.width(25);
7661 right(ios);
7662 {
7663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7664 std::string ex(str, iter.base());
7665 assert(ex == "*************+1;23457E+09");
7666 assert(ios.width() == 0);
7667 }
7668 ios.width(25);
7669 internal(ios);
7670 {
7671 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7672 std::string ex(str, iter.base());
7673 assert(ex == "+*************1;23457E+09");
7674 assert(ios.width() == 0);
7675 }
7676 }
7677 }
7678 showpoint(ios);
7679 {
7680 ios.imbue(lc);
7681 {
7682 ios.width(0);
7683 {
7684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7685 std::string ex(str, iter.base());
7686 assert(ex == "+1.23457E+09");
7687 assert(ios.width() == 0);
7688 }
7689 ios.width(25);
7690 left(ios);
7691 {
7692 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7693 std::string ex(str, iter.base());
7694 assert(ex == "+1.23457E+09*************");
7695 assert(ios.width() == 0);
7696 }
7697 ios.width(25);
7698 right(ios);
7699 {
7700 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7701 std::string ex(str, iter.base());
7702 assert(ex == "*************+1.23457E+09");
7703 assert(ios.width() == 0);
7704 }
7705 ios.width(25);
7706 internal(ios);
7707 {
7708 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7709 std::string ex(str, iter.base());
7710 assert(ex == "+*************1.23457E+09");
7711 assert(ios.width() == 0);
7712 }
7713 }
7714 ios.imbue(lg);
7715 {
7716 ios.width(0);
7717 {
7718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7719 std::string ex(str, iter.base());
7720 assert(ex == "+1;23457E+09");
7721 assert(ios.width() == 0);
7722 }
7723 ios.width(25);
7724 left(ios);
7725 {
7726 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7727 std::string ex(str, iter.base());
7728 assert(ex == "+1;23457E+09*************");
7729 assert(ios.width() == 0);
7730 }
7731 ios.width(25);
7732 right(ios);
7733 {
7734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7735 std::string ex(str, iter.base());
7736 assert(ex == "*************+1;23457E+09");
7737 assert(ios.width() == 0);
7738 }
7739 ios.width(25);
7740 internal(ios);
7741 {
7742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7743 std::string ex(str, iter.base());
7744 assert(ex == "+*************1;23457E+09");
7745 assert(ios.width() == 0);
7746 }
7747 }
7748 }
7749 }
7750 }
7751 }
7752 ios.precision(16);
7753 {
7754 nouppercase(ios);
7755 {
7756 noshowpos(ios);
7757 {
7758 noshowpoint(ios);
7759 {
7760 ios.imbue(lc);
7761 {
7762 ios.width(0);
7763 {
7764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7765 std::string ex(str, iter.base());
7766 assert(ex == "1234567890.125");
7767 assert(ios.width() == 0);
7768 }
7769 ios.width(25);
7770 left(ios);
7771 {
7772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7773 std::string ex(str, iter.base());
7774 assert(ex == "1234567890.125***********");
7775 assert(ios.width() == 0);
7776 }
7777 ios.width(25);
7778 right(ios);
7779 {
7780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7781 std::string ex(str, iter.base());
7782 assert(ex == "***********1234567890.125");
7783 assert(ios.width() == 0);
7784 }
7785 ios.width(25);
7786 internal(ios);
7787 {
7788 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7789 std::string ex(str, iter.base());
7790 assert(ex == "***********1234567890.125");
7791 assert(ios.width() == 0);
7792 }
7793 }
7794 ios.imbue(lg);
7795 {
7796 ios.width(0);
7797 {
7798 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7799 std::string ex(str, iter.base());
7800 assert(ex == "1_234_567_89_0;125");
7801 assert(ios.width() == 0);
7802 }
7803 ios.width(25);
7804 left(ios);
7805 {
7806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7807 std::string ex(str, iter.base());
7808 assert(ex == "1_234_567_89_0;125*******");
7809 assert(ios.width() == 0);
7810 }
7811 ios.width(25);
7812 right(ios);
7813 {
7814 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7815 std::string ex(str, iter.base());
7816 assert(ex == "*******1_234_567_89_0;125");
7817 assert(ios.width() == 0);
7818 }
7819 ios.width(25);
7820 internal(ios);
7821 {
7822 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7823 std::string ex(str, iter.base());
7824 assert(ex == "*******1_234_567_89_0;125");
7825 assert(ios.width() == 0);
7826 }
7827 }
7828 }
7829 showpoint(ios);
7830 {
7831 ios.imbue(lc);
7832 {
7833 ios.width(0);
7834 {
7835 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7836 std::string ex(str, iter.base());
7837 assert(ex == "1234567890.125000");
7838 assert(ios.width() == 0);
7839 }
7840 ios.width(25);
7841 left(ios);
7842 {
7843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7844 std::string ex(str, iter.base());
7845 assert(ex == "1234567890.125000********");
7846 assert(ios.width() == 0);
7847 }
7848 ios.width(25);
7849 right(ios);
7850 {
7851 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7852 std::string ex(str, iter.base());
7853 assert(ex == "********1234567890.125000");
7854 assert(ios.width() == 0);
7855 }
7856 ios.width(25);
7857 internal(ios);
7858 {
7859 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7860 std::string ex(str, iter.base());
7861 assert(ex == "********1234567890.125000");
7862 assert(ios.width() == 0);
7863 }
7864 }
7865 ios.imbue(lg);
7866 {
7867 ios.width(0);
7868 {
7869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7870 std::string ex(str, iter.base());
7871 assert(ex == "1_234_567_89_0;125000");
7872 assert(ios.width() == 0);
7873 }
7874 ios.width(25);
7875 left(ios);
7876 {
7877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7878 std::string ex(str, iter.base());
7879 assert(ex == "1_234_567_89_0;125000****");
7880 assert(ios.width() == 0);
7881 }
7882 ios.width(25);
7883 right(ios);
7884 {
7885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7886 std::string ex(str, iter.base());
7887 assert(ex == "****1_234_567_89_0;125000");
7888 assert(ios.width() == 0);
7889 }
7890 ios.width(25);
7891 internal(ios);
7892 {
7893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7894 std::string ex(str, iter.base());
7895 assert(ex == "****1_234_567_89_0;125000");
7896 assert(ios.width() == 0);
7897 }
7898 }
7899 }
7900 }
7901 showpos(ios);
7902 {
7903 noshowpoint(ios);
7904 {
7905 ios.imbue(lc);
7906 {
7907 ios.width(0);
7908 {
7909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7910 std::string ex(str, iter.base());
7911 assert(ex == "+1234567890.125");
7912 assert(ios.width() == 0);
7913 }
7914 ios.width(25);
7915 left(ios);
7916 {
7917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7918 std::string ex(str, iter.base());
7919 assert(ex == "+1234567890.125**********");
7920 assert(ios.width() == 0);
7921 }
7922 ios.width(25);
7923 right(ios);
7924 {
7925 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7926 std::string ex(str, iter.base());
7927 assert(ex == "**********+1234567890.125");
7928 assert(ios.width() == 0);
7929 }
7930 ios.width(25);
7931 internal(ios);
7932 {
7933 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7934 std::string ex(str, iter.base());
7935 assert(ex == "+**********1234567890.125");
7936 assert(ios.width() == 0);
7937 }
7938 }
7939 ios.imbue(lg);
7940 {
7941 ios.width(0);
7942 {
7943 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7944 std::string ex(str, iter.base());
7945 assert(ex == "+1_234_567_89_0;125");
7946 assert(ios.width() == 0);
7947 }
7948 ios.width(25);
7949 left(ios);
7950 {
7951 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7952 std::string ex(str, iter.base());
7953 assert(ex == "+1_234_567_89_0;125******");
7954 assert(ios.width() == 0);
7955 }
7956 ios.width(25);
7957 right(ios);
7958 {
7959 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7960 std::string ex(str, iter.base());
7961 assert(ex == "******+1_234_567_89_0;125");
7962 assert(ios.width() == 0);
7963 }
7964 ios.width(25);
7965 internal(ios);
7966 {
7967 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7968 std::string ex(str, iter.base());
7969 assert(ex == "+******1_234_567_89_0;125");
7970 assert(ios.width() == 0);
7971 }
7972 }
7973 }
7974 showpoint(ios);
7975 {
7976 ios.imbue(lc);
7977 {
7978 ios.width(0);
7979 {
7980 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7981 std::string ex(str, iter.base());
7982 assert(ex == "+1234567890.125000");
7983 assert(ios.width() == 0);
7984 }
7985 ios.width(25);
7986 left(ios);
7987 {
7988 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7989 std::string ex(str, iter.base());
7990 assert(ex == "+1234567890.125000*******");
7991 assert(ios.width() == 0);
7992 }
7993 ios.width(25);
7994 right(ios);
7995 {
7996 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7997 std::string ex(str, iter.base());
7998 assert(ex == "*******+1234567890.125000");
7999 assert(ios.width() == 0);
8000 }
8001 ios.width(25);
8002 internal(ios);
8003 {
8004 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8005 std::string ex(str, iter.base());
8006 assert(ex == "+*******1234567890.125000");
8007 assert(ios.width() == 0);
8008 }
8009 }
8010 ios.imbue(lg);
8011 {
8012 ios.width(0);
8013 {
8014 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8015 std::string ex(str, iter.base());
8016 assert(ex == "+1_234_567_89_0;125000");
8017 assert(ios.width() == 0);
8018 }
8019 ios.width(25);
8020 left(ios);
8021 {
8022 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8023 std::string ex(str, iter.base());
8024 assert(ex == "+1_234_567_89_0;125000***");
8025 assert(ios.width() == 0);
8026 }
8027 ios.width(25);
8028 right(ios);
8029 {
8030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8031 std::string ex(str, iter.base());
8032 assert(ex == "***+1_234_567_89_0;125000");
8033 assert(ios.width() == 0);
8034 }
8035 ios.width(25);
8036 internal(ios);
8037 {
8038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8039 std::string ex(str, iter.base());
8040 assert(ex == "+***1_234_567_89_0;125000");
8041 assert(ios.width() == 0);
8042 }
8043 }
8044 }
8045 }
8046 }
8047 uppercase(ios);
8048 {
8049 noshowpos(ios);
8050 {
8051 noshowpoint(ios);
8052 {
8053 ios.imbue(lc);
8054 {
8055 ios.width(0);
8056 {
8057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8058 std::string ex(str, iter.base());
8059 assert(ex == "1234567890.125");
8060 assert(ios.width() == 0);
8061 }
8062 ios.width(25);
8063 left(ios);
8064 {
8065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8066 std::string ex(str, iter.base());
8067 assert(ex == "1234567890.125***********");
8068 assert(ios.width() == 0);
8069 }
8070 ios.width(25);
8071 right(ios);
8072 {
8073 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8074 std::string ex(str, iter.base());
8075 assert(ex == "***********1234567890.125");
8076 assert(ios.width() == 0);
8077 }
8078 ios.width(25);
8079 internal(ios);
8080 {
8081 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8082 std::string ex(str, iter.base());
8083 assert(ex == "***********1234567890.125");
8084 assert(ios.width() == 0);
8085 }
8086 }
8087 ios.imbue(lg);
8088 {
8089 ios.width(0);
8090 {
8091 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8092 std::string ex(str, iter.base());
8093 assert(ex == "1_234_567_89_0;125");
8094 assert(ios.width() == 0);
8095 }
8096 ios.width(25);
8097 left(ios);
8098 {
8099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8100 std::string ex(str, iter.base());
8101 assert(ex == "1_234_567_89_0;125*******");
8102 assert(ios.width() == 0);
8103 }
8104 ios.width(25);
8105 right(ios);
8106 {
8107 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8108 std::string ex(str, iter.base());
8109 assert(ex == "*******1_234_567_89_0;125");
8110 assert(ios.width() == 0);
8111 }
8112 ios.width(25);
8113 internal(ios);
8114 {
8115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8116 std::string ex(str, iter.base());
8117 assert(ex == "*******1_234_567_89_0;125");
8118 assert(ios.width() == 0);
8119 }
8120 }
8121 }
8122 showpoint(ios);
8123 {
8124 ios.imbue(lc);
8125 {
8126 ios.width(0);
8127 {
8128 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8129 std::string ex(str, iter.base());
8130 assert(ex == "1234567890.125000");
8131 assert(ios.width() == 0);
8132 }
8133 ios.width(25);
8134 left(ios);
8135 {
8136 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8137 std::string ex(str, iter.base());
8138 assert(ex == "1234567890.125000********");
8139 assert(ios.width() == 0);
8140 }
8141 ios.width(25);
8142 right(ios);
8143 {
8144 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8145 std::string ex(str, iter.base());
8146 assert(ex == "********1234567890.125000");
8147 assert(ios.width() == 0);
8148 }
8149 ios.width(25);
8150 internal(ios);
8151 {
8152 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8153 std::string ex(str, iter.base());
8154 assert(ex == "********1234567890.125000");
8155 assert(ios.width() == 0);
8156 }
8157 }
8158 ios.imbue(lg);
8159 {
8160 ios.width(0);
8161 {
8162 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8163 std::string ex(str, iter.base());
8164 assert(ex == "1_234_567_89_0;125000");
8165 assert(ios.width() == 0);
8166 }
8167 ios.width(25);
8168 left(ios);
8169 {
8170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8171 std::string ex(str, iter.base());
8172 assert(ex == "1_234_567_89_0;125000****");
8173 assert(ios.width() == 0);
8174 }
8175 ios.width(25);
8176 right(ios);
8177 {
8178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8179 std::string ex(str, iter.base());
8180 assert(ex == "****1_234_567_89_0;125000");
8181 assert(ios.width() == 0);
8182 }
8183 ios.width(25);
8184 internal(ios);
8185 {
8186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8187 std::string ex(str, iter.base());
8188 assert(ex == "****1_234_567_89_0;125000");
8189 assert(ios.width() == 0);
8190 }
8191 }
8192 }
8193 }
8194 showpos(ios);
8195 {
8196 noshowpoint(ios);
8197 {
8198 ios.imbue(lc);
8199 {
8200 ios.width(0);
8201 {
8202 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8203 std::string ex(str, iter.base());
8204 assert(ex == "+1234567890.125");
8205 assert(ios.width() == 0);
8206 }
8207 ios.width(25);
8208 left(ios);
8209 {
8210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8211 std::string ex(str, iter.base());
8212 assert(ex == "+1234567890.125**********");
8213 assert(ios.width() == 0);
8214 }
8215 ios.width(25);
8216 right(ios);
8217 {
8218 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8219 std::string ex(str, iter.base());
8220 assert(ex == "**********+1234567890.125");
8221 assert(ios.width() == 0);
8222 }
8223 ios.width(25);
8224 internal(ios);
8225 {
8226 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8227 std::string ex(str, iter.base());
8228 assert(ex == "+**********1234567890.125");
8229 assert(ios.width() == 0);
8230 }
8231 }
8232 ios.imbue(lg);
8233 {
8234 ios.width(0);
8235 {
8236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8237 std::string ex(str, iter.base());
8238 assert(ex == "+1_234_567_89_0;125");
8239 assert(ios.width() == 0);
8240 }
8241 ios.width(25);
8242 left(ios);
8243 {
8244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8245 std::string ex(str, iter.base());
8246 assert(ex == "+1_234_567_89_0;125******");
8247 assert(ios.width() == 0);
8248 }
8249 ios.width(25);
8250 right(ios);
8251 {
8252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8253 std::string ex(str, iter.base());
8254 assert(ex == "******+1_234_567_89_0;125");
8255 assert(ios.width() == 0);
8256 }
8257 ios.width(25);
8258 internal(ios);
8259 {
8260 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8261 std::string ex(str, iter.base());
8262 assert(ex == "+******1_234_567_89_0;125");
8263 assert(ios.width() == 0);
8264 }
8265 }
8266 }
8267 showpoint(ios);
8268 {
8269 ios.imbue(lc);
8270 {
8271 ios.width(0);
8272 {
8273 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8274 std::string ex(str, iter.base());
8275 assert(ex == "+1234567890.125000");
8276 assert(ios.width() == 0);
8277 }
8278 ios.width(25);
8279 left(ios);
8280 {
8281 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8282 std::string ex(str, iter.base());
8283 assert(ex == "+1234567890.125000*******");
8284 assert(ios.width() == 0);
8285 }
8286 ios.width(25);
8287 right(ios);
8288 {
8289 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8290 std::string ex(str, iter.base());
8291 assert(ex == "*******+1234567890.125000");
8292 assert(ios.width() == 0);
8293 }
8294 ios.width(25);
8295 internal(ios);
8296 {
8297 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8298 std::string ex(str, iter.base());
8299 assert(ex == "+*******1234567890.125000");
8300 assert(ios.width() == 0);
8301 }
8302 }
8303 ios.imbue(lg);
8304 {
8305 ios.width(0);
8306 {
8307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8308 std::string ex(str, iter.base());
8309 assert(ex == "+1_234_567_89_0;125000");
8310 assert(ios.width() == 0);
8311 }
8312 ios.width(25);
8313 left(ios);
8314 {
8315 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8316 std::string ex(str, iter.base());
8317 assert(ex == "+1_234_567_89_0;125000***");
8318 assert(ios.width() == 0);
8319 }
8320 ios.width(25);
8321 right(ios);
8322 {
8323 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8324 std::string ex(str, iter.base());
8325 assert(ex == "***+1_234_567_89_0;125000");
8326 assert(ios.width() == 0);
8327 }
8328 ios.width(25);
8329 internal(ios);
8330 {
8331 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8332 std::string ex(str, iter.base());
8333 assert(ex == "+***1_234_567_89_0;125000");
8334 assert(ios.width() == 0);
8335 }
8336 }
8337 }
8338 }
8339 }
8340 }
8341 ios.precision(60);
8342 {
8343 nouppercase(ios);
8344 {
8345 noshowpos(ios);
8346 {
8347 noshowpoint(ios);
8348 {
8349 ios.imbue(lc);
8350 {
8351 ios.width(0);
8352 {
8353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8354 std::string ex(str, iter.base());
8355 assert(ex == "1234567890.125");
8356 assert(ios.width() == 0);
8357 }
8358 ios.width(25);
8359 left(ios);
8360 {
8361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8362 std::string ex(str, iter.base());
8363 assert(ex == "1234567890.125***********");
8364 assert(ios.width() == 0);
8365 }
8366 ios.width(25);
8367 right(ios);
8368 {
8369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8370 std::string ex(str, iter.base());
8371 assert(ex == "***********1234567890.125");
8372 assert(ios.width() == 0);
8373 }
8374 ios.width(25);
8375 internal(ios);
8376 {
8377 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8378 std::string ex(str, iter.base());
8379 assert(ex == "***********1234567890.125");
8380 assert(ios.width() == 0);
8381 }
8382 }
8383 ios.imbue(lg);
8384 {
8385 ios.width(0);
8386 {
8387 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8388 std::string ex(str, iter.base());
8389 assert(ex == "1_234_567_89_0;125");
8390 assert(ios.width() == 0);
8391 }
8392 ios.width(25);
8393 left(ios);
8394 {
8395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8396 std::string ex(str, iter.base());
8397 assert(ex == "1_234_567_89_0;125*******");
8398 assert(ios.width() == 0);
8399 }
8400 ios.width(25);
8401 right(ios);
8402 {
8403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8404 std::string ex(str, iter.base());
8405 assert(ex == "*******1_234_567_89_0;125");
8406 assert(ios.width() == 0);
8407 }
8408 ios.width(25);
8409 internal(ios);
8410 {
8411 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8412 std::string ex(str, iter.base());
8413 assert(ex == "*******1_234_567_89_0;125");
8414 assert(ios.width() == 0);
8415 }
8416 }
8417 }
8418 showpoint(ios);
8419 {
8420 ios.imbue(lc);
8421 {
8422 ios.width(0);
8423 {
8424 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8425 std::string ex(str, iter.base());
8426 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8427 assert(ios.width() == 0);
8428 }
8429 ios.width(25);
8430 left(ios);
8431 {
8432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8433 std::string ex(str, iter.base());
8434 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8435 assert(ios.width() == 0);
8436 }
8437 ios.width(25);
8438 right(ios);
8439 {
8440 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8441 std::string ex(str, iter.base());
8442 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8443 assert(ios.width() == 0);
8444 }
8445 ios.width(25);
8446 internal(ios);
8447 {
8448 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8449 std::string ex(str, iter.base());
8450 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8451 assert(ios.width() == 0);
8452 }
8453 }
8454 ios.imbue(lg);
8455 {
8456 ios.width(0);
8457 {
8458 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8459 std::string ex(str, iter.base());
8460 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8461 assert(ios.width() == 0);
8462 }
8463 ios.width(25);
8464 left(ios);
8465 {
8466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8467 std::string ex(str, iter.base());
8468 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8469 assert(ios.width() == 0);
8470 }
8471 ios.width(25);
8472 right(ios);
8473 {
8474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8475 std::string ex(str, iter.base());
8476 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8477 assert(ios.width() == 0);
8478 }
8479 ios.width(25);
8480 internal(ios);
8481 {
8482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8483 std::string ex(str, iter.base());
8484 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8485 assert(ios.width() == 0);
8486 }
8487 }
8488 }
8489 }
8490 showpos(ios);
8491 {
8492 noshowpoint(ios);
8493 {
8494 ios.imbue(lc);
8495 {
8496 ios.width(0);
8497 {
8498 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8499 std::string ex(str, iter.base());
8500 assert(ex == "+1234567890.125");
8501 assert(ios.width() == 0);
8502 }
8503 ios.width(25);
8504 left(ios);
8505 {
8506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8507 std::string ex(str, iter.base());
8508 assert(ex == "+1234567890.125**********");
8509 assert(ios.width() == 0);
8510 }
8511 ios.width(25);
8512 right(ios);
8513 {
8514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8515 std::string ex(str, iter.base());
8516 assert(ex == "**********+1234567890.125");
8517 assert(ios.width() == 0);
8518 }
8519 ios.width(25);
8520 internal(ios);
8521 {
8522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8523 std::string ex(str, iter.base());
8524 assert(ex == "+**********1234567890.125");
8525 assert(ios.width() == 0);
8526 }
8527 }
8528 ios.imbue(lg);
8529 {
8530 ios.width(0);
8531 {
8532 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8533 std::string ex(str, iter.base());
8534 assert(ex == "+1_234_567_89_0;125");
8535 assert(ios.width() == 0);
8536 }
8537 ios.width(25);
8538 left(ios);
8539 {
8540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8541 std::string ex(str, iter.base());
8542 assert(ex == "+1_234_567_89_0;125******");
8543 assert(ios.width() == 0);
8544 }
8545 ios.width(25);
8546 right(ios);
8547 {
8548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8549 std::string ex(str, iter.base());
8550 assert(ex == "******+1_234_567_89_0;125");
8551 assert(ios.width() == 0);
8552 }
8553 ios.width(25);
8554 internal(ios);
8555 {
8556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8557 std::string ex(str, iter.base());
8558 assert(ex == "+******1_234_567_89_0;125");
8559 assert(ios.width() == 0);
8560 }
8561 }
8562 }
8563 showpoint(ios);
8564 {
8565 ios.imbue(lc);
8566 {
8567 ios.width(0);
8568 {
8569 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8570 std::string ex(str, iter.base());
8571 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8572 assert(ios.width() == 0);
8573 }
8574 ios.width(25);
8575 left(ios);
8576 {
8577 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8578 std::string ex(str, iter.base());
8579 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8580 assert(ios.width() == 0);
8581 }
8582 ios.width(25);
8583 right(ios);
8584 {
8585 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8586 std::string ex(str, iter.base());
8587 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8588 assert(ios.width() == 0);
8589 }
8590 ios.width(25);
8591 internal(ios);
8592 {
8593 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8594 std::string ex(str, iter.base());
8595 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8596 assert(ios.width() == 0);
8597 }
8598 }
8599 ios.imbue(lg);
8600 {
8601 ios.width(0);
8602 {
8603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8604 std::string ex(str, iter.base());
8605 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8606 assert(ios.width() == 0);
8607 }
8608 ios.width(25);
8609 left(ios);
8610 {
8611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8612 std::string ex(str, iter.base());
8613 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8614 assert(ios.width() == 0);
8615 }
8616 ios.width(25);
8617 right(ios);
8618 {
8619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8620 std::string ex(str, iter.base());
8621 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8622 assert(ios.width() == 0);
8623 }
8624 ios.width(25);
8625 internal(ios);
8626 {
8627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8628 std::string ex(str, iter.base());
8629 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8630 assert(ios.width() == 0);
8631 }
8632 }
8633 }
8634 }
8635 }
8636 uppercase(ios);
8637 {
8638 noshowpos(ios);
8639 {
8640 noshowpoint(ios);
8641 {
8642 ios.imbue(lc);
8643 {
8644 ios.width(0);
8645 {
8646 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8647 std::string ex(str, iter.base());
8648 assert(ex == "1234567890.125");
8649 assert(ios.width() == 0);
8650 }
8651 ios.width(25);
8652 left(ios);
8653 {
8654 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8655 std::string ex(str, iter.base());
8656 assert(ex == "1234567890.125***********");
8657 assert(ios.width() == 0);
8658 }
8659 ios.width(25);
8660 right(ios);
8661 {
8662 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8663 std::string ex(str, iter.base());
8664 assert(ex == "***********1234567890.125");
8665 assert(ios.width() == 0);
8666 }
8667 ios.width(25);
8668 internal(ios);
8669 {
8670 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8671 std::string ex(str, iter.base());
8672 assert(ex == "***********1234567890.125");
8673 assert(ios.width() == 0);
8674 }
8675 }
8676 ios.imbue(lg);
8677 {
8678 ios.width(0);
8679 {
8680 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8681 std::string ex(str, iter.base());
8682 assert(ex == "1_234_567_89_0;125");
8683 assert(ios.width() == 0);
8684 }
8685 ios.width(25);
8686 left(ios);
8687 {
8688 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8689 std::string ex(str, iter.base());
8690 assert(ex == "1_234_567_89_0;125*******");
8691 assert(ios.width() == 0);
8692 }
8693 ios.width(25);
8694 right(ios);
8695 {
8696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8697 std::string ex(str, iter.base());
8698 assert(ex == "*******1_234_567_89_0;125");
8699 assert(ios.width() == 0);
8700 }
8701 ios.width(25);
8702 internal(ios);
8703 {
8704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8705 std::string ex(str, iter.base());
8706 assert(ex == "*******1_234_567_89_0;125");
8707 assert(ios.width() == 0);
8708 }
8709 }
8710 }
8711 showpoint(ios);
8712 {
8713 ios.imbue(lc);
8714 {
8715 ios.width(0);
8716 {
8717 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8718 std::string ex(str, iter.base());
8719 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8720 assert(ios.width() == 0);
8721 }
8722 ios.width(25);
8723 left(ios);
8724 {
8725 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8726 std::string ex(str, iter.base());
8727 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8728 assert(ios.width() == 0);
8729 }
8730 ios.width(25);
8731 right(ios);
8732 {
8733 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8734 std::string ex(str, iter.base());
8735 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8736 assert(ios.width() == 0);
8737 }
8738 ios.width(25);
8739 internal(ios);
8740 {
8741 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8742 std::string ex(str, iter.base());
8743 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8744 assert(ios.width() == 0);
8745 }
8746 }
8747 ios.imbue(lg);
8748 {
8749 ios.width(0);
8750 {
8751 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8752 std::string ex(str, iter.base());
8753 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8754 assert(ios.width() == 0);
8755 }
8756 ios.width(25);
8757 left(ios);
8758 {
8759 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8760 std::string ex(str, iter.base());
8761 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8762 assert(ios.width() == 0);
8763 }
8764 ios.width(25);
8765 right(ios);
8766 {
8767 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8768 std::string ex(str, iter.base());
8769 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8770 assert(ios.width() == 0);
8771 }
8772 ios.width(25);
8773 internal(ios);
8774 {
8775 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8776 std::string ex(str, iter.base());
8777 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8778 assert(ios.width() == 0);
8779 }
8780 }
8781 }
8782 }
8783 showpos(ios);
8784 {
8785 noshowpoint(ios);
8786 {
8787 ios.imbue(lc);
8788 {
8789 ios.width(0);
8790 {
8791 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8792 std::string ex(str, iter.base());
8793 assert(ex == "+1234567890.125");
8794 assert(ios.width() == 0);
8795 }
8796 ios.width(25);
8797 left(ios);
8798 {
8799 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8800 std::string ex(str, iter.base());
8801 assert(ex == "+1234567890.125**********");
8802 assert(ios.width() == 0);
8803 }
8804 ios.width(25);
8805 right(ios);
8806 {
8807 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8808 std::string ex(str, iter.base());
8809 assert(ex == "**********+1234567890.125");
8810 assert(ios.width() == 0);
8811 }
8812 ios.width(25);
8813 internal(ios);
8814 {
8815 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8816 std::string ex(str, iter.base());
8817 assert(ex == "+**********1234567890.125");
8818 assert(ios.width() == 0);
8819 }
8820 }
8821 ios.imbue(lg);
8822 {
8823 ios.width(0);
8824 {
8825 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8826 std::string ex(str, iter.base());
8827 assert(ex == "+1_234_567_89_0;125");
8828 assert(ios.width() == 0);
8829 }
8830 ios.width(25);
8831 left(ios);
8832 {
8833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8834 std::string ex(str, iter.base());
8835 assert(ex == "+1_234_567_89_0;125******");
8836 assert(ios.width() == 0);
8837 }
8838 ios.width(25);
8839 right(ios);
8840 {
8841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8842 std::string ex(str, iter.base());
8843 assert(ex == "******+1_234_567_89_0;125");
8844 assert(ios.width() == 0);
8845 }
8846 ios.width(25);
8847 internal(ios);
8848 {
8849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8850 std::string ex(str, iter.base());
8851 assert(ex == "+******1_234_567_89_0;125");
8852 assert(ios.width() == 0);
8853 }
8854 }
8855 }
8856 showpoint(ios);
8857 {
8858 ios.imbue(lc);
8859 {
8860 ios.width(0);
8861 {
8862 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8863 std::string ex(str, iter.base());
8864 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8865 assert(ios.width() == 0);
8866 }
8867 ios.width(25);
8868 left(ios);
8869 {
8870 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8871 std::string ex(str, iter.base());
8872 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8873 assert(ios.width() == 0);
8874 }
8875 ios.width(25);
8876 right(ios);
8877 {
8878 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8879 std::string ex(str, iter.base());
8880 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8881 assert(ios.width() == 0);
8882 }
8883 ios.width(25);
8884 internal(ios);
8885 {
8886 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8887 std::string ex(str, iter.base());
8888 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8889 assert(ios.width() == 0);
8890 }
8891 }
8892 ios.imbue(lg);
8893 {
8894 ios.width(0);
8895 {
8896 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8897 std::string ex(str, iter.base());
8898 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8899 assert(ios.width() == 0);
8900 }
8901 ios.width(25);
8902 left(ios);
8903 {
8904 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8905 std::string ex(str, iter.base());
8906 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8907 assert(ios.width() == 0);
8908 }
8909 ios.width(25);
8910 right(ios);
8911 {
8912 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8913 std::string ex(str, iter.base());
8914 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8915 assert(ios.width() == 0);
8916 }
8917 ios.width(25);
8918 internal(ios);
8919 {
8920 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8921 std::string ex(str, iter.base());
8922 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8923 assert(ios.width() == 0);
8924 }
8925 }
8926 }
8927 }
8928 }
8929 }
8930 }
8931 }
8932 }
8933
test4()8934 void test4()
8935 {
8936 char str[200];
8937 output_iterator<char*> iter;
8938 std::locale lc = std::locale::classic();
8939 std::locale lg(lc, new my_numpunct);
8940 const my_facet f(1);
8941 {
8942 long double v = -INFINITY;
8943 std::ios ios(0);
8944 // %g
8945 {
8946 ios.precision(0);
8947 {
8948 nouppercase(ios);
8949 {
8950 noshowpos(ios);
8951 {
8952 noshowpoint(ios);
8953 {
8954 ios.imbue(lc);
8955 {
8956 ios.width(0);
8957 {
8958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8959 std::string ex(str, iter.base());
8960 assert(ex == "-inf");
8961 assert(ios.width() == 0);
8962 }
8963 ios.width(25);
8964 left(ios);
8965 {
8966 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8967 std::string ex(str, iter.base());
8968 assert(ex == "-inf*********************");
8969 assert(ios.width() == 0);
8970 }
8971 ios.width(25);
8972 right(ios);
8973 {
8974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8975 std::string ex(str, iter.base());
8976 assert(ex == "*********************-inf");
8977 assert(ios.width() == 0);
8978 }
8979 ios.width(25);
8980 internal(ios);
8981 {
8982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8983 std::string ex(str, iter.base());
8984 assert(ex == "-*********************inf");
8985 assert(ios.width() == 0);
8986 }
8987 }
8988 ios.imbue(lg);
8989 {
8990 ios.width(0);
8991 {
8992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8993 std::string ex(str, iter.base());
8994 assert(ex == "-inf");
8995 assert(ios.width() == 0);
8996 }
8997 ios.width(25);
8998 left(ios);
8999 {
9000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9001 std::string ex(str, iter.base());
9002 assert(ex == "-inf*********************");
9003 assert(ios.width() == 0);
9004 }
9005 ios.width(25);
9006 right(ios);
9007 {
9008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9009 std::string ex(str, iter.base());
9010 assert(ex == "*********************-inf");
9011 assert(ios.width() == 0);
9012 }
9013 ios.width(25);
9014 internal(ios);
9015 {
9016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9017 std::string ex(str, iter.base());
9018 assert(ex == "-*********************inf");
9019 assert(ios.width() == 0);
9020 }
9021 }
9022 }
9023 showpoint(ios);
9024 {
9025 ios.imbue(lc);
9026 {
9027 ios.width(0);
9028 {
9029 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9030 std::string ex(str, iter.base());
9031 assert(ex == "-inf");
9032 assert(ios.width() == 0);
9033 }
9034 ios.width(25);
9035 left(ios);
9036 {
9037 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9038 std::string ex(str, iter.base());
9039 assert(ex == "-inf*********************");
9040 assert(ios.width() == 0);
9041 }
9042 ios.width(25);
9043 right(ios);
9044 {
9045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9046 std::string ex(str, iter.base());
9047 assert(ex == "*********************-inf");
9048 assert(ios.width() == 0);
9049 }
9050 ios.width(25);
9051 internal(ios);
9052 {
9053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9054 std::string ex(str, iter.base());
9055 assert(ex == "-*********************inf");
9056 assert(ios.width() == 0);
9057 }
9058 }
9059 ios.imbue(lg);
9060 {
9061 ios.width(0);
9062 {
9063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9064 std::string ex(str, iter.base());
9065 assert(ex == "-inf");
9066 assert(ios.width() == 0);
9067 }
9068 ios.width(25);
9069 left(ios);
9070 {
9071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9072 std::string ex(str, iter.base());
9073 assert(ex == "-inf*********************");
9074 assert(ios.width() == 0);
9075 }
9076 ios.width(25);
9077 right(ios);
9078 {
9079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9080 std::string ex(str, iter.base());
9081 assert(ex == "*********************-inf");
9082 assert(ios.width() == 0);
9083 }
9084 ios.width(25);
9085 internal(ios);
9086 {
9087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9088 std::string ex(str, iter.base());
9089 assert(ex == "-*********************inf");
9090 assert(ios.width() == 0);
9091 }
9092 }
9093 }
9094 }
9095 showpos(ios);
9096 {
9097 noshowpoint(ios);
9098 {
9099 ios.imbue(lc);
9100 {
9101 ios.width(0);
9102 {
9103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9104 std::string ex(str, iter.base());
9105 assert(ex == "-inf");
9106 assert(ios.width() == 0);
9107 }
9108 ios.width(25);
9109 left(ios);
9110 {
9111 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9112 std::string ex(str, iter.base());
9113 assert(ex == "-inf*********************");
9114 assert(ios.width() == 0);
9115 }
9116 ios.width(25);
9117 right(ios);
9118 {
9119 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9120 std::string ex(str, iter.base());
9121 assert(ex == "*********************-inf");
9122 assert(ios.width() == 0);
9123 }
9124 ios.width(25);
9125 internal(ios);
9126 {
9127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9128 std::string ex(str, iter.base());
9129 assert(ex == "-*********************inf");
9130 assert(ios.width() == 0);
9131 }
9132 }
9133 ios.imbue(lg);
9134 {
9135 ios.width(0);
9136 {
9137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9138 std::string ex(str, iter.base());
9139 assert(ex == "-inf");
9140 assert(ios.width() == 0);
9141 }
9142 ios.width(25);
9143 left(ios);
9144 {
9145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9146 std::string ex(str, iter.base());
9147 assert(ex == "-inf*********************");
9148 assert(ios.width() == 0);
9149 }
9150 ios.width(25);
9151 right(ios);
9152 {
9153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9154 std::string ex(str, iter.base());
9155 assert(ex == "*********************-inf");
9156 assert(ios.width() == 0);
9157 }
9158 ios.width(25);
9159 internal(ios);
9160 {
9161 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9162 std::string ex(str, iter.base());
9163 assert(ex == "-*********************inf");
9164 assert(ios.width() == 0);
9165 }
9166 }
9167 }
9168 showpoint(ios);
9169 {
9170 ios.imbue(lc);
9171 {
9172 ios.width(0);
9173 {
9174 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9175 std::string ex(str, iter.base());
9176 assert(ex == "-inf");
9177 assert(ios.width() == 0);
9178 }
9179 ios.width(25);
9180 left(ios);
9181 {
9182 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9183 std::string ex(str, iter.base());
9184 assert(ex == "-inf*********************");
9185 assert(ios.width() == 0);
9186 }
9187 ios.width(25);
9188 right(ios);
9189 {
9190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9191 std::string ex(str, iter.base());
9192 assert(ex == "*********************-inf");
9193 assert(ios.width() == 0);
9194 }
9195 ios.width(25);
9196 internal(ios);
9197 {
9198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9199 std::string ex(str, iter.base());
9200 assert(ex == "-*********************inf");
9201 assert(ios.width() == 0);
9202 }
9203 }
9204 ios.imbue(lg);
9205 {
9206 ios.width(0);
9207 {
9208 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9209 std::string ex(str, iter.base());
9210 assert(ex == "-inf");
9211 assert(ios.width() == 0);
9212 }
9213 ios.width(25);
9214 left(ios);
9215 {
9216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9217 std::string ex(str, iter.base());
9218 assert(ex == "-inf*********************");
9219 assert(ios.width() == 0);
9220 }
9221 ios.width(25);
9222 right(ios);
9223 {
9224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9225 std::string ex(str, iter.base());
9226 assert(ex == "*********************-inf");
9227 assert(ios.width() == 0);
9228 }
9229 ios.width(25);
9230 internal(ios);
9231 {
9232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9233 std::string ex(str, iter.base());
9234 assert(ex == "-*********************inf");
9235 assert(ios.width() == 0);
9236 }
9237 }
9238 }
9239 }
9240 }
9241 uppercase(ios);
9242 {
9243 noshowpos(ios);
9244 {
9245 noshowpoint(ios);
9246 {
9247 ios.imbue(lc);
9248 {
9249 ios.width(0);
9250 {
9251 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9252 std::string ex(str, iter.base());
9253 assert(ex == "-INF");
9254 assert(ios.width() == 0);
9255 }
9256 ios.width(25);
9257 left(ios);
9258 {
9259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9260 std::string ex(str, iter.base());
9261 assert(ex == "-INF*********************");
9262 assert(ios.width() == 0);
9263 }
9264 ios.width(25);
9265 right(ios);
9266 {
9267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9268 std::string ex(str, iter.base());
9269 assert(ex == "*********************-INF");
9270 assert(ios.width() == 0);
9271 }
9272 ios.width(25);
9273 internal(ios);
9274 {
9275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9276 std::string ex(str, iter.base());
9277 assert(ex == "-*********************INF");
9278 assert(ios.width() == 0);
9279 }
9280 }
9281 ios.imbue(lg);
9282 {
9283 ios.width(0);
9284 {
9285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9286 std::string ex(str, iter.base());
9287 assert(ex == "-INF");
9288 assert(ios.width() == 0);
9289 }
9290 ios.width(25);
9291 left(ios);
9292 {
9293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9294 std::string ex(str, iter.base());
9295 assert(ex == "-INF*********************");
9296 assert(ios.width() == 0);
9297 }
9298 ios.width(25);
9299 right(ios);
9300 {
9301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9302 std::string ex(str, iter.base());
9303 assert(ex == "*********************-INF");
9304 assert(ios.width() == 0);
9305 }
9306 ios.width(25);
9307 internal(ios);
9308 {
9309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9310 std::string ex(str, iter.base());
9311 assert(ex == "-*********************INF");
9312 assert(ios.width() == 0);
9313 }
9314 }
9315 }
9316 showpoint(ios);
9317 {
9318 ios.imbue(lc);
9319 {
9320 ios.width(0);
9321 {
9322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9323 std::string ex(str, iter.base());
9324 assert(ex == "-INF");
9325 assert(ios.width() == 0);
9326 }
9327 ios.width(25);
9328 left(ios);
9329 {
9330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9331 std::string ex(str, iter.base());
9332 assert(ex == "-INF*********************");
9333 assert(ios.width() == 0);
9334 }
9335 ios.width(25);
9336 right(ios);
9337 {
9338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9339 std::string ex(str, iter.base());
9340 assert(ex == "*********************-INF");
9341 assert(ios.width() == 0);
9342 }
9343 ios.width(25);
9344 internal(ios);
9345 {
9346 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9347 std::string ex(str, iter.base());
9348 assert(ex == "-*********************INF");
9349 assert(ios.width() == 0);
9350 }
9351 }
9352 ios.imbue(lg);
9353 {
9354 ios.width(0);
9355 {
9356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9357 std::string ex(str, iter.base());
9358 assert(ex == "-INF");
9359 assert(ios.width() == 0);
9360 }
9361 ios.width(25);
9362 left(ios);
9363 {
9364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9365 std::string ex(str, iter.base());
9366 assert(ex == "-INF*********************");
9367 assert(ios.width() == 0);
9368 }
9369 ios.width(25);
9370 right(ios);
9371 {
9372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9373 std::string ex(str, iter.base());
9374 assert(ex == "*********************-INF");
9375 assert(ios.width() == 0);
9376 }
9377 ios.width(25);
9378 internal(ios);
9379 {
9380 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9381 std::string ex(str, iter.base());
9382 assert(ex == "-*********************INF");
9383 assert(ios.width() == 0);
9384 }
9385 }
9386 }
9387 }
9388 showpos(ios);
9389 {
9390 noshowpoint(ios);
9391 {
9392 ios.imbue(lc);
9393 {
9394 ios.width(0);
9395 {
9396 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9397 std::string ex(str, iter.base());
9398 assert(ex == "-INF");
9399 assert(ios.width() == 0);
9400 }
9401 ios.width(25);
9402 left(ios);
9403 {
9404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9405 std::string ex(str, iter.base());
9406 assert(ex == "-INF*********************");
9407 assert(ios.width() == 0);
9408 }
9409 ios.width(25);
9410 right(ios);
9411 {
9412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9413 std::string ex(str, iter.base());
9414 assert(ex == "*********************-INF");
9415 assert(ios.width() == 0);
9416 }
9417 ios.width(25);
9418 internal(ios);
9419 {
9420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9421 std::string ex(str, iter.base());
9422 assert(ex == "-*********************INF");
9423 assert(ios.width() == 0);
9424 }
9425 }
9426 ios.imbue(lg);
9427 {
9428 ios.width(0);
9429 {
9430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9431 std::string ex(str, iter.base());
9432 assert(ex == "-INF");
9433 assert(ios.width() == 0);
9434 }
9435 ios.width(25);
9436 left(ios);
9437 {
9438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9439 std::string ex(str, iter.base());
9440 assert(ex == "-INF*********************");
9441 assert(ios.width() == 0);
9442 }
9443 ios.width(25);
9444 right(ios);
9445 {
9446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9447 std::string ex(str, iter.base());
9448 assert(ex == "*********************-INF");
9449 assert(ios.width() == 0);
9450 }
9451 ios.width(25);
9452 internal(ios);
9453 {
9454 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9455 std::string ex(str, iter.base());
9456 assert(ex == "-*********************INF");
9457 assert(ios.width() == 0);
9458 }
9459 }
9460 }
9461 showpoint(ios);
9462 {
9463 ios.imbue(lc);
9464 {
9465 ios.width(0);
9466 {
9467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9468 std::string ex(str, iter.base());
9469 assert(ex == "-INF");
9470 assert(ios.width() == 0);
9471 }
9472 ios.width(25);
9473 left(ios);
9474 {
9475 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9476 std::string ex(str, iter.base());
9477 assert(ex == "-INF*********************");
9478 assert(ios.width() == 0);
9479 }
9480 ios.width(25);
9481 right(ios);
9482 {
9483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9484 std::string ex(str, iter.base());
9485 assert(ex == "*********************-INF");
9486 assert(ios.width() == 0);
9487 }
9488 ios.width(25);
9489 internal(ios);
9490 {
9491 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9492 std::string ex(str, iter.base());
9493 assert(ex == "-*********************INF");
9494 assert(ios.width() == 0);
9495 }
9496 }
9497 ios.imbue(lg);
9498 {
9499 ios.width(0);
9500 {
9501 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9502 std::string ex(str, iter.base());
9503 assert(ex == "-INF");
9504 assert(ios.width() == 0);
9505 }
9506 ios.width(25);
9507 left(ios);
9508 {
9509 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9510 std::string ex(str, iter.base());
9511 assert(ex == "-INF*********************");
9512 assert(ios.width() == 0);
9513 }
9514 ios.width(25);
9515 right(ios);
9516 {
9517 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9518 std::string ex(str, iter.base());
9519 assert(ex == "*********************-INF");
9520 assert(ios.width() == 0);
9521 }
9522 ios.width(25);
9523 internal(ios);
9524 {
9525 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9526 std::string ex(str, iter.base());
9527 assert(ex == "-*********************INF");
9528 assert(ios.width() == 0);
9529 }
9530 }
9531 }
9532 }
9533 }
9534 }
9535 ios.precision(1);
9536 {
9537 nouppercase(ios);
9538 {
9539 noshowpos(ios);
9540 {
9541 noshowpoint(ios);
9542 {
9543 ios.imbue(lc);
9544 {
9545 ios.width(0);
9546 {
9547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9548 std::string ex(str, iter.base());
9549 assert(ex == "-inf");
9550 assert(ios.width() == 0);
9551 }
9552 ios.width(25);
9553 left(ios);
9554 {
9555 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9556 std::string ex(str, iter.base());
9557 assert(ex == "-inf*********************");
9558 assert(ios.width() == 0);
9559 }
9560 ios.width(25);
9561 right(ios);
9562 {
9563 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9564 std::string ex(str, iter.base());
9565 assert(ex == "*********************-inf");
9566 assert(ios.width() == 0);
9567 }
9568 ios.width(25);
9569 internal(ios);
9570 {
9571 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9572 std::string ex(str, iter.base());
9573 assert(ex == "-*********************inf");
9574 assert(ios.width() == 0);
9575 }
9576 }
9577 ios.imbue(lg);
9578 {
9579 ios.width(0);
9580 {
9581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9582 std::string ex(str, iter.base());
9583 assert(ex == "-inf");
9584 assert(ios.width() == 0);
9585 }
9586 ios.width(25);
9587 left(ios);
9588 {
9589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9590 std::string ex(str, iter.base());
9591 assert(ex == "-inf*********************");
9592 assert(ios.width() == 0);
9593 }
9594 ios.width(25);
9595 right(ios);
9596 {
9597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9598 std::string ex(str, iter.base());
9599 assert(ex == "*********************-inf");
9600 assert(ios.width() == 0);
9601 }
9602 ios.width(25);
9603 internal(ios);
9604 {
9605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9606 std::string ex(str, iter.base());
9607 assert(ex == "-*********************inf");
9608 assert(ios.width() == 0);
9609 }
9610 }
9611 }
9612 showpoint(ios);
9613 {
9614 ios.imbue(lc);
9615 {
9616 ios.width(0);
9617 {
9618 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9619 std::string ex(str, iter.base());
9620 assert(ex == "-inf");
9621 assert(ios.width() == 0);
9622 }
9623 ios.width(25);
9624 left(ios);
9625 {
9626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9627 std::string ex(str, iter.base());
9628 assert(ex == "-inf*********************");
9629 assert(ios.width() == 0);
9630 }
9631 ios.width(25);
9632 right(ios);
9633 {
9634 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9635 std::string ex(str, iter.base());
9636 assert(ex == "*********************-inf");
9637 assert(ios.width() == 0);
9638 }
9639 ios.width(25);
9640 internal(ios);
9641 {
9642 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9643 std::string ex(str, iter.base());
9644 assert(ex == "-*********************inf");
9645 assert(ios.width() == 0);
9646 }
9647 }
9648 ios.imbue(lg);
9649 {
9650 ios.width(0);
9651 {
9652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9653 std::string ex(str, iter.base());
9654 assert(ex == "-inf");
9655 assert(ios.width() == 0);
9656 }
9657 ios.width(25);
9658 left(ios);
9659 {
9660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9661 std::string ex(str, iter.base());
9662 assert(ex == "-inf*********************");
9663 assert(ios.width() == 0);
9664 }
9665 ios.width(25);
9666 right(ios);
9667 {
9668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9669 std::string ex(str, iter.base());
9670 assert(ex == "*********************-inf");
9671 assert(ios.width() == 0);
9672 }
9673 ios.width(25);
9674 internal(ios);
9675 {
9676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9677 std::string ex(str, iter.base());
9678 assert(ex == "-*********************inf");
9679 assert(ios.width() == 0);
9680 }
9681 }
9682 }
9683 }
9684 showpos(ios);
9685 {
9686 noshowpoint(ios);
9687 {
9688 ios.imbue(lc);
9689 {
9690 ios.width(0);
9691 {
9692 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9693 std::string ex(str, iter.base());
9694 assert(ex == "-inf");
9695 assert(ios.width() == 0);
9696 }
9697 ios.width(25);
9698 left(ios);
9699 {
9700 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9701 std::string ex(str, iter.base());
9702 assert(ex == "-inf*********************");
9703 assert(ios.width() == 0);
9704 }
9705 ios.width(25);
9706 right(ios);
9707 {
9708 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9709 std::string ex(str, iter.base());
9710 assert(ex == "*********************-inf");
9711 assert(ios.width() == 0);
9712 }
9713 ios.width(25);
9714 internal(ios);
9715 {
9716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9717 std::string ex(str, iter.base());
9718 assert(ex == "-*********************inf");
9719 assert(ios.width() == 0);
9720 }
9721 }
9722 ios.imbue(lg);
9723 {
9724 ios.width(0);
9725 {
9726 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9727 std::string ex(str, iter.base());
9728 assert(ex == "-inf");
9729 assert(ios.width() == 0);
9730 }
9731 ios.width(25);
9732 left(ios);
9733 {
9734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9735 std::string ex(str, iter.base());
9736 assert(ex == "-inf*********************");
9737 assert(ios.width() == 0);
9738 }
9739 ios.width(25);
9740 right(ios);
9741 {
9742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9743 std::string ex(str, iter.base());
9744 assert(ex == "*********************-inf");
9745 assert(ios.width() == 0);
9746 }
9747 ios.width(25);
9748 internal(ios);
9749 {
9750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9751 std::string ex(str, iter.base());
9752 assert(ex == "-*********************inf");
9753 assert(ios.width() == 0);
9754 }
9755 }
9756 }
9757 showpoint(ios);
9758 {
9759 ios.imbue(lc);
9760 {
9761 ios.width(0);
9762 {
9763 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9764 std::string ex(str, iter.base());
9765 assert(ex == "-inf");
9766 assert(ios.width() == 0);
9767 }
9768 ios.width(25);
9769 left(ios);
9770 {
9771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9772 std::string ex(str, iter.base());
9773 assert(ex == "-inf*********************");
9774 assert(ios.width() == 0);
9775 }
9776 ios.width(25);
9777 right(ios);
9778 {
9779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9780 std::string ex(str, iter.base());
9781 assert(ex == "*********************-inf");
9782 assert(ios.width() == 0);
9783 }
9784 ios.width(25);
9785 internal(ios);
9786 {
9787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9788 std::string ex(str, iter.base());
9789 assert(ex == "-*********************inf");
9790 assert(ios.width() == 0);
9791 }
9792 }
9793 ios.imbue(lg);
9794 {
9795 ios.width(0);
9796 {
9797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9798 std::string ex(str, iter.base());
9799 assert(ex == "-inf");
9800 assert(ios.width() == 0);
9801 }
9802 ios.width(25);
9803 left(ios);
9804 {
9805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9806 std::string ex(str, iter.base());
9807 assert(ex == "-inf*********************");
9808 assert(ios.width() == 0);
9809 }
9810 ios.width(25);
9811 right(ios);
9812 {
9813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9814 std::string ex(str, iter.base());
9815 assert(ex == "*********************-inf");
9816 assert(ios.width() == 0);
9817 }
9818 ios.width(25);
9819 internal(ios);
9820 {
9821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9822 std::string ex(str, iter.base());
9823 assert(ex == "-*********************inf");
9824 assert(ios.width() == 0);
9825 }
9826 }
9827 }
9828 }
9829 }
9830 uppercase(ios);
9831 {
9832 noshowpos(ios);
9833 {
9834 noshowpoint(ios);
9835 {
9836 ios.imbue(lc);
9837 {
9838 ios.width(0);
9839 {
9840 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9841 std::string ex(str, iter.base());
9842 assert(ex == "-INF");
9843 assert(ios.width() == 0);
9844 }
9845 ios.width(25);
9846 left(ios);
9847 {
9848 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9849 std::string ex(str, iter.base());
9850 assert(ex == "-INF*********************");
9851 assert(ios.width() == 0);
9852 }
9853 ios.width(25);
9854 right(ios);
9855 {
9856 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9857 std::string ex(str, iter.base());
9858 assert(ex == "*********************-INF");
9859 assert(ios.width() == 0);
9860 }
9861 ios.width(25);
9862 internal(ios);
9863 {
9864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9865 std::string ex(str, iter.base());
9866 assert(ex == "-*********************INF");
9867 assert(ios.width() == 0);
9868 }
9869 }
9870 ios.imbue(lg);
9871 {
9872 ios.width(0);
9873 {
9874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9875 std::string ex(str, iter.base());
9876 assert(ex == "-INF");
9877 assert(ios.width() == 0);
9878 }
9879 ios.width(25);
9880 left(ios);
9881 {
9882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9883 std::string ex(str, iter.base());
9884 assert(ex == "-INF*********************");
9885 assert(ios.width() == 0);
9886 }
9887 ios.width(25);
9888 right(ios);
9889 {
9890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9891 std::string ex(str, iter.base());
9892 assert(ex == "*********************-INF");
9893 assert(ios.width() == 0);
9894 }
9895 ios.width(25);
9896 internal(ios);
9897 {
9898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9899 std::string ex(str, iter.base());
9900 assert(ex == "-*********************INF");
9901 assert(ios.width() == 0);
9902 }
9903 }
9904 }
9905 showpoint(ios);
9906 {
9907 ios.imbue(lc);
9908 {
9909 ios.width(0);
9910 {
9911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9912 std::string ex(str, iter.base());
9913 assert(ex == "-INF");
9914 assert(ios.width() == 0);
9915 }
9916 ios.width(25);
9917 left(ios);
9918 {
9919 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9920 std::string ex(str, iter.base());
9921 assert(ex == "-INF*********************");
9922 assert(ios.width() == 0);
9923 }
9924 ios.width(25);
9925 right(ios);
9926 {
9927 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9928 std::string ex(str, iter.base());
9929 assert(ex == "*********************-INF");
9930 assert(ios.width() == 0);
9931 }
9932 ios.width(25);
9933 internal(ios);
9934 {
9935 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9936 std::string ex(str, iter.base());
9937 assert(ex == "-*********************INF");
9938 assert(ios.width() == 0);
9939 }
9940 }
9941 ios.imbue(lg);
9942 {
9943 ios.width(0);
9944 {
9945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9946 std::string ex(str, iter.base());
9947 assert(ex == "-INF");
9948 assert(ios.width() == 0);
9949 }
9950 ios.width(25);
9951 left(ios);
9952 {
9953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9954 std::string ex(str, iter.base());
9955 assert(ex == "-INF*********************");
9956 assert(ios.width() == 0);
9957 }
9958 ios.width(25);
9959 right(ios);
9960 {
9961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9962 std::string ex(str, iter.base());
9963 assert(ex == "*********************-INF");
9964 assert(ios.width() == 0);
9965 }
9966 ios.width(25);
9967 internal(ios);
9968 {
9969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9970 std::string ex(str, iter.base());
9971 assert(ex == "-*********************INF");
9972 assert(ios.width() == 0);
9973 }
9974 }
9975 }
9976 }
9977 showpos(ios);
9978 {
9979 noshowpoint(ios);
9980 {
9981 ios.imbue(lc);
9982 {
9983 ios.width(0);
9984 {
9985 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9986 std::string ex(str, iter.base());
9987 assert(ex == "-INF");
9988 assert(ios.width() == 0);
9989 }
9990 ios.width(25);
9991 left(ios);
9992 {
9993 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9994 std::string ex(str, iter.base());
9995 assert(ex == "-INF*********************");
9996 assert(ios.width() == 0);
9997 }
9998 ios.width(25);
9999 right(ios);
10000 {
10001 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10002 std::string ex(str, iter.base());
10003 assert(ex == "*********************-INF");
10004 assert(ios.width() == 0);
10005 }
10006 ios.width(25);
10007 internal(ios);
10008 {
10009 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10010 std::string ex(str, iter.base());
10011 assert(ex == "-*********************INF");
10012 assert(ios.width() == 0);
10013 }
10014 }
10015 ios.imbue(lg);
10016 {
10017 ios.width(0);
10018 {
10019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10020 std::string ex(str, iter.base());
10021 assert(ex == "-INF");
10022 assert(ios.width() == 0);
10023 }
10024 ios.width(25);
10025 left(ios);
10026 {
10027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10028 std::string ex(str, iter.base());
10029 assert(ex == "-INF*********************");
10030 assert(ios.width() == 0);
10031 }
10032 ios.width(25);
10033 right(ios);
10034 {
10035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10036 std::string ex(str, iter.base());
10037 assert(ex == "*********************-INF");
10038 assert(ios.width() == 0);
10039 }
10040 ios.width(25);
10041 internal(ios);
10042 {
10043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10044 std::string ex(str, iter.base());
10045 assert(ex == "-*********************INF");
10046 assert(ios.width() == 0);
10047 }
10048 }
10049 }
10050 showpoint(ios);
10051 {
10052 ios.imbue(lc);
10053 {
10054 ios.width(0);
10055 {
10056 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10057 std::string ex(str, iter.base());
10058 assert(ex == "-INF");
10059 assert(ios.width() == 0);
10060 }
10061 ios.width(25);
10062 left(ios);
10063 {
10064 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10065 std::string ex(str, iter.base());
10066 assert(ex == "-INF*********************");
10067 assert(ios.width() == 0);
10068 }
10069 ios.width(25);
10070 right(ios);
10071 {
10072 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10073 std::string ex(str, iter.base());
10074 assert(ex == "*********************-INF");
10075 assert(ios.width() == 0);
10076 }
10077 ios.width(25);
10078 internal(ios);
10079 {
10080 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10081 std::string ex(str, iter.base());
10082 assert(ex == "-*********************INF");
10083 assert(ios.width() == 0);
10084 }
10085 }
10086 ios.imbue(lg);
10087 {
10088 ios.width(0);
10089 {
10090 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10091 std::string ex(str, iter.base());
10092 assert(ex == "-INF");
10093 assert(ios.width() == 0);
10094 }
10095 ios.width(25);
10096 left(ios);
10097 {
10098 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10099 std::string ex(str, iter.base());
10100 assert(ex == "-INF*********************");
10101 assert(ios.width() == 0);
10102 }
10103 ios.width(25);
10104 right(ios);
10105 {
10106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10107 std::string ex(str, iter.base());
10108 assert(ex == "*********************-INF");
10109 assert(ios.width() == 0);
10110 }
10111 ios.width(25);
10112 internal(ios);
10113 {
10114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10115 std::string ex(str, iter.base());
10116 assert(ex == "-*********************INF");
10117 assert(ios.width() == 0);
10118 }
10119 }
10120 }
10121 }
10122 }
10123 }
10124 ios.precision(6);
10125 {
10126 nouppercase(ios);
10127 {
10128 noshowpos(ios);
10129 {
10130 noshowpoint(ios);
10131 {
10132 ios.imbue(lc);
10133 {
10134 ios.width(0);
10135 {
10136 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10137 std::string ex(str, iter.base());
10138 assert(ex == "-inf");
10139 assert(ios.width() == 0);
10140 }
10141 ios.width(25);
10142 left(ios);
10143 {
10144 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10145 std::string ex(str, iter.base());
10146 assert(ex == "-inf*********************");
10147 assert(ios.width() == 0);
10148 }
10149 ios.width(25);
10150 right(ios);
10151 {
10152 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10153 std::string ex(str, iter.base());
10154 assert(ex == "*********************-inf");
10155 assert(ios.width() == 0);
10156 }
10157 ios.width(25);
10158 internal(ios);
10159 {
10160 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10161 std::string ex(str, iter.base());
10162 assert(ex == "-*********************inf");
10163 assert(ios.width() == 0);
10164 }
10165 }
10166 ios.imbue(lg);
10167 {
10168 ios.width(0);
10169 {
10170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10171 std::string ex(str, iter.base());
10172 assert(ex == "-inf");
10173 assert(ios.width() == 0);
10174 }
10175 ios.width(25);
10176 left(ios);
10177 {
10178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10179 std::string ex(str, iter.base());
10180 assert(ex == "-inf*********************");
10181 assert(ios.width() == 0);
10182 }
10183 ios.width(25);
10184 right(ios);
10185 {
10186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10187 std::string ex(str, iter.base());
10188 assert(ex == "*********************-inf");
10189 assert(ios.width() == 0);
10190 }
10191 ios.width(25);
10192 internal(ios);
10193 {
10194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10195 std::string ex(str, iter.base());
10196 assert(ex == "-*********************inf");
10197 assert(ios.width() == 0);
10198 }
10199 }
10200 }
10201 showpoint(ios);
10202 {
10203 ios.imbue(lc);
10204 {
10205 ios.width(0);
10206 {
10207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10208 std::string ex(str, iter.base());
10209 assert(ex == "-inf");
10210 assert(ios.width() == 0);
10211 }
10212 ios.width(25);
10213 left(ios);
10214 {
10215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10216 std::string ex(str, iter.base());
10217 assert(ex == "-inf*********************");
10218 assert(ios.width() == 0);
10219 }
10220 ios.width(25);
10221 right(ios);
10222 {
10223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10224 std::string ex(str, iter.base());
10225 assert(ex == "*********************-inf");
10226 assert(ios.width() == 0);
10227 }
10228 ios.width(25);
10229 internal(ios);
10230 {
10231 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10232 std::string ex(str, iter.base());
10233 assert(ex == "-*********************inf");
10234 assert(ios.width() == 0);
10235 }
10236 }
10237 ios.imbue(lg);
10238 {
10239 ios.width(0);
10240 {
10241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10242 std::string ex(str, iter.base());
10243 assert(ex == "-inf");
10244 assert(ios.width() == 0);
10245 }
10246 ios.width(25);
10247 left(ios);
10248 {
10249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10250 std::string ex(str, iter.base());
10251 assert(ex == "-inf*********************");
10252 assert(ios.width() == 0);
10253 }
10254 ios.width(25);
10255 right(ios);
10256 {
10257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10258 std::string ex(str, iter.base());
10259 assert(ex == "*********************-inf");
10260 assert(ios.width() == 0);
10261 }
10262 ios.width(25);
10263 internal(ios);
10264 {
10265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10266 std::string ex(str, iter.base());
10267 assert(ex == "-*********************inf");
10268 assert(ios.width() == 0);
10269 }
10270 }
10271 }
10272 }
10273 showpos(ios);
10274 {
10275 noshowpoint(ios);
10276 {
10277 ios.imbue(lc);
10278 {
10279 ios.width(0);
10280 {
10281 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10282 std::string ex(str, iter.base());
10283 assert(ex == "-inf");
10284 assert(ios.width() == 0);
10285 }
10286 ios.width(25);
10287 left(ios);
10288 {
10289 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10290 std::string ex(str, iter.base());
10291 assert(ex == "-inf*********************");
10292 assert(ios.width() == 0);
10293 }
10294 ios.width(25);
10295 right(ios);
10296 {
10297 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10298 std::string ex(str, iter.base());
10299 assert(ex == "*********************-inf");
10300 assert(ios.width() == 0);
10301 }
10302 ios.width(25);
10303 internal(ios);
10304 {
10305 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10306 std::string ex(str, iter.base());
10307 assert(ex == "-*********************inf");
10308 assert(ios.width() == 0);
10309 }
10310 }
10311 ios.imbue(lg);
10312 {
10313 ios.width(0);
10314 {
10315 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10316 std::string ex(str, iter.base());
10317 assert(ex == "-inf");
10318 assert(ios.width() == 0);
10319 }
10320 ios.width(25);
10321 left(ios);
10322 {
10323 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10324 std::string ex(str, iter.base());
10325 assert(ex == "-inf*********************");
10326 assert(ios.width() == 0);
10327 }
10328 ios.width(25);
10329 right(ios);
10330 {
10331 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10332 std::string ex(str, iter.base());
10333 assert(ex == "*********************-inf");
10334 assert(ios.width() == 0);
10335 }
10336 ios.width(25);
10337 internal(ios);
10338 {
10339 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10340 std::string ex(str, iter.base());
10341 assert(ex == "-*********************inf");
10342 assert(ios.width() == 0);
10343 }
10344 }
10345 }
10346 showpoint(ios);
10347 {
10348 ios.imbue(lc);
10349 {
10350 ios.width(0);
10351 {
10352 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10353 std::string ex(str, iter.base());
10354 assert(ex == "-inf");
10355 assert(ios.width() == 0);
10356 }
10357 ios.width(25);
10358 left(ios);
10359 {
10360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10361 std::string ex(str, iter.base());
10362 assert(ex == "-inf*********************");
10363 assert(ios.width() == 0);
10364 }
10365 ios.width(25);
10366 right(ios);
10367 {
10368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10369 std::string ex(str, iter.base());
10370 assert(ex == "*********************-inf");
10371 assert(ios.width() == 0);
10372 }
10373 ios.width(25);
10374 internal(ios);
10375 {
10376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10377 std::string ex(str, iter.base());
10378 assert(ex == "-*********************inf");
10379 assert(ios.width() == 0);
10380 }
10381 }
10382 ios.imbue(lg);
10383 {
10384 ios.width(0);
10385 {
10386 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10387 std::string ex(str, iter.base());
10388 assert(ex == "-inf");
10389 assert(ios.width() == 0);
10390 }
10391 ios.width(25);
10392 left(ios);
10393 {
10394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10395 std::string ex(str, iter.base());
10396 assert(ex == "-inf*********************");
10397 assert(ios.width() == 0);
10398 }
10399 ios.width(25);
10400 right(ios);
10401 {
10402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10403 std::string ex(str, iter.base());
10404 assert(ex == "*********************-inf");
10405 assert(ios.width() == 0);
10406 }
10407 ios.width(25);
10408 internal(ios);
10409 {
10410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10411 std::string ex(str, iter.base());
10412 assert(ex == "-*********************inf");
10413 assert(ios.width() == 0);
10414 }
10415 }
10416 }
10417 }
10418 }
10419 uppercase(ios);
10420 {
10421 noshowpos(ios);
10422 {
10423 noshowpoint(ios);
10424 {
10425 ios.imbue(lc);
10426 {
10427 ios.width(0);
10428 {
10429 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10430 std::string ex(str, iter.base());
10431 assert(ex == "-INF");
10432 assert(ios.width() == 0);
10433 }
10434 ios.width(25);
10435 left(ios);
10436 {
10437 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10438 std::string ex(str, iter.base());
10439 assert(ex == "-INF*********************");
10440 assert(ios.width() == 0);
10441 }
10442 ios.width(25);
10443 right(ios);
10444 {
10445 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10446 std::string ex(str, iter.base());
10447 assert(ex == "*********************-INF");
10448 assert(ios.width() == 0);
10449 }
10450 ios.width(25);
10451 internal(ios);
10452 {
10453 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10454 std::string ex(str, iter.base());
10455 assert(ex == "-*********************INF");
10456 assert(ios.width() == 0);
10457 }
10458 }
10459 ios.imbue(lg);
10460 {
10461 ios.width(0);
10462 {
10463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10464 std::string ex(str, iter.base());
10465 assert(ex == "-INF");
10466 assert(ios.width() == 0);
10467 }
10468 ios.width(25);
10469 left(ios);
10470 {
10471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10472 std::string ex(str, iter.base());
10473 assert(ex == "-INF*********************");
10474 assert(ios.width() == 0);
10475 }
10476 ios.width(25);
10477 right(ios);
10478 {
10479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10480 std::string ex(str, iter.base());
10481 assert(ex == "*********************-INF");
10482 assert(ios.width() == 0);
10483 }
10484 ios.width(25);
10485 internal(ios);
10486 {
10487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10488 std::string ex(str, iter.base());
10489 assert(ex == "-*********************INF");
10490 assert(ios.width() == 0);
10491 }
10492 }
10493 }
10494 showpoint(ios);
10495 {
10496 ios.imbue(lc);
10497 {
10498 ios.width(0);
10499 {
10500 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10501 std::string ex(str, iter.base());
10502 assert(ex == "-INF");
10503 assert(ios.width() == 0);
10504 }
10505 ios.width(25);
10506 left(ios);
10507 {
10508 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10509 std::string ex(str, iter.base());
10510 assert(ex == "-INF*********************");
10511 assert(ios.width() == 0);
10512 }
10513 ios.width(25);
10514 right(ios);
10515 {
10516 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10517 std::string ex(str, iter.base());
10518 assert(ex == "*********************-INF");
10519 assert(ios.width() == 0);
10520 }
10521 ios.width(25);
10522 internal(ios);
10523 {
10524 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10525 std::string ex(str, iter.base());
10526 assert(ex == "-*********************INF");
10527 assert(ios.width() == 0);
10528 }
10529 }
10530 ios.imbue(lg);
10531 {
10532 ios.width(0);
10533 {
10534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10535 std::string ex(str, iter.base());
10536 assert(ex == "-INF");
10537 assert(ios.width() == 0);
10538 }
10539 ios.width(25);
10540 left(ios);
10541 {
10542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10543 std::string ex(str, iter.base());
10544 assert(ex == "-INF*********************");
10545 assert(ios.width() == 0);
10546 }
10547 ios.width(25);
10548 right(ios);
10549 {
10550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10551 std::string ex(str, iter.base());
10552 assert(ex == "*********************-INF");
10553 assert(ios.width() == 0);
10554 }
10555 ios.width(25);
10556 internal(ios);
10557 {
10558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10559 std::string ex(str, iter.base());
10560 assert(ex == "-*********************INF");
10561 assert(ios.width() == 0);
10562 }
10563 }
10564 }
10565 }
10566 showpos(ios);
10567 {
10568 noshowpoint(ios);
10569 {
10570 ios.imbue(lc);
10571 {
10572 ios.width(0);
10573 {
10574 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10575 std::string ex(str, iter.base());
10576 assert(ex == "-INF");
10577 assert(ios.width() == 0);
10578 }
10579 ios.width(25);
10580 left(ios);
10581 {
10582 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10583 std::string ex(str, iter.base());
10584 assert(ex == "-INF*********************");
10585 assert(ios.width() == 0);
10586 }
10587 ios.width(25);
10588 right(ios);
10589 {
10590 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10591 std::string ex(str, iter.base());
10592 assert(ex == "*********************-INF");
10593 assert(ios.width() == 0);
10594 }
10595 ios.width(25);
10596 internal(ios);
10597 {
10598 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10599 std::string ex(str, iter.base());
10600 assert(ex == "-*********************INF");
10601 assert(ios.width() == 0);
10602 }
10603 }
10604 ios.imbue(lg);
10605 {
10606 ios.width(0);
10607 {
10608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10609 std::string ex(str, iter.base());
10610 assert(ex == "-INF");
10611 assert(ios.width() == 0);
10612 }
10613 ios.width(25);
10614 left(ios);
10615 {
10616 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10617 std::string ex(str, iter.base());
10618 assert(ex == "-INF*********************");
10619 assert(ios.width() == 0);
10620 }
10621 ios.width(25);
10622 right(ios);
10623 {
10624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10625 std::string ex(str, iter.base());
10626 assert(ex == "*********************-INF");
10627 assert(ios.width() == 0);
10628 }
10629 ios.width(25);
10630 internal(ios);
10631 {
10632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10633 std::string ex(str, iter.base());
10634 assert(ex == "-*********************INF");
10635 assert(ios.width() == 0);
10636 }
10637 }
10638 }
10639 showpoint(ios);
10640 {
10641 ios.imbue(lc);
10642 {
10643 ios.width(0);
10644 {
10645 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10646 std::string ex(str, iter.base());
10647 assert(ex == "-INF");
10648 assert(ios.width() == 0);
10649 }
10650 ios.width(25);
10651 left(ios);
10652 {
10653 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10654 std::string ex(str, iter.base());
10655 assert(ex == "-INF*********************");
10656 assert(ios.width() == 0);
10657 }
10658 ios.width(25);
10659 right(ios);
10660 {
10661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10662 std::string ex(str, iter.base());
10663 assert(ex == "*********************-INF");
10664 assert(ios.width() == 0);
10665 }
10666 ios.width(25);
10667 internal(ios);
10668 {
10669 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10670 std::string ex(str, iter.base());
10671 assert(ex == "-*********************INF");
10672 assert(ios.width() == 0);
10673 }
10674 }
10675 ios.imbue(lg);
10676 {
10677 ios.width(0);
10678 {
10679 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10680 std::string ex(str, iter.base());
10681 assert(ex == "-INF");
10682 assert(ios.width() == 0);
10683 }
10684 ios.width(25);
10685 left(ios);
10686 {
10687 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10688 std::string ex(str, iter.base());
10689 assert(ex == "-INF*********************");
10690 assert(ios.width() == 0);
10691 }
10692 ios.width(25);
10693 right(ios);
10694 {
10695 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10696 std::string ex(str, iter.base());
10697 assert(ex == "*********************-INF");
10698 assert(ios.width() == 0);
10699 }
10700 ios.width(25);
10701 internal(ios);
10702 {
10703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10704 std::string ex(str, iter.base());
10705 assert(ex == "-*********************INF");
10706 assert(ios.width() == 0);
10707 }
10708 }
10709 }
10710 }
10711 }
10712 }
10713 ios.precision(16);
10714 {}
10715 ios.precision(60);
10716 {}
10717 }
10718 }
10719 }
10720
test5()10721 void test5()
10722 {
10723 char str[200];
10724 output_iterator<char*> iter;
10725 std::locale lc = std::locale::classic();
10726 std::locale lg(lc, new my_numpunct);
10727 const my_facet f(1);
10728 {
10729 long double v = std::nan("");
10730 std::ios ios(0);
10731 // %g
10732 {
10733 ios.precision(0);
10734 {
10735 nouppercase(ios);
10736 {
10737 noshowpos(ios);
10738 {
10739 noshowpoint(ios);
10740 {
10741 ios.imbue(lc);
10742 {
10743 ios.width(0);
10744 {
10745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10746 std::string ex(str, iter.base());
10747 assert(ex == "nan");
10748 assert(ios.width() == 0);
10749 }
10750 ios.width(25);
10751 left(ios);
10752 {
10753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10754 std::string ex(str, iter.base());
10755 assert(ex == "nan**********************");
10756 assert(ios.width() == 0);
10757 }
10758 ios.width(25);
10759 right(ios);
10760 {
10761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10762 std::string ex(str, iter.base());
10763 assert(ex == "**********************nan");
10764 assert(ios.width() == 0);
10765 }
10766 ios.width(25);
10767 internal(ios);
10768 {
10769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10770 std::string ex(str, iter.base());
10771 assert(ex == "**********************nan");
10772 assert(ios.width() == 0);
10773 }
10774 }
10775 ios.imbue(lg);
10776 {
10777 ios.width(0);
10778 {
10779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10780 std::string ex(str, iter.base());
10781 assert(ex == "nan");
10782 assert(ios.width() == 0);
10783 }
10784 ios.width(25);
10785 left(ios);
10786 {
10787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10788 std::string ex(str, iter.base());
10789 assert(ex == "nan**********************");
10790 assert(ios.width() == 0);
10791 }
10792 ios.width(25);
10793 right(ios);
10794 {
10795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10796 std::string ex(str, iter.base());
10797 assert(ex == "**********************nan");
10798 assert(ios.width() == 0);
10799 }
10800 ios.width(25);
10801 internal(ios);
10802 {
10803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10804 std::string ex(str, iter.base());
10805 assert(ex == "**********************nan");
10806 assert(ios.width() == 0);
10807 }
10808 }
10809 }
10810 showpoint(ios);
10811 {
10812 ios.imbue(lc);
10813 {
10814 ios.width(0);
10815 {
10816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10817 std::string ex(str, iter.base());
10818 assert(ex == "nan");
10819 assert(ios.width() == 0);
10820 }
10821 ios.width(25);
10822 left(ios);
10823 {
10824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10825 std::string ex(str, iter.base());
10826 assert(ex == "nan**********************");
10827 assert(ios.width() == 0);
10828 }
10829 ios.width(25);
10830 right(ios);
10831 {
10832 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10833 std::string ex(str, iter.base());
10834 assert(ex == "**********************nan");
10835 assert(ios.width() == 0);
10836 }
10837 ios.width(25);
10838 internal(ios);
10839 {
10840 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10841 std::string ex(str, iter.base());
10842 assert(ex == "**********************nan");
10843 assert(ios.width() == 0);
10844 }
10845 }
10846 ios.imbue(lg);
10847 {
10848 ios.width(0);
10849 {
10850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10851 std::string ex(str, iter.base());
10852 assert(ex == "nan");
10853 assert(ios.width() == 0);
10854 }
10855 ios.width(25);
10856 left(ios);
10857 {
10858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10859 std::string ex(str, iter.base());
10860 assert(ex == "nan**********************");
10861 assert(ios.width() == 0);
10862 }
10863 ios.width(25);
10864 right(ios);
10865 {
10866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10867 std::string ex(str, iter.base());
10868 assert(ex == "**********************nan");
10869 assert(ios.width() == 0);
10870 }
10871 ios.width(25);
10872 internal(ios);
10873 {
10874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10875 std::string ex(str, iter.base());
10876 assert(ex == "**********************nan");
10877 assert(ios.width() == 0);
10878 }
10879 }
10880 }
10881 }
10882 showpos(ios);
10883 {
10884 noshowpoint(ios);
10885 {
10886 ios.imbue(lc);
10887 {
10888 ios.width(0);
10889 {
10890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10891 std::string ex(str, iter.base());
10892 assert(ex == "nan");
10893 assert(ios.width() == 0);
10894 }
10895 ios.width(25);
10896 left(ios);
10897 {
10898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10899 std::string ex(str, iter.base());
10900 assert(ex == "nan**********************");
10901 assert(ios.width() == 0);
10902 }
10903 ios.width(25);
10904 right(ios);
10905 {
10906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10907 std::string ex(str, iter.base());
10908 assert(ex == "**********************nan");
10909 assert(ios.width() == 0);
10910 }
10911 ios.width(25);
10912 internal(ios);
10913 {
10914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10915 std::string ex(str, iter.base());
10916 assert(ex == "**********************nan");
10917 assert(ios.width() == 0);
10918 }
10919 }
10920 ios.imbue(lg);
10921 {
10922 ios.width(0);
10923 {
10924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10925 std::string ex(str, iter.base());
10926 assert(ex == "nan");
10927 assert(ios.width() == 0);
10928 }
10929 ios.width(25);
10930 left(ios);
10931 {
10932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10933 std::string ex(str, iter.base());
10934 assert(ex == "nan**********************");
10935 assert(ios.width() == 0);
10936 }
10937 ios.width(25);
10938 right(ios);
10939 {
10940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10941 std::string ex(str, iter.base());
10942 assert(ex == "**********************nan");
10943 assert(ios.width() == 0);
10944 }
10945 ios.width(25);
10946 internal(ios);
10947 {
10948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10949 std::string ex(str, iter.base());
10950 assert(ex == "**********************nan");
10951 assert(ios.width() == 0);
10952 }
10953 }
10954 }
10955 showpoint(ios);
10956 {
10957 ios.imbue(lc);
10958 {
10959 ios.width(0);
10960 {
10961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10962 std::string ex(str, iter.base());
10963 assert(ex == "nan");
10964 assert(ios.width() == 0);
10965 }
10966 ios.width(25);
10967 left(ios);
10968 {
10969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10970 std::string ex(str, iter.base());
10971 assert(ex == "nan**********************");
10972 assert(ios.width() == 0);
10973 }
10974 ios.width(25);
10975 right(ios);
10976 {
10977 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10978 std::string ex(str, iter.base());
10979 assert(ex == "**********************nan");
10980 assert(ios.width() == 0);
10981 }
10982 ios.width(25);
10983 internal(ios);
10984 {
10985 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10986 std::string ex(str, iter.base());
10987 assert(ex == "**********************nan");
10988 assert(ios.width() == 0);
10989 }
10990 }
10991 ios.imbue(lg);
10992 {
10993 ios.width(0);
10994 {
10995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10996 std::string ex(str, iter.base());
10997 assert(ex == "nan");
10998 assert(ios.width() == 0);
10999 }
11000 ios.width(25);
11001 left(ios);
11002 {
11003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11004 std::string ex(str, iter.base());
11005 assert(ex == "nan**********************");
11006 assert(ios.width() == 0);
11007 }
11008 ios.width(25);
11009 right(ios);
11010 {
11011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11012 std::string ex(str, iter.base());
11013 assert(ex == "**********************nan");
11014 assert(ios.width() == 0);
11015 }
11016 ios.width(25);
11017 internal(ios);
11018 {
11019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11020 std::string ex(str, iter.base());
11021 assert(ex == "**********************nan");
11022 assert(ios.width() == 0);
11023 }
11024 }
11025 }
11026 }
11027 }
11028 uppercase(ios);
11029 {
11030 noshowpos(ios);
11031 {
11032 noshowpoint(ios);
11033 {
11034 ios.imbue(lc);
11035 {
11036 ios.width(0);
11037 {
11038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11039 std::string ex(str, iter.base());
11040 assert(ex == "NAN");
11041 assert(ios.width() == 0);
11042 }
11043 ios.width(25);
11044 left(ios);
11045 {
11046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11047 std::string ex(str, iter.base());
11048 assert(ex == "NAN**********************");
11049 assert(ios.width() == 0);
11050 }
11051 ios.width(25);
11052 right(ios);
11053 {
11054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11055 std::string ex(str, iter.base());
11056 assert(ex == "**********************NAN");
11057 assert(ios.width() == 0);
11058 }
11059 ios.width(25);
11060 internal(ios);
11061 {
11062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11063 std::string ex(str, iter.base());
11064 assert(ex == "**********************NAN");
11065 assert(ios.width() == 0);
11066 }
11067 }
11068 ios.imbue(lg);
11069 {
11070 ios.width(0);
11071 {
11072 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11073 std::string ex(str, iter.base());
11074 assert(ex == "NAN");
11075 assert(ios.width() == 0);
11076 }
11077 ios.width(25);
11078 left(ios);
11079 {
11080 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11081 std::string ex(str, iter.base());
11082 assert(ex == "NAN**********************");
11083 assert(ios.width() == 0);
11084 }
11085 ios.width(25);
11086 right(ios);
11087 {
11088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11089 std::string ex(str, iter.base());
11090 assert(ex == "**********************NAN");
11091 assert(ios.width() == 0);
11092 }
11093 ios.width(25);
11094 internal(ios);
11095 {
11096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11097 std::string ex(str, iter.base());
11098 assert(ex == "**********************NAN");
11099 assert(ios.width() == 0);
11100 }
11101 }
11102 }
11103 showpoint(ios);
11104 {
11105 ios.imbue(lc);
11106 {
11107 ios.width(0);
11108 {
11109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11110 std::string ex(str, iter.base());
11111 assert(ex == "NAN");
11112 assert(ios.width() == 0);
11113 }
11114 ios.width(25);
11115 left(ios);
11116 {
11117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11118 std::string ex(str, iter.base());
11119 assert(ex == "NAN**********************");
11120 assert(ios.width() == 0);
11121 }
11122 ios.width(25);
11123 right(ios);
11124 {
11125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11126 std::string ex(str, iter.base());
11127 assert(ex == "**********************NAN");
11128 assert(ios.width() == 0);
11129 }
11130 ios.width(25);
11131 internal(ios);
11132 {
11133 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11134 std::string ex(str, iter.base());
11135 assert(ex == "**********************NAN");
11136 assert(ios.width() == 0);
11137 }
11138 }
11139 ios.imbue(lg);
11140 {
11141 ios.width(0);
11142 {
11143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11144 std::string ex(str, iter.base());
11145 assert(ex == "NAN");
11146 assert(ios.width() == 0);
11147 }
11148 ios.width(25);
11149 left(ios);
11150 {
11151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11152 std::string ex(str, iter.base());
11153 assert(ex == "NAN**********************");
11154 assert(ios.width() == 0);
11155 }
11156 ios.width(25);
11157 right(ios);
11158 {
11159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11160 std::string ex(str, iter.base());
11161 assert(ex == "**********************NAN");
11162 assert(ios.width() == 0);
11163 }
11164 ios.width(25);
11165 internal(ios);
11166 {
11167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11168 std::string ex(str, iter.base());
11169 assert(ex == "**********************NAN");
11170 assert(ios.width() == 0);
11171 }
11172 }
11173 }
11174 }
11175 showpos(ios);
11176 {
11177 noshowpoint(ios);
11178 {
11179 ios.imbue(lc);
11180 {
11181 ios.width(0);
11182 {
11183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11184 std::string ex(str, iter.base());
11185 assert(ex == "NAN");
11186 assert(ios.width() == 0);
11187 }
11188 ios.width(25);
11189 left(ios);
11190 {
11191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11192 std::string ex(str, iter.base());
11193 assert(ex == "NAN**********************");
11194 assert(ios.width() == 0);
11195 }
11196 ios.width(25);
11197 right(ios);
11198 {
11199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11200 std::string ex(str, iter.base());
11201 assert(ex == "**********************NAN");
11202 assert(ios.width() == 0);
11203 }
11204 ios.width(25);
11205 internal(ios);
11206 {
11207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11208 std::string ex(str, iter.base());
11209 assert(ex == "**********************NAN");
11210 assert(ios.width() == 0);
11211 }
11212 }
11213 ios.imbue(lg);
11214 {
11215 ios.width(0);
11216 {
11217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11218 std::string ex(str, iter.base());
11219 assert(ex == "NAN");
11220 assert(ios.width() == 0);
11221 }
11222 ios.width(25);
11223 left(ios);
11224 {
11225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11226 std::string ex(str, iter.base());
11227 assert(ex == "NAN**********************");
11228 assert(ios.width() == 0);
11229 }
11230 ios.width(25);
11231 right(ios);
11232 {
11233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11234 std::string ex(str, iter.base());
11235 assert(ex == "**********************NAN");
11236 assert(ios.width() == 0);
11237 }
11238 ios.width(25);
11239 internal(ios);
11240 {
11241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11242 std::string ex(str, iter.base());
11243 assert(ex == "**********************NAN");
11244 assert(ios.width() == 0);
11245 }
11246 }
11247 }
11248 showpoint(ios);
11249 {
11250 ios.imbue(lc);
11251 {
11252 ios.width(0);
11253 {
11254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11255 std::string ex(str, iter.base());
11256 assert(ex == "NAN");
11257 assert(ios.width() == 0);
11258 }
11259 ios.width(25);
11260 left(ios);
11261 {
11262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11263 std::string ex(str, iter.base());
11264 assert(ex == "NAN**********************");
11265 assert(ios.width() == 0);
11266 }
11267 ios.width(25);
11268 right(ios);
11269 {
11270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11271 std::string ex(str, iter.base());
11272 assert(ex == "**********************NAN");
11273 assert(ios.width() == 0);
11274 }
11275 ios.width(25);
11276 internal(ios);
11277 {
11278 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11279 std::string ex(str, iter.base());
11280 assert(ex == "**********************NAN");
11281 assert(ios.width() == 0);
11282 }
11283 }
11284 ios.imbue(lg);
11285 {
11286 ios.width(0);
11287 {
11288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11289 std::string ex(str, iter.base());
11290 assert(ex == "NAN");
11291 assert(ios.width() == 0);
11292 }
11293 ios.width(25);
11294 left(ios);
11295 {
11296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11297 std::string ex(str, iter.base());
11298 assert(ex == "NAN**********************");
11299 assert(ios.width() == 0);
11300 }
11301 ios.width(25);
11302 right(ios);
11303 {
11304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11305 std::string ex(str, iter.base());
11306 assert(ex == "**********************NAN");
11307 assert(ios.width() == 0);
11308 }
11309 ios.width(25);
11310 internal(ios);
11311 {
11312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11313 std::string ex(str, iter.base());
11314 assert(ex == "**********************NAN");
11315 assert(ios.width() == 0);
11316 }
11317 }
11318 }
11319 }
11320 }
11321 }
11322 ios.precision(1);
11323 {}
11324 ios.precision(6);
11325 {}
11326 ios.precision(16);
11327 {}
11328 ios.precision(60);
11329 {}
11330 }
11331 }
11332 }
11333
test6()11334 void test6()
11335 {
11336 char str[200];
11337 output_iterator<char*> iter;
11338 std::locale lc = std::locale::classic();
11339 std::locale lg(lc, new my_numpunct);
11340 const my_facet f(1);
11341 {
11342 long double v = +0.;
11343 std::ios ios(0);
11344 fixed(ios);
11345 // %f
11346 {
11347 ios.precision(0);
11348 {
11349 nouppercase(ios);
11350 {
11351 noshowpos(ios);
11352 {
11353 noshowpoint(ios);
11354 {
11355 ios.imbue(lc);
11356 {
11357 ios.width(0);
11358 {
11359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11360 std::string ex(str, iter.base());
11361 assert(ex == "0");
11362 assert(ios.width() == 0);
11363 }
11364 ios.width(25);
11365 left(ios);
11366 {
11367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11368 std::string ex(str, iter.base());
11369 assert(ex == "0************************");
11370 assert(ios.width() == 0);
11371 }
11372 ios.width(25);
11373 right(ios);
11374 {
11375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11376 std::string ex(str, iter.base());
11377 assert(ex == "************************0");
11378 assert(ios.width() == 0);
11379 }
11380 ios.width(25);
11381 internal(ios);
11382 {
11383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11384 std::string ex(str, iter.base());
11385 assert(ex == "************************0");
11386 assert(ios.width() == 0);
11387 }
11388 }
11389 ios.imbue(lg);
11390 {
11391 ios.width(0);
11392 {
11393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11394 std::string ex(str, iter.base());
11395 assert(ex == "0");
11396 assert(ios.width() == 0);
11397 }
11398 ios.width(25);
11399 left(ios);
11400 {
11401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11402 std::string ex(str, iter.base());
11403 assert(ex == "0************************");
11404 assert(ios.width() == 0);
11405 }
11406 ios.width(25);
11407 right(ios);
11408 {
11409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11410 std::string ex(str, iter.base());
11411 assert(ex == "************************0");
11412 assert(ios.width() == 0);
11413 }
11414 ios.width(25);
11415 internal(ios);
11416 {
11417 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11418 std::string ex(str, iter.base());
11419 assert(ex == "************************0");
11420 assert(ios.width() == 0);
11421 }
11422 }
11423 }
11424 showpoint(ios);
11425 {
11426 ios.imbue(lc);
11427 {
11428 ios.width(0);
11429 {
11430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11431 std::string ex(str, iter.base());
11432 assert(ex == "0.");
11433 assert(ios.width() == 0);
11434 }
11435 ios.width(25);
11436 left(ios);
11437 {
11438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11439 std::string ex(str, iter.base());
11440 assert(ex == "0.***********************");
11441 assert(ios.width() == 0);
11442 }
11443 ios.width(25);
11444 right(ios);
11445 {
11446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11447 std::string ex(str, iter.base());
11448 assert(ex == "***********************0.");
11449 assert(ios.width() == 0);
11450 }
11451 ios.width(25);
11452 internal(ios);
11453 {
11454 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11455 std::string ex(str, iter.base());
11456 assert(ex == "***********************0.");
11457 assert(ios.width() == 0);
11458 }
11459 }
11460 ios.imbue(lg);
11461 {
11462 ios.width(0);
11463 {
11464 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11465 std::string ex(str, iter.base());
11466 assert(ex == "0;");
11467 assert(ios.width() == 0);
11468 }
11469 ios.width(25);
11470 left(ios);
11471 {
11472 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11473 std::string ex(str, iter.base());
11474 assert(ex == "0;***********************");
11475 assert(ios.width() == 0);
11476 }
11477 ios.width(25);
11478 right(ios);
11479 {
11480 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11481 std::string ex(str, iter.base());
11482 assert(ex == "***********************0;");
11483 assert(ios.width() == 0);
11484 }
11485 ios.width(25);
11486 internal(ios);
11487 {
11488 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11489 std::string ex(str, iter.base());
11490 assert(ex == "***********************0;");
11491 assert(ios.width() == 0);
11492 }
11493 }
11494 }
11495 }
11496 showpos(ios);
11497 {
11498 noshowpoint(ios);
11499 {
11500 ios.imbue(lc);
11501 {
11502 ios.width(0);
11503 {
11504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11505 std::string ex(str, iter.base());
11506 assert(ex == "+0");
11507 assert(ios.width() == 0);
11508 }
11509 ios.width(25);
11510 left(ios);
11511 {
11512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11513 std::string ex(str, iter.base());
11514 assert(ex == "+0***********************");
11515 assert(ios.width() == 0);
11516 }
11517 ios.width(25);
11518 right(ios);
11519 {
11520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11521 std::string ex(str, iter.base());
11522 assert(ex == "***********************+0");
11523 assert(ios.width() == 0);
11524 }
11525 ios.width(25);
11526 internal(ios);
11527 {
11528 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11529 std::string ex(str, iter.base());
11530 assert(ex == "+***********************0");
11531 assert(ios.width() == 0);
11532 }
11533 }
11534 ios.imbue(lg);
11535 {
11536 ios.width(0);
11537 {
11538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11539 std::string ex(str, iter.base());
11540 assert(ex == "+0");
11541 assert(ios.width() == 0);
11542 }
11543 ios.width(25);
11544 left(ios);
11545 {
11546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11547 std::string ex(str, iter.base());
11548 assert(ex == "+0***********************");
11549 assert(ios.width() == 0);
11550 }
11551 ios.width(25);
11552 right(ios);
11553 {
11554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11555 std::string ex(str, iter.base());
11556 assert(ex == "***********************+0");
11557 assert(ios.width() == 0);
11558 }
11559 ios.width(25);
11560 internal(ios);
11561 {
11562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11563 std::string ex(str, iter.base());
11564 assert(ex == "+***********************0");
11565 assert(ios.width() == 0);
11566 }
11567 }
11568 }
11569 showpoint(ios);
11570 {
11571 ios.imbue(lc);
11572 {
11573 ios.width(0);
11574 {
11575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11576 std::string ex(str, iter.base());
11577 assert(ex == "+0.");
11578 assert(ios.width() == 0);
11579 }
11580 ios.width(25);
11581 left(ios);
11582 {
11583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11584 std::string ex(str, iter.base());
11585 assert(ex == "+0.**********************");
11586 assert(ios.width() == 0);
11587 }
11588 ios.width(25);
11589 right(ios);
11590 {
11591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11592 std::string ex(str, iter.base());
11593 assert(ex == "**********************+0.");
11594 assert(ios.width() == 0);
11595 }
11596 ios.width(25);
11597 internal(ios);
11598 {
11599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11600 std::string ex(str, iter.base());
11601 assert(ex == "+**********************0.");
11602 assert(ios.width() == 0);
11603 }
11604 }
11605 ios.imbue(lg);
11606 {
11607 ios.width(0);
11608 {
11609 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11610 std::string ex(str, iter.base());
11611 assert(ex == "+0;");
11612 assert(ios.width() == 0);
11613 }
11614 ios.width(25);
11615 left(ios);
11616 {
11617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11618 std::string ex(str, iter.base());
11619 assert(ex == "+0;**********************");
11620 assert(ios.width() == 0);
11621 }
11622 ios.width(25);
11623 right(ios);
11624 {
11625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11626 std::string ex(str, iter.base());
11627 assert(ex == "**********************+0;");
11628 assert(ios.width() == 0);
11629 }
11630 ios.width(25);
11631 internal(ios);
11632 {
11633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11634 std::string ex(str, iter.base());
11635 assert(ex == "+**********************0;");
11636 assert(ios.width() == 0);
11637 }
11638 }
11639 }
11640 }
11641 }
11642 uppercase(ios);
11643 {
11644 noshowpos(ios);
11645 {
11646 noshowpoint(ios);
11647 {
11648 ios.imbue(lc);
11649 {
11650 ios.width(0);
11651 {
11652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11653 std::string ex(str, iter.base());
11654 assert(ex == "0");
11655 assert(ios.width() == 0);
11656 }
11657 ios.width(25);
11658 left(ios);
11659 {
11660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11661 std::string ex(str, iter.base());
11662 assert(ex == "0************************");
11663 assert(ios.width() == 0);
11664 }
11665 ios.width(25);
11666 right(ios);
11667 {
11668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11669 std::string ex(str, iter.base());
11670 assert(ex == "************************0");
11671 assert(ios.width() == 0);
11672 }
11673 ios.width(25);
11674 internal(ios);
11675 {
11676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11677 std::string ex(str, iter.base());
11678 assert(ex == "************************0");
11679 assert(ios.width() == 0);
11680 }
11681 }
11682 ios.imbue(lg);
11683 {
11684 ios.width(0);
11685 {
11686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11687 std::string ex(str, iter.base());
11688 assert(ex == "0");
11689 assert(ios.width() == 0);
11690 }
11691 ios.width(25);
11692 left(ios);
11693 {
11694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11695 std::string ex(str, iter.base());
11696 assert(ex == "0************************");
11697 assert(ios.width() == 0);
11698 }
11699 ios.width(25);
11700 right(ios);
11701 {
11702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11703 std::string ex(str, iter.base());
11704 assert(ex == "************************0");
11705 assert(ios.width() == 0);
11706 }
11707 ios.width(25);
11708 internal(ios);
11709 {
11710 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11711 std::string ex(str, iter.base());
11712 assert(ex == "************************0");
11713 assert(ios.width() == 0);
11714 }
11715 }
11716 }
11717 showpoint(ios);
11718 {
11719 ios.imbue(lc);
11720 {
11721 ios.width(0);
11722 {
11723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11724 std::string ex(str, iter.base());
11725 assert(ex == "0.");
11726 assert(ios.width() == 0);
11727 }
11728 ios.width(25);
11729 left(ios);
11730 {
11731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11732 std::string ex(str, iter.base());
11733 assert(ex == "0.***********************");
11734 assert(ios.width() == 0);
11735 }
11736 ios.width(25);
11737 right(ios);
11738 {
11739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11740 std::string ex(str, iter.base());
11741 assert(ex == "***********************0.");
11742 assert(ios.width() == 0);
11743 }
11744 ios.width(25);
11745 internal(ios);
11746 {
11747 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11748 std::string ex(str, iter.base());
11749 assert(ex == "***********************0.");
11750 assert(ios.width() == 0);
11751 }
11752 }
11753 ios.imbue(lg);
11754 {
11755 ios.width(0);
11756 {
11757 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11758 std::string ex(str, iter.base());
11759 assert(ex == "0;");
11760 assert(ios.width() == 0);
11761 }
11762 ios.width(25);
11763 left(ios);
11764 {
11765 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11766 std::string ex(str, iter.base());
11767 assert(ex == "0;***********************");
11768 assert(ios.width() == 0);
11769 }
11770 ios.width(25);
11771 right(ios);
11772 {
11773 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11774 std::string ex(str, iter.base());
11775 assert(ex == "***********************0;");
11776 assert(ios.width() == 0);
11777 }
11778 ios.width(25);
11779 internal(ios);
11780 {
11781 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11782 std::string ex(str, iter.base());
11783 assert(ex == "***********************0;");
11784 assert(ios.width() == 0);
11785 }
11786 }
11787 }
11788 }
11789 showpos(ios);
11790 {
11791 noshowpoint(ios);
11792 {
11793 ios.imbue(lc);
11794 {
11795 ios.width(0);
11796 {
11797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11798 std::string ex(str, iter.base());
11799 assert(ex == "+0");
11800 assert(ios.width() == 0);
11801 }
11802 ios.width(25);
11803 left(ios);
11804 {
11805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11806 std::string ex(str, iter.base());
11807 assert(ex == "+0***********************");
11808 assert(ios.width() == 0);
11809 }
11810 ios.width(25);
11811 right(ios);
11812 {
11813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11814 std::string ex(str, iter.base());
11815 assert(ex == "***********************+0");
11816 assert(ios.width() == 0);
11817 }
11818 ios.width(25);
11819 internal(ios);
11820 {
11821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11822 std::string ex(str, iter.base());
11823 assert(ex == "+***********************0");
11824 assert(ios.width() == 0);
11825 }
11826 }
11827 ios.imbue(lg);
11828 {
11829 ios.width(0);
11830 {
11831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11832 std::string ex(str, iter.base());
11833 assert(ex == "+0");
11834 assert(ios.width() == 0);
11835 }
11836 ios.width(25);
11837 left(ios);
11838 {
11839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11840 std::string ex(str, iter.base());
11841 assert(ex == "+0***********************");
11842 assert(ios.width() == 0);
11843 }
11844 ios.width(25);
11845 right(ios);
11846 {
11847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11848 std::string ex(str, iter.base());
11849 assert(ex == "***********************+0");
11850 assert(ios.width() == 0);
11851 }
11852 ios.width(25);
11853 internal(ios);
11854 {
11855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11856 std::string ex(str, iter.base());
11857 assert(ex == "+***********************0");
11858 assert(ios.width() == 0);
11859 }
11860 }
11861 }
11862 showpoint(ios);
11863 {
11864 ios.imbue(lc);
11865 {
11866 ios.width(0);
11867 {
11868 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11869 std::string ex(str, iter.base());
11870 assert(ex == "+0.");
11871 assert(ios.width() == 0);
11872 }
11873 ios.width(25);
11874 left(ios);
11875 {
11876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11877 std::string ex(str, iter.base());
11878 assert(ex == "+0.**********************");
11879 assert(ios.width() == 0);
11880 }
11881 ios.width(25);
11882 right(ios);
11883 {
11884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11885 std::string ex(str, iter.base());
11886 assert(ex == "**********************+0.");
11887 assert(ios.width() == 0);
11888 }
11889 ios.width(25);
11890 internal(ios);
11891 {
11892 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11893 std::string ex(str, iter.base());
11894 assert(ex == "+**********************0.");
11895 assert(ios.width() == 0);
11896 }
11897 }
11898 ios.imbue(lg);
11899 {
11900 ios.width(0);
11901 {
11902 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11903 std::string ex(str, iter.base());
11904 assert(ex == "+0;");
11905 assert(ios.width() == 0);
11906 }
11907 ios.width(25);
11908 left(ios);
11909 {
11910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11911 std::string ex(str, iter.base());
11912 assert(ex == "+0;**********************");
11913 assert(ios.width() == 0);
11914 }
11915 ios.width(25);
11916 right(ios);
11917 {
11918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11919 std::string ex(str, iter.base());
11920 assert(ex == "**********************+0;");
11921 assert(ios.width() == 0);
11922 }
11923 ios.width(25);
11924 internal(ios);
11925 {
11926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11927 std::string ex(str, iter.base());
11928 assert(ex == "+**********************0;");
11929 assert(ios.width() == 0);
11930 }
11931 }
11932 }
11933 }
11934 }
11935 }
11936 ios.precision(1);
11937 {
11938 nouppercase(ios);
11939 {
11940 noshowpos(ios);
11941 {
11942 noshowpoint(ios);
11943 {
11944 ios.imbue(lc);
11945 {
11946 ios.width(0);
11947 {
11948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11949 std::string ex(str, iter.base());
11950 assert(ex == "0.0");
11951 assert(ios.width() == 0);
11952 }
11953 ios.width(25);
11954 left(ios);
11955 {
11956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11957 std::string ex(str, iter.base());
11958 assert(ex == "0.0**********************");
11959 assert(ios.width() == 0);
11960 }
11961 ios.width(25);
11962 right(ios);
11963 {
11964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11965 std::string ex(str, iter.base());
11966 assert(ex == "**********************0.0");
11967 assert(ios.width() == 0);
11968 }
11969 ios.width(25);
11970 internal(ios);
11971 {
11972 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11973 std::string ex(str, iter.base());
11974 assert(ex == "**********************0.0");
11975 assert(ios.width() == 0);
11976 }
11977 }
11978 ios.imbue(lg);
11979 {
11980 ios.width(0);
11981 {
11982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11983 std::string ex(str, iter.base());
11984 assert(ex == "0;0");
11985 assert(ios.width() == 0);
11986 }
11987 ios.width(25);
11988 left(ios);
11989 {
11990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11991 std::string ex(str, iter.base());
11992 assert(ex == "0;0**********************");
11993 assert(ios.width() == 0);
11994 }
11995 ios.width(25);
11996 right(ios);
11997 {
11998 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11999 std::string ex(str, iter.base());
12000 assert(ex == "**********************0;0");
12001 assert(ios.width() == 0);
12002 }
12003 ios.width(25);
12004 internal(ios);
12005 {
12006 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12007 std::string ex(str, iter.base());
12008 assert(ex == "**********************0;0");
12009 assert(ios.width() == 0);
12010 }
12011 }
12012 }
12013 showpoint(ios);
12014 {
12015 ios.imbue(lc);
12016 {
12017 ios.width(0);
12018 {
12019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12020 std::string ex(str, iter.base());
12021 assert(ex == "0.0");
12022 assert(ios.width() == 0);
12023 }
12024 ios.width(25);
12025 left(ios);
12026 {
12027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12028 std::string ex(str, iter.base());
12029 assert(ex == "0.0**********************");
12030 assert(ios.width() == 0);
12031 }
12032 ios.width(25);
12033 right(ios);
12034 {
12035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12036 std::string ex(str, iter.base());
12037 assert(ex == "**********************0.0");
12038 assert(ios.width() == 0);
12039 }
12040 ios.width(25);
12041 internal(ios);
12042 {
12043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12044 std::string ex(str, iter.base());
12045 assert(ex == "**********************0.0");
12046 assert(ios.width() == 0);
12047 }
12048 }
12049 ios.imbue(lg);
12050 {
12051 ios.width(0);
12052 {
12053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12054 std::string ex(str, iter.base());
12055 assert(ex == "0;0");
12056 assert(ios.width() == 0);
12057 }
12058 ios.width(25);
12059 left(ios);
12060 {
12061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12062 std::string ex(str, iter.base());
12063 assert(ex == "0;0**********************");
12064 assert(ios.width() == 0);
12065 }
12066 ios.width(25);
12067 right(ios);
12068 {
12069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12070 std::string ex(str, iter.base());
12071 assert(ex == "**********************0;0");
12072 assert(ios.width() == 0);
12073 }
12074 ios.width(25);
12075 internal(ios);
12076 {
12077 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12078 std::string ex(str, iter.base());
12079 assert(ex == "**********************0;0");
12080 assert(ios.width() == 0);
12081 }
12082 }
12083 }
12084 }
12085 showpos(ios);
12086 {
12087 noshowpoint(ios);
12088 {
12089 ios.imbue(lc);
12090 {
12091 ios.width(0);
12092 {
12093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12094 std::string ex(str, iter.base());
12095 assert(ex == "+0.0");
12096 assert(ios.width() == 0);
12097 }
12098 ios.width(25);
12099 left(ios);
12100 {
12101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12102 std::string ex(str, iter.base());
12103 assert(ex == "+0.0*********************");
12104 assert(ios.width() == 0);
12105 }
12106 ios.width(25);
12107 right(ios);
12108 {
12109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12110 std::string ex(str, iter.base());
12111 assert(ex == "*********************+0.0");
12112 assert(ios.width() == 0);
12113 }
12114 ios.width(25);
12115 internal(ios);
12116 {
12117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12118 std::string ex(str, iter.base());
12119 assert(ex == "+*********************0.0");
12120 assert(ios.width() == 0);
12121 }
12122 }
12123 ios.imbue(lg);
12124 {
12125 ios.width(0);
12126 {
12127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12128 std::string ex(str, iter.base());
12129 assert(ex == "+0;0");
12130 assert(ios.width() == 0);
12131 }
12132 ios.width(25);
12133 left(ios);
12134 {
12135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12136 std::string ex(str, iter.base());
12137 assert(ex == "+0;0*********************");
12138 assert(ios.width() == 0);
12139 }
12140 ios.width(25);
12141 right(ios);
12142 {
12143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12144 std::string ex(str, iter.base());
12145 assert(ex == "*********************+0;0");
12146 assert(ios.width() == 0);
12147 }
12148 ios.width(25);
12149 internal(ios);
12150 {
12151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12152 std::string ex(str, iter.base());
12153 assert(ex == "+*********************0;0");
12154 assert(ios.width() == 0);
12155 }
12156 }
12157 }
12158 showpoint(ios);
12159 {
12160 ios.imbue(lc);
12161 {
12162 ios.width(0);
12163 {
12164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12165 std::string ex(str, iter.base());
12166 assert(ex == "+0.0");
12167 assert(ios.width() == 0);
12168 }
12169 ios.width(25);
12170 left(ios);
12171 {
12172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12173 std::string ex(str, iter.base());
12174 assert(ex == "+0.0*********************");
12175 assert(ios.width() == 0);
12176 }
12177 ios.width(25);
12178 right(ios);
12179 {
12180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12181 std::string ex(str, iter.base());
12182 assert(ex == "*********************+0.0");
12183 assert(ios.width() == 0);
12184 }
12185 ios.width(25);
12186 internal(ios);
12187 {
12188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12189 std::string ex(str, iter.base());
12190 assert(ex == "+*********************0.0");
12191 assert(ios.width() == 0);
12192 }
12193 }
12194 ios.imbue(lg);
12195 {
12196 ios.width(0);
12197 {
12198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12199 std::string ex(str, iter.base());
12200 assert(ex == "+0;0");
12201 assert(ios.width() == 0);
12202 }
12203 ios.width(25);
12204 left(ios);
12205 {
12206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12207 std::string ex(str, iter.base());
12208 assert(ex == "+0;0*********************");
12209 assert(ios.width() == 0);
12210 }
12211 ios.width(25);
12212 right(ios);
12213 {
12214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12215 std::string ex(str, iter.base());
12216 assert(ex == "*********************+0;0");
12217 assert(ios.width() == 0);
12218 }
12219 ios.width(25);
12220 internal(ios);
12221 {
12222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12223 std::string ex(str, iter.base());
12224 assert(ex == "+*********************0;0");
12225 assert(ios.width() == 0);
12226 }
12227 }
12228 }
12229 }
12230 }
12231 uppercase(ios);
12232 {
12233 noshowpos(ios);
12234 {
12235 noshowpoint(ios);
12236 {
12237 ios.imbue(lc);
12238 {
12239 ios.width(0);
12240 {
12241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12242 std::string ex(str, iter.base());
12243 assert(ex == "0.0");
12244 assert(ios.width() == 0);
12245 }
12246 ios.width(25);
12247 left(ios);
12248 {
12249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12250 std::string ex(str, iter.base());
12251 assert(ex == "0.0**********************");
12252 assert(ios.width() == 0);
12253 }
12254 ios.width(25);
12255 right(ios);
12256 {
12257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12258 std::string ex(str, iter.base());
12259 assert(ex == "**********************0.0");
12260 assert(ios.width() == 0);
12261 }
12262 ios.width(25);
12263 internal(ios);
12264 {
12265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12266 std::string ex(str, iter.base());
12267 assert(ex == "**********************0.0");
12268 assert(ios.width() == 0);
12269 }
12270 }
12271 ios.imbue(lg);
12272 {
12273 ios.width(0);
12274 {
12275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12276 std::string ex(str, iter.base());
12277 assert(ex == "0;0");
12278 assert(ios.width() == 0);
12279 }
12280 ios.width(25);
12281 left(ios);
12282 {
12283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12284 std::string ex(str, iter.base());
12285 assert(ex == "0;0**********************");
12286 assert(ios.width() == 0);
12287 }
12288 ios.width(25);
12289 right(ios);
12290 {
12291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12292 std::string ex(str, iter.base());
12293 assert(ex == "**********************0;0");
12294 assert(ios.width() == 0);
12295 }
12296 ios.width(25);
12297 internal(ios);
12298 {
12299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12300 std::string ex(str, iter.base());
12301 assert(ex == "**********************0;0");
12302 assert(ios.width() == 0);
12303 }
12304 }
12305 }
12306 showpoint(ios);
12307 {
12308 ios.imbue(lc);
12309 {
12310 ios.width(0);
12311 {
12312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12313 std::string ex(str, iter.base());
12314 assert(ex == "0.0");
12315 assert(ios.width() == 0);
12316 }
12317 ios.width(25);
12318 left(ios);
12319 {
12320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12321 std::string ex(str, iter.base());
12322 assert(ex == "0.0**********************");
12323 assert(ios.width() == 0);
12324 }
12325 ios.width(25);
12326 right(ios);
12327 {
12328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12329 std::string ex(str, iter.base());
12330 assert(ex == "**********************0.0");
12331 assert(ios.width() == 0);
12332 }
12333 ios.width(25);
12334 internal(ios);
12335 {
12336 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12337 std::string ex(str, iter.base());
12338 assert(ex == "**********************0.0");
12339 assert(ios.width() == 0);
12340 }
12341 }
12342 ios.imbue(lg);
12343 {
12344 ios.width(0);
12345 {
12346 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12347 std::string ex(str, iter.base());
12348 assert(ex == "0;0");
12349 assert(ios.width() == 0);
12350 }
12351 ios.width(25);
12352 left(ios);
12353 {
12354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12355 std::string ex(str, iter.base());
12356 assert(ex == "0;0**********************");
12357 assert(ios.width() == 0);
12358 }
12359 ios.width(25);
12360 right(ios);
12361 {
12362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12363 std::string ex(str, iter.base());
12364 assert(ex == "**********************0;0");
12365 assert(ios.width() == 0);
12366 }
12367 ios.width(25);
12368 internal(ios);
12369 {
12370 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12371 std::string ex(str, iter.base());
12372 assert(ex == "**********************0;0");
12373 assert(ios.width() == 0);
12374 }
12375 }
12376 }
12377 }
12378 showpos(ios);
12379 {
12380 noshowpoint(ios);
12381 {
12382 ios.imbue(lc);
12383 {
12384 ios.width(0);
12385 {
12386 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12387 std::string ex(str, iter.base());
12388 assert(ex == "+0.0");
12389 assert(ios.width() == 0);
12390 }
12391 ios.width(25);
12392 left(ios);
12393 {
12394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12395 std::string ex(str, iter.base());
12396 assert(ex == "+0.0*********************");
12397 assert(ios.width() == 0);
12398 }
12399 ios.width(25);
12400 right(ios);
12401 {
12402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12403 std::string ex(str, iter.base());
12404 assert(ex == "*********************+0.0");
12405 assert(ios.width() == 0);
12406 }
12407 ios.width(25);
12408 internal(ios);
12409 {
12410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12411 std::string ex(str, iter.base());
12412 assert(ex == "+*********************0.0");
12413 assert(ios.width() == 0);
12414 }
12415 }
12416 ios.imbue(lg);
12417 {
12418 ios.width(0);
12419 {
12420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12421 std::string ex(str, iter.base());
12422 assert(ex == "+0;0");
12423 assert(ios.width() == 0);
12424 }
12425 ios.width(25);
12426 left(ios);
12427 {
12428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12429 std::string ex(str, iter.base());
12430 assert(ex == "+0;0*********************");
12431 assert(ios.width() == 0);
12432 }
12433 ios.width(25);
12434 right(ios);
12435 {
12436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12437 std::string ex(str, iter.base());
12438 assert(ex == "*********************+0;0");
12439 assert(ios.width() == 0);
12440 }
12441 ios.width(25);
12442 internal(ios);
12443 {
12444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12445 std::string ex(str, iter.base());
12446 assert(ex == "+*********************0;0");
12447 assert(ios.width() == 0);
12448 }
12449 }
12450 }
12451 showpoint(ios);
12452 {
12453 ios.imbue(lc);
12454 {
12455 ios.width(0);
12456 {
12457 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12458 std::string ex(str, iter.base());
12459 assert(ex == "+0.0");
12460 assert(ios.width() == 0);
12461 }
12462 ios.width(25);
12463 left(ios);
12464 {
12465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12466 std::string ex(str, iter.base());
12467 assert(ex == "+0.0*********************");
12468 assert(ios.width() == 0);
12469 }
12470 ios.width(25);
12471 right(ios);
12472 {
12473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12474 std::string ex(str, iter.base());
12475 assert(ex == "*********************+0.0");
12476 assert(ios.width() == 0);
12477 }
12478 ios.width(25);
12479 internal(ios);
12480 {
12481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12482 std::string ex(str, iter.base());
12483 assert(ex == "+*********************0.0");
12484 assert(ios.width() == 0);
12485 }
12486 }
12487 ios.imbue(lg);
12488 {
12489 ios.width(0);
12490 {
12491 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12492 std::string ex(str, iter.base());
12493 assert(ex == "+0;0");
12494 assert(ios.width() == 0);
12495 }
12496 ios.width(25);
12497 left(ios);
12498 {
12499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12500 std::string ex(str, iter.base());
12501 assert(ex == "+0;0*********************");
12502 assert(ios.width() == 0);
12503 }
12504 ios.width(25);
12505 right(ios);
12506 {
12507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12508 std::string ex(str, iter.base());
12509 assert(ex == "*********************+0;0");
12510 assert(ios.width() == 0);
12511 }
12512 ios.width(25);
12513 internal(ios);
12514 {
12515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12516 std::string ex(str, iter.base());
12517 assert(ex == "+*********************0;0");
12518 assert(ios.width() == 0);
12519 }
12520 }
12521 }
12522 }
12523 }
12524 }
12525 ios.precision(6);
12526 {
12527 nouppercase(ios);
12528 {
12529 noshowpos(ios);
12530 {
12531 noshowpoint(ios);
12532 {
12533 ios.imbue(lc);
12534 {
12535 ios.width(0);
12536 {
12537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12538 std::string ex(str, iter.base());
12539 assert(ex == "0.000000");
12540 assert(ios.width() == 0);
12541 }
12542 ios.width(25);
12543 left(ios);
12544 {
12545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12546 std::string ex(str, iter.base());
12547 assert(ex == "0.000000*****************");
12548 assert(ios.width() == 0);
12549 }
12550 ios.width(25);
12551 right(ios);
12552 {
12553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12554 std::string ex(str, iter.base());
12555 assert(ex == "*****************0.000000");
12556 assert(ios.width() == 0);
12557 }
12558 ios.width(25);
12559 internal(ios);
12560 {
12561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12562 std::string ex(str, iter.base());
12563 assert(ex == "*****************0.000000");
12564 assert(ios.width() == 0);
12565 }
12566 }
12567 ios.imbue(lg);
12568 {
12569 ios.width(0);
12570 {
12571 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12572 std::string ex(str, iter.base());
12573 assert(ex == "0;000000");
12574 assert(ios.width() == 0);
12575 }
12576 ios.width(25);
12577 left(ios);
12578 {
12579 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12580 std::string ex(str, iter.base());
12581 assert(ex == "0;000000*****************");
12582 assert(ios.width() == 0);
12583 }
12584 ios.width(25);
12585 right(ios);
12586 {
12587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12588 std::string ex(str, iter.base());
12589 assert(ex == "*****************0;000000");
12590 assert(ios.width() == 0);
12591 }
12592 ios.width(25);
12593 internal(ios);
12594 {
12595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12596 std::string ex(str, iter.base());
12597 assert(ex == "*****************0;000000");
12598 assert(ios.width() == 0);
12599 }
12600 }
12601 }
12602 showpoint(ios);
12603 {
12604 ios.imbue(lc);
12605 {
12606 ios.width(0);
12607 {
12608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12609 std::string ex(str, iter.base());
12610 assert(ex == "0.000000");
12611 assert(ios.width() == 0);
12612 }
12613 ios.width(25);
12614 left(ios);
12615 {
12616 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12617 std::string ex(str, iter.base());
12618 assert(ex == "0.000000*****************");
12619 assert(ios.width() == 0);
12620 }
12621 ios.width(25);
12622 right(ios);
12623 {
12624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12625 std::string ex(str, iter.base());
12626 assert(ex == "*****************0.000000");
12627 assert(ios.width() == 0);
12628 }
12629 ios.width(25);
12630 internal(ios);
12631 {
12632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12633 std::string ex(str, iter.base());
12634 assert(ex == "*****************0.000000");
12635 assert(ios.width() == 0);
12636 }
12637 }
12638 ios.imbue(lg);
12639 {
12640 ios.width(0);
12641 {
12642 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12643 std::string ex(str, iter.base());
12644 assert(ex == "0;000000");
12645 assert(ios.width() == 0);
12646 }
12647 ios.width(25);
12648 left(ios);
12649 {
12650 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12651 std::string ex(str, iter.base());
12652 assert(ex == "0;000000*****************");
12653 assert(ios.width() == 0);
12654 }
12655 ios.width(25);
12656 right(ios);
12657 {
12658 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12659 std::string ex(str, iter.base());
12660 assert(ex == "*****************0;000000");
12661 assert(ios.width() == 0);
12662 }
12663 ios.width(25);
12664 internal(ios);
12665 {
12666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12667 std::string ex(str, iter.base());
12668 assert(ex == "*****************0;000000");
12669 assert(ios.width() == 0);
12670 }
12671 }
12672 }
12673 }
12674 showpos(ios);
12675 {
12676 noshowpoint(ios);
12677 {
12678 ios.imbue(lc);
12679 {
12680 ios.width(0);
12681 {
12682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12683 std::string ex(str, iter.base());
12684 assert(ex == "+0.000000");
12685 assert(ios.width() == 0);
12686 }
12687 ios.width(25);
12688 left(ios);
12689 {
12690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12691 std::string ex(str, iter.base());
12692 assert(ex == "+0.000000****************");
12693 assert(ios.width() == 0);
12694 }
12695 ios.width(25);
12696 right(ios);
12697 {
12698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12699 std::string ex(str, iter.base());
12700 assert(ex == "****************+0.000000");
12701 assert(ios.width() == 0);
12702 }
12703 ios.width(25);
12704 internal(ios);
12705 {
12706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12707 std::string ex(str, iter.base());
12708 assert(ex == "+****************0.000000");
12709 assert(ios.width() == 0);
12710 }
12711 }
12712 ios.imbue(lg);
12713 {
12714 ios.width(0);
12715 {
12716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12717 std::string ex(str, iter.base());
12718 assert(ex == "+0;000000");
12719 assert(ios.width() == 0);
12720 }
12721 ios.width(25);
12722 left(ios);
12723 {
12724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12725 std::string ex(str, iter.base());
12726 assert(ex == "+0;000000****************");
12727 assert(ios.width() == 0);
12728 }
12729 ios.width(25);
12730 right(ios);
12731 {
12732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12733 std::string ex(str, iter.base());
12734 assert(ex == "****************+0;000000");
12735 assert(ios.width() == 0);
12736 }
12737 ios.width(25);
12738 internal(ios);
12739 {
12740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12741 std::string ex(str, iter.base());
12742 assert(ex == "+****************0;000000");
12743 assert(ios.width() == 0);
12744 }
12745 }
12746 }
12747 showpoint(ios);
12748 {
12749 ios.imbue(lc);
12750 {
12751 ios.width(0);
12752 {
12753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12754 std::string ex(str, iter.base());
12755 assert(ex == "+0.000000");
12756 assert(ios.width() == 0);
12757 }
12758 ios.width(25);
12759 left(ios);
12760 {
12761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12762 std::string ex(str, iter.base());
12763 assert(ex == "+0.000000****************");
12764 assert(ios.width() == 0);
12765 }
12766 ios.width(25);
12767 right(ios);
12768 {
12769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12770 std::string ex(str, iter.base());
12771 assert(ex == "****************+0.000000");
12772 assert(ios.width() == 0);
12773 }
12774 ios.width(25);
12775 internal(ios);
12776 {
12777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12778 std::string ex(str, iter.base());
12779 assert(ex == "+****************0.000000");
12780 assert(ios.width() == 0);
12781 }
12782 }
12783 ios.imbue(lg);
12784 {
12785 ios.width(0);
12786 {
12787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12788 std::string ex(str, iter.base());
12789 assert(ex == "+0;000000");
12790 assert(ios.width() == 0);
12791 }
12792 ios.width(25);
12793 left(ios);
12794 {
12795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12796 std::string ex(str, iter.base());
12797 assert(ex == "+0;000000****************");
12798 assert(ios.width() == 0);
12799 }
12800 ios.width(25);
12801 right(ios);
12802 {
12803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12804 std::string ex(str, iter.base());
12805 assert(ex == "****************+0;000000");
12806 assert(ios.width() == 0);
12807 }
12808 ios.width(25);
12809 internal(ios);
12810 {
12811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12812 std::string ex(str, iter.base());
12813 assert(ex == "+****************0;000000");
12814 assert(ios.width() == 0);
12815 }
12816 }
12817 }
12818 }
12819 }
12820 uppercase(ios);
12821 {
12822 noshowpos(ios);
12823 {
12824 noshowpoint(ios);
12825 {
12826 ios.imbue(lc);
12827 {
12828 ios.width(0);
12829 {
12830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12831 std::string ex(str, iter.base());
12832 assert(ex == "0.000000");
12833 assert(ios.width() == 0);
12834 }
12835 ios.width(25);
12836 left(ios);
12837 {
12838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12839 std::string ex(str, iter.base());
12840 assert(ex == "0.000000*****************");
12841 assert(ios.width() == 0);
12842 }
12843 ios.width(25);
12844 right(ios);
12845 {
12846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12847 std::string ex(str, iter.base());
12848 assert(ex == "*****************0.000000");
12849 assert(ios.width() == 0);
12850 }
12851 ios.width(25);
12852 internal(ios);
12853 {
12854 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12855 std::string ex(str, iter.base());
12856 assert(ex == "*****************0.000000");
12857 assert(ios.width() == 0);
12858 }
12859 }
12860 ios.imbue(lg);
12861 {
12862 ios.width(0);
12863 {
12864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12865 std::string ex(str, iter.base());
12866 assert(ex == "0;000000");
12867 assert(ios.width() == 0);
12868 }
12869 ios.width(25);
12870 left(ios);
12871 {
12872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12873 std::string ex(str, iter.base());
12874 assert(ex == "0;000000*****************");
12875 assert(ios.width() == 0);
12876 }
12877 ios.width(25);
12878 right(ios);
12879 {
12880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12881 std::string ex(str, iter.base());
12882 assert(ex == "*****************0;000000");
12883 assert(ios.width() == 0);
12884 }
12885 ios.width(25);
12886 internal(ios);
12887 {
12888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12889 std::string ex(str, iter.base());
12890 assert(ex == "*****************0;000000");
12891 assert(ios.width() == 0);
12892 }
12893 }
12894 }
12895 showpoint(ios);
12896 {
12897 ios.imbue(lc);
12898 {
12899 ios.width(0);
12900 {
12901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12902 std::string ex(str, iter.base());
12903 assert(ex == "0.000000");
12904 assert(ios.width() == 0);
12905 }
12906 ios.width(25);
12907 left(ios);
12908 {
12909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12910 std::string ex(str, iter.base());
12911 assert(ex == "0.000000*****************");
12912 assert(ios.width() == 0);
12913 }
12914 ios.width(25);
12915 right(ios);
12916 {
12917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12918 std::string ex(str, iter.base());
12919 assert(ex == "*****************0.000000");
12920 assert(ios.width() == 0);
12921 }
12922 ios.width(25);
12923 internal(ios);
12924 {
12925 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12926 std::string ex(str, iter.base());
12927 assert(ex == "*****************0.000000");
12928 assert(ios.width() == 0);
12929 }
12930 }
12931 ios.imbue(lg);
12932 {
12933 ios.width(0);
12934 {
12935 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12936 std::string ex(str, iter.base());
12937 assert(ex == "0;000000");
12938 assert(ios.width() == 0);
12939 }
12940 ios.width(25);
12941 left(ios);
12942 {
12943 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12944 std::string ex(str, iter.base());
12945 assert(ex == "0;000000*****************");
12946 assert(ios.width() == 0);
12947 }
12948 ios.width(25);
12949 right(ios);
12950 {
12951 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12952 std::string ex(str, iter.base());
12953 assert(ex == "*****************0;000000");
12954 assert(ios.width() == 0);
12955 }
12956 ios.width(25);
12957 internal(ios);
12958 {
12959 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12960 std::string ex(str, iter.base());
12961 assert(ex == "*****************0;000000");
12962 assert(ios.width() == 0);
12963 }
12964 }
12965 }
12966 }
12967 showpos(ios);
12968 {
12969 noshowpoint(ios);
12970 {
12971 ios.imbue(lc);
12972 {
12973 ios.width(0);
12974 {
12975 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12976 std::string ex(str, iter.base());
12977 assert(ex == "+0.000000");
12978 assert(ios.width() == 0);
12979 }
12980 ios.width(25);
12981 left(ios);
12982 {
12983 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12984 std::string ex(str, iter.base());
12985 assert(ex == "+0.000000****************");
12986 assert(ios.width() == 0);
12987 }
12988 ios.width(25);
12989 right(ios);
12990 {
12991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12992 std::string ex(str, iter.base());
12993 assert(ex == "****************+0.000000");
12994 assert(ios.width() == 0);
12995 }
12996 ios.width(25);
12997 internal(ios);
12998 {
12999 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13000 std::string ex(str, iter.base());
13001 assert(ex == "+****************0.000000");
13002 assert(ios.width() == 0);
13003 }
13004 }
13005 ios.imbue(lg);
13006 {
13007 ios.width(0);
13008 {
13009 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13010 std::string ex(str, iter.base());
13011 assert(ex == "+0;000000");
13012 assert(ios.width() == 0);
13013 }
13014 ios.width(25);
13015 left(ios);
13016 {
13017 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13018 std::string ex(str, iter.base());
13019 assert(ex == "+0;000000****************");
13020 assert(ios.width() == 0);
13021 }
13022 ios.width(25);
13023 right(ios);
13024 {
13025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13026 std::string ex(str, iter.base());
13027 assert(ex == "****************+0;000000");
13028 assert(ios.width() == 0);
13029 }
13030 ios.width(25);
13031 internal(ios);
13032 {
13033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13034 std::string ex(str, iter.base());
13035 assert(ex == "+****************0;000000");
13036 assert(ios.width() == 0);
13037 }
13038 }
13039 }
13040 showpoint(ios);
13041 {
13042 ios.imbue(lc);
13043 {
13044 ios.width(0);
13045 {
13046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13047 std::string ex(str, iter.base());
13048 assert(ex == "+0.000000");
13049 assert(ios.width() == 0);
13050 }
13051 ios.width(25);
13052 left(ios);
13053 {
13054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13055 std::string ex(str, iter.base());
13056 assert(ex == "+0.000000****************");
13057 assert(ios.width() == 0);
13058 }
13059 ios.width(25);
13060 right(ios);
13061 {
13062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13063 std::string ex(str, iter.base());
13064 assert(ex == "****************+0.000000");
13065 assert(ios.width() == 0);
13066 }
13067 ios.width(25);
13068 internal(ios);
13069 {
13070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13071 std::string ex(str, iter.base());
13072 assert(ex == "+****************0.000000");
13073 assert(ios.width() == 0);
13074 }
13075 }
13076 ios.imbue(lg);
13077 {
13078 ios.width(0);
13079 {
13080 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13081 std::string ex(str, iter.base());
13082 assert(ex == "+0;000000");
13083 assert(ios.width() == 0);
13084 }
13085 ios.width(25);
13086 left(ios);
13087 {
13088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13089 std::string ex(str, iter.base());
13090 assert(ex == "+0;000000****************");
13091 assert(ios.width() == 0);
13092 }
13093 ios.width(25);
13094 right(ios);
13095 {
13096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13097 std::string ex(str, iter.base());
13098 assert(ex == "****************+0;000000");
13099 assert(ios.width() == 0);
13100 }
13101 ios.width(25);
13102 internal(ios);
13103 {
13104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13105 std::string ex(str, iter.base());
13106 assert(ex == "+****************0;000000");
13107 assert(ios.width() == 0);
13108 }
13109 }
13110 }
13111 }
13112 }
13113 }
13114 ios.precision(16);
13115 {
13116 nouppercase(ios);
13117 {
13118 noshowpos(ios);
13119 {
13120 noshowpoint(ios);
13121 {
13122 ios.imbue(lc);
13123 {
13124 ios.width(0);
13125 {
13126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13127 std::string ex(str, iter.base());
13128 assert(ex == "0.0000000000000000");
13129 assert(ios.width() == 0);
13130 }
13131 ios.width(25);
13132 left(ios);
13133 {
13134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13135 std::string ex(str, iter.base());
13136 assert(ex == "0.0000000000000000*******");
13137 assert(ios.width() == 0);
13138 }
13139 ios.width(25);
13140 right(ios);
13141 {
13142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13143 std::string ex(str, iter.base());
13144 assert(ex == "*******0.0000000000000000");
13145 assert(ios.width() == 0);
13146 }
13147 ios.width(25);
13148 internal(ios);
13149 {
13150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13151 std::string ex(str, iter.base());
13152 assert(ex == "*******0.0000000000000000");
13153 assert(ios.width() == 0);
13154 }
13155 }
13156 ios.imbue(lg);
13157 {
13158 ios.width(0);
13159 {
13160 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13161 std::string ex(str, iter.base());
13162 assert(ex == "0;0000000000000000");
13163 assert(ios.width() == 0);
13164 }
13165 ios.width(25);
13166 left(ios);
13167 {
13168 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13169 std::string ex(str, iter.base());
13170 assert(ex == "0;0000000000000000*******");
13171 assert(ios.width() == 0);
13172 }
13173 ios.width(25);
13174 right(ios);
13175 {
13176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13177 std::string ex(str, iter.base());
13178 assert(ex == "*******0;0000000000000000");
13179 assert(ios.width() == 0);
13180 }
13181 ios.width(25);
13182 internal(ios);
13183 {
13184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13185 std::string ex(str, iter.base());
13186 assert(ex == "*******0;0000000000000000");
13187 assert(ios.width() == 0);
13188 }
13189 }
13190 }
13191 showpoint(ios);
13192 {
13193 ios.imbue(lc);
13194 {
13195 ios.width(0);
13196 {
13197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13198 std::string ex(str, iter.base());
13199 assert(ex == "0.0000000000000000");
13200 assert(ios.width() == 0);
13201 }
13202 ios.width(25);
13203 left(ios);
13204 {
13205 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13206 std::string ex(str, iter.base());
13207 assert(ex == "0.0000000000000000*******");
13208 assert(ios.width() == 0);
13209 }
13210 ios.width(25);
13211 right(ios);
13212 {
13213 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13214 std::string ex(str, iter.base());
13215 assert(ex == "*******0.0000000000000000");
13216 assert(ios.width() == 0);
13217 }
13218 ios.width(25);
13219 internal(ios);
13220 {
13221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13222 std::string ex(str, iter.base());
13223 assert(ex == "*******0.0000000000000000");
13224 assert(ios.width() == 0);
13225 }
13226 }
13227 ios.imbue(lg);
13228 {
13229 ios.width(0);
13230 {
13231 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13232 std::string ex(str, iter.base());
13233 assert(ex == "0;0000000000000000");
13234 assert(ios.width() == 0);
13235 }
13236 ios.width(25);
13237 left(ios);
13238 {
13239 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13240 std::string ex(str, iter.base());
13241 assert(ex == "0;0000000000000000*******");
13242 assert(ios.width() == 0);
13243 }
13244 ios.width(25);
13245 right(ios);
13246 {
13247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13248 std::string ex(str, iter.base());
13249 assert(ex == "*******0;0000000000000000");
13250 assert(ios.width() == 0);
13251 }
13252 ios.width(25);
13253 internal(ios);
13254 {
13255 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13256 std::string ex(str, iter.base());
13257 assert(ex == "*******0;0000000000000000");
13258 assert(ios.width() == 0);
13259 }
13260 }
13261 }
13262 }
13263 showpos(ios);
13264 {
13265 noshowpoint(ios);
13266 {
13267 ios.imbue(lc);
13268 {
13269 ios.width(0);
13270 {
13271 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13272 std::string ex(str, iter.base());
13273 assert(ex == "+0.0000000000000000");
13274 assert(ios.width() == 0);
13275 }
13276 ios.width(25);
13277 left(ios);
13278 {
13279 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13280 std::string ex(str, iter.base());
13281 assert(ex == "+0.0000000000000000******");
13282 assert(ios.width() == 0);
13283 }
13284 ios.width(25);
13285 right(ios);
13286 {
13287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13288 std::string ex(str, iter.base());
13289 assert(ex == "******+0.0000000000000000");
13290 assert(ios.width() == 0);
13291 }
13292 ios.width(25);
13293 internal(ios);
13294 {
13295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13296 std::string ex(str, iter.base());
13297 assert(ex == "+******0.0000000000000000");
13298 assert(ios.width() == 0);
13299 }
13300 }
13301 ios.imbue(lg);
13302 {
13303 ios.width(0);
13304 {
13305 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13306 std::string ex(str, iter.base());
13307 assert(ex == "+0;0000000000000000");
13308 assert(ios.width() == 0);
13309 }
13310 ios.width(25);
13311 left(ios);
13312 {
13313 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13314 std::string ex(str, iter.base());
13315 assert(ex == "+0;0000000000000000******");
13316 assert(ios.width() == 0);
13317 }
13318 ios.width(25);
13319 right(ios);
13320 {
13321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13322 std::string ex(str, iter.base());
13323 assert(ex == "******+0;0000000000000000");
13324 assert(ios.width() == 0);
13325 }
13326 ios.width(25);
13327 internal(ios);
13328 {
13329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13330 std::string ex(str, iter.base());
13331 assert(ex == "+******0;0000000000000000");
13332 assert(ios.width() == 0);
13333 }
13334 }
13335 }
13336 showpoint(ios);
13337 {
13338 ios.imbue(lc);
13339 {
13340 ios.width(0);
13341 {
13342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13343 std::string ex(str, iter.base());
13344 assert(ex == "+0.0000000000000000");
13345 assert(ios.width() == 0);
13346 }
13347 ios.width(25);
13348 left(ios);
13349 {
13350 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13351 std::string ex(str, iter.base());
13352 assert(ex == "+0.0000000000000000******");
13353 assert(ios.width() == 0);
13354 }
13355 ios.width(25);
13356 right(ios);
13357 {
13358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13359 std::string ex(str, iter.base());
13360 assert(ex == "******+0.0000000000000000");
13361 assert(ios.width() == 0);
13362 }
13363 ios.width(25);
13364 internal(ios);
13365 {
13366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13367 std::string ex(str, iter.base());
13368 assert(ex == "+******0.0000000000000000");
13369 assert(ios.width() == 0);
13370 }
13371 }
13372 ios.imbue(lg);
13373 {
13374 ios.width(0);
13375 {
13376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13377 std::string ex(str, iter.base());
13378 assert(ex == "+0;0000000000000000");
13379 assert(ios.width() == 0);
13380 }
13381 ios.width(25);
13382 left(ios);
13383 {
13384 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13385 std::string ex(str, iter.base());
13386 assert(ex == "+0;0000000000000000******");
13387 assert(ios.width() == 0);
13388 }
13389 ios.width(25);
13390 right(ios);
13391 {
13392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13393 std::string ex(str, iter.base());
13394 assert(ex == "******+0;0000000000000000");
13395 assert(ios.width() == 0);
13396 }
13397 ios.width(25);
13398 internal(ios);
13399 {
13400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13401 std::string ex(str, iter.base());
13402 assert(ex == "+******0;0000000000000000");
13403 assert(ios.width() == 0);
13404 }
13405 }
13406 }
13407 }
13408 }
13409 uppercase(ios);
13410 {
13411 noshowpos(ios);
13412 {
13413 noshowpoint(ios);
13414 {
13415 ios.imbue(lc);
13416 {
13417 ios.width(0);
13418 {
13419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13420 std::string ex(str, iter.base());
13421 assert(ex == "0.0000000000000000");
13422 assert(ios.width() == 0);
13423 }
13424 ios.width(25);
13425 left(ios);
13426 {
13427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13428 std::string ex(str, iter.base());
13429 assert(ex == "0.0000000000000000*******");
13430 assert(ios.width() == 0);
13431 }
13432 ios.width(25);
13433 right(ios);
13434 {
13435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13436 std::string ex(str, iter.base());
13437 assert(ex == "*******0.0000000000000000");
13438 assert(ios.width() == 0);
13439 }
13440 ios.width(25);
13441 internal(ios);
13442 {
13443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13444 std::string ex(str, iter.base());
13445 assert(ex == "*******0.0000000000000000");
13446 assert(ios.width() == 0);
13447 }
13448 }
13449 ios.imbue(lg);
13450 {
13451 ios.width(0);
13452 {
13453 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13454 std::string ex(str, iter.base());
13455 assert(ex == "0;0000000000000000");
13456 assert(ios.width() == 0);
13457 }
13458 ios.width(25);
13459 left(ios);
13460 {
13461 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13462 std::string ex(str, iter.base());
13463 assert(ex == "0;0000000000000000*******");
13464 assert(ios.width() == 0);
13465 }
13466 ios.width(25);
13467 right(ios);
13468 {
13469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13470 std::string ex(str, iter.base());
13471 assert(ex == "*******0;0000000000000000");
13472 assert(ios.width() == 0);
13473 }
13474 ios.width(25);
13475 internal(ios);
13476 {
13477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13478 std::string ex(str, iter.base());
13479 assert(ex == "*******0;0000000000000000");
13480 assert(ios.width() == 0);
13481 }
13482 }
13483 }
13484 showpoint(ios);
13485 {
13486 ios.imbue(lc);
13487 {
13488 ios.width(0);
13489 {
13490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13491 std::string ex(str, iter.base());
13492 assert(ex == "0.0000000000000000");
13493 assert(ios.width() == 0);
13494 }
13495 ios.width(25);
13496 left(ios);
13497 {
13498 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13499 std::string ex(str, iter.base());
13500 assert(ex == "0.0000000000000000*******");
13501 assert(ios.width() == 0);
13502 }
13503 ios.width(25);
13504 right(ios);
13505 {
13506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13507 std::string ex(str, iter.base());
13508 assert(ex == "*******0.0000000000000000");
13509 assert(ios.width() == 0);
13510 }
13511 ios.width(25);
13512 internal(ios);
13513 {
13514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13515 std::string ex(str, iter.base());
13516 assert(ex == "*******0.0000000000000000");
13517 assert(ios.width() == 0);
13518 }
13519 }
13520 ios.imbue(lg);
13521 {
13522 ios.width(0);
13523 {
13524 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13525 std::string ex(str, iter.base());
13526 assert(ex == "0;0000000000000000");
13527 assert(ios.width() == 0);
13528 }
13529 ios.width(25);
13530 left(ios);
13531 {
13532 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13533 std::string ex(str, iter.base());
13534 assert(ex == "0;0000000000000000*******");
13535 assert(ios.width() == 0);
13536 }
13537 ios.width(25);
13538 right(ios);
13539 {
13540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13541 std::string ex(str, iter.base());
13542 assert(ex == "*******0;0000000000000000");
13543 assert(ios.width() == 0);
13544 }
13545 ios.width(25);
13546 internal(ios);
13547 {
13548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13549 std::string ex(str, iter.base());
13550 assert(ex == "*******0;0000000000000000");
13551 assert(ios.width() == 0);
13552 }
13553 }
13554 }
13555 }
13556 showpos(ios);
13557 {
13558 noshowpoint(ios);
13559 {
13560 ios.imbue(lc);
13561 {
13562 ios.width(0);
13563 {
13564 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13565 std::string ex(str, iter.base());
13566 assert(ex == "+0.0000000000000000");
13567 assert(ios.width() == 0);
13568 }
13569 ios.width(25);
13570 left(ios);
13571 {
13572 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13573 std::string ex(str, iter.base());
13574 assert(ex == "+0.0000000000000000******");
13575 assert(ios.width() == 0);
13576 }
13577 ios.width(25);
13578 right(ios);
13579 {
13580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13581 std::string ex(str, iter.base());
13582 assert(ex == "******+0.0000000000000000");
13583 assert(ios.width() == 0);
13584 }
13585 ios.width(25);
13586 internal(ios);
13587 {
13588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13589 std::string ex(str, iter.base());
13590 assert(ex == "+******0.0000000000000000");
13591 assert(ios.width() == 0);
13592 }
13593 }
13594 ios.imbue(lg);
13595 {
13596 ios.width(0);
13597 {
13598 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13599 std::string ex(str, iter.base());
13600 assert(ex == "+0;0000000000000000");
13601 assert(ios.width() == 0);
13602 }
13603 ios.width(25);
13604 left(ios);
13605 {
13606 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13607 std::string ex(str, iter.base());
13608 assert(ex == "+0;0000000000000000******");
13609 assert(ios.width() == 0);
13610 }
13611 ios.width(25);
13612 right(ios);
13613 {
13614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13615 std::string ex(str, iter.base());
13616 assert(ex == "******+0;0000000000000000");
13617 assert(ios.width() == 0);
13618 }
13619 ios.width(25);
13620 internal(ios);
13621 {
13622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13623 std::string ex(str, iter.base());
13624 assert(ex == "+******0;0000000000000000");
13625 assert(ios.width() == 0);
13626 }
13627 }
13628 }
13629 showpoint(ios);
13630 {
13631 ios.imbue(lc);
13632 {
13633 ios.width(0);
13634 {
13635 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13636 std::string ex(str, iter.base());
13637 assert(ex == "+0.0000000000000000");
13638 assert(ios.width() == 0);
13639 }
13640 ios.width(25);
13641 left(ios);
13642 {
13643 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13644 std::string ex(str, iter.base());
13645 assert(ex == "+0.0000000000000000******");
13646 assert(ios.width() == 0);
13647 }
13648 ios.width(25);
13649 right(ios);
13650 {
13651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13652 std::string ex(str, iter.base());
13653 assert(ex == "******+0.0000000000000000");
13654 assert(ios.width() == 0);
13655 }
13656 ios.width(25);
13657 internal(ios);
13658 {
13659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13660 std::string ex(str, iter.base());
13661 assert(ex == "+******0.0000000000000000");
13662 assert(ios.width() == 0);
13663 }
13664 }
13665 ios.imbue(lg);
13666 {
13667 ios.width(0);
13668 {
13669 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13670 std::string ex(str, iter.base());
13671 assert(ex == "+0;0000000000000000");
13672 assert(ios.width() == 0);
13673 }
13674 ios.width(25);
13675 left(ios);
13676 {
13677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13678 std::string ex(str, iter.base());
13679 assert(ex == "+0;0000000000000000******");
13680 assert(ios.width() == 0);
13681 }
13682 ios.width(25);
13683 right(ios);
13684 {
13685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13686 std::string ex(str, iter.base());
13687 assert(ex == "******+0;0000000000000000");
13688 assert(ios.width() == 0);
13689 }
13690 ios.width(25);
13691 internal(ios);
13692 {
13693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13694 std::string ex(str, iter.base());
13695 assert(ex == "+******0;0000000000000000");
13696 assert(ios.width() == 0);
13697 }
13698 }
13699 }
13700 }
13701 }
13702 }
13703 ios.precision(60);
13704 {
13705 nouppercase(ios);
13706 {
13707 noshowpos(ios);
13708 {
13709 noshowpoint(ios);
13710 {
13711 ios.imbue(lc);
13712 {
13713 ios.width(0);
13714 {
13715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13716 std::string ex(str, iter.base());
13717 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13718 assert(ios.width() == 0);
13719 }
13720 ios.width(25);
13721 left(ios);
13722 {
13723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13724 std::string ex(str, iter.base());
13725 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13726 assert(ios.width() == 0);
13727 }
13728 ios.width(25);
13729 right(ios);
13730 {
13731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13732 std::string ex(str, iter.base());
13733 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13734 assert(ios.width() == 0);
13735 }
13736 ios.width(25);
13737 internal(ios);
13738 {
13739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13740 std::string ex(str, iter.base());
13741 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13742 assert(ios.width() == 0);
13743 }
13744 }
13745 ios.imbue(lg);
13746 {
13747 ios.width(0);
13748 {
13749 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13750 std::string ex(str, iter.base());
13751 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13752 assert(ios.width() == 0);
13753 }
13754 ios.width(25);
13755 left(ios);
13756 {
13757 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13758 std::string ex(str, iter.base());
13759 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13760 assert(ios.width() == 0);
13761 }
13762 ios.width(25);
13763 right(ios);
13764 {
13765 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13766 std::string ex(str, iter.base());
13767 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13768 assert(ios.width() == 0);
13769 }
13770 ios.width(25);
13771 internal(ios);
13772 {
13773 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13774 std::string ex(str, iter.base());
13775 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13776 assert(ios.width() == 0);
13777 }
13778 }
13779 }
13780 showpoint(ios);
13781 {
13782 ios.imbue(lc);
13783 {
13784 ios.width(0);
13785 {
13786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13787 std::string ex(str, iter.base());
13788 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13789 assert(ios.width() == 0);
13790 }
13791 ios.width(25);
13792 left(ios);
13793 {
13794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13795 std::string ex(str, iter.base());
13796 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13797 assert(ios.width() == 0);
13798 }
13799 ios.width(25);
13800 right(ios);
13801 {
13802 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13803 std::string ex(str, iter.base());
13804 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13805 assert(ios.width() == 0);
13806 }
13807 ios.width(25);
13808 internal(ios);
13809 {
13810 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13811 std::string ex(str, iter.base());
13812 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13813 assert(ios.width() == 0);
13814 }
13815 }
13816 ios.imbue(lg);
13817 {
13818 ios.width(0);
13819 {
13820 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13821 std::string ex(str, iter.base());
13822 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13823 assert(ios.width() == 0);
13824 }
13825 ios.width(25);
13826 left(ios);
13827 {
13828 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13829 std::string ex(str, iter.base());
13830 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13831 assert(ios.width() == 0);
13832 }
13833 ios.width(25);
13834 right(ios);
13835 {
13836 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13837 std::string ex(str, iter.base());
13838 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13839 assert(ios.width() == 0);
13840 }
13841 ios.width(25);
13842 internal(ios);
13843 {
13844 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13845 std::string ex(str, iter.base());
13846 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13847 assert(ios.width() == 0);
13848 }
13849 }
13850 }
13851 }
13852 showpos(ios);
13853 {
13854 noshowpoint(ios);
13855 {
13856 ios.imbue(lc);
13857 {
13858 ios.width(0);
13859 {
13860 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13861 std::string ex(str, iter.base());
13862 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13863 assert(ios.width() == 0);
13864 }
13865 ios.width(25);
13866 left(ios);
13867 {
13868 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13869 std::string ex(str, iter.base());
13870 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13871 assert(ios.width() == 0);
13872 }
13873 ios.width(25);
13874 right(ios);
13875 {
13876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13877 std::string ex(str, iter.base());
13878 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13879 assert(ios.width() == 0);
13880 }
13881 ios.width(25);
13882 internal(ios);
13883 {
13884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13885 std::string ex(str, iter.base());
13886 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13887 assert(ios.width() == 0);
13888 }
13889 }
13890 ios.imbue(lg);
13891 {
13892 ios.width(0);
13893 {
13894 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13895 std::string ex(str, iter.base());
13896 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13897 assert(ios.width() == 0);
13898 }
13899 ios.width(25);
13900 left(ios);
13901 {
13902 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13903 std::string ex(str, iter.base());
13904 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13905 assert(ios.width() == 0);
13906 }
13907 ios.width(25);
13908 right(ios);
13909 {
13910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13911 std::string ex(str, iter.base());
13912 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13913 assert(ios.width() == 0);
13914 }
13915 ios.width(25);
13916 internal(ios);
13917 {
13918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13919 std::string ex(str, iter.base());
13920 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13921 assert(ios.width() == 0);
13922 }
13923 }
13924 }
13925 showpoint(ios);
13926 {
13927 ios.imbue(lc);
13928 {
13929 ios.width(0);
13930 {
13931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13932 std::string ex(str, iter.base());
13933 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13934 assert(ios.width() == 0);
13935 }
13936 ios.width(25);
13937 left(ios);
13938 {
13939 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13940 std::string ex(str, iter.base());
13941 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13942 assert(ios.width() == 0);
13943 }
13944 ios.width(25);
13945 right(ios);
13946 {
13947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13948 std::string ex(str, iter.base());
13949 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13950 assert(ios.width() == 0);
13951 }
13952 ios.width(25);
13953 internal(ios);
13954 {
13955 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13956 std::string ex(str, iter.base());
13957 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13958 assert(ios.width() == 0);
13959 }
13960 }
13961 ios.imbue(lg);
13962 {
13963 ios.width(0);
13964 {
13965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13966 std::string ex(str, iter.base());
13967 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13968 assert(ios.width() == 0);
13969 }
13970 ios.width(25);
13971 left(ios);
13972 {
13973 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13974 std::string ex(str, iter.base());
13975 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13976 assert(ios.width() == 0);
13977 }
13978 ios.width(25);
13979 right(ios);
13980 {
13981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13982 std::string ex(str, iter.base());
13983 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13984 assert(ios.width() == 0);
13985 }
13986 ios.width(25);
13987 internal(ios);
13988 {
13989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13990 std::string ex(str, iter.base());
13991 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13992 assert(ios.width() == 0);
13993 }
13994 }
13995 }
13996 }
13997 }
13998 uppercase(ios);
13999 {
14000 noshowpos(ios);
14001 {
14002 noshowpoint(ios);
14003 {
14004 ios.imbue(lc);
14005 {
14006 ios.width(0);
14007 {
14008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14009 std::string ex(str, iter.base());
14010 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14011 assert(ios.width() == 0);
14012 }
14013 ios.width(25);
14014 left(ios);
14015 {
14016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14017 std::string ex(str, iter.base());
14018 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14019 assert(ios.width() == 0);
14020 }
14021 ios.width(25);
14022 right(ios);
14023 {
14024 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14025 std::string ex(str, iter.base());
14026 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14027 assert(ios.width() == 0);
14028 }
14029 ios.width(25);
14030 internal(ios);
14031 {
14032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14033 std::string ex(str, iter.base());
14034 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14035 assert(ios.width() == 0);
14036 }
14037 }
14038 ios.imbue(lg);
14039 {
14040 ios.width(0);
14041 {
14042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14043 std::string ex(str, iter.base());
14044 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14045 assert(ios.width() == 0);
14046 }
14047 ios.width(25);
14048 left(ios);
14049 {
14050 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14051 std::string ex(str, iter.base());
14052 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14053 assert(ios.width() == 0);
14054 }
14055 ios.width(25);
14056 right(ios);
14057 {
14058 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14059 std::string ex(str, iter.base());
14060 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14061 assert(ios.width() == 0);
14062 }
14063 ios.width(25);
14064 internal(ios);
14065 {
14066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14067 std::string ex(str, iter.base());
14068 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14069 assert(ios.width() == 0);
14070 }
14071 }
14072 }
14073 showpoint(ios);
14074 {
14075 ios.imbue(lc);
14076 {
14077 ios.width(0);
14078 {
14079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14080 std::string ex(str, iter.base());
14081 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14082 assert(ios.width() == 0);
14083 }
14084 ios.width(25);
14085 left(ios);
14086 {
14087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14088 std::string ex(str, iter.base());
14089 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14090 assert(ios.width() == 0);
14091 }
14092 ios.width(25);
14093 right(ios);
14094 {
14095 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14096 std::string ex(str, iter.base());
14097 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14098 assert(ios.width() == 0);
14099 }
14100 ios.width(25);
14101 internal(ios);
14102 {
14103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14104 std::string ex(str, iter.base());
14105 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14106 assert(ios.width() == 0);
14107 }
14108 }
14109 ios.imbue(lg);
14110 {
14111 ios.width(0);
14112 {
14113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14114 std::string ex(str, iter.base());
14115 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14116 assert(ios.width() == 0);
14117 }
14118 ios.width(25);
14119 left(ios);
14120 {
14121 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14122 std::string ex(str, iter.base());
14123 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14124 assert(ios.width() == 0);
14125 }
14126 ios.width(25);
14127 right(ios);
14128 {
14129 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14130 std::string ex(str, iter.base());
14131 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14132 assert(ios.width() == 0);
14133 }
14134 ios.width(25);
14135 internal(ios);
14136 {
14137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14138 std::string ex(str, iter.base());
14139 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14140 assert(ios.width() == 0);
14141 }
14142 }
14143 }
14144 }
14145 showpos(ios);
14146 {
14147 noshowpoint(ios);
14148 {
14149 ios.imbue(lc);
14150 {
14151 ios.width(0);
14152 {
14153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14154 std::string ex(str, iter.base());
14155 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14156 assert(ios.width() == 0);
14157 }
14158 ios.width(25);
14159 left(ios);
14160 {
14161 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14162 std::string ex(str, iter.base());
14163 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14164 assert(ios.width() == 0);
14165 }
14166 ios.width(25);
14167 right(ios);
14168 {
14169 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14170 std::string ex(str, iter.base());
14171 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14172 assert(ios.width() == 0);
14173 }
14174 ios.width(25);
14175 internal(ios);
14176 {
14177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14178 std::string ex(str, iter.base());
14179 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14180 assert(ios.width() == 0);
14181 }
14182 }
14183 ios.imbue(lg);
14184 {
14185 ios.width(0);
14186 {
14187 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14188 std::string ex(str, iter.base());
14189 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14190 assert(ios.width() == 0);
14191 }
14192 ios.width(25);
14193 left(ios);
14194 {
14195 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14196 std::string ex(str, iter.base());
14197 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14198 assert(ios.width() == 0);
14199 }
14200 ios.width(25);
14201 right(ios);
14202 {
14203 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14204 std::string ex(str, iter.base());
14205 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14206 assert(ios.width() == 0);
14207 }
14208 ios.width(25);
14209 internal(ios);
14210 {
14211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14212 std::string ex(str, iter.base());
14213 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14214 assert(ios.width() == 0);
14215 }
14216 }
14217 }
14218 showpoint(ios);
14219 {
14220 ios.imbue(lc);
14221 {
14222 ios.width(0);
14223 {
14224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14225 std::string ex(str, iter.base());
14226 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14227 assert(ios.width() == 0);
14228 }
14229 ios.width(25);
14230 left(ios);
14231 {
14232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14233 std::string ex(str, iter.base());
14234 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14235 assert(ios.width() == 0);
14236 }
14237 ios.width(25);
14238 right(ios);
14239 {
14240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14241 std::string ex(str, iter.base());
14242 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14243 assert(ios.width() == 0);
14244 }
14245 ios.width(25);
14246 internal(ios);
14247 {
14248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14249 std::string ex(str, iter.base());
14250 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14251 assert(ios.width() == 0);
14252 }
14253 }
14254 ios.imbue(lg);
14255 {
14256 ios.width(0);
14257 {
14258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14259 std::string ex(str, iter.base());
14260 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14261 assert(ios.width() == 0);
14262 }
14263 ios.width(25);
14264 left(ios);
14265 {
14266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14267 std::string ex(str, iter.base());
14268 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14269 assert(ios.width() == 0);
14270 }
14271 ios.width(25);
14272 right(ios);
14273 {
14274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14275 std::string ex(str, iter.base());
14276 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14277 assert(ios.width() == 0);
14278 }
14279 ios.width(25);
14280 internal(ios);
14281 {
14282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14283 std::string ex(str, iter.base());
14284 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14285 assert(ios.width() == 0);
14286 }
14287 }
14288 }
14289 }
14290 }
14291 }
14292 }
14293 }
14294 }
14295
test7()14296 void test7()
14297 {
14298 char str[200];
14299 output_iterator<char*> iter;
14300 std::locale lc = std::locale::classic();
14301 std::locale lg(lc, new my_numpunct);
14302 const my_facet f(1);
14303 {
14304 long double v = -0.;
14305 std::ios ios(0);
14306 fixed(ios);
14307 // %f
14308 {
14309 ios.precision(0);
14310 {
14311 nouppercase(ios);
14312 {
14313 noshowpos(ios);
14314 {
14315 noshowpoint(ios);
14316 {
14317 ios.imbue(lc);
14318 {
14319 ios.width(0);
14320 {
14321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14322 std::string ex(str, iter.base());
14323 assert(ex == "-0");
14324 assert(ios.width() == 0);
14325 }
14326 ios.width(25);
14327 left(ios);
14328 {
14329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14330 std::string ex(str, iter.base());
14331 assert(ex == "-0***********************");
14332 assert(ios.width() == 0);
14333 }
14334 ios.width(25);
14335 right(ios);
14336 {
14337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14338 std::string ex(str, iter.base());
14339 assert(ex == "***********************-0");
14340 assert(ios.width() == 0);
14341 }
14342 ios.width(25);
14343 internal(ios);
14344 {
14345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14346 std::string ex(str, iter.base());
14347 assert(ex == "-***********************0");
14348 assert(ios.width() == 0);
14349 }
14350 }
14351 ios.imbue(lg);
14352 {
14353 ios.width(0);
14354 {
14355 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14356 std::string ex(str, iter.base());
14357 assert(ex == "-0");
14358 assert(ios.width() == 0);
14359 }
14360 ios.width(25);
14361 left(ios);
14362 {
14363 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14364 std::string ex(str, iter.base());
14365 assert(ex == "-0***********************");
14366 assert(ios.width() == 0);
14367 }
14368 ios.width(25);
14369 right(ios);
14370 {
14371 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14372 std::string ex(str, iter.base());
14373 assert(ex == "***********************-0");
14374 assert(ios.width() == 0);
14375 }
14376 ios.width(25);
14377 internal(ios);
14378 {
14379 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14380 std::string ex(str, iter.base());
14381 assert(ex == "-***********************0");
14382 assert(ios.width() == 0);
14383 }
14384 }
14385 }
14386 showpoint(ios);
14387 {
14388 ios.imbue(lc);
14389 {
14390 ios.width(0);
14391 {
14392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14393 std::string ex(str, iter.base());
14394 assert(ex == "-0.");
14395 assert(ios.width() == 0);
14396 }
14397 ios.width(25);
14398 left(ios);
14399 {
14400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14401 std::string ex(str, iter.base());
14402 assert(ex == "-0.**********************");
14403 assert(ios.width() == 0);
14404 }
14405 ios.width(25);
14406 right(ios);
14407 {
14408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14409 std::string ex(str, iter.base());
14410 assert(ex == "**********************-0.");
14411 assert(ios.width() == 0);
14412 }
14413 ios.width(25);
14414 internal(ios);
14415 {
14416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14417 std::string ex(str, iter.base());
14418 assert(ex == "-**********************0.");
14419 assert(ios.width() == 0);
14420 }
14421 }
14422 ios.imbue(lg);
14423 {
14424 ios.width(0);
14425 {
14426 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14427 std::string ex(str, iter.base());
14428 assert(ex == "-0;");
14429 assert(ios.width() == 0);
14430 }
14431 ios.width(25);
14432 left(ios);
14433 {
14434 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14435 std::string ex(str, iter.base());
14436 assert(ex == "-0;**********************");
14437 assert(ios.width() == 0);
14438 }
14439 ios.width(25);
14440 right(ios);
14441 {
14442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14443 std::string ex(str, iter.base());
14444 assert(ex == "**********************-0;");
14445 assert(ios.width() == 0);
14446 }
14447 ios.width(25);
14448 internal(ios);
14449 {
14450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14451 std::string ex(str, iter.base());
14452 assert(ex == "-**********************0;");
14453 assert(ios.width() == 0);
14454 }
14455 }
14456 }
14457 }
14458 showpos(ios);
14459 {
14460 noshowpoint(ios);
14461 {
14462 ios.imbue(lc);
14463 {
14464 ios.width(0);
14465 {
14466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14467 std::string ex(str, iter.base());
14468 assert(ex == "-0");
14469 assert(ios.width() == 0);
14470 }
14471 ios.width(25);
14472 left(ios);
14473 {
14474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14475 std::string ex(str, iter.base());
14476 assert(ex == "-0***********************");
14477 assert(ios.width() == 0);
14478 }
14479 ios.width(25);
14480 right(ios);
14481 {
14482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14483 std::string ex(str, iter.base());
14484 assert(ex == "***********************-0");
14485 assert(ios.width() == 0);
14486 }
14487 ios.width(25);
14488 internal(ios);
14489 {
14490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14491 std::string ex(str, iter.base());
14492 assert(ex == "-***********************0");
14493 assert(ios.width() == 0);
14494 }
14495 }
14496 ios.imbue(lg);
14497 {
14498 ios.width(0);
14499 {
14500 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14501 std::string ex(str, iter.base());
14502 assert(ex == "-0");
14503 assert(ios.width() == 0);
14504 }
14505 ios.width(25);
14506 left(ios);
14507 {
14508 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14509 std::string ex(str, iter.base());
14510 assert(ex == "-0***********************");
14511 assert(ios.width() == 0);
14512 }
14513 ios.width(25);
14514 right(ios);
14515 {
14516 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14517 std::string ex(str, iter.base());
14518 assert(ex == "***********************-0");
14519 assert(ios.width() == 0);
14520 }
14521 ios.width(25);
14522 internal(ios);
14523 {
14524 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14525 std::string ex(str, iter.base());
14526 assert(ex == "-***********************0");
14527 assert(ios.width() == 0);
14528 }
14529 }
14530 }
14531 showpoint(ios);
14532 {
14533 ios.imbue(lc);
14534 {
14535 ios.width(0);
14536 {
14537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14538 std::string ex(str, iter.base());
14539 assert(ex == "-0.");
14540 assert(ios.width() == 0);
14541 }
14542 ios.width(25);
14543 left(ios);
14544 {
14545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14546 std::string ex(str, iter.base());
14547 assert(ex == "-0.**********************");
14548 assert(ios.width() == 0);
14549 }
14550 ios.width(25);
14551 right(ios);
14552 {
14553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14554 std::string ex(str, iter.base());
14555 assert(ex == "**********************-0.");
14556 assert(ios.width() == 0);
14557 }
14558 ios.width(25);
14559 internal(ios);
14560 {
14561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14562 std::string ex(str, iter.base());
14563 assert(ex == "-**********************0.");
14564 assert(ios.width() == 0);
14565 }
14566 }
14567 ios.imbue(lg);
14568 {
14569 ios.width(0);
14570 {
14571 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14572 std::string ex(str, iter.base());
14573 assert(ex == "-0;");
14574 assert(ios.width() == 0);
14575 }
14576 ios.width(25);
14577 left(ios);
14578 {
14579 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14580 std::string ex(str, iter.base());
14581 assert(ex == "-0;**********************");
14582 assert(ios.width() == 0);
14583 }
14584 ios.width(25);
14585 right(ios);
14586 {
14587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14588 std::string ex(str, iter.base());
14589 assert(ex == "**********************-0;");
14590 assert(ios.width() == 0);
14591 }
14592 ios.width(25);
14593 internal(ios);
14594 {
14595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14596 std::string ex(str, iter.base());
14597 assert(ex == "-**********************0;");
14598 assert(ios.width() == 0);
14599 }
14600 }
14601 }
14602 }
14603 }
14604 uppercase(ios);
14605 {
14606 noshowpos(ios);
14607 {
14608 noshowpoint(ios);
14609 {
14610 ios.imbue(lc);
14611 {
14612 ios.width(0);
14613 {
14614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14615 std::string ex(str, iter.base());
14616 assert(ex == "-0");
14617 assert(ios.width() == 0);
14618 }
14619 ios.width(25);
14620 left(ios);
14621 {
14622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14623 std::string ex(str, iter.base());
14624 assert(ex == "-0***********************");
14625 assert(ios.width() == 0);
14626 }
14627 ios.width(25);
14628 right(ios);
14629 {
14630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14631 std::string ex(str, iter.base());
14632 assert(ex == "***********************-0");
14633 assert(ios.width() == 0);
14634 }
14635 ios.width(25);
14636 internal(ios);
14637 {
14638 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14639 std::string ex(str, iter.base());
14640 assert(ex == "-***********************0");
14641 assert(ios.width() == 0);
14642 }
14643 }
14644 ios.imbue(lg);
14645 {
14646 ios.width(0);
14647 {
14648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14649 std::string ex(str, iter.base());
14650 assert(ex == "-0");
14651 assert(ios.width() == 0);
14652 }
14653 ios.width(25);
14654 left(ios);
14655 {
14656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14657 std::string ex(str, iter.base());
14658 assert(ex == "-0***********************");
14659 assert(ios.width() == 0);
14660 }
14661 ios.width(25);
14662 right(ios);
14663 {
14664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14665 std::string ex(str, iter.base());
14666 assert(ex == "***********************-0");
14667 assert(ios.width() == 0);
14668 }
14669 ios.width(25);
14670 internal(ios);
14671 {
14672 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14673 std::string ex(str, iter.base());
14674 assert(ex == "-***********************0");
14675 assert(ios.width() == 0);
14676 }
14677 }
14678 }
14679 showpoint(ios);
14680 {
14681 ios.imbue(lc);
14682 {
14683 ios.width(0);
14684 {
14685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14686 std::string ex(str, iter.base());
14687 assert(ex == "-0.");
14688 assert(ios.width() == 0);
14689 }
14690 ios.width(25);
14691 left(ios);
14692 {
14693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14694 std::string ex(str, iter.base());
14695 assert(ex == "-0.**********************");
14696 assert(ios.width() == 0);
14697 }
14698 ios.width(25);
14699 right(ios);
14700 {
14701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14702 std::string ex(str, iter.base());
14703 assert(ex == "**********************-0.");
14704 assert(ios.width() == 0);
14705 }
14706 ios.width(25);
14707 internal(ios);
14708 {
14709 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14710 std::string ex(str, iter.base());
14711 assert(ex == "-**********************0.");
14712 assert(ios.width() == 0);
14713 }
14714 }
14715 ios.imbue(lg);
14716 {
14717 ios.width(0);
14718 {
14719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14720 std::string ex(str, iter.base());
14721 assert(ex == "-0;");
14722 assert(ios.width() == 0);
14723 }
14724 ios.width(25);
14725 left(ios);
14726 {
14727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14728 std::string ex(str, iter.base());
14729 assert(ex == "-0;**********************");
14730 assert(ios.width() == 0);
14731 }
14732 ios.width(25);
14733 right(ios);
14734 {
14735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14736 std::string ex(str, iter.base());
14737 assert(ex == "**********************-0;");
14738 assert(ios.width() == 0);
14739 }
14740 ios.width(25);
14741 internal(ios);
14742 {
14743 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14744 std::string ex(str, iter.base());
14745 assert(ex == "-**********************0;");
14746 assert(ios.width() == 0);
14747 }
14748 }
14749 }
14750 }
14751 showpos(ios);
14752 {
14753 noshowpoint(ios);
14754 {
14755 ios.imbue(lc);
14756 {
14757 ios.width(0);
14758 {
14759 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14760 std::string ex(str, iter.base());
14761 assert(ex == "-0");
14762 assert(ios.width() == 0);
14763 }
14764 ios.width(25);
14765 left(ios);
14766 {
14767 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14768 std::string ex(str, iter.base());
14769 assert(ex == "-0***********************");
14770 assert(ios.width() == 0);
14771 }
14772 ios.width(25);
14773 right(ios);
14774 {
14775 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14776 std::string ex(str, iter.base());
14777 assert(ex == "***********************-0");
14778 assert(ios.width() == 0);
14779 }
14780 ios.width(25);
14781 internal(ios);
14782 {
14783 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14784 std::string ex(str, iter.base());
14785 assert(ex == "-***********************0");
14786 assert(ios.width() == 0);
14787 }
14788 }
14789 ios.imbue(lg);
14790 {
14791 ios.width(0);
14792 {
14793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14794 std::string ex(str, iter.base());
14795 assert(ex == "-0");
14796 assert(ios.width() == 0);
14797 }
14798 ios.width(25);
14799 left(ios);
14800 {
14801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14802 std::string ex(str, iter.base());
14803 assert(ex == "-0***********************");
14804 assert(ios.width() == 0);
14805 }
14806 ios.width(25);
14807 right(ios);
14808 {
14809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14810 std::string ex(str, iter.base());
14811 assert(ex == "***********************-0");
14812 assert(ios.width() == 0);
14813 }
14814 ios.width(25);
14815 internal(ios);
14816 {
14817 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14818 std::string ex(str, iter.base());
14819 assert(ex == "-***********************0");
14820 assert(ios.width() == 0);
14821 }
14822 }
14823 }
14824 showpoint(ios);
14825 {
14826 ios.imbue(lc);
14827 {
14828 ios.width(0);
14829 {
14830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14831 std::string ex(str, iter.base());
14832 assert(ex == "-0.");
14833 assert(ios.width() == 0);
14834 }
14835 ios.width(25);
14836 left(ios);
14837 {
14838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14839 std::string ex(str, iter.base());
14840 assert(ex == "-0.**********************");
14841 assert(ios.width() == 0);
14842 }
14843 ios.width(25);
14844 right(ios);
14845 {
14846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14847 std::string ex(str, iter.base());
14848 assert(ex == "**********************-0.");
14849 assert(ios.width() == 0);
14850 }
14851 ios.width(25);
14852 internal(ios);
14853 {
14854 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14855 std::string ex(str, iter.base());
14856 assert(ex == "-**********************0.");
14857 assert(ios.width() == 0);
14858 }
14859 }
14860 ios.imbue(lg);
14861 {
14862 ios.width(0);
14863 {
14864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14865 std::string ex(str, iter.base());
14866 assert(ex == "-0;");
14867 assert(ios.width() == 0);
14868 }
14869 ios.width(25);
14870 left(ios);
14871 {
14872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14873 std::string ex(str, iter.base());
14874 assert(ex == "-0;**********************");
14875 assert(ios.width() == 0);
14876 }
14877 ios.width(25);
14878 right(ios);
14879 {
14880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14881 std::string ex(str, iter.base());
14882 assert(ex == "**********************-0;");
14883 assert(ios.width() == 0);
14884 }
14885 ios.width(25);
14886 internal(ios);
14887 {
14888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14889 std::string ex(str, iter.base());
14890 assert(ex == "-**********************0;");
14891 assert(ios.width() == 0);
14892 }
14893 }
14894 }
14895 }
14896 }
14897 }
14898 ios.precision(1);
14899 {
14900 nouppercase(ios);
14901 {
14902 noshowpos(ios);
14903 {
14904 noshowpoint(ios);
14905 {
14906 ios.imbue(lc);
14907 {
14908 ios.width(0);
14909 {
14910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14911 std::string ex(str, iter.base());
14912 assert(ex == "-0.0");
14913 assert(ios.width() == 0);
14914 }
14915 ios.width(25);
14916 left(ios);
14917 {
14918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14919 std::string ex(str, iter.base());
14920 assert(ex == "-0.0*********************");
14921 assert(ios.width() == 0);
14922 }
14923 ios.width(25);
14924 right(ios);
14925 {
14926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14927 std::string ex(str, iter.base());
14928 assert(ex == "*********************-0.0");
14929 assert(ios.width() == 0);
14930 }
14931 ios.width(25);
14932 internal(ios);
14933 {
14934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14935 std::string ex(str, iter.base());
14936 assert(ex == "-*********************0.0");
14937 assert(ios.width() == 0);
14938 }
14939 }
14940 ios.imbue(lg);
14941 {
14942 ios.width(0);
14943 {
14944 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14945 std::string ex(str, iter.base());
14946 assert(ex == "-0;0");
14947 assert(ios.width() == 0);
14948 }
14949 ios.width(25);
14950 left(ios);
14951 {
14952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14953 std::string ex(str, iter.base());
14954 assert(ex == "-0;0*********************");
14955 assert(ios.width() == 0);
14956 }
14957 ios.width(25);
14958 right(ios);
14959 {
14960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14961 std::string ex(str, iter.base());
14962 assert(ex == "*********************-0;0");
14963 assert(ios.width() == 0);
14964 }
14965 ios.width(25);
14966 internal(ios);
14967 {
14968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14969 std::string ex(str, iter.base());
14970 assert(ex == "-*********************0;0");
14971 assert(ios.width() == 0);
14972 }
14973 }
14974 }
14975 showpoint(ios);
14976 {
14977 ios.imbue(lc);
14978 {
14979 ios.width(0);
14980 {
14981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14982 std::string ex(str, iter.base());
14983 assert(ex == "-0.0");
14984 assert(ios.width() == 0);
14985 }
14986 ios.width(25);
14987 left(ios);
14988 {
14989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14990 std::string ex(str, iter.base());
14991 assert(ex == "-0.0*********************");
14992 assert(ios.width() == 0);
14993 }
14994 ios.width(25);
14995 right(ios);
14996 {
14997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14998 std::string ex(str, iter.base());
14999 assert(ex == "*********************-0.0");
15000 assert(ios.width() == 0);
15001 }
15002 ios.width(25);
15003 internal(ios);
15004 {
15005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15006 std::string ex(str, iter.base());
15007 assert(ex == "-*********************0.0");
15008 assert(ios.width() == 0);
15009 }
15010 }
15011 ios.imbue(lg);
15012 {
15013 ios.width(0);
15014 {
15015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15016 std::string ex(str, iter.base());
15017 assert(ex == "-0;0");
15018 assert(ios.width() == 0);
15019 }
15020 ios.width(25);
15021 left(ios);
15022 {
15023 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15024 std::string ex(str, iter.base());
15025 assert(ex == "-0;0*********************");
15026 assert(ios.width() == 0);
15027 }
15028 ios.width(25);
15029 right(ios);
15030 {
15031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15032 std::string ex(str, iter.base());
15033 assert(ex == "*********************-0;0");
15034 assert(ios.width() == 0);
15035 }
15036 ios.width(25);
15037 internal(ios);
15038 {
15039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15040 std::string ex(str, iter.base());
15041 assert(ex == "-*********************0;0");
15042 assert(ios.width() == 0);
15043 }
15044 }
15045 }
15046 }
15047 showpos(ios);
15048 {
15049 noshowpoint(ios);
15050 {
15051 ios.imbue(lc);
15052 {
15053 ios.width(0);
15054 {
15055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15056 std::string ex(str, iter.base());
15057 assert(ex == "-0.0");
15058 assert(ios.width() == 0);
15059 }
15060 ios.width(25);
15061 left(ios);
15062 {
15063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15064 std::string ex(str, iter.base());
15065 assert(ex == "-0.0*********************");
15066 assert(ios.width() == 0);
15067 }
15068 ios.width(25);
15069 right(ios);
15070 {
15071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15072 std::string ex(str, iter.base());
15073 assert(ex == "*********************-0.0");
15074 assert(ios.width() == 0);
15075 }
15076 ios.width(25);
15077 internal(ios);
15078 {
15079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15080 std::string ex(str, iter.base());
15081 assert(ex == "-*********************0.0");
15082 assert(ios.width() == 0);
15083 }
15084 }
15085 ios.imbue(lg);
15086 {
15087 ios.width(0);
15088 {
15089 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15090 std::string ex(str, iter.base());
15091 assert(ex == "-0;0");
15092 assert(ios.width() == 0);
15093 }
15094 ios.width(25);
15095 left(ios);
15096 {
15097 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15098 std::string ex(str, iter.base());
15099 assert(ex == "-0;0*********************");
15100 assert(ios.width() == 0);
15101 }
15102 ios.width(25);
15103 right(ios);
15104 {
15105 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15106 std::string ex(str, iter.base());
15107 assert(ex == "*********************-0;0");
15108 assert(ios.width() == 0);
15109 }
15110 ios.width(25);
15111 internal(ios);
15112 {
15113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15114 std::string ex(str, iter.base());
15115 assert(ex == "-*********************0;0");
15116 assert(ios.width() == 0);
15117 }
15118 }
15119 }
15120 showpoint(ios);
15121 {
15122 ios.imbue(lc);
15123 {
15124 ios.width(0);
15125 {
15126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15127 std::string ex(str, iter.base());
15128 assert(ex == "-0.0");
15129 assert(ios.width() == 0);
15130 }
15131 ios.width(25);
15132 left(ios);
15133 {
15134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15135 std::string ex(str, iter.base());
15136 assert(ex == "-0.0*********************");
15137 assert(ios.width() == 0);
15138 }
15139 ios.width(25);
15140 right(ios);
15141 {
15142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15143 std::string ex(str, iter.base());
15144 assert(ex == "*********************-0.0");
15145 assert(ios.width() == 0);
15146 }
15147 ios.width(25);
15148 internal(ios);
15149 {
15150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15151 std::string ex(str, iter.base());
15152 assert(ex == "-*********************0.0");
15153 assert(ios.width() == 0);
15154 }
15155 }
15156 ios.imbue(lg);
15157 {
15158 ios.width(0);
15159 {
15160 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15161 std::string ex(str, iter.base());
15162 assert(ex == "-0;0");
15163 assert(ios.width() == 0);
15164 }
15165 ios.width(25);
15166 left(ios);
15167 {
15168 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15169 std::string ex(str, iter.base());
15170 assert(ex == "-0;0*********************");
15171 assert(ios.width() == 0);
15172 }
15173 ios.width(25);
15174 right(ios);
15175 {
15176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15177 std::string ex(str, iter.base());
15178 assert(ex == "*********************-0;0");
15179 assert(ios.width() == 0);
15180 }
15181 ios.width(25);
15182 internal(ios);
15183 {
15184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15185 std::string ex(str, iter.base());
15186 assert(ex == "-*********************0;0");
15187 assert(ios.width() == 0);
15188 }
15189 }
15190 }
15191 }
15192 }
15193 uppercase(ios);
15194 {
15195 noshowpos(ios);
15196 {
15197 noshowpoint(ios);
15198 {
15199 ios.imbue(lc);
15200 {
15201 ios.width(0);
15202 {
15203 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15204 std::string ex(str, iter.base());
15205 assert(ex == "-0.0");
15206 assert(ios.width() == 0);
15207 }
15208 ios.width(25);
15209 left(ios);
15210 {
15211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15212 std::string ex(str, iter.base());
15213 assert(ex == "-0.0*********************");
15214 assert(ios.width() == 0);
15215 }
15216 ios.width(25);
15217 right(ios);
15218 {
15219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15220 std::string ex(str, iter.base());
15221 assert(ex == "*********************-0.0");
15222 assert(ios.width() == 0);
15223 }
15224 ios.width(25);
15225 internal(ios);
15226 {
15227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15228 std::string ex(str, iter.base());
15229 assert(ex == "-*********************0.0");
15230 assert(ios.width() == 0);
15231 }
15232 }
15233 ios.imbue(lg);
15234 {
15235 ios.width(0);
15236 {
15237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15238 std::string ex(str, iter.base());
15239 assert(ex == "-0;0");
15240 assert(ios.width() == 0);
15241 }
15242 ios.width(25);
15243 left(ios);
15244 {
15245 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15246 std::string ex(str, iter.base());
15247 assert(ex == "-0;0*********************");
15248 assert(ios.width() == 0);
15249 }
15250 ios.width(25);
15251 right(ios);
15252 {
15253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15254 std::string ex(str, iter.base());
15255 assert(ex == "*********************-0;0");
15256 assert(ios.width() == 0);
15257 }
15258 ios.width(25);
15259 internal(ios);
15260 {
15261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15262 std::string ex(str, iter.base());
15263 assert(ex == "-*********************0;0");
15264 assert(ios.width() == 0);
15265 }
15266 }
15267 }
15268 showpoint(ios);
15269 {
15270 ios.imbue(lc);
15271 {
15272 ios.width(0);
15273 {
15274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15275 std::string ex(str, iter.base());
15276 assert(ex == "-0.0");
15277 assert(ios.width() == 0);
15278 }
15279 ios.width(25);
15280 left(ios);
15281 {
15282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15283 std::string ex(str, iter.base());
15284 assert(ex == "-0.0*********************");
15285 assert(ios.width() == 0);
15286 }
15287 ios.width(25);
15288 right(ios);
15289 {
15290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15291 std::string ex(str, iter.base());
15292 assert(ex == "*********************-0.0");
15293 assert(ios.width() == 0);
15294 }
15295 ios.width(25);
15296 internal(ios);
15297 {
15298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15299 std::string ex(str, iter.base());
15300 assert(ex == "-*********************0.0");
15301 assert(ios.width() == 0);
15302 }
15303 }
15304 ios.imbue(lg);
15305 {
15306 ios.width(0);
15307 {
15308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15309 std::string ex(str, iter.base());
15310 assert(ex == "-0;0");
15311 assert(ios.width() == 0);
15312 }
15313 ios.width(25);
15314 left(ios);
15315 {
15316 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15317 std::string ex(str, iter.base());
15318 assert(ex == "-0;0*********************");
15319 assert(ios.width() == 0);
15320 }
15321 ios.width(25);
15322 right(ios);
15323 {
15324 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15325 std::string ex(str, iter.base());
15326 assert(ex == "*********************-0;0");
15327 assert(ios.width() == 0);
15328 }
15329 ios.width(25);
15330 internal(ios);
15331 {
15332 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15333 std::string ex(str, iter.base());
15334 assert(ex == "-*********************0;0");
15335 assert(ios.width() == 0);
15336 }
15337 }
15338 }
15339 }
15340 showpos(ios);
15341 {
15342 noshowpoint(ios);
15343 {
15344 ios.imbue(lc);
15345 {
15346 ios.width(0);
15347 {
15348 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15349 std::string ex(str, iter.base());
15350 assert(ex == "-0.0");
15351 assert(ios.width() == 0);
15352 }
15353 ios.width(25);
15354 left(ios);
15355 {
15356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15357 std::string ex(str, iter.base());
15358 assert(ex == "-0.0*********************");
15359 assert(ios.width() == 0);
15360 }
15361 ios.width(25);
15362 right(ios);
15363 {
15364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15365 std::string ex(str, iter.base());
15366 assert(ex == "*********************-0.0");
15367 assert(ios.width() == 0);
15368 }
15369 ios.width(25);
15370 internal(ios);
15371 {
15372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15373 std::string ex(str, iter.base());
15374 assert(ex == "-*********************0.0");
15375 assert(ios.width() == 0);
15376 }
15377 }
15378 ios.imbue(lg);
15379 {
15380 ios.width(0);
15381 {
15382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15383 std::string ex(str, iter.base());
15384 assert(ex == "-0;0");
15385 assert(ios.width() == 0);
15386 }
15387 ios.width(25);
15388 left(ios);
15389 {
15390 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15391 std::string ex(str, iter.base());
15392 assert(ex == "-0;0*********************");
15393 assert(ios.width() == 0);
15394 }
15395 ios.width(25);
15396 right(ios);
15397 {
15398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15399 std::string ex(str, iter.base());
15400 assert(ex == "*********************-0;0");
15401 assert(ios.width() == 0);
15402 }
15403 ios.width(25);
15404 internal(ios);
15405 {
15406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15407 std::string ex(str, iter.base());
15408 assert(ex == "-*********************0;0");
15409 assert(ios.width() == 0);
15410 }
15411 }
15412 }
15413 showpoint(ios);
15414 {
15415 ios.imbue(lc);
15416 {
15417 ios.width(0);
15418 {
15419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15420 std::string ex(str, iter.base());
15421 assert(ex == "-0.0");
15422 assert(ios.width() == 0);
15423 }
15424 ios.width(25);
15425 left(ios);
15426 {
15427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15428 std::string ex(str, iter.base());
15429 assert(ex == "-0.0*********************");
15430 assert(ios.width() == 0);
15431 }
15432 ios.width(25);
15433 right(ios);
15434 {
15435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15436 std::string ex(str, iter.base());
15437 assert(ex == "*********************-0.0");
15438 assert(ios.width() == 0);
15439 }
15440 ios.width(25);
15441 internal(ios);
15442 {
15443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15444 std::string ex(str, iter.base());
15445 assert(ex == "-*********************0.0");
15446 assert(ios.width() == 0);
15447 }
15448 }
15449 ios.imbue(lg);
15450 {
15451 ios.width(0);
15452 {
15453 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15454 std::string ex(str, iter.base());
15455 assert(ex == "-0;0");
15456 assert(ios.width() == 0);
15457 }
15458 ios.width(25);
15459 left(ios);
15460 {
15461 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15462 std::string ex(str, iter.base());
15463 assert(ex == "-0;0*********************");
15464 assert(ios.width() == 0);
15465 }
15466 ios.width(25);
15467 right(ios);
15468 {
15469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15470 std::string ex(str, iter.base());
15471 assert(ex == "*********************-0;0");
15472 assert(ios.width() == 0);
15473 }
15474 ios.width(25);
15475 internal(ios);
15476 {
15477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15478 std::string ex(str, iter.base());
15479 assert(ex == "-*********************0;0");
15480 assert(ios.width() == 0);
15481 }
15482 }
15483 }
15484 }
15485 }
15486 }
15487 ios.precision(6);
15488 {
15489 nouppercase(ios);
15490 {
15491 noshowpos(ios);
15492 {
15493 noshowpoint(ios);
15494 {
15495 ios.imbue(lc);
15496 {
15497 ios.width(0);
15498 {
15499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15500 std::string ex(str, iter.base());
15501 assert(ex == "-0.000000");
15502 assert(ios.width() == 0);
15503 }
15504 ios.width(25);
15505 left(ios);
15506 {
15507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15508 std::string ex(str, iter.base());
15509 assert(ex == "-0.000000****************");
15510 assert(ios.width() == 0);
15511 }
15512 ios.width(25);
15513 right(ios);
15514 {
15515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15516 std::string ex(str, iter.base());
15517 assert(ex == "****************-0.000000");
15518 assert(ios.width() == 0);
15519 }
15520 ios.width(25);
15521 internal(ios);
15522 {
15523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15524 std::string ex(str, iter.base());
15525 assert(ex == "-****************0.000000");
15526 assert(ios.width() == 0);
15527 }
15528 }
15529 ios.imbue(lg);
15530 {
15531 ios.width(0);
15532 {
15533 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15534 std::string ex(str, iter.base());
15535 assert(ex == "-0;000000");
15536 assert(ios.width() == 0);
15537 }
15538 ios.width(25);
15539 left(ios);
15540 {
15541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15542 std::string ex(str, iter.base());
15543 assert(ex == "-0;000000****************");
15544 assert(ios.width() == 0);
15545 }
15546 ios.width(25);
15547 right(ios);
15548 {
15549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15550 std::string ex(str, iter.base());
15551 assert(ex == "****************-0;000000");
15552 assert(ios.width() == 0);
15553 }
15554 ios.width(25);
15555 internal(ios);
15556 {
15557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15558 std::string ex(str, iter.base());
15559 assert(ex == "-****************0;000000");
15560 assert(ios.width() == 0);
15561 }
15562 }
15563 }
15564 showpoint(ios);
15565 {
15566 ios.imbue(lc);
15567 {
15568 ios.width(0);
15569 {
15570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15571 std::string ex(str, iter.base());
15572 assert(ex == "-0.000000");
15573 assert(ios.width() == 0);
15574 }
15575 ios.width(25);
15576 left(ios);
15577 {
15578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15579 std::string ex(str, iter.base());
15580 assert(ex == "-0.000000****************");
15581 assert(ios.width() == 0);
15582 }
15583 ios.width(25);
15584 right(ios);
15585 {
15586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15587 std::string ex(str, iter.base());
15588 assert(ex == "****************-0.000000");
15589 assert(ios.width() == 0);
15590 }
15591 ios.width(25);
15592 internal(ios);
15593 {
15594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15595 std::string ex(str, iter.base());
15596 assert(ex == "-****************0.000000");
15597 assert(ios.width() == 0);
15598 }
15599 }
15600 ios.imbue(lg);
15601 {
15602 ios.width(0);
15603 {
15604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15605 std::string ex(str, iter.base());
15606 assert(ex == "-0;000000");
15607 assert(ios.width() == 0);
15608 }
15609 ios.width(25);
15610 left(ios);
15611 {
15612 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15613 std::string ex(str, iter.base());
15614 assert(ex == "-0;000000****************");
15615 assert(ios.width() == 0);
15616 }
15617 ios.width(25);
15618 right(ios);
15619 {
15620 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15621 std::string ex(str, iter.base());
15622 assert(ex == "****************-0;000000");
15623 assert(ios.width() == 0);
15624 }
15625 ios.width(25);
15626 internal(ios);
15627 {
15628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15629 std::string ex(str, iter.base());
15630 assert(ex == "-****************0;000000");
15631 assert(ios.width() == 0);
15632 }
15633 }
15634 }
15635 }
15636 showpos(ios);
15637 {
15638 noshowpoint(ios);
15639 {
15640 ios.imbue(lc);
15641 {
15642 ios.width(0);
15643 {
15644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15645 std::string ex(str, iter.base());
15646 assert(ex == "-0.000000");
15647 assert(ios.width() == 0);
15648 }
15649 ios.width(25);
15650 left(ios);
15651 {
15652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15653 std::string ex(str, iter.base());
15654 assert(ex == "-0.000000****************");
15655 assert(ios.width() == 0);
15656 }
15657 ios.width(25);
15658 right(ios);
15659 {
15660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15661 std::string ex(str, iter.base());
15662 assert(ex == "****************-0.000000");
15663 assert(ios.width() == 0);
15664 }
15665 ios.width(25);
15666 internal(ios);
15667 {
15668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15669 std::string ex(str, iter.base());
15670 assert(ex == "-****************0.000000");
15671 assert(ios.width() == 0);
15672 }
15673 }
15674 ios.imbue(lg);
15675 {
15676 ios.width(0);
15677 {
15678 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15679 std::string ex(str, iter.base());
15680 assert(ex == "-0;000000");
15681 assert(ios.width() == 0);
15682 }
15683 ios.width(25);
15684 left(ios);
15685 {
15686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15687 std::string ex(str, iter.base());
15688 assert(ex == "-0;000000****************");
15689 assert(ios.width() == 0);
15690 }
15691 ios.width(25);
15692 right(ios);
15693 {
15694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15695 std::string ex(str, iter.base());
15696 assert(ex == "****************-0;000000");
15697 assert(ios.width() == 0);
15698 }
15699 ios.width(25);
15700 internal(ios);
15701 {
15702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15703 std::string ex(str, iter.base());
15704 assert(ex == "-****************0;000000");
15705 assert(ios.width() == 0);
15706 }
15707 }
15708 }
15709 showpoint(ios);
15710 {
15711 ios.imbue(lc);
15712 {
15713 ios.width(0);
15714 {
15715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15716 std::string ex(str, iter.base());
15717 assert(ex == "-0.000000");
15718 assert(ios.width() == 0);
15719 }
15720 ios.width(25);
15721 left(ios);
15722 {
15723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15724 std::string ex(str, iter.base());
15725 assert(ex == "-0.000000****************");
15726 assert(ios.width() == 0);
15727 }
15728 ios.width(25);
15729 right(ios);
15730 {
15731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15732 std::string ex(str, iter.base());
15733 assert(ex == "****************-0.000000");
15734 assert(ios.width() == 0);
15735 }
15736 ios.width(25);
15737 internal(ios);
15738 {
15739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15740 std::string ex(str, iter.base());
15741 assert(ex == "-****************0.000000");
15742 assert(ios.width() == 0);
15743 }
15744 }
15745 ios.imbue(lg);
15746 {
15747 ios.width(0);
15748 {
15749 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15750 std::string ex(str, iter.base());
15751 assert(ex == "-0;000000");
15752 assert(ios.width() == 0);
15753 }
15754 ios.width(25);
15755 left(ios);
15756 {
15757 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15758 std::string ex(str, iter.base());
15759 assert(ex == "-0;000000****************");
15760 assert(ios.width() == 0);
15761 }
15762 ios.width(25);
15763 right(ios);
15764 {
15765 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15766 std::string ex(str, iter.base());
15767 assert(ex == "****************-0;000000");
15768 assert(ios.width() == 0);
15769 }
15770 ios.width(25);
15771 internal(ios);
15772 {
15773 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15774 std::string ex(str, iter.base());
15775 assert(ex == "-****************0;000000");
15776 assert(ios.width() == 0);
15777 }
15778 }
15779 }
15780 }
15781 }
15782 uppercase(ios);
15783 {
15784 noshowpos(ios);
15785 {
15786 noshowpoint(ios);
15787 {
15788 ios.imbue(lc);
15789 {
15790 ios.width(0);
15791 {
15792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15793 std::string ex(str, iter.base());
15794 assert(ex == "-0.000000");
15795 assert(ios.width() == 0);
15796 }
15797 ios.width(25);
15798 left(ios);
15799 {
15800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15801 std::string ex(str, iter.base());
15802 assert(ex == "-0.000000****************");
15803 assert(ios.width() == 0);
15804 }
15805 ios.width(25);
15806 right(ios);
15807 {
15808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15809 std::string ex(str, iter.base());
15810 assert(ex == "****************-0.000000");
15811 assert(ios.width() == 0);
15812 }
15813 ios.width(25);
15814 internal(ios);
15815 {
15816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15817 std::string ex(str, iter.base());
15818 assert(ex == "-****************0.000000");
15819 assert(ios.width() == 0);
15820 }
15821 }
15822 ios.imbue(lg);
15823 {
15824 ios.width(0);
15825 {
15826 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15827 std::string ex(str, iter.base());
15828 assert(ex == "-0;000000");
15829 assert(ios.width() == 0);
15830 }
15831 ios.width(25);
15832 left(ios);
15833 {
15834 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15835 std::string ex(str, iter.base());
15836 assert(ex == "-0;000000****************");
15837 assert(ios.width() == 0);
15838 }
15839 ios.width(25);
15840 right(ios);
15841 {
15842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15843 std::string ex(str, iter.base());
15844 assert(ex == "****************-0;000000");
15845 assert(ios.width() == 0);
15846 }
15847 ios.width(25);
15848 internal(ios);
15849 {
15850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15851 std::string ex(str, iter.base());
15852 assert(ex == "-****************0;000000");
15853 assert(ios.width() == 0);
15854 }
15855 }
15856 }
15857 showpoint(ios);
15858 {
15859 ios.imbue(lc);
15860 {
15861 ios.width(0);
15862 {
15863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15864 std::string ex(str, iter.base());
15865 assert(ex == "-0.000000");
15866 assert(ios.width() == 0);
15867 }
15868 ios.width(25);
15869 left(ios);
15870 {
15871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15872 std::string ex(str, iter.base());
15873 assert(ex == "-0.000000****************");
15874 assert(ios.width() == 0);
15875 }
15876 ios.width(25);
15877 right(ios);
15878 {
15879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15880 std::string ex(str, iter.base());
15881 assert(ex == "****************-0.000000");
15882 assert(ios.width() == 0);
15883 }
15884 ios.width(25);
15885 internal(ios);
15886 {
15887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15888 std::string ex(str, iter.base());
15889 assert(ex == "-****************0.000000");
15890 assert(ios.width() == 0);
15891 }
15892 }
15893 ios.imbue(lg);
15894 {
15895 ios.width(0);
15896 {
15897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15898 std::string ex(str, iter.base());
15899 assert(ex == "-0;000000");
15900 assert(ios.width() == 0);
15901 }
15902 ios.width(25);
15903 left(ios);
15904 {
15905 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15906 std::string ex(str, iter.base());
15907 assert(ex == "-0;000000****************");
15908 assert(ios.width() == 0);
15909 }
15910 ios.width(25);
15911 right(ios);
15912 {
15913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15914 std::string ex(str, iter.base());
15915 assert(ex == "****************-0;000000");
15916 assert(ios.width() == 0);
15917 }
15918 ios.width(25);
15919 internal(ios);
15920 {
15921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15922 std::string ex(str, iter.base());
15923 assert(ex == "-****************0;000000");
15924 assert(ios.width() == 0);
15925 }
15926 }
15927 }
15928 }
15929 showpos(ios);
15930 {
15931 noshowpoint(ios);
15932 {
15933 ios.imbue(lc);
15934 {
15935 ios.width(0);
15936 {
15937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15938 std::string ex(str, iter.base());
15939 assert(ex == "-0.000000");
15940 assert(ios.width() == 0);
15941 }
15942 ios.width(25);
15943 left(ios);
15944 {
15945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15946 std::string ex(str, iter.base());
15947 assert(ex == "-0.000000****************");
15948 assert(ios.width() == 0);
15949 }
15950 ios.width(25);
15951 right(ios);
15952 {
15953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15954 std::string ex(str, iter.base());
15955 assert(ex == "****************-0.000000");
15956 assert(ios.width() == 0);
15957 }
15958 ios.width(25);
15959 internal(ios);
15960 {
15961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15962 std::string ex(str, iter.base());
15963 assert(ex == "-****************0.000000");
15964 assert(ios.width() == 0);
15965 }
15966 }
15967 ios.imbue(lg);
15968 {
15969 ios.width(0);
15970 {
15971 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15972 std::string ex(str, iter.base());
15973 assert(ex == "-0;000000");
15974 assert(ios.width() == 0);
15975 }
15976 ios.width(25);
15977 left(ios);
15978 {
15979 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15980 std::string ex(str, iter.base());
15981 assert(ex == "-0;000000****************");
15982 assert(ios.width() == 0);
15983 }
15984 ios.width(25);
15985 right(ios);
15986 {
15987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15988 std::string ex(str, iter.base());
15989 assert(ex == "****************-0;000000");
15990 assert(ios.width() == 0);
15991 }
15992 ios.width(25);
15993 internal(ios);
15994 {
15995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15996 std::string ex(str, iter.base());
15997 assert(ex == "-****************0;000000");
15998 assert(ios.width() == 0);
15999 }
16000 }
16001 }
16002 showpoint(ios);
16003 {
16004 ios.imbue(lc);
16005 {
16006 ios.width(0);
16007 {
16008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16009 std::string ex(str, iter.base());
16010 assert(ex == "-0.000000");
16011 assert(ios.width() == 0);
16012 }
16013 ios.width(25);
16014 left(ios);
16015 {
16016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16017 std::string ex(str, iter.base());
16018 assert(ex == "-0.000000****************");
16019 assert(ios.width() == 0);
16020 }
16021 ios.width(25);
16022 right(ios);
16023 {
16024 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16025 std::string ex(str, iter.base());
16026 assert(ex == "****************-0.000000");
16027 assert(ios.width() == 0);
16028 }
16029 ios.width(25);
16030 internal(ios);
16031 {
16032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16033 std::string ex(str, iter.base());
16034 assert(ex == "-****************0.000000");
16035 assert(ios.width() == 0);
16036 }
16037 }
16038 ios.imbue(lg);
16039 {
16040 ios.width(0);
16041 {
16042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16043 std::string ex(str, iter.base());
16044 assert(ex == "-0;000000");
16045 assert(ios.width() == 0);
16046 }
16047 ios.width(25);
16048 left(ios);
16049 {
16050 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16051 std::string ex(str, iter.base());
16052 assert(ex == "-0;000000****************");
16053 assert(ios.width() == 0);
16054 }
16055 ios.width(25);
16056 right(ios);
16057 {
16058 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16059 std::string ex(str, iter.base());
16060 assert(ex == "****************-0;000000");
16061 assert(ios.width() == 0);
16062 }
16063 ios.width(25);
16064 internal(ios);
16065 {
16066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16067 std::string ex(str, iter.base());
16068 assert(ex == "-****************0;000000");
16069 assert(ios.width() == 0);
16070 }
16071 }
16072 }
16073 }
16074 }
16075 }
16076 ios.precision(16);
16077 {
16078 nouppercase(ios);
16079 {
16080 noshowpos(ios);
16081 {
16082 noshowpoint(ios);
16083 {
16084 ios.imbue(lc);
16085 {
16086 ios.width(0);
16087 {
16088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16089 std::string ex(str, iter.base());
16090 assert(ex == "-0.0000000000000000");
16091 assert(ios.width() == 0);
16092 }
16093 ios.width(25);
16094 left(ios);
16095 {
16096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16097 std::string ex(str, iter.base());
16098 assert(ex == "-0.0000000000000000******");
16099 assert(ios.width() == 0);
16100 }
16101 ios.width(25);
16102 right(ios);
16103 {
16104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16105 std::string ex(str, iter.base());
16106 assert(ex == "******-0.0000000000000000");
16107 assert(ios.width() == 0);
16108 }
16109 ios.width(25);
16110 internal(ios);
16111 {
16112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16113 std::string ex(str, iter.base());
16114 assert(ex == "-******0.0000000000000000");
16115 assert(ios.width() == 0);
16116 }
16117 }
16118 ios.imbue(lg);
16119 {
16120 ios.width(0);
16121 {
16122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16123 std::string ex(str, iter.base());
16124 assert(ex == "-0;0000000000000000");
16125 assert(ios.width() == 0);
16126 }
16127 ios.width(25);
16128 left(ios);
16129 {
16130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16131 std::string ex(str, iter.base());
16132 assert(ex == "-0;0000000000000000******");
16133 assert(ios.width() == 0);
16134 }
16135 ios.width(25);
16136 right(ios);
16137 {
16138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16139 std::string ex(str, iter.base());
16140 assert(ex == "******-0;0000000000000000");
16141 assert(ios.width() == 0);
16142 }
16143 ios.width(25);
16144 internal(ios);
16145 {
16146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16147 std::string ex(str, iter.base());
16148 assert(ex == "-******0;0000000000000000");
16149 assert(ios.width() == 0);
16150 }
16151 }
16152 }
16153 showpoint(ios);
16154 {
16155 ios.imbue(lc);
16156 {
16157 ios.width(0);
16158 {
16159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16160 std::string ex(str, iter.base());
16161 assert(ex == "-0.0000000000000000");
16162 assert(ios.width() == 0);
16163 }
16164 ios.width(25);
16165 left(ios);
16166 {
16167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16168 std::string ex(str, iter.base());
16169 assert(ex == "-0.0000000000000000******");
16170 assert(ios.width() == 0);
16171 }
16172 ios.width(25);
16173 right(ios);
16174 {
16175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16176 std::string ex(str, iter.base());
16177 assert(ex == "******-0.0000000000000000");
16178 assert(ios.width() == 0);
16179 }
16180 ios.width(25);
16181 internal(ios);
16182 {
16183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16184 std::string ex(str, iter.base());
16185 assert(ex == "-******0.0000000000000000");
16186 assert(ios.width() == 0);
16187 }
16188 }
16189 ios.imbue(lg);
16190 {
16191 ios.width(0);
16192 {
16193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16194 std::string ex(str, iter.base());
16195 assert(ex == "-0;0000000000000000");
16196 assert(ios.width() == 0);
16197 }
16198 ios.width(25);
16199 left(ios);
16200 {
16201 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16202 std::string ex(str, iter.base());
16203 assert(ex == "-0;0000000000000000******");
16204 assert(ios.width() == 0);
16205 }
16206 ios.width(25);
16207 right(ios);
16208 {
16209 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16210 std::string ex(str, iter.base());
16211 assert(ex == "******-0;0000000000000000");
16212 assert(ios.width() == 0);
16213 }
16214 ios.width(25);
16215 internal(ios);
16216 {
16217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16218 std::string ex(str, iter.base());
16219 assert(ex == "-******0;0000000000000000");
16220 assert(ios.width() == 0);
16221 }
16222 }
16223 }
16224 }
16225 showpos(ios);
16226 {
16227 noshowpoint(ios);
16228 {
16229 ios.imbue(lc);
16230 {
16231 ios.width(0);
16232 {
16233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16234 std::string ex(str, iter.base());
16235 assert(ex == "-0.0000000000000000");
16236 assert(ios.width() == 0);
16237 }
16238 ios.width(25);
16239 left(ios);
16240 {
16241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16242 std::string ex(str, iter.base());
16243 assert(ex == "-0.0000000000000000******");
16244 assert(ios.width() == 0);
16245 }
16246 ios.width(25);
16247 right(ios);
16248 {
16249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16250 std::string ex(str, iter.base());
16251 assert(ex == "******-0.0000000000000000");
16252 assert(ios.width() == 0);
16253 }
16254 ios.width(25);
16255 internal(ios);
16256 {
16257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16258 std::string ex(str, iter.base());
16259 assert(ex == "-******0.0000000000000000");
16260 assert(ios.width() == 0);
16261 }
16262 }
16263 ios.imbue(lg);
16264 {
16265 ios.width(0);
16266 {
16267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16268 std::string ex(str, iter.base());
16269 assert(ex == "-0;0000000000000000");
16270 assert(ios.width() == 0);
16271 }
16272 ios.width(25);
16273 left(ios);
16274 {
16275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16276 std::string ex(str, iter.base());
16277 assert(ex == "-0;0000000000000000******");
16278 assert(ios.width() == 0);
16279 }
16280 ios.width(25);
16281 right(ios);
16282 {
16283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16284 std::string ex(str, iter.base());
16285 assert(ex == "******-0;0000000000000000");
16286 assert(ios.width() == 0);
16287 }
16288 ios.width(25);
16289 internal(ios);
16290 {
16291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16292 std::string ex(str, iter.base());
16293 assert(ex == "-******0;0000000000000000");
16294 assert(ios.width() == 0);
16295 }
16296 }
16297 }
16298 showpoint(ios);
16299 {
16300 ios.imbue(lc);
16301 {
16302 ios.width(0);
16303 {
16304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16305 std::string ex(str, iter.base());
16306 assert(ex == "-0.0000000000000000");
16307 assert(ios.width() == 0);
16308 }
16309 ios.width(25);
16310 left(ios);
16311 {
16312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16313 std::string ex(str, iter.base());
16314 assert(ex == "-0.0000000000000000******");
16315 assert(ios.width() == 0);
16316 }
16317 ios.width(25);
16318 right(ios);
16319 {
16320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16321 std::string ex(str, iter.base());
16322 assert(ex == "******-0.0000000000000000");
16323 assert(ios.width() == 0);
16324 }
16325 ios.width(25);
16326 internal(ios);
16327 {
16328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16329 std::string ex(str, iter.base());
16330 assert(ex == "-******0.0000000000000000");
16331 assert(ios.width() == 0);
16332 }
16333 }
16334 ios.imbue(lg);
16335 {
16336 ios.width(0);
16337 {
16338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16339 std::string ex(str, iter.base());
16340 assert(ex == "-0;0000000000000000");
16341 assert(ios.width() == 0);
16342 }
16343 ios.width(25);
16344 left(ios);
16345 {
16346 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16347 std::string ex(str, iter.base());
16348 assert(ex == "-0;0000000000000000******");
16349 assert(ios.width() == 0);
16350 }
16351 ios.width(25);
16352 right(ios);
16353 {
16354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16355 std::string ex(str, iter.base());
16356 assert(ex == "******-0;0000000000000000");
16357 assert(ios.width() == 0);
16358 }
16359 ios.width(25);
16360 internal(ios);
16361 {
16362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16363 std::string ex(str, iter.base());
16364 assert(ex == "-******0;0000000000000000");
16365 assert(ios.width() == 0);
16366 }
16367 }
16368 }
16369 }
16370 }
16371 uppercase(ios);
16372 {
16373 noshowpos(ios);
16374 {
16375 noshowpoint(ios);
16376 {
16377 ios.imbue(lc);
16378 {
16379 ios.width(0);
16380 {
16381 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16382 std::string ex(str, iter.base());
16383 assert(ex == "-0.0000000000000000");
16384 assert(ios.width() == 0);
16385 }
16386 ios.width(25);
16387 left(ios);
16388 {
16389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16390 std::string ex(str, iter.base());
16391 assert(ex == "-0.0000000000000000******");
16392 assert(ios.width() == 0);
16393 }
16394 ios.width(25);
16395 right(ios);
16396 {
16397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16398 std::string ex(str, iter.base());
16399 assert(ex == "******-0.0000000000000000");
16400 assert(ios.width() == 0);
16401 }
16402 ios.width(25);
16403 internal(ios);
16404 {
16405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16406 std::string ex(str, iter.base());
16407 assert(ex == "-******0.0000000000000000");
16408 assert(ios.width() == 0);
16409 }
16410 }
16411 ios.imbue(lg);
16412 {
16413 ios.width(0);
16414 {
16415 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16416 std::string ex(str, iter.base());
16417 assert(ex == "-0;0000000000000000");
16418 assert(ios.width() == 0);
16419 }
16420 ios.width(25);
16421 left(ios);
16422 {
16423 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16424 std::string ex(str, iter.base());
16425 assert(ex == "-0;0000000000000000******");
16426 assert(ios.width() == 0);
16427 }
16428 ios.width(25);
16429 right(ios);
16430 {
16431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16432 std::string ex(str, iter.base());
16433 assert(ex == "******-0;0000000000000000");
16434 assert(ios.width() == 0);
16435 }
16436 ios.width(25);
16437 internal(ios);
16438 {
16439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16440 std::string ex(str, iter.base());
16441 assert(ex == "-******0;0000000000000000");
16442 assert(ios.width() == 0);
16443 }
16444 }
16445 }
16446 showpoint(ios);
16447 {
16448 ios.imbue(lc);
16449 {
16450 ios.width(0);
16451 {
16452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16453 std::string ex(str, iter.base());
16454 assert(ex == "-0.0000000000000000");
16455 assert(ios.width() == 0);
16456 }
16457 ios.width(25);
16458 left(ios);
16459 {
16460 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16461 std::string ex(str, iter.base());
16462 assert(ex == "-0.0000000000000000******");
16463 assert(ios.width() == 0);
16464 }
16465 ios.width(25);
16466 right(ios);
16467 {
16468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16469 std::string ex(str, iter.base());
16470 assert(ex == "******-0.0000000000000000");
16471 assert(ios.width() == 0);
16472 }
16473 ios.width(25);
16474 internal(ios);
16475 {
16476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16477 std::string ex(str, iter.base());
16478 assert(ex == "-******0.0000000000000000");
16479 assert(ios.width() == 0);
16480 }
16481 }
16482 ios.imbue(lg);
16483 {
16484 ios.width(0);
16485 {
16486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16487 std::string ex(str, iter.base());
16488 assert(ex == "-0;0000000000000000");
16489 assert(ios.width() == 0);
16490 }
16491 ios.width(25);
16492 left(ios);
16493 {
16494 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16495 std::string ex(str, iter.base());
16496 assert(ex == "-0;0000000000000000******");
16497 assert(ios.width() == 0);
16498 }
16499 ios.width(25);
16500 right(ios);
16501 {
16502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16503 std::string ex(str, iter.base());
16504 assert(ex == "******-0;0000000000000000");
16505 assert(ios.width() == 0);
16506 }
16507 ios.width(25);
16508 internal(ios);
16509 {
16510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16511 std::string ex(str, iter.base());
16512 assert(ex == "-******0;0000000000000000");
16513 assert(ios.width() == 0);
16514 }
16515 }
16516 }
16517 }
16518 showpos(ios);
16519 {
16520 noshowpoint(ios);
16521 {
16522 ios.imbue(lc);
16523 {
16524 ios.width(0);
16525 {
16526 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16527 std::string ex(str, iter.base());
16528 assert(ex == "-0.0000000000000000");
16529 assert(ios.width() == 0);
16530 }
16531 ios.width(25);
16532 left(ios);
16533 {
16534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16535 std::string ex(str, iter.base());
16536 assert(ex == "-0.0000000000000000******");
16537 assert(ios.width() == 0);
16538 }
16539 ios.width(25);
16540 right(ios);
16541 {
16542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16543 std::string ex(str, iter.base());
16544 assert(ex == "******-0.0000000000000000");
16545 assert(ios.width() == 0);
16546 }
16547 ios.width(25);
16548 internal(ios);
16549 {
16550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16551 std::string ex(str, iter.base());
16552 assert(ex == "-******0.0000000000000000");
16553 assert(ios.width() == 0);
16554 }
16555 }
16556 ios.imbue(lg);
16557 {
16558 ios.width(0);
16559 {
16560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16561 std::string ex(str, iter.base());
16562 assert(ex == "-0;0000000000000000");
16563 assert(ios.width() == 0);
16564 }
16565 ios.width(25);
16566 left(ios);
16567 {
16568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16569 std::string ex(str, iter.base());
16570 assert(ex == "-0;0000000000000000******");
16571 assert(ios.width() == 0);
16572 }
16573 ios.width(25);
16574 right(ios);
16575 {
16576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16577 std::string ex(str, iter.base());
16578 assert(ex == "******-0;0000000000000000");
16579 assert(ios.width() == 0);
16580 }
16581 ios.width(25);
16582 internal(ios);
16583 {
16584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16585 std::string ex(str, iter.base());
16586 assert(ex == "-******0;0000000000000000");
16587 assert(ios.width() == 0);
16588 }
16589 }
16590 }
16591 showpoint(ios);
16592 {
16593 ios.imbue(lc);
16594 {
16595 ios.width(0);
16596 {
16597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16598 std::string ex(str, iter.base());
16599 assert(ex == "-0.0000000000000000");
16600 assert(ios.width() == 0);
16601 }
16602 ios.width(25);
16603 left(ios);
16604 {
16605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16606 std::string ex(str, iter.base());
16607 assert(ex == "-0.0000000000000000******");
16608 assert(ios.width() == 0);
16609 }
16610 ios.width(25);
16611 right(ios);
16612 {
16613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16614 std::string ex(str, iter.base());
16615 assert(ex == "******-0.0000000000000000");
16616 assert(ios.width() == 0);
16617 }
16618 ios.width(25);
16619 internal(ios);
16620 {
16621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16622 std::string ex(str, iter.base());
16623 assert(ex == "-******0.0000000000000000");
16624 assert(ios.width() == 0);
16625 }
16626 }
16627 ios.imbue(lg);
16628 {
16629 ios.width(0);
16630 {
16631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16632 std::string ex(str, iter.base());
16633 assert(ex == "-0;0000000000000000");
16634 assert(ios.width() == 0);
16635 }
16636 ios.width(25);
16637 left(ios);
16638 {
16639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16640 std::string ex(str, iter.base());
16641 assert(ex == "-0;0000000000000000******");
16642 assert(ios.width() == 0);
16643 }
16644 ios.width(25);
16645 right(ios);
16646 {
16647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16648 std::string ex(str, iter.base());
16649 assert(ex == "******-0;0000000000000000");
16650 assert(ios.width() == 0);
16651 }
16652 ios.width(25);
16653 internal(ios);
16654 {
16655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16656 std::string ex(str, iter.base());
16657 assert(ex == "-******0;0000000000000000");
16658 assert(ios.width() == 0);
16659 }
16660 }
16661 }
16662 }
16663 }
16664 }
16665 ios.precision(60);
16666 {
16667 nouppercase(ios);
16668 {
16669 noshowpos(ios);
16670 {
16671 noshowpoint(ios);
16672 {
16673 ios.imbue(lc);
16674 {
16675 ios.width(0);
16676 {
16677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16678 std::string ex(str, iter.base());
16679 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16680 assert(ios.width() == 0);
16681 }
16682 ios.width(25);
16683 left(ios);
16684 {
16685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16686 std::string ex(str, iter.base());
16687 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16688 assert(ios.width() == 0);
16689 }
16690 ios.width(25);
16691 right(ios);
16692 {
16693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16694 std::string ex(str, iter.base());
16695 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16696 assert(ios.width() == 0);
16697 }
16698 ios.width(25);
16699 internal(ios);
16700 {
16701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16702 std::string ex(str, iter.base());
16703 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16704 assert(ios.width() == 0);
16705 }
16706 }
16707 ios.imbue(lg);
16708 {
16709 ios.width(0);
16710 {
16711 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16712 std::string ex(str, iter.base());
16713 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16714 assert(ios.width() == 0);
16715 }
16716 ios.width(25);
16717 left(ios);
16718 {
16719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16720 std::string ex(str, iter.base());
16721 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16722 assert(ios.width() == 0);
16723 }
16724 ios.width(25);
16725 right(ios);
16726 {
16727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16728 std::string ex(str, iter.base());
16729 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16730 assert(ios.width() == 0);
16731 }
16732 ios.width(25);
16733 internal(ios);
16734 {
16735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16736 std::string ex(str, iter.base());
16737 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16738 assert(ios.width() == 0);
16739 }
16740 }
16741 }
16742 showpoint(ios);
16743 {
16744 ios.imbue(lc);
16745 {
16746 ios.width(0);
16747 {
16748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16749 std::string ex(str, iter.base());
16750 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16751 assert(ios.width() == 0);
16752 }
16753 ios.width(25);
16754 left(ios);
16755 {
16756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16757 std::string ex(str, iter.base());
16758 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16759 assert(ios.width() == 0);
16760 }
16761 ios.width(25);
16762 right(ios);
16763 {
16764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16765 std::string ex(str, iter.base());
16766 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16767 assert(ios.width() == 0);
16768 }
16769 ios.width(25);
16770 internal(ios);
16771 {
16772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16773 std::string ex(str, iter.base());
16774 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16775 assert(ios.width() == 0);
16776 }
16777 }
16778 ios.imbue(lg);
16779 {
16780 ios.width(0);
16781 {
16782 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16783 std::string ex(str, iter.base());
16784 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16785 assert(ios.width() == 0);
16786 }
16787 ios.width(25);
16788 left(ios);
16789 {
16790 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16791 std::string ex(str, iter.base());
16792 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16793 assert(ios.width() == 0);
16794 }
16795 ios.width(25);
16796 right(ios);
16797 {
16798 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16799 std::string ex(str, iter.base());
16800 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16801 assert(ios.width() == 0);
16802 }
16803 ios.width(25);
16804 internal(ios);
16805 {
16806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16807 std::string ex(str, iter.base());
16808 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16809 assert(ios.width() == 0);
16810 }
16811 }
16812 }
16813 }
16814 showpos(ios);
16815 {
16816 noshowpoint(ios);
16817 {
16818 ios.imbue(lc);
16819 {
16820 ios.width(0);
16821 {
16822 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16823 std::string ex(str, iter.base());
16824 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16825 assert(ios.width() == 0);
16826 }
16827 ios.width(25);
16828 left(ios);
16829 {
16830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16831 std::string ex(str, iter.base());
16832 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16833 assert(ios.width() == 0);
16834 }
16835 ios.width(25);
16836 right(ios);
16837 {
16838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16839 std::string ex(str, iter.base());
16840 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16841 assert(ios.width() == 0);
16842 }
16843 ios.width(25);
16844 internal(ios);
16845 {
16846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16847 std::string ex(str, iter.base());
16848 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16849 assert(ios.width() == 0);
16850 }
16851 }
16852 ios.imbue(lg);
16853 {
16854 ios.width(0);
16855 {
16856 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16857 std::string ex(str, iter.base());
16858 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16859 assert(ios.width() == 0);
16860 }
16861 ios.width(25);
16862 left(ios);
16863 {
16864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16865 std::string ex(str, iter.base());
16866 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16867 assert(ios.width() == 0);
16868 }
16869 ios.width(25);
16870 right(ios);
16871 {
16872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16873 std::string ex(str, iter.base());
16874 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16875 assert(ios.width() == 0);
16876 }
16877 ios.width(25);
16878 internal(ios);
16879 {
16880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16881 std::string ex(str, iter.base());
16882 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16883 assert(ios.width() == 0);
16884 }
16885 }
16886 }
16887 showpoint(ios);
16888 {
16889 ios.imbue(lc);
16890 {
16891 ios.width(0);
16892 {
16893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16894 std::string ex(str, iter.base());
16895 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16896 assert(ios.width() == 0);
16897 }
16898 ios.width(25);
16899 left(ios);
16900 {
16901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16902 std::string ex(str, iter.base());
16903 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16904 assert(ios.width() == 0);
16905 }
16906 ios.width(25);
16907 right(ios);
16908 {
16909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16910 std::string ex(str, iter.base());
16911 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16912 assert(ios.width() == 0);
16913 }
16914 ios.width(25);
16915 internal(ios);
16916 {
16917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16918 std::string ex(str, iter.base());
16919 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16920 assert(ios.width() == 0);
16921 }
16922 }
16923 ios.imbue(lg);
16924 {
16925 ios.width(0);
16926 {
16927 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16928 std::string ex(str, iter.base());
16929 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16930 assert(ios.width() == 0);
16931 }
16932 ios.width(25);
16933 left(ios);
16934 {
16935 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16936 std::string ex(str, iter.base());
16937 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16938 assert(ios.width() == 0);
16939 }
16940 ios.width(25);
16941 right(ios);
16942 {
16943 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16944 std::string ex(str, iter.base());
16945 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16946 assert(ios.width() == 0);
16947 }
16948 ios.width(25);
16949 internal(ios);
16950 {
16951 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16952 std::string ex(str, iter.base());
16953 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16954 assert(ios.width() == 0);
16955 }
16956 }
16957 }
16958 }
16959 }
16960 uppercase(ios);
16961 {
16962 noshowpos(ios);
16963 {
16964 noshowpoint(ios);
16965 {
16966 ios.imbue(lc);
16967 {
16968 ios.width(0);
16969 {
16970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16971 std::string ex(str, iter.base());
16972 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16973 assert(ios.width() == 0);
16974 }
16975 ios.width(25);
16976 left(ios);
16977 {
16978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16979 std::string ex(str, iter.base());
16980 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16981 assert(ios.width() == 0);
16982 }
16983 ios.width(25);
16984 right(ios);
16985 {
16986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16987 std::string ex(str, iter.base());
16988 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16989 assert(ios.width() == 0);
16990 }
16991 ios.width(25);
16992 internal(ios);
16993 {
16994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16995 std::string ex(str, iter.base());
16996 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16997 assert(ios.width() == 0);
16998 }
16999 }
17000 ios.imbue(lg);
17001 {
17002 ios.width(0);
17003 {
17004 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17005 std::string ex(str, iter.base());
17006 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17007 assert(ios.width() == 0);
17008 }
17009 ios.width(25);
17010 left(ios);
17011 {
17012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17013 std::string ex(str, iter.base());
17014 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17015 assert(ios.width() == 0);
17016 }
17017 ios.width(25);
17018 right(ios);
17019 {
17020 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17021 std::string ex(str, iter.base());
17022 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17023 assert(ios.width() == 0);
17024 }
17025 ios.width(25);
17026 internal(ios);
17027 {
17028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17029 std::string ex(str, iter.base());
17030 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17031 assert(ios.width() == 0);
17032 }
17033 }
17034 }
17035 showpoint(ios);
17036 {
17037 ios.imbue(lc);
17038 {
17039 ios.width(0);
17040 {
17041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17042 std::string ex(str, iter.base());
17043 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17044 assert(ios.width() == 0);
17045 }
17046 ios.width(25);
17047 left(ios);
17048 {
17049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17050 std::string ex(str, iter.base());
17051 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17052 assert(ios.width() == 0);
17053 }
17054 ios.width(25);
17055 right(ios);
17056 {
17057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17058 std::string ex(str, iter.base());
17059 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17060 assert(ios.width() == 0);
17061 }
17062 ios.width(25);
17063 internal(ios);
17064 {
17065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17066 std::string ex(str, iter.base());
17067 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17068 assert(ios.width() == 0);
17069 }
17070 }
17071 ios.imbue(lg);
17072 {
17073 ios.width(0);
17074 {
17075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17076 std::string ex(str, iter.base());
17077 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17078 assert(ios.width() == 0);
17079 }
17080 ios.width(25);
17081 left(ios);
17082 {
17083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17084 std::string ex(str, iter.base());
17085 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17086 assert(ios.width() == 0);
17087 }
17088 ios.width(25);
17089 right(ios);
17090 {
17091 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17092 std::string ex(str, iter.base());
17093 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17094 assert(ios.width() == 0);
17095 }
17096 ios.width(25);
17097 internal(ios);
17098 {
17099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17100 std::string ex(str, iter.base());
17101 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17102 assert(ios.width() == 0);
17103 }
17104 }
17105 }
17106 }
17107 showpos(ios);
17108 {
17109 noshowpoint(ios);
17110 {
17111 ios.imbue(lc);
17112 {
17113 ios.width(0);
17114 {
17115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17116 std::string ex(str, iter.base());
17117 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17118 assert(ios.width() == 0);
17119 }
17120 ios.width(25);
17121 left(ios);
17122 {
17123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17124 std::string ex(str, iter.base());
17125 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17126 assert(ios.width() == 0);
17127 }
17128 ios.width(25);
17129 right(ios);
17130 {
17131 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17132 std::string ex(str, iter.base());
17133 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17134 assert(ios.width() == 0);
17135 }
17136 ios.width(25);
17137 internal(ios);
17138 {
17139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17140 std::string ex(str, iter.base());
17141 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17142 assert(ios.width() == 0);
17143 }
17144 }
17145 ios.imbue(lg);
17146 {
17147 ios.width(0);
17148 {
17149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17150 std::string ex(str, iter.base());
17151 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17152 assert(ios.width() == 0);
17153 }
17154 ios.width(25);
17155 left(ios);
17156 {
17157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17158 std::string ex(str, iter.base());
17159 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17160 assert(ios.width() == 0);
17161 }
17162 ios.width(25);
17163 right(ios);
17164 {
17165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17166 std::string ex(str, iter.base());
17167 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17168 assert(ios.width() == 0);
17169 }
17170 ios.width(25);
17171 internal(ios);
17172 {
17173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17174 std::string ex(str, iter.base());
17175 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17176 assert(ios.width() == 0);
17177 }
17178 }
17179 }
17180 showpoint(ios);
17181 {
17182 ios.imbue(lc);
17183 {
17184 ios.width(0);
17185 {
17186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17187 std::string ex(str, iter.base());
17188 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17189 assert(ios.width() == 0);
17190 }
17191 ios.width(25);
17192 left(ios);
17193 {
17194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17195 std::string ex(str, iter.base());
17196 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17197 assert(ios.width() == 0);
17198 }
17199 ios.width(25);
17200 right(ios);
17201 {
17202 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17203 std::string ex(str, iter.base());
17204 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17205 assert(ios.width() == 0);
17206 }
17207 ios.width(25);
17208 internal(ios);
17209 {
17210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17211 std::string ex(str, iter.base());
17212 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17213 assert(ios.width() == 0);
17214 }
17215 }
17216 ios.imbue(lg);
17217 {
17218 ios.width(0);
17219 {
17220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17221 std::string ex(str, iter.base());
17222 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17223 assert(ios.width() == 0);
17224 }
17225 ios.width(25);
17226 left(ios);
17227 {
17228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17229 std::string ex(str, iter.base());
17230 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17231 assert(ios.width() == 0);
17232 }
17233 ios.width(25);
17234 right(ios);
17235 {
17236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17237 std::string ex(str, iter.base());
17238 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17239 assert(ios.width() == 0);
17240 }
17241 ios.width(25);
17242 internal(ios);
17243 {
17244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17245 std::string ex(str, iter.base());
17246 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17247 assert(ios.width() == 0);
17248 }
17249 }
17250 }
17251 }
17252 }
17253 }
17254 }
17255 }
17256 }
17257
test8()17258 void test8()
17259 {
17260 char str[200];
17261 output_iterator<char*> iter;
17262 std::locale lc = std::locale::classic();
17263 std::locale lg(lc, new my_numpunct);
17264 const my_facet f(1);
17265 {
17266 long double v = 1234567890.125;
17267 std::ios ios(0);
17268 fixed(ios);
17269 // %f
17270 {
17271 ios.precision(0);
17272 {
17273 nouppercase(ios);
17274 {
17275 noshowpos(ios);
17276 {
17277 noshowpoint(ios);
17278 {
17279 ios.imbue(lc);
17280 {
17281 ios.width(0);
17282 {
17283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17284 std::string ex(str, iter.base());
17285 assert(ex == "1234567890");
17286 assert(ios.width() == 0);
17287 }
17288 ios.width(25);
17289 left(ios);
17290 {
17291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17292 std::string ex(str, iter.base());
17293 assert(ex == "1234567890***************");
17294 assert(ios.width() == 0);
17295 }
17296 ios.width(25);
17297 right(ios);
17298 {
17299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17300 std::string ex(str, iter.base());
17301 assert(ex == "***************1234567890");
17302 assert(ios.width() == 0);
17303 }
17304 ios.width(25);
17305 internal(ios);
17306 {
17307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17308 std::string ex(str, iter.base());
17309 assert(ex == "***************1234567890");
17310 assert(ios.width() == 0);
17311 }
17312 }
17313 ios.imbue(lg);
17314 {
17315 ios.width(0);
17316 {
17317 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17318 std::string ex(str, iter.base());
17319 assert(ex == "1_234_567_89_0");
17320 assert(ios.width() == 0);
17321 }
17322 ios.width(25);
17323 left(ios);
17324 {
17325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17326 std::string ex(str, iter.base());
17327 assert(ex == "1_234_567_89_0***********");
17328 assert(ios.width() == 0);
17329 }
17330 ios.width(25);
17331 right(ios);
17332 {
17333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17334 std::string ex(str, iter.base());
17335 assert(ex == "***********1_234_567_89_0");
17336 assert(ios.width() == 0);
17337 }
17338 ios.width(25);
17339 internal(ios);
17340 {
17341 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17342 std::string ex(str, iter.base());
17343 assert(ex == "***********1_234_567_89_0");
17344 assert(ios.width() == 0);
17345 }
17346 }
17347 }
17348 showpoint(ios);
17349 {
17350 ios.imbue(lc);
17351 {
17352 ios.width(0);
17353 {
17354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17355 std::string ex(str, iter.base());
17356 assert(ex == "1234567890.");
17357 assert(ios.width() == 0);
17358 }
17359 ios.width(25);
17360 left(ios);
17361 {
17362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17363 std::string ex(str, iter.base());
17364 assert(ex == "1234567890.**************");
17365 assert(ios.width() == 0);
17366 }
17367 ios.width(25);
17368 right(ios);
17369 {
17370 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17371 std::string ex(str, iter.base());
17372 assert(ex == "**************1234567890.");
17373 assert(ios.width() == 0);
17374 }
17375 ios.width(25);
17376 internal(ios);
17377 {
17378 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17379 std::string ex(str, iter.base());
17380 assert(ex == "**************1234567890.");
17381 assert(ios.width() == 0);
17382 }
17383 }
17384 ios.imbue(lg);
17385 {
17386 ios.width(0);
17387 {
17388 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17389 std::string ex(str, iter.base());
17390 assert(ex == "1_234_567_89_0;");
17391 assert(ios.width() == 0);
17392 }
17393 ios.width(25);
17394 left(ios);
17395 {
17396 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17397 std::string ex(str, iter.base());
17398 assert(ex == "1_234_567_89_0;**********");
17399 assert(ios.width() == 0);
17400 }
17401 ios.width(25);
17402 right(ios);
17403 {
17404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17405 std::string ex(str, iter.base());
17406 assert(ex == "**********1_234_567_89_0;");
17407 assert(ios.width() == 0);
17408 }
17409 ios.width(25);
17410 internal(ios);
17411 {
17412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17413 std::string ex(str, iter.base());
17414 assert(ex == "**********1_234_567_89_0;");
17415 assert(ios.width() == 0);
17416 }
17417 }
17418 }
17419 }
17420 showpos(ios);
17421 {
17422 noshowpoint(ios);
17423 {
17424 ios.imbue(lc);
17425 {
17426 ios.width(0);
17427 {
17428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17429 std::string ex(str, iter.base());
17430 assert(ex == "+1234567890");
17431 assert(ios.width() == 0);
17432 }
17433 ios.width(25);
17434 left(ios);
17435 {
17436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17437 std::string ex(str, iter.base());
17438 assert(ex == "+1234567890**************");
17439 assert(ios.width() == 0);
17440 }
17441 ios.width(25);
17442 right(ios);
17443 {
17444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17445 std::string ex(str, iter.base());
17446 assert(ex == "**************+1234567890");
17447 assert(ios.width() == 0);
17448 }
17449 ios.width(25);
17450 internal(ios);
17451 {
17452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17453 std::string ex(str, iter.base());
17454 assert(ex == "+**************1234567890");
17455 assert(ios.width() == 0);
17456 }
17457 }
17458 ios.imbue(lg);
17459 {
17460 ios.width(0);
17461 {
17462 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17463 std::string ex(str, iter.base());
17464 assert(ex == "+1_234_567_89_0");
17465 assert(ios.width() == 0);
17466 }
17467 ios.width(25);
17468 left(ios);
17469 {
17470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17471 std::string ex(str, iter.base());
17472 assert(ex == "+1_234_567_89_0**********");
17473 assert(ios.width() == 0);
17474 }
17475 ios.width(25);
17476 right(ios);
17477 {
17478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17479 std::string ex(str, iter.base());
17480 assert(ex == "**********+1_234_567_89_0");
17481 assert(ios.width() == 0);
17482 }
17483 ios.width(25);
17484 internal(ios);
17485 {
17486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17487 std::string ex(str, iter.base());
17488 assert(ex == "+**********1_234_567_89_0");
17489 assert(ios.width() == 0);
17490 }
17491 }
17492 }
17493 showpoint(ios);
17494 {
17495 ios.imbue(lc);
17496 {
17497 ios.width(0);
17498 {
17499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17500 std::string ex(str, iter.base());
17501 assert(ex == "+1234567890.");
17502 assert(ios.width() == 0);
17503 }
17504 ios.width(25);
17505 left(ios);
17506 {
17507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17508 std::string ex(str, iter.base());
17509 assert(ex == "+1234567890.*************");
17510 assert(ios.width() == 0);
17511 }
17512 ios.width(25);
17513 right(ios);
17514 {
17515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17516 std::string ex(str, iter.base());
17517 assert(ex == "*************+1234567890.");
17518 assert(ios.width() == 0);
17519 }
17520 ios.width(25);
17521 internal(ios);
17522 {
17523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17524 std::string ex(str, iter.base());
17525 assert(ex == "+*************1234567890.");
17526 assert(ios.width() == 0);
17527 }
17528 }
17529 ios.imbue(lg);
17530 {
17531 ios.width(0);
17532 {
17533 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17534 std::string ex(str, iter.base());
17535 assert(ex == "+1_234_567_89_0;");
17536 assert(ios.width() == 0);
17537 }
17538 ios.width(25);
17539 left(ios);
17540 {
17541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17542 std::string ex(str, iter.base());
17543 assert(ex == "+1_234_567_89_0;*********");
17544 assert(ios.width() == 0);
17545 }
17546 ios.width(25);
17547 right(ios);
17548 {
17549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17550 std::string ex(str, iter.base());
17551 assert(ex == "*********+1_234_567_89_0;");
17552 assert(ios.width() == 0);
17553 }
17554 ios.width(25);
17555 internal(ios);
17556 {
17557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17558 std::string ex(str, iter.base());
17559 assert(ex == "+*********1_234_567_89_0;");
17560 assert(ios.width() == 0);
17561 }
17562 }
17563 }
17564 }
17565 }
17566 uppercase(ios);
17567 {
17568 noshowpos(ios);
17569 {
17570 noshowpoint(ios);
17571 {
17572 ios.imbue(lc);
17573 {
17574 ios.width(0);
17575 {
17576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17577 std::string ex(str, iter.base());
17578 assert(ex == "1234567890");
17579 assert(ios.width() == 0);
17580 }
17581 ios.width(25);
17582 left(ios);
17583 {
17584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17585 std::string ex(str, iter.base());
17586 assert(ex == "1234567890***************");
17587 assert(ios.width() == 0);
17588 }
17589 ios.width(25);
17590 right(ios);
17591 {
17592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17593 std::string ex(str, iter.base());
17594 assert(ex == "***************1234567890");
17595 assert(ios.width() == 0);
17596 }
17597 ios.width(25);
17598 internal(ios);
17599 {
17600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17601 std::string ex(str, iter.base());
17602 assert(ex == "***************1234567890");
17603 assert(ios.width() == 0);
17604 }
17605 }
17606 ios.imbue(lg);
17607 {
17608 ios.width(0);
17609 {
17610 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17611 std::string ex(str, iter.base());
17612 assert(ex == "1_234_567_89_0");
17613 assert(ios.width() == 0);
17614 }
17615 ios.width(25);
17616 left(ios);
17617 {
17618 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17619 std::string ex(str, iter.base());
17620 assert(ex == "1_234_567_89_0***********");
17621 assert(ios.width() == 0);
17622 }
17623 ios.width(25);
17624 right(ios);
17625 {
17626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17627 std::string ex(str, iter.base());
17628 assert(ex == "***********1_234_567_89_0");
17629 assert(ios.width() == 0);
17630 }
17631 ios.width(25);
17632 internal(ios);
17633 {
17634 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17635 std::string ex(str, iter.base());
17636 assert(ex == "***********1_234_567_89_0");
17637 assert(ios.width() == 0);
17638 }
17639 }
17640 }
17641 showpoint(ios);
17642 {
17643 ios.imbue(lc);
17644 {
17645 ios.width(0);
17646 {
17647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17648 std::string ex(str, iter.base());
17649 assert(ex == "1234567890.");
17650 assert(ios.width() == 0);
17651 }
17652 ios.width(25);
17653 left(ios);
17654 {
17655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17656 std::string ex(str, iter.base());
17657 assert(ex == "1234567890.**************");
17658 assert(ios.width() == 0);
17659 }
17660 ios.width(25);
17661 right(ios);
17662 {
17663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17664 std::string ex(str, iter.base());
17665 assert(ex == "**************1234567890.");
17666 assert(ios.width() == 0);
17667 }
17668 ios.width(25);
17669 internal(ios);
17670 {
17671 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17672 std::string ex(str, iter.base());
17673 assert(ex == "**************1234567890.");
17674 assert(ios.width() == 0);
17675 }
17676 }
17677 ios.imbue(lg);
17678 {
17679 ios.width(0);
17680 {
17681 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17682 std::string ex(str, iter.base());
17683 assert(ex == "1_234_567_89_0;");
17684 assert(ios.width() == 0);
17685 }
17686 ios.width(25);
17687 left(ios);
17688 {
17689 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17690 std::string ex(str, iter.base());
17691 assert(ex == "1_234_567_89_0;**********");
17692 assert(ios.width() == 0);
17693 }
17694 ios.width(25);
17695 right(ios);
17696 {
17697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17698 std::string ex(str, iter.base());
17699 assert(ex == "**********1_234_567_89_0;");
17700 assert(ios.width() == 0);
17701 }
17702 ios.width(25);
17703 internal(ios);
17704 {
17705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17706 std::string ex(str, iter.base());
17707 assert(ex == "**********1_234_567_89_0;");
17708 assert(ios.width() == 0);
17709 }
17710 }
17711 }
17712 }
17713 showpos(ios);
17714 {
17715 noshowpoint(ios);
17716 {
17717 ios.imbue(lc);
17718 {
17719 ios.width(0);
17720 {
17721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17722 std::string ex(str, iter.base());
17723 assert(ex == "+1234567890");
17724 assert(ios.width() == 0);
17725 }
17726 ios.width(25);
17727 left(ios);
17728 {
17729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17730 std::string ex(str, iter.base());
17731 assert(ex == "+1234567890**************");
17732 assert(ios.width() == 0);
17733 }
17734 ios.width(25);
17735 right(ios);
17736 {
17737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17738 std::string ex(str, iter.base());
17739 assert(ex == "**************+1234567890");
17740 assert(ios.width() == 0);
17741 }
17742 ios.width(25);
17743 internal(ios);
17744 {
17745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17746 std::string ex(str, iter.base());
17747 assert(ex == "+**************1234567890");
17748 assert(ios.width() == 0);
17749 }
17750 }
17751 ios.imbue(lg);
17752 {
17753 ios.width(0);
17754 {
17755 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17756 std::string ex(str, iter.base());
17757 assert(ex == "+1_234_567_89_0");
17758 assert(ios.width() == 0);
17759 }
17760 ios.width(25);
17761 left(ios);
17762 {
17763 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17764 std::string ex(str, iter.base());
17765 assert(ex == "+1_234_567_89_0**********");
17766 assert(ios.width() == 0);
17767 }
17768 ios.width(25);
17769 right(ios);
17770 {
17771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17772 std::string ex(str, iter.base());
17773 assert(ex == "**********+1_234_567_89_0");
17774 assert(ios.width() == 0);
17775 }
17776 ios.width(25);
17777 internal(ios);
17778 {
17779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17780 std::string ex(str, iter.base());
17781 assert(ex == "+**********1_234_567_89_0");
17782 assert(ios.width() == 0);
17783 }
17784 }
17785 }
17786 showpoint(ios);
17787 {
17788 ios.imbue(lc);
17789 {
17790 ios.width(0);
17791 {
17792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17793 std::string ex(str, iter.base());
17794 assert(ex == "+1234567890.");
17795 assert(ios.width() == 0);
17796 }
17797 ios.width(25);
17798 left(ios);
17799 {
17800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17801 std::string ex(str, iter.base());
17802 assert(ex == "+1234567890.*************");
17803 assert(ios.width() == 0);
17804 }
17805 ios.width(25);
17806 right(ios);
17807 {
17808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17809 std::string ex(str, iter.base());
17810 assert(ex == "*************+1234567890.");
17811 assert(ios.width() == 0);
17812 }
17813 ios.width(25);
17814 internal(ios);
17815 {
17816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17817 std::string ex(str, iter.base());
17818 assert(ex == "+*************1234567890.");
17819 assert(ios.width() == 0);
17820 }
17821 }
17822 ios.imbue(lg);
17823 {
17824 ios.width(0);
17825 {
17826 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17827 std::string ex(str, iter.base());
17828 assert(ex == "+1_234_567_89_0;");
17829 assert(ios.width() == 0);
17830 }
17831 ios.width(25);
17832 left(ios);
17833 {
17834 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17835 std::string ex(str, iter.base());
17836 assert(ex == "+1_234_567_89_0;*********");
17837 assert(ios.width() == 0);
17838 }
17839 ios.width(25);
17840 right(ios);
17841 {
17842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17843 std::string ex(str, iter.base());
17844 assert(ex == "*********+1_234_567_89_0;");
17845 assert(ios.width() == 0);
17846 }
17847 ios.width(25);
17848 internal(ios);
17849 {
17850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17851 std::string ex(str, iter.base());
17852 assert(ex == "+*********1_234_567_89_0;");
17853 assert(ios.width() == 0);
17854 }
17855 }
17856 }
17857 }
17858 }
17859 }
17860 ios.precision(1);
17861 {
17862 nouppercase(ios);
17863 {
17864 noshowpos(ios);
17865 {
17866 noshowpoint(ios);
17867 {
17868 ios.imbue(lc);
17869 {
17870 ios.width(0);
17871 {
17872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17873 std::string ex(str, iter.base());
17874 assert(ex == "1234567890.1");
17875 assert(ios.width() == 0);
17876 }
17877 ios.width(25);
17878 left(ios);
17879 {
17880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17881 std::string ex(str, iter.base());
17882 assert(ex == "1234567890.1*************");
17883 assert(ios.width() == 0);
17884 }
17885 ios.width(25);
17886 right(ios);
17887 {
17888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17889 std::string ex(str, iter.base());
17890 assert(ex == "*************1234567890.1");
17891 assert(ios.width() == 0);
17892 }
17893 ios.width(25);
17894 internal(ios);
17895 {
17896 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17897 std::string ex(str, iter.base());
17898 assert(ex == "*************1234567890.1");
17899 assert(ios.width() == 0);
17900 }
17901 }
17902 ios.imbue(lg);
17903 {
17904 ios.width(0);
17905 {
17906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17907 std::string ex(str, iter.base());
17908 assert(ex == "1_234_567_89_0;1");
17909 assert(ios.width() == 0);
17910 }
17911 ios.width(25);
17912 left(ios);
17913 {
17914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17915 std::string ex(str, iter.base());
17916 assert(ex == "1_234_567_89_0;1*********");
17917 assert(ios.width() == 0);
17918 }
17919 ios.width(25);
17920 right(ios);
17921 {
17922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17923 std::string ex(str, iter.base());
17924 assert(ex == "*********1_234_567_89_0;1");
17925 assert(ios.width() == 0);
17926 }
17927 ios.width(25);
17928 internal(ios);
17929 {
17930 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17931 std::string ex(str, iter.base());
17932 assert(ex == "*********1_234_567_89_0;1");
17933 assert(ios.width() == 0);
17934 }
17935 }
17936 }
17937 showpoint(ios);
17938 {
17939 ios.imbue(lc);
17940 {
17941 ios.width(0);
17942 {
17943 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17944 std::string ex(str, iter.base());
17945 assert(ex == "1234567890.1");
17946 assert(ios.width() == 0);
17947 }
17948 ios.width(25);
17949 left(ios);
17950 {
17951 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17952 std::string ex(str, iter.base());
17953 assert(ex == "1234567890.1*************");
17954 assert(ios.width() == 0);
17955 }
17956 ios.width(25);
17957 right(ios);
17958 {
17959 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17960 std::string ex(str, iter.base());
17961 assert(ex == "*************1234567890.1");
17962 assert(ios.width() == 0);
17963 }
17964 ios.width(25);
17965 internal(ios);
17966 {
17967 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17968 std::string ex(str, iter.base());
17969 assert(ex == "*************1234567890.1");
17970 assert(ios.width() == 0);
17971 }
17972 }
17973 ios.imbue(lg);
17974 {
17975 ios.width(0);
17976 {
17977 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17978 std::string ex(str, iter.base());
17979 assert(ex == "1_234_567_89_0;1");
17980 assert(ios.width() == 0);
17981 }
17982 ios.width(25);
17983 left(ios);
17984 {
17985 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17986 std::string ex(str, iter.base());
17987 assert(ex == "1_234_567_89_0;1*********");
17988 assert(ios.width() == 0);
17989 }
17990 ios.width(25);
17991 right(ios);
17992 {
17993 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17994 std::string ex(str, iter.base());
17995 assert(ex == "*********1_234_567_89_0;1");
17996 assert(ios.width() == 0);
17997 }
17998 ios.width(25);
17999 internal(ios);
18000 {
18001 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18002 std::string ex(str, iter.base());
18003 assert(ex == "*********1_234_567_89_0;1");
18004 assert(ios.width() == 0);
18005 }
18006 }
18007 }
18008 }
18009 showpos(ios);
18010 {
18011 noshowpoint(ios);
18012 {
18013 ios.imbue(lc);
18014 {
18015 ios.width(0);
18016 {
18017 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18018 std::string ex(str, iter.base());
18019 assert(ex == "+1234567890.1");
18020 assert(ios.width() == 0);
18021 }
18022 ios.width(25);
18023 left(ios);
18024 {
18025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18026 std::string ex(str, iter.base());
18027 assert(ex == "+1234567890.1************");
18028 assert(ios.width() == 0);
18029 }
18030 ios.width(25);
18031 right(ios);
18032 {
18033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18034 std::string ex(str, iter.base());
18035 assert(ex == "************+1234567890.1");
18036 assert(ios.width() == 0);
18037 }
18038 ios.width(25);
18039 internal(ios);
18040 {
18041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18042 std::string ex(str, iter.base());
18043 assert(ex == "+************1234567890.1");
18044 assert(ios.width() == 0);
18045 }
18046 }
18047 ios.imbue(lg);
18048 {
18049 ios.width(0);
18050 {
18051 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18052 std::string ex(str, iter.base());
18053 assert(ex == "+1_234_567_89_0;1");
18054 assert(ios.width() == 0);
18055 }
18056 ios.width(25);
18057 left(ios);
18058 {
18059 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18060 std::string ex(str, iter.base());
18061 assert(ex == "+1_234_567_89_0;1********");
18062 assert(ios.width() == 0);
18063 }
18064 ios.width(25);
18065 right(ios);
18066 {
18067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18068 std::string ex(str, iter.base());
18069 assert(ex == "********+1_234_567_89_0;1");
18070 assert(ios.width() == 0);
18071 }
18072 ios.width(25);
18073 internal(ios);
18074 {
18075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18076 std::string ex(str, iter.base());
18077 assert(ex == "+********1_234_567_89_0;1");
18078 assert(ios.width() == 0);
18079 }
18080 }
18081 }
18082 showpoint(ios);
18083 {
18084 ios.imbue(lc);
18085 {
18086 ios.width(0);
18087 {
18088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18089 std::string ex(str, iter.base());
18090 assert(ex == "+1234567890.1");
18091 assert(ios.width() == 0);
18092 }
18093 ios.width(25);
18094 left(ios);
18095 {
18096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18097 std::string ex(str, iter.base());
18098 assert(ex == "+1234567890.1************");
18099 assert(ios.width() == 0);
18100 }
18101 ios.width(25);
18102 right(ios);
18103 {
18104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18105 std::string ex(str, iter.base());
18106 assert(ex == "************+1234567890.1");
18107 assert(ios.width() == 0);
18108 }
18109 ios.width(25);
18110 internal(ios);
18111 {
18112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18113 std::string ex(str, iter.base());
18114 assert(ex == "+************1234567890.1");
18115 assert(ios.width() == 0);
18116 }
18117 }
18118 ios.imbue(lg);
18119 {
18120 ios.width(0);
18121 {
18122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18123 std::string ex(str, iter.base());
18124 assert(ex == "+1_234_567_89_0;1");
18125 assert(ios.width() == 0);
18126 }
18127 ios.width(25);
18128 left(ios);
18129 {
18130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18131 std::string ex(str, iter.base());
18132 assert(ex == "+1_234_567_89_0;1********");
18133 assert(ios.width() == 0);
18134 }
18135 ios.width(25);
18136 right(ios);
18137 {
18138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18139 std::string ex(str, iter.base());
18140 assert(ex == "********+1_234_567_89_0;1");
18141 assert(ios.width() == 0);
18142 }
18143 ios.width(25);
18144 internal(ios);
18145 {
18146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18147 std::string ex(str, iter.base());
18148 assert(ex == "+********1_234_567_89_0;1");
18149 assert(ios.width() == 0);
18150 }
18151 }
18152 }
18153 }
18154 }
18155 uppercase(ios);
18156 {
18157 noshowpos(ios);
18158 {
18159 noshowpoint(ios);
18160 {
18161 ios.imbue(lc);
18162 {
18163 ios.width(0);
18164 {
18165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18166 std::string ex(str, iter.base());
18167 assert(ex == "1234567890.1");
18168 assert(ios.width() == 0);
18169 }
18170 ios.width(25);
18171 left(ios);
18172 {
18173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18174 std::string ex(str, iter.base());
18175 assert(ex == "1234567890.1*************");
18176 assert(ios.width() == 0);
18177 }
18178 ios.width(25);
18179 right(ios);
18180 {
18181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18182 std::string ex(str, iter.base());
18183 assert(ex == "*************1234567890.1");
18184 assert(ios.width() == 0);
18185 }
18186 ios.width(25);
18187 internal(ios);
18188 {
18189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18190 std::string ex(str, iter.base());
18191 assert(ex == "*************1234567890.1");
18192 assert(ios.width() == 0);
18193 }
18194 }
18195 ios.imbue(lg);
18196 {
18197 ios.width(0);
18198 {
18199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18200 std::string ex(str, iter.base());
18201 assert(ex == "1_234_567_89_0;1");
18202 assert(ios.width() == 0);
18203 }
18204 ios.width(25);
18205 left(ios);
18206 {
18207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18208 std::string ex(str, iter.base());
18209 assert(ex == "1_234_567_89_0;1*********");
18210 assert(ios.width() == 0);
18211 }
18212 ios.width(25);
18213 right(ios);
18214 {
18215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18216 std::string ex(str, iter.base());
18217 assert(ex == "*********1_234_567_89_0;1");
18218 assert(ios.width() == 0);
18219 }
18220 ios.width(25);
18221 internal(ios);
18222 {
18223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18224 std::string ex(str, iter.base());
18225 assert(ex == "*********1_234_567_89_0;1");
18226 assert(ios.width() == 0);
18227 }
18228 }
18229 }
18230 showpoint(ios);
18231 {
18232 ios.imbue(lc);
18233 {
18234 ios.width(0);
18235 {
18236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18237 std::string ex(str, iter.base());
18238 assert(ex == "1234567890.1");
18239 assert(ios.width() == 0);
18240 }
18241 ios.width(25);
18242 left(ios);
18243 {
18244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18245 std::string ex(str, iter.base());
18246 assert(ex == "1234567890.1*************");
18247 assert(ios.width() == 0);
18248 }
18249 ios.width(25);
18250 right(ios);
18251 {
18252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18253 std::string ex(str, iter.base());
18254 assert(ex == "*************1234567890.1");
18255 assert(ios.width() == 0);
18256 }
18257 ios.width(25);
18258 internal(ios);
18259 {
18260 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18261 std::string ex(str, iter.base());
18262 assert(ex == "*************1234567890.1");
18263 assert(ios.width() == 0);
18264 }
18265 }
18266 ios.imbue(lg);
18267 {
18268 ios.width(0);
18269 {
18270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18271 std::string ex(str, iter.base());
18272 assert(ex == "1_234_567_89_0;1");
18273 assert(ios.width() == 0);
18274 }
18275 ios.width(25);
18276 left(ios);
18277 {
18278 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18279 std::string ex(str, iter.base());
18280 assert(ex == "1_234_567_89_0;1*********");
18281 assert(ios.width() == 0);
18282 }
18283 ios.width(25);
18284 right(ios);
18285 {
18286 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18287 std::string ex(str, iter.base());
18288 assert(ex == "*********1_234_567_89_0;1");
18289 assert(ios.width() == 0);
18290 }
18291 ios.width(25);
18292 internal(ios);
18293 {
18294 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18295 std::string ex(str, iter.base());
18296 assert(ex == "*********1_234_567_89_0;1");
18297 assert(ios.width() == 0);
18298 }
18299 }
18300 }
18301 }
18302 showpos(ios);
18303 {
18304 noshowpoint(ios);
18305 {
18306 ios.imbue(lc);
18307 {
18308 ios.width(0);
18309 {
18310 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18311 std::string ex(str, iter.base());
18312 assert(ex == "+1234567890.1");
18313 assert(ios.width() == 0);
18314 }
18315 ios.width(25);
18316 left(ios);
18317 {
18318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18319 std::string ex(str, iter.base());
18320 assert(ex == "+1234567890.1************");
18321 assert(ios.width() == 0);
18322 }
18323 ios.width(25);
18324 right(ios);
18325 {
18326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18327 std::string ex(str, iter.base());
18328 assert(ex == "************+1234567890.1");
18329 assert(ios.width() == 0);
18330 }
18331 ios.width(25);
18332 internal(ios);
18333 {
18334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18335 std::string ex(str, iter.base());
18336 assert(ex == "+************1234567890.1");
18337 assert(ios.width() == 0);
18338 }
18339 }
18340 ios.imbue(lg);
18341 {
18342 ios.width(0);
18343 {
18344 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18345 std::string ex(str, iter.base());
18346 assert(ex == "+1_234_567_89_0;1");
18347 assert(ios.width() == 0);
18348 }
18349 ios.width(25);
18350 left(ios);
18351 {
18352 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18353 std::string ex(str, iter.base());
18354 assert(ex == "+1_234_567_89_0;1********");
18355 assert(ios.width() == 0);
18356 }
18357 ios.width(25);
18358 right(ios);
18359 {
18360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18361 std::string ex(str, iter.base());
18362 assert(ex == "********+1_234_567_89_0;1");
18363 assert(ios.width() == 0);
18364 }
18365 ios.width(25);
18366 internal(ios);
18367 {
18368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18369 std::string ex(str, iter.base());
18370 assert(ex == "+********1_234_567_89_0;1");
18371 assert(ios.width() == 0);
18372 }
18373 }
18374 }
18375 showpoint(ios);
18376 {
18377 ios.imbue(lc);
18378 {
18379 ios.width(0);
18380 {
18381 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18382 std::string ex(str, iter.base());
18383 assert(ex == "+1234567890.1");
18384 assert(ios.width() == 0);
18385 }
18386 ios.width(25);
18387 left(ios);
18388 {
18389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18390 std::string ex(str, iter.base());
18391 assert(ex == "+1234567890.1************");
18392 assert(ios.width() == 0);
18393 }
18394 ios.width(25);
18395 right(ios);
18396 {
18397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18398 std::string ex(str, iter.base());
18399 assert(ex == "************+1234567890.1");
18400 assert(ios.width() == 0);
18401 }
18402 ios.width(25);
18403 internal(ios);
18404 {
18405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18406 std::string ex(str, iter.base());
18407 assert(ex == "+************1234567890.1");
18408 assert(ios.width() == 0);
18409 }
18410 }
18411 ios.imbue(lg);
18412 {
18413 ios.width(0);
18414 {
18415 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18416 std::string ex(str, iter.base());
18417 assert(ex == "+1_234_567_89_0;1");
18418 assert(ios.width() == 0);
18419 }
18420 ios.width(25);
18421 left(ios);
18422 {
18423 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18424 std::string ex(str, iter.base());
18425 assert(ex == "+1_234_567_89_0;1********");
18426 assert(ios.width() == 0);
18427 }
18428 ios.width(25);
18429 right(ios);
18430 {
18431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18432 std::string ex(str, iter.base());
18433 assert(ex == "********+1_234_567_89_0;1");
18434 assert(ios.width() == 0);
18435 }
18436 ios.width(25);
18437 internal(ios);
18438 {
18439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18440 std::string ex(str, iter.base());
18441 assert(ex == "+********1_234_567_89_0;1");
18442 assert(ios.width() == 0);
18443 }
18444 }
18445 }
18446 }
18447 }
18448 }
18449 ios.precision(6);
18450 {
18451 nouppercase(ios);
18452 {
18453 noshowpos(ios);
18454 {
18455 noshowpoint(ios);
18456 {
18457 ios.imbue(lc);
18458 {
18459 ios.width(0);
18460 {
18461 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18462 std::string ex(str, iter.base());
18463 assert(ex == "1234567890.125000");
18464 assert(ios.width() == 0);
18465 }
18466 ios.width(25);
18467 left(ios);
18468 {
18469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18470 std::string ex(str, iter.base());
18471 assert(ex == "1234567890.125000********");
18472 assert(ios.width() == 0);
18473 }
18474 ios.width(25);
18475 right(ios);
18476 {
18477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18478 std::string ex(str, iter.base());
18479 assert(ex == "********1234567890.125000");
18480 assert(ios.width() == 0);
18481 }
18482 ios.width(25);
18483 internal(ios);
18484 {
18485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18486 std::string ex(str, iter.base());
18487 assert(ex == "********1234567890.125000");
18488 assert(ios.width() == 0);
18489 }
18490 }
18491 ios.imbue(lg);
18492 {
18493 ios.width(0);
18494 {
18495 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18496 std::string ex(str, iter.base());
18497 assert(ex == "1_234_567_89_0;125000");
18498 assert(ios.width() == 0);
18499 }
18500 ios.width(25);
18501 left(ios);
18502 {
18503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18504 std::string ex(str, iter.base());
18505 assert(ex == "1_234_567_89_0;125000****");
18506 assert(ios.width() == 0);
18507 }
18508 ios.width(25);
18509 right(ios);
18510 {
18511 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18512 std::string ex(str, iter.base());
18513 assert(ex == "****1_234_567_89_0;125000");
18514 assert(ios.width() == 0);
18515 }
18516 ios.width(25);
18517 internal(ios);
18518 {
18519 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18520 std::string ex(str, iter.base());
18521 assert(ex == "****1_234_567_89_0;125000");
18522 assert(ios.width() == 0);
18523 }
18524 }
18525 }
18526 showpoint(ios);
18527 {
18528 ios.imbue(lc);
18529 {
18530 ios.width(0);
18531 {
18532 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18533 std::string ex(str, iter.base());
18534 assert(ex == "1234567890.125000");
18535 assert(ios.width() == 0);
18536 }
18537 ios.width(25);
18538 left(ios);
18539 {
18540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18541 std::string ex(str, iter.base());
18542 assert(ex == "1234567890.125000********");
18543 assert(ios.width() == 0);
18544 }
18545 ios.width(25);
18546 right(ios);
18547 {
18548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18549 std::string ex(str, iter.base());
18550 assert(ex == "********1234567890.125000");
18551 assert(ios.width() == 0);
18552 }
18553 ios.width(25);
18554 internal(ios);
18555 {
18556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18557 std::string ex(str, iter.base());
18558 assert(ex == "********1234567890.125000");
18559 assert(ios.width() == 0);
18560 }
18561 }
18562 ios.imbue(lg);
18563 {
18564 ios.width(0);
18565 {
18566 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18567 std::string ex(str, iter.base());
18568 assert(ex == "1_234_567_89_0;125000");
18569 assert(ios.width() == 0);
18570 }
18571 ios.width(25);
18572 left(ios);
18573 {
18574 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18575 std::string ex(str, iter.base());
18576 assert(ex == "1_234_567_89_0;125000****");
18577 assert(ios.width() == 0);
18578 }
18579 ios.width(25);
18580 right(ios);
18581 {
18582 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18583 std::string ex(str, iter.base());
18584 assert(ex == "****1_234_567_89_0;125000");
18585 assert(ios.width() == 0);
18586 }
18587 ios.width(25);
18588 internal(ios);
18589 {
18590 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18591 std::string ex(str, iter.base());
18592 assert(ex == "****1_234_567_89_0;125000");
18593 assert(ios.width() == 0);
18594 }
18595 }
18596 }
18597 }
18598 showpos(ios);
18599 {
18600 noshowpoint(ios);
18601 {
18602 ios.imbue(lc);
18603 {
18604 ios.width(0);
18605 {
18606 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18607 std::string ex(str, iter.base());
18608 assert(ex == "+1234567890.125000");
18609 assert(ios.width() == 0);
18610 }
18611 ios.width(25);
18612 left(ios);
18613 {
18614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18615 std::string ex(str, iter.base());
18616 assert(ex == "+1234567890.125000*******");
18617 assert(ios.width() == 0);
18618 }
18619 ios.width(25);
18620 right(ios);
18621 {
18622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18623 std::string ex(str, iter.base());
18624 assert(ex == "*******+1234567890.125000");
18625 assert(ios.width() == 0);
18626 }
18627 ios.width(25);
18628 internal(ios);
18629 {
18630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18631 std::string ex(str, iter.base());
18632 assert(ex == "+*******1234567890.125000");
18633 assert(ios.width() == 0);
18634 }
18635 }
18636 ios.imbue(lg);
18637 {
18638 ios.width(0);
18639 {
18640 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18641 std::string ex(str, iter.base());
18642 assert(ex == "+1_234_567_89_0;125000");
18643 assert(ios.width() == 0);
18644 }
18645 ios.width(25);
18646 left(ios);
18647 {
18648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18649 std::string ex(str, iter.base());
18650 assert(ex == "+1_234_567_89_0;125000***");
18651 assert(ios.width() == 0);
18652 }
18653 ios.width(25);
18654 right(ios);
18655 {
18656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18657 std::string ex(str, iter.base());
18658 assert(ex == "***+1_234_567_89_0;125000");
18659 assert(ios.width() == 0);
18660 }
18661 ios.width(25);
18662 internal(ios);
18663 {
18664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18665 std::string ex(str, iter.base());
18666 assert(ex == "+***1_234_567_89_0;125000");
18667 assert(ios.width() == 0);
18668 }
18669 }
18670 }
18671 showpoint(ios);
18672 {
18673 ios.imbue(lc);
18674 {
18675 ios.width(0);
18676 {
18677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18678 std::string ex(str, iter.base());
18679 assert(ex == "+1234567890.125000");
18680 assert(ios.width() == 0);
18681 }
18682 ios.width(25);
18683 left(ios);
18684 {
18685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18686 std::string ex(str, iter.base());
18687 assert(ex == "+1234567890.125000*******");
18688 assert(ios.width() == 0);
18689 }
18690 ios.width(25);
18691 right(ios);
18692 {
18693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18694 std::string ex(str, iter.base());
18695 assert(ex == "*******+1234567890.125000");
18696 assert(ios.width() == 0);
18697 }
18698 ios.width(25);
18699 internal(ios);
18700 {
18701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18702 std::string ex(str, iter.base());
18703 assert(ex == "+*******1234567890.125000");
18704 assert(ios.width() == 0);
18705 }
18706 }
18707 ios.imbue(lg);
18708 {
18709 ios.width(0);
18710 {
18711 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18712 std::string ex(str, iter.base());
18713 assert(ex == "+1_234_567_89_0;125000");
18714 assert(ios.width() == 0);
18715 }
18716 ios.width(25);
18717 left(ios);
18718 {
18719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18720 std::string ex(str, iter.base());
18721 assert(ex == "+1_234_567_89_0;125000***");
18722 assert(ios.width() == 0);
18723 }
18724 ios.width(25);
18725 right(ios);
18726 {
18727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18728 std::string ex(str, iter.base());
18729 assert(ex == "***+1_234_567_89_0;125000");
18730 assert(ios.width() == 0);
18731 }
18732 ios.width(25);
18733 internal(ios);
18734 {
18735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18736 std::string ex(str, iter.base());
18737 assert(ex == "+***1_234_567_89_0;125000");
18738 assert(ios.width() == 0);
18739 }
18740 }
18741 }
18742 }
18743 }
18744 uppercase(ios);
18745 {
18746 noshowpos(ios);
18747 {
18748 noshowpoint(ios);
18749 {
18750 ios.imbue(lc);
18751 {
18752 ios.width(0);
18753 {
18754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18755 std::string ex(str, iter.base());
18756 assert(ex == "1234567890.125000");
18757 assert(ios.width() == 0);
18758 }
18759 ios.width(25);
18760 left(ios);
18761 {
18762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18763 std::string ex(str, iter.base());
18764 assert(ex == "1234567890.125000********");
18765 assert(ios.width() == 0);
18766 }
18767 ios.width(25);
18768 right(ios);
18769 {
18770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18771 std::string ex(str, iter.base());
18772 assert(ex == "********1234567890.125000");
18773 assert(ios.width() == 0);
18774 }
18775 ios.width(25);
18776 internal(ios);
18777 {
18778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18779 std::string ex(str, iter.base());
18780 assert(ex == "********1234567890.125000");
18781 assert(ios.width() == 0);
18782 }
18783 }
18784 ios.imbue(lg);
18785 {
18786 ios.width(0);
18787 {
18788 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18789 std::string ex(str, iter.base());
18790 assert(ex == "1_234_567_89_0;125000");
18791 assert(ios.width() == 0);
18792 }
18793 ios.width(25);
18794 left(ios);
18795 {
18796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18797 std::string ex(str, iter.base());
18798 assert(ex == "1_234_567_89_0;125000****");
18799 assert(ios.width() == 0);
18800 }
18801 ios.width(25);
18802 right(ios);
18803 {
18804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18805 std::string ex(str, iter.base());
18806 assert(ex == "****1_234_567_89_0;125000");
18807 assert(ios.width() == 0);
18808 }
18809 ios.width(25);
18810 internal(ios);
18811 {
18812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18813 std::string ex(str, iter.base());
18814 assert(ex == "****1_234_567_89_0;125000");
18815 assert(ios.width() == 0);
18816 }
18817 }
18818 }
18819 showpoint(ios);
18820 {
18821 ios.imbue(lc);
18822 {
18823 ios.width(0);
18824 {
18825 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18826 std::string ex(str, iter.base());
18827 assert(ex == "1234567890.125000");
18828 assert(ios.width() == 0);
18829 }
18830 ios.width(25);
18831 left(ios);
18832 {
18833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18834 std::string ex(str, iter.base());
18835 assert(ex == "1234567890.125000********");
18836 assert(ios.width() == 0);
18837 }
18838 ios.width(25);
18839 right(ios);
18840 {
18841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18842 std::string ex(str, iter.base());
18843 assert(ex == "********1234567890.125000");
18844 assert(ios.width() == 0);
18845 }
18846 ios.width(25);
18847 internal(ios);
18848 {
18849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18850 std::string ex(str, iter.base());
18851 assert(ex == "********1234567890.125000");
18852 assert(ios.width() == 0);
18853 }
18854 }
18855 ios.imbue(lg);
18856 {
18857 ios.width(0);
18858 {
18859 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18860 std::string ex(str, iter.base());
18861 assert(ex == "1_234_567_89_0;125000");
18862 assert(ios.width() == 0);
18863 }
18864 ios.width(25);
18865 left(ios);
18866 {
18867 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18868 std::string ex(str, iter.base());
18869 assert(ex == "1_234_567_89_0;125000****");
18870 assert(ios.width() == 0);
18871 }
18872 ios.width(25);
18873 right(ios);
18874 {
18875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18876 std::string ex(str, iter.base());
18877 assert(ex == "****1_234_567_89_0;125000");
18878 assert(ios.width() == 0);
18879 }
18880 ios.width(25);
18881 internal(ios);
18882 {
18883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18884 std::string ex(str, iter.base());
18885 assert(ex == "****1_234_567_89_0;125000");
18886 assert(ios.width() == 0);
18887 }
18888 }
18889 }
18890 }
18891 showpos(ios);
18892 {
18893 noshowpoint(ios);
18894 {
18895 ios.imbue(lc);
18896 {
18897 ios.width(0);
18898 {
18899 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18900 std::string ex(str, iter.base());
18901 assert(ex == "+1234567890.125000");
18902 assert(ios.width() == 0);
18903 }
18904 ios.width(25);
18905 left(ios);
18906 {
18907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18908 std::string ex(str, iter.base());
18909 assert(ex == "+1234567890.125000*******");
18910 assert(ios.width() == 0);
18911 }
18912 ios.width(25);
18913 right(ios);
18914 {
18915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18916 std::string ex(str, iter.base());
18917 assert(ex == "*******+1234567890.125000");
18918 assert(ios.width() == 0);
18919 }
18920 ios.width(25);
18921 internal(ios);
18922 {
18923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18924 std::string ex(str, iter.base());
18925 assert(ex == "+*******1234567890.125000");
18926 assert(ios.width() == 0);
18927 }
18928 }
18929 ios.imbue(lg);
18930 {
18931 ios.width(0);
18932 {
18933 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18934 std::string ex(str, iter.base());
18935 assert(ex == "+1_234_567_89_0;125000");
18936 assert(ios.width() == 0);
18937 }
18938 ios.width(25);
18939 left(ios);
18940 {
18941 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18942 std::string ex(str, iter.base());
18943 assert(ex == "+1_234_567_89_0;125000***");
18944 assert(ios.width() == 0);
18945 }
18946 ios.width(25);
18947 right(ios);
18948 {
18949 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18950 std::string ex(str, iter.base());
18951 assert(ex == "***+1_234_567_89_0;125000");
18952 assert(ios.width() == 0);
18953 }
18954 ios.width(25);
18955 internal(ios);
18956 {
18957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18958 std::string ex(str, iter.base());
18959 assert(ex == "+***1_234_567_89_0;125000");
18960 assert(ios.width() == 0);
18961 }
18962 }
18963 }
18964 showpoint(ios);
18965 {
18966 ios.imbue(lc);
18967 {
18968 ios.width(0);
18969 {
18970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18971 std::string ex(str, iter.base());
18972 assert(ex == "+1234567890.125000");
18973 assert(ios.width() == 0);
18974 }
18975 ios.width(25);
18976 left(ios);
18977 {
18978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18979 std::string ex(str, iter.base());
18980 assert(ex == "+1234567890.125000*******");
18981 assert(ios.width() == 0);
18982 }
18983 ios.width(25);
18984 right(ios);
18985 {
18986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18987 std::string ex(str, iter.base());
18988 assert(ex == "*******+1234567890.125000");
18989 assert(ios.width() == 0);
18990 }
18991 ios.width(25);
18992 internal(ios);
18993 {
18994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18995 std::string ex(str, iter.base());
18996 assert(ex == "+*******1234567890.125000");
18997 assert(ios.width() == 0);
18998 }
18999 }
19000 ios.imbue(lg);
19001 {
19002 ios.width(0);
19003 {
19004 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19005 std::string ex(str, iter.base());
19006 assert(ex == "+1_234_567_89_0;125000");
19007 assert(ios.width() == 0);
19008 }
19009 ios.width(25);
19010 left(ios);
19011 {
19012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19013 std::string ex(str, iter.base());
19014 assert(ex == "+1_234_567_89_0;125000***");
19015 assert(ios.width() == 0);
19016 }
19017 ios.width(25);
19018 right(ios);
19019 {
19020 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19021 std::string ex(str, iter.base());
19022 assert(ex == "***+1_234_567_89_0;125000");
19023 assert(ios.width() == 0);
19024 }
19025 ios.width(25);
19026 internal(ios);
19027 {
19028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19029 std::string ex(str, iter.base());
19030 assert(ex == "+***1_234_567_89_0;125000");
19031 assert(ios.width() == 0);
19032 }
19033 }
19034 }
19035 }
19036 }
19037 }
19038 ios.precision(16);
19039 {}
19040 ios.precision(60);
19041 {}
19042 }
19043 }
19044 }
19045
test9()19046 void test9()
19047 {
19048 char str[200];
19049 output_iterator<char*> iter;
19050 std::locale lc = std::locale::classic();
19051 std::locale lg(lc, new my_numpunct);
19052 const my_facet f(1);
19053 {
19054 long double v = -0.;
19055 std::ios ios(0);
19056 scientific(ios);
19057 // %e
19058 {
19059 ios.precision(0);
19060 {
19061 nouppercase(ios);
19062 {
19063 noshowpos(ios);
19064 {
19065 noshowpoint(ios);
19066 {
19067 ios.imbue(lc);
19068 {
19069 ios.width(0);
19070 {
19071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19072 std::string ex(str, iter.base());
19073 assert(ex == "-0e+00");
19074 assert(ios.width() == 0);
19075 }
19076 ios.width(25);
19077 left(ios);
19078 {
19079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19080 std::string ex(str, iter.base());
19081 assert(ex == "-0e+00*******************");
19082 assert(ios.width() == 0);
19083 }
19084 ios.width(25);
19085 right(ios);
19086 {
19087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19088 std::string ex(str, iter.base());
19089 assert(ex == "*******************-0e+00");
19090 assert(ios.width() == 0);
19091 }
19092 ios.width(25);
19093 internal(ios);
19094 {
19095 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19096 std::string ex(str, iter.base());
19097 assert(ex == "-*******************0e+00");
19098 assert(ios.width() == 0);
19099 }
19100 }
19101 ios.imbue(lg);
19102 {
19103 ios.width(0);
19104 {
19105 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19106 std::string ex(str, iter.base());
19107 assert(ex == "-0e+00");
19108 assert(ios.width() == 0);
19109 }
19110 ios.width(25);
19111 left(ios);
19112 {
19113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19114 std::string ex(str, iter.base());
19115 assert(ex == "-0e+00*******************");
19116 assert(ios.width() == 0);
19117 }
19118 ios.width(25);
19119 right(ios);
19120 {
19121 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19122 std::string ex(str, iter.base());
19123 assert(ex == "*******************-0e+00");
19124 assert(ios.width() == 0);
19125 }
19126 ios.width(25);
19127 internal(ios);
19128 {
19129 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19130 std::string ex(str, iter.base());
19131 assert(ex == "-*******************0e+00");
19132 assert(ios.width() == 0);
19133 }
19134 }
19135 }
19136 showpoint(ios);
19137 {
19138 ios.imbue(lc);
19139 {
19140 ios.width(0);
19141 {
19142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19143 std::string ex(str, iter.base());
19144 assert(ex == "-0.e+00");
19145 assert(ios.width() == 0);
19146 }
19147 ios.width(25);
19148 left(ios);
19149 {
19150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19151 std::string ex(str, iter.base());
19152 assert(ex == "-0.e+00******************");
19153 assert(ios.width() == 0);
19154 }
19155 ios.width(25);
19156 right(ios);
19157 {
19158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19159 std::string ex(str, iter.base());
19160 assert(ex == "******************-0.e+00");
19161 assert(ios.width() == 0);
19162 }
19163 ios.width(25);
19164 internal(ios);
19165 {
19166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19167 std::string ex(str, iter.base());
19168 assert(ex == "-******************0.e+00");
19169 assert(ios.width() == 0);
19170 }
19171 }
19172 ios.imbue(lg);
19173 {
19174 ios.width(0);
19175 {
19176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19177 std::string ex(str, iter.base());
19178 assert(ex == "-0;e+00");
19179 assert(ios.width() == 0);
19180 }
19181 ios.width(25);
19182 left(ios);
19183 {
19184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19185 std::string ex(str, iter.base());
19186 assert(ex == "-0;e+00******************");
19187 assert(ios.width() == 0);
19188 }
19189 ios.width(25);
19190 right(ios);
19191 {
19192 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19193 std::string ex(str, iter.base());
19194 assert(ex == "******************-0;e+00");
19195 assert(ios.width() == 0);
19196 }
19197 ios.width(25);
19198 internal(ios);
19199 {
19200 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19201 std::string ex(str, iter.base());
19202 assert(ex == "-******************0;e+00");
19203 assert(ios.width() == 0);
19204 }
19205 }
19206 }
19207 }
19208 showpos(ios);
19209 {
19210 noshowpoint(ios);
19211 {
19212 ios.imbue(lc);
19213 {
19214 ios.width(0);
19215 {
19216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19217 std::string ex(str, iter.base());
19218 assert(ex == "-0e+00");
19219 assert(ios.width() == 0);
19220 }
19221 ios.width(25);
19222 left(ios);
19223 {
19224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19225 std::string ex(str, iter.base());
19226 assert(ex == "-0e+00*******************");
19227 assert(ios.width() == 0);
19228 }
19229 ios.width(25);
19230 right(ios);
19231 {
19232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19233 std::string ex(str, iter.base());
19234 assert(ex == "*******************-0e+00");
19235 assert(ios.width() == 0);
19236 }
19237 ios.width(25);
19238 internal(ios);
19239 {
19240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19241 std::string ex(str, iter.base());
19242 assert(ex == "-*******************0e+00");
19243 assert(ios.width() == 0);
19244 }
19245 }
19246 ios.imbue(lg);
19247 {
19248 ios.width(0);
19249 {
19250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19251 std::string ex(str, iter.base());
19252 assert(ex == "-0e+00");
19253 assert(ios.width() == 0);
19254 }
19255 ios.width(25);
19256 left(ios);
19257 {
19258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19259 std::string ex(str, iter.base());
19260 assert(ex == "-0e+00*******************");
19261 assert(ios.width() == 0);
19262 }
19263 ios.width(25);
19264 right(ios);
19265 {
19266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19267 std::string ex(str, iter.base());
19268 assert(ex == "*******************-0e+00");
19269 assert(ios.width() == 0);
19270 }
19271 ios.width(25);
19272 internal(ios);
19273 {
19274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19275 std::string ex(str, iter.base());
19276 assert(ex == "-*******************0e+00");
19277 assert(ios.width() == 0);
19278 }
19279 }
19280 }
19281 showpoint(ios);
19282 {
19283 ios.imbue(lc);
19284 {
19285 ios.width(0);
19286 {
19287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19288 std::string ex(str, iter.base());
19289 assert(ex == "-0.e+00");
19290 assert(ios.width() == 0);
19291 }
19292 ios.width(25);
19293 left(ios);
19294 {
19295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19296 std::string ex(str, iter.base());
19297 assert(ex == "-0.e+00******************");
19298 assert(ios.width() == 0);
19299 }
19300 ios.width(25);
19301 right(ios);
19302 {
19303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19304 std::string ex(str, iter.base());
19305 assert(ex == "******************-0.e+00");
19306 assert(ios.width() == 0);
19307 }
19308 ios.width(25);
19309 internal(ios);
19310 {
19311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19312 std::string ex(str, iter.base());
19313 assert(ex == "-******************0.e+00");
19314 assert(ios.width() == 0);
19315 }
19316 }
19317 ios.imbue(lg);
19318 {
19319 ios.width(0);
19320 {
19321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19322 std::string ex(str, iter.base());
19323 assert(ex == "-0;e+00");
19324 assert(ios.width() == 0);
19325 }
19326 ios.width(25);
19327 left(ios);
19328 {
19329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19330 std::string ex(str, iter.base());
19331 assert(ex == "-0;e+00******************");
19332 assert(ios.width() == 0);
19333 }
19334 ios.width(25);
19335 right(ios);
19336 {
19337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19338 std::string ex(str, iter.base());
19339 assert(ex == "******************-0;e+00");
19340 assert(ios.width() == 0);
19341 }
19342 ios.width(25);
19343 internal(ios);
19344 {
19345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19346 std::string ex(str, iter.base());
19347 assert(ex == "-******************0;e+00");
19348 assert(ios.width() == 0);
19349 }
19350 }
19351 }
19352 }
19353 }
19354 uppercase(ios);
19355 {
19356 noshowpos(ios);
19357 {
19358 noshowpoint(ios);
19359 {
19360 ios.imbue(lc);
19361 {
19362 ios.width(0);
19363 {
19364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19365 std::string ex(str, iter.base());
19366 assert(ex == "-0E+00");
19367 assert(ios.width() == 0);
19368 }
19369 ios.width(25);
19370 left(ios);
19371 {
19372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19373 std::string ex(str, iter.base());
19374 assert(ex == "-0E+00*******************");
19375 assert(ios.width() == 0);
19376 }
19377 ios.width(25);
19378 right(ios);
19379 {
19380 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19381 std::string ex(str, iter.base());
19382 assert(ex == "*******************-0E+00");
19383 assert(ios.width() == 0);
19384 }
19385 ios.width(25);
19386 internal(ios);
19387 {
19388 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19389 std::string ex(str, iter.base());
19390 assert(ex == "-*******************0E+00");
19391 assert(ios.width() == 0);
19392 }
19393 }
19394 ios.imbue(lg);
19395 {
19396 ios.width(0);
19397 {
19398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19399 std::string ex(str, iter.base());
19400 assert(ex == "-0E+00");
19401 assert(ios.width() == 0);
19402 }
19403 ios.width(25);
19404 left(ios);
19405 {
19406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19407 std::string ex(str, iter.base());
19408 assert(ex == "-0E+00*******************");
19409 assert(ios.width() == 0);
19410 }
19411 ios.width(25);
19412 right(ios);
19413 {
19414 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19415 std::string ex(str, iter.base());
19416 assert(ex == "*******************-0E+00");
19417 assert(ios.width() == 0);
19418 }
19419 ios.width(25);
19420 internal(ios);
19421 {
19422 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19423 std::string ex(str, iter.base());
19424 assert(ex == "-*******************0E+00");
19425 assert(ios.width() == 0);
19426 }
19427 }
19428 }
19429 showpoint(ios);
19430 {
19431 ios.imbue(lc);
19432 {
19433 ios.width(0);
19434 {
19435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19436 std::string ex(str, iter.base());
19437 assert(ex == "-0.E+00");
19438 assert(ios.width() == 0);
19439 }
19440 ios.width(25);
19441 left(ios);
19442 {
19443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19444 std::string ex(str, iter.base());
19445 assert(ex == "-0.E+00******************");
19446 assert(ios.width() == 0);
19447 }
19448 ios.width(25);
19449 right(ios);
19450 {
19451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19452 std::string ex(str, iter.base());
19453 assert(ex == "******************-0.E+00");
19454 assert(ios.width() == 0);
19455 }
19456 ios.width(25);
19457 internal(ios);
19458 {
19459 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19460 std::string ex(str, iter.base());
19461 assert(ex == "-******************0.E+00");
19462 assert(ios.width() == 0);
19463 }
19464 }
19465 ios.imbue(lg);
19466 {
19467 ios.width(0);
19468 {
19469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19470 std::string ex(str, iter.base());
19471 assert(ex == "-0;E+00");
19472 assert(ios.width() == 0);
19473 }
19474 ios.width(25);
19475 left(ios);
19476 {
19477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19478 std::string ex(str, iter.base());
19479 assert(ex == "-0;E+00******************");
19480 assert(ios.width() == 0);
19481 }
19482 ios.width(25);
19483 right(ios);
19484 {
19485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19486 std::string ex(str, iter.base());
19487 assert(ex == "******************-0;E+00");
19488 assert(ios.width() == 0);
19489 }
19490 ios.width(25);
19491 internal(ios);
19492 {
19493 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19494 std::string ex(str, iter.base());
19495 assert(ex == "-******************0;E+00");
19496 assert(ios.width() == 0);
19497 }
19498 }
19499 }
19500 }
19501 showpos(ios);
19502 {
19503 noshowpoint(ios);
19504 {
19505 ios.imbue(lc);
19506 {
19507 ios.width(0);
19508 {
19509 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19510 std::string ex(str, iter.base());
19511 assert(ex == "-0E+00");
19512 assert(ios.width() == 0);
19513 }
19514 ios.width(25);
19515 left(ios);
19516 {
19517 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19518 std::string ex(str, iter.base());
19519 assert(ex == "-0E+00*******************");
19520 assert(ios.width() == 0);
19521 }
19522 ios.width(25);
19523 right(ios);
19524 {
19525 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19526 std::string ex(str, iter.base());
19527 assert(ex == "*******************-0E+00");
19528 assert(ios.width() == 0);
19529 }
19530 ios.width(25);
19531 internal(ios);
19532 {
19533 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19534 std::string ex(str, iter.base());
19535 assert(ex == "-*******************0E+00");
19536 assert(ios.width() == 0);
19537 }
19538 }
19539 ios.imbue(lg);
19540 {
19541 ios.width(0);
19542 {
19543 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19544 std::string ex(str, iter.base());
19545 assert(ex == "-0E+00");
19546 assert(ios.width() == 0);
19547 }
19548 ios.width(25);
19549 left(ios);
19550 {
19551 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19552 std::string ex(str, iter.base());
19553 assert(ex == "-0E+00*******************");
19554 assert(ios.width() == 0);
19555 }
19556 ios.width(25);
19557 right(ios);
19558 {
19559 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19560 std::string ex(str, iter.base());
19561 assert(ex == "*******************-0E+00");
19562 assert(ios.width() == 0);
19563 }
19564 ios.width(25);
19565 internal(ios);
19566 {
19567 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19568 std::string ex(str, iter.base());
19569 assert(ex == "-*******************0E+00");
19570 assert(ios.width() == 0);
19571 }
19572 }
19573 }
19574 showpoint(ios);
19575 {
19576 ios.imbue(lc);
19577 {
19578 ios.width(0);
19579 {
19580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19581 std::string ex(str, iter.base());
19582 assert(ex == "-0.E+00");
19583 assert(ios.width() == 0);
19584 }
19585 ios.width(25);
19586 left(ios);
19587 {
19588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19589 std::string ex(str, iter.base());
19590 assert(ex == "-0.E+00******************");
19591 assert(ios.width() == 0);
19592 }
19593 ios.width(25);
19594 right(ios);
19595 {
19596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19597 std::string ex(str, iter.base());
19598 assert(ex == "******************-0.E+00");
19599 assert(ios.width() == 0);
19600 }
19601 ios.width(25);
19602 internal(ios);
19603 {
19604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19605 std::string ex(str, iter.base());
19606 assert(ex == "-******************0.E+00");
19607 assert(ios.width() == 0);
19608 }
19609 }
19610 ios.imbue(lg);
19611 {
19612 ios.width(0);
19613 {
19614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19615 std::string ex(str, iter.base());
19616 assert(ex == "-0;E+00");
19617 assert(ios.width() == 0);
19618 }
19619 ios.width(25);
19620 left(ios);
19621 {
19622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19623 std::string ex(str, iter.base());
19624 assert(ex == "-0;E+00******************");
19625 assert(ios.width() == 0);
19626 }
19627 ios.width(25);
19628 right(ios);
19629 {
19630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19631 std::string ex(str, iter.base());
19632 assert(ex == "******************-0;E+00");
19633 assert(ios.width() == 0);
19634 }
19635 ios.width(25);
19636 internal(ios);
19637 {
19638 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19639 std::string ex(str, iter.base());
19640 assert(ex == "-******************0;E+00");
19641 assert(ios.width() == 0);
19642 }
19643 }
19644 }
19645 }
19646 }
19647 }
19648 ios.precision(1);
19649 {
19650 nouppercase(ios);
19651 {
19652 noshowpos(ios);
19653 {
19654 noshowpoint(ios);
19655 {
19656 ios.imbue(lc);
19657 {
19658 ios.width(0);
19659 {
19660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19661 std::string ex(str, iter.base());
19662 assert(ex == "-0.0e+00");
19663 assert(ios.width() == 0);
19664 }
19665 ios.width(25);
19666 left(ios);
19667 {
19668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19669 std::string ex(str, iter.base());
19670 assert(ex == "-0.0e+00*****************");
19671 assert(ios.width() == 0);
19672 }
19673 ios.width(25);
19674 right(ios);
19675 {
19676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19677 std::string ex(str, iter.base());
19678 assert(ex == "*****************-0.0e+00");
19679 assert(ios.width() == 0);
19680 }
19681 ios.width(25);
19682 internal(ios);
19683 {
19684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19685 std::string ex(str, iter.base());
19686 assert(ex == "-*****************0.0e+00");
19687 assert(ios.width() == 0);
19688 }
19689 }
19690 ios.imbue(lg);
19691 {
19692 ios.width(0);
19693 {
19694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19695 std::string ex(str, iter.base());
19696 assert(ex == "-0;0e+00");
19697 assert(ios.width() == 0);
19698 }
19699 ios.width(25);
19700 left(ios);
19701 {
19702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19703 std::string ex(str, iter.base());
19704 assert(ex == "-0;0e+00*****************");
19705 assert(ios.width() == 0);
19706 }
19707 ios.width(25);
19708 right(ios);
19709 {
19710 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19711 std::string ex(str, iter.base());
19712 assert(ex == "*****************-0;0e+00");
19713 assert(ios.width() == 0);
19714 }
19715 ios.width(25);
19716 internal(ios);
19717 {
19718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19719 std::string ex(str, iter.base());
19720 assert(ex == "-*****************0;0e+00");
19721 assert(ios.width() == 0);
19722 }
19723 }
19724 }
19725 showpoint(ios);
19726 {
19727 ios.imbue(lc);
19728 {
19729 ios.width(0);
19730 {
19731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19732 std::string ex(str, iter.base());
19733 assert(ex == "-0.0e+00");
19734 assert(ios.width() == 0);
19735 }
19736 ios.width(25);
19737 left(ios);
19738 {
19739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19740 std::string ex(str, iter.base());
19741 assert(ex == "-0.0e+00*****************");
19742 assert(ios.width() == 0);
19743 }
19744 ios.width(25);
19745 right(ios);
19746 {
19747 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19748 std::string ex(str, iter.base());
19749 assert(ex == "*****************-0.0e+00");
19750 assert(ios.width() == 0);
19751 }
19752 ios.width(25);
19753 internal(ios);
19754 {
19755 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19756 std::string ex(str, iter.base());
19757 assert(ex == "-*****************0.0e+00");
19758 assert(ios.width() == 0);
19759 }
19760 }
19761 ios.imbue(lg);
19762 {
19763 ios.width(0);
19764 {
19765 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19766 std::string ex(str, iter.base());
19767 assert(ex == "-0;0e+00");
19768 assert(ios.width() == 0);
19769 }
19770 ios.width(25);
19771 left(ios);
19772 {
19773 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19774 std::string ex(str, iter.base());
19775 assert(ex == "-0;0e+00*****************");
19776 assert(ios.width() == 0);
19777 }
19778 ios.width(25);
19779 right(ios);
19780 {
19781 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19782 std::string ex(str, iter.base());
19783 assert(ex == "*****************-0;0e+00");
19784 assert(ios.width() == 0);
19785 }
19786 ios.width(25);
19787 internal(ios);
19788 {
19789 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19790 std::string ex(str, iter.base());
19791 assert(ex == "-*****************0;0e+00");
19792 assert(ios.width() == 0);
19793 }
19794 }
19795 }
19796 }
19797 showpos(ios);
19798 {
19799 noshowpoint(ios);
19800 {
19801 ios.imbue(lc);
19802 {
19803 ios.width(0);
19804 {
19805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19806 std::string ex(str, iter.base());
19807 assert(ex == "-0.0e+00");
19808 assert(ios.width() == 0);
19809 }
19810 ios.width(25);
19811 left(ios);
19812 {
19813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19814 std::string ex(str, iter.base());
19815 assert(ex == "-0.0e+00*****************");
19816 assert(ios.width() == 0);
19817 }
19818 ios.width(25);
19819 right(ios);
19820 {
19821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19822 std::string ex(str, iter.base());
19823 assert(ex == "*****************-0.0e+00");
19824 assert(ios.width() == 0);
19825 }
19826 ios.width(25);
19827 internal(ios);
19828 {
19829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19830 std::string ex(str, iter.base());
19831 assert(ex == "-*****************0.0e+00");
19832 assert(ios.width() == 0);
19833 }
19834 }
19835 ios.imbue(lg);
19836 {
19837 ios.width(0);
19838 {
19839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19840 std::string ex(str, iter.base());
19841 assert(ex == "-0;0e+00");
19842 assert(ios.width() == 0);
19843 }
19844 ios.width(25);
19845 left(ios);
19846 {
19847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19848 std::string ex(str, iter.base());
19849 assert(ex == "-0;0e+00*****************");
19850 assert(ios.width() == 0);
19851 }
19852 ios.width(25);
19853 right(ios);
19854 {
19855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19856 std::string ex(str, iter.base());
19857 assert(ex == "*****************-0;0e+00");
19858 assert(ios.width() == 0);
19859 }
19860 ios.width(25);
19861 internal(ios);
19862 {
19863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19864 std::string ex(str, iter.base());
19865 assert(ex == "-*****************0;0e+00");
19866 assert(ios.width() == 0);
19867 }
19868 }
19869 }
19870 showpoint(ios);
19871 {
19872 ios.imbue(lc);
19873 {
19874 ios.width(0);
19875 {
19876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19877 std::string ex(str, iter.base());
19878 assert(ex == "-0.0e+00");
19879 assert(ios.width() == 0);
19880 }
19881 ios.width(25);
19882 left(ios);
19883 {
19884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19885 std::string ex(str, iter.base());
19886 assert(ex == "-0.0e+00*****************");
19887 assert(ios.width() == 0);
19888 }
19889 ios.width(25);
19890 right(ios);
19891 {
19892 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19893 std::string ex(str, iter.base());
19894 assert(ex == "*****************-0.0e+00");
19895 assert(ios.width() == 0);
19896 }
19897 ios.width(25);
19898 internal(ios);
19899 {
19900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19901 std::string ex(str, iter.base());
19902 assert(ex == "-*****************0.0e+00");
19903 assert(ios.width() == 0);
19904 }
19905 }
19906 ios.imbue(lg);
19907 {
19908 ios.width(0);
19909 {
19910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19911 std::string ex(str, iter.base());
19912 assert(ex == "-0;0e+00");
19913 assert(ios.width() == 0);
19914 }
19915 ios.width(25);
19916 left(ios);
19917 {
19918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19919 std::string ex(str, iter.base());
19920 assert(ex == "-0;0e+00*****************");
19921 assert(ios.width() == 0);
19922 }
19923 ios.width(25);
19924 right(ios);
19925 {
19926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19927 std::string ex(str, iter.base());
19928 assert(ex == "*****************-0;0e+00");
19929 assert(ios.width() == 0);
19930 }
19931 ios.width(25);
19932 internal(ios);
19933 {
19934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19935 std::string ex(str, iter.base());
19936 assert(ex == "-*****************0;0e+00");
19937 assert(ios.width() == 0);
19938 }
19939 }
19940 }
19941 }
19942 }
19943 uppercase(ios);
19944 {
19945 noshowpos(ios);
19946 {
19947 noshowpoint(ios);
19948 {
19949 ios.imbue(lc);
19950 {
19951 ios.width(0);
19952 {
19953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19954 std::string ex(str, iter.base());
19955 assert(ex == "-0.0E+00");
19956 assert(ios.width() == 0);
19957 }
19958 ios.width(25);
19959 left(ios);
19960 {
19961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19962 std::string ex(str, iter.base());
19963 assert(ex == "-0.0E+00*****************");
19964 assert(ios.width() == 0);
19965 }
19966 ios.width(25);
19967 right(ios);
19968 {
19969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19970 std::string ex(str, iter.base());
19971 assert(ex == "*****************-0.0E+00");
19972 assert(ios.width() == 0);
19973 }
19974 ios.width(25);
19975 internal(ios);
19976 {
19977 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19978 std::string ex(str, iter.base());
19979 assert(ex == "-*****************0.0E+00");
19980 assert(ios.width() == 0);
19981 }
19982 }
19983 ios.imbue(lg);
19984 {
19985 ios.width(0);
19986 {
19987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19988 std::string ex(str, iter.base());
19989 assert(ex == "-0;0E+00");
19990 assert(ios.width() == 0);
19991 }
19992 ios.width(25);
19993 left(ios);
19994 {
19995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19996 std::string ex(str, iter.base());
19997 assert(ex == "-0;0E+00*****************");
19998 assert(ios.width() == 0);
19999 }
20000 ios.width(25);
20001 right(ios);
20002 {
20003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20004 std::string ex(str, iter.base());
20005 assert(ex == "*****************-0;0E+00");
20006 assert(ios.width() == 0);
20007 }
20008 ios.width(25);
20009 internal(ios);
20010 {
20011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20012 std::string ex(str, iter.base());
20013 assert(ex == "-*****************0;0E+00");
20014 assert(ios.width() == 0);
20015 }
20016 }
20017 }
20018 showpoint(ios);
20019 {
20020 ios.imbue(lc);
20021 {
20022 ios.width(0);
20023 {
20024 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20025 std::string ex(str, iter.base());
20026 assert(ex == "-0.0E+00");
20027 assert(ios.width() == 0);
20028 }
20029 ios.width(25);
20030 left(ios);
20031 {
20032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20033 std::string ex(str, iter.base());
20034 assert(ex == "-0.0E+00*****************");
20035 assert(ios.width() == 0);
20036 }
20037 ios.width(25);
20038 right(ios);
20039 {
20040 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20041 std::string ex(str, iter.base());
20042 assert(ex == "*****************-0.0E+00");
20043 assert(ios.width() == 0);
20044 }
20045 ios.width(25);
20046 internal(ios);
20047 {
20048 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20049 std::string ex(str, iter.base());
20050 assert(ex == "-*****************0.0E+00");
20051 assert(ios.width() == 0);
20052 }
20053 }
20054 ios.imbue(lg);
20055 {
20056 ios.width(0);
20057 {
20058 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20059 std::string ex(str, iter.base());
20060 assert(ex == "-0;0E+00");
20061 assert(ios.width() == 0);
20062 }
20063 ios.width(25);
20064 left(ios);
20065 {
20066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20067 std::string ex(str, iter.base());
20068 assert(ex == "-0;0E+00*****************");
20069 assert(ios.width() == 0);
20070 }
20071 ios.width(25);
20072 right(ios);
20073 {
20074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20075 std::string ex(str, iter.base());
20076 assert(ex == "*****************-0;0E+00");
20077 assert(ios.width() == 0);
20078 }
20079 ios.width(25);
20080 internal(ios);
20081 {
20082 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20083 std::string ex(str, iter.base());
20084 assert(ex == "-*****************0;0E+00");
20085 assert(ios.width() == 0);
20086 }
20087 }
20088 }
20089 }
20090 showpos(ios);
20091 {
20092 noshowpoint(ios);
20093 {
20094 ios.imbue(lc);
20095 {
20096 ios.width(0);
20097 {
20098 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20099 std::string ex(str, iter.base());
20100 assert(ex == "-0.0E+00");
20101 assert(ios.width() == 0);
20102 }
20103 ios.width(25);
20104 left(ios);
20105 {
20106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20107 std::string ex(str, iter.base());
20108 assert(ex == "-0.0E+00*****************");
20109 assert(ios.width() == 0);
20110 }
20111 ios.width(25);
20112 right(ios);
20113 {
20114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20115 std::string ex(str, iter.base());
20116 assert(ex == "*****************-0.0E+00");
20117 assert(ios.width() == 0);
20118 }
20119 ios.width(25);
20120 internal(ios);
20121 {
20122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20123 std::string ex(str, iter.base());
20124 assert(ex == "-*****************0.0E+00");
20125 assert(ios.width() == 0);
20126 }
20127 }
20128 ios.imbue(lg);
20129 {
20130 ios.width(0);
20131 {
20132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20133 std::string ex(str, iter.base());
20134 assert(ex == "-0;0E+00");
20135 assert(ios.width() == 0);
20136 }
20137 ios.width(25);
20138 left(ios);
20139 {
20140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20141 std::string ex(str, iter.base());
20142 assert(ex == "-0;0E+00*****************");
20143 assert(ios.width() == 0);
20144 }
20145 ios.width(25);
20146 right(ios);
20147 {
20148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20149 std::string ex(str, iter.base());
20150 assert(ex == "*****************-0;0E+00");
20151 assert(ios.width() == 0);
20152 }
20153 ios.width(25);
20154 internal(ios);
20155 {
20156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20157 std::string ex(str, iter.base());
20158 assert(ex == "-*****************0;0E+00");
20159 assert(ios.width() == 0);
20160 }
20161 }
20162 }
20163 showpoint(ios);
20164 {
20165 ios.imbue(lc);
20166 {
20167 ios.width(0);
20168 {
20169 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20170 std::string ex(str, iter.base());
20171 assert(ex == "-0.0E+00");
20172 assert(ios.width() == 0);
20173 }
20174 ios.width(25);
20175 left(ios);
20176 {
20177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20178 std::string ex(str, iter.base());
20179 assert(ex == "-0.0E+00*****************");
20180 assert(ios.width() == 0);
20181 }
20182 ios.width(25);
20183 right(ios);
20184 {
20185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20186 std::string ex(str, iter.base());
20187 assert(ex == "*****************-0.0E+00");
20188 assert(ios.width() == 0);
20189 }
20190 ios.width(25);
20191 internal(ios);
20192 {
20193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20194 std::string ex(str, iter.base());
20195 assert(ex == "-*****************0.0E+00");
20196 assert(ios.width() == 0);
20197 }
20198 }
20199 ios.imbue(lg);
20200 {
20201 ios.width(0);
20202 {
20203 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20204 std::string ex(str, iter.base());
20205 assert(ex == "-0;0E+00");
20206 assert(ios.width() == 0);
20207 }
20208 ios.width(25);
20209 left(ios);
20210 {
20211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20212 std::string ex(str, iter.base());
20213 assert(ex == "-0;0E+00*****************");
20214 assert(ios.width() == 0);
20215 }
20216 ios.width(25);
20217 right(ios);
20218 {
20219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20220 std::string ex(str, iter.base());
20221 assert(ex == "*****************-0;0E+00");
20222 assert(ios.width() == 0);
20223 }
20224 ios.width(25);
20225 internal(ios);
20226 {
20227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20228 std::string ex(str, iter.base());
20229 assert(ex == "-*****************0;0E+00");
20230 assert(ios.width() == 0);
20231 }
20232 }
20233 }
20234 }
20235 }
20236 }
20237 ios.precision(6);
20238 {
20239 nouppercase(ios);
20240 {
20241 noshowpos(ios);
20242 {
20243 noshowpoint(ios);
20244 {
20245 ios.imbue(lc);
20246 {
20247 ios.width(0);
20248 {
20249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20250 std::string ex(str, iter.base());
20251 assert(ex == "-0.000000e+00");
20252 assert(ios.width() == 0);
20253 }
20254 ios.width(25);
20255 left(ios);
20256 {
20257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20258 std::string ex(str, iter.base());
20259 assert(ex == "-0.000000e+00************");
20260 assert(ios.width() == 0);
20261 }
20262 ios.width(25);
20263 right(ios);
20264 {
20265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20266 std::string ex(str, iter.base());
20267 assert(ex == "************-0.000000e+00");
20268 assert(ios.width() == 0);
20269 }
20270 ios.width(25);
20271 internal(ios);
20272 {
20273 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20274 std::string ex(str, iter.base());
20275 assert(ex == "-************0.000000e+00");
20276 assert(ios.width() == 0);
20277 }
20278 }
20279 ios.imbue(lg);
20280 {
20281 ios.width(0);
20282 {
20283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20284 std::string ex(str, iter.base());
20285 assert(ex == "-0;000000e+00");
20286 assert(ios.width() == 0);
20287 }
20288 ios.width(25);
20289 left(ios);
20290 {
20291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20292 std::string ex(str, iter.base());
20293 assert(ex == "-0;000000e+00************");
20294 assert(ios.width() == 0);
20295 }
20296 ios.width(25);
20297 right(ios);
20298 {
20299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20300 std::string ex(str, iter.base());
20301 assert(ex == "************-0;000000e+00");
20302 assert(ios.width() == 0);
20303 }
20304 ios.width(25);
20305 internal(ios);
20306 {
20307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20308 std::string ex(str, iter.base());
20309 assert(ex == "-************0;000000e+00");
20310 assert(ios.width() == 0);
20311 }
20312 }
20313 }
20314 showpoint(ios);
20315 {
20316 ios.imbue(lc);
20317 {
20318 ios.width(0);
20319 {
20320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20321 std::string ex(str, iter.base());
20322 assert(ex == "-0.000000e+00");
20323 assert(ios.width() == 0);
20324 }
20325 ios.width(25);
20326 left(ios);
20327 {
20328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20329 std::string ex(str, iter.base());
20330 assert(ex == "-0.000000e+00************");
20331 assert(ios.width() == 0);
20332 }
20333 ios.width(25);
20334 right(ios);
20335 {
20336 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20337 std::string ex(str, iter.base());
20338 assert(ex == "************-0.000000e+00");
20339 assert(ios.width() == 0);
20340 }
20341 ios.width(25);
20342 internal(ios);
20343 {
20344 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20345 std::string ex(str, iter.base());
20346 assert(ex == "-************0.000000e+00");
20347 assert(ios.width() == 0);
20348 }
20349 }
20350 ios.imbue(lg);
20351 {
20352 ios.width(0);
20353 {
20354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20355 std::string ex(str, iter.base());
20356 assert(ex == "-0;000000e+00");
20357 assert(ios.width() == 0);
20358 }
20359 ios.width(25);
20360 left(ios);
20361 {
20362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20363 std::string ex(str, iter.base());
20364 assert(ex == "-0;000000e+00************");
20365 assert(ios.width() == 0);
20366 }
20367 ios.width(25);
20368 right(ios);
20369 {
20370 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20371 std::string ex(str, iter.base());
20372 assert(ex == "************-0;000000e+00");
20373 assert(ios.width() == 0);
20374 }
20375 ios.width(25);
20376 internal(ios);
20377 {
20378 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20379 std::string ex(str, iter.base());
20380 assert(ex == "-************0;000000e+00");
20381 assert(ios.width() == 0);
20382 }
20383 }
20384 }
20385 }
20386 showpos(ios);
20387 {
20388 noshowpoint(ios);
20389 {
20390 ios.imbue(lc);
20391 {
20392 ios.width(0);
20393 {
20394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20395 std::string ex(str, iter.base());
20396 assert(ex == "-0.000000e+00");
20397 assert(ios.width() == 0);
20398 }
20399 ios.width(25);
20400 left(ios);
20401 {
20402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20403 std::string ex(str, iter.base());
20404 assert(ex == "-0.000000e+00************");
20405 assert(ios.width() == 0);
20406 }
20407 ios.width(25);
20408 right(ios);
20409 {
20410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20411 std::string ex(str, iter.base());
20412 assert(ex == "************-0.000000e+00");
20413 assert(ios.width() == 0);
20414 }
20415 ios.width(25);
20416 internal(ios);
20417 {
20418 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20419 std::string ex(str, iter.base());
20420 assert(ex == "-************0.000000e+00");
20421 assert(ios.width() == 0);
20422 }
20423 }
20424 ios.imbue(lg);
20425 {
20426 ios.width(0);
20427 {
20428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20429 std::string ex(str, iter.base());
20430 assert(ex == "-0;000000e+00");
20431 assert(ios.width() == 0);
20432 }
20433 ios.width(25);
20434 left(ios);
20435 {
20436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20437 std::string ex(str, iter.base());
20438 assert(ex == "-0;000000e+00************");
20439 assert(ios.width() == 0);
20440 }
20441 ios.width(25);
20442 right(ios);
20443 {
20444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20445 std::string ex(str, iter.base());
20446 assert(ex == "************-0;000000e+00");
20447 assert(ios.width() == 0);
20448 }
20449 ios.width(25);
20450 internal(ios);
20451 {
20452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20453 std::string ex(str, iter.base());
20454 assert(ex == "-************0;000000e+00");
20455 assert(ios.width() == 0);
20456 }
20457 }
20458 }
20459 showpoint(ios);
20460 {
20461 ios.imbue(lc);
20462 {
20463 ios.width(0);
20464 {
20465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20466 std::string ex(str, iter.base());
20467 assert(ex == "-0.000000e+00");
20468 assert(ios.width() == 0);
20469 }
20470 ios.width(25);
20471 left(ios);
20472 {
20473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20474 std::string ex(str, iter.base());
20475 assert(ex == "-0.000000e+00************");
20476 assert(ios.width() == 0);
20477 }
20478 ios.width(25);
20479 right(ios);
20480 {
20481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20482 std::string ex(str, iter.base());
20483 assert(ex == "************-0.000000e+00");
20484 assert(ios.width() == 0);
20485 }
20486 ios.width(25);
20487 internal(ios);
20488 {
20489 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20490 std::string ex(str, iter.base());
20491 assert(ex == "-************0.000000e+00");
20492 assert(ios.width() == 0);
20493 }
20494 }
20495 ios.imbue(lg);
20496 {
20497 ios.width(0);
20498 {
20499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20500 std::string ex(str, iter.base());
20501 assert(ex == "-0;000000e+00");
20502 assert(ios.width() == 0);
20503 }
20504 ios.width(25);
20505 left(ios);
20506 {
20507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20508 std::string ex(str, iter.base());
20509 assert(ex == "-0;000000e+00************");
20510 assert(ios.width() == 0);
20511 }
20512 ios.width(25);
20513 right(ios);
20514 {
20515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20516 std::string ex(str, iter.base());
20517 assert(ex == "************-0;000000e+00");
20518 assert(ios.width() == 0);
20519 }
20520 ios.width(25);
20521 internal(ios);
20522 {
20523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20524 std::string ex(str, iter.base());
20525 assert(ex == "-************0;000000e+00");
20526 assert(ios.width() == 0);
20527 }
20528 }
20529 }
20530 }
20531 }
20532 uppercase(ios);
20533 {
20534 noshowpos(ios);
20535 {
20536 noshowpoint(ios);
20537 {
20538 ios.imbue(lc);
20539 {
20540 ios.width(0);
20541 {
20542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20543 std::string ex(str, iter.base());
20544 assert(ex == "-0.000000E+00");
20545 assert(ios.width() == 0);
20546 }
20547 ios.width(25);
20548 left(ios);
20549 {
20550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20551 std::string ex(str, iter.base());
20552 assert(ex == "-0.000000E+00************");
20553 assert(ios.width() == 0);
20554 }
20555 ios.width(25);
20556 right(ios);
20557 {
20558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20559 std::string ex(str, iter.base());
20560 assert(ex == "************-0.000000E+00");
20561 assert(ios.width() == 0);
20562 }
20563 ios.width(25);
20564 internal(ios);
20565 {
20566 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20567 std::string ex(str, iter.base());
20568 assert(ex == "-************0.000000E+00");
20569 assert(ios.width() == 0);
20570 }
20571 }
20572 ios.imbue(lg);
20573 {
20574 ios.width(0);
20575 {
20576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20577 std::string ex(str, iter.base());
20578 assert(ex == "-0;000000E+00");
20579 assert(ios.width() == 0);
20580 }
20581 ios.width(25);
20582 left(ios);
20583 {
20584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20585 std::string ex(str, iter.base());
20586 assert(ex == "-0;000000E+00************");
20587 assert(ios.width() == 0);
20588 }
20589 ios.width(25);
20590 right(ios);
20591 {
20592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20593 std::string ex(str, iter.base());
20594 assert(ex == "************-0;000000E+00");
20595 assert(ios.width() == 0);
20596 }
20597 ios.width(25);
20598 internal(ios);
20599 {
20600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20601 std::string ex(str, iter.base());
20602 assert(ex == "-************0;000000E+00");
20603 assert(ios.width() == 0);
20604 }
20605 }
20606 }
20607 showpoint(ios);
20608 {
20609 ios.imbue(lc);
20610 {
20611 ios.width(0);
20612 {
20613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20614 std::string ex(str, iter.base());
20615 assert(ex == "-0.000000E+00");
20616 assert(ios.width() == 0);
20617 }
20618 ios.width(25);
20619 left(ios);
20620 {
20621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20622 std::string ex(str, iter.base());
20623 assert(ex == "-0.000000E+00************");
20624 assert(ios.width() == 0);
20625 }
20626 ios.width(25);
20627 right(ios);
20628 {
20629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20630 std::string ex(str, iter.base());
20631 assert(ex == "************-0.000000E+00");
20632 assert(ios.width() == 0);
20633 }
20634 ios.width(25);
20635 internal(ios);
20636 {
20637 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20638 std::string ex(str, iter.base());
20639 assert(ex == "-************0.000000E+00");
20640 assert(ios.width() == 0);
20641 }
20642 }
20643 ios.imbue(lg);
20644 {
20645 ios.width(0);
20646 {
20647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20648 std::string ex(str, iter.base());
20649 assert(ex == "-0;000000E+00");
20650 assert(ios.width() == 0);
20651 }
20652 ios.width(25);
20653 left(ios);
20654 {
20655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20656 std::string ex(str, iter.base());
20657 assert(ex == "-0;000000E+00************");
20658 assert(ios.width() == 0);
20659 }
20660 ios.width(25);
20661 right(ios);
20662 {
20663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20664 std::string ex(str, iter.base());
20665 assert(ex == "************-0;000000E+00");
20666 assert(ios.width() == 0);
20667 }
20668 ios.width(25);
20669 internal(ios);
20670 {
20671 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20672 std::string ex(str, iter.base());
20673 assert(ex == "-************0;000000E+00");
20674 assert(ios.width() == 0);
20675 }
20676 }
20677 }
20678 }
20679 showpos(ios);
20680 {
20681 noshowpoint(ios);
20682 {
20683 ios.imbue(lc);
20684 {
20685 ios.width(0);
20686 {
20687 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20688 std::string ex(str, iter.base());
20689 assert(ex == "-0.000000E+00");
20690 assert(ios.width() == 0);
20691 }
20692 ios.width(25);
20693 left(ios);
20694 {
20695 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20696 std::string ex(str, iter.base());
20697 assert(ex == "-0.000000E+00************");
20698 assert(ios.width() == 0);
20699 }
20700 ios.width(25);
20701 right(ios);
20702 {
20703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20704 std::string ex(str, iter.base());
20705 assert(ex == "************-0.000000E+00");
20706 assert(ios.width() == 0);
20707 }
20708 ios.width(25);
20709 internal(ios);
20710 {
20711 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20712 std::string ex(str, iter.base());
20713 assert(ex == "-************0.000000E+00");
20714 assert(ios.width() == 0);
20715 }
20716 }
20717 ios.imbue(lg);
20718 {
20719 ios.width(0);
20720 {
20721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20722 std::string ex(str, iter.base());
20723 assert(ex == "-0;000000E+00");
20724 assert(ios.width() == 0);
20725 }
20726 ios.width(25);
20727 left(ios);
20728 {
20729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20730 std::string ex(str, iter.base());
20731 assert(ex == "-0;000000E+00************");
20732 assert(ios.width() == 0);
20733 }
20734 ios.width(25);
20735 right(ios);
20736 {
20737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20738 std::string ex(str, iter.base());
20739 assert(ex == "************-0;000000E+00");
20740 assert(ios.width() == 0);
20741 }
20742 ios.width(25);
20743 internal(ios);
20744 {
20745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20746 std::string ex(str, iter.base());
20747 assert(ex == "-************0;000000E+00");
20748 assert(ios.width() == 0);
20749 }
20750 }
20751 }
20752 showpoint(ios);
20753 {
20754 ios.imbue(lc);
20755 {
20756 ios.width(0);
20757 {
20758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20759 std::string ex(str, iter.base());
20760 assert(ex == "-0.000000E+00");
20761 assert(ios.width() == 0);
20762 }
20763 ios.width(25);
20764 left(ios);
20765 {
20766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20767 std::string ex(str, iter.base());
20768 assert(ex == "-0.000000E+00************");
20769 assert(ios.width() == 0);
20770 }
20771 ios.width(25);
20772 right(ios);
20773 {
20774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20775 std::string ex(str, iter.base());
20776 assert(ex == "************-0.000000E+00");
20777 assert(ios.width() == 0);
20778 }
20779 ios.width(25);
20780 internal(ios);
20781 {
20782 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20783 std::string ex(str, iter.base());
20784 assert(ex == "-************0.000000E+00");
20785 assert(ios.width() == 0);
20786 }
20787 }
20788 ios.imbue(lg);
20789 {
20790 ios.width(0);
20791 {
20792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20793 std::string ex(str, iter.base());
20794 assert(ex == "-0;000000E+00");
20795 assert(ios.width() == 0);
20796 }
20797 ios.width(25);
20798 left(ios);
20799 {
20800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20801 std::string ex(str, iter.base());
20802 assert(ex == "-0;000000E+00************");
20803 assert(ios.width() == 0);
20804 }
20805 ios.width(25);
20806 right(ios);
20807 {
20808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20809 std::string ex(str, iter.base());
20810 assert(ex == "************-0;000000E+00");
20811 assert(ios.width() == 0);
20812 }
20813 ios.width(25);
20814 internal(ios);
20815 {
20816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20817 std::string ex(str, iter.base());
20818 assert(ex == "-************0;000000E+00");
20819 assert(ios.width() == 0);
20820 }
20821 }
20822 }
20823 }
20824 }
20825 }
20826 ios.precision(16);
20827 {
20828 }
20829 ios.precision(60);
20830 {
20831 }
20832 }
20833 }
20834 }
20835
test10()20836 void test10()
20837 {
20838 char str[200];
20839 output_iterator<char*> iter;
20840 std::locale lc = std::locale::classic();
20841 std::locale lg(lc, new my_numpunct);
20842 const my_facet f(1);
20843 {
20844 long double v = 1234567890.125;
20845 std::ios ios(0);
20846 scientific(ios);
20847 // %e
20848 {
20849 ios.precision(0);
20850 {
20851 nouppercase(ios);
20852 {
20853 noshowpos(ios);
20854 {
20855 noshowpoint(ios);
20856 {
20857 ios.imbue(lc);
20858 {
20859 ios.width(0);
20860 {
20861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20862 std::string ex(str, iter.base());
20863 assert(ex == "1e+09");
20864 assert(ios.width() == 0);
20865 }
20866 ios.width(25);
20867 left(ios);
20868 {
20869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20870 std::string ex(str, iter.base());
20871 assert(ex == "1e+09********************");
20872 assert(ios.width() == 0);
20873 }
20874 ios.width(25);
20875 right(ios);
20876 {
20877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20878 std::string ex(str, iter.base());
20879 assert(ex == "********************1e+09");
20880 assert(ios.width() == 0);
20881 }
20882 ios.width(25);
20883 internal(ios);
20884 {
20885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20886 std::string ex(str, iter.base());
20887 assert(ex == "********************1e+09");
20888 assert(ios.width() == 0);
20889 }
20890 }
20891 ios.imbue(lg);
20892 {
20893 ios.width(0);
20894 {
20895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20896 std::string ex(str, iter.base());
20897 assert(ex == "1e+09");
20898 assert(ios.width() == 0);
20899 }
20900 ios.width(25);
20901 left(ios);
20902 {
20903 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20904 std::string ex(str, iter.base());
20905 assert(ex == "1e+09********************");
20906 assert(ios.width() == 0);
20907 }
20908 ios.width(25);
20909 right(ios);
20910 {
20911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20912 std::string ex(str, iter.base());
20913 assert(ex == "********************1e+09");
20914 assert(ios.width() == 0);
20915 }
20916 ios.width(25);
20917 internal(ios);
20918 {
20919 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20920 std::string ex(str, iter.base());
20921 assert(ex == "********************1e+09");
20922 assert(ios.width() == 0);
20923 }
20924 }
20925 }
20926 showpoint(ios);
20927 {
20928 ios.imbue(lc);
20929 {
20930 ios.width(0);
20931 {
20932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20933 std::string ex(str, iter.base());
20934 assert(ex == "1.e+09");
20935 assert(ios.width() == 0);
20936 }
20937 ios.width(25);
20938 left(ios);
20939 {
20940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20941 std::string ex(str, iter.base());
20942 assert(ex == "1.e+09*******************");
20943 assert(ios.width() == 0);
20944 }
20945 ios.width(25);
20946 right(ios);
20947 {
20948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20949 std::string ex(str, iter.base());
20950 assert(ex == "*******************1.e+09");
20951 assert(ios.width() == 0);
20952 }
20953 ios.width(25);
20954 internal(ios);
20955 {
20956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20957 std::string ex(str, iter.base());
20958 assert(ex == "*******************1.e+09");
20959 assert(ios.width() == 0);
20960 }
20961 }
20962 ios.imbue(lg);
20963 {
20964 ios.width(0);
20965 {
20966 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20967 std::string ex(str, iter.base());
20968 assert(ex == "1;e+09");
20969 assert(ios.width() == 0);
20970 }
20971 ios.width(25);
20972 left(ios);
20973 {
20974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20975 std::string ex(str, iter.base());
20976 assert(ex == "1;e+09*******************");
20977 assert(ios.width() == 0);
20978 }
20979 ios.width(25);
20980 right(ios);
20981 {
20982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20983 std::string ex(str, iter.base());
20984 assert(ex == "*******************1;e+09");
20985 assert(ios.width() == 0);
20986 }
20987 ios.width(25);
20988 internal(ios);
20989 {
20990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20991 std::string ex(str, iter.base());
20992 assert(ex == "*******************1;e+09");
20993 assert(ios.width() == 0);
20994 }
20995 }
20996 }
20997 }
20998 showpos(ios);
20999 {
21000 noshowpoint(ios);
21001 {
21002 ios.imbue(lc);
21003 {
21004 ios.width(0);
21005 {
21006 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21007 std::string ex(str, iter.base());
21008 assert(ex == "+1e+09");
21009 assert(ios.width() == 0);
21010 }
21011 ios.width(25);
21012 left(ios);
21013 {
21014 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21015 std::string ex(str, iter.base());
21016 assert(ex == "+1e+09*******************");
21017 assert(ios.width() == 0);
21018 }
21019 ios.width(25);
21020 right(ios);
21021 {
21022 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21023 std::string ex(str, iter.base());
21024 assert(ex == "*******************+1e+09");
21025 assert(ios.width() == 0);
21026 }
21027 ios.width(25);
21028 internal(ios);
21029 {
21030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21031 std::string ex(str, iter.base());
21032 assert(ex == "+*******************1e+09");
21033 assert(ios.width() == 0);
21034 }
21035 }
21036 ios.imbue(lg);
21037 {
21038 ios.width(0);
21039 {
21040 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21041 std::string ex(str, iter.base());
21042 assert(ex == "+1e+09");
21043 assert(ios.width() == 0);
21044 }
21045 ios.width(25);
21046 left(ios);
21047 {
21048 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21049 std::string ex(str, iter.base());
21050 assert(ex == "+1e+09*******************");
21051 assert(ios.width() == 0);
21052 }
21053 ios.width(25);
21054 right(ios);
21055 {
21056 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21057 std::string ex(str, iter.base());
21058 assert(ex == "*******************+1e+09");
21059 assert(ios.width() == 0);
21060 }
21061 ios.width(25);
21062 internal(ios);
21063 {
21064 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21065 std::string ex(str, iter.base());
21066 assert(ex == "+*******************1e+09");
21067 assert(ios.width() == 0);
21068 }
21069 }
21070 }
21071 showpoint(ios);
21072 {
21073 ios.imbue(lc);
21074 {
21075 ios.width(0);
21076 {
21077 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21078 std::string ex(str, iter.base());
21079 assert(ex == "+1.e+09");
21080 assert(ios.width() == 0);
21081 }
21082 ios.width(25);
21083 left(ios);
21084 {
21085 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21086 std::string ex(str, iter.base());
21087 assert(ex == "+1.e+09******************");
21088 assert(ios.width() == 0);
21089 }
21090 ios.width(25);
21091 right(ios);
21092 {
21093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21094 std::string ex(str, iter.base());
21095 assert(ex == "******************+1.e+09");
21096 assert(ios.width() == 0);
21097 }
21098 ios.width(25);
21099 internal(ios);
21100 {
21101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21102 std::string ex(str, iter.base());
21103 assert(ex == "+******************1.e+09");
21104 assert(ios.width() == 0);
21105 }
21106 }
21107 ios.imbue(lg);
21108 {
21109 ios.width(0);
21110 {
21111 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21112 std::string ex(str, iter.base());
21113 assert(ex == "+1;e+09");
21114 assert(ios.width() == 0);
21115 }
21116 ios.width(25);
21117 left(ios);
21118 {
21119 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21120 std::string ex(str, iter.base());
21121 assert(ex == "+1;e+09******************");
21122 assert(ios.width() == 0);
21123 }
21124 ios.width(25);
21125 right(ios);
21126 {
21127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21128 std::string ex(str, iter.base());
21129 assert(ex == "******************+1;e+09");
21130 assert(ios.width() == 0);
21131 }
21132 ios.width(25);
21133 internal(ios);
21134 {
21135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21136 std::string ex(str, iter.base());
21137 assert(ex == "+******************1;e+09");
21138 assert(ios.width() == 0);
21139 }
21140 }
21141 }
21142 }
21143 }
21144 uppercase(ios);
21145 {
21146 noshowpos(ios);
21147 {
21148 noshowpoint(ios);
21149 {
21150 ios.imbue(lc);
21151 {
21152 ios.width(0);
21153 {
21154 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21155 std::string ex(str, iter.base());
21156 assert(ex == "1E+09");
21157 assert(ios.width() == 0);
21158 }
21159 ios.width(25);
21160 left(ios);
21161 {
21162 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21163 std::string ex(str, iter.base());
21164 assert(ex == "1E+09********************");
21165 assert(ios.width() == 0);
21166 }
21167 ios.width(25);
21168 right(ios);
21169 {
21170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21171 std::string ex(str, iter.base());
21172 assert(ex == "********************1E+09");
21173 assert(ios.width() == 0);
21174 }
21175 ios.width(25);
21176 internal(ios);
21177 {
21178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21179 std::string ex(str, iter.base());
21180 assert(ex == "********************1E+09");
21181 assert(ios.width() == 0);
21182 }
21183 }
21184 ios.imbue(lg);
21185 {
21186 ios.width(0);
21187 {
21188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21189 std::string ex(str, iter.base());
21190 assert(ex == "1E+09");
21191 assert(ios.width() == 0);
21192 }
21193 ios.width(25);
21194 left(ios);
21195 {
21196 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21197 std::string ex(str, iter.base());
21198 assert(ex == "1E+09********************");
21199 assert(ios.width() == 0);
21200 }
21201 ios.width(25);
21202 right(ios);
21203 {
21204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21205 std::string ex(str, iter.base());
21206 assert(ex == "********************1E+09");
21207 assert(ios.width() == 0);
21208 }
21209 ios.width(25);
21210 internal(ios);
21211 {
21212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21213 std::string ex(str, iter.base());
21214 assert(ex == "********************1E+09");
21215 assert(ios.width() == 0);
21216 }
21217 }
21218 }
21219 showpoint(ios);
21220 {
21221 ios.imbue(lc);
21222 {
21223 ios.width(0);
21224 {
21225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21226 std::string ex(str, iter.base());
21227 assert(ex == "1.E+09");
21228 assert(ios.width() == 0);
21229 }
21230 ios.width(25);
21231 left(ios);
21232 {
21233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21234 std::string ex(str, iter.base());
21235 assert(ex == "1.E+09*******************");
21236 assert(ios.width() == 0);
21237 }
21238 ios.width(25);
21239 right(ios);
21240 {
21241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21242 std::string ex(str, iter.base());
21243 assert(ex == "*******************1.E+09");
21244 assert(ios.width() == 0);
21245 }
21246 ios.width(25);
21247 internal(ios);
21248 {
21249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21250 std::string ex(str, iter.base());
21251 assert(ex == "*******************1.E+09");
21252 assert(ios.width() == 0);
21253 }
21254 }
21255 ios.imbue(lg);
21256 {
21257 ios.width(0);
21258 {
21259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21260 std::string ex(str, iter.base());
21261 assert(ex == "1;E+09");
21262 assert(ios.width() == 0);
21263 }
21264 ios.width(25);
21265 left(ios);
21266 {
21267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21268 std::string ex(str, iter.base());
21269 assert(ex == "1;E+09*******************");
21270 assert(ios.width() == 0);
21271 }
21272 ios.width(25);
21273 right(ios);
21274 {
21275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21276 std::string ex(str, iter.base());
21277 assert(ex == "*******************1;E+09");
21278 assert(ios.width() == 0);
21279 }
21280 ios.width(25);
21281 internal(ios);
21282 {
21283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21284 std::string ex(str, iter.base());
21285 assert(ex == "*******************1;E+09");
21286 assert(ios.width() == 0);
21287 }
21288 }
21289 }
21290 }
21291 showpos(ios);
21292 {
21293 noshowpoint(ios);
21294 {
21295 ios.imbue(lc);
21296 {
21297 ios.width(0);
21298 {
21299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21300 std::string ex(str, iter.base());
21301 assert(ex == "+1E+09");
21302 assert(ios.width() == 0);
21303 }
21304 ios.width(25);
21305 left(ios);
21306 {
21307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21308 std::string ex(str, iter.base());
21309 assert(ex == "+1E+09*******************");
21310 assert(ios.width() == 0);
21311 }
21312 ios.width(25);
21313 right(ios);
21314 {
21315 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21316 std::string ex(str, iter.base());
21317 assert(ex == "*******************+1E+09");
21318 assert(ios.width() == 0);
21319 }
21320 ios.width(25);
21321 internal(ios);
21322 {
21323 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21324 std::string ex(str, iter.base());
21325 assert(ex == "+*******************1E+09");
21326 assert(ios.width() == 0);
21327 }
21328 }
21329 ios.imbue(lg);
21330 {
21331 ios.width(0);
21332 {
21333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21334 std::string ex(str, iter.base());
21335 assert(ex == "+1E+09");
21336 assert(ios.width() == 0);
21337 }
21338 ios.width(25);
21339 left(ios);
21340 {
21341 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21342 std::string ex(str, iter.base());
21343 assert(ex == "+1E+09*******************");
21344 assert(ios.width() == 0);
21345 }
21346 ios.width(25);
21347 right(ios);
21348 {
21349 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21350 std::string ex(str, iter.base());
21351 assert(ex == "*******************+1E+09");
21352 assert(ios.width() == 0);
21353 }
21354 ios.width(25);
21355 internal(ios);
21356 {
21357 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21358 std::string ex(str, iter.base());
21359 assert(ex == "+*******************1E+09");
21360 assert(ios.width() == 0);
21361 }
21362 }
21363 }
21364 showpoint(ios);
21365 {
21366 ios.imbue(lc);
21367 {
21368 ios.width(0);
21369 {
21370 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21371 std::string ex(str, iter.base());
21372 assert(ex == "+1.E+09");
21373 assert(ios.width() == 0);
21374 }
21375 ios.width(25);
21376 left(ios);
21377 {
21378 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21379 std::string ex(str, iter.base());
21380 assert(ex == "+1.E+09******************");
21381 assert(ios.width() == 0);
21382 }
21383 ios.width(25);
21384 right(ios);
21385 {
21386 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21387 std::string ex(str, iter.base());
21388 assert(ex == "******************+1.E+09");
21389 assert(ios.width() == 0);
21390 }
21391 ios.width(25);
21392 internal(ios);
21393 {
21394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21395 std::string ex(str, iter.base());
21396 assert(ex == "+******************1.E+09");
21397 assert(ios.width() == 0);
21398 }
21399 }
21400 ios.imbue(lg);
21401 {
21402 ios.width(0);
21403 {
21404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21405 std::string ex(str, iter.base());
21406 assert(ex == "+1;E+09");
21407 assert(ios.width() == 0);
21408 }
21409 ios.width(25);
21410 left(ios);
21411 {
21412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21413 std::string ex(str, iter.base());
21414 assert(ex == "+1;E+09******************");
21415 assert(ios.width() == 0);
21416 }
21417 ios.width(25);
21418 right(ios);
21419 {
21420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21421 std::string ex(str, iter.base());
21422 assert(ex == "******************+1;E+09");
21423 assert(ios.width() == 0);
21424 }
21425 ios.width(25);
21426 internal(ios);
21427 {
21428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21429 std::string ex(str, iter.base());
21430 assert(ex == "+******************1;E+09");
21431 assert(ios.width() == 0);
21432 }
21433 }
21434 }
21435 }
21436 }
21437 }
21438 ios.precision(1);
21439 {
21440 nouppercase(ios);
21441 {
21442 noshowpos(ios);
21443 {
21444 noshowpoint(ios);
21445 {
21446 ios.imbue(lc);
21447 {
21448 ios.width(0);
21449 {
21450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21451 std::string ex(str, iter.base());
21452 assert(ex == "1.2e+09");
21453 assert(ios.width() == 0);
21454 }
21455 ios.width(25);
21456 left(ios);
21457 {
21458 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21459 std::string ex(str, iter.base());
21460 assert(ex == "1.2e+09******************");
21461 assert(ios.width() == 0);
21462 }
21463 ios.width(25);
21464 right(ios);
21465 {
21466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21467 std::string ex(str, iter.base());
21468 assert(ex == "******************1.2e+09");
21469 assert(ios.width() == 0);
21470 }
21471 ios.width(25);
21472 internal(ios);
21473 {
21474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21475 std::string ex(str, iter.base());
21476 assert(ex == "******************1.2e+09");
21477 assert(ios.width() == 0);
21478 }
21479 }
21480 ios.imbue(lg);
21481 {
21482 ios.width(0);
21483 {
21484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21485 std::string ex(str, iter.base());
21486 assert(ex == "1;2e+09");
21487 assert(ios.width() == 0);
21488 }
21489 ios.width(25);
21490 left(ios);
21491 {
21492 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21493 std::string ex(str, iter.base());
21494 assert(ex == "1;2e+09******************");
21495 assert(ios.width() == 0);
21496 }
21497 ios.width(25);
21498 right(ios);
21499 {
21500 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21501 std::string ex(str, iter.base());
21502 assert(ex == "******************1;2e+09");
21503 assert(ios.width() == 0);
21504 }
21505 ios.width(25);
21506 internal(ios);
21507 {
21508 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21509 std::string ex(str, iter.base());
21510 assert(ex == "******************1;2e+09");
21511 assert(ios.width() == 0);
21512 }
21513 }
21514 }
21515 showpoint(ios);
21516 {
21517 ios.imbue(lc);
21518 {
21519 ios.width(0);
21520 {
21521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21522 std::string ex(str, iter.base());
21523 assert(ex == "1.2e+09");
21524 assert(ios.width() == 0);
21525 }
21526 ios.width(25);
21527 left(ios);
21528 {
21529 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21530 std::string ex(str, iter.base());
21531 assert(ex == "1.2e+09******************");
21532 assert(ios.width() == 0);
21533 }
21534 ios.width(25);
21535 right(ios);
21536 {
21537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21538 std::string ex(str, iter.base());
21539 assert(ex == "******************1.2e+09");
21540 assert(ios.width() == 0);
21541 }
21542 ios.width(25);
21543 internal(ios);
21544 {
21545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21546 std::string ex(str, iter.base());
21547 assert(ex == "******************1.2e+09");
21548 assert(ios.width() == 0);
21549 }
21550 }
21551 ios.imbue(lg);
21552 {
21553 ios.width(0);
21554 {
21555 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21556 std::string ex(str, iter.base());
21557 assert(ex == "1;2e+09");
21558 assert(ios.width() == 0);
21559 }
21560 ios.width(25);
21561 left(ios);
21562 {
21563 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21564 std::string ex(str, iter.base());
21565 assert(ex == "1;2e+09******************");
21566 assert(ios.width() == 0);
21567 }
21568 ios.width(25);
21569 right(ios);
21570 {
21571 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21572 std::string ex(str, iter.base());
21573 assert(ex == "******************1;2e+09");
21574 assert(ios.width() == 0);
21575 }
21576 ios.width(25);
21577 internal(ios);
21578 {
21579 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21580 std::string ex(str, iter.base());
21581 assert(ex == "******************1;2e+09");
21582 assert(ios.width() == 0);
21583 }
21584 }
21585 }
21586 }
21587 showpos(ios);
21588 {
21589 noshowpoint(ios);
21590 {
21591 ios.imbue(lc);
21592 {
21593 ios.width(0);
21594 {
21595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21596 std::string ex(str, iter.base());
21597 assert(ex == "+1.2e+09");
21598 assert(ios.width() == 0);
21599 }
21600 ios.width(25);
21601 left(ios);
21602 {
21603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21604 std::string ex(str, iter.base());
21605 assert(ex == "+1.2e+09*****************");
21606 assert(ios.width() == 0);
21607 }
21608 ios.width(25);
21609 right(ios);
21610 {
21611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21612 std::string ex(str, iter.base());
21613 assert(ex == "*****************+1.2e+09");
21614 assert(ios.width() == 0);
21615 }
21616 ios.width(25);
21617 internal(ios);
21618 {
21619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21620 std::string ex(str, iter.base());
21621 assert(ex == "+*****************1.2e+09");
21622 assert(ios.width() == 0);
21623 }
21624 }
21625 ios.imbue(lg);
21626 {
21627 ios.width(0);
21628 {
21629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21630 std::string ex(str, iter.base());
21631 assert(ex == "+1;2e+09");
21632 assert(ios.width() == 0);
21633 }
21634 ios.width(25);
21635 left(ios);
21636 {
21637 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21638 std::string ex(str, iter.base());
21639 assert(ex == "+1;2e+09*****************");
21640 assert(ios.width() == 0);
21641 }
21642 ios.width(25);
21643 right(ios);
21644 {
21645 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21646 std::string ex(str, iter.base());
21647 assert(ex == "*****************+1;2e+09");
21648 assert(ios.width() == 0);
21649 }
21650 ios.width(25);
21651 internal(ios);
21652 {
21653 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21654 std::string ex(str, iter.base());
21655 assert(ex == "+*****************1;2e+09");
21656 assert(ios.width() == 0);
21657 }
21658 }
21659 }
21660 showpoint(ios);
21661 {
21662 ios.imbue(lc);
21663 {
21664 ios.width(0);
21665 {
21666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21667 std::string ex(str, iter.base());
21668 assert(ex == "+1.2e+09");
21669 assert(ios.width() == 0);
21670 }
21671 ios.width(25);
21672 left(ios);
21673 {
21674 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21675 std::string ex(str, iter.base());
21676 assert(ex == "+1.2e+09*****************");
21677 assert(ios.width() == 0);
21678 }
21679 ios.width(25);
21680 right(ios);
21681 {
21682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21683 std::string ex(str, iter.base());
21684 assert(ex == "*****************+1.2e+09");
21685 assert(ios.width() == 0);
21686 }
21687 ios.width(25);
21688 internal(ios);
21689 {
21690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21691 std::string ex(str, iter.base());
21692 assert(ex == "+*****************1.2e+09");
21693 assert(ios.width() == 0);
21694 }
21695 }
21696 ios.imbue(lg);
21697 {
21698 ios.width(0);
21699 {
21700 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21701 std::string ex(str, iter.base());
21702 assert(ex == "+1;2e+09");
21703 assert(ios.width() == 0);
21704 }
21705 ios.width(25);
21706 left(ios);
21707 {
21708 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21709 std::string ex(str, iter.base());
21710 assert(ex == "+1;2e+09*****************");
21711 assert(ios.width() == 0);
21712 }
21713 ios.width(25);
21714 right(ios);
21715 {
21716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21717 std::string ex(str, iter.base());
21718 assert(ex == "*****************+1;2e+09");
21719 assert(ios.width() == 0);
21720 }
21721 ios.width(25);
21722 internal(ios);
21723 {
21724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21725 std::string ex(str, iter.base());
21726 assert(ex == "+*****************1;2e+09");
21727 assert(ios.width() == 0);
21728 }
21729 }
21730 }
21731 }
21732 }
21733 uppercase(ios);
21734 {
21735 noshowpos(ios);
21736 {
21737 noshowpoint(ios);
21738 {
21739 ios.imbue(lc);
21740 {
21741 ios.width(0);
21742 {
21743 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21744 std::string ex(str, iter.base());
21745 assert(ex == "1.2E+09");
21746 assert(ios.width() == 0);
21747 }
21748 ios.width(25);
21749 left(ios);
21750 {
21751 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21752 std::string ex(str, iter.base());
21753 assert(ex == "1.2E+09******************");
21754 assert(ios.width() == 0);
21755 }
21756 ios.width(25);
21757 right(ios);
21758 {
21759 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21760 std::string ex(str, iter.base());
21761 assert(ex == "******************1.2E+09");
21762 assert(ios.width() == 0);
21763 }
21764 ios.width(25);
21765 internal(ios);
21766 {
21767 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21768 std::string ex(str, iter.base());
21769 assert(ex == "******************1.2E+09");
21770 assert(ios.width() == 0);
21771 }
21772 }
21773 ios.imbue(lg);
21774 {
21775 ios.width(0);
21776 {
21777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21778 std::string ex(str, iter.base());
21779 assert(ex == "1;2E+09");
21780 assert(ios.width() == 0);
21781 }
21782 ios.width(25);
21783 left(ios);
21784 {
21785 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21786 std::string ex(str, iter.base());
21787 assert(ex == "1;2E+09******************");
21788 assert(ios.width() == 0);
21789 }
21790 ios.width(25);
21791 right(ios);
21792 {
21793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21794 std::string ex(str, iter.base());
21795 assert(ex == "******************1;2E+09");
21796 assert(ios.width() == 0);
21797 }
21798 ios.width(25);
21799 internal(ios);
21800 {
21801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21802 std::string ex(str, iter.base());
21803 assert(ex == "******************1;2E+09");
21804 assert(ios.width() == 0);
21805 }
21806 }
21807 }
21808 showpoint(ios);
21809 {
21810 ios.imbue(lc);
21811 {
21812 ios.width(0);
21813 {
21814 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21815 std::string ex(str, iter.base());
21816 assert(ex == "1.2E+09");
21817 assert(ios.width() == 0);
21818 }
21819 ios.width(25);
21820 left(ios);
21821 {
21822 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21823 std::string ex(str, iter.base());
21824 assert(ex == "1.2E+09******************");
21825 assert(ios.width() == 0);
21826 }
21827 ios.width(25);
21828 right(ios);
21829 {
21830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21831 std::string ex(str, iter.base());
21832 assert(ex == "******************1.2E+09");
21833 assert(ios.width() == 0);
21834 }
21835 ios.width(25);
21836 internal(ios);
21837 {
21838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21839 std::string ex(str, iter.base());
21840 assert(ex == "******************1.2E+09");
21841 assert(ios.width() == 0);
21842 }
21843 }
21844 ios.imbue(lg);
21845 {
21846 ios.width(0);
21847 {
21848 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21849 std::string ex(str, iter.base());
21850 assert(ex == "1;2E+09");
21851 assert(ios.width() == 0);
21852 }
21853 ios.width(25);
21854 left(ios);
21855 {
21856 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21857 std::string ex(str, iter.base());
21858 assert(ex == "1;2E+09******************");
21859 assert(ios.width() == 0);
21860 }
21861 ios.width(25);
21862 right(ios);
21863 {
21864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21865 std::string ex(str, iter.base());
21866 assert(ex == "******************1;2E+09");
21867 assert(ios.width() == 0);
21868 }
21869 ios.width(25);
21870 internal(ios);
21871 {
21872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21873 std::string ex(str, iter.base());
21874 assert(ex == "******************1;2E+09");
21875 assert(ios.width() == 0);
21876 }
21877 }
21878 }
21879 }
21880 showpos(ios);
21881 {
21882 noshowpoint(ios);
21883 {
21884 ios.imbue(lc);
21885 {
21886 ios.width(0);
21887 {
21888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21889 std::string ex(str, iter.base());
21890 assert(ex == "+1.2E+09");
21891 assert(ios.width() == 0);
21892 }
21893 ios.width(25);
21894 left(ios);
21895 {
21896 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21897 std::string ex(str, iter.base());
21898 assert(ex == "+1.2E+09*****************");
21899 assert(ios.width() == 0);
21900 }
21901 ios.width(25);
21902 right(ios);
21903 {
21904 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21905 std::string ex(str, iter.base());
21906 assert(ex == "*****************+1.2E+09");
21907 assert(ios.width() == 0);
21908 }
21909 ios.width(25);
21910 internal(ios);
21911 {
21912 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21913 std::string ex(str, iter.base());
21914 assert(ex == "+*****************1.2E+09");
21915 assert(ios.width() == 0);
21916 }
21917 }
21918 ios.imbue(lg);
21919 {
21920 ios.width(0);
21921 {
21922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21923 std::string ex(str, iter.base());
21924 assert(ex == "+1;2E+09");
21925 assert(ios.width() == 0);
21926 }
21927 ios.width(25);
21928 left(ios);
21929 {
21930 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21931 std::string ex(str, iter.base());
21932 assert(ex == "+1;2E+09*****************");
21933 assert(ios.width() == 0);
21934 }
21935 ios.width(25);
21936 right(ios);
21937 {
21938 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21939 std::string ex(str, iter.base());
21940 assert(ex == "*****************+1;2E+09");
21941 assert(ios.width() == 0);
21942 }
21943 ios.width(25);
21944 internal(ios);
21945 {
21946 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21947 std::string ex(str, iter.base());
21948 assert(ex == "+*****************1;2E+09");
21949 assert(ios.width() == 0);
21950 }
21951 }
21952 }
21953 showpoint(ios);
21954 {
21955 ios.imbue(lc);
21956 {
21957 ios.width(0);
21958 {
21959 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21960 std::string ex(str, iter.base());
21961 assert(ex == "+1.2E+09");
21962 assert(ios.width() == 0);
21963 }
21964 ios.width(25);
21965 left(ios);
21966 {
21967 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21968 std::string ex(str, iter.base());
21969 assert(ex == "+1.2E+09*****************");
21970 assert(ios.width() == 0);
21971 }
21972 ios.width(25);
21973 right(ios);
21974 {
21975 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21976 std::string ex(str, iter.base());
21977 assert(ex == "*****************+1.2E+09");
21978 assert(ios.width() == 0);
21979 }
21980 ios.width(25);
21981 internal(ios);
21982 {
21983 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21984 std::string ex(str, iter.base());
21985 assert(ex == "+*****************1.2E+09");
21986 assert(ios.width() == 0);
21987 }
21988 }
21989 ios.imbue(lg);
21990 {
21991 ios.width(0);
21992 {
21993 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21994 std::string ex(str, iter.base());
21995 assert(ex == "+1;2E+09");
21996 assert(ios.width() == 0);
21997 }
21998 ios.width(25);
21999 left(ios);
22000 {
22001 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22002 std::string ex(str, iter.base());
22003 assert(ex == "+1;2E+09*****************");
22004 assert(ios.width() == 0);
22005 }
22006 ios.width(25);
22007 right(ios);
22008 {
22009 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22010 std::string ex(str, iter.base());
22011 assert(ex == "*****************+1;2E+09");
22012 assert(ios.width() == 0);
22013 }
22014 ios.width(25);
22015 internal(ios);
22016 {
22017 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22018 std::string ex(str, iter.base());
22019 assert(ex == "+*****************1;2E+09");
22020 assert(ios.width() == 0);
22021 }
22022 }
22023 }
22024 }
22025 }
22026 }
22027 ios.precision(6);
22028 {
22029 }
22030 ios.precision(16);
22031 {
22032 }
22033 ios.precision(60);
22034 {
22035 nouppercase(ios);
22036 {
22037 noshowpos(ios);
22038 {
22039 noshowpoint(ios);
22040 {
22041 ios.imbue(lc);
22042 {
22043 ios.width(0);
22044 {
22045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22046 std::string ex(str, iter.base());
22047 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22048 assert(ios.width() == 0);
22049 }
22050 ios.width(25);
22051 left(ios);
22052 {
22053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22054 std::string ex(str, iter.base());
22055 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22056 assert(ios.width() == 0);
22057 }
22058 ios.width(25);
22059 right(ios);
22060 {
22061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22062 std::string ex(str, iter.base());
22063 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22064 assert(ios.width() == 0);
22065 }
22066 ios.width(25);
22067 internal(ios);
22068 {
22069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22070 std::string ex(str, iter.base());
22071 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22072 assert(ios.width() == 0);
22073 }
22074 }
22075 ios.imbue(lg);
22076 {
22077 ios.width(0);
22078 {
22079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22080 std::string ex(str, iter.base());
22081 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22082 assert(ios.width() == 0);
22083 }
22084 ios.width(25);
22085 left(ios);
22086 {
22087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22088 std::string ex(str, iter.base());
22089 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22090 assert(ios.width() == 0);
22091 }
22092 ios.width(25);
22093 right(ios);
22094 {
22095 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22096 std::string ex(str, iter.base());
22097 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22098 assert(ios.width() == 0);
22099 }
22100 ios.width(25);
22101 internal(ios);
22102 {
22103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22104 std::string ex(str, iter.base());
22105 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22106 assert(ios.width() == 0);
22107 }
22108 }
22109 }
22110 showpoint(ios);
22111 {
22112 ios.imbue(lc);
22113 {
22114 ios.width(0);
22115 {
22116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22117 std::string ex(str, iter.base());
22118 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22119 assert(ios.width() == 0);
22120 }
22121 ios.width(25);
22122 left(ios);
22123 {
22124 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22125 std::string ex(str, iter.base());
22126 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22127 assert(ios.width() == 0);
22128 }
22129 ios.width(25);
22130 right(ios);
22131 {
22132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22133 std::string ex(str, iter.base());
22134 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22135 assert(ios.width() == 0);
22136 }
22137 ios.width(25);
22138 internal(ios);
22139 {
22140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22141 std::string ex(str, iter.base());
22142 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22143 assert(ios.width() == 0);
22144 }
22145 }
22146 ios.imbue(lg);
22147 {
22148 ios.width(0);
22149 {
22150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22151 std::string ex(str, iter.base());
22152 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22153 assert(ios.width() == 0);
22154 }
22155 ios.width(25);
22156 left(ios);
22157 {
22158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22159 std::string ex(str, iter.base());
22160 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22161 assert(ios.width() == 0);
22162 }
22163 ios.width(25);
22164 right(ios);
22165 {
22166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22167 std::string ex(str, iter.base());
22168 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22169 assert(ios.width() == 0);
22170 }
22171 ios.width(25);
22172 internal(ios);
22173 {
22174 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22175 std::string ex(str, iter.base());
22176 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22177 assert(ios.width() == 0);
22178 }
22179 }
22180 }
22181 }
22182 showpos(ios);
22183 {
22184 noshowpoint(ios);
22185 {
22186 ios.imbue(lc);
22187 {
22188 ios.width(0);
22189 {
22190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22191 std::string ex(str, iter.base());
22192 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22193 assert(ios.width() == 0);
22194 }
22195 ios.width(25);
22196 left(ios);
22197 {
22198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22199 std::string ex(str, iter.base());
22200 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22201 assert(ios.width() == 0);
22202 }
22203 ios.width(25);
22204 right(ios);
22205 {
22206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22207 std::string ex(str, iter.base());
22208 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22209 assert(ios.width() == 0);
22210 }
22211 ios.width(25);
22212 internal(ios);
22213 {
22214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22215 std::string ex(str, iter.base());
22216 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22217 assert(ios.width() == 0);
22218 }
22219 }
22220 ios.imbue(lg);
22221 {
22222 ios.width(0);
22223 {
22224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22225 std::string ex(str, iter.base());
22226 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22227 assert(ios.width() == 0);
22228 }
22229 ios.width(25);
22230 left(ios);
22231 {
22232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22233 std::string ex(str, iter.base());
22234 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22235 assert(ios.width() == 0);
22236 }
22237 ios.width(25);
22238 right(ios);
22239 {
22240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22241 std::string ex(str, iter.base());
22242 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22243 assert(ios.width() == 0);
22244 }
22245 ios.width(25);
22246 internal(ios);
22247 {
22248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22249 std::string ex(str, iter.base());
22250 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22251 assert(ios.width() == 0);
22252 }
22253 }
22254 }
22255 showpoint(ios);
22256 {
22257 ios.imbue(lc);
22258 {
22259 ios.width(0);
22260 {
22261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22262 std::string ex(str, iter.base());
22263 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22264 assert(ios.width() == 0);
22265 }
22266 ios.width(25);
22267 left(ios);
22268 {
22269 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22270 std::string ex(str, iter.base());
22271 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22272 assert(ios.width() == 0);
22273 }
22274 ios.width(25);
22275 right(ios);
22276 {
22277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22278 std::string ex(str, iter.base());
22279 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22280 assert(ios.width() == 0);
22281 }
22282 ios.width(25);
22283 internal(ios);
22284 {
22285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22286 std::string ex(str, iter.base());
22287 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22288 assert(ios.width() == 0);
22289 }
22290 }
22291 ios.imbue(lg);
22292 {
22293 ios.width(0);
22294 {
22295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22296 std::string ex(str, iter.base());
22297 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22298 assert(ios.width() == 0);
22299 }
22300 ios.width(25);
22301 left(ios);
22302 {
22303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22304 std::string ex(str, iter.base());
22305 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22306 assert(ios.width() == 0);
22307 }
22308 ios.width(25);
22309 right(ios);
22310 {
22311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22312 std::string ex(str, iter.base());
22313 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22314 assert(ios.width() == 0);
22315 }
22316 ios.width(25);
22317 internal(ios);
22318 {
22319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22320 std::string ex(str, iter.base());
22321 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22322 assert(ios.width() == 0);
22323 }
22324 }
22325 }
22326 }
22327 }
22328 uppercase(ios);
22329 {
22330 noshowpos(ios);
22331 {
22332 noshowpoint(ios);
22333 {
22334 ios.imbue(lc);
22335 {
22336 ios.width(0);
22337 {
22338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22339 std::string ex(str, iter.base());
22340 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22341 assert(ios.width() == 0);
22342 }
22343 ios.width(25);
22344 left(ios);
22345 {
22346 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22347 std::string ex(str, iter.base());
22348 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22349 assert(ios.width() == 0);
22350 }
22351 ios.width(25);
22352 right(ios);
22353 {
22354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22355 std::string ex(str, iter.base());
22356 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22357 assert(ios.width() == 0);
22358 }
22359 ios.width(25);
22360 internal(ios);
22361 {
22362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22363 std::string ex(str, iter.base());
22364 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22365 assert(ios.width() == 0);
22366 }
22367 }
22368 ios.imbue(lg);
22369 {
22370 ios.width(0);
22371 {
22372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22373 std::string ex(str, iter.base());
22374 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22375 assert(ios.width() == 0);
22376 }
22377 ios.width(25);
22378 left(ios);
22379 {
22380 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22381 std::string ex(str, iter.base());
22382 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22383 assert(ios.width() == 0);
22384 }
22385 ios.width(25);
22386 right(ios);
22387 {
22388 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22389 std::string ex(str, iter.base());
22390 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22391 assert(ios.width() == 0);
22392 }
22393 ios.width(25);
22394 internal(ios);
22395 {
22396 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22397 std::string ex(str, iter.base());
22398 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22399 assert(ios.width() == 0);
22400 }
22401 }
22402 }
22403 showpoint(ios);
22404 {
22405 ios.imbue(lc);
22406 {
22407 ios.width(0);
22408 {
22409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22410 std::string ex(str, iter.base());
22411 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22412 assert(ios.width() == 0);
22413 }
22414 ios.width(25);
22415 left(ios);
22416 {
22417 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22418 std::string ex(str, iter.base());
22419 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22420 assert(ios.width() == 0);
22421 }
22422 ios.width(25);
22423 right(ios);
22424 {
22425 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22426 std::string ex(str, iter.base());
22427 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22428 assert(ios.width() == 0);
22429 }
22430 ios.width(25);
22431 internal(ios);
22432 {
22433 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22434 std::string ex(str, iter.base());
22435 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22436 assert(ios.width() == 0);
22437 }
22438 }
22439 ios.imbue(lg);
22440 {
22441 ios.width(0);
22442 {
22443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22444 std::string ex(str, iter.base());
22445 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22446 assert(ios.width() == 0);
22447 }
22448 ios.width(25);
22449 left(ios);
22450 {
22451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22452 std::string ex(str, iter.base());
22453 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22454 assert(ios.width() == 0);
22455 }
22456 ios.width(25);
22457 right(ios);
22458 {
22459 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22460 std::string ex(str, iter.base());
22461 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22462 assert(ios.width() == 0);
22463 }
22464 ios.width(25);
22465 internal(ios);
22466 {
22467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22468 std::string ex(str, iter.base());
22469 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22470 assert(ios.width() == 0);
22471 }
22472 }
22473 }
22474 }
22475 showpos(ios);
22476 {
22477 noshowpoint(ios);
22478 {
22479 ios.imbue(lc);
22480 {
22481 ios.width(0);
22482 {
22483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22484 std::string ex(str, iter.base());
22485 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22486 assert(ios.width() == 0);
22487 }
22488 ios.width(25);
22489 left(ios);
22490 {
22491 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22492 std::string ex(str, iter.base());
22493 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22494 assert(ios.width() == 0);
22495 }
22496 ios.width(25);
22497 right(ios);
22498 {
22499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22500 std::string ex(str, iter.base());
22501 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22502 assert(ios.width() == 0);
22503 }
22504 ios.width(25);
22505 internal(ios);
22506 {
22507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22508 std::string ex(str, iter.base());
22509 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22510 assert(ios.width() == 0);
22511 }
22512 }
22513 ios.imbue(lg);
22514 {
22515 ios.width(0);
22516 {
22517 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22518 std::string ex(str, iter.base());
22519 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22520 assert(ios.width() == 0);
22521 }
22522 ios.width(25);
22523 left(ios);
22524 {
22525 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22526 std::string ex(str, iter.base());
22527 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22528 assert(ios.width() == 0);
22529 }
22530 ios.width(25);
22531 right(ios);
22532 {
22533 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22534 std::string ex(str, iter.base());
22535 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22536 assert(ios.width() == 0);
22537 }
22538 ios.width(25);
22539 internal(ios);
22540 {
22541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22542 std::string ex(str, iter.base());
22543 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22544 assert(ios.width() == 0);
22545 }
22546 }
22547 }
22548 showpoint(ios);
22549 {
22550 ios.imbue(lc);
22551 {
22552 ios.width(0);
22553 {
22554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22555 std::string ex(str, iter.base());
22556 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22557 assert(ios.width() == 0);
22558 }
22559 ios.width(25);
22560 left(ios);
22561 {
22562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22563 std::string ex(str, iter.base());
22564 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22565 assert(ios.width() == 0);
22566 }
22567 ios.width(25);
22568 right(ios);
22569 {
22570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22571 std::string ex(str, iter.base());
22572 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22573 assert(ios.width() == 0);
22574 }
22575 ios.width(25);
22576 internal(ios);
22577 {
22578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22579 std::string ex(str, iter.base());
22580 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22581 assert(ios.width() == 0);
22582 }
22583 }
22584 ios.imbue(lg);
22585 {
22586 ios.width(0);
22587 {
22588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22589 std::string ex(str, iter.base());
22590 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22591 assert(ios.width() == 0);
22592 }
22593 ios.width(25);
22594 left(ios);
22595 {
22596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22597 std::string ex(str, iter.base());
22598 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22599 assert(ios.width() == 0);
22600 }
22601 ios.width(25);
22602 right(ios);
22603 {
22604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22605 std::string ex(str, iter.base());
22606 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22607 assert(ios.width() == 0);
22608 }
22609 ios.width(25);
22610 internal(ios);
22611 {
22612 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22613 std::string ex(str, iter.base());
22614 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22615 assert(ios.width() == 0);
22616 }
22617 }
22618 }
22619 }
22620 }
22621 }
22622 }
22623 }
22624 }
22625
test11()22626 void test11()
22627 {
22628 char str[200];
22629 output_iterator<char*> iter;
22630 std::locale lc = std::locale::classic();
22631 std::locale lg(lc, new my_numpunct);
22632 const my_facet f(1);
22633 {
22634 long double v = -0.;
22635 std::ios ios(0);
22636 hexfloat(ios);
22637 // %a
22638 {
22639 ios.precision(0);
22640 {
22641 nouppercase(ios);
22642 {
22643 noshowpos(ios);
22644 {
22645 noshowpoint(ios);
22646 {
22647 ios.imbue(lc);
22648 {
22649 ios.width(0);
22650 {
22651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22652 std::string ex(str, iter.base());
22653 assert(ex == "-0x0p+0");
22654 assert(ios.width() == 0);
22655 }
22656 ios.width(25);
22657 left(ios);
22658 {
22659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22660 std::string ex(str, iter.base());
22661 assert(ex == "-0x0p+0******************");
22662 assert(ios.width() == 0);
22663 }
22664 ios.width(25);
22665 right(ios);
22666 {
22667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22668 std::string ex(str, iter.base());
22669 assert(ex == "******************-0x0p+0");
22670 assert(ios.width() == 0);
22671 }
22672 ios.width(25);
22673 internal(ios);
22674 {
22675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22676 std::string ex(str, iter.base());
22677 assert(ex == "-******************0x0p+0");
22678 assert(ios.width() == 0);
22679 }
22680 }
22681 ios.imbue(lg);
22682 {
22683 ios.width(0);
22684 {
22685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22686 std::string ex(str, iter.base());
22687 assert(ex == "-0x0p+0");
22688 assert(ios.width() == 0);
22689 }
22690 ios.width(25);
22691 left(ios);
22692 {
22693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22694 std::string ex(str, iter.base());
22695 assert(ex == "-0x0p+0******************");
22696 assert(ios.width() == 0);
22697 }
22698 ios.width(25);
22699 right(ios);
22700 {
22701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22702 std::string ex(str, iter.base());
22703 assert(ex == "******************-0x0p+0");
22704 assert(ios.width() == 0);
22705 }
22706 ios.width(25);
22707 internal(ios);
22708 {
22709 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22710 std::string ex(str, iter.base());
22711 assert(ex == "-******************0x0p+0");
22712 assert(ios.width() == 0);
22713 }
22714 }
22715 }
22716 showpoint(ios);
22717 {
22718 ios.imbue(lc);
22719 {
22720 ios.width(0);
22721 {
22722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22723 std::string ex(str, iter.base());
22724 assert(ex == "-0x0.p+0");
22725 assert(ios.width() == 0);
22726 }
22727 ios.width(25);
22728 left(ios);
22729 {
22730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22731 std::string ex(str, iter.base());
22732 assert(ex == "-0x0.p+0*****************");
22733 assert(ios.width() == 0);
22734 }
22735 ios.width(25);
22736 right(ios);
22737 {
22738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22739 std::string ex(str, iter.base());
22740 assert(ex == "*****************-0x0.p+0");
22741 assert(ios.width() == 0);
22742 }
22743 ios.width(25);
22744 internal(ios);
22745 {
22746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22747 std::string ex(str, iter.base());
22748 assert(ex == "-*****************0x0.p+0");
22749 assert(ios.width() == 0);
22750 }
22751 }
22752 ios.imbue(lg);
22753 {
22754 ios.width(0);
22755 {
22756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22757 std::string ex(str, iter.base());
22758 assert(ex == "-0x0;p+0");
22759 assert(ios.width() == 0);
22760 }
22761 ios.width(25);
22762 left(ios);
22763 {
22764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22765 std::string ex(str, iter.base());
22766 assert(ex == "-0x0;p+0*****************");
22767 assert(ios.width() == 0);
22768 }
22769 ios.width(25);
22770 right(ios);
22771 {
22772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22773 std::string ex(str, iter.base());
22774 assert(ex == "*****************-0x0;p+0");
22775 assert(ios.width() == 0);
22776 }
22777 ios.width(25);
22778 internal(ios);
22779 {
22780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22781 std::string ex(str, iter.base());
22782 assert(ex == "-*****************0x0;p+0");
22783 assert(ios.width() == 0);
22784 }
22785 }
22786 }
22787 }
22788 showpos(ios);
22789 {
22790 noshowpoint(ios);
22791 {
22792 ios.imbue(lc);
22793 {
22794 ios.width(0);
22795 {
22796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22797 std::string ex(str, iter.base());
22798 assert(ex == "-0x0p+0");
22799 assert(ios.width() == 0);
22800 }
22801 ios.width(25);
22802 left(ios);
22803 {
22804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22805 std::string ex(str, iter.base());
22806 assert(ex == "-0x0p+0******************");
22807 assert(ios.width() == 0);
22808 }
22809 ios.width(25);
22810 right(ios);
22811 {
22812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22813 std::string ex(str, iter.base());
22814 assert(ex == "******************-0x0p+0");
22815 assert(ios.width() == 0);
22816 }
22817 ios.width(25);
22818 internal(ios);
22819 {
22820 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22821 std::string ex(str, iter.base());
22822 assert(ex == "-******************0x0p+0");
22823 assert(ios.width() == 0);
22824 }
22825 }
22826 ios.imbue(lg);
22827 {
22828 ios.width(0);
22829 {
22830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22831 std::string ex(str, iter.base());
22832 assert(ex == "-0x0p+0");
22833 assert(ios.width() == 0);
22834 }
22835 ios.width(25);
22836 left(ios);
22837 {
22838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22839 std::string ex(str, iter.base());
22840 assert(ex == "-0x0p+0******************");
22841 assert(ios.width() == 0);
22842 }
22843 ios.width(25);
22844 right(ios);
22845 {
22846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22847 std::string ex(str, iter.base());
22848 assert(ex == "******************-0x0p+0");
22849 assert(ios.width() == 0);
22850 }
22851 ios.width(25);
22852 internal(ios);
22853 {
22854 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22855 std::string ex(str, iter.base());
22856 assert(ex == "-******************0x0p+0");
22857 assert(ios.width() == 0);
22858 }
22859 }
22860 }
22861 showpoint(ios);
22862 {
22863 ios.imbue(lc);
22864 {
22865 ios.width(0);
22866 {
22867 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22868 std::string ex(str, iter.base());
22869 assert(ex == "-0x0.p+0");
22870 assert(ios.width() == 0);
22871 }
22872 ios.width(25);
22873 left(ios);
22874 {
22875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22876 std::string ex(str, iter.base());
22877 assert(ex == "-0x0.p+0*****************");
22878 assert(ios.width() == 0);
22879 }
22880 ios.width(25);
22881 right(ios);
22882 {
22883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22884 std::string ex(str, iter.base());
22885 assert(ex == "*****************-0x0.p+0");
22886 assert(ios.width() == 0);
22887 }
22888 ios.width(25);
22889 internal(ios);
22890 {
22891 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22892 std::string ex(str, iter.base());
22893 assert(ex == "-*****************0x0.p+0");
22894 assert(ios.width() == 0);
22895 }
22896 }
22897 ios.imbue(lg);
22898 {
22899 ios.width(0);
22900 {
22901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22902 std::string ex(str, iter.base());
22903 assert(ex == "-0x0;p+0");
22904 assert(ios.width() == 0);
22905 }
22906 ios.width(25);
22907 left(ios);
22908 {
22909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22910 std::string ex(str, iter.base());
22911 assert(ex == "-0x0;p+0*****************");
22912 assert(ios.width() == 0);
22913 }
22914 ios.width(25);
22915 right(ios);
22916 {
22917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22918 std::string ex(str, iter.base());
22919 assert(ex == "*****************-0x0;p+0");
22920 assert(ios.width() == 0);
22921 }
22922 ios.width(25);
22923 internal(ios);
22924 {
22925 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22926 std::string ex(str, iter.base());
22927 assert(ex == "-*****************0x0;p+0");
22928 assert(ios.width() == 0);
22929 }
22930 }
22931 }
22932 }
22933 }
22934 uppercase(ios);
22935 {
22936 noshowpos(ios);
22937 {
22938 noshowpoint(ios);
22939 {
22940 ios.imbue(lc);
22941 {
22942 ios.width(0);
22943 {
22944 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22945 std::string ex(str, iter.base());
22946 assert(ex == "-0X0P+0");
22947 assert(ios.width() == 0);
22948 }
22949 ios.width(25);
22950 left(ios);
22951 {
22952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22953 std::string ex(str, iter.base());
22954 assert(ex == "-0X0P+0******************");
22955 assert(ios.width() == 0);
22956 }
22957 ios.width(25);
22958 right(ios);
22959 {
22960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22961 std::string ex(str, iter.base());
22962 assert(ex == "******************-0X0P+0");
22963 assert(ios.width() == 0);
22964 }
22965 ios.width(25);
22966 internal(ios);
22967 {
22968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22969 std::string ex(str, iter.base());
22970 assert(ex == "-******************0X0P+0");
22971 assert(ios.width() == 0);
22972 }
22973 }
22974 ios.imbue(lg);
22975 {
22976 ios.width(0);
22977 {
22978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22979 std::string ex(str, iter.base());
22980 assert(ex == "-0X0P+0");
22981 assert(ios.width() == 0);
22982 }
22983 ios.width(25);
22984 left(ios);
22985 {
22986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22987 std::string ex(str, iter.base());
22988 assert(ex == "-0X0P+0******************");
22989 assert(ios.width() == 0);
22990 }
22991 ios.width(25);
22992 right(ios);
22993 {
22994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22995 std::string ex(str, iter.base());
22996 assert(ex == "******************-0X0P+0");
22997 assert(ios.width() == 0);
22998 }
22999 ios.width(25);
23000 internal(ios);
23001 {
23002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23003 std::string ex(str, iter.base());
23004 assert(ex == "-******************0X0P+0");
23005 assert(ios.width() == 0);
23006 }
23007 }
23008 }
23009 showpoint(ios);
23010 {
23011 ios.imbue(lc);
23012 {
23013 ios.width(0);
23014 {
23015 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23016 std::string ex(str, iter.base());
23017 assert(ex == "-0X0.P+0");
23018 assert(ios.width() == 0);
23019 }
23020 ios.width(25);
23021 left(ios);
23022 {
23023 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23024 std::string ex(str, iter.base());
23025 assert(ex == "-0X0.P+0*****************");
23026 assert(ios.width() == 0);
23027 }
23028 ios.width(25);
23029 right(ios);
23030 {
23031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23032 std::string ex(str, iter.base());
23033 assert(ex == "*****************-0X0.P+0");
23034 assert(ios.width() == 0);
23035 }
23036 ios.width(25);
23037 internal(ios);
23038 {
23039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23040 std::string ex(str, iter.base());
23041 assert(ex == "-*****************0X0.P+0");
23042 assert(ios.width() == 0);
23043 }
23044 }
23045 ios.imbue(lg);
23046 {
23047 ios.width(0);
23048 {
23049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23050 std::string ex(str, iter.base());
23051 assert(ex == "-0X0;P+0");
23052 assert(ios.width() == 0);
23053 }
23054 ios.width(25);
23055 left(ios);
23056 {
23057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23058 std::string ex(str, iter.base());
23059 assert(ex == "-0X0;P+0*****************");
23060 assert(ios.width() == 0);
23061 }
23062 ios.width(25);
23063 right(ios);
23064 {
23065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23066 std::string ex(str, iter.base());
23067 assert(ex == "*****************-0X0;P+0");
23068 assert(ios.width() == 0);
23069 }
23070 ios.width(25);
23071 internal(ios);
23072 {
23073 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23074 std::string ex(str, iter.base());
23075 assert(ex == "-*****************0X0;P+0");
23076 assert(ios.width() == 0);
23077 }
23078 }
23079 }
23080 }
23081 showpos(ios);
23082 {
23083 noshowpoint(ios);
23084 {
23085 ios.imbue(lc);
23086 {
23087 ios.width(0);
23088 {
23089 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23090 std::string ex(str, iter.base());
23091 assert(ex == "-0X0P+0");
23092 assert(ios.width() == 0);
23093 }
23094 ios.width(25);
23095 left(ios);
23096 {
23097 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23098 std::string ex(str, iter.base());
23099 assert(ex == "-0X0P+0******************");
23100 assert(ios.width() == 0);
23101 }
23102 ios.width(25);
23103 right(ios);
23104 {
23105 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23106 std::string ex(str, iter.base());
23107 assert(ex == "******************-0X0P+0");
23108 assert(ios.width() == 0);
23109 }
23110 ios.width(25);
23111 internal(ios);
23112 {
23113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23114 std::string ex(str, iter.base());
23115 assert(ex == "-******************0X0P+0");
23116 assert(ios.width() == 0);
23117 }
23118 }
23119 ios.imbue(lg);
23120 {
23121 ios.width(0);
23122 {
23123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23124 std::string ex(str, iter.base());
23125 assert(ex == "-0X0P+0");
23126 assert(ios.width() == 0);
23127 }
23128 ios.width(25);
23129 left(ios);
23130 {
23131 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23132 std::string ex(str, iter.base());
23133 assert(ex == "-0X0P+0******************");
23134 assert(ios.width() == 0);
23135 }
23136 ios.width(25);
23137 right(ios);
23138 {
23139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23140 std::string ex(str, iter.base());
23141 assert(ex == "******************-0X0P+0");
23142 assert(ios.width() == 0);
23143 }
23144 ios.width(25);
23145 internal(ios);
23146 {
23147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23148 std::string ex(str, iter.base());
23149 assert(ex == "-******************0X0P+0");
23150 assert(ios.width() == 0);
23151 }
23152 }
23153 }
23154 showpoint(ios);
23155 {
23156 ios.imbue(lc);
23157 {
23158 ios.width(0);
23159 {
23160 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23161 std::string ex(str, iter.base());
23162 assert(ex == "-0X0.P+0");
23163 assert(ios.width() == 0);
23164 }
23165 ios.width(25);
23166 left(ios);
23167 {
23168 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23169 std::string ex(str, iter.base());
23170 assert(ex == "-0X0.P+0*****************");
23171 assert(ios.width() == 0);
23172 }
23173 ios.width(25);
23174 right(ios);
23175 {
23176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23177 std::string ex(str, iter.base());
23178 assert(ex == "*****************-0X0.P+0");
23179 assert(ios.width() == 0);
23180 }
23181 ios.width(25);
23182 internal(ios);
23183 {
23184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23185 std::string ex(str, iter.base());
23186 assert(ex == "-*****************0X0.P+0");
23187 assert(ios.width() == 0);
23188 }
23189 }
23190 ios.imbue(lg);
23191 {
23192 ios.width(0);
23193 {
23194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23195 std::string ex(str, iter.base());
23196 assert(ex == "-0X0;P+0");
23197 assert(ios.width() == 0);
23198 }
23199 ios.width(25);
23200 left(ios);
23201 {
23202 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23203 std::string ex(str, iter.base());
23204 assert(ex == "-0X0;P+0*****************");
23205 assert(ios.width() == 0);
23206 }
23207 ios.width(25);
23208 right(ios);
23209 {
23210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23211 std::string ex(str, iter.base());
23212 assert(ex == "*****************-0X0;P+0");
23213 assert(ios.width() == 0);
23214 }
23215 ios.width(25);
23216 internal(ios);
23217 {
23218 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23219 std::string ex(str, iter.base());
23220 assert(ex == "-*****************0X0;P+0");
23221 assert(ios.width() == 0);
23222 }
23223 }
23224 }
23225 }
23226 }
23227 }
23228 ios.precision(1);
23229 {
23230 nouppercase(ios);
23231 {
23232 noshowpos(ios);
23233 {
23234 noshowpoint(ios);
23235 {
23236 ios.imbue(lc);
23237 {
23238 ios.width(0);
23239 {
23240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23241 std::string ex(str, iter.base());
23242 assert(ex == "-0x0p+0");
23243 assert(ios.width() == 0);
23244 }
23245 ios.width(25);
23246 left(ios);
23247 {
23248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23249 std::string ex(str, iter.base());
23250 assert(ex == "-0x0p+0******************");
23251 assert(ios.width() == 0);
23252 }
23253 ios.width(25);
23254 right(ios);
23255 {
23256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23257 std::string ex(str, iter.base());
23258 assert(ex == "******************-0x0p+0");
23259 assert(ios.width() == 0);
23260 }
23261 ios.width(25);
23262 internal(ios);
23263 {
23264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23265 std::string ex(str, iter.base());
23266 assert(ex == "-******************0x0p+0");
23267 assert(ios.width() == 0);
23268 }
23269 }
23270 ios.imbue(lg);
23271 {
23272 ios.width(0);
23273 {
23274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23275 std::string ex(str, iter.base());
23276 assert(ex == "-0x0p+0");
23277 assert(ios.width() == 0);
23278 }
23279 ios.width(25);
23280 left(ios);
23281 {
23282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23283 std::string ex(str, iter.base());
23284 assert(ex == "-0x0p+0******************");
23285 assert(ios.width() == 0);
23286 }
23287 ios.width(25);
23288 right(ios);
23289 {
23290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23291 std::string ex(str, iter.base());
23292 assert(ex == "******************-0x0p+0");
23293 assert(ios.width() == 0);
23294 }
23295 ios.width(25);
23296 internal(ios);
23297 {
23298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23299 std::string ex(str, iter.base());
23300 assert(ex == "-******************0x0p+0");
23301 assert(ios.width() == 0);
23302 }
23303 }
23304 }
23305 showpoint(ios);
23306 {
23307 ios.imbue(lc);
23308 {
23309 ios.width(0);
23310 {
23311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23312 std::string ex(str, iter.base());
23313 assert(ex == "-0x0.p+0");
23314 assert(ios.width() == 0);
23315 }
23316 ios.width(25);
23317 left(ios);
23318 {
23319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23320 std::string ex(str, iter.base());
23321 assert(ex == "-0x0.p+0*****************");
23322 assert(ios.width() == 0);
23323 }
23324 ios.width(25);
23325 right(ios);
23326 {
23327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23328 std::string ex(str, iter.base());
23329 assert(ex == "*****************-0x0.p+0");
23330 assert(ios.width() == 0);
23331 }
23332 ios.width(25);
23333 internal(ios);
23334 {
23335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23336 std::string ex(str, iter.base());
23337 assert(ex == "-*****************0x0.p+0");
23338 assert(ios.width() == 0);
23339 }
23340 }
23341 ios.imbue(lg);
23342 {
23343 ios.width(0);
23344 {
23345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23346 std::string ex(str, iter.base());
23347 assert(ex == "-0x0;p+0");
23348 assert(ios.width() == 0);
23349 }
23350 ios.width(25);
23351 left(ios);
23352 {
23353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23354 std::string ex(str, iter.base());
23355 assert(ex == "-0x0;p+0*****************");
23356 assert(ios.width() == 0);
23357 }
23358 ios.width(25);
23359 right(ios);
23360 {
23361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23362 std::string ex(str, iter.base());
23363 assert(ex == "*****************-0x0;p+0");
23364 assert(ios.width() == 0);
23365 }
23366 ios.width(25);
23367 internal(ios);
23368 {
23369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23370 std::string ex(str, iter.base());
23371 assert(ex == "-*****************0x0;p+0");
23372 assert(ios.width() == 0);
23373 }
23374 }
23375 }
23376 }
23377 showpos(ios);
23378 {
23379 noshowpoint(ios);
23380 {
23381 ios.imbue(lc);
23382 {
23383 ios.width(0);
23384 {
23385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23386 std::string ex(str, iter.base());
23387 assert(ex == "-0x0p+0");
23388 assert(ios.width() == 0);
23389 }
23390 ios.width(25);
23391 left(ios);
23392 {
23393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23394 std::string ex(str, iter.base());
23395 assert(ex == "-0x0p+0******************");
23396 assert(ios.width() == 0);
23397 }
23398 ios.width(25);
23399 right(ios);
23400 {
23401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23402 std::string ex(str, iter.base());
23403 assert(ex == "******************-0x0p+0");
23404 assert(ios.width() == 0);
23405 }
23406 ios.width(25);
23407 internal(ios);
23408 {
23409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23410 std::string ex(str, iter.base());
23411 assert(ex == "-******************0x0p+0");
23412 assert(ios.width() == 0);
23413 }
23414 }
23415 ios.imbue(lg);
23416 {
23417 ios.width(0);
23418 {
23419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23420 std::string ex(str, iter.base());
23421 assert(ex == "-0x0p+0");
23422 assert(ios.width() == 0);
23423 }
23424 ios.width(25);
23425 left(ios);
23426 {
23427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23428 std::string ex(str, iter.base());
23429 assert(ex == "-0x0p+0******************");
23430 assert(ios.width() == 0);
23431 }
23432 ios.width(25);
23433 right(ios);
23434 {
23435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23436 std::string ex(str, iter.base());
23437 assert(ex == "******************-0x0p+0");
23438 assert(ios.width() == 0);
23439 }
23440 ios.width(25);
23441 internal(ios);
23442 {
23443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23444 std::string ex(str, iter.base());
23445 assert(ex == "-******************0x0p+0");
23446 assert(ios.width() == 0);
23447 }
23448 }
23449 }
23450 showpoint(ios);
23451 {
23452 ios.imbue(lc);
23453 {
23454 ios.width(0);
23455 {
23456 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23457 std::string ex(str, iter.base());
23458 assert(ex == "-0x0.p+0");
23459 assert(ios.width() == 0);
23460 }
23461 ios.width(25);
23462 left(ios);
23463 {
23464 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23465 std::string ex(str, iter.base());
23466 assert(ex == "-0x0.p+0*****************");
23467 assert(ios.width() == 0);
23468 }
23469 ios.width(25);
23470 right(ios);
23471 {
23472 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23473 std::string ex(str, iter.base());
23474 assert(ex == "*****************-0x0.p+0");
23475 assert(ios.width() == 0);
23476 }
23477 ios.width(25);
23478 internal(ios);
23479 {
23480 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23481 std::string ex(str, iter.base());
23482 assert(ex == "-*****************0x0.p+0");
23483 assert(ios.width() == 0);
23484 }
23485 }
23486 ios.imbue(lg);
23487 {
23488 ios.width(0);
23489 {
23490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23491 std::string ex(str, iter.base());
23492 assert(ex == "-0x0;p+0");
23493 assert(ios.width() == 0);
23494 }
23495 ios.width(25);
23496 left(ios);
23497 {
23498 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23499 std::string ex(str, iter.base());
23500 assert(ex == "-0x0;p+0*****************");
23501 assert(ios.width() == 0);
23502 }
23503 ios.width(25);
23504 right(ios);
23505 {
23506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23507 std::string ex(str, iter.base());
23508 assert(ex == "*****************-0x0;p+0");
23509 assert(ios.width() == 0);
23510 }
23511 ios.width(25);
23512 internal(ios);
23513 {
23514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23515 std::string ex(str, iter.base());
23516 assert(ex == "-*****************0x0;p+0");
23517 assert(ios.width() == 0);
23518 }
23519 }
23520 }
23521 }
23522 }
23523 uppercase(ios);
23524 {
23525 noshowpos(ios);
23526 {
23527 noshowpoint(ios);
23528 {
23529 ios.imbue(lc);
23530 {
23531 ios.width(0);
23532 {
23533 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23534 std::string ex(str, iter.base());
23535 assert(ex == "-0X0P+0");
23536 assert(ios.width() == 0);
23537 }
23538 ios.width(25);
23539 left(ios);
23540 {
23541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23542 std::string ex(str, iter.base());
23543 assert(ex == "-0X0P+0******************");
23544 assert(ios.width() == 0);
23545 }
23546 ios.width(25);
23547 right(ios);
23548 {
23549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23550 std::string ex(str, iter.base());
23551 assert(ex == "******************-0X0P+0");
23552 assert(ios.width() == 0);
23553 }
23554 ios.width(25);
23555 internal(ios);
23556 {
23557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23558 std::string ex(str, iter.base());
23559 assert(ex == "-******************0X0P+0");
23560 assert(ios.width() == 0);
23561 }
23562 }
23563 ios.imbue(lg);
23564 {
23565 ios.width(0);
23566 {
23567 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23568 std::string ex(str, iter.base());
23569 assert(ex == "-0X0P+0");
23570 assert(ios.width() == 0);
23571 }
23572 ios.width(25);
23573 left(ios);
23574 {
23575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23576 std::string ex(str, iter.base());
23577 assert(ex == "-0X0P+0******************");
23578 assert(ios.width() == 0);
23579 }
23580 ios.width(25);
23581 right(ios);
23582 {
23583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23584 std::string ex(str, iter.base());
23585 assert(ex == "******************-0X0P+0");
23586 assert(ios.width() == 0);
23587 }
23588 ios.width(25);
23589 internal(ios);
23590 {
23591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23592 std::string ex(str, iter.base());
23593 assert(ex == "-******************0X0P+0");
23594 assert(ios.width() == 0);
23595 }
23596 }
23597 }
23598 showpoint(ios);
23599 {
23600 ios.imbue(lc);
23601 {
23602 ios.width(0);
23603 {
23604 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23605 std::string ex(str, iter.base());
23606 assert(ex == "-0X0.P+0");
23607 assert(ios.width() == 0);
23608 }
23609 ios.width(25);
23610 left(ios);
23611 {
23612 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23613 std::string ex(str, iter.base());
23614 assert(ex == "-0X0.P+0*****************");
23615 assert(ios.width() == 0);
23616 }
23617 ios.width(25);
23618 right(ios);
23619 {
23620 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23621 std::string ex(str, iter.base());
23622 assert(ex == "*****************-0X0.P+0");
23623 assert(ios.width() == 0);
23624 }
23625 ios.width(25);
23626 internal(ios);
23627 {
23628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23629 std::string ex(str, iter.base());
23630 assert(ex == "-*****************0X0.P+0");
23631 assert(ios.width() == 0);
23632 }
23633 }
23634 ios.imbue(lg);
23635 {
23636 ios.width(0);
23637 {
23638 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23639 std::string ex(str, iter.base());
23640 assert(ex == "-0X0;P+0");
23641 assert(ios.width() == 0);
23642 }
23643 ios.width(25);
23644 left(ios);
23645 {
23646 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23647 std::string ex(str, iter.base());
23648 assert(ex == "-0X0;P+0*****************");
23649 assert(ios.width() == 0);
23650 }
23651 ios.width(25);
23652 right(ios);
23653 {
23654 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23655 std::string ex(str, iter.base());
23656 assert(ex == "*****************-0X0;P+0");
23657 assert(ios.width() == 0);
23658 }
23659 ios.width(25);
23660 internal(ios);
23661 {
23662 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23663 std::string ex(str, iter.base());
23664 assert(ex == "-*****************0X0;P+0");
23665 assert(ios.width() == 0);
23666 }
23667 }
23668 }
23669 }
23670 showpos(ios);
23671 {
23672 noshowpoint(ios);
23673 {
23674 ios.imbue(lc);
23675 {
23676 ios.width(0);
23677 {
23678 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23679 std::string ex(str, iter.base());
23680 assert(ex == "-0X0P+0");
23681 assert(ios.width() == 0);
23682 }
23683 ios.width(25);
23684 left(ios);
23685 {
23686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23687 std::string ex(str, iter.base());
23688 assert(ex == "-0X0P+0******************");
23689 assert(ios.width() == 0);
23690 }
23691 ios.width(25);
23692 right(ios);
23693 {
23694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23695 std::string ex(str, iter.base());
23696 assert(ex == "******************-0X0P+0");
23697 assert(ios.width() == 0);
23698 }
23699 ios.width(25);
23700 internal(ios);
23701 {
23702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23703 std::string ex(str, iter.base());
23704 assert(ex == "-******************0X0P+0");
23705 assert(ios.width() == 0);
23706 }
23707 }
23708 ios.imbue(lg);
23709 {
23710 ios.width(0);
23711 {
23712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23713 std::string ex(str, iter.base());
23714 assert(ex == "-0X0P+0");
23715 assert(ios.width() == 0);
23716 }
23717 ios.width(25);
23718 left(ios);
23719 {
23720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23721 std::string ex(str, iter.base());
23722 assert(ex == "-0X0P+0******************");
23723 assert(ios.width() == 0);
23724 }
23725 ios.width(25);
23726 right(ios);
23727 {
23728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23729 std::string ex(str, iter.base());
23730 assert(ex == "******************-0X0P+0");
23731 assert(ios.width() == 0);
23732 }
23733 ios.width(25);
23734 internal(ios);
23735 {
23736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23737 std::string ex(str, iter.base());
23738 assert(ex == "-******************0X0P+0");
23739 assert(ios.width() == 0);
23740 }
23741 }
23742 }
23743 showpoint(ios);
23744 {
23745 ios.imbue(lc);
23746 {
23747 ios.width(0);
23748 {
23749 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23750 std::string ex(str, iter.base());
23751 assert(ex == "-0X0.P+0");
23752 assert(ios.width() == 0);
23753 }
23754 ios.width(25);
23755 left(ios);
23756 {
23757 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23758 std::string ex(str, iter.base());
23759 assert(ex == "-0X0.P+0*****************");
23760 assert(ios.width() == 0);
23761 }
23762 ios.width(25);
23763 right(ios);
23764 {
23765 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23766 std::string ex(str, iter.base());
23767 assert(ex == "*****************-0X0.P+0");
23768 assert(ios.width() == 0);
23769 }
23770 ios.width(25);
23771 internal(ios);
23772 {
23773 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23774 std::string ex(str, iter.base());
23775 assert(ex == "-*****************0X0.P+0");
23776 assert(ios.width() == 0);
23777 }
23778 }
23779 ios.imbue(lg);
23780 {
23781 ios.width(0);
23782 {
23783 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23784 std::string ex(str, iter.base());
23785 assert(ex == "-0X0;P+0");
23786 assert(ios.width() == 0);
23787 }
23788 ios.width(25);
23789 left(ios);
23790 {
23791 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23792 std::string ex(str, iter.base());
23793 assert(ex == "-0X0;P+0*****************");
23794 assert(ios.width() == 0);
23795 }
23796 ios.width(25);
23797 right(ios);
23798 {
23799 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23800 std::string ex(str, iter.base());
23801 assert(ex == "*****************-0X0;P+0");
23802 assert(ios.width() == 0);
23803 }
23804 ios.width(25);
23805 internal(ios);
23806 {
23807 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23808 std::string ex(str, iter.base());
23809 assert(ex == "-*****************0X0;P+0");
23810 assert(ios.width() == 0);
23811 }
23812 }
23813 }
23814 }
23815 }
23816 }
23817 ios.precision(6);
23818 {
23819 nouppercase(ios);
23820 {
23821 noshowpos(ios);
23822 {
23823 noshowpoint(ios);
23824 {
23825 ios.imbue(lc);
23826 {
23827 ios.width(0);
23828 {
23829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23830 std::string ex(str, iter.base());
23831 assert(ex == "-0x0p+0");
23832 assert(ios.width() == 0);
23833 }
23834 ios.width(25);
23835 left(ios);
23836 {
23837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23838 std::string ex(str, iter.base());
23839 assert(ex == "-0x0p+0******************");
23840 assert(ios.width() == 0);
23841 }
23842 ios.width(25);
23843 right(ios);
23844 {
23845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23846 std::string ex(str, iter.base());
23847 assert(ex == "******************-0x0p+0");
23848 assert(ios.width() == 0);
23849 }
23850 ios.width(25);
23851 internal(ios);
23852 {
23853 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23854 std::string ex(str, iter.base());
23855 assert(ex == "-******************0x0p+0");
23856 assert(ios.width() == 0);
23857 }
23858 }
23859 ios.imbue(lg);
23860 {
23861 ios.width(0);
23862 {
23863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23864 std::string ex(str, iter.base());
23865 assert(ex == "-0x0p+0");
23866 assert(ios.width() == 0);
23867 }
23868 ios.width(25);
23869 left(ios);
23870 {
23871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23872 std::string ex(str, iter.base());
23873 assert(ex == "-0x0p+0******************");
23874 assert(ios.width() == 0);
23875 }
23876 ios.width(25);
23877 right(ios);
23878 {
23879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23880 std::string ex(str, iter.base());
23881 assert(ex == "******************-0x0p+0");
23882 assert(ios.width() == 0);
23883 }
23884 ios.width(25);
23885 internal(ios);
23886 {
23887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23888 std::string ex(str, iter.base());
23889 assert(ex == "-******************0x0p+0");
23890 assert(ios.width() == 0);
23891 }
23892 }
23893 }
23894 showpoint(ios);
23895 {
23896 ios.imbue(lc);
23897 {
23898 ios.width(0);
23899 {
23900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23901 std::string ex(str, iter.base());
23902 assert(ex == "-0x0.p+0");
23903 assert(ios.width() == 0);
23904 }
23905 ios.width(25);
23906 left(ios);
23907 {
23908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23909 std::string ex(str, iter.base());
23910 assert(ex == "-0x0.p+0*****************");
23911 assert(ios.width() == 0);
23912 }
23913 ios.width(25);
23914 right(ios);
23915 {
23916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23917 std::string ex(str, iter.base());
23918 assert(ex == "*****************-0x0.p+0");
23919 assert(ios.width() == 0);
23920 }
23921 ios.width(25);
23922 internal(ios);
23923 {
23924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23925 std::string ex(str, iter.base());
23926 assert(ex == "-*****************0x0.p+0");
23927 assert(ios.width() == 0);
23928 }
23929 }
23930 ios.imbue(lg);
23931 {
23932 ios.width(0);
23933 {
23934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23935 std::string ex(str, iter.base());
23936 assert(ex == "-0x0;p+0");
23937 assert(ios.width() == 0);
23938 }
23939 ios.width(25);
23940 left(ios);
23941 {
23942 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23943 std::string ex(str, iter.base());
23944 assert(ex == "-0x0;p+0*****************");
23945 assert(ios.width() == 0);
23946 }
23947 ios.width(25);
23948 right(ios);
23949 {
23950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23951 std::string ex(str, iter.base());
23952 assert(ex == "*****************-0x0;p+0");
23953 assert(ios.width() == 0);
23954 }
23955 ios.width(25);
23956 internal(ios);
23957 {
23958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23959 std::string ex(str, iter.base());
23960 assert(ex == "-*****************0x0;p+0");
23961 assert(ios.width() == 0);
23962 }
23963 }
23964 }
23965 }
23966 showpos(ios);
23967 {
23968 noshowpoint(ios);
23969 {
23970 ios.imbue(lc);
23971 {
23972 ios.width(0);
23973 {
23974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23975 std::string ex(str, iter.base());
23976 assert(ex == "-0x0p+0");
23977 assert(ios.width() == 0);
23978 }
23979 ios.width(25);
23980 left(ios);
23981 {
23982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23983 std::string ex(str, iter.base());
23984 assert(ex == "-0x0p+0******************");
23985 assert(ios.width() == 0);
23986 }
23987 ios.width(25);
23988 right(ios);
23989 {
23990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23991 std::string ex(str, iter.base());
23992 assert(ex == "******************-0x0p+0");
23993 assert(ios.width() == 0);
23994 }
23995 ios.width(25);
23996 internal(ios);
23997 {
23998 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23999 std::string ex(str, iter.base());
24000 assert(ex == "-******************0x0p+0");
24001 assert(ios.width() == 0);
24002 }
24003 }
24004 ios.imbue(lg);
24005 {
24006 ios.width(0);
24007 {
24008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24009 std::string ex(str, iter.base());
24010 assert(ex == "-0x0p+0");
24011 assert(ios.width() == 0);
24012 }
24013 ios.width(25);
24014 left(ios);
24015 {
24016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24017 std::string ex(str, iter.base());
24018 assert(ex == "-0x0p+0******************");
24019 assert(ios.width() == 0);
24020 }
24021 ios.width(25);
24022 right(ios);
24023 {
24024 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24025 std::string ex(str, iter.base());
24026 assert(ex == "******************-0x0p+0");
24027 assert(ios.width() == 0);
24028 }
24029 ios.width(25);
24030 internal(ios);
24031 {
24032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24033 std::string ex(str, iter.base());
24034 assert(ex == "-******************0x0p+0");
24035 assert(ios.width() == 0);
24036 }
24037 }
24038 }
24039 showpoint(ios);
24040 {
24041 ios.imbue(lc);
24042 {
24043 ios.width(0);
24044 {
24045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24046 std::string ex(str, iter.base());
24047 assert(ex == "-0x0.p+0");
24048 assert(ios.width() == 0);
24049 }
24050 ios.width(25);
24051 left(ios);
24052 {
24053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24054 std::string ex(str, iter.base());
24055 assert(ex == "-0x0.p+0*****************");
24056 assert(ios.width() == 0);
24057 }
24058 ios.width(25);
24059 right(ios);
24060 {
24061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24062 std::string ex(str, iter.base());
24063 assert(ex == "*****************-0x0.p+0");
24064 assert(ios.width() == 0);
24065 }
24066 ios.width(25);
24067 internal(ios);
24068 {
24069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24070 std::string ex(str, iter.base());
24071 assert(ex == "-*****************0x0.p+0");
24072 assert(ios.width() == 0);
24073 }
24074 }
24075 ios.imbue(lg);
24076 {
24077 ios.width(0);
24078 {
24079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24080 std::string ex(str, iter.base());
24081 assert(ex == "-0x0;p+0");
24082 assert(ios.width() == 0);
24083 }
24084 ios.width(25);
24085 left(ios);
24086 {
24087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24088 std::string ex(str, iter.base());
24089 assert(ex == "-0x0;p+0*****************");
24090 assert(ios.width() == 0);
24091 }
24092 ios.width(25);
24093 right(ios);
24094 {
24095 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24096 std::string ex(str, iter.base());
24097 assert(ex == "*****************-0x0;p+0");
24098 assert(ios.width() == 0);
24099 }
24100 ios.width(25);
24101 internal(ios);
24102 {
24103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24104 std::string ex(str, iter.base());
24105 assert(ex == "-*****************0x0;p+0");
24106 assert(ios.width() == 0);
24107 }
24108 }
24109 }
24110 }
24111 }
24112 uppercase(ios);
24113 {
24114 noshowpos(ios);
24115 {
24116 noshowpoint(ios);
24117 {
24118 ios.imbue(lc);
24119 {
24120 ios.width(0);
24121 {
24122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24123 std::string ex(str, iter.base());
24124 assert(ex == "-0X0P+0");
24125 assert(ios.width() == 0);
24126 }
24127 ios.width(25);
24128 left(ios);
24129 {
24130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24131 std::string ex(str, iter.base());
24132 assert(ex == "-0X0P+0******************");
24133 assert(ios.width() == 0);
24134 }
24135 ios.width(25);
24136 right(ios);
24137 {
24138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24139 std::string ex(str, iter.base());
24140 assert(ex == "******************-0X0P+0");
24141 assert(ios.width() == 0);
24142 }
24143 ios.width(25);
24144 internal(ios);
24145 {
24146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24147 std::string ex(str, iter.base());
24148 assert(ex == "-******************0X0P+0");
24149 assert(ios.width() == 0);
24150 }
24151 }
24152 ios.imbue(lg);
24153 {
24154 ios.width(0);
24155 {
24156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24157 std::string ex(str, iter.base());
24158 assert(ex == "-0X0P+0");
24159 assert(ios.width() == 0);
24160 }
24161 ios.width(25);
24162 left(ios);
24163 {
24164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24165 std::string ex(str, iter.base());
24166 assert(ex == "-0X0P+0******************");
24167 assert(ios.width() == 0);
24168 }
24169 ios.width(25);
24170 right(ios);
24171 {
24172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24173 std::string ex(str, iter.base());
24174 assert(ex == "******************-0X0P+0");
24175 assert(ios.width() == 0);
24176 }
24177 ios.width(25);
24178 internal(ios);
24179 {
24180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24181 std::string ex(str, iter.base());
24182 assert(ex == "-******************0X0P+0");
24183 assert(ios.width() == 0);
24184 }
24185 }
24186 }
24187 showpoint(ios);
24188 {
24189 ios.imbue(lc);
24190 {
24191 ios.width(0);
24192 {
24193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24194 std::string ex(str, iter.base());
24195 assert(ex == "-0X0.P+0");
24196 assert(ios.width() == 0);
24197 }
24198 ios.width(25);
24199 left(ios);
24200 {
24201 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24202 std::string ex(str, iter.base());
24203 assert(ex == "-0X0.P+0*****************");
24204 assert(ios.width() == 0);
24205 }
24206 ios.width(25);
24207 right(ios);
24208 {
24209 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24210 std::string ex(str, iter.base());
24211 assert(ex == "*****************-0X0.P+0");
24212 assert(ios.width() == 0);
24213 }
24214 ios.width(25);
24215 internal(ios);
24216 {
24217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24218 std::string ex(str, iter.base());
24219 assert(ex == "-*****************0X0.P+0");
24220 assert(ios.width() == 0);
24221 }
24222 }
24223 ios.imbue(lg);
24224 {
24225 ios.width(0);
24226 {
24227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24228 std::string ex(str, iter.base());
24229 assert(ex == "-0X0;P+0");
24230 assert(ios.width() == 0);
24231 }
24232 ios.width(25);
24233 left(ios);
24234 {
24235 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24236 std::string ex(str, iter.base());
24237 assert(ex == "-0X0;P+0*****************");
24238 assert(ios.width() == 0);
24239 }
24240 ios.width(25);
24241 right(ios);
24242 {
24243 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24244 std::string ex(str, iter.base());
24245 assert(ex == "*****************-0X0;P+0");
24246 assert(ios.width() == 0);
24247 }
24248 ios.width(25);
24249 internal(ios);
24250 {
24251 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24252 std::string ex(str, iter.base());
24253 assert(ex == "-*****************0X0;P+0");
24254 assert(ios.width() == 0);
24255 }
24256 }
24257 }
24258 }
24259 showpos(ios);
24260 {
24261 noshowpoint(ios);
24262 {
24263 ios.imbue(lc);
24264 {
24265 ios.width(0);
24266 {
24267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24268 std::string ex(str, iter.base());
24269 assert(ex == "-0X0P+0");
24270 assert(ios.width() == 0);
24271 }
24272 ios.width(25);
24273 left(ios);
24274 {
24275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24276 std::string ex(str, iter.base());
24277 assert(ex == "-0X0P+0******************");
24278 assert(ios.width() == 0);
24279 }
24280 ios.width(25);
24281 right(ios);
24282 {
24283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24284 std::string ex(str, iter.base());
24285 assert(ex == "******************-0X0P+0");
24286 assert(ios.width() == 0);
24287 }
24288 ios.width(25);
24289 internal(ios);
24290 {
24291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24292 std::string ex(str, iter.base());
24293 assert(ex == "-******************0X0P+0");
24294 assert(ios.width() == 0);
24295 }
24296 }
24297 ios.imbue(lg);
24298 {
24299 ios.width(0);
24300 {
24301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24302 std::string ex(str, iter.base());
24303 assert(ex == "-0X0P+0");
24304 assert(ios.width() == 0);
24305 }
24306 ios.width(25);
24307 left(ios);
24308 {
24309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24310 std::string ex(str, iter.base());
24311 assert(ex == "-0X0P+0******************");
24312 assert(ios.width() == 0);
24313 }
24314 ios.width(25);
24315 right(ios);
24316 {
24317 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24318 std::string ex(str, iter.base());
24319 assert(ex == "******************-0X0P+0");
24320 assert(ios.width() == 0);
24321 }
24322 ios.width(25);
24323 internal(ios);
24324 {
24325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24326 std::string ex(str, iter.base());
24327 assert(ex == "-******************0X0P+0");
24328 assert(ios.width() == 0);
24329 }
24330 }
24331 }
24332 showpoint(ios);
24333 {
24334 ios.imbue(lc);
24335 {
24336 ios.width(0);
24337 {
24338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24339 std::string ex(str, iter.base());
24340 assert(ex == "-0X0.P+0");
24341 assert(ios.width() == 0);
24342 }
24343 ios.width(25);
24344 left(ios);
24345 {
24346 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24347 std::string ex(str, iter.base());
24348 assert(ex == "-0X0.P+0*****************");
24349 assert(ios.width() == 0);
24350 }
24351 ios.width(25);
24352 right(ios);
24353 {
24354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24355 std::string ex(str, iter.base());
24356 assert(ex == "*****************-0X0.P+0");
24357 assert(ios.width() == 0);
24358 }
24359 ios.width(25);
24360 internal(ios);
24361 {
24362 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24363 std::string ex(str, iter.base());
24364 assert(ex == "-*****************0X0.P+0");
24365 assert(ios.width() == 0);
24366 }
24367 }
24368 ios.imbue(lg);
24369 {
24370 ios.width(0);
24371 {
24372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24373 std::string ex(str, iter.base());
24374 assert(ex == "-0X0;P+0");
24375 assert(ios.width() == 0);
24376 }
24377 ios.width(25);
24378 left(ios);
24379 {
24380 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24381 std::string ex(str, iter.base());
24382 assert(ex == "-0X0;P+0*****************");
24383 assert(ios.width() == 0);
24384 }
24385 ios.width(25);
24386 right(ios);
24387 {
24388 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24389 std::string ex(str, iter.base());
24390 assert(ex == "*****************-0X0;P+0");
24391 assert(ios.width() == 0);
24392 }
24393 ios.width(25);
24394 internal(ios);
24395 {
24396 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24397 std::string ex(str, iter.base());
24398 assert(ex == "-*****************0X0;P+0");
24399 assert(ios.width() == 0);
24400 }
24401 }
24402 }
24403 }
24404 }
24405 }
24406 ios.precision(16);
24407 {
24408 }
24409 ios.precision(60);
24410 {
24411 }
24412 }
24413 }
24414 }
24415
test12()24416 void test12()
24417 {
24418 output_iterator<char*> iter;
24419 std::locale lc = std::locale::classic();
24420 std::locale lg(lc, new my_numpunct);
24421 #ifdef __APPLE__
24422 // This test is failing on FreeBSD, possibly due to different representations
24423 // of the floating point numbers.
24424 const my_facet f(1);
24425 char str[200];
24426 {
24427 long double v = 1234567890.125;
24428 std::ios ios(0);
24429 hexfloat(ios);
24430 // %a
24431 {
24432 ios.precision(0);
24433 {
24434 nouppercase(ios);
24435 {
24436 noshowpos(ios);
24437 {
24438 noshowpoint(ios);
24439 {
24440 ios.width(0);
24441 ios.imbue(lc);
24442 {
24443 {
24444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24445 std::string ex(str, iter.base());
24446 assert(ex == "0x9.32c05a44p+27");
24447 assert(ios.width() == 0);
24448 }
24449 ios.width(25);
24450 left(ios);
24451 {
24452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24453 std::string ex(str, iter.base());
24454 assert(ex == "0x9.32c05a44p+27*********");
24455 assert(ios.width() == 0);
24456 }
24457 ios.width(25);
24458 right(ios);
24459 {
24460 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24461 std::string ex(str, iter.base());
24462 assert(ex == "*********0x9.32c05a44p+27");
24463 assert(ios.width() == 0);
24464 }
24465 ios.width(25);
24466 internal(ios);
24467 {
24468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24469 std::string ex(str, iter.base());
24470 assert(ex == "0x*********9.32c05a44p+27");
24471 assert(ios.width() == 0);
24472 }
24473 }
24474 ios.imbue(lg);
24475 {
24476 ios.width(0);
24477 {
24478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24479 std::string ex(str, iter.base());
24480 assert(ex == "0x9;32c05a44p+27");
24481 assert(ios.width() == 0);
24482 }
24483 ios.width(25);
24484 left(ios);
24485 {
24486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24487 std::string ex(str, iter.base());
24488 assert(ex == "0x9;32c05a44p+27*********");
24489 assert(ios.width() == 0);
24490 }
24491 ios.width(25);
24492 right(ios);
24493 {
24494 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24495 std::string ex(str, iter.base());
24496 assert(ex == "*********0x9;32c05a44p+27");
24497 assert(ios.width() == 0);
24498 }
24499 ios.width(25);
24500 internal(ios);
24501 {
24502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24503 std::string ex(str, iter.base());
24504 assert(ex == "0x*********9;32c05a44p+27");
24505 assert(ios.width() == 0);
24506 }
24507 }
24508 }
24509 showpoint(ios);
24510 {
24511 ios.imbue(lc);
24512 {
24513 ios.width(0);
24514 {
24515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24516 std::string ex(str, iter.base());
24517 assert(ex == "0x9.32c05a44p+27");
24518 assert(ios.width() == 0);
24519 }
24520 ios.width(25);
24521 left(ios);
24522 {
24523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24524 std::string ex(str, iter.base());
24525 assert(ex == "0x9.32c05a44p+27*********");
24526 assert(ios.width() == 0);
24527 }
24528 ios.width(25);
24529 right(ios);
24530 {
24531 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24532 std::string ex(str, iter.base());
24533 assert(ex == "*********0x9.32c05a44p+27");
24534 assert(ios.width() == 0);
24535 }
24536 ios.width(25);
24537 internal(ios);
24538 {
24539 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24540 std::string ex(str, iter.base());
24541 assert(ex == "0x*********9.32c05a44p+27");
24542 assert(ios.width() == 0);
24543 }
24544 }
24545 ios.imbue(lg);
24546 {
24547 ios.width(0);
24548 {
24549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24550 std::string ex(str, iter.base());
24551 assert(ex == "0x9;32c05a44p+27");
24552 assert(ios.width() == 0);
24553 }
24554 ios.width(25);
24555 left(ios);
24556 {
24557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24558 std::string ex(str, iter.base());
24559 assert(ex == "0x9;32c05a44p+27*********");
24560 assert(ios.width() == 0);
24561 }
24562 ios.width(25);
24563 right(ios);
24564 {
24565 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24566 std::string ex(str, iter.base());
24567 assert(ex == "*********0x9;32c05a44p+27");
24568 assert(ios.width() == 0);
24569 }
24570 ios.width(25);
24571 internal(ios);
24572 {
24573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24574 std::string ex(str, iter.base());
24575 assert(ex == "0x*********9;32c05a44p+27");
24576 assert(ios.width() == 0);
24577 }
24578 }
24579 }
24580 }
24581 showpos(ios);
24582 {
24583 noshowpoint(ios);
24584 {
24585 ios.imbue(lc);
24586 {
24587 ios.width(0);
24588 {
24589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24590 std::string ex(str, iter.base());
24591 assert(ex == "+0x9.32c05a44p+27");
24592 assert(ios.width() == 0);
24593 }
24594 ios.width(25);
24595 left(ios);
24596 {
24597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24598 std::string ex(str, iter.base());
24599 assert(ex == "+0x9.32c05a44p+27********");
24600 assert(ios.width() == 0);
24601 }
24602 ios.width(25);
24603 right(ios);
24604 {
24605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24606 std::string ex(str, iter.base());
24607 assert(ex == "********+0x9.32c05a44p+27");
24608 assert(ios.width() == 0);
24609 }
24610 ios.width(25);
24611 internal(ios);
24612 {
24613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24614 std::string ex(str, iter.base());
24615 assert(ex == "+********0x9.32c05a44p+27");
24616 assert(ios.width() == 0);
24617 }
24618 }
24619 ios.imbue(lg);
24620 {
24621 ios.width(0);
24622 {
24623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24624 std::string ex(str, iter.base());
24625 assert(ex == "+0x9;32c05a44p+27");
24626 assert(ios.width() == 0);
24627 }
24628 ios.width(25);
24629 left(ios);
24630 {
24631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24632 std::string ex(str, iter.base());
24633 assert(ex == "+0x9;32c05a44p+27********");
24634 assert(ios.width() == 0);
24635 }
24636 ios.width(25);
24637 right(ios);
24638 {
24639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24640 std::string ex(str, iter.base());
24641 assert(ex == "********+0x9;32c05a44p+27");
24642 assert(ios.width() == 0);
24643 }
24644 ios.width(25);
24645 internal(ios);
24646 {
24647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24648 std::string ex(str, iter.base());
24649 assert(ex == "+********0x9;32c05a44p+27");
24650 assert(ios.width() == 0);
24651 }
24652 }
24653 }
24654 showpoint(ios);
24655 {
24656 ios.imbue(lc);
24657 {
24658 ios.width(0);
24659 {
24660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24661 std::string ex(str, iter.base());
24662 assert(ex == "+0x9.32c05a44p+27");
24663 assert(ios.width() == 0);
24664 }
24665 ios.width(25);
24666 left(ios);
24667 {
24668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24669 std::string ex(str, iter.base());
24670 assert(ex == "+0x9.32c05a44p+27********");
24671 assert(ios.width() == 0);
24672 }
24673 ios.width(25);
24674 right(ios);
24675 {
24676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24677 std::string ex(str, iter.base());
24678 assert(ex == "********+0x9.32c05a44p+27");
24679 assert(ios.width() == 0);
24680 }
24681 ios.width(25);
24682 internal(ios);
24683 {
24684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24685 std::string ex(str, iter.base());
24686 assert(ex == "+********0x9.32c05a44p+27");
24687 assert(ios.width() == 0);
24688 }
24689 }
24690 ios.imbue(lg);
24691 {
24692 ios.width(0);
24693 {
24694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24695 std::string ex(str, iter.base());
24696 assert(ex == "+0x9;32c05a44p+27");
24697 assert(ios.width() == 0);
24698 }
24699 ios.width(25);
24700 left(ios);
24701 {
24702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24703 std::string ex(str, iter.base());
24704 assert(ex == "+0x9;32c05a44p+27********");
24705 assert(ios.width() == 0);
24706 }
24707 ios.width(25);
24708 right(ios);
24709 {
24710 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24711 std::string ex(str, iter.base());
24712 assert(ex == "********+0x9;32c05a44p+27");
24713 assert(ios.width() == 0);
24714 }
24715 ios.width(25);
24716 internal(ios);
24717 {
24718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24719 std::string ex(str, iter.base());
24720 assert(ex == "+********0x9;32c05a44p+27");
24721 assert(ios.width() == 0);
24722 }
24723 }
24724 }
24725 }
24726 }
24727 uppercase(ios);
24728 {
24729 noshowpos(ios);
24730 {
24731 noshowpoint(ios);
24732 {
24733 ios.imbue(lc);
24734 {
24735 ios.width(0);
24736 {
24737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24738 std::string ex(str, iter.base());
24739 assert(ex == "0X9.32C05A44P+27");
24740 assert(ios.width() == 0);
24741 }
24742 ios.width(25);
24743 left(ios);
24744 {
24745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24746 std::string ex(str, iter.base());
24747 assert(ex == "0X9.32C05A44P+27*********");
24748 assert(ios.width() == 0);
24749 }
24750 ios.width(25);
24751 right(ios);
24752 {
24753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24754 std::string ex(str, iter.base());
24755 assert(ex == "*********0X9.32C05A44P+27");
24756 assert(ios.width() == 0);
24757 }
24758 ios.width(25);
24759 internal(ios);
24760 {
24761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24762 std::string ex(str, iter.base());
24763 assert(ex == "0X*********9.32C05A44P+27");
24764 assert(ios.width() == 0);
24765 }
24766 }
24767 ios.imbue(lg);
24768 {
24769 ios.width(0);
24770 {
24771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24772 std::string ex(str, iter.base());
24773 assert(ex == "0X9;32C05A44P+27");
24774 assert(ios.width() == 0);
24775 }
24776 ios.width(25);
24777 left(ios);
24778 {
24779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24780 std::string ex(str, iter.base());
24781 assert(ex == "0X9;32C05A44P+27*********");
24782 assert(ios.width() == 0);
24783 }
24784 ios.width(25);
24785 right(ios);
24786 {
24787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24788 std::string ex(str, iter.base());
24789 assert(ex == "*********0X9;32C05A44P+27");
24790 assert(ios.width() == 0);
24791 }
24792 ios.width(25);
24793 internal(ios);
24794 {
24795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24796 std::string ex(str, iter.base());
24797 assert(ex == "0X*********9;32C05A44P+27");
24798 assert(ios.width() == 0);
24799 }
24800 }
24801 }
24802 showpoint(ios);
24803 {
24804 ios.imbue(lc);
24805 {
24806 ios.width(0);
24807 {
24808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24809 std::string ex(str, iter.base());
24810 assert(ex == "0X9.32C05A44P+27");
24811 assert(ios.width() == 0);
24812 }
24813 ios.width(25);
24814 left(ios);
24815 {
24816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24817 std::string ex(str, iter.base());
24818 assert(ex == "0X9.32C05A44P+27*********");
24819 assert(ios.width() == 0);
24820 }
24821 ios.width(25);
24822 right(ios);
24823 {
24824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24825 std::string ex(str, iter.base());
24826 assert(ex == "*********0X9.32C05A44P+27");
24827 assert(ios.width() == 0);
24828 }
24829 ios.width(25);
24830 internal(ios);
24831 {
24832 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24833 std::string ex(str, iter.base());
24834 assert(ex == "0X*********9.32C05A44P+27");
24835 assert(ios.width() == 0);
24836 }
24837 }
24838 ios.imbue(lg);
24839 {
24840 ios.width(0);
24841 {
24842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24843 std::string ex(str, iter.base());
24844 assert(ex == "0X9;32C05A44P+27");
24845 assert(ios.width() == 0);
24846 }
24847 ios.width(25);
24848 left(ios);
24849 {
24850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24851 std::string ex(str, iter.base());
24852 assert(ex == "0X9;32C05A44P+27*********");
24853 assert(ios.width() == 0);
24854 }
24855 ios.width(25);
24856 right(ios);
24857 {
24858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24859 std::string ex(str, iter.base());
24860 assert(ex == "*********0X9;32C05A44P+27");
24861 assert(ios.width() == 0);
24862 }
24863 ios.width(25);
24864 internal(ios);
24865 {
24866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24867 std::string ex(str, iter.base());
24868 assert(ex == "0X*********9;32C05A44P+27");
24869 assert(ios.width() == 0);
24870 }
24871 }
24872 }
24873 }
24874 showpos(ios);
24875 {
24876 noshowpoint(ios);
24877 {
24878 ios.imbue(lc);
24879 {
24880 ios.width(0);
24881 {
24882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24883 std::string ex(str, iter.base());
24884 assert(ex == "+0X9.32C05A44P+27");
24885 assert(ios.width() == 0);
24886 }
24887 ios.width(25);
24888 left(ios);
24889 {
24890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24891 std::string ex(str, iter.base());
24892 assert(ex == "+0X9.32C05A44P+27********");
24893 assert(ios.width() == 0);
24894 }
24895 ios.width(25);
24896 right(ios);
24897 {
24898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24899 std::string ex(str, iter.base());
24900 assert(ex == "********+0X9.32C05A44P+27");
24901 assert(ios.width() == 0);
24902 }
24903 ios.width(25);
24904 internal(ios);
24905 {
24906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24907 std::string ex(str, iter.base());
24908 assert(ex == "+********0X9.32C05A44P+27");
24909 assert(ios.width() == 0);
24910 }
24911 }
24912 ios.imbue(lg);
24913 {
24914 ios.width(0);
24915 {
24916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24917 std::string ex(str, iter.base());
24918 assert(ex == "+0X9;32C05A44P+27");
24919 assert(ios.width() == 0);
24920 }
24921 ios.width(25);
24922 left(ios);
24923 {
24924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24925 std::string ex(str, iter.base());
24926 assert(ex == "+0X9;32C05A44P+27********");
24927 assert(ios.width() == 0);
24928 }
24929 ios.width(25);
24930 right(ios);
24931 {
24932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24933 std::string ex(str, iter.base());
24934 assert(ex == "********+0X9;32C05A44P+27");
24935 assert(ios.width() == 0);
24936 }
24937 ios.width(25);
24938 internal(ios);
24939 {
24940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24941 std::string ex(str, iter.base());
24942 assert(ex == "+********0X9;32C05A44P+27");
24943 assert(ios.width() == 0);
24944 }
24945 }
24946 }
24947 showpoint(ios);
24948 {
24949 ios.imbue(lc);
24950 {
24951 ios.width(0);
24952 {
24953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24954 std::string ex(str, iter.base());
24955 assert(ex == "+0X9.32C05A44P+27");
24956 assert(ios.width() == 0);
24957 }
24958 ios.width(25);
24959 left(ios);
24960 {
24961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24962 std::string ex(str, iter.base());
24963 assert(ex == "+0X9.32C05A44P+27********");
24964 assert(ios.width() == 0);
24965 }
24966 ios.width(25);
24967 right(ios);
24968 {
24969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24970 std::string ex(str, iter.base());
24971 assert(ex == "********+0X9.32C05A44P+27");
24972 assert(ios.width() == 0);
24973 }
24974 ios.width(25);
24975 internal(ios);
24976 {
24977 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24978 std::string ex(str, iter.base());
24979 assert(ex == "+********0X9.32C05A44P+27");
24980 assert(ios.width() == 0);
24981 }
24982 }
24983 ios.imbue(lg);
24984 {
24985 ios.width(0);
24986 {
24987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24988 std::string ex(str, iter.base());
24989 assert(ex == "+0X9;32C05A44P+27");
24990 assert(ios.width() == 0);
24991 }
24992 ios.width(25);
24993 left(ios);
24994 {
24995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24996 std::string ex(str, iter.base());
24997 assert(ex == "+0X9;32C05A44P+27********");
24998 assert(ios.width() == 0);
24999 }
25000 ios.width(25);
25001 right(ios);
25002 {
25003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25004 std::string ex(str, iter.base());
25005 assert(ex == "********+0X9;32C05A44P+27");
25006 assert(ios.width() == 0);
25007 }
25008 ios.width(25);
25009 internal(ios);
25010 {
25011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25012 std::string ex(str, iter.base());
25013 assert(ex == "+********0X9;32C05A44P+27");
25014 assert(ios.width() == 0);
25015 }
25016 }
25017 }
25018 }
25019 }
25020 }
25021 ios.precision(1);
25022 {
25023 nouppercase(ios);
25024 {
25025 noshowpos(ios);
25026 {
25027 noshowpoint(ios);
25028 {
25029 ios.imbue(lc);
25030 {
25031 ios.width(0);
25032 {
25033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25034 std::string ex(str, iter.base());
25035 assert(ex == "0x9.32c05a44p+27");
25036 assert(ios.width() == 0);
25037 }
25038 ios.width(25);
25039 left(ios);
25040 {
25041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25042 std::string ex(str, iter.base());
25043 assert(ex == "0x9.32c05a44p+27*********");
25044 assert(ios.width() == 0);
25045 }
25046 ios.width(25);
25047 right(ios);
25048 {
25049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25050 std::string ex(str, iter.base());
25051 assert(ex == "*********0x9.32c05a44p+27");
25052 assert(ios.width() == 0);
25053 }
25054 ios.width(25);
25055 internal(ios);
25056 {
25057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25058 std::string ex(str, iter.base());
25059 assert(ex == "0x*********9.32c05a44p+27");
25060 assert(ios.width() == 0);
25061 }
25062 }
25063 ios.imbue(lg);
25064 {
25065 ios.width(0);
25066 {
25067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25068 std::string ex(str, iter.base());
25069 assert(ex == "0x9;32c05a44p+27");
25070 assert(ios.width() == 0);
25071 }
25072 ios.width(25);
25073 left(ios);
25074 {
25075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25076 std::string ex(str, iter.base());
25077 assert(ex == "0x9;32c05a44p+27*********");
25078 assert(ios.width() == 0);
25079 }
25080 ios.width(25);
25081 right(ios);
25082 {
25083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25084 std::string ex(str, iter.base());
25085 assert(ex == "*********0x9;32c05a44p+27");
25086 assert(ios.width() == 0);
25087 }
25088 ios.width(25);
25089 internal(ios);
25090 {
25091 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25092 std::string ex(str, iter.base());
25093 assert(ex == "0x*********9;32c05a44p+27");
25094 assert(ios.width() == 0);
25095 }
25096 }
25097 }
25098 showpoint(ios);
25099 {
25100 ios.imbue(lc);
25101 {
25102 ios.width(0);
25103 {
25104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25105 std::string ex(str, iter.base());
25106 assert(ex == "0x9.32c05a44p+27");
25107 assert(ios.width() == 0);
25108 }
25109 ios.width(25);
25110 left(ios);
25111 {
25112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25113 std::string ex(str, iter.base());
25114 assert(ex == "0x9.32c05a44p+27*********");
25115 assert(ios.width() == 0);
25116 }
25117 ios.width(25);
25118 right(ios);
25119 {
25120 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25121 std::string ex(str, iter.base());
25122 assert(ex == "*********0x9.32c05a44p+27");
25123 assert(ios.width() == 0);
25124 }
25125 ios.width(25);
25126 internal(ios);
25127 {
25128 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25129 std::string ex(str, iter.base());
25130 assert(ex == "0x*********9.32c05a44p+27");
25131 assert(ios.width() == 0);
25132 }
25133 }
25134 ios.imbue(lg);
25135 {
25136 ios.width(0);
25137 {
25138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25139 std::string ex(str, iter.base());
25140 assert(ex == "0x9;32c05a44p+27");
25141 assert(ios.width() == 0);
25142 }
25143 ios.width(25);
25144 left(ios);
25145 {
25146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25147 std::string ex(str, iter.base());
25148 assert(ex == "0x9;32c05a44p+27*********");
25149 assert(ios.width() == 0);
25150 }
25151 ios.width(25);
25152 right(ios);
25153 {
25154 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25155 std::string ex(str, iter.base());
25156 assert(ex == "*********0x9;32c05a44p+27");
25157 assert(ios.width() == 0);
25158 }
25159 ios.width(25);
25160 internal(ios);
25161 {
25162 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25163 std::string ex(str, iter.base());
25164 assert(ex == "0x*********9;32c05a44p+27");
25165 assert(ios.width() == 0);
25166 }
25167 }
25168 }
25169 }
25170 showpos(ios);
25171 {
25172 noshowpoint(ios);
25173 {
25174 ios.imbue(lc);
25175 {
25176 ios.width(0);
25177 {
25178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25179 std::string ex(str, iter.base());
25180 assert(ex == "+0x9.32c05a44p+27");
25181 assert(ios.width() == 0);
25182 }
25183 ios.width(25);
25184 left(ios);
25185 {
25186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25187 std::string ex(str, iter.base());
25188 assert(ex == "+0x9.32c05a44p+27********");
25189 assert(ios.width() == 0);
25190 }
25191 ios.width(25);
25192 right(ios);
25193 {
25194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25195 std::string ex(str, iter.base());
25196 assert(ex == "********+0x9.32c05a44p+27");
25197 assert(ios.width() == 0);
25198 }
25199 ios.width(25);
25200 internal(ios);
25201 {
25202 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25203 std::string ex(str, iter.base());
25204 assert(ex == "+********0x9.32c05a44p+27");
25205 assert(ios.width() == 0);
25206 }
25207 }
25208 ios.imbue(lg);
25209 {
25210 ios.width(0);
25211 {
25212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25213 std::string ex(str, iter.base());
25214 assert(ex == "+0x9;32c05a44p+27");
25215 assert(ios.width() == 0);
25216 }
25217 ios.width(25);
25218 left(ios);
25219 {
25220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25221 std::string ex(str, iter.base());
25222 assert(ex == "+0x9;32c05a44p+27********");
25223 assert(ios.width() == 0);
25224 }
25225 ios.width(25);
25226 right(ios);
25227 {
25228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25229 std::string ex(str, iter.base());
25230 assert(ex == "********+0x9;32c05a44p+27");
25231 assert(ios.width() == 0);
25232 }
25233 ios.width(25);
25234 internal(ios);
25235 {
25236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25237 std::string ex(str, iter.base());
25238 assert(ex == "+********0x9;32c05a44p+27");
25239 assert(ios.width() == 0);
25240 }
25241 }
25242 }
25243 showpoint(ios);
25244 {
25245 ios.imbue(lc);
25246 {
25247 ios.width(0);
25248 {
25249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25250 std::string ex(str, iter.base());
25251 assert(ex == "+0x9.32c05a44p+27");
25252 assert(ios.width() == 0);
25253 }
25254 ios.width(25);
25255 left(ios);
25256 {
25257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25258 std::string ex(str, iter.base());
25259 assert(ex == "+0x9.32c05a44p+27********");
25260 assert(ios.width() == 0);
25261 }
25262 ios.width(25);
25263 right(ios);
25264 {
25265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25266 std::string ex(str, iter.base());
25267 assert(ex == "********+0x9.32c05a44p+27");
25268 assert(ios.width() == 0);
25269 }
25270 ios.width(25);
25271 internal(ios);
25272 {
25273 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25274 std::string ex(str, iter.base());
25275 assert(ex == "+********0x9.32c05a44p+27");
25276 assert(ios.width() == 0);
25277 }
25278 }
25279 ios.imbue(lg);
25280 {
25281 ios.width(0);
25282 {
25283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25284 std::string ex(str, iter.base());
25285 assert(ex == "+0x9;32c05a44p+27");
25286 assert(ios.width() == 0);
25287 }
25288 ios.width(25);
25289 left(ios);
25290 {
25291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25292 std::string ex(str, iter.base());
25293 assert(ex == "+0x9;32c05a44p+27********");
25294 assert(ios.width() == 0);
25295 }
25296 ios.width(25);
25297 right(ios);
25298 {
25299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25300 std::string ex(str, iter.base());
25301 assert(ex == "********+0x9;32c05a44p+27");
25302 assert(ios.width() == 0);
25303 }
25304 ios.width(25);
25305 internal(ios);
25306 {
25307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25308 std::string ex(str, iter.base());
25309 assert(ex == "+********0x9;32c05a44p+27");
25310 assert(ios.width() == 0);
25311 }
25312 }
25313 }
25314 }
25315 }
25316 uppercase(ios);
25317 {
25318 noshowpos(ios);
25319 {
25320 noshowpoint(ios);
25321 {
25322 ios.imbue(lc);
25323 {
25324 ios.width(0);
25325 {
25326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25327 std::string ex(str, iter.base());
25328 assert(ex == "0X9.32C05A44P+27");
25329 assert(ios.width() == 0);
25330 }
25331 ios.width(25);
25332 left(ios);
25333 {
25334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25335 std::string ex(str, iter.base());
25336 assert(ex == "0X9.32C05A44P+27*********");
25337 assert(ios.width() == 0);
25338 }
25339 ios.width(25);
25340 right(ios);
25341 {
25342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25343 std::string ex(str, iter.base());
25344 assert(ex == "*********0X9.32C05A44P+27");
25345 assert(ios.width() == 0);
25346 }
25347 ios.width(25);
25348 internal(ios);
25349 {
25350 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25351 std::string ex(str, iter.base());
25352 assert(ex == "0X*********9.32C05A44P+27");
25353 assert(ios.width() == 0);
25354 }
25355 }
25356 ios.imbue(lg);
25357 {
25358 ios.width(0);
25359 {
25360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25361 std::string ex(str, iter.base());
25362 assert(ex == "0X9;32C05A44P+27");
25363 assert(ios.width() == 0);
25364 }
25365 ios.width(25);
25366 left(ios);
25367 {
25368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25369 std::string ex(str, iter.base());
25370 assert(ex == "0X9;32C05A44P+27*********");
25371 assert(ios.width() == 0);
25372 }
25373 ios.width(25);
25374 right(ios);
25375 {
25376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25377 std::string ex(str, iter.base());
25378 assert(ex == "*********0X9;32C05A44P+27");
25379 assert(ios.width() == 0);
25380 }
25381 ios.width(25);
25382 internal(ios);
25383 {
25384 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25385 std::string ex(str, iter.base());
25386 assert(ex == "0X*********9;32C05A44P+27");
25387 assert(ios.width() == 0);
25388 }
25389 }
25390 }
25391 showpoint(ios);
25392 {
25393 ios.imbue(lc);
25394 {
25395 ios.width(0);
25396 {
25397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25398 std::string ex(str, iter.base());
25399 assert(ex == "0X9.32C05A44P+27");
25400 assert(ios.width() == 0);
25401 }
25402 ios.width(25);
25403 left(ios);
25404 {
25405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25406 std::string ex(str, iter.base());
25407 assert(ex == "0X9.32C05A44P+27*********");
25408 assert(ios.width() == 0);
25409 }
25410 ios.width(25);
25411 right(ios);
25412 {
25413 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25414 std::string ex(str, iter.base());
25415 assert(ex == "*********0X9.32C05A44P+27");
25416 assert(ios.width() == 0);
25417 }
25418 ios.width(25);
25419 internal(ios);
25420 {
25421 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25422 std::string ex(str, iter.base());
25423 assert(ex == "0X*********9.32C05A44P+27");
25424 assert(ios.width() == 0);
25425 }
25426 }
25427 ios.imbue(lg);
25428 {
25429 ios.width(0);
25430 {
25431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25432 std::string ex(str, iter.base());
25433 assert(ex == "0X9;32C05A44P+27");
25434 assert(ios.width() == 0);
25435 }
25436 ios.width(25);
25437 left(ios);
25438 {
25439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25440 std::string ex(str, iter.base());
25441 assert(ex == "0X9;32C05A44P+27*********");
25442 assert(ios.width() == 0);
25443 }
25444 ios.width(25);
25445 right(ios);
25446 {
25447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25448 std::string ex(str, iter.base());
25449 assert(ex == "*********0X9;32C05A44P+27");
25450 assert(ios.width() == 0);
25451 }
25452 ios.width(25);
25453 internal(ios);
25454 {
25455 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25456 std::string ex(str, iter.base());
25457 assert(ex == "0X*********9;32C05A44P+27");
25458 assert(ios.width() == 0);
25459 }
25460 }
25461 }
25462 }
25463 showpos(ios);
25464 {
25465 noshowpoint(ios);
25466 {
25467 ios.imbue(lc);
25468 {
25469 ios.width(0);
25470 {
25471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25472 std::string ex(str, iter.base());
25473 assert(ex == "+0X9.32C05A44P+27");
25474 assert(ios.width() == 0);
25475 }
25476 ios.width(25);
25477 left(ios);
25478 {
25479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25480 std::string ex(str, iter.base());
25481 assert(ex == "+0X9.32C05A44P+27********");
25482 assert(ios.width() == 0);
25483 }
25484 ios.width(25);
25485 right(ios);
25486 {
25487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25488 std::string ex(str, iter.base());
25489 assert(ex == "********+0X9.32C05A44P+27");
25490 assert(ios.width() == 0);
25491 }
25492 ios.width(25);
25493 internal(ios);
25494 {
25495 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25496 std::string ex(str, iter.base());
25497 assert(ex == "+********0X9.32C05A44P+27");
25498 assert(ios.width() == 0);
25499 }
25500 }
25501 ios.imbue(lg);
25502 {
25503 ios.width(0);
25504 {
25505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25506 std::string ex(str, iter.base());
25507 assert(ex == "+0X9;32C05A44P+27");
25508 assert(ios.width() == 0);
25509 }
25510 ios.width(25);
25511 left(ios);
25512 {
25513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25514 std::string ex(str, iter.base());
25515 assert(ex == "+0X9;32C05A44P+27********");
25516 assert(ios.width() == 0);
25517 }
25518 ios.width(25);
25519 right(ios);
25520 {
25521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25522 std::string ex(str, iter.base());
25523 assert(ex == "********+0X9;32C05A44P+27");
25524 assert(ios.width() == 0);
25525 }
25526 ios.width(25);
25527 internal(ios);
25528 {
25529 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25530 std::string ex(str, iter.base());
25531 assert(ex == "+********0X9;32C05A44P+27");
25532 assert(ios.width() == 0);
25533 }
25534 }
25535 }
25536 showpoint(ios);
25537 {
25538 ios.imbue(lc);
25539 {
25540 ios.width(0);
25541 {
25542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25543 std::string ex(str, iter.base());
25544 assert(ex == "+0X9.32C05A44P+27");
25545 assert(ios.width() == 0);
25546 }
25547 ios.width(25);
25548 left(ios);
25549 {
25550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25551 std::string ex(str, iter.base());
25552 assert(ex == "+0X9.32C05A44P+27********");
25553 assert(ios.width() == 0);
25554 }
25555 ios.width(25);
25556 right(ios);
25557 {
25558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25559 std::string ex(str, iter.base());
25560 assert(ex == "********+0X9.32C05A44P+27");
25561 assert(ios.width() == 0);
25562 }
25563 ios.width(25);
25564 internal(ios);
25565 {
25566 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25567 std::string ex(str, iter.base());
25568 assert(ex == "+********0X9.32C05A44P+27");
25569 assert(ios.width() == 0);
25570 }
25571 }
25572 ios.imbue(lg);
25573 {
25574 ios.width(0);
25575 {
25576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25577 std::string ex(str, iter.base());
25578 assert(ex == "+0X9;32C05A44P+27");
25579 assert(ios.width() == 0);
25580 }
25581 ios.width(25);
25582 left(ios);
25583 {
25584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25585 std::string ex(str, iter.base());
25586 assert(ex == "+0X9;32C05A44P+27********");
25587 assert(ios.width() == 0);
25588 }
25589 ios.width(25);
25590 right(ios);
25591 {
25592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25593 std::string ex(str, iter.base());
25594 assert(ex == "********+0X9;32C05A44P+27");
25595 assert(ios.width() == 0);
25596 }
25597 ios.width(25);
25598 internal(ios);
25599 {
25600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25601 std::string ex(str, iter.base());
25602 assert(ex == "+********0X9;32C05A44P+27");
25603 assert(ios.width() == 0);
25604 }
25605 }
25606 }
25607 }
25608 }
25609 }
25610 ios.precision(6);
25611 {
25612 }
25613 ios.precision(16);
25614 {
25615 }
25616 ios.precision(60);
25617 {
25618 nouppercase(ios);
25619 {
25620 noshowpos(ios);
25621 {
25622 noshowpoint(ios);
25623 {
25624 ios.imbue(lc);
25625 {
25626 ios.width(0);
25627 {
25628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25629 std::string ex(str, iter.base());
25630 assert(ex == "0x9.32c05a44p+27");
25631 assert(ios.width() == 0);
25632 }
25633 ios.width(25);
25634 left(ios);
25635 {
25636 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25637 std::string ex(str, iter.base());
25638 assert(ex == "0x9.32c05a44p+27*********");
25639 assert(ios.width() == 0);
25640 }
25641 ios.width(25);
25642 right(ios);
25643 {
25644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25645 std::string ex(str, iter.base());
25646 assert(ex == "*********0x9.32c05a44p+27");
25647 assert(ios.width() == 0);
25648 }
25649 ios.width(25);
25650 internal(ios);
25651 {
25652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25653 std::string ex(str, iter.base());
25654 assert(ex == "0x*********9.32c05a44p+27");
25655 assert(ios.width() == 0);
25656 }
25657 }
25658 ios.imbue(lg);
25659 {
25660 ios.width(0);
25661 {
25662 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25663 std::string ex(str, iter.base());
25664 assert(ex == "0x9;32c05a44p+27");
25665 assert(ios.width() == 0);
25666 }
25667 ios.width(25);
25668 left(ios);
25669 {
25670 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25671 std::string ex(str, iter.base());
25672 assert(ex == "0x9;32c05a44p+27*********");
25673 assert(ios.width() == 0);
25674 }
25675 ios.width(25);
25676 right(ios);
25677 {
25678 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25679 std::string ex(str, iter.base());
25680 assert(ex == "*********0x9;32c05a44p+27");
25681 assert(ios.width() == 0);
25682 }
25683 ios.width(25);
25684 internal(ios);
25685 {
25686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25687 std::string ex(str, iter.base());
25688 assert(ex == "0x*********9;32c05a44p+27");
25689 assert(ios.width() == 0);
25690 }
25691 }
25692 }
25693 showpoint(ios);
25694 {
25695 ios.imbue(lc);
25696 {
25697 ios.width(0);
25698 {
25699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25700 std::string ex(str, iter.base());
25701 assert(ex == "0x9.32c05a44p+27");
25702 assert(ios.width() == 0);
25703 }
25704 ios.width(25);
25705 left(ios);
25706 {
25707 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25708 std::string ex(str, iter.base());
25709 assert(ex == "0x9.32c05a44p+27*********");
25710 assert(ios.width() == 0);
25711 }
25712 ios.width(25);
25713 right(ios);
25714 {
25715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25716 std::string ex(str, iter.base());
25717 assert(ex == "*********0x9.32c05a44p+27");
25718 assert(ios.width() == 0);
25719 }
25720 ios.width(25);
25721 internal(ios);
25722 {
25723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25724 std::string ex(str, iter.base());
25725 assert(ex == "0x*********9.32c05a44p+27");
25726 assert(ios.width() == 0);
25727 }
25728 }
25729 ios.imbue(lg);
25730 {
25731 ios.width(0);
25732 {
25733 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25734 std::string ex(str, iter.base());
25735 assert(ex == "0x9;32c05a44p+27");
25736 assert(ios.width() == 0);
25737 }
25738 ios.width(25);
25739 left(ios);
25740 {
25741 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25742 std::string ex(str, iter.base());
25743 assert(ex == "0x9;32c05a44p+27*********");
25744 assert(ios.width() == 0);
25745 }
25746 ios.width(25);
25747 right(ios);
25748 {
25749 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25750 std::string ex(str, iter.base());
25751 assert(ex == "*********0x9;32c05a44p+27");
25752 assert(ios.width() == 0);
25753 }
25754 ios.width(25);
25755 internal(ios);
25756 {
25757 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25758 std::string ex(str, iter.base());
25759 assert(ex == "0x*********9;32c05a44p+27");
25760 assert(ios.width() == 0);
25761 }
25762 }
25763 }
25764 }
25765 showpos(ios);
25766 {
25767 noshowpoint(ios);
25768 {
25769 ios.imbue(lc);
25770 {
25771 ios.width(0);
25772 {
25773 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25774 std::string ex(str, iter.base());
25775 assert(ex == "+0x9.32c05a44p+27");
25776 assert(ios.width() == 0);
25777 }
25778 ios.width(25);
25779 left(ios);
25780 {
25781 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25782 std::string ex(str, iter.base());
25783 assert(ex == "+0x9.32c05a44p+27********");
25784 assert(ios.width() == 0);
25785 }
25786 ios.width(25);
25787 right(ios);
25788 {
25789 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25790 std::string ex(str, iter.base());
25791 assert(ex == "********+0x9.32c05a44p+27");
25792 assert(ios.width() == 0);
25793 }
25794 ios.width(25);
25795 internal(ios);
25796 {
25797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25798 std::string ex(str, iter.base());
25799 assert(ex == "+********0x9.32c05a44p+27");
25800 assert(ios.width() == 0);
25801 }
25802 }
25803 ios.imbue(lg);
25804 {
25805 ios.width(0);
25806 {
25807 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25808 std::string ex(str, iter.base());
25809 assert(ex == "+0x9;32c05a44p+27");
25810 assert(ios.width() == 0);
25811 }
25812 ios.width(25);
25813 left(ios);
25814 {
25815 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25816 std::string ex(str, iter.base());
25817 assert(ex == "+0x9;32c05a44p+27********");
25818 assert(ios.width() == 0);
25819 }
25820 ios.width(25);
25821 right(ios);
25822 {
25823 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25824 std::string ex(str, iter.base());
25825 assert(ex == "********+0x9;32c05a44p+27");
25826 assert(ios.width() == 0);
25827 }
25828 ios.width(25);
25829 internal(ios);
25830 {
25831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25832 std::string ex(str, iter.base());
25833 assert(ex == "+********0x9;32c05a44p+27");
25834 assert(ios.width() == 0);
25835 }
25836 }
25837 }
25838 showpoint(ios);
25839 {
25840 ios.imbue(lc);
25841 {
25842 ios.width(0);
25843 {
25844 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25845 std::string ex(str, iter.base());
25846 assert(ex == "+0x9.32c05a44p+27");
25847 assert(ios.width() == 0);
25848 }
25849 ios.width(25);
25850 left(ios);
25851 {
25852 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25853 std::string ex(str, iter.base());
25854 assert(ex == "+0x9.32c05a44p+27********");
25855 assert(ios.width() == 0);
25856 }
25857 ios.width(25);
25858 right(ios);
25859 {
25860 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25861 std::string ex(str, iter.base());
25862 assert(ex == "********+0x9.32c05a44p+27");
25863 assert(ios.width() == 0);
25864 }
25865 ios.width(25);
25866 internal(ios);
25867 {
25868 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25869 std::string ex(str, iter.base());
25870 assert(ex == "+********0x9.32c05a44p+27");
25871 assert(ios.width() == 0);
25872 }
25873 }
25874 ios.imbue(lg);
25875 {
25876 ios.width(0);
25877 {
25878 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25879 std::string ex(str, iter.base());
25880 assert(ex == "+0x9;32c05a44p+27");
25881 assert(ios.width() == 0);
25882 }
25883 ios.width(25);
25884 left(ios);
25885 {
25886 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25887 std::string ex(str, iter.base());
25888 assert(ex == "+0x9;32c05a44p+27********");
25889 assert(ios.width() == 0);
25890 }
25891 ios.width(25);
25892 right(ios);
25893 {
25894 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25895 std::string ex(str, iter.base());
25896 assert(ex == "********+0x9;32c05a44p+27");
25897 assert(ios.width() == 0);
25898 }
25899 ios.width(25);
25900 internal(ios);
25901 {
25902 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25903 std::string ex(str, iter.base());
25904 assert(ex == "+********0x9;32c05a44p+27");
25905 assert(ios.width() == 0);
25906 }
25907 }
25908 }
25909 }
25910 }
25911 uppercase(ios);
25912 {
25913 noshowpos(ios);
25914 {
25915 noshowpoint(ios);
25916 {
25917 ios.imbue(lc);
25918 {
25919 ios.width(0);
25920 {
25921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25922 std::string ex(str, iter.base());
25923 assert(ex == "0X9.32C05A44P+27");
25924 assert(ios.width() == 0);
25925 }
25926 ios.width(25);
25927 left(ios);
25928 {
25929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25930 std::string ex(str, iter.base());
25931 assert(ex == "0X9.32C05A44P+27*********");
25932 assert(ios.width() == 0);
25933 }
25934 ios.width(25);
25935 right(ios);
25936 {
25937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25938 std::string ex(str, iter.base());
25939 assert(ex == "*********0X9.32C05A44P+27");
25940 assert(ios.width() == 0);
25941 }
25942 ios.width(25);
25943 internal(ios);
25944 {
25945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25946 std::string ex(str, iter.base());
25947 assert(ex == "0X*********9.32C05A44P+27");
25948 assert(ios.width() == 0);
25949 }
25950 }
25951 ios.imbue(lg);
25952 {
25953 ios.width(0);
25954 {
25955 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25956 std::string ex(str, iter.base());
25957 assert(ex == "0X9;32C05A44P+27");
25958 assert(ios.width() == 0);
25959 }
25960 ios.width(25);
25961 left(ios);
25962 {
25963 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25964 std::string ex(str, iter.base());
25965 assert(ex == "0X9;32C05A44P+27*********");
25966 assert(ios.width() == 0);
25967 }
25968 ios.width(25);
25969 right(ios);
25970 {
25971 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25972 std::string ex(str, iter.base());
25973 assert(ex == "*********0X9;32C05A44P+27");
25974 assert(ios.width() == 0);
25975 }
25976 ios.width(25);
25977 internal(ios);
25978 {
25979 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25980 std::string ex(str, iter.base());
25981 assert(ex == "0X*********9;32C05A44P+27");
25982 assert(ios.width() == 0);
25983 }
25984 }
25985 }
25986 showpoint(ios);
25987 {
25988 ios.imbue(lc);
25989 {
25990 ios.width(0);
25991 {
25992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25993 std::string ex(str, iter.base());
25994 assert(ex == "0X9.32C05A44P+27");
25995 assert(ios.width() == 0);
25996 }
25997 ios.width(25);
25998 left(ios);
25999 {
26000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26001 std::string ex(str, iter.base());
26002 assert(ex == "0X9.32C05A44P+27*********");
26003 assert(ios.width() == 0);
26004 }
26005 ios.width(25);
26006 right(ios);
26007 {
26008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26009 std::string ex(str, iter.base());
26010 assert(ex == "*********0X9.32C05A44P+27");
26011 assert(ios.width() == 0);
26012 }
26013 ios.width(25);
26014 internal(ios);
26015 {
26016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26017 std::string ex(str, iter.base());
26018 assert(ex == "0X*********9.32C05A44P+27");
26019 assert(ios.width() == 0);
26020 }
26021 }
26022 ios.imbue(lg);
26023 {
26024 ios.width(0);
26025 {
26026 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26027 std::string ex(str, iter.base());
26028 assert(ex == "0X9;32C05A44P+27");
26029 assert(ios.width() == 0);
26030 }
26031 ios.width(25);
26032 left(ios);
26033 {
26034 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26035 std::string ex(str, iter.base());
26036 assert(ex == "0X9;32C05A44P+27*********");
26037 assert(ios.width() == 0);
26038 }
26039 ios.width(25);
26040 right(ios);
26041 {
26042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26043 std::string ex(str, iter.base());
26044 assert(ex == "*********0X9;32C05A44P+27");
26045 assert(ios.width() == 0);
26046 }
26047 ios.width(25);
26048 internal(ios);
26049 {
26050 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26051 std::string ex(str, iter.base());
26052 assert(ex == "0X*********9;32C05A44P+27");
26053 assert(ios.width() == 0);
26054 }
26055 }
26056 }
26057 }
26058 showpos(ios);
26059 {
26060 noshowpoint(ios);
26061 {
26062 ios.imbue(lc);
26063 {
26064 ios.width(0);
26065 {
26066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26067 std::string ex(str, iter.base());
26068 assert(ex == "+0X9.32C05A44P+27");
26069 assert(ios.width() == 0);
26070 }
26071 ios.width(25);
26072 left(ios);
26073 {
26074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26075 std::string ex(str, iter.base());
26076 assert(ex == "+0X9.32C05A44P+27********");
26077 assert(ios.width() == 0);
26078 }
26079 ios.width(25);
26080 right(ios);
26081 {
26082 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26083 std::string ex(str, iter.base());
26084 assert(ex == "********+0X9.32C05A44P+27");
26085 assert(ios.width() == 0);
26086 }
26087 ios.width(25);
26088 internal(ios);
26089 {
26090 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26091 std::string ex(str, iter.base());
26092 assert(ex == "+********0X9.32C05A44P+27");
26093 assert(ios.width() == 0);
26094 }
26095 }
26096 ios.imbue(lg);
26097 {
26098 ios.width(0);
26099 {
26100 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26101 std::string ex(str, iter.base());
26102 assert(ex == "+0X9;32C05A44P+27");
26103 assert(ios.width() == 0);
26104 }
26105 ios.width(25);
26106 left(ios);
26107 {
26108 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26109 std::string ex(str, iter.base());
26110 assert(ex == "+0X9;32C05A44P+27********");
26111 assert(ios.width() == 0);
26112 }
26113 ios.width(25);
26114 right(ios);
26115 {
26116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26117 std::string ex(str, iter.base());
26118 assert(ex == "********+0X9;32C05A44P+27");
26119 assert(ios.width() == 0);
26120 }
26121 ios.width(25);
26122 internal(ios);
26123 {
26124 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26125 std::string ex(str, iter.base());
26126 assert(ex == "+********0X9;32C05A44P+27");
26127 assert(ios.width() == 0);
26128 }
26129 }
26130 }
26131 showpoint(ios);
26132 {
26133 ios.imbue(lc);
26134 {
26135 ios.width(0);
26136 {
26137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26138 std::string ex(str, iter.base());
26139 assert(ex == "+0X9.32C05A44P+27");
26140 assert(ios.width() == 0);
26141 }
26142 ios.width(25);
26143 left(ios);
26144 {
26145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26146 std::string ex(str, iter.base());
26147 assert(ex == "+0X9.32C05A44P+27********");
26148 assert(ios.width() == 0);
26149 }
26150 ios.width(25);
26151 right(ios);
26152 {
26153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26154 std::string ex(str, iter.base());
26155 assert(ex == "********+0X9.32C05A44P+27");
26156 assert(ios.width() == 0);
26157 }
26158 ios.width(25);
26159 internal(ios);
26160 {
26161 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26162 std::string ex(str, iter.base());
26163 assert(ex == "+********0X9.32C05A44P+27");
26164 assert(ios.width() == 0);
26165 }
26166 }
26167 ios.imbue(lg);
26168 {
26169 ios.width(0);
26170 {
26171 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26172 std::string ex(str, iter.base());
26173 assert(ex == "+0X9;32C05A44P+27");
26174 assert(ios.width() == 0);
26175 }
26176 ios.width(25);
26177 left(ios);
26178 {
26179 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26180 std::string ex(str, iter.base());
26181 assert(ex == "+0X9;32C05A44P+27********");
26182 assert(ios.width() == 0);
26183 }
26184 ios.width(25);
26185 right(ios);
26186 {
26187 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26188 std::string ex(str, iter.base());
26189 assert(ex == "********+0X9;32C05A44P+27");
26190 assert(ios.width() == 0);
26191 }
26192 ios.width(25);
26193 internal(ios);
26194 {
26195 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26196 std::string ex(str, iter.base());
26197 assert(ex == "+********0X9;32C05A44P+27");
26198 assert(ios.width() == 0);
26199 }
26200 }
26201 }
26202 }
26203 }
26204 }
26205 }
26206 }
26207 #endif
26208 }
26209
main(int,char **)26210 int main(int, char**)
26211 {
26212 test1();
26213 test2();
26214 test3();
26215 test4();
26216 test5();
26217 test6();
26218 test7();
26219 test8();
26220 test9();
26221 test10();
26222 test11();
26223 test12();
26224 output_iterator<char*> iter;
26225 std::locale lc = std::locale::classic();
26226 std::locale lg(lc, new my_numpunct);
26227 const my_facet f(1);
26228 {
26229 long double v = -INFINITY; ((void)v);
26230 }
26231 {
26232 long double v = std::nan(""); ((void)v);
26233 }
26234
26235 {
26236 long double v = +0.; ((void)v);
26237 }
26238 {
26239 long double v = -INFINITY; ((void)v);
26240 }
26241 {
26242 long double v = std::nan(""); ((void)v);
26243 }
26244 {
26245 long double v = -INFINITY; ((void)v);
26246 }
26247 {
26248 long double v = std::nan(""); ((void)v);
26249 }
26250
26251 return 0;
26252 }
26253