1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 // <locale>
10
11 // class num_put<charT, OutputIterator>
12
13 // iter_type put(iter_type s, ios_base& iob, char_type fill, long double v) const;
14
15 // TODO GLIBC uses a different string for positive and negative NAN numbers.
16 // XFAIL: linux-gnu
17
18 #include <locale>
19 #include <ios>
20 #include <cassert>
21 #include <streambuf>
22 #include <cmath>
23 #include "test_macros.h"
24 #include "test_iterators.h"
25
26 typedef std::num_put<char, output_iterator<char*> > F;
27
28 class my_facet
29 : public F
30 {
31 public:
my_facet(std::size_t refs=0)32 explicit my_facet(std::size_t refs = 0)
33 : F(refs) {}
34 };
35
36 class my_numpunct
37 : public std::numpunct<char>
38 {
39 public:
my_numpunct()40 my_numpunct() : std::numpunct<char>() {}
41
42 protected:
do_decimal_point() const43 virtual char_type do_decimal_point() const {return ';';}
do_thousands_sep() const44 virtual char_type do_thousands_sep() const {return '_';}
do_grouping() const45 virtual std::string do_grouping() const {return std::string("\1\2\3");}
46 };
47
test1()48 void test1()
49 {
50 char str[200];
51 output_iterator<char*> iter;
52 std::locale lc = std::locale::classic();
53 std::locale lg(lc, new my_numpunct);
54 const my_facet f(1);
55 {
56 long double v = +0.;
57 std::ios ios(0);
58 // %g
59 {
60 ios.precision(0);
61 {
62 nouppercase(ios);
63 {
64 noshowpos(ios);
65 {
66 noshowpoint(ios);
67 {
68 ios.imbue(lc);
69 {
70 ios.width(0);
71 {
72 iter = f.put(output_iterator<char*>(str), ios, '*', v);
73 std::string ex(str, iter.base());
74 assert(ex == "0");
75 assert(ios.width() == 0);
76 }
77 ios.width(25);
78 left(ios);
79 {
80 iter = f.put(output_iterator<char*>(str), ios, '*', v);
81 std::string ex(str, iter.base());
82 assert(ex == "0************************");
83 assert(ios.width() == 0);
84 }
85 ios.width(25);
86 right(ios);
87 {
88 iter = f.put(output_iterator<char*>(str), ios, '*', v);
89 std::string ex(str, iter.base());
90 assert(ex == "************************0");
91 assert(ios.width() == 0);
92 }
93 ios.width(25);
94 internal(ios);
95 {
96 iter = f.put(output_iterator<char*>(str), ios, '*', v);
97 std::string ex(str, iter.base());
98 assert(ex == "************************0");
99 assert(ios.width() == 0);
100 }
101 }
102 ios.imbue(lg);
103 {
104 ios.width(0);
105 {
106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
107 std::string ex(str, iter.base());
108 assert(ex == "0");
109 assert(ios.width() == 0);
110 }
111 ios.width(25);
112 left(ios);
113 {
114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
115 std::string ex(str, iter.base());
116 assert(ex == "0************************");
117 assert(ios.width() == 0);
118 }
119 ios.width(25);
120 right(ios);
121 {
122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
123 std::string ex(str, iter.base());
124 assert(ex == "************************0");
125 assert(ios.width() == 0);
126 }
127 ios.width(25);
128 internal(ios);
129 {
130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
131 std::string ex(str, iter.base());
132 assert(ex == "************************0");
133 assert(ios.width() == 0);
134 }
135 }
136 }
137 showpoint(ios);
138 {
139 ios.imbue(lc);
140 {
141 ios.width(0);
142 {
143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
144 std::string ex(str, iter.base());
145 assert(ex == "0.");
146 assert(ios.width() == 0);
147 }
148 ios.width(25);
149 left(ios);
150 {
151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
152 std::string ex(str, iter.base());
153 assert(ex == "0.***********************");
154 assert(ios.width() == 0);
155 }
156 ios.width(25);
157 right(ios);
158 {
159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
160 std::string ex(str, iter.base());
161 assert(ex == "***********************0.");
162 assert(ios.width() == 0);
163 }
164 ios.width(25);
165 internal(ios);
166 {
167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
168 std::string ex(str, iter.base());
169 assert(ex == "***********************0.");
170 assert(ios.width() == 0);
171 }
172 }
173 ios.imbue(lg);
174 {
175 ios.width(0);
176 {
177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
178 std::string ex(str, iter.base());
179 assert(ex == "0;");
180 assert(ios.width() == 0);
181 }
182 ios.width(25);
183 left(ios);
184 {
185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
186 std::string ex(str, iter.base());
187 assert(ex == "0;***********************");
188 assert(ios.width() == 0);
189 }
190 ios.width(25);
191 right(ios);
192 {
193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
194 std::string ex(str, iter.base());
195 assert(ex == "***********************0;");
196 assert(ios.width() == 0);
197 }
198 ios.width(25);
199 internal(ios);
200 {
201 iter = f.put(output_iterator<char*>(str), ios, '*', v);
202 std::string ex(str, iter.base());
203 assert(ex == "***********************0;");
204 assert(ios.width() == 0);
205 }
206 }
207 }
208 }
209 showpos(ios);
210 {
211 noshowpoint(ios);
212 {
213 ios.imbue(lc);
214 {
215 ios.width(0);
216 {
217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
218 std::string ex(str, iter.base());
219 assert(ex == "+0");
220 assert(ios.width() == 0);
221 }
222 ios.width(25);
223 left(ios);
224 {
225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
226 std::string ex(str, iter.base());
227 assert(ex == "+0***********************");
228 assert(ios.width() == 0);
229 }
230 ios.width(25);
231 right(ios);
232 {
233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
234 std::string ex(str, iter.base());
235 assert(ex == "***********************+0");
236 assert(ios.width() == 0);
237 }
238 ios.width(25);
239 internal(ios);
240 {
241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
242 std::string ex(str, iter.base());
243 assert(ex == "+***********************0");
244 assert(ios.width() == 0);
245 }
246 }
247 ios.imbue(lg);
248 {
249 ios.width(0);
250 {
251 iter = f.put(output_iterator<char*>(str), ios, '*', v);
252 std::string ex(str, iter.base());
253 assert(ex == "+0");
254 assert(ios.width() == 0);
255 }
256 ios.width(25);
257 left(ios);
258 {
259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
260 std::string ex(str, iter.base());
261 assert(ex == "+0***********************");
262 assert(ios.width() == 0);
263 }
264 ios.width(25);
265 right(ios);
266 {
267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
268 std::string ex(str, iter.base());
269 assert(ex == "***********************+0");
270 assert(ios.width() == 0);
271 }
272 ios.width(25);
273 internal(ios);
274 {
275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
276 std::string ex(str, iter.base());
277 assert(ex == "+***********************0");
278 assert(ios.width() == 0);
279 }
280 }
281 }
282 showpoint(ios);
283 {
284 ios.imbue(lc);
285 {
286 ios.width(0);
287 {
288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
289 std::string ex(str, iter.base());
290 assert(ex == "+0.");
291 assert(ios.width() == 0);
292 }
293 ios.width(25);
294 left(ios);
295 {
296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
297 std::string ex(str, iter.base());
298 assert(ex == "+0.**********************");
299 assert(ios.width() == 0);
300 }
301 ios.width(25);
302 right(ios);
303 {
304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
305 std::string ex(str, iter.base());
306 assert(ex == "**********************+0.");
307 assert(ios.width() == 0);
308 }
309 ios.width(25);
310 internal(ios);
311 {
312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
313 std::string ex(str, iter.base());
314 assert(ex == "+**********************0.");
315 assert(ios.width() == 0);
316 }
317 }
318 ios.imbue(lg);
319 {
320 ios.width(0);
321 {
322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
323 std::string ex(str, iter.base());
324 assert(ex == "+0;");
325 assert(ios.width() == 0);
326 }
327 ios.width(25);
328 left(ios);
329 {
330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
331 std::string ex(str, iter.base());
332 assert(ex == "+0;**********************");
333 assert(ios.width() == 0);
334 }
335 ios.width(25);
336 right(ios);
337 {
338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
339 std::string ex(str, iter.base());
340 assert(ex == "**********************+0;");
341 assert(ios.width() == 0);
342 }
343 ios.width(25);
344 internal(ios);
345 {
346 iter = f.put(output_iterator<char*>(str), ios, '*', v);
347 std::string ex(str, iter.base());
348 assert(ex == "+**********************0;");
349 assert(ios.width() == 0);
350 }
351 }
352 }
353 }
354 }
355 uppercase(ios);
356 {
357 noshowpos(ios);
358 {
359 noshowpoint(ios);
360 {
361 ios.imbue(lc);
362 {
363 ios.width(0);
364 {
365 iter = f.put(output_iterator<char*>(str), ios, '*', v);
366 std::string ex(str, iter.base());
367 assert(ex == "0");
368 assert(ios.width() == 0);
369 }
370 ios.width(25);
371 left(ios);
372 {
373 iter = f.put(output_iterator<char*>(str), ios, '*', v);
374 std::string ex(str, iter.base());
375 assert(ex == "0************************");
376 assert(ios.width() == 0);
377 }
378 ios.width(25);
379 right(ios);
380 {
381 iter = f.put(output_iterator<char*>(str), ios, '*', v);
382 std::string ex(str, iter.base());
383 assert(ex == "************************0");
384 assert(ios.width() == 0);
385 }
386 ios.width(25);
387 internal(ios);
388 {
389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
390 std::string ex(str, iter.base());
391 assert(ex == "************************0");
392 assert(ios.width() == 0);
393 }
394 }
395 ios.imbue(lg);
396 {
397 ios.width(0);
398 {
399 iter = f.put(output_iterator<char*>(str), ios, '*', v);
400 std::string ex(str, iter.base());
401 assert(ex == "0");
402 assert(ios.width() == 0);
403 }
404 ios.width(25);
405 left(ios);
406 {
407 iter = f.put(output_iterator<char*>(str), ios, '*', v);
408 std::string ex(str, iter.base());
409 assert(ex == "0************************");
410 assert(ios.width() == 0);
411 }
412 ios.width(25);
413 right(ios);
414 {
415 iter = f.put(output_iterator<char*>(str), ios, '*', v);
416 std::string ex(str, iter.base());
417 assert(ex == "************************0");
418 assert(ios.width() == 0);
419 }
420 ios.width(25);
421 internal(ios);
422 {
423 iter = f.put(output_iterator<char*>(str), ios, '*', v);
424 std::string ex(str, iter.base());
425 assert(ex == "************************0");
426 assert(ios.width() == 0);
427 }
428 }
429 }
430 showpoint(ios);
431 {
432 ios.imbue(lc);
433 {
434 ios.width(0);
435 {
436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
437 std::string ex(str, iter.base());
438 assert(ex == "0.");
439 assert(ios.width() == 0);
440 }
441 ios.width(25);
442 left(ios);
443 {
444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
445 std::string ex(str, iter.base());
446 assert(ex == "0.***********************");
447 assert(ios.width() == 0);
448 }
449 ios.width(25);
450 right(ios);
451 {
452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
453 std::string ex(str, iter.base());
454 assert(ex == "***********************0.");
455 assert(ios.width() == 0);
456 }
457 ios.width(25);
458 internal(ios);
459 {
460 iter = f.put(output_iterator<char*>(str), ios, '*', v);
461 std::string ex(str, iter.base());
462 assert(ex == "***********************0.");
463 assert(ios.width() == 0);
464 }
465 }
466 ios.imbue(lg);
467 {
468 ios.width(0);
469 {
470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
471 std::string ex(str, iter.base());
472 assert(ex == "0;");
473 assert(ios.width() == 0);
474 }
475 ios.width(25);
476 left(ios);
477 {
478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
479 std::string ex(str, iter.base());
480 assert(ex == "0;***********************");
481 assert(ios.width() == 0);
482 }
483 ios.width(25);
484 right(ios);
485 {
486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
487 std::string ex(str, iter.base());
488 assert(ex == "***********************0;");
489 assert(ios.width() == 0);
490 }
491 ios.width(25);
492 internal(ios);
493 {
494 iter = f.put(output_iterator<char*>(str), ios, '*', v);
495 std::string ex(str, iter.base());
496 assert(ex == "***********************0;");
497 assert(ios.width() == 0);
498 }
499 }
500 }
501 }
502 showpos(ios);
503 {
504 noshowpoint(ios);
505 {
506 ios.imbue(lc);
507 {
508 ios.width(0);
509 {
510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
511 std::string ex(str, iter.base());
512 assert(ex == "+0");
513 assert(ios.width() == 0);
514 }
515 ios.width(25);
516 left(ios);
517 {
518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
519 std::string ex(str, iter.base());
520 assert(ex == "+0***********************");
521 assert(ios.width() == 0);
522 }
523 ios.width(25);
524 right(ios);
525 {
526 iter = f.put(output_iterator<char*>(str), ios, '*', v);
527 std::string ex(str, iter.base());
528 assert(ex == "***********************+0");
529 assert(ios.width() == 0);
530 }
531 ios.width(25);
532 internal(ios);
533 {
534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
535 std::string ex(str, iter.base());
536 assert(ex == "+***********************0");
537 assert(ios.width() == 0);
538 }
539 }
540 ios.imbue(lg);
541 {
542 ios.width(0);
543 {
544 iter = f.put(output_iterator<char*>(str), ios, '*', v);
545 std::string ex(str, iter.base());
546 assert(ex == "+0");
547 assert(ios.width() == 0);
548 }
549 ios.width(25);
550 left(ios);
551 {
552 iter = f.put(output_iterator<char*>(str), ios, '*', v);
553 std::string ex(str, iter.base());
554 assert(ex == "+0***********************");
555 assert(ios.width() == 0);
556 }
557 ios.width(25);
558 right(ios);
559 {
560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
561 std::string ex(str, iter.base());
562 assert(ex == "***********************+0");
563 assert(ios.width() == 0);
564 }
565 ios.width(25);
566 internal(ios);
567 {
568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
569 std::string ex(str, iter.base());
570 assert(ex == "+***********************0");
571 assert(ios.width() == 0);
572 }
573 }
574 }
575 showpoint(ios);
576 {
577 ios.imbue(lc);
578 {
579 ios.width(0);
580 {
581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
582 std::string ex(str, iter.base());
583 assert(ex == "+0.");
584 assert(ios.width() == 0);
585 }
586 ios.width(25);
587 left(ios);
588 {
589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
590 std::string ex(str, iter.base());
591 assert(ex == "+0.**********************");
592 assert(ios.width() == 0);
593 }
594 ios.width(25);
595 right(ios);
596 {
597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
598 std::string ex(str, iter.base());
599 assert(ex == "**********************+0.");
600 assert(ios.width() == 0);
601 }
602 ios.width(25);
603 internal(ios);
604 {
605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
606 std::string ex(str, iter.base());
607 assert(ex == "+**********************0.");
608 assert(ios.width() == 0);
609 }
610 }
611 ios.imbue(lg);
612 {
613 ios.width(0);
614 {
615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
616 std::string ex(str, iter.base());
617 assert(ex == "+0;");
618 assert(ios.width() == 0);
619 }
620 ios.width(25);
621 left(ios);
622 {
623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
624 std::string ex(str, iter.base());
625 assert(ex == "+0;**********************");
626 assert(ios.width() == 0);
627 }
628 ios.width(25);
629 right(ios);
630 {
631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
632 std::string ex(str, iter.base());
633 assert(ex == "**********************+0;");
634 assert(ios.width() == 0);
635 }
636 ios.width(25);
637 internal(ios);
638 {
639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
640 std::string ex(str, iter.base());
641 assert(ex == "+**********************0;");
642 assert(ios.width() == 0);
643 }
644 }
645 }
646 }
647 }
648 }
649 ios.precision(1);
650 {
651 nouppercase(ios);
652 {
653 noshowpos(ios);
654 {
655 noshowpoint(ios);
656 {
657 ios.imbue(lc);
658 {
659 ios.width(0);
660 {
661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
662 std::string ex(str, iter.base());
663 assert(ex == "0");
664 assert(ios.width() == 0);
665 }
666 ios.width(25);
667 left(ios);
668 {
669 iter = f.put(output_iterator<char*>(str), ios, '*', v);
670 std::string ex(str, iter.base());
671 assert(ex == "0************************");
672 assert(ios.width() == 0);
673 }
674 ios.width(25);
675 right(ios);
676 {
677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
678 std::string ex(str, iter.base());
679 assert(ex == "************************0");
680 assert(ios.width() == 0);
681 }
682 ios.width(25);
683 internal(ios);
684 {
685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
686 std::string ex(str, iter.base());
687 assert(ex == "************************0");
688 assert(ios.width() == 0);
689 }
690 }
691 ios.imbue(lg);
692 {
693 ios.width(0);
694 {
695 iter = f.put(output_iterator<char*>(str), ios, '*', v);
696 std::string ex(str, iter.base());
697 assert(ex == "0");
698 assert(ios.width() == 0);
699 }
700 ios.width(25);
701 left(ios);
702 {
703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
704 std::string ex(str, iter.base());
705 assert(ex == "0************************");
706 assert(ios.width() == 0);
707 }
708 ios.width(25);
709 right(ios);
710 {
711 iter = f.put(output_iterator<char*>(str), ios, '*', v);
712 std::string ex(str, iter.base());
713 assert(ex == "************************0");
714 assert(ios.width() == 0);
715 }
716 ios.width(25);
717 internal(ios);
718 {
719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
720 std::string ex(str, iter.base());
721 assert(ex == "************************0");
722 assert(ios.width() == 0);
723 }
724 }
725 }
726 showpoint(ios);
727 {
728 ios.imbue(lc);
729 {
730 ios.width(0);
731 {
732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
733 std::string ex(str, iter.base());
734 assert(ex == "0.");
735 assert(ios.width() == 0);
736 }
737 ios.width(25);
738 left(ios);
739 {
740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
741 std::string ex(str, iter.base());
742 assert(ex == "0.***********************");
743 assert(ios.width() == 0);
744 }
745 ios.width(25);
746 right(ios);
747 {
748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
749 std::string ex(str, iter.base());
750 assert(ex == "***********************0.");
751 assert(ios.width() == 0);
752 }
753 ios.width(25);
754 internal(ios);
755 {
756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
757 std::string ex(str, iter.base());
758 assert(ex == "***********************0.");
759 assert(ios.width() == 0);
760 }
761 }
762 ios.imbue(lg);
763 {
764 ios.width(0);
765 {
766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
767 std::string ex(str, iter.base());
768 assert(ex == "0;");
769 assert(ios.width() == 0);
770 }
771 ios.width(25);
772 left(ios);
773 {
774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
775 std::string ex(str, iter.base());
776 assert(ex == "0;***********************");
777 assert(ios.width() == 0);
778 }
779 ios.width(25);
780 right(ios);
781 {
782 iter = f.put(output_iterator<char*>(str), ios, '*', v);
783 std::string ex(str, iter.base());
784 assert(ex == "***********************0;");
785 assert(ios.width() == 0);
786 }
787 ios.width(25);
788 internal(ios);
789 {
790 iter = f.put(output_iterator<char*>(str), ios, '*', v);
791 std::string ex(str, iter.base());
792 assert(ex == "***********************0;");
793 assert(ios.width() == 0);
794 }
795 }
796 }
797 }
798 showpos(ios);
799 {
800 noshowpoint(ios);
801 {
802 ios.imbue(lc);
803 {
804 ios.width(0);
805 {
806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
807 std::string ex(str, iter.base());
808 assert(ex == "+0");
809 assert(ios.width() == 0);
810 }
811 ios.width(25);
812 left(ios);
813 {
814 iter = f.put(output_iterator<char*>(str), ios, '*', v);
815 std::string ex(str, iter.base());
816 assert(ex == "+0***********************");
817 assert(ios.width() == 0);
818 }
819 ios.width(25);
820 right(ios);
821 {
822 iter = f.put(output_iterator<char*>(str), ios, '*', v);
823 std::string ex(str, iter.base());
824 assert(ex == "***********************+0");
825 assert(ios.width() == 0);
826 }
827 ios.width(25);
828 internal(ios);
829 {
830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
831 std::string ex(str, iter.base());
832 assert(ex == "+***********************0");
833 assert(ios.width() == 0);
834 }
835 }
836 ios.imbue(lg);
837 {
838 ios.width(0);
839 {
840 iter = f.put(output_iterator<char*>(str), ios, '*', v);
841 std::string ex(str, iter.base());
842 assert(ex == "+0");
843 assert(ios.width() == 0);
844 }
845 ios.width(25);
846 left(ios);
847 {
848 iter = f.put(output_iterator<char*>(str), ios, '*', v);
849 std::string ex(str, iter.base());
850 assert(ex == "+0***********************");
851 assert(ios.width() == 0);
852 }
853 ios.width(25);
854 right(ios);
855 {
856 iter = f.put(output_iterator<char*>(str), ios, '*', v);
857 std::string ex(str, iter.base());
858 assert(ex == "***********************+0");
859 assert(ios.width() == 0);
860 }
861 ios.width(25);
862 internal(ios);
863 {
864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
865 std::string ex(str, iter.base());
866 assert(ex == "+***********************0");
867 assert(ios.width() == 0);
868 }
869 }
870 }
871 showpoint(ios);
872 {
873 ios.imbue(lc);
874 {
875 ios.width(0);
876 {
877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
878 std::string ex(str, iter.base());
879 assert(ex == "+0.");
880 assert(ios.width() == 0);
881 }
882 ios.width(25);
883 left(ios);
884 {
885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
886 std::string ex(str, iter.base());
887 assert(ex == "+0.**********************");
888 assert(ios.width() == 0);
889 }
890 ios.width(25);
891 right(ios);
892 {
893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
894 std::string ex(str, iter.base());
895 assert(ex == "**********************+0.");
896 assert(ios.width() == 0);
897 }
898 ios.width(25);
899 internal(ios);
900 {
901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
902 std::string ex(str, iter.base());
903 assert(ex == "+**********************0.");
904 assert(ios.width() == 0);
905 }
906 }
907 ios.imbue(lg);
908 {
909 ios.width(0);
910 {
911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
912 std::string ex(str, iter.base());
913 assert(ex == "+0;");
914 assert(ios.width() == 0);
915 }
916 ios.width(25);
917 left(ios);
918 {
919 iter = f.put(output_iterator<char*>(str), ios, '*', v);
920 std::string ex(str, iter.base());
921 assert(ex == "+0;**********************");
922 assert(ios.width() == 0);
923 }
924 ios.width(25);
925 right(ios);
926 {
927 iter = f.put(output_iterator<char*>(str), ios, '*', v);
928 std::string ex(str, iter.base());
929 assert(ex == "**********************+0;");
930 assert(ios.width() == 0);
931 }
932 ios.width(25);
933 internal(ios);
934 {
935 iter = f.put(output_iterator<char*>(str), ios, '*', v);
936 std::string ex(str, iter.base());
937 assert(ex == "+**********************0;");
938 assert(ios.width() == 0);
939 }
940 }
941 }
942 }
943 }
944 uppercase(ios);
945 {
946 noshowpos(ios);
947 {
948 noshowpoint(ios);
949 {
950 ios.imbue(lc);
951 {
952 ios.width(0);
953 {
954 iter = f.put(output_iterator<char*>(str), ios, '*', v);
955 std::string ex(str, iter.base());
956 assert(ex == "0");
957 assert(ios.width() == 0);
958 }
959 ios.width(25);
960 left(ios);
961 {
962 iter = f.put(output_iterator<char*>(str), ios, '*', v);
963 std::string ex(str, iter.base());
964 assert(ex == "0************************");
965 assert(ios.width() == 0);
966 }
967 ios.width(25);
968 right(ios);
969 {
970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
971 std::string ex(str, iter.base());
972 assert(ex == "************************0");
973 assert(ios.width() == 0);
974 }
975 ios.width(25);
976 internal(ios);
977 {
978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
979 std::string ex(str, iter.base());
980 assert(ex == "************************0");
981 assert(ios.width() == 0);
982 }
983 }
984 ios.imbue(lg);
985 {
986 ios.width(0);
987 {
988 iter = f.put(output_iterator<char*>(str), ios, '*', v);
989 std::string ex(str, iter.base());
990 assert(ex == "0");
991 assert(ios.width() == 0);
992 }
993 ios.width(25);
994 left(ios);
995 {
996 iter = f.put(output_iterator<char*>(str), ios, '*', v);
997 std::string ex(str, iter.base());
998 assert(ex == "0************************");
999 assert(ios.width() == 0);
1000 }
1001 ios.width(25);
1002 right(ios);
1003 {
1004 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1005 std::string ex(str, iter.base());
1006 assert(ex == "************************0");
1007 assert(ios.width() == 0);
1008 }
1009 ios.width(25);
1010 internal(ios);
1011 {
1012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1013 std::string ex(str, iter.base());
1014 assert(ex == "************************0");
1015 assert(ios.width() == 0);
1016 }
1017 }
1018 }
1019 showpoint(ios);
1020 {
1021 ios.imbue(lc);
1022 {
1023 ios.width(0);
1024 {
1025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1026 std::string ex(str, iter.base());
1027 assert(ex == "0.");
1028 assert(ios.width() == 0);
1029 }
1030 ios.width(25);
1031 left(ios);
1032 {
1033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1034 std::string ex(str, iter.base());
1035 assert(ex == "0.***********************");
1036 assert(ios.width() == 0);
1037 }
1038 ios.width(25);
1039 right(ios);
1040 {
1041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1042 std::string ex(str, iter.base());
1043 assert(ex == "***********************0.");
1044 assert(ios.width() == 0);
1045 }
1046 ios.width(25);
1047 internal(ios);
1048 {
1049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1050 std::string ex(str, iter.base());
1051 assert(ex == "***********************0.");
1052 assert(ios.width() == 0);
1053 }
1054 }
1055 ios.imbue(lg);
1056 {
1057 ios.width(0);
1058 {
1059 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1060 std::string ex(str, iter.base());
1061 assert(ex == "0;");
1062 assert(ios.width() == 0);
1063 }
1064 ios.width(25);
1065 left(ios);
1066 {
1067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1068 std::string ex(str, iter.base());
1069 assert(ex == "0;***********************");
1070 assert(ios.width() == 0);
1071 }
1072 ios.width(25);
1073 right(ios);
1074 {
1075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1076 std::string ex(str, iter.base());
1077 assert(ex == "***********************0;");
1078 assert(ios.width() == 0);
1079 }
1080 ios.width(25);
1081 internal(ios);
1082 {
1083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1084 std::string ex(str, iter.base());
1085 assert(ex == "***********************0;");
1086 assert(ios.width() == 0);
1087 }
1088 }
1089 }
1090 }
1091 showpos(ios);
1092 {
1093 noshowpoint(ios);
1094 {
1095 ios.imbue(lc);
1096 {
1097 ios.width(0);
1098 {
1099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1100 std::string ex(str, iter.base());
1101 assert(ex == "+0");
1102 assert(ios.width() == 0);
1103 }
1104 ios.width(25);
1105 left(ios);
1106 {
1107 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1108 std::string ex(str, iter.base());
1109 assert(ex == "+0***********************");
1110 assert(ios.width() == 0);
1111 }
1112 ios.width(25);
1113 right(ios);
1114 {
1115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1116 std::string ex(str, iter.base());
1117 assert(ex == "***********************+0");
1118 assert(ios.width() == 0);
1119 }
1120 ios.width(25);
1121 internal(ios);
1122 {
1123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1124 std::string ex(str, iter.base());
1125 assert(ex == "+***********************0");
1126 assert(ios.width() == 0);
1127 }
1128 }
1129 ios.imbue(lg);
1130 {
1131 ios.width(0);
1132 {
1133 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1134 std::string ex(str, iter.base());
1135 assert(ex == "+0");
1136 assert(ios.width() == 0);
1137 }
1138 ios.width(25);
1139 left(ios);
1140 {
1141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1142 std::string ex(str, iter.base());
1143 assert(ex == "+0***********************");
1144 assert(ios.width() == 0);
1145 }
1146 ios.width(25);
1147 right(ios);
1148 {
1149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1150 std::string ex(str, iter.base());
1151 assert(ex == "***********************+0");
1152 assert(ios.width() == 0);
1153 }
1154 ios.width(25);
1155 internal(ios);
1156 {
1157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1158 std::string ex(str, iter.base());
1159 assert(ex == "+***********************0");
1160 assert(ios.width() == 0);
1161 }
1162 }
1163 }
1164 showpoint(ios);
1165 {
1166 ios.imbue(lc);
1167 {
1168 ios.width(0);
1169 {
1170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1171 std::string ex(str, iter.base());
1172 assert(ex == "+0.");
1173 assert(ios.width() == 0);
1174 }
1175 ios.width(25);
1176 left(ios);
1177 {
1178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1179 std::string ex(str, iter.base());
1180 assert(ex == "+0.**********************");
1181 assert(ios.width() == 0);
1182 }
1183 ios.width(25);
1184 right(ios);
1185 {
1186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1187 std::string ex(str, iter.base());
1188 assert(ex == "**********************+0.");
1189 assert(ios.width() == 0);
1190 }
1191 ios.width(25);
1192 internal(ios);
1193 {
1194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1195 std::string ex(str, iter.base());
1196 assert(ex == "+**********************0.");
1197 assert(ios.width() == 0);
1198 }
1199 }
1200 ios.imbue(lg);
1201 {
1202 ios.width(0);
1203 {
1204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1205 std::string ex(str, iter.base());
1206 assert(ex == "+0;");
1207 assert(ios.width() == 0);
1208 }
1209 ios.width(25);
1210 left(ios);
1211 {
1212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1213 std::string ex(str, iter.base());
1214 assert(ex == "+0;**********************");
1215 assert(ios.width() == 0);
1216 }
1217 ios.width(25);
1218 right(ios);
1219 {
1220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1221 std::string ex(str, iter.base());
1222 assert(ex == "**********************+0;");
1223 assert(ios.width() == 0);
1224 }
1225 ios.width(25);
1226 internal(ios);
1227 {
1228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1229 std::string ex(str, iter.base());
1230 assert(ex == "+**********************0;");
1231 assert(ios.width() == 0);
1232 }
1233 }
1234 }
1235 }
1236 }
1237 }
1238 ios.precision(6);
1239 {
1240 nouppercase(ios);
1241 {
1242 noshowpos(ios);
1243 {
1244 noshowpoint(ios);
1245 {
1246 ios.imbue(lc);
1247 {
1248 ios.width(0);
1249 {
1250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1251 std::string ex(str, iter.base());
1252 assert(ex == "0");
1253 assert(ios.width() == 0);
1254 }
1255 ios.width(25);
1256 left(ios);
1257 {
1258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1259 std::string ex(str, iter.base());
1260 assert(ex == "0************************");
1261 assert(ios.width() == 0);
1262 }
1263 ios.width(25);
1264 right(ios);
1265 {
1266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1267 std::string ex(str, iter.base());
1268 assert(ex == "************************0");
1269 assert(ios.width() == 0);
1270 }
1271 ios.width(25);
1272 internal(ios);
1273 {
1274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1275 std::string ex(str, iter.base());
1276 assert(ex == "************************0");
1277 assert(ios.width() == 0);
1278 }
1279 }
1280 ios.imbue(lg);
1281 {
1282 ios.width(0);
1283 {
1284 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1285 std::string ex(str, iter.base());
1286 assert(ex == "0");
1287 assert(ios.width() == 0);
1288 }
1289 ios.width(25);
1290 left(ios);
1291 {
1292 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1293 std::string ex(str, iter.base());
1294 assert(ex == "0************************");
1295 assert(ios.width() == 0);
1296 }
1297 ios.width(25);
1298 right(ios);
1299 {
1300 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1301 std::string ex(str, iter.base());
1302 assert(ex == "************************0");
1303 assert(ios.width() == 0);
1304 }
1305 ios.width(25);
1306 internal(ios);
1307 {
1308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1309 std::string ex(str, iter.base());
1310 assert(ex == "************************0");
1311 assert(ios.width() == 0);
1312 }
1313 }
1314 }
1315 showpoint(ios);
1316 {
1317 ios.imbue(lc);
1318 {
1319 ios.width(0);
1320 {
1321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1322 std::string ex(str, iter.base());
1323 assert(ex == "0.00000");
1324 assert(ios.width() == 0);
1325 }
1326 ios.width(25);
1327 left(ios);
1328 {
1329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1330 std::string ex(str, iter.base());
1331 assert(ex == "0.00000******************");
1332 assert(ios.width() == 0);
1333 }
1334 ios.width(25);
1335 right(ios);
1336 {
1337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1338 std::string ex(str, iter.base());
1339 assert(ex == "******************0.00000");
1340 assert(ios.width() == 0);
1341 }
1342 ios.width(25);
1343 internal(ios);
1344 {
1345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1346 std::string ex(str, iter.base());
1347 assert(ex == "******************0.00000");
1348 assert(ios.width() == 0);
1349 }
1350 }
1351 ios.imbue(lg);
1352 {
1353 ios.width(0);
1354 {
1355 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1356 std::string ex(str, iter.base());
1357 assert(ex == "0;00000");
1358 assert(ios.width() == 0);
1359 }
1360 ios.width(25);
1361 left(ios);
1362 {
1363 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1364 std::string ex(str, iter.base());
1365 assert(ex == "0;00000******************");
1366 assert(ios.width() == 0);
1367 }
1368 ios.width(25);
1369 right(ios);
1370 {
1371 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1372 std::string ex(str, iter.base());
1373 assert(ex == "******************0;00000");
1374 assert(ios.width() == 0);
1375 }
1376 ios.width(25);
1377 internal(ios);
1378 {
1379 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1380 std::string ex(str, iter.base());
1381 assert(ex == "******************0;00000");
1382 assert(ios.width() == 0);
1383 }
1384 }
1385 }
1386 }
1387 showpos(ios);
1388 {
1389 noshowpoint(ios);
1390 {
1391 ios.imbue(lc);
1392 {
1393 ios.width(0);
1394 {
1395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1396 std::string ex(str, iter.base());
1397 assert(ex == "+0");
1398 assert(ios.width() == 0);
1399 }
1400 ios.width(25);
1401 left(ios);
1402 {
1403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1404 std::string ex(str, iter.base());
1405 assert(ex == "+0***********************");
1406 assert(ios.width() == 0);
1407 }
1408 ios.width(25);
1409 right(ios);
1410 {
1411 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1412 std::string ex(str, iter.base());
1413 assert(ex == "***********************+0");
1414 assert(ios.width() == 0);
1415 }
1416 ios.width(25);
1417 internal(ios);
1418 {
1419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1420 std::string ex(str, iter.base());
1421 assert(ex == "+***********************0");
1422 assert(ios.width() == 0);
1423 }
1424 }
1425 ios.imbue(lg);
1426 {
1427 ios.width(0);
1428 {
1429 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1430 std::string ex(str, iter.base());
1431 assert(ex == "+0");
1432 assert(ios.width() == 0);
1433 }
1434 ios.width(25);
1435 left(ios);
1436 {
1437 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1438 std::string ex(str, iter.base());
1439 assert(ex == "+0***********************");
1440 assert(ios.width() == 0);
1441 }
1442 ios.width(25);
1443 right(ios);
1444 {
1445 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1446 std::string ex(str, iter.base());
1447 assert(ex == "***********************+0");
1448 assert(ios.width() == 0);
1449 }
1450 ios.width(25);
1451 internal(ios);
1452 {
1453 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1454 std::string ex(str, iter.base());
1455 assert(ex == "+***********************0");
1456 assert(ios.width() == 0);
1457 }
1458 }
1459 }
1460 showpoint(ios);
1461 {
1462 ios.imbue(lc);
1463 {
1464 ios.width(0);
1465 {
1466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1467 std::string ex(str, iter.base());
1468 assert(ex == "+0.00000");
1469 assert(ios.width() == 0);
1470 }
1471 ios.width(25);
1472 left(ios);
1473 {
1474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1475 std::string ex(str, iter.base());
1476 assert(ex == "+0.00000*****************");
1477 assert(ios.width() == 0);
1478 }
1479 ios.width(25);
1480 right(ios);
1481 {
1482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1483 std::string ex(str, iter.base());
1484 assert(ex == "*****************+0.00000");
1485 assert(ios.width() == 0);
1486 }
1487 ios.width(25);
1488 internal(ios);
1489 {
1490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1491 std::string ex(str, iter.base());
1492 assert(ex == "+*****************0.00000");
1493 assert(ios.width() == 0);
1494 }
1495 }
1496 ios.imbue(lg);
1497 {
1498 ios.width(0);
1499 {
1500 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1501 std::string ex(str, iter.base());
1502 assert(ex == "+0;00000");
1503 assert(ios.width() == 0);
1504 }
1505 ios.width(25);
1506 left(ios);
1507 {
1508 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1509 std::string ex(str, iter.base());
1510 assert(ex == "+0;00000*****************");
1511 assert(ios.width() == 0);
1512 }
1513 ios.width(25);
1514 right(ios);
1515 {
1516 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1517 std::string ex(str, iter.base());
1518 assert(ex == "*****************+0;00000");
1519 assert(ios.width() == 0);
1520 }
1521 ios.width(25);
1522 internal(ios);
1523 {
1524 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1525 std::string ex(str, iter.base());
1526 assert(ex == "+*****************0;00000");
1527 assert(ios.width() == 0);
1528 }
1529 }
1530 }
1531 }
1532 }
1533 uppercase(ios);
1534 {
1535 noshowpos(ios);
1536 {
1537 noshowpoint(ios);
1538 {
1539 ios.imbue(lc);
1540 {
1541 ios.width(0);
1542 {
1543 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1544 std::string ex(str, iter.base());
1545 assert(ex == "0");
1546 assert(ios.width() == 0);
1547 }
1548 ios.width(25);
1549 left(ios);
1550 {
1551 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1552 std::string ex(str, iter.base());
1553 assert(ex == "0************************");
1554 assert(ios.width() == 0);
1555 }
1556 ios.width(25);
1557 right(ios);
1558 {
1559 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1560 std::string ex(str, iter.base());
1561 assert(ex == "************************0");
1562 assert(ios.width() == 0);
1563 }
1564 ios.width(25);
1565 internal(ios);
1566 {
1567 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1568 std::string ex(str, iter.base());
1569 assert(ex == "************************0");
1570 assert(ios.width() == 0);
1571 }
1572 }
1573 ios.imbue(lg);
1574 {
1575 ios.width(0);
1576 {
1577 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1578 std::string ex(str, iter.base());
1579 assert(ex == "0");
1580 assert(ios.width() == 0);
1581 }
1582 ios.width(25);
1583 left(ios);
1584 {
1585 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1586 std::string ex(str, iter.base());
1587 assert(ex == "0************************");
1588 assert(ios.width() == 0);
1589 }
1590 ios.width(25);
1591 right(ios);
1592 {
1593 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1594 std::string ex(str, iter.base());
1595 assert(ex == "************************0");
1596 assert(ios.width() == 0);
1597 }
1598 ios.width(25);
1599 internal(ios);
1600 {
1601 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1602 std::string ex(str, iter.base());
1603 assert(ex == "************************0");
1604 assert(ios.width() == 0);
1605 }
1606 }
1607 }
1608 showpoint(ios);
1609 {
1610 ios.imbue(lc);
1611 {
1612 ios.width(0);
1613 {
1614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1615 std::string ex(str, iter.base());
1616 assert(ex == "0.00000");
1617 assert(ios.width() == 0);
1618 }
1619 ios.width(25);
1620 left(ios);
1621 {
1622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1623 std::string ex(str, iter.base());
1624 assert(ex == "0.00000******************");
1625 assert(ios.width() == 0);
1626 }
1627 ios.width(25);
1628 right(ios);
1629 {
1630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1631 std::string ex(str, iter.base());
1632 assert(ex == "******************0.00000");
1633 assert(ios.width() == 0);
1634 }
1635 ios.width(25);
1636 internal(ios);
1637 {
1638 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1639 std::string ex(str, iter.base());
1640 assert(ex == "******************0.00000");
1641 assert(ios.width() == 0);
1642 }
1643 }
1644 ios.imbue(lg);
1645 {
1646 ios.width(0);
1647 {
1648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1649 std::string ex(str, iter.base());
1650 assert(ex == "0;00000");
1651 assert(ios.width() == 0);
1652 }
1653 ios.width(25);
1654 left(ios);
1655 {
1656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1657 std::string ex(str, iter.base());
1658 assert(ex == "0;00000******************");
1659 assert(ios.width() == 0);
1660 }
1661 ios.width(25);
1662 right(ios);
1663 {
1664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1665 std::string ex(str, iter.base());
1666 assert(ex == "******************0;00000");
1667 assert(ios.width() == 0);
1668 }
1669 ios.width(25);
1670 internal(ios);
1671 {
1672 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1673 std::string ex(str, iter.base());
1674 assert(ex == "******************0;00000");
1675 assert(ios.width() == 0);
1676 }
1677 }
1678 }
1679 }
1680 showpos(ios);
1681 {
1682 noshowpoint(ios);
1683 {
1684 ios.imbue(lc);
1685 {
1686 ios.width(0);
1687 {
1688 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1689 std::string ex(str, iter.base());
1690 assert(ex == "+0");
1691 assert(ios.width() == 0);
1692 }
1693 ios.width(25);
1694 left(ios);
1695 {
1696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1697 std::string ex(str, iter.base());
1698 assert(ex == "+0***********************");
1699 assert(ios.width() == 0);
1700 }
1701 ios.width(25);
1702 right(ios);
1703 {
1704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1705 std::string ex(str, iter.base());
1706 assert(ex == "***********************+0");
1707 assert(ios.width() == 0);
1708 }
1709 ios.width(25);
1710 internal(ios);
1711 {
1712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1713 std::string ex(str, iter.base());
1714 assert(ex == "+***********************0");
1715 assert(ios.width() == 0);
1716 }
1717 }
1718 ios.imbue(lg);
1719 {
1720 ios.width(0);
1721 {
1722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1723 std::string ex(str, iter.base());
1724 assert(ex == "+0");
1725 assert(ios.width() == 0);
1726 }
1727 ios.width(25);
1728 left(ios);
1729 {
1730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1731 std::string ex(str, iter.base());
1732 assert(ex == "+0***********************");
1733 assert(ios.width() == 0);
1734 }
1735 ios.width(25);
1736 right(ios);
1737 {
1738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1739 std::string ex(str, iter.base());
1740 assert(ex == "***********************+0");
1741 assert(ios.width() == 0);
1742 }
1743 ios.width(25);
1744 internal(ios);
1745 {
1746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1747 std::string ex(str, iter.base());
1748 assert(ex == "+***********************0");
1749 assert(ios.width() == 0);
1750 }
1751 }
1752 }
1753 showpoint(ios);
1754 {
1755 ios.imbue(lc);
1756 {
1757 ios.width(0);
1758 {
1759 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1760 std::string ex(str, iter.base());
1761 assert(ex == "+0.00000");
1762 assert(ios.width() == 0);
1763 }
1764 ios.width(25);
1765 left(ios);
1766 {
1767 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1768 std::string ex(str, iter.base());
1769 assert(ex == "+0.00000*****************");
1770 assert(ios.width() == 0);
1771 }
1772 ios.width(25);
1773 right(ios);
1774 {
1775 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1776 std::string ex(str, iter.base());
1777 assert(ex == "*****************+0.00000");
1778 assert(ios.width() == 0);
1779 }
1780 ios.width(25);
1781 internal(ios);
1782 {
1783 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1784 std::string ex(str, iter.base());
1785 assert(ex == "+*****************0.00000");
1786 assert(ios.width() == 0);
1787 }
1788 }
1789 ios.imbue(lg);
1790 {
1791 ios.width(0);
1792 {
1793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1794 std::string ex(str, iter.base());
1795 assert(ex == "+0;00000");
1796 assert(ios.width() == 0);
1797 }
1798 ios.width(25);
1799 left(ios);
1800 {
1801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1802 std::string ex(str, iter.base());
1803 assert(ex == "+0;00000*****************");
1804 assert(ios.width() == 0);
1805 }
1806 ios.width(25);
1807 right(ios);
1808 {
1809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1810 std::string ex(str, iter.base());
1811 assert(ex == "*****************+0;00000");
1812 assert(ios.width() == 0);
1813 }
1814 ios.width(25);
1815 internal(ios);
1816 {
1817 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1818 std::string ex(str, iter.base());
1819 assert(ex == "+*****************0;00000");
1820 assert(ios.width() == 0);
1821 }
1822 }
1823 }
1824 }
1825 }
1826 }
1827 ios.precision(16);
1828 {
1829 nouppercase(ios);
1830 {
1831 noshowpos(ios);
1832 {
1833 noshowpoint(ios);
1834 {
1835 ios.imbue(lc);
1836 {
1837 ios.width(0);
1838 {
1839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1840 std::string ex(str, iter.base());
1841 assert(ex == "0");
1842 assert(ios.width() == 0);
1843 }
1844 ios.width(25);
1845 left(ios);
1846 {
1847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1848 std::string ex(str, iter.base());
1849 assert(ex == "0************************");
1850 assert(ios.width() == 0);
1851 }
1852 ios.width(25);
1853 right(ios);
1854 {
1855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1856 std::string ex(str, iter.base());
1857 assert(ex == "************************0");
1858 assert(ios.width() == 0);
1859 }
1860 ios.width(25);
1861 internal(ios);
1862 {
1863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1864 std::string ex(str, iter.base());
1865 assert(ex == "************************0");
1866 assert(ios.width() == 0);
1867 }
1868 }
1869 ios.imbue(lg);
1870 {
1871 ios.width(0);
1872 {
1873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1874 std::string ex(str, iter.base());
1875 assert(ex == "0");
1876 assert(ios.width() == 0);
1877 }
1878 ios.width(25);
1879 left(ios);
1880 {
1881 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1882 std::string ex(str, iter.base());
1883 assert(ex == "0************************");
1884 assert(ios.width() == 0);
1885 }
1886 ios.width(25);
1887 right(ios);
1888 {
1889 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1890 std::string ex(str, iter.base());
1891 assert(ex == "************************0");
1892 assert(ios.width() == 0);
1893 }
1894 ios.width(25);
1895 internal(ios);
1896 {
1897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1898 std::string ex(str, iter.base());
1899 assert(ex == "************************0");
1900 assert(ios.width() == 0);
1901 }
1902 }
1903 }
1904 showpoint(ios);
1905 {
1906 ios.imbue(lc);
1907 {
1908 ios.width(0);
1909 {
1910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1911 std::string ex(str, iter.base());
1912 assert(ex == "0.000000000000000");
1913 assert(ios.width() == 0);
1914 }
1915 ios.width(25);
1916 left(ios);
1917 {
1918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1919 std::string ex(str, iter.base());
1920 assert(ex == "0.000000000000000********");
1921 assert(ios.width() == 0);
1922 }
1923 ios.width(25);
1924 right(ios);
1925 {
1926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1927 std::string ex(str, iter.base());
1928 assert(ex == "********0.000000000000000");
1929 assert(ios.width() == 0);
1930 }
1931 ios.width(25);
1932 internal(ios);
1933 {
1934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1935 std::string ex(str, iter.base());
1936 assert(ex == "********0.000000000000000");
1937 assert(ios.width() == 0);
1938 }
1939 }
1940 ios.imbue(lg);
1941 {
1942 ios.width(0);
1943 {
1944 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1945 std::string ex(str, iter.base());
1946 assert(ex == "0;000000000000000");
1947 assert(ios.width() == 0);
1948 }
1949 ios.width(25);
1950 left(ios);
1951 {
1952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1953 std::string ex(str, iter.base());
1954 assert(ex == "0;000000000000000********");
1955 assert(ios.width() == 0);
1956 }
1957 ios.width(25);
1958 right(ios);
1959 {
1960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1961 std::string ex(str, iter.base());
1962 assert(ex == "********0;000000000000000");
1963 assert(ios.width() == 0);
1964 }
1965 ios.width(25);
1966 internal(ios);
1967 {
1968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1969 std::string ex(str, iter.base());
1970 assert(ex == "********0;000000000000000");
1971 assert(ios.width() == 0);
1972 }
1973 }
1974 }
1975 }
1976 showpos(ios);
1977 {
1978 noshowpoint(ios);
1979 {
1980 ios.imbue(lc);
1981 {
1982 ios.width(0);
1983 {
1984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1985 std::string ex(str, iter.base());
1986 assert(ex == "+0");
1987 assert(ios.width() == 0);
1988 }
1989 ios.width(25);
1990 left(ios);
1991 {
1992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
1993 std::string ex(str, iter.base());
1994 assert(ex == "+0***********************");
1995 assert(ios.width() == 0);
1996 }
1997 ios.width(25);
1998 right(ios);
1999 {
2000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2001 std::string ex(str, iter.base());
2002 assert(ex == "***********************+0");
2003 assert(ios.width() == 0);
2004 }
2005 ios.width(25);
2006 internal(ios);
2007 {
2008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2009 std::string ex(str, iter.base());
2010 assert(ex == "+***********************0");
2011 assert(ios.width() == 0);
2012 }
2013 }
2014 ios.imbue(lg);
2015 {
2016 ios.width(0);
2017 {
2018 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2019 std::string ex(str, iter.base());
2020 assert(ex == "+0");
2021 assert(ios.width() == 0);
2022 }
2023 ios.width(25);
2024 left(ios);
2025 {
2026 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2027 std::string ex(str, iter.base());
2028 assert(ex == "+0***********************");
2029 assert(ios.width() == 0);
2030 }
2031 ios.width(25);
2032 right(ios);
2033 {
2034 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2035 std::string ex(str, iter.base());
2036 assert(ex == "***********************+0");
2037 assert(ios.width() == 0);
2038 }
2039 ios.width(25);
2040 internal(ios);
2041 {
2042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2043 std::string ex(str, iter.base());
2044 assert(ex == "+***********************0");
2045 assert(ios.width() == 0);
2046 }
2047 }
2048 }
2049 showpoint(ios);
2050 {
2051 ios.imbue(lc);
2052 {
2053 ios.width(0);
2054 {
2055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2056 std::string ex(str, iter.base());
2057 assert(ex == "+0.000000000000000");
2058 assert(ios.width() == 0);
2059 }
2060 ios.width(25);
2061 left(ios);
2062 {
2063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2064 std::string ex(str, iter.base());
2065 assert(ex == "+0.000000000000000*******");
2066 assert(ios.width() == 0);
2067 }
2068 ios.width(25);
2069 right(ios);
2070 {
2071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2072 std::string ex(str, iter.base());
2073 assert(ex == "*******+0.000000000000000");
2074 assert(ios.width() == 0);
2075 }
2076 ios.width(25);
2077 internal(ios);
2078 {
2079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2080 std::string ex(str, iter.base());
2081 assert(ex == "+*******0.000000000000000");
2082 assert(ios.width() == 0);
2083 }
2084 }
2085 ios.imbue(lg);
2086 {
2087 ios.width(0);
2088 {
2089 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2090 std::string ex(str, iter.base());
2091 assert(ex == "+0;000000000000000");
2092 assert(ios.width() == 0);
2093 }
2094 ios.width(25);
2095 left(ios);
2096 {
2097 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2098 std::string ex(str, iter.base());
2099 assert(ex == "+0;000000000000000*******");
2100 assert(ios.width() == 0);
2101 }
2102 ios.width(25);
2103 right(ios);
2104 {
2105 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2106 std::string ex(str, iter.base());
2107 assert(ex == "*******+0;000000000000000");
2108 assert(ios.width() == 0);
2109 }
2110 ios.width(25);
2111 internal(ios);
2112 {
2113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2114 std::string ex(str, iter.base());
2115 assert(ex == "+*******0;000000000000000");
2116 assert(ios.width() == 0);
2117 }
2118 }
2119 }
2120 }
2121 }
2122 uppercase(ios);
2123 {
2124 noshowpos(ios);
2125 {
2126 noshowpoint(ios);
2127 {
2128 ios.imbue(lc);
2129 {
2130 ios.width(0);
2131 {
2132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2133 std::string ex(str, iter.base());
2134 assert(ex == "0");
2135 assert(ios.width() == 0);
2136 }
2137 ios.width(25);
2138 left(ios);
2139 {
2140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2141 std::string ex(str, iter.base());
2142 assert(ex == "0************************");
2143 assert(ios.width() == 0);
2144 }
2145 ios.width(25);
2146 right(ios);
2147 {
2148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2149 std::string ex(str, iter.base());
2150 assert(ex == "************************0");
2151 assert(ios.width() == 0);
2152 }
2153 ios.width(25);
2154 internal(ios);
2155 {
2156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2157 std::string ex(str, iter.base());
2158 assert(ex == "************************0");
2159 assert(ios.width() == 0);
2160 }
2161 }
2162 ios.imbue(lg);
2163 {
2164 ios.width(0);
2165 {
2166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2167 std::string ex(str, iter.base());
2168 assert(ex == "0");
2169 assert(ios.width() == 0);
2170 }
2171 ios.width(25);
2172 left(ios);
2173 {
2174 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2175 std::string ex(str, iter.base());
2176 assert(ex == "0************************");
2177 assert(ios.width() == 0);
2178 }
2179 ios.width(25);
2180 right(ios);
2181 {
2182 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2183 std::string ex(str, iter.base());
2184 assert(ex == "************************0");
2185 assert(ios.width() == 0);
2186 }
2187 ios.width(25);
2188 internal(ios);
2189 {
2190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2191 std::string ex(str, iter.base());
2192 assert(ex == "************************0");
2193 assert(ios.width() == 0);
2194 }
2195 }
2196 }
2197 showpoint(ios);
2198 {
2199 ios.imbue(lc);
2200 {
2201 ios.width(0);
2202 {
2203 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2204 std::string ex(str, iter.base());
2205 assert(ex == "0.000000000000000");
2206 assert(ios.width() == 0);
2207 }
2208 ios.width(25);
2209 left(ios);
2210 {
2211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2212 std::string ex(str, iter.base());
2213 assert(ex == "0.000000000000000********");
2214 assert(ios.width() == 0);
2215 }
2216 ios.width(25);
2217 right(ios);
2218 {
2219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2220 std::string ex(str, iter.base());
2221 assert(ex == "********0.000000000000000");
2222 assert(ios.width() == 0);
2223 }
2224 ios.width(25);
2225 internal(ios);
2226 {
2227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2228 std::string ex(str, iter.base());
2229 assert(ex == "********0.000000000000000");
2230 assert(ios.width() == 0);
2231 }
2232 }
2233 ios.imbue(lg);
2234 {
2235 ios.width(0);
2236 {
2237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2238 std::string ex(str, iter.base());
2239 assert(ex == "0;000000000000000");
2240 assert(ios.width() == 0);
2241 }
2242 ios.width(25);
2243 left(ios);
2244 {
2245 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2246 std::string ex(str, iter.base());
2247 assert(ex == "0;000000000000000********");
2248 assert(ios.width() == 0);
2249 }
2250 ios.width(25);
2251 right(ios);
2252 {
2253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2254 std::string ex(str, iter.base());
2255 assert(ex == "********0;000000000000000");
2256 assert(ios.width() == 0);
2257 }
2258 ios.width(25);
2259 internal(ios);
2260 {
2261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2262 std::string ex(str, iter.base());
2263 assert(ex == "********0;000000000000000");
2264 assert(ios.width() == 0);
2265 }
2266 }
2267 }
2268 }
2269 showpos(ios);
2270 {
2271 noshowpoint(ios);
2272 {
2273 ios.imbue(lc);
2274 {
2275 ios.width(0);
2276 {
2277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2278 std::string ex(str, iter.base());
2279 assert(ex == "+0");
2280 assert(ios.width() == 0);
2281 }
2282 ios.width(25);
2283 left(ios);
2284 {
2285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2286 std::string ex(str, iter.base());
2287 assert(ex == "+0***********************");
2288 assert(ios.width() == 0);
2289 }
2290 ios.width(25);
2291 right(ios);
2292 {
2293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2294 std::string ex(str, iter.base());
2295 assert(ex == "***********************+0");
2296 assert(ios.width() == 0);
2297 }
2298 ios.width(25);
2299 internal(ios);
2300 {
2301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2302 std::string ex(str, iter.base());
2303 assert(ex == "+***********************0");
2304 assert(ios.width() == 0);
2305 }
2306 }
2307 ios.imbue(lg);
2308 {
2309 ios.width(0);
2310 {
2311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2312 std::string ex(str, iter.base());
2313 assert(ex == "+0");
2314 assert(ios.width() == 0);
2315 }
2316 ios.width(25);
2317 left(ios);
2318 {
2319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2320 std::string ex(str, iter.base());
2321 assert(ex == "+0***********************");
2322 assert(ios.width() == 0);
2323 }
2324 ios.width(25);
2325 right(ios);
2326 {
2327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2328 std::string ex(str, iter.base());
2329 assert(ex == "***********************+0");
2330 assert(ios.width() == 0);
2331 }
2332 ios.width(25);
2333 internal(ios);
2334 {
2335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2336 std::string ex(str, iter.base());
2337 assert(ex == "+***********************0");
2338 assert(ios.width() == 0);
2339 }
2340 }
2341 }
2342 showpoint(ios);
2343 {
2344 ios.imbue(lc);
2345 {
2346 ios.width(0);
2347 {
2348 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2349 std::string ex(str, iter.base());
2350 assert(ex == "+0.000000000000000");
2351 assert(ios.width() == 0);
2352 }
2353 ios.width(25);
2354 left(ios);
2355 {
2356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2357 std::string ex(str, iter.base());
2358 assert(ex == "+0.000000000000000*******");
2359 assert(ios.width() == 0);
2360 }
2361 ios.width(25);
2362 right(ios);
2363 {
2364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2365 std::string ex(str, iter.base());
2366 assert(ex == "*******+0.000000000000000");
2367 assert(ios.width() == 0);
2368 }
2369 ios.width(25);
2370 internal(ios);
2371 {
2372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2373 std::string ex(str, iter.base());
2374 assert(ex == "+*******0.000000000000000");
2375 assert(ios.width() == 0);
2376 }
2377 }
2378 ios.imbue(lg);
2379 {
2380 ios.width(0);
2381 {
2382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2383 std::string ex(str, iter.base());
2384 assert(ex == "+0;000000000000000");
2385 assert(ios.width() == 0);
2386 }
2387 ios.width(25);
2388 left(ios);
2389 {
2390 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2391 std::string ex(str, iter.base());
2392 assert(ex == "+0;000000000000000*******");
2393 assert(ios.width() == 0);
2394 }
2395 ios.width(25);
2396 right(ios);
2397 {
2398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2399 std::string ex(str, iter.base());
2400 assert(ex == "*******+0;000000000000000");
2401 assert(ios.width() == 0);
2402 }
2403 ios.width(25);
2404 internal(ios);
2405 {
2406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2407 std::string ex(str, iter.base());
2408 assert(ex == "+*******0;000000000000000");
2409 assert(ios.width() == 0);
2410 }
2411 }
2412 }
2413 }
2414 }
2415 }
2416 ios.precision(60);
2417 {
2418 nouppercase(ios);
2419 {
2420 noshowpos(ios);
2421 {
2422 noshowpoint(ios);
2423 {
2424 ios.imbue(lc);
2425 {
2426 ios.width(0);
2427 {
2428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2429 std::string ex(str, iter.base());
2430 assert(ex == "0");
2431 assert(ios.width() == 0);
2432 }
2433 ios.width(25);
2434 left(ios);
2435 {
2436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2437 std::string ex(str, iter.base());
2438 assert(ex == "0************************");
2439 assert(ios.width() == 0);
2440 }
2441 ios.width(25);
2442 right(ios);
2443 {
2444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2445 std::string ex(str, iter.base());
2446 assert(ex == "************************0");
2447 assert(ios.width() == 0);
2448 }
2449 ios.width(25);
2450 internal(ios);
2451 {
2452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2453 std::string ex(str, iter.base());
2454 assert(ex == "************************0");
2455 assert(ios.width() == 0);
2456 }
2457 }
2458 ios.imbue(lg);
2459 {
2460 ios.width(0);
2461 {
2462 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2463 std::string ex(str, iter.base());
2464 assert(ex == "0");
2465 assert(ios.width() == 0);
2466 }
2467 ios.width(25);
2468 left(ios);
2469 {
2470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2471 std::string ex(str, iter.base());
2472 assert(ex == "0************************");
2473 assert(ios.width() == 0);
2474 }
2475 ios.width(25);
2476 right(ios);
2477 {
2478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2479 std::string ex(str, iter.base());
2480 assert(ex == "************************0");
2481 assert(ios.width() == 0);
2482 }
2483 ios.width(25);
2484 internal(ios);
2485 {
2486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2487 std::string ex(str, iter.base());
2488 assert(ex == "************************0");
2489 assert(ios.width() == 0);
2490 }
2491 }
2492 }
2493 showpoint(ios);
2494 {
2495 ios.imbue(lc);
2496 {
2497 ios.width(0);
2498 {
2499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2500 std::string ex(str, iter.base());
2501 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2502 assert(ios.width() == 0);
2503 }
2504 ios.width(25);
2505 left(ios);
2506 {
2507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2508 std::string ex(str, iter.base());
2509 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2510 assert(ios.width() == 0);
2511 }
2512 ios.width(25);
2513 right(ios);
2514 {
2515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2516 std::string ex(str, iter.base());
2517 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2518 assert(ios.width() == 0);
2519 }
2520 ios.width(25);
2521 internal(ios);
2522 {
2523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2524 std::string ex(str, iter.base());
2525 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2526 assert(ios.width() == 0);
2527 }
2528 }
2529 ios.imbue(lg);
2530 {
2531 ios.width(0);
2532 {
2533 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2534 std::string ex(str, iter.base());
2535 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2536 assert(ios.width() == 0);
2537 }
2538 ios.width(25);
2539 left(ios);
2540 {
2541 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2542 std::string ex(str, iter.base());
2543 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2544 assert(ios.width() == 0);
2545 }
2546 ios.width(25);
2547 right(ios);
2548 {
2549 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2550 std::string ex(str, iter.base());
2551 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2552 assert(ios.width() == 0);
2553 }
2554 ios.width(25);
2555 internal(ios);
2556 {
2557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2558 std::string ex(str, iter.base());
2559 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2560 assert(ios.width() == 0);
2561 }
2562 }
2563 }
2564 }
2565 showpos(ios);
2566 {
2567 noshowpoint(ios);
2568 {
2569 ios.imbue(lc);
2570 {
2571 ios.width(0);
2572 {
2573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2574 std::string ex(str, iter.base());
2575 assert(ex == "+0");
2576 assert(ios.width() == 0);
2577 }
2578 ios.width(25);
2579 left(ios);
2580 {
2581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2582 std::string ex(str, iter.base());
2583 assert(ex == "+0***********************");
2584 assert(ios.width() == 0);
2585 }
2586 ios.width(25);
2587 right(ios);
2588 {
2589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2590 std::string ex(str, iter.base());
2591 assert(ex == "***********************+0");
2592 assert(ios.width() == 0);
2593 }
2594 ios.width(25);
2595 internal(ios);
2596 {
2597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2598 std::string ex(str, iter.base());
2599 assert(ex == "+***********************0");
2600 assert(ios.width() == 0);
2601 }
2602 }
2603 ios.imbue(lg);
2604 {
2605 ios.width(0);
2606 {
2607 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2608 std::string ex(str, iter.base());
2609 assert(ex == "+0");
2610 assert(ios.width() == 0);
2611 }
2612 ios.width(25);
2613 left(ios);
2614 {
2615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2616 std::string ex(str, iter.base());
2617 assert(ex == "+0***********************");
2618 assert(ios.width() == 0);
2619 }
2620 ios.width(25);
2621 right(ios);
2622 {
2623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2624 std::string ex(str, iter.base());
2625 assert(ex == "***********************+0");
2626 assert(ios.width() == 0);
2627 }
2628 ios.width(25);
2629 internal(ios);
2630 {
2631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2632 std::string ex(str, iter.base());
2633 assert(ex == "+***********************0");
2634 assert(ios.width() == 0);
2635 }
2636 }
2637 }
2638 showpoint(ios);
2639 {
2640 ios.imbue(lc);
2641 {
2642 ios.width(0);
2643 {
2644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2645 std::string ex(str, iter.base());
2646 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2647 assert(ios.width() == 0);
2648 }
2649 ios.width(25);
2650 left(ios);
2651 {
2652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2653 std::string ex(str, iter.base());
2654 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2655 assert(ios.width() == 0);
2656 }
2657 ios.width(25);
2658 right(ios);
2659 {
2660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2661 std::string ex(str, iter.base());
2662 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2663 assert(ios.width() == 0);
2664 }
2665 ios.width(25);
2666 internal(ios);
2667 {
2668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2669 std::string ex(str, iter.base());
2670 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2671 assert(ios.width() == 0);
2672 }
2673 }
2674 ios.imbue(lg);
2675 {
2676 ios.width(0);
2677 {
2678 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2679 std::string ex(str, iter.base());
2680 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2681 assert(ios.width() == 0);
2682 }
2683 ios.width(25);
2684 left(ios);
2685 {
2686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2687 std::string ex(str, iter.base());
2688 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2689 assert(ios.width() == 0);
2690 }
2691 ios.width(25);
2692 right(ios);
2693 {
2694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2695 std::string ex(str, iter.base());
2696 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2697 assert(ios.width() == 0);
2698 }
2699 ios.width(25);
2700 internal(ios);
2701 {
2702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2703 std::string ex(str, iter.base());
2704 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2705 assert(ios.width() == 0);
2706 }
2707 }
2708 }
2709 }
2710 }
2711 uppercase(ios);
2712 {
2713 noshowpos(ios);
2714 {
2715 noshowpoint(ios);
2716 {
2717 ios.imbue(lc);
2718 {
2719 ios.width(0);
2720 {
2721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2722 std::string ex(str, iter.base());
2723 assert(ex == "0");
2724 assert(ios.width() == 0);
2725 }
2726 ios.width(25);
2727 left(ios);
2728 {
2729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2730 std::string ex(str, iter.base());
2731 assert(ex == "0************************");
2732 assert(ios.width() == 0);
2733 }
2734 ios.width(25);
2735 right(ios);
2736 {
2737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2738 std::string ex(str, iter.base());
2739 assert(ex == "************************0");
2740 assert(ios.width() == 0);
2741 }
2742 ios.width(25);
2743 internal(ios);
2744 {
2745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2746 std::string ex(str, iter.base());
2747 assert(ex == "************************0");
2748 assert(ios.width() == 0);
2749 }
2750 }
2751 ios.imbue(lg);
2752 {
2753 ios.width(0);
2754 {
2755 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2756 std::string ex(str, iter.base());
2757 assert(ex == "0");
2758 assert(ios.width() == 0);
2759 }
2760 ios.width(25);
2761 left(ios);
2762 {
2763 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2764 std::string ex(str, iter.base());
2765 assert(ex == "0************************");
2766 assert(ios.width() == 0);
2767 }
2768 ios.width(25);
2769 right(ios);
2770 {
2771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2772 std::string ex(str, iter.base());
2773 assert(ex == "************************0");
2774 assert(ios.width() == 0);
2775 }
2776 ios.width(25);
2777 internal(ios);
2778 {
2779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2780 std::string ex(str, iter.base());
2781 assert(ex == "************************0");
2782 assert(ios.width() == 0);
2783 }
2784 }
2785 }
2786 showpoint(ios);
2787 {
2788 ios.imbue(lc);
2789 {
2790 ios.width(0);
2791 {
2792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2793 std::string ex(str, iter.base());
2794 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2795 assert(ios.width() == 0);
2796 }
2797 ios.width(25);
2798 left(ios);
2799 {
2800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2801 std::string ex(str, iter.base());
2802 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2803 assert(ios.width() == 0);
2804 }
2805 ios.width(25);
2806 right(ios);
2807 {
2808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2809 std::string ex(str, iter.base());
2810 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2811 assert(ios.width() == 0);
2812 }
2813 ios.width(25);
2814 internal(ios);
2815 {
2816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2817 std::string ex(str, iter.base());
2818 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2819 assert(ios.width() == 0);
2820 }
2821 }
2822 ios.imbue(lg);
2823 {
2824 ios.width(0);
2825 {
2826 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2827 std::string ex(str, iter.base());
2828 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2829 assert(ios.width() == 0);
2830 }
2831 ios.width(25);
2832 left(ios);
2833 {
2834 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2835 std::string ex(str, iter.base());
2836 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2837 assert(ios.width() == 0);
2838 }
2839 ios.width(25);
2840 right(ios);
2841 {
2842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2843 std::string ex(str, iter.base());
2844 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2845 assert(ios.width() == 0);
2846 }
2847 ios.width(25);
2848 internal(ios);
2849 {
2850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2851 std::string ex(str, iter.base());
2852 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2853 assert(ios.width() == 0);
2854 }
2855 }
2856 }
2857 }
2858 showpos(ios);
2859 {
2860 noshowpoint(ios);
2861 {
2862 ios.imbue(lc);
2863 {
2864 ios.width(0);
2865 {
2866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2867 std::string ex(str, iter.base());
2868 assert(ex == "+0");
2869 assert(ios.width() == 0);
2870 }
2871 ios.width(25);
2872 left(ios);
2873 {
2874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2875 std::string ex(str, iter.base());
2876 assert(ex == "+0***********************");
2877 assert(ios.width() == 0);
2878 }
2879 ios.width(25);
2880 right(ios);
2881 {
2882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2883 std::string ex(str, iter.base());
2884 assert(ex == "***********************+0");
2885 assert(ios.width() == 0);
2886 }
2887 ios.width(25);
2888 internal(ios);
2889 {
2890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2891 std::string ex(str, iter.base());
2892 assert(ex == "+***********************0");
2893 assert(ios.width() == 0);
2894 }
2895 }
2896 ios.imbue(lg);
2897 {
2898 ios.width(0);
2899 {
2900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2901 std::string ex(str, iter.base());
2902 assert(ex == "+0");
2903 assert(ios.width() == 0);
2904 }
2905 ios.width(25);
2906 left(ios);
2907 {
2908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2909 std::string ex(str, iter.base());
2910 assert(ex == "+0***********************");
2911 assert(ios.width() == 0);
2912 }
2913 ios.width(25);
2914 right(ios);
2915 {
2916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2917 std::string ex(str, iter.base());
2918 assert(ex == "***********************+0");
2919 assert(ios.width() == 0);
2920 }
2921 ios.width(25);
2922 internal(ios);
2923 {
2924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2925 std::string ex(str, iter.base());
2926 assert(ex == "+***********************0");
2927 assert(ios.width() == 0);
2928 }
2929 }
2930 }
2931 showpoint(ios);
2932 {
2933 ios.imbue(lc);
2934 {
2935 ios.width(0);
2936 {
2937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2938 std::string ex(str, iter.base());
2939 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2940 assert(ios.width() == 0);
2941 }
2942 ios.width(25);
2943 left(ios);
2944 {
2945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2946 std::string ex(str, iter.base());
2947 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2948 assert(ios.width() == 0);
2949 }
2950 ios.width(25);
2951 right(ios);
2952 {
2953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2954 std::string ex(str, iter.base());
2955 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2956 assert(ios.width() == 0);
2957 }
2958 ios.width(25);
2959 internal(ios);
2960 {
2961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2962 std::string ex(str, iter.base());
2963 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2964 assert(ios.width() == 0);
2965 }
2966 }
2967 ios.imbue(lg);
2968 {
2969 ios.width(0);
2970 {
2971 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2972 std::string ex(str, iter.base());
2973 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2974 assert(ios.width() == 0);
2975 }
2976 ios.width(25);
2977 left(ios);
2978 {
2979 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2980 std::string ex(str, iter.base());
2981 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2982 assert(ios.width() == 0);
2983 }
2984 ios.width(25);
2985 right(ios);
2986 {
2987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2988 std::string ex(str, iter.base());
2989 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2990 assert(ios.width() == 0);
2991 }
2992 ios.width(25);
2993 internal(ios);
2994 {
2995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
2996 std::string ex(str, iter.base());
2997 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2998 assert(ios.width() == 0);
2999 }
3000 }
3001 }
3002 }
3003 }
3004 }
3005 }
3006 }
3007 }
3008
test2()3009 void test2()
3010 {
3011 char str[200];
3012 output_iterator<char*> iter;
3013 std::locale lc = std::locale::classic();
3014 std::locale lg(lc, new my_numpunct);
3015 const my_facet f(1);
3016 {
3017 long double v = -0.;
3018 std::ios ios(0);
3019 // %g
3020 {
3021 ios.precision(0);
3022 {
3023 nouppercase(ios);
3024 {
3025 noshowpos(ios);
3026 {
3027 noshowpoint(ios);
3028 {
3029 ios.imbue(lc);
3030 {
3031 ios.width(0);
3032 {
3033 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3034 std::string ex(str, iter.base());
3035 assert(ex == "-0");
3036 assert(ios.width() == 0);
3037 }
3038 ios.width(25);
3039 left(ios);
3040 {
3041 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3042 std::string ex(str, iter.base());
3043 assert(ex == "-0***********************");
3044 assert(ios.width() == 0);
3045 }
3046 ios.width(25);
3047 right(ios);
3048 {
3049 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3050 std::string ex(str, iter.base());
3051 assert(ex == "***********************-0");
3052 assert(ios.width() == 0);
3053 }
3054 ios.width(25);
3055 internal(ios);
3056 {
3057 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3058 std::string ex(str, iter.base());
3059 assert(ex == "-***********************0");
3060 assert(ios.width() == 0);
3061 }
3062 }
3063 ios.imbue(lg);
3064 {
3065 ios.width(0);
3066 {
3067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3068 std::string ex(str, iter.base());
3069 assert(ex == "-0");
3070 assert(ios.width() == 0);
3071 }
3072 ios.width(25);
3073 left(ios);
3074 {
3075 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3076 std::string ex(str, iter.base());
3077 assert(ex == "-0***********************");
3078 assert(ios.width() == 0);
3079 }
3080 ios.width(25);
3081 right(ios);
3082 {
3083 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3084 std::string ex(str, iter.base());
3085 assert(ex == "***********************-0");
3086 assert(ios.width() == 0);
3087 }
3088 ios.width(25);
3089 internal(ios);
3090 {
3091 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3092 std::string ex(str, iter.base());
3093 assert(ex == "-***********************0");
3094 assert(ios.width() == 0);
3095 }
3096 }
3097 }
3098 showpoint(ios);
3099 {
3100 ios.imbue(lc);
3101 {
3102 ios.width(0);
3103 {
3104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3105 std::string ex(str, iter.base());
3106 assert(ex == "-0.");
3107 assert(ios.width() == 0);
3108 }
3109 ios.width(25);
3110 left(ios);
3111 {
3112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3113 std::string ex(str, iter.base());
3114 assert(ex == "-0.**********************");
3115 assert(ios.width() == 0);
3116 }
3117 ios.width(25);
3118 right(ios);
3119 {
3120 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3121 std::string ex(str, iter.base());
3122 assert(ex == "**********************-0.");
3123 assert(ios.width() == 0);
3124 }
3125 ios.width(25);
3126 internal(ios);
3127 {
3128 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3129 std::string ex(str, iter.base());
3130 assert(ex == "-**********************0.");
3131 assert(ios.width() == 0);
3132 }
3133 }
3134 ios.imbue(lg);
3135 {
3136 ios.width(0);
3137 {
3138 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3139 std::string ex(str, iter.base());
3140 assert(ex == "-0;");
3141 assert(ios.width() == 0);
3142 }
3143 ios.width(25);
3144 left(ios);
3145 {
3146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3147 std::string ex(str, iter.base());
3148 assert(ex == "-0;**********************");
3149 assert(ios.width() == 0);
3150 }
3151 ios.width(25);
3152 right(ios);
3153 {
3154 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3155 std::string ex(str, iter.base());
3156 assert(ex == "**********************-0;");
3157 assert(ios.width() == 0);
3158 }
3159 ios.width(25);
3160 internal(ios);
3161 {
3162 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3163 std::string ex(str, iter.base());
3164 assert(ex == "-**********************0;");
3165 assert(ios.width() == 0);
3166 }
3167 }
3168 }
3169 }
3170 showpos(ios);
3171 {
3172 noshowpoint(ios);
3173 {
3174 ios.imbue(lc);
3175 {
3176 ios.width(0);
3177 {
3178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3179 std::string ex(str, iter.base());
3180 assert(ex == "-0");
3181 assert(ios.width() == 0);
3182 }
3183 ios.width(25);
3184 left(ios);
3185 {
3186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3187 std::string ex(str, iter.base());
3188 assert(ex == "-0***********************");
3189 assert(ios.width() == 0);
3190 }
3191 ios.width(25);
3192 right(ios);
3193 {
3194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3195 std::string ex(str, iter.base());
3196 assert(ex == "***********************-0");
3197 assert(ios.width() == 0);
3198 }
3199 ios.width(25);
3200 internal(ios);
3201 {
3202 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3203 std::string ex(str, iter.base());
3204 assert(ex == "-***********************0");
3205 assert(ios.width() == 0);
3206 }
3207 }
3208 ios.imbue(lg);
3209 {
3210 ios.width(0);
3211 {
3212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3213 std::string ex(str, iter.base());
3214 assert(ex == "-0");
3215 assert(ios.width() == 0);
3216 }
3217 ios.width(25);
3218 left(ios);
3219 {
3220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3221 std::string ex(str, iter.base());
3222 assert(ex == "-0***********************");
3223 assert(ios.width() == 0);
3224 }
3225 ios.width(25);
3226 right(ios);
3227 {
3228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3229 std::string ex(str, iter.base());
3230 assert(ex == "***********************-0");
3231 assert(ios.width() == 0);
3232 }
3233 ios.width(25);
3234 internal(ios);
3235 {
3236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3237 std::string ex(str, iter.base());
3238 assert(ex == "-***********************0");
3239 assert(ios.width() == 0);
3240 }
3241 }
3242 }
3243 showpoint(ios);
3244 {
3245 ios.imbue(lc);
3246 {
3247 ios.width(0);
3248 {
3249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3250 std::string ex(str, iter.base());
3251 assert(ex == "-0.");
3252 assert(ios.width() == 0);
3253 }
3254 ios.width(25);
3255 left(ios);
3256 {
3257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3258 std::string ex(str, iter.base());
3259 assert(ex == "-0.**********************");
3260 assert(ios.width() == 0);
3261 }
3262 ios.width(25);
3263 right(ios);
3264 {
3265 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3266 std::string ex(str, iter.base());
3267 assert(ex == "**********************-0.");
3268 assert(ios.width() == 0);
3269 }
3270 ios.width(25);
3271 internal(ios);
3272 {
3273 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3274 std::string ex(str, iter.base());
3275 assert(ex == "-**********************0.");
3276 assert(ios.width() == 0);
3277 }
3278 }
3279 ios.imbue(lg);
3280 {
3281 ios.width(0);
3282 {
3283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3284 std::string ex(str, iter.base());
3285 assert(ex == "-0;");
3286 assert(ios.width() == 0);
3287 }
3288 ios.width(25);
3289 left(ios);
3290 {
3291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3292 std::string ex(str, iter.base());
3293 assert(ex == "-0;**********************");
3294 assert(ios.width() == 0);
3295 }
3296 ios.width(25);
3297 right(ios);
3298 {
3299 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3300 std::string ex(str, iter.base());
3301 assert(ex == "**********************-0;");
3302 assert(ios.width() == 0);
3303 }
3304 ios.width(25);
3305 internal(ios);
3306 {
3307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3308 std::string ex(str, iter.base());
3309 assert(ex == "-**********************0;");
3310 assert(ios.width() == 0);
3311 }
3312 }
3313 }
3314 }
3315 }
3316 uppercase(ios);
3317 {
3318 noshowpos(ios);
3319 {
3320 noshowpoint(ios);
3321 {
3322 ios.imbue(lc);
3323 {
3324 ios.width(0);
3325 {
3326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3327 std::string ex(str, iter.base());
3328 assert(ex == "-0");
3329 assert(ios.width() == 0);
3330 }
3331 ios.width(25);
3332 left(ios);
3333 {
3334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3335 std::string ex(str, iter.base());
3336 assert(ex == "-0***********************");
3337 assert(ios.width() == 0);
3338 }
3339 ios.width(25);
3340 right(ios);
3341 {
3342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3343 std::string ex(str, iter.base());
3344 assert(ex == "***********************-0");
3345 assert(ios.width() == 0);
3346 }
3347 ios.width(25);
3348 internal(ios);
3349 {
3350 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3351 std::string ex(str, iter.base());
3352 assert(ex == "-***********************0");
3353 assert(ios.width() == 0);
3354 }
3355 }
3356 ios.imbue(lg);
3357 {
3358 ios.width(0);
3359 {
3360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3361 std::string ex(str, iter.base());
3362 assert(ex == "-0");
3363 assert(ios.width() == 0);
3364 }
3365 ios.width(25);
3366 left(ios);
3367 {
3368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3369 std::string ex(str, iter.base());
3370 assert(ex == "-0***********************");
3371 assert(ios.width() == 0);
3372 }
3373 ios.width(25);
3374 right(ios);
3375 {
3376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3377 std::string ex(str, iter.base());
3378 assert(ex == "***********************-0");
3379 assert(ios.width() == 0);
3380 }
3381 ios.width(25);
3382 internal(ios);
3383 {
3384 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3385 std::string ex(str, iter.base());
3386 assert(ex == "-***********************0");
3387 assert(ios.width() == 0);
3388 }
3389 }
3390 }
3391 showpoint(ios);
3392 {
3393 ios.imbue(lc);
3394 {
3395 ios.width(0);
3396 {
3397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3398 std::string ex(str, iter.base());
3399 assert(ex == "-0.");
3400 assert(ios.width() == 0);
3401 }
3402 ios.width(25);
3403 left(ios);
3404 {
3405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3406 std::string ex(str, iter.base());
3407 assert(ex == "-0.**********************");
3408 assert(ios.width() == 0);
3409 }
3410 ios.width(25);
3411 right(ios);
3412 {
3413 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3414 std::string ex(str, iter.base());
3415 assert(ex == "**********************-0.");
3416 assert(ios.width() == 0);
3417 }
3418 ios.width(25);
3419 internal(ios);
3420 {
3421 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3422 std::string ex(str, iter.base());
3423 assert(ex == "-**********************0.");
3424 assert(ios.width() == 0);
3425 }
3426 }
3427 ios.imbue(lg);
3428 {
3429 ios.width(0);
3430 {
3431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3432 std::string ex(str, iter.base());
3433 assert(ex == "-0;");
3434 assert(ios.width() == 0);
3435 }
3436 ios.width(25);
3437 left(ios);
3438 {
3439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3440 std::string ex(str, iter.base());
3441 assert(ex == "-0;**********************");
3442 assert(ios.width() == 0);
3443 }
3444 ios.width(25);
3445 right(ios);
3446 {
3447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3448 std::string ex(str, iter.base());
3449 assert(ex == "**********************-0;");
3450 assert(ios.width() == 0);
3451 }
3452 ios.width(25);
3453 internal(ios);
3454 {
3455 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3456 std::string ex(str, iter.base());
3457 assert(ex == "-**********************0;");
3458 assert(ios.width() == 0);
3459 }
3460 }
3461 }
3462 }
3463 showpos(ios);
3464 {
3465 noshowpoint(ios);
3466 {
3467 ios.imbue(lc);
3468 {
3469 ios.width(0);
3470 {
3471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3472 std::string ex(str, iter.base());
3473 assert(ex == "-0");
3474 assert(ios.width() == 0);
3475 }
3476 ios.width(25);
3477 left(ios);
3478 {
3479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3480 std::string ex(str, iter.base());
3481 assert(ex == "-0***********************");
3482 assert(ios.width() == 0);
3483 }
3484 ios.width(25);
3485 right(ios);
3486 {
3487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3488 std::string ex(str, iter.base());
3489 assert(ex == "***********************-0");
3490 assert(ios.width() == 0);
3491 }
3492 ios.width(25);
3493 internal(ios);
3494 {
3495 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3496 std::string ex(str, iter.base());
3497 assert(ex == "-***********************0");
3498 assert(ios.width() == 0);
3499 }
3500 }
3501 ios.imbue(lg);
3502 {
3503 ios.width(0);
3504 {
3505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3506 std::string ex(str, iter.base());
3507 assert(ex == "-0");
3508 assert(ios.width() == 0);
3509 }
3510 ios.width(25);
3511 left(ios);
3512 {
3513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3514 std::string ex(str, iter.base());
3515 assert(ex == "-0***********************");
3516 assert(ios.width() == 0);
3517 }
3518 ios.width(25);
3519 right(ios);
3520 {
3521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3522 std::string ex(str, iter.base());
3523 assert(ex == "***********************-0");
3524 assert(ios.width() == 0);
3525 }
3526 ios.width(25);
3527 internal(ios);
3528 {
3529 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3530 std::string ex(str, iter.base());
3531 assert(ex == "-***********************0");
3532 assert(ios.width() == 0);
3533 }
3534 }
3535 }
3536 showpoint(ios);
3537 {
3538 ios.imbue(lc);
3539 {
3540 ios.width(0);
3541 {
3542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3543 std::string ex(str, iter.base());
3544 assert(ex == "-0.");
3545 assert(ios.width() == 0);
3546 }
3547 ios.width(25);
3548 left(ios);
3549 {
3550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3551 std::string ex(str, iter.base());
3552 assert(ex == "-0.**********************");
3553 assert(ios.width() == 0);
3554 }
3555 ios.width(25);
3556 right(ios);
3557 {
3558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3559 std::string ex(str, iter.base());
3560 assert(ex == "**********************-0.");
3561 assert(ios.width() == 0);
3562 }
3563 ios.width(25);
3564 internal(ios);
3565 {
3566 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3567 std::string ex(str, iter.base());
3568 assert(ex == "-**********************0.");
3569 assert(ios.width() == 0);
3570 }
3571 }
3572 ios.imbue(lg);
3573 {
3574 ios.width(0);
3575 {
3576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3577 std::string ex(str, iter.base());
3578 assert(ex == "-0;");
3579 assert(ios.width() == 0);
3580 }
3581 ios.width(25);
3582 left(ios);
3583 {
3584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3585 std::string ex(str, iter.base());
3586 assert(ex == "-0;**********************");
3587 assert(ios.width() == 0);
3588 }
3589 ios.width(25);
3590 right(ios);
3591 {
3592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3593 std::string ex(str, iter.base());
3594 assert(ex == "**********************-0;");
3595 assert(ios.width() == 0);
3596 }
3597 ios.width(25);
3598 internal(ios);
3599 {
3600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3601 std::string ex(str, iter.base());
3602 assert(ex == "-**********************0;");
3603 assert(ios.width() == 0);
3604 }
3605 }
3606 }
3607 }
3608 }
3609 }
3610 ios.precision(1);
3611 {
3612 nouppercase(ios);
3613 {
3614 noshowpos(ios);
3615 {
3616 noshowpoint(ios);
3617 {
3618 ios.imbue(lc);
3619 {
3620 ios.width(0);
3621 {
3622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3623 std::string ex(str, iter.base());
3624 assert(ex == "-0");
3625 assert(ios.width() == 0);
3626 }
3627 ios.width(25);
3628 left(ios);
3629 {
3630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3631 std::string ex(str, iter.base());
3632 assert(ex == "-0***********************");
3633 assert(ios.width() == 0);
3634 }
3635 ios.width(25);
3636 right(ios);
3637 {
3638 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3639 std::string ex(str, iter.base());
3640 assert(ex == "***********************-0");
3641 assert(ios.width() == 0);
3642 }
3643 ios.width(25);
3644 internal(ios);
3645 {
3646 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3647 std::string ex(str, iter.base());
3648 assert(ex == "-***********************0");
3649 assert(ios.width() == 0);
3650 }
3651 }
3652 ios.imbue(lg);
3653 {
3654 ios.width(0);
3655 {
3656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3657 std::string ex(str, iter.base());
3658 assert(ex == "-0");
3659 assert(ios.width() == 0);
3660 }
3661 ios.width(25);
3662 left(ios);
3663 {
3664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3665 std::string ex(str, iter.base());
3666 assert(ex == "-0***********************");
3667 assert(ios.width() == 0);
3668 }
3669 ios.width(25);
3670 right(ios);
3671 {
3672 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3673 std::string ex(str, iter.base());
3674 assert(ex == "***********************-0");
3675 assert(ios.width() == 0);
3676 }
3677 ios.width(25);
3678 internal(ios);
3679 {
3680 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3681 std::string ex(str, iter.base());
3682 assert(ex == "-***********************0");
3683 assert(ios.width() == 0);
3684 }
3685 }
3686 }
3687 showpoint(ios);
3688 {
3689 ios.imbue(lc);
3690 {
3691 ios.width(0);
3692 {
3693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3694 std::string ex(str, iter.base());
3695 assert(ex == "-0.");
3696 assert(ios.width() == 0);
3697 }
3698 ios.width(25);
3699 left(ios);
3700 {
3701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3702 std::string ex(str, iter.base());
3703 assert(ex == "-0.**********************");
3704 assert(ios.width() == 0);
3705 }
3706 ios.width(25);
3707 right(ios);
3708 {
3709 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3710 std::string ex(str, iter.base());
3711 assert(ex == "**********************-0.");
3712 assert(ios.width() == 0);
3713 }
3714 ios.width(25);
3715 internal(ios);
3716 {
3717 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3718 std::string ex(str, iter.base());
3719 assert(ex == "-**********************0.");
3720 assert(ios.width() == 0);
3721 }
3722 }
3723 ios.imbue(lg);
3724 {
3725 ios.width(0);
3726 {
3727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3728 std::string ex(str, iter.base());
3729 assert(ex == "-0;");
3730 assert(ios.width() == 0);
3731 }
3732 ios.width(25);
3733 left(ios);
3734 {
3735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3736 std::string ex(str, iter.base());
3737 assert(ex == "-0;**********************");
3738 assert(ios.width() == 0);
3739 }
3740 ios.width(25);
3741 right(ios);
3742 {
3743 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3744 std::string ex(str, iter.base());
3745 assert(ex == "**********************-0;");
3746 assert(ios.width() == 0);
3747 }
3748 ios.width(25);
3749 internal(ios);
3750 {
3751 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3752 std::string ex(str, iter.base());
3753 assert(ex == "-**********************0;");
3754 assert(ios.width() == 0);
3755 }
3756 }
3757 }
3758 }
3759 showpos(ios);
3760 {
3761 noshowpoint(ios);
3762 {
3763 ios.imbue(lc);
3764 {
3765 ios.width(0);
3766 {
3767 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3768 std::string ex(str, iter.base());
3769 assert(ex == "-0");
3770 assert(ios.width() == 0);
3771 }
3772 ios.width(25);
3773 left(ios);
3774 {
3775 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3776 std::string ex(str, iter.base());
3777 assert(ex == "-0***********************");
3778 assert(ios.width() == 0);
3779 }
3780 ios.width(25);
3781 right(ios);
3782 {
3783 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3784 std::string ex(str, iter.base());
3785 assert(ex == "***********************-0");
3786 assert(ios.width() == 0);
3787 }
3788 ios.width(25);
3789 internal(ios);
3790 {
3791 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3792 std::string ex(str, iter.base());
3793 assert(ex == "-***********************0");
3794 assert(ios.width() == 0);
3795 }
3796 }
3797 ios.imbue(lg);
3798 {
3799 ios.width(0);
3800 {
3801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3802 std::string ex(str, iter.base());
3803 assert(ex == "-0");
3804 assert(ios.width() == 0);
3805 }
3806 ios.width(25);
3807 left(ios);
3808 {
3809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3810 std::string ex(str, iter.base());
3811 assert(ex == "-0***********************");
3812 assert(ios.width() == 0);
3813 }
3814 ios.width(25);
3815 right(ios);
3816 {
3817 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3818 std::string ex(str, iter.base());
3819 assert(ex == "***********************-0");
3820 assert(ios.width() == 0);
3821 }
3822 ios.width(25);
3823 internal(ios);
3824 {
3825 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3826 std::string ex(str, iter.base());
3827 assert(ex == "-***********************0");
3828 assert(ios.width() == 0);
3829 }
3830 }
3831 }
3832 showpoint(ios);
3833 {
3834 ios.imbue(lc);
3835 {
3836 ios.width(0);
3837 {
3838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3839 std::string ex(str, iter.base());
3840 assert(ex == "-0.");
3841 assert(ios.width() == 0);
3842 }
3843 ios.width(25);
3844 left(ios);
3845 {
3846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3847 std::string ex(str, iter.base());
3848 assert(ex == "-0.**********************");
3849 assert(ios.width() == 0);
3850 }
3851 ios.width(25);
3852 right(ios);
3853 {
3854 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3855 std::string ex(str, iter.base());
3856 assert(ex == "**********************-0.");
3857 assert(ios.width() == 0);
3858 }
3859 ios.width(25);
3860 internal(ios);
3861 {
3862 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3863 std::string ex(str, iter.base());
3864 assert(ex == "-**********************0.");
3865 assert(ios.width() == 0);
3866 }
3867 }
3868 ios.imbue(lg);
3869 {
3870 ios.width(0);
3871 {
3872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3873 std::string ex(str, iter.base());
3874 assert(ex == "-0;");
3875 assert(ios.width() == 0);
3876 }
3877 ios.width(25);
3878 left(ios);
3879 {
3880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3881 std::string ex(str, iter.base());
3882 assert(ex == "-0;**********************");
3883 assert(ios.width() == 0);
3884 }
3885 ios.width(25);
3886 right(ios);
3887 {
3888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3889 std::string ex(str, iter.base());
3890 assert(ex == "**********************-0;");
3891 assert(ios.width() == 0);
3892 }
3893 ios.width(25);
3894 internal(ios);
3895 {
3896 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3897 std::string ex(str, iter.base());
3898 assert(ex == "-**********************0;");
3899 assert(ios.width() == 0);
3900 }
3901 }
3902 }
3903 }
3904 }
3905 uppercase(ios);
3906 {
3907 noshowpos(ios);
3908 {
3909 noshowpoint(ios);
3910 {
3911 ios.imbue(lc);
3912 {
3913 ios.width(0);
3914 {
3915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3916 std::string ex(str, iter.base());
3917 assert(ex == "-0");
3918 assert(ios.width() == 0);
3919 }
3920 ios.width(25);
3921 left(ios);
3922 {
3923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3924 std::string ex(str, iter.base());
3925 assert(ex == "-0***********************");
3926 assert(ios.width() == 0);
3927 }
3928 ios.width(25);
3929 right(ios);
3930 {
3931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3932 std::string ex(str, iter.base());
3933 assert(ex == "***********************-0");
3934 assert(ios.width() == 0);
3935 }
3936 ios.width(25);
3937 internal(ios);
3938 {
3939 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3940 std::string ex(str, iter.base());
3941 assert(ex == "-***********************0");
3942 assert(ios.width() == 0);
3943 }
3944 }
3945 ios.imbue(lg);
3946 {
3947 ios.width(0);
3948 {
3949 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3950 std::string ex(str, iter.base());
3951 assert(ex == "-0");
3952 assert(ios.width() == 0);
3953 }
3954 ios.width(25);
3955 left(ios);
3956 {
3957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3958 std::string ex(str, iter.base());
3959 assert(ex == "-0***********************");
3960 assert(ios.width() == 0);
3961 }
3962 ios.width(25);
3963 right(ios);
3964 {
3965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3966 std::string ex(str, iter.base());
3967 assert(ex == "***********************-0");
3968 assert(ios.width() == 0);
3969 }
3970 ios.width(25);
3971 internal(ios);
3972 {
3973 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3974 std::string ex(str, iter.base());
3975 assert(ex == "-***********************0");
3976 assert(ios.width() == 0);
3977 }
3978 }
3979 }
3980 showpoint(ios);
3981 {
3982 ios.imbue(lc);
3983 {
3984 ios.width(0);
3985 {
3986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3987 std::string ex(str, iter.base());
3988 assert(ex == "-0.");
3989 assert(ios.width() == 0);
3990 }
3991 ios.width(25);
3992 left(ios);
3993 {
3994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
3995 std::string ex(str, iter.base());
3996 assert(ex == "-0.**********************");
3997 assert(ios.width() == 0);
3998 }
3999 ios.width(25);
4000 right(ios);
4001 {
4002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4003 std::string ex(str, iter.base());
4004 assert(ex == "**********************-0.");
4005 assert(ios.width() == 0);
4006 }
4007 ios.width(25);
4008 internal(ios);
4009 {
4010 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4011 std::string ex(str, iter.base());
4012 assert(ex == "-**********************0.");
4013 assert(ios.width() == 0);
4014 }
4015 }
4016 ios.imbue(lg);
4017 {
4018 ios.width(0);
4019 {
4020 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4021 std::string ex(str, iter.base());
4022 assert(ex == "-0;");
4023 assert(ios.width() == 0);
4024 }
4025 ios.width(25);
4026 left(ios);
4027 {
4028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4029 std::string ex(str, iter.base());
4030 assert(ex == "-0;**********************");
4031 assert(ios.width() == 0);
4032 }
4033 ios.width(25);
4034 right(ios);
4035 {
4036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4037 std::string ex(str, iter.base());
4038 assert(ex == "**********************-0;");
4039 assert(ios.width() == 0);
4040 }
4041 ios.width(25);
4042 internal(ios);
4043 {
4044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4045 std::string ex(str, iter.base());
4046 assert(ex == "-**********************0;");
4047 assert(ios.width() == 0);
4048 }
4049 }
4050 }
4051 }
4052 showpos(ios);
4053 {
4054 noshowpoint(ios);
4055 {
4056 ios.imbue(lc);
4057 {
4058 ios.width(0);
4059 {
4060 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4061 std::string ex(str, iter.base());
4062 assert(ex == "-0");
4063 assert(ios.width() == 0);
4064 }
4065 ios.width(25);
4066 left(ios);
4067 {
4068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4069 std::string ex(str, iter.base());
4070 assert(ex == "-0***********************");
4071 assert(ios.width() == 0);
4072 }
4073 ios.width(25);
4074 right(ios);
4075 {
4076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4077 std::string ex(str, iter.base());
4078 assert(ex == "***********************-0");
4079 assert(ios.width() == 0);
4080 }
4081 ios.width(25);
4082 internal(ios);
4083 {
4084 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4085 std::string ex(str, iter.base());
4086 assert(ex == "-***********************0");
4087 assert(ios.width() == 0);
4088 }
4089 }
4090 ios.imbue(lg);
4091 {
4092 ios.width(0);
4093 {
4094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4095 std::string ex(str, iter.base());
4096 assert(ex == "-0");
4097 assert(ios.width() == 0);
4098 }
4099 ios.width(25);
4100 left(ios);
4101 {
4102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4103 std::string ex(str, iter.base());
4104 assert(ex == "-0***********************");
4105 assert(ios.width() == 0);
4106 }
4107 ios.width(25);
4108 right(ios);
4109 {
4110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4111 std::string ex(str, iter.base());
4112 assert(ex == "***********************-0");
4113 assert(ios.width() == 0);
4114 }
4115 ios.width(25);
4116 internal(ios);
4117 {
4118 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4119 std::string ex(str, iter.base());
4120 assert(ex == "-***********************0");
4121 assert(ios.width() == 0);
4122 }
4123 }
4124 }
4125 showpoint(ios);
4126 {
4127 ios.imbue(lc);
4128 {
4129 ios.width(0);
4130 {
4131 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4132 std::string ex(str, iter.base());
4133 assert(ex == "-0.");
4134 assert(ios.width() == 0);
4135 }
4136 ios.width(25);
4137 left(ios);
4138 {
4139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4140 std::string ex(str, iter.base());
4141 assert(ex == "-0.**********************");
4142 assert(ios.width() == 0);
4143 }
4144 ios.width(25);
4145 right(ios);
4146 {
4147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4148 std::string ex(str, iter.base());
4149 assert(ex == "**********************-0.");
4150 assert(ios.width() == 0);
4151 }
4152 ios.width(25);
4153 internal(ios);
4154 {
4155 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4156 std::string ex(str, iter.base());
4157 assert(ex == "-**********************0.");
4158 assert(ios.width() == 0);
4159 }
4160 }
4161 ios.imbue(lg);
4162 {
4163 ios.width(0);
4164 {
4165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4166 std::string ex(str, iter.base());
4167 assert(ex == "-0;");
4168 assert(ios.width() == 0);
4169 }
4170 ios.width(25);
4171 left(ios);
4172 {
4173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4174 std::string ex(str, iter.base());
4175 assert(ex == "-0;**********************");
4176 assert(ios.width() == 0);
4177 }
4178 ios.width(25);
4179 right(ios);
4180 {
4181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4182 std::string ex(str, iter.base());
4183 assert(ex == "**********************-0;");
4184 assert(ios.width() == 0);
4185 }
4186 ios.width(25);
4187 internal(ios);
4188 {
4189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4190 std::string ex(str, iter.base());
4191 assert(ex == "-**********************0;");
4192 assert(ios.width() == 0);
4193 }
4194 }
4195 }
4196 }
4197 }
4198 }
4199 ios.precision(6);
4200 {
4201 nouppercase(ios);
4202 {
4203 noshowpos(ios);
4204 {
4205 noshowpoint(ios);
4206 {
4207 ios.imbue(lc);
4208 {
4209 ios.width(0);
4210 {
4211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4212 std::string ex(str, iter.base());
4213 assert(ex == "-0");
4214 assert(ios.width() == 0);
4215 }
4216 ios.width(25);
4217 left(ios);
4218 {
4219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4220 std::string ex(str, iter.base());
4221 assert(ex == "-0***********************");
4222 assert(ios.width() == 0);
4223 }
4224 ios.width(25);
4225 right(ios);
4226 {
4227 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4228 std::string ex(str, iter.base());
4229 assert(ex == "***********************-0");
4230 assert(ios.width() == 0);
4231 }
4232 ios.width(25);
4233 internal(ios);
4234 {
4235 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4236 std::string ex(str, iter.base());
4237 assert(ex == "-***********************0");
4238 assert(ios.width() == 0);
4239 }
4240 }
4241 ios.imbue(lg);
4242 {
4243 ios.width(0);
4244 {
4245 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4246 std::string ex(str, iter.base());
4247 assert(ex == "-0");
4248 assert(ios.width() == 0);
4249 }
4250 ios.width(25);
4251 left(ios);
4252 {
4253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4254 std::string ex(str, iter.base());
4255 assert(ex == "-0***********************");
4256 assert(ios.width() == 0);
4257 }
4258 ios.width(25);
4259 right(ios);
4260 {
4261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4262 std::string ex(str, iter.base());
4263 assert(ex == "***********************-0");
4264 assert(ios.width() == 0);
4265 }
4266 ios.width(25);
4267 internal(ios);
4268 {
4269 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4270 std::string ex(str, iter.base());
4271 assert(ex == "-***********************0");
4272 assert(ios.width() == 0);
4273 }
4274 }
4275 }
4276 showpoint(ios);
4277 {
4278 ios.imbue(lc);
4279 {
4280 ios.width(0);
4281 {
4282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4283 std::string ex(str, iter.base());
4284 assert(ex == "-0.00000");
4285 assert(ios.width() == 0);
4286 }
4287 ios.width(25);
4288 left(ios);
4289 {
4290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4291 std::string ex(str, iter.base());
4292 assert(ex == "-0.00000*****************");
4293 assert(ios.width() == 0);
4294 }
4295 ios.width(25);
4296 right(ios);
4297 {
4298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4299 std::string ex(str, iter.base());
4300 assert(ex == "*****************-0.00000");
4301 assert(ios.width() == 0);
4302 }
4303 ios.width(25);
4304 internal(ios);
4305 {
4306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4307 std::string ex(str, iter.base());
4308 assert(ex == "-*****************0.00000");
4309 assert(ios.width() == 0);
4310 }
4311 }
4312 ios.imbue(lg);
4313 {
4314 ios.width(0);
4315 {
4316 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4317 std::string ex(str, iter.base());
4318 assert(ex == "-0;00000");
4319 assert(ios.width() == 0);
4320 }
4321 ios.width(25);
4322 left(ios);
4323 {
4324 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4325 std::string ex(str, iter.base());
4326 assert(ex == "-0;00000*****************");
4327 assert(ios.width() == 0);
4328 }
4329 ios.width(25);
4330 right(ios);
4331 {
4332 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4333 std::string ex(str, iter.base());
4334 assert(ex == "*****************-0;00000");
4335 assert(ios.width() == 0);
4336 }
4337 ios.width(25);
4338 internal(ios);
4339 {
4340 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4341 std::string ex(str, iter.base());
4342 assert(ex == "-*****************0;00000");
4343 assert(ios.width() == 0);
4344 }
4345 }
4346 }
4347 }
4348 showpos(ios);
4349 {
4350 noshowpoint(ios);
4351 {
4352 ios.imbue(lc);
4353 {
4354 ios.width(0);
4355 {
4356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4357 std::string ex(str, iter.base());
4358 assert(ex == "-0");
4359 assert(ios.width() == 0);
4360 }
4361 ios.width(25);
4362 left(ios);
4363 {
4364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4365 std::string ex(str, iter.base());
4366 assert(ex == "-0***********************");
4367 assert(ios.width() == 0);
4368 }
4369 ios.width(25);
4370 right(ios);
4371 {
4372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4373 std::string ex(str, iter.base());
4374 assert(ex == "***********************-0");
4375 assert(ios.width() == 0);
4376 }
4377 ios.width(25);
4378 internal(ios);
4379 {
4380 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4381 std::string ex(str, iter.base());
4382 assert(ex == "-***********************0");
4383 assert(ios.width() == 0);
4384 }
4385 }
4386 ios.imbue(lg);
4387 {
4388 ios.width(0);
4389 {
4390 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4391 std::string ex(str, iter.base());
4392 assert(ex == "-0");
4393 assert(ios.width() == 0);
4394 }
4395 ios.width(25);
4396 left(ios);
4397 {
4398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4399 std::string ex(str, iter.base());
4400 assert(ex == "-0***********************");
4401 assert(ios.width() == 0);
4402 }
4403 ios.width(25);
4404 right(ios);
4405 {
4406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4407 std::string ex(str, iter.base());
4408 assert(ex == "***********************-0");
4409 assert(ios.width() == 0);
4410 }
4411 ios.width(25);
4412 internal(ios);
4413 {
4414 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4415 std::string ex(str, iter.base());
4416 assert(ex == "-***********************0");
4417 assert(ios.width() == 0);
4418 }
4419 }
4420 }
4421 showpoint(ios);
4422 {
4423 ios.imbue(lc);
4424 {
4425 ios.width(0);
4426 {
4427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4428 std::string ex(str, iter.base());
4429 assert(ex == "-0.00000");
4430 assert(ios.width() == 0);
4431 }
4432 ios.width(25);
4433 left(ios);
4434 {
4435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4436 std::string ex(str, iter.base());
4437 assert(ex == "-0.00000*****************");
4438 assert(ios.width() == 0);
4439 }
4440 ios.width(25);
4441 right(ios);
4442 {
4443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4444 std::string ex(str, iter.base());
4445 assert(ex == "*****************-0.00000");
4446 assert(ios.width() == 0);
4447 }
4448 ios.width(25);
4449 internal(ios);
4450 {
4451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4452 std::string ex(str, iter.base());
4453 assert(ex == "-*****************0.00000");
4454 assert(ios.width() == 0);
4455 }
4456 }
4457 ios.imbue(lg);
4458 {
4459 ios.width(0);
4460 {
4461 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4462 std::string ex(str, iter.base());
4463 assert(ex == "-0;00000");
4464 assert(ios.width() == 0);
4465 }
4466 ios.width(25);
4467 left(ios);
4468 {
4469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4470 std::string ex(str, iter.base());
4471 assert(ex == "-0;00000*****************");
4472 assert(ios.width() == 0);
4473 }
4474 ios.width(25);
4475 right(ios);
4476 {
4477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4478 std::string ex(str, iter.base());
4479 assert(ex == "*****************-0;00000");
4480 assert(ios.width() == 0);
4481 }
4482 ios.width(25);
4483 internal(ios);
4484 {
4485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4486 std::string ex(str, iter.base());
4487 assert(ex == "-*****************0;00000");
4488 assert(ios.width() == 0);
4489 }
4490 }
4491 }
4492 }
4493 }
4494 uppercase(ios);
4495 {
4496 noshowpos(ios);
4497 {
4498 noshowpoint(ios);
4499 {
4500 ios.imbue(lc);
4501 {
4502 ios.width(0);
4503 {
4504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4505 std::string ex(str, iter.base());
4506 assert(ex == "-0");
4507 assert(ios.width() == 0);
4508 }
4509 ios.width(25);
4510 left(ios);
4511 {
4512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4513 std::string ex(str, iter.base());
4514 assert(ex == "-0***********************");
4515 assert(ios.width() == 0);
4516 }
4517 ios.width(25);
4518 right(ios);
4519 {
4520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4521 std::string ex(str, iter.base());
4522 assert(ex == "***********************-0");
4523 assert(ios.width() == 0);
4524 }
4525 ios.width(25);
4526 internal(ios);
4527 {
4528 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4529 std::string ex(str, iter.base());
4530 assert(ex == "-***********************0");
4531 assert(ios.width() == 0);
4532 }
4533 }
4534 ios.imbue(lg);
4535 {
4536 ios.width(0);
4537 {
4538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4539 std::string ex(str, iter.base());
4540 assert(ex == "-0");
4541 assert(ios.width() == 0);
4542 }
4543 ios.width(25);
4544 left(ios);
4545 {
4546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4547 std::string ex(str, iter.base());
4548 assert(ex == "-0***********************");
4549 assert(ios.width() == 0);
4550 }
4551 ios.width(25);
4552 right(ios);
4553 {
4554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4555 std::string ex(str, iter.base());
4556 assert(ex == "***********************-0");
4557 assert(ios.width() == 0);
4558 }
4559 ios.width(25);
4560 internal(ios);
4561 {
4562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4563 std::string ex(str, iter.base());
4564 assert(ex == "-***********************0");
4565 assert(ios.width() == 0);
4566 }
4567 }
4568 }
4569 showpoint(ios);
4570 {
4571 ios.imbue(lc);
4572 {
4573 ios.width(0);
4574 {
4575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4576 std::string ex(str, iter.base());
4577 assert(ex == "-0.00000");
4578 assert(ios.width() == 0);
4579 }
4580 ios.width(25);
4581 left(ios);
4582 {
4583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4584 std::string ex(str, iter.base());
4585 assert(ex == "-0.00000*****************");
4586 assert(ios.width() == 0);
4587 }
4588 ios.width(25);
4589 right(ios);
4590 {
4591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4592 std::string ex(str, iter.base());
4593 assert(ex == "*****************-0.00000");
4594 assert(ios.width() == 0);
4595 }
4596 ios.width(25);
4597 internal(ios);
4598 {
4599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4600 std::string ex(str, iter.base());
4601 assert(ex == "-*****************0.00000");
4602 assert(ios.width() == 0);
4603 }
4604 }
4605 ios.imbue(lg);
4606 {
4607 ios.width(0);
4608 {
4609 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4610 std::string ex(str, iter.base());
4611 assert(ex == "-0;00000");
4612 assert(ios.width() == 0);
4613 }
4614 ios.width(25);
4615 left(ios);
4616 {
4617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4618 std::string ex(str, iter.base());
4619 assert(ex == "-0;00000*****************");
4620 assert(ios.width() == 0);
4621 }
4622 ios.width(25);
4623 right(ios);
4624 {
4625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4626 std::string ex(str, iter.base());
4627 assert(ex == "*****************-0;00000");
4628 assert(ios.width() == 0);
4629 }
4630 ios.width(25);
4631 internal(ios);
4632 {
4633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4634 std::string ex(str, iter.base());
4635 assert(ex == "-*****************0;00000");
4636 assert(ios.width() == 0);
4637 }
4638 }
4639 }
4640 }
4641 showpos(ios);
4642 {
4643 noshowpoint(ios);
4644 {
4645 ios.imbue(lc);
4646 {
4647 ios.width(0);
4648 {
4649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4650 std::string ex(str, iter.base());
4651 assert(ex == "-0");
4652 assert(ios.width() == 0);
4653 }
4654 ios.width(25);
4655 left(ios);
4656 {
4657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4658 std::string ex(str, iter.base());
4659 assert(ex == "-0***********************");
4660 assert(ios.width() == 0);
4661 }
4662 ios.width(25);
4663 right(ios);
4664 {
4665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4666 std::string ex(str, iter.base());
4667 assert(ex == "***********************-0");
4668 assert(ios.width() == 0);
4669 }
4670 ios.width(25);
4671 internal(ios);
4672 {
4673 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4674 std::string ex(str, iter.base());
4675 assert(ex == "-***********************0");
4676 assert(ios.width() == 0);
4677 }
4678 }
4679 ios.imbue(lg);
4680 {
4681 ios.width(0);
4682 {
4683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4684 std::string ex(str, iter.base());
4685 assert(ex == "-0");
4686 assert(ios.width() == 0);
4687 }
4688 ios.width(25);
4689 left(ios);
4690 {
4691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4692 std::string ex(str, iter.base());
4693 assert(ex == "-0***********************");
4694 assert(ios.width() == 0);
4695 }
4696 ios.width(25);
4697 right(ios);
4698 {
4699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4700 std::string ex(str, iter.base());
4701 assert(ex == "***********************-0");
4702 assert(ios.width() == 0);
4703 }
4704 ios.width(25);
4705 internal(ios);
4706 {
4707 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4708 std::string ex(str, iter.base());
4709 assert(ex == "-***********************0");
4710 assert(ios.width() == 0);
4711 }
4712 }
4713 }
4714 showpoint(ios);
4715 {
4716 ios.imbue(lc);
4717 {
4718 ios.width(0);
4719 {
4720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4721 std::string ex(str, iter.base());
4722 assert(ex == "-0.00000");
4723 assert(ios.width() == 0);
4724 }
4725 ios.width(25);
4726 left(ios);
4727 {
4728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4729 std::string ex(str, iter.base());
4730 assert(ex == "-0.00000*****************");
4731 assert(ios.width() == 0);
4732 }
4733 ios.width(25);
4734 right(ios);
4735 {
4736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4737 std::string ex(str, iter.base());
4738 assert(ex == "*****************-0.00000");
4739 assert(ios.width() == 0);
4740 }
4741 ios.width(25);
4742 internal(ios);
4743 {
4744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4745 std::string ex(str, iter.base());
4746 assert(ex == "-*****************0.00000");
4747 assert(ios.width() == 0);
4748 }
4749 }
4750 ios.imbue(lg);
4751 {
4752 ios.width(0);
4753 {
4754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4755 std::string ex(str, iter.base());
4756 assert(ex == "-0;00000");
4757 assert(ios.width() == 0);
4758 }
4759 ios.width(25);
4760 left(ios);
4761 {
4762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4763 std::string ex(str, iter.base());
4764 assert(ex == "-0;00000*****************");
4765 assert(ios.width() == 0);
4766 }
4767 ios.width(25);
4768 right(ios);
4769 {
4770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4771 std::string ex(str, iter.base());
4772 assert(ex == "*****************-0;00000");
4773 assert(ios.width() == 0);
4774 }
4775 ios.width(25);
4776 internal(ios);
4777 {
4778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4779 std::string ex(str, iter.base());
4780 assert(ex == "-*****************0;00000");
4781 assert(ios.width() == 0);
4782 }
4783 }
4784 }
4785 }
4786 }
4787 }
4788 ios.precision(16);
4789 {
4790 nouppercase(ios);
4791 {
4792 noshowpos(ios);
4793 {
4794 noshowpoint(ios);
4795 {
4796 ios.imbue(lc);
4797 {
4798 ios.width(0);
4799 {
4800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4801 std::string ex(str, iter.base());
4802 assert(ex == "-0");
4803 assert(ios.width() == 0);
4804 }
4805 ios.width(25);
4806 left(ios);
4807 {
4808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4809 std::string ex(str, iter.base());
4810 assert(ex == "-0***********************");
4811 assert(ios.width() == 0);
4812 }
4813 ios.width(25);
4814 right(ios);
4815 {
4816 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4817 std::string ex(str, iter.base());
4818 assert(ex == "***********************-0");
4819 assert(ios.width() == 0);
4820 }
4821 ios.width(25);
4822 internal(ios);
4823 {
4824 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4825 std::string ex(str, iter.base());
4826 assert(ex == "-***********************0");
4827 assert(ios.width() == 0);
4828 }
4829 }
4830 ios.imbue(lg);
4831 {
4832 ios.width(0);
4833 {
4834 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4835 std::string ex(str, iter.base());
4836 assert(ex == "-0");
4837 assert(ios.width() == 0);
4838 }
4839 ios.width(25);
4840 left(ios);
4841 {
4842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4843 std::string ex(str, iter.base());
4844 assert(ex == "-0***********************");
4845 assert(ios.width() == 0);
4846 }
4847 ios.width(25);
4848 right(ios);
4849 {
4850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4851 std::string ex(str, iter.base());
4852 assert(ex == "***********************-0");
4853 assert(ios.width() == 0);
4854 }
4855 ios.width(25);
4856 internal(ios);
4857 {
4858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4859 std::string ex(str, iter.base());
4860 assert(ex == "-***********************0");
4861 assert(ios.width() == 0);
4862 }
4863 }
4864 }
4865 showpoint(ios);
4866 {
4867 ios.imbue(lc);
4868 {
4869 ios.width(0);
4870 {
4871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4872 std::string ex(str, iter.base());
4873 assert(ex == "-0.000000000000000");
4874 assert(ios.width() == 0);
4875 }
4876 ios.width(25);
4877 left(ios);
4878 {
4879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4880 std::string ex(str, iter.base());
4881 assert(ex == "-0.000000000000000*******");
4882 assert(ios.width() == 0);
4883 }
4884 ios.width(25);
4885 right(ios);
4886 {
4887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4888 std::string ex(str, iter.base());
4889 assert(ex == "*******-0.000000000000000");
4890 assert(ios.width() == 0);
4891 }
4892 ios.width(25);
4893 internal(ios);
4894 {
4895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4896 std::string ex(str, iter.base());
4897 assert(ex == "-*******0.000000000000000");
4898 assert(ios.width() == 0);
4899 }
4900 }
4901 ios.imbue(lg);
4902 {
4903 ios.width(0);
4904 {
4905 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4906 std::string ex(str, iter.base());
4907 assert(ex == "-0;000000000000000");
4908 assert(ios.width() == 0);
4909 }
4910 ios.width(25);
4911 left(ios);
4912 {
4913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4914 std::string ex(str, iter.base());
4915 assert(ex == "-0;000000000000000*******");
4916 assert(ios.width() == 0);
4917 }
4918 ios.width(25);
4919 right(ios);
4920 {
4921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4922 std::string ex(str, iter.base());
4923 assert(ex == "*******-0;000000000000000");
4924 assert(ios.width() == 0);
4925 }
4926 ios.width(25);
4927 internal(ios);
4928 {
4929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4930 std::string ex(str, iter.base());
4931 assert(ex == "-*******0;000000000000000");
4932 assert(ios.width() == 0);
4933 }
4934 }
4935 }
4936 }
4937 showpos(ios);
4938 {
4939 noshowpoint(ios);
4940 {
4941 ios.imbue(lc);
4942 {
4943 ios.width(0);
4944 {
4945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4946 std::string ex(str, iter.base());
4947 assert(ex == "-0");
4948 assert(ios.width() == 0);
4949 }
4950 ios.width(25);
4951 left(ios);
4952 {
4953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4954 std::string ex(str, iter.base());
4955 assert(ex == "-0***********************");
4956 assert(ios.width() == 0);
4957 }
4958 ios.width(25);
4959 right(ios);
4960 {
4961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4962 std::string ex(str, iter.base());
4963 assert(ex == "***********************-0");
4964 assert(ios.width() == 0);
4965 }
4966 ios.width(25);
4967 internal(ios);
4968 {
4969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4970 std::string ex(str, iter.base());
4971 assert(ex == "-***********************0");
4972 assert(ios.width() == 0);
4973 }
4974 }
4975 ios.imbue(lg);
4976 {
4977 ios.width(0);
4978 {
4979 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4980 std::string ex(str, iter.base());
4981 assert(ex == "-0");
4982 assert(ios.width() == 0);
4983 }
4984 ios.width(25);
4985 left(ios);
4986 {
4987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4988 std::string ex(str, iter.base());
4989 assert(ex == "-0***********************");
4990 assert(ios.width() == 0);
4991 }
4992 ios.width(25);
4993 right(ios);
4994 {
4995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
4996 std::string ex(str, iter.base());
4997 assert(ex == "***********************-0");
4998 assert(ios.width() == 0);
4999 }
5000 ios.width(25);
5001 internal(ios);
5002 {
5003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5004 std::string ex(str, iter.base());
5005 assert(ex == "-***********************0");
5006 assert(ios.width() == 0);
5007 }
5008 }
5009 }
5010 showpoint(ios);
5011 {
5012 ios.imbue(lc);
5013 {
5014 ios.width(0);
5015 {
5016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5017 std::string ex(str, iter.base());
5018 assert(ex == "-0.000000000000000");
5019 assert(ios.width() == 0);
5020 }
5021 ios.width(25);
5022 left(ios);
5023 {
5024 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5025 std::string ex(str, iter.base());
5026 assert(ex == "-0.000000000000000*******");
5027 assert(ios.width() == 0);
5028 }
5029 ios.width(25);
5030 right(ios);
5031 {
5032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5033 std::string ex(str, iter.base());
5034 assert(ex == "*******-0.000000000000000");
5035 assert(ios.width() == 0);
5036 }
5037 ios.width(25);
5038 internal(ios);
5039 {
5040 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5041 std::string ex(str, iter.base());
5042 assert(ex == "-*******0.000000000000000");
5043 assert(ios.width() == 0);
5044 }
5045 }
5046 ios.imbue(lg);
5047 {
5048 ios.width(0);
5049 {
5050 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5051 std::string ex(str, iter.base());
5052 assert(ex == "-0;000000000000000");
5053 assert(ios.width() == 0);
5054 }
5055 ios.width(25);
5056 left(ios);
5057 {
5058 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5059 std::string ex(str, iter.base());
5060 assert(ex == "-0;000000000000000*******");
5061 assert(ios.width() == 0);
5062 }
5063 ios.width(25);
5064 right(ios);
5065 {
5066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5067 std::string ex(str, iter.base());
5068 assert(ex == "*******-0;000000000000000");
5069 assert(ios.width() == 0);
5070 }
5071 ios.width(25);
5072 internal(ios);
5073 {
5074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5075 std::string ex(str, iter.base());
5076 assert(ex == "-*******0;000000000000000");
5077 assert(ios.width() == 0);
5078 }
5079 }
5080 }
5081 }
5082 }
5083 uppercase(ios);
5084 {
5085 noshowpos(ios);
5086 {
5087 noshowpoint(ios);
5088 {
5089 ios.imbue(lc);
5090 {
5091 ios.width(0);
5092 {
5093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5094 std::string ex(str, iter.base());
5095 assert(ex == "-0");
5096 assert(ios.width() == 0);
5097 }
5098 ios.width(25);
5099 left(ios);
5100 {
5101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5102 std::string ex(str, iter.base());
5103 assert(ex == "-0***********************");
5104 assert(ios.width() == 0);
5105 }
5106 ios.width(25);
5107 right(ios);
5108 {
5109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5110 std::string ex(str, iter.base());
5111 assert(ex == "***********************-0");
5112 assert(ios.width() == 0);
5113 }
5114 ios.width(25);
5115 internal(ios);
5116 {
5117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5118 std::string ex(str, iter.base());
5119 assert(ex == "-***********************0");
5120 assert(ios.width() == 0);
5121 }
5122 }
5123 ios.imbue(lg);
5124 {
5125 ios.width(0);
5126 {
5127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5128 std::string ex(str, iter.base());
5129 assert(ex == "-0");
5130 assert(ios.width() == 0);
5131 }
5132 ios.width(25);
5133 left(ios);
5134 {
5135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5136 std::string ex(str, iter.base());
5137 assert(ex == "-0***********************");
5138 assert(ios.width() == 0);
5139 }
5140 ios.width(25);
5141 right(ios);
5142 {
5143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5144 std::string ex(str, iter.base());
5145 assert(ex == "***********************-0");
5146 assert(ios.width() == 0);
5147 }
5148 ios.width(25);
5149 internal(ios);
5150 {
5151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5152 std::string ex(str, iter.base());
5153 assert(ex == "-***********************0");
5154 assert(ios.width() == 0);
5155 }
5156 }
5157 }
5158 showpoint(ios);
5159 {
5160 ios.imbue(lc);
5161 {
5162 ios.width(0);
5163 {
5164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5165 std::string ex(str, iter.base());
5166 assert(ex == "-0.000000000000000");
5167 assert(ios.width() == 0);
5168 }
5169 ios.width(25);
5170 left(ios);
5171 {
5172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5173 std::string ex(str, iter.base());
5174 assert(ex == "-0.000000000000000*******");
5175 assert(ios.width() == 0);
5176 }
5177 ios.width(25);
5178 right(ios);
5179 {
5180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5181 std::string ex(str, iter.base());
5182 assert(ex == "*******-0.000000000000000");
5183 assert(ios.width() == 0);
5184 }
5185 ios.width(25);
5186 internal(ios);
5187 {
5188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5189 std::string ex(str, iter.base());
5190 assert(ex == "-*******0.000000000000000");
5191 assert(ios.width() == 0);
5192 }
5193 }
5194 ios.imbue(lg);
5195 {
5196 ios.width(0);
5197 {
5198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5199 std::string ex(str, iter.base());
5200 assert(ex == "-0;000000000000000");
5201 assert(ios.width() == 0);
5202 }
5203 ios.width(25);
5204 left(ios);
5205 {
5206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5207 std::string ex(str, iter.base());
5208 assert(ex == "-0;000000000000000*******");
5209 assert(ios.width() == 0);
5210 }
5211 ios.width(25);
5212 right(ios);
5213 {
5214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5215 std::string ex(str, iter.base());
5216 assert(ex == "*******-0;000000000000000");
5217 assert(ios.width() == 0);
5218 }
5219 ios.width(25);
5220 internal(ios);
5221 {
5222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5223 std::string ex(str, iter.base());
5224 assert(ex == "-*******0;000000000000000");
5225 assert(ios.width() == 0);
5226 }
5227 }
5228 }
5229 }
5230 showpos(ios);
5231 {
5232 noshowpoint(ios);
5233 {
5234 ios.imbue(lc);
5235 {
5236 ios.width(0);
5237 {
5238 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5239 std::string ex(str, iter.base());
5240 assert(ex == "-0");
5241 assert(ios.width() == 0);
5242 }
5243 ios.width(25);
5244 left(ios);
5245 {
5246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5247 std::string ex(str, iter.base());
5248 assert(ex == "-0***********************");
5249 assert(ios.width() == 0);
5250 }
5251 ios.width(25);
5252 right(ios);
5253 {
5254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5255 std::string ex(str, iter.base());
5256 assert(ex == "***********************-0");
5257 assert(ios.width() == 0);
5258 }
5259 ios.width(25);
5260 internal(ios);
5261 {
5262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5263 std::string ex(str, iter.base());
5264 assert(ex == "-***********************0");
5265 assert(ios.width() == 0);
5266 }
5267 }
5268 ios.imbue(lg);
5269 {
5270 ios.width(0);
5271 {
5272 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5273 std::string ex(str, iter.base());
5274 assert(ex == "-0");
5275 assert(ios.width() == 0);
5276 }
5277 ios.width(25);
5278 left(ios);
5279 {
5280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5281 std::string ex(str, iter.base());
5282 assert(ex == "-0***********************");
5283 assert(ios.width() == 0);
5284 }
5285 ios.width(25);
5286 right(ios);
5287 {
5288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5289 std::string ex(str, iter.base());
5290 assert(ex == "***********************-0");
5291 assert(ios.width() == 0);
5292 }
5293 ios.width(25);
5294 internal(ios);
5295 {
5296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5297 std::string ex(str, iter.base());
5298 assert(ex == "-***********************0");
5299 assert(ios.width() == 0);
5300 }
5301 }
5302 }
5303 showpoint(ios);
5304 {
5305 ios.imbue(lc);
5306 {
5307 ios.width(0);
5308 {
5309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5310 std::string ex(str, iter.base());
5311 assert(ex == "-0.000000000000000");
5312 assert(ios.width() == 0);
5313 }
5314 ios.width(25);
5315 left(ios);
5316 {
5317 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5318 std::string ex(str, iter.base());
5319 assert(ex == "-0.000000000000000*******");
5320 assert(ios.width() == 0);
5321 }
5322 ios.width(25);
5323 right(ios);
5324 {
5325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5326 std::string ex(str, iter.base());
5327 assert(ex == "*******-0.000000000000000");
5328 assert(ios.width() == 0);
5329 }
5330 ios.width(25);
5331 internal(ios);
5332 {
5333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5334 std::string ex(str, iter.base());
5335 assert(ex == "-*******0.000000000000000");
5336 assert(ios.width() == 0);
5337 }
5338 }
5339 ios.imbue(lg);
5340 {
5341 ios.width(0);
5342 {
5343 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5344 std::string ex(str, iter.base());
5345 assert(ex == "-0;000000000000000");
5346 assert(ios.width() == 0);
5347 }
5348 ios.width(25);
5349 left(ios);
5350 {
5351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5352 std::string ex(str, iter.base());
5353 assert(ex == "-0;000000000000000*******");
5354 assert(ios.width() == 0);
5355 }
5356 ios.width(25);
5357 right(ios);
5358 {
5359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5360 std::string ex(str, iter.base());
5361 assert(ex == "*******-0;000000000000000");
5362 assert(ios.width() == 0);
5363 }
5364 ios.width(25);
5365 internal(ios);
5366 {
5367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5368 std::string ex(str, iter.base());
5369 assert(ex == "-*******0;000000000000000");
5370 assert(ios.width() == 0);
5371 }
5372 }
5373 }
5374 }
5375 }
5376 }
5377 ios.precision(60);
5378 {
5379 nouppercase(ios);
5380 {
5381 noshowpos(ios);
5382 {
5383 noshowpoint(ios);
5384 {
5385 ios.imbue(lc);
5386 {
5387 ios.width(0);
5388 {
5389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5390 std::string ex(str, iter.base());
5391 assert(ex == "-0");
5392 assert(ios.width() == 0);
5393 }
5394 ios.width(25);
5395 left(ios);
5396 {
5397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5398 std::string ex(str, iter.base());
5399 assert(ex == "-0***********************");
5400 assert(ios.width() == 0);
5401 }
5402 ios.width(25);
5403 right(ios);
5404 {
5405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5406 std::string ex(str, iter.base());
5407 assert(ex == "***********************-0");
5408 assert(ios.width() == 0);
5409 }
5410 ios.width(25);
5411 internal(ios);
5412 {
5413 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5414 std::string ex(str, iter.base());
5415 assert(ex == "-***********************0");
5416 assert(ios.width() == 0);
5417 }
5418 }
5419 ios.imbue(lg);
5420 {
5421 ios.width(0);
5422 {
5423 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5424 std::string ex(str, iter.base());
5425 assert(ex == "-0");
5426 assert(ios.width() == 0);
5427 }
5428 ios.width(25);
5429 left(ios);
5430 {
5431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5432 std::string ex(str, iter.base());
5433 assert(ex == "-0***********************");
5434 assert(ios.width() == 0);
5435 }
5436 ios.width(25);
5437 right(ios);
5438 {
5439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5440 std::string ex(str, iter.base());
5441 assert(ex == "***********************-0");
5442 assert(ios.width() == 0);
5443 }
5444 ios.width(25);
5445 internal(ios);
5446 {
5447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5448 std::string ex(str, iter.base());
5449 assert(ex == "-***********************0");
5450 assert(ios.width() == 0);
5451 }
5452 }
5453 }
5454 showpoint(ios);
5455 {
5456 ios.imbue(lc);
5457 {
5458 ios.width(0);
5459 {
5460 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5461 std::string ex(str, iter.base());
5462 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5463 assert(ios.width() == 0);
5464 }
5465 ios.width(25);
5466 left(ios);
5467 {
5468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5469 std::string ex(str, iter.base());
5470 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5471 assert(ios.width() == 0);
5472 }
5473 ios.width(25);
5474 right(ios);
5475 {
5476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5477 std::string ex(str, iter.base());
5478 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5479 assert(ios.width() == 0);
5480 }
5481 ios.width(25);
5482 internal(ios);
5483 {
5484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5485 std::string ex(str, iter.base());
5486 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5487 assert(ios.width() == 0);
5488 }
5489 }
5490 ios.imbue(lg);
5491 {
5492 ios.width(0);
5493 {
5494 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5495 std::string ex(str, iter.base());
5496 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5497 assert(ios.width() == 0);
5498 }
5499 ios.width(25);
5500 left(ios);
5501 {
5502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5503 std::string ex(str, iter.base());
5504 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5505 assert(ios.width() == 0);
5506 }
5507 ios.width(25);
5508 right(ios);
5509 {
5510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5511 std::string ex(str, iter.base());
5512 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5513 assert(ios.width() == 0);
5514 }
5515 ios.width(25);
5516 internal(ios);
5517 {
5518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5519 std::string ex(str, iter.base());
5520 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5521 assert(ios.width() == 0);
5522 }
5523 }
5524 }
5525 }
5526 showpos(ios);
5527 {
5528 noshowpoint(ios);
5529 {
5530 ios.imbue(lc);
5531 {
5532 ios.width(0);
5533 {
5534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5535 std::string ex(str, iter.base());
5536 assert(ex == "-0");
5537 assert(ios.width() == 0);
5538 }
5539 ios.width(25);
5540 left(ios);
5541 {
5542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5543 std::string ex(str, iter.base());
5544 assert(ex == "-0***********************");
5545 assert(ios.width() == 0);
5546 }
5547 ios.width(25);
5548 right(ios);
5549 {
5550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5551 std::string ex(str, iter.base());
5552 assert(ex == "***********************-0");
5553 assert(ios.width() == 0);
5554 }
5555 ios.width(25);
5556 internal(ios);
5557 {
5558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5559 std::string ex(str, iter.base());
5560 assert(ex == "-***********************0");
5561 assert(ios.width() == 0);
5562 }
5563 }
5564 ios.imbue(lg);
5565 {
5566 ios.width(0);
5567 {
5568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5569 std::string ex(str, iter.base());
5570 assert(ex == "-0");
5571 assert(ios.width() == 0);
5572 }
5573 ios.width(25);
5574 left(ios);
5575 {
5576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5577 std::string ex(str, iter.base());
5578 assert(ex == "-0***********************");
5579 assert(ios.width() == 0);
5580 }
5581 ios.width(25);
5582 right(ios);
5583 {
5584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5585 std::string ex(str, iter.base());
5586 assert(ex == "***********************-0");
5587 assert(ios.width() == 0);
5588 }
5589 ios.width(25);
5590 internal(ios);
5591 {
5592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5593 std::string ex(str, iter.base());
5594 assert(ex == "-***********************0");
5595 assert(ios.width() == 0);
5596 }
5597 }
5598 }
5599 showpoint(ios);
5600 {
5601 ios.imbue(lc);
5602 {
5603 ios.width(0);
5604 {
5605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5606 std::string ex(str, iter.base());
5607 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5608 assert(ios.width() == 0);
5609 }
5610 ios.width(25);
5611 left(ios);
5612 {
5613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5614 std::string ex(str, iter.base());
5615 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5616 assert(ios.width() == 0);
5617 }
5618 ios.width(25);
5619 right(ios);
5620 {
5621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5622 std::string ex(str, iter.base());
5623 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5624 assert(ios.width() == 0);
5625 }
5626 ios.width(25);
5627 internal(ios);
5628 {
5629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5630 std::string ex(str, iter.base());
5631 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5632 assert(ios.width() == 0);
5633 }
5634 }
5635 ios.imbue(lg);
5636 {
5637 ios.width(0);
5638 {
5639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5640 std::string ex(str, iter.base());
5641 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5642 assert(ios.width() == 0);
5643 }
5644 ios.width(25);
5645 left(ios);
5646 {
5647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5648 std::string ex(str, iter.base());
5649 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5650 assert(ios.width() == 0);
5651 }
5652 ios.width(25);
5653 right(ios);
5654 {
5655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5656 std::string ex(str, iter.base());
5657 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5658 assert(ios.width() == 0);
5659 }
5660 ios.width(25);
5661 internal(ios);
5662 {
5663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5664 std::string ex(str, iter.base());
5665 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5666 assert(ios.width() == 0);
5667 }
5668 }
5669 }
5670 }
5671 }
5672 uppercase(ios);
5673 {
5674 noshowpos(ios);
5675 {
5676 noshowpoint(ios);
5677 {
5678 ios.imbue(lc);
5679 {
5680 ios.width(0);
5681 {
5682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5683 std::string ex(str, iter.base());
5684 assert(ex == "-0");
5685 assert(ios.width() == 0);
5686 }
5687 ios.width(25);
5688 left(ios);
5689 {
5690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5691 std::string ex(str, iter.base());
5692 assert(ex == "-0***********************");
5693 assert(ios.width() == 0);
5694 }
5695 ios.width(25);
5696 right(ios);
5697 {
5698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5699 std::string ex(str, iter.base());
5700 assert(ex == "***********************-0");
5701 assert(ios.width() == 0);
5702 }
5703 ios.width(25);
5704 internal(ios);
5705 {
5706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5707 std::string ex(str, iter.base());
5708 assert(ex == "-***********************0");
5709 assert(ios.width() == 0);
5710 }
5711 }
5712 ios.imbue(lg);
5713 {
5714 ios.width(0);
5715 {
5716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5717 std::string ex(str, iter.base());
5718 assert(ex == "-0");
5719 assert(ios.width() == 0);
5720 }
5721 ios.width(25);
5722 left(ios);
5723 {
5724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5725 std::string ex(str, iter.base());
5726 assert(ex == "-0***********************");
5727 assert(ios.width() == 0);
5728 }
5729 ios.width(25);
5730 right(ios);
5731 {
5732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5733 std::string ex(str, iter.base());
5734 assert(ex == "***********************-0");
5735 assert(ios.width() == 0);
5736 }
5737 ios.width(25);
5738 internal(ios);
5739 {
5740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5741 std::string ex(str, iter.base());
5742 assert(ex == "-***********************0");
5743 assert(ios.width() == 0);
5744 }
5745 }
5746 }
5747 showpoint(ios);
5748 {
5749 ios.imbue(lc);
5750 {
5751 ios.width(0);
5752 {
5753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5754 std::string ex(str, iter.base());
5755 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5756 assert(ios.width() == 0);
5757 }
5758 ios.width(25);
5759 left(ios);
5760 {
5761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5762 std::string ex(str, iter.base());
5763 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5764 assert(ios.width() == 0);
5765 }
5766 ios.width(25);
5767 right(ios);
5768 {
5769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5770 std::string ex(str, iter.base());
5771 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5772 assert(ios.width() == 0);
5773 }
5774 ios.width(25);
5775 internal(ios);
5776 {
5777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5778 std::string ex(str, iter.base());
5779 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5780 assert(ios.width() == 0);
5781 }
5782 }
5783 ios.imbue(lg);
5784 {
5785 ios.width(0);
5786 {
5787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5788 std::string ex(str, iter.base());
5789 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5790 assert(ios.width() == 0);
5791 }
5792 ios.width(25);
5793 left(ios);
5794 {
5795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5796 std::string ex(str, iter.base());
5797 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5798 assert(ios.width() == 0);
5799 }
5800 ios.width(25);
5801 right(ios);
5802 {
5803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5804 std::string ex(str, iter.base());
5805 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5806 assert(ios.width() == 0);
5807 }
5808 ios.width(25);
5809 internal(ios);
5810 {
5811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5812 std::string ex(str, iter.base());
5813 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5814 assert(ios.width() == 0);
5815 }
5816 }
5817 }
5818 }
5819 showpos(ios);
5820 {
5821 noshowpoint(ios);
5822 {
5823 ios.imbue(lc);
5824 {
5825 ios.width(0);
5826 {
5827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5828 std::string ex(str, iter.base());
5829 assert(ex == "-0");
5830 assert(ios.width() == 0);
5831 }
5832 ios.width(25);
5833 left(ios);
5834 {
5835 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5836 std::string ex(str, iter.base());
5837 assert(ex == "-0***********************");
5838 assert(ios.width() == 0);
5839 }
5840 ios.width(25);
5841 right(ios);
5842 {
5843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5844 std::string ex(str, iter.base());
5845 assert(ex == "***********************-0");
5846 assert(ios.width() == 0);
5847 }
5848 ios.width(25);
5849 internal(ios);
5850 {
5851 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5852 std::string ex(str, iter.base());
5853 assert(ex == "-***********************0");
5854 assert(ios.width() == 0);
5855 }
5856 }
5857 ios.imbue(lg);
5858 {
5859 ios.width(0);
5860 {
5861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5862 std::string ex(str, iter.base());
5863 assert(ex == "-0");
5864 assert(ios.width() == 0);
5865 }
5866 ios.width(25);
5867 left(ios);
5868 {
5869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5870 std::string ex(str, iter.base());
5871 assert(ex == "-0***********************");
5872 assert(ios.width() == 0);
5873 }
5874 ios.width(25);
5875 right(ios);
5876 {
5877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5878 std::string ex(str, iter.base());
5879 assert(ex == "***********************-0");
5880 assert(ios.width() == 0);
5881 }
5882 ios.width(25);
5883 internal(ios);
5884 {
5885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5886 std::string ex(str, iter.base());
5887 assert(ex == "-***********************0");
5888 assert(ios.width() == 0);
5889 }
5890 }
5891 }
5892 showpoint(ios);
5893 {
5894 ios.imbue(lc);
5895 {
5896 ios.width(0);
5897 {
5898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5899 std::string ex(str, iter.base());
5900 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5901 assert(ios.width() == 0);
5902 }
5903 ios.width(25);
5904 left(ios);
5905 {
5906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5907 std::string ex(str, iter.base());
5908 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5909 assert(ios.width() == 0);
5910 }
5911 ios.width(25);
5912 right(ios);
5913 {
5914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5915 std::string ex(str, iter.base());
5916 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5917 assert(ios.width() == 0);
5918 }
5919 ios.width(25);
5920 internal(ios);
5921 {
5922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5923 std::string ex(str, iter.base());
5924 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5925 assert(ios.width() == 0);
5926 }
5927 }
5928 ios.imbue(lg);
5929 {
5930 ios.width(0);
5931 {
5932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5933 std::string ex(str, iter.base());
5934 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5935 assert(ios.width() == 0);
5936 }
5937 ios.width(25);
5938 left(ios);
5939 {
5940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5941 std::string ex(str, iter.base());
5942 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5943 assert(ios.width() == 0);
5944 }
5945 ios.width(25);
5946 right(ios);
5947 {
5948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5949 std::string ex(str, iter.base());
5950 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5951 assert(ios.width() == 0);
5952 }
5953 ios.width(25);
5954 internal(ios);
5955 {
5956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5957 std::string ex(str, iter.base());
5958 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5959 assert(ios.width() == 0);
5960 }
5961 }
5962 }
5963 }
5964 }
5965 }
5966 }
5967 }
5968 }
5969
test3()5970 void test3()
5971 {
5972 char str[200];
5973 output_iterator<char*> iter;
5974 std::locale lc = std::locale::classic();
5975 std::locale lg(lc, new my_numpunct);
5976 const my_facet f(1);
5977 {
5978 long double v = 1234567890.125;
5979 std::ios ios(0);
5980 // %g
5981 {
5982 ios.precision(0);
5983 {
5984 nouppercase(ios);
5985 {
5986 noshowpos(ios);
5987 {
5988 noshowpoint(ios);
5989 {
5990 ios.imbue(lc);
5991 {
5992 ios.width(0);
5993 {
5994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
5995 std::string ex(str, iter.base());
5996 assert(ex == "1e+09");
5997 assert(ios.width() == 0);
5998 }
5999 ios.width(25);
6000 left(ios);
6001 {
6002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6003 std::string ex(str, iter.base());
6004 assert(ex == "1e+09********************");
6005 assert(ios.width() == 0);
6006 }
6007 ios.width(25);
6008 right(ios);
6009 {
6010 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6011 std::string ex(str, iter.base());
6012 assert(ex == "********************1e+09");
6013 assert(ios.width() == 0);
6014 }
6015 ios.width(25);
6016 internal(ios);
6017 {
6018 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6019 std::string ex(str, iter.base());
6020 assert(ex == "********************1e+09");
6021 assert(ios.width() == 0);
6022 }
6023 }
6024 ios.imbue(lg);
6025 {
6026 ios.width(0);
6027 {
6028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6029 std::string ex(str, iter.base());
6030 assert(ex == "1e+09");
6031 assert(ios.width() == 0);
6032 }
6033 ios.width(25);
6034 left(ios);
6035 {
6036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6037 std::string ex(str, iter.base());
6038 assert(ex == "1e+09********************");
6039 assert(ios.width() == 0);
6040 }
6041 ios.width(25);
6042 right(ios);
6043 {
6044 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6045 std::string ex(str, iter.base());
6046 assert(ex == "********************1e+09");
6047 assert(ios.width() == 0);
6048 }
6049 ios.width(25);
6050 internal(ios);
6051 {
6052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6053 std::string ex(str, iter.base());
6054 assert(ex == "********************1e+09");
6055 assert(ios.width() == 0);
6056 }
6057 }
6058 }
6059 showpoint(ios);
6060 {
6061 ios.imbue(lc);
6062 {
6063 ios.width(0);
6064 {
6065 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6066 std::string ex(str, iter.base());
6067 assert(ex == "1.e+09");
6068 assert(ios.width() == 0);
6069 }
6070 ios.width(25);
6071 left(ios);
6072 {
6073 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6074 std::string ex(str, iter.base());
6075 assert(ex == "1.e+09*******************");
6076 assert(ios.width() == 0);
6077 }
6078 ios.width(25);
6079 right(ios);
6080 {
6081 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6082 std::string ex(str, iter.base());
6083 assert(ex == "*******************1.e+09");
6084 assert(ios.width() == 0);
6085 }
6086 ios.width(25);
6087 internal(ios);
6088 {
6089 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6090 std::string ex(str, iter.base());
6091 assert(ex == "*******************1.e+09");
6092 assert(ios.width() == 0);
6093 }
6094 }
6095 ios.imbue(lg);
6096 {
6097 ios.width(0);
6098 {
6099 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6100 std::string ex(str, iter.base());
6101 assert(ex == "1;e+09");
6102 assert(ios.width() == 0);
6103 }
6104 ios.width(25);
6105 left(ios);
6106 {
6107 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6108 std::string ex(str, iter.base());
6109 assert(ex == "1;e+09*******************");
6110 assert(ios.width() == 0);
6111 }
6112 ios.width(25);
6113 right(ios);
6114 {
6115 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6116 std::string ex(str, iter.base());
6117 assert(ex == "*******************1;e+09");
6118 assert(ios.width() == 0);
6119 }
6120 ios.width(25);
6121 internal(ios);
6122 {
6123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6124 std::string ex(str, iter.base());
6125 assert(ex == "*******************1;e+09");
6126 assert(ios.width() == 0);
6127 }
6128 }
6129 }
6130 }
6131 showpos(ios);
6132 {
6133 noshowpoint(ios);
6134 {
6135 ios.imbue(lc);
6136 {
6137 ios.width(0);
6138 {
6139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6140 std::string ex(str, iter.base());
6141 assert(ex == "+1e+09");
6142 assert(ios.width() == 0);
6143 }
6144 ios.width(25);
6145 left(ios);
6146 {
6147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6148 std::string ex(str, iter.base());
6149 assert(ex == "+1e+09*******************");
6150 assert(ios.width() == 0);
6151 }
6152 ios.width(25);
6153 right(ios);
6154 {
6155 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6156 std::string ex(str, iter.base());
6157 assert(ex == "*******************+1e+09");
6158 assert(ios.width() == 0);
6159 }
6160 ios.width(25);
6161 internal(ios);
6162 {
6163 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6164 std::string ex(str, iter.base());
6165 assert(ex == "+*******************1e+09");
6166 assert(ios.width() == 0);
6167 }
6168 }
6169 ios.imbue(lg);
6170 {
6171 ios.width(0);
6172 {
6173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6174 std::string ex(str, iter.base());
6175 assert(ex == "+1e+09");
6176 assert(ios.width() == 0);
6177 }
6178 ios.width(25);
6179 left(ios);
6180 {
6181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6182 std::string ex(str, iter.base());
6183 assert(ex == "+1e+09*******************");
6184 assert(ios.width() == 0);
6185 }
6186 ios.width(25);
6187 right(ios);
6188 {
6189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6190 std::string ex(str, iter.base());
6191 assert(ex == "*******************+1e+09");
6192 assert(ios.width() == 0);
6193 }
6194 ios.width(25);
6195 internal(ios);
6196 {
6197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6198 std::string ex(str, iter.base());
6199 assert(ex == "+*******************1e+09");
6200 assert(ios.width() == 0);
6201 }
6202 }
6203 }
6204 showpoint(ios);
6205 {
6206 ios.imbue(lc);
6207 {
6208 ios.width(0);
6209 {
6210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6211 std::string ex(str, iter.base());
6212 assert(ex == "+1.e+09");
6213 assert(ios.width() == 0);
6214 }
6215 ios.width(25);
6216 left(ios);
6217 {
6218 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6219 std::string ex(str, iter.base());
6220 assert(ex == "+1.e+09******************");
6221 assert(ios.width() == 0);
6222 }
6223 ios.width(25);
6224 right(ios);
6225 {
6226 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6227 std::string ex(str, iter.base());
6228 assert(ex == "******************+1.e+09");
6229 assert(ios.width() == 0);
6230 }
6231 ios.width(25);
6232 internal(ios);
6233 {
6234 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6235 std::string ex(str, iter.base());
6236 assert(ex == "+******************1.e+09");
6237 assert(ios.width() == 0);
6238 }
6239 }
6240 ios.imbue(lg);
6241 {
6242 ios.width(0);
6243 {
6244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6245 std::string ex(str, iter.base());
6246 assert(ex == "+1;e+09");
6247 assert(ios.width() == 0);
6248 }
6249 ios.width(25);
6250 left(ios);
6251 {
6252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6253 std::string ex(str, iter.base());
6254 assert(ex == "+1;e+09******************");
6255 assert(ios.width() == 0);
6256 }
6257 ios.width(25);
6258 right(ios);
6259 {
6260 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6261 std::string ex(str, iter.base());
6262 assert(ex == "******************+1;e+09");
6263 assert(ios.width() == 0);
6264 }
6265 ios.width(25);
6266 internal(ios);
6267 {
6268 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6269 std::string ex(str, iter.base());
6270 assert(ex == "+******************1;e+09");
6271 assert(ios.width() == 0);
6272 }
6273 }
6274 }
6275 }
6276 }
6277 uppercase(ios);
6278 {
6279 noshowpos(ios);
6280 {
6281 noshowpoint(ios);
6282 {
6283 ios.imbue(lc);
6284 {
6285 ios.width(0);
6286 {
6287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6288 std::string ex(str, iter.base());
6289 assert(ex == "1E+09");
6290 assert(ios.width() == 0);
6291 }
6292 ios.width(25);
6293 left(ios);
6294 {
6295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6296 std::string ex(str, iter.base());
6297 assert(ex == "1E+09********************");
6298 assert(ios.width() == 0);
6299 }
6300 ios.width(25);
6301 right(ios);
6302 {
6303 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6304 std::string ex(str, iter.base());
6305 assert(ex == "********************1E+09");
6306 assert(ios.width() == 0);
6307 }
6308 ios.width(25);
6309 internal(ios);
6310 {
6311 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6312 std::string ex(str, iter.base());
6313 assert(ex == "********************1E+09");
6314 assert(ios.width() == 0);
6315 }
6316 }
6317 ios.imbue(lg);
6318 {
6319 ios.width(0);
6320 {
6321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6322 std::string ex(str, iter.base());
6323 assert(ex == "1E+09");
6324 assert(ios.width() == 0);
6325 }
6326 ios.width(25);
6327 left(ios);
6328 {
6329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6330 std::string ex(str, iter.base());
6331 assert(ex == "1E+09********************");
6332 assert(ios.width() == 0);
6333 }
6334 ios.width(25);
6335 right(ios);
6336 {
6337 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6338 std::string ex(str, iter.base());
6339 assert(ex == "********************1E+09");
6340 assert(ios.width() == 0);
6341 }
6342 ios.width(25);
6343 internal(ios);
6344 {
6345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6346 std::string ex(str, iter.base());
6347 assert(ex == "********************1E+09");
6348 assert(ios.width() == 0);
6349 }
6350 }
6351 }
6352 showpoint(ios);
6353 {
6354 ios.imbue(lc);
6355 {
6356 ios.width(0);
6357 {
6358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6359 std::string ex(str, iter.base());
6360 assert(ex == "1.E+09");
6361 assert(ios.width() == 0);
6362 }
6363 ios.width(25);
6364 left(ios);
6365 {
6366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6367 std::string ex(str, iter.base());
6368 assert(ex == "1.E+09*******************");
6369 assert(ios.width() == 0);
6370 }
6371 ios.width(25);
6372 right(ios);
6373 {
6374 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6375 std::string ex(str, iter.base());
6376 assert(ex == "*******************1.E+09");
6377 assert(ios.width() == 0);
6378 }
6379 ios.width(25);
6380 internal(ios);
6381 {
6382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6383 std::string ex(str, iter.base());
6384 assert(ex == "*******************1.E+09");
6385 assert(ios.width() == 0);
6386 }
6387 }
6388 ios.imbue(lg);
6389 {
6390 ios.width(0);
6391 {
6392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6393 std::string ex(str, iter.base());
6394 assert(ex == "1;E+09");
6395 assert(ios.width() == 0);
6396 }
6397 ios.width(25);
6398 left(ios);
6399 {
6400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6401 std::string ex(str, iter.base());
6402 assert(ex == "1;E+09*******************");
6403 assert(ios.width() == 0);
6404 }
6405 ios.width(25);
6406 right(ios);
6407 {
6408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6409 std::string ex(str, iter.base());
6410 assert(ex == "*******************1;E+09");
6411 assert(ios.width() == 0);
6412 }
6413 ios.width(25);
6414 internal(ios);
6415 {
6416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6417 std::string ex(str, iter.base());
6418 assert(ex == "*******************1;E+09");
6419 assert(ios.width() == 0);
6420 }
6421 }
6422 }
6423 }
6424 showpos(ios);
6425 {
6426 noshowpoint(ios);
6427 {
6428 ios.imbue(lc);
6429 {
6430 ios.width(0);
6431 {
6432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6433 std::string ex(str, iter.base());
6434 assert(ex == "+1E+09");
6435 assert(ios.width() == 0);
6436 }
6437 ios.width(25);
6438 left(ios);
6439 {
6440 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6441 std::string ex(str, iter.base());
6442 assert(ex == "+1E+09*******************");
6443 assert(ios.width() == 0);
6444 }
6445 ios.width(25);
6446 right(ios);
6447 {
6448 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6449 std::string ex(str, iter.base());
6450 assert(ex == "*******************+1E+09");
6451 assert(ios.width() == 0);
6452 }
6453 ios.width(25);
6454 internal(ios);
6455 {
6456 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6457 std::string ex(str, iter.base());
6458 assert(ex == "+*******************1E+09");
6459 assert(ios.width() == 0);
6460 }
6461 }
6462 ios.imbue(lg);
6463 {
6464 ios.width(0);
6465 {
6466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6467 std::string ex(str, iter.base());
6468 assert(ex == "+1E+09");
6469 assert(ios.width() == 0);
6470 }
6471 ios.width(25);
6472 left(ios);
6473 {
6474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6475 std::string ex(str, iter.base());
6476 assert(ex == "+1E+09*******************");
6477 assert(ios.width() == 0);
6478 }
6479 ios.width(25);
6480 right(ios);
6481 {
6482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6483 std::string ex(str, iter.base());
6484 assert(ex == "*******************+1E+09");
6485 assert(ios.width() == 0);
6486 }
6487 ios.width(25);
6488 internal(ios);
6489 {
6490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6491 std::string ex(str, iter.base());
6492 assert(ex == "+*******************1E+09");
6493 assert(ios.width() == 0);
6494 }
6495 }
6496 }
6497 showpoint(ios);
6498 {
6499 ios.imbue(lc);
6500 {
6501 ios.width(0);
6502 {
6503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6504 std::string ex(str, iter.base());
6505 assert(ex == "+1.E+09");
6506 assert(ios.width() == 0);
6507 }
6508 ios.width(25);
6509 left(ios);
6510 {
6511 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6512 std::string ex(str, iter.base());
6513 assert(ex == "+1.E+09******************");
6514 assert(ios.width() == 0);
6515 }
6516 ios.width(25);
6517 right(ios);
6518 {
6519 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6520 std::string ex(str, iter.base());
6521 assert(ex == "******************+1.E+09");
6522 assert(ios.width() == 0);
6523 }
6524 ios.width(25);
6525 internal(ios);
6526 {
6527 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6528 std::string ex(str, iter.base());
6529 assert(ex == "+******************1.E+09");
6530 assert(ios.width() == 0);
6531 }
6532 }
6533 ios.imbue(lg);
6534 {
6535 ios.width(0);
6536 {
6537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6538 std::string ex(str, iter.base());
6539 assert(ex == "+1;E+09");
6540 assert(ios.width() == 0);
6541 }
6542 ios.width(25);
6543 left(ios);
6544 {
6545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6546 std::string ex(str, iter.base());
6547 assert(ex == "+1;E+09******************");
6548 assert(ios.width() == 0);
6549 }
6550 ios.width(25);
6551 right(ios);
6552 {
6553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6554 std::string ex(str, iter.base());
6555 assert(ex == "******************+1;E+09");
6556 assert(ios.width() == 0);
6557 }
6558 ios.width(25);
6559 internal(ios);
6560 {
6561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6562 std::string ex(str, iter.base());
6563 assert(ex == "+******************1;E+09");
6564 assert(ios.width() == 0);
6565 }
6566 }
6567 }
6568 }
6569 }
6570 }
6571 ios.precision(1);
6572 {
6573 nouppercase(ios);
6574 {
6575 noshowpos(ios);
6576 {
6577 noshowpoint(ios);
6578 {
6579 ios.imbue(lc);
6580 {
6581 ios.width(0);
6582 {
6583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6584 std::string ex(str, iter.base());
6585 assert(ex == "1e+09");
6586 assert(ios.width() == 0);
6587 }
6588 ios.width(25);
6589 left(ios);
6590 {
6591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6592 std::string ex(str, iter.base());
6593 assert(ex == "1e+09********************");
6594 assert(ios.width() == 0);
6595 }
6596 ios.width(25);
6597 right(ios);
6598 {
6599 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6600 std::string ex(str, iter.base());
6601 assert(ex == "********************1e+09");
6602 assert(ios.width() == 0);
6603 }
6604 ios.width(25);
6605 internal(ios);
6606 {
6607 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6608 std::string ex(str, iter.base());
6609 assert(ex == "********************1e+09");
6610 assert(ios.width() == 0);
6611 }
6612 }
6613 ios.imbue(lg);
6614 {
6615 ios.width(0);
6616 {
6617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6618 std::string ex(str, iter.base());
6619 assert(ex == "1e+09");
6620 assert(ios.width() == 0);
6621 }
6622 ios.width(25);
6623 left(ios);
6624 {
6625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6626 std::string ex(str, iter.base());
6627 assert(ex == "1e+09********************");
6628 assert(ios.width() == 0);
6629 }
6630 ios.width(25);
6631 right(ios);
6632 {
6633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6634 std::string ex(str, iter.base());
6635 assert(ex == "********************1e+09");
6636 assert(ios.width() == 0);
6637 }
6638 ios.width(25);
6639 internal(ios);
6640 {
6641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6642 std::string ex(str, iter.base());
6643 assert(ex == "********************1e+09");
6644 assert(ios.width() == 0);
6645 }
6646 }
6647 }
6648 showpoint(ios);
6649 {
6650 ios.imbue(lc);
6651 {
6652 ios.width(0);
6653 {
6654 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6655 std::string ex(str, iter.base());
6656 assert(ex == "1.e+09");
6657 assert(ios.width() == 0);
6658 }
6659 ios.width(25);
6660 left(ios);
6661 {
6662 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6663 std::string ex(str, iter.base());
6664 assert(ex == "1.e+09*******************");
6665 assert(ios.width() == 0);
6666 }
6667 ios.width(25);
6668 right(ios);
6669 {
6670 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6671 std::string ex(str, iter.base());
6672 assert(ex == "*******************1.e+09");
6673 assert(ios.width() == 0);
6674 }
6675 ios.width(25);
6676 internal(ios);
6677 {
6678 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6679 std::string ex(str, iter.base());
6680 assert(ex == "*******************1.e+09");
6681 assert(ios.width() == 0);
6682 }
6683 }
6684 ios.imbue(lg);
6685 {
6686 ios.width(0);
6687 {
6688 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6689 std::string ex(str, iter.base());
6690 assert(ex == "1;e+09");
6691 assert(ios.width() == 0);
6692 }
6693 ios.width(25);
6694 left(ios);
6695 {
6696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6697 std::string ex(str, iter.base());
6698 assert(ex == "1;e+09*******************");
6699 assert(ios.width() == 0);
6700 }
6701 ios.width(25);
6702 right(ios);
6703 {
6704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6705 std::string ex(str, iter.base());
6706 assert(ex == "*******************1;e+09");
6707 assert(ios.width() == 0);
6708 }
6709 ios.width(25);
6710 internal(ios);
6711 {
6712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6713 std::string ex(str, iter.base());
6714 assert(ex == "*******************1;e+09");
6715 assert(ios.width() == 0);
6716 }
6717 }
6718 }
6719 }
6720 showpos(ios);
6721 {
6722 noshowpoint(ios);
6723 {
6724 ios.imbue(lc);
6725 {
6726 ios.width(0);
6727 {
6728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6729 std::string ex(str, iter.base());
6730 assert(ex == "+1e+09");
6731 assert(ios.width() == 0);
6732 }
6733 ios.width(25);
6734 left(ios);
6735 {
6736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6737 std::string ex(str, iter.base());
6738 assert(ex == "+1e+09*******************");
6739 assert(ios.width() == 0);
6740 }
6741 ios.width(25);
6742 right(ios);
6743 {
6744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6745 std::string ex(str, iter.base());
6746 assert(ex == "*******************+1e+09");
6747 assert(ios.width() == 0);
6748 }
6749 ios.width(25);
6750 internal(ios);
6751 {
6752 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6753 std::string ex(str, iter.base());
6754 assert(ex == "+*******************1e+09");
6755 assert(ios.width() == 0);
6756 }
6757 }
6758 ios.imbue(lg);
6759 {
6760 ios.width(0);
6761 {
6762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6763 std::string ex(str, iter.base());
6764 assert(ex == "+1e+09");
6765 assert(ios.width() == 0);
6766 }
6767 ios.width(25);
6768 left(ios);
6769 {
6770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6771 std::string ex(str, iter.base());
6772 assert(ex == "+1e+09*******************");
6773 assert(ios.width() == 0);
6774 }
6775 ios.width(25);
6776 right(ios);
6777 {
6778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6779 std::string ex(str, iter.base());
6780 assert(ex == "*******************+1e+09");
6781 assert(ios.width() == 0);
6782 }
6783 ios.width(25);
6784 internal(ios);
6785 {
6786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6787 std::string ex(str, iter.base());
6788 assert(ex == "+*******************1e+09");
6789 assert(ios.width() == 0);
6790 }
6791 }
6792 }
6793 showpoint(ios);
6794 {
6795 ios.imbue(lc);
6796 {
6797 ios.width(0);
6798 {
6799 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6800 std::string ex(str, iter.base());
6801 assert(ex == "+1.e+09");
6802 assert(ios.width() == 0);
6803 }
6804 ios.width(25);
6805 left(ios);
6806 {
6807 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6808 std::string ex(str, iter.base());
6809 assert(ex == "+1.e+09******************");
6810 assert(ios.width() == 0);
6811 }
6812 ios.width(25);
6813 right(ios);
6814 {
6815 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6816 std::string ex(str, iter.base());
6817 assert(ex == "******************+1.e+09");
6818 assert(ios.width() == 0);
6819 }
6820 ios.width(25);
6821 internal(ios);
6822 {
6823 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6824 std::string ex(str, iter.base());
6825 assert(ex == "+******************1.e+09");
6826 assert(ios.width() == 0);
6827 }
6828 }
6829 ios.imbue(lg);
6830 {
6831 ios.width(0);
6832 {
6833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6834 std::string ex(str, iter.base());
6835 assert(ex == "+1;e+09");
6836 assert(ios.width() == 0);
6837 }
6838 ios.width(25);
6839 left(ios);
6840 {
6841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6842 std::string ex(str, iter.base());
6843 assert(ex == "+1;e+09******************");
6844 assert(ios.width() == 0);
6845 }
6846 ios.width(25);
6847 right(ios);
6848 {
6849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6850 std::string ex(str, iter.base());
6851 assert(ex == "******************+1;e+09");
6852 assert(ios.width() == 0);
6853 }
6854 ios.width(25);
6855 internal(ios);
6856 {
6857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6858 std::string ex(str, iter.base());
6859 assert(ex == "+******************1;e+09");
6860 assert(ios.width() == 0);
6861 }
6862 }
6863 }
6864 }
6865 }
6866 uppercase(ios);
6867 {
6868 noshowpos(ios);
6869 {
6870 noshowpoint(ios);
6871 {
6872 ios.imbue(lc);
6873 {
6874 ios.width(0);
6875 {
6876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6877 std::string ex(str, iter.base());
6878 assert(ex == "1E+09");
6879 assert(ios.width() == 0);
6880 }
6881 ios.width(25);
6882 left(ios);
6883 {
6884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6885 std::string ex(str, iter.base());
6886 assert(ex == "1E+09********************");
6887 assert(ios.width() == 0);
6888 }
6889 ios.width(25);
6890 right(ios);
6891 {
6892 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6893 std::string ex(str, iter.base());
6894 assert(ex == "********************1E+09");
6895 assert(ios.width() == 0);
6896 }
6897 ios.width(25);
6898 internal(ios);
6899 {
6900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6901 std::string ex(str, iter.base());
6902 assert(ex == "********************1E+09");
6903 assert(ios.width() == 0);
6904 }
6905 }
6906 ios.imbue(lg);
6907 {
6908 ios.width(0);
6909 {
6910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6911 std::string ex(str, iter.base());
6912 assert(ex == "1E+09");
6913 assert(ios.width() == 0);
6914 }
6915 ios.width(25);
6916 left(ios);
6917 {
6918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6919 std::string ex(str, iter.base());
6920 assert(ex == "1E+09********************");
6921 assert(ios.width() == 0);
6922 }
6923 ios.width(25);
6924 right(ios);
6925 {
6926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6927 std::string ex(str, iter.base());
6928 assert(ex == "********************1E+09");
6929 assert(ios.width() == 0);
6930 }
6931 ios.width(25);
6932 internal(ios);
6933 {
6934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6935 std::string ex(str, iter.base());
6936 assert(ex == "********************1E+09");
6937 assert(ios.width() == 0);
6938 }
6939 }
6940 }
6941 showpoint(ios);
6942 {
6943 ios.imbue(lc);
6944 {
6945 ios.width(0);
6946 {
6947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6948 std::string ex(str, iter.base());
6949 assert(ex == "1.E+09");
6950 assert(ios.width() == 0);
6951 }
6952 ios.width(25);
6953 left(ios);
6954 {
6955 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6956 std::string ex(str, iter.base());
6957 assert(ex == "1.E+09*******************");
6958 assert(ios.width() == 0);
6959 }
6960 ios.width(25);
6961 right(ios);
6962 {
6963 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6964 std::string ex(str, iter.base());
6965 assert(ex == "*******************1.E+09");
6966 assert(ios.width() == 0);
6967 }
6968 ios.width(25);
6969 internal(ios);
6970 {
6971 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6972 std::string ex(str, iter.base());
6973 assert(ex == "*******************1.E+09");
6974 assert(ios.width() == 0);
6975 }
6976 }
6977 ios.imbue(lg);
6978 {
6979 ios.width(0);
6980 {
6981 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6982 std::string ex(str, iter.base());
6983 assert(ex == "1;E+09");
6984 assert(ios.width() == 0);
6985 }
6986 ios.width(25);
6987 left(ios);
6988 {
6989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6990 std::string ex(str, iter.base());
6991 assert(ex == "1;E+09*******************");
6992 assert(ios.width() == 0);
6993 }
6994 ios.width(25);
6995 right(ios);
6996 {
6997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
6998 std::string ex(str, iter.base());
6999 assert(ex == "*******************1;E+09");
7000 assert(ios.width() == 0);
7001 }
7002 ios.width(25);
7003 internal(ios);
7004 {
7005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7006 std::string ex(str, iter.base());
7007 assert(ex == "*******************1;E+09");
7008 assert(ios.width() == 0);
7009 }
7010 }
7011 }
7012 }
7013 showpos(ios);
7014 {
7015 noshowpoint(ios);
7016 {
7017 ios.imbue(lc);
7018 {
7019 ios.width(0);
7020 {
7021 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7022 std::string ex(str, iter.base());
7023 assert(ex == "+1E+09");
7024 assert(ios.width() == 0);
7025 }
7026 ios.width(25);
7027 left(ios);
7028 {
7029 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7030 std::string ex(str, iter.base());
7031 assert(ex == "+1E+09*******************");
7032 assert(ios.width() == 0);
7033 }
7034 ios.width(25);
7035 right(ios);
7036 {
7037 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7038 std::string ex(str, iter.base());
7039 assert(ex == "*******************+1E+09");
7040 assert(ios.width() == 0);
7041 }
7042 ios.width(25);
7043 internal(ios);
7044 {
7045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7046 std::string ex(str, iter.base());
7047 assert(ex == "+*******************1E+09");
7048 assert(ios.width() == 0);
7049 }
7050 }
7051 ios.imbue(lg);
7052 {
7053 ios.width(0);
7054 {
7055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7056 std::string ex(str, iter.base());
7057 assert(ex == "+1E+09");
7058 assert(ios.width() == 0);
7059 }
7060 ios.width(25);
7061 left(ios);
7062 {
7063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7064 std::string ex(str, iter.base());
7065 assert(ex == "+1E+09*******************");
7066 assert(ios.width() == 0);
7067 }
7068 ios.width(25);
7069 right(ios);
7070 {
7071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7072 std::string ex(str, iter.base());
7073 assert(ex == "*******************+1E+09");
7074 assert(ios.width() == 0);
7075 }
7076 ios.width(25);
7077 internal(ios);
7078 {
7079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7080 std::string ex(str, iter.base());
7081 assert(ex == "+*******************1E+09");
7082 assert(ios.width() == 0);
7083 }
7084 }
7085 }
7086 showpoint(ios);
7087 {
7088 ios.imbue(lc);
7089 {
7090 ios.width(0);
7091 {
7092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7093 std::string ex(str, iter.base());
7094 assert(ex == "+1.E+09");
7095 assert(ios.width() == 0);
7096 }
7097 ios.width(25);
7098 left(ios);
7099 {
7100 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7101 std::string ex(str, iter.base());
7102 assert(ex == "+1.E+09******************");
7103 assert(ios.width() == 0);
7104 }
7105 ios.width(25);
7106 right(ios);
7107 {
7108 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7109 std::string ex(str, iter.base());
7110 assert(ex == "******************+1.E+09");
7111 assert(ios.width() == 0);
7112 }
7113 ios.width(25);
7114 internal(ios);
7115 {
7116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7117 std::string ex(str, iter.base());
7118 assert(ex == "+******************1.E+09");
7119 assert(ios.width() == 0);
7120 }
7121 }
7122 ios.imbue(lg);
7123 {
7124 ios.width(0);
7125 {
7126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7127 std::string ex(str, iter.base());
7128 assert(ex == "+1;E+09");
7129 assert(ios.width() == 0);
7130 }
7131 ios.width(25);
7132 left(ios);
7133 {
7134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7135 std::string ex(str, iter.base());
7136 assert(ex == "+1;E+09******************");
7137 assert(ios.width() == 0);
7138 }
7139 ios.width(25);
7140 right(ios);
7141 {
7142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7143 std::string ex(str, iter.base());
7144 assert(ex == "******************+1;E+09");
7145 assert(ios.width() == 0);
7146 }
7147 ios.width(25);
7148 internal(ios);
7149 {
7150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7151 std::string ex(str, iter.base());
7152 assert(ex == "+******************1;E+09");
7153 assert(ios.width() == 0);
7154 }
7155 }
7156 }
7157 }
7158 }
7159 }
7160 ios.precision(6);
7161 {
7162 nouppercase(ios);
7163 {
7164 noshowpos(ios);
7165 {
7166 noshowpoint(ios);
7167 {
7168 ios.imbue(lc);
7169 {
7170 ios.width(0);
7171 {
7172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7173 std::string ex(str, iter.base());
7174 assert(ex == "1.23457e+09");
7175 assert(ios.width() == 0);
7176 }
7177 ios.width(25);
7178 left(ios);
7179 {
7180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7181 std::string ex(str, iter.base());
7182 assert(ex == "1.23457e+09**************");
7183 assert(ios.width() == 0);
7184 }
7185 ios.width(25);
7186 right(ios);
7187 {
7188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7189 std::string ex(str, iter.base());
7190 assert(ex == "**************1.23457e+09");
7191 assert(ios.width() == 0);
7192 }
7193 ios.width(25);
7194 internal(ios);
7195 {
7196 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7197 std::string ex(str, iter.base());
7198 assert(ex == "**************1.23457e+09");
7199 assert(ios.width() == 0);
7200 }
7201 }
7202 ios.imbue(lg);
7203 {
7204 ios.width(0);
7205 {
7206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7207 std::string ex(str, iter.base());
7208 assert(ex == "1;23457e+09");
7209 assert(ios.width() == 0);
7210 }
7211 ios.width(25);
7212 left(ios);
7213 {
7214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7215 std::string ex(str, iter.base());
7216 assert(ex == "1;23457e+09**************");
7217 assert(ios.width() == 0);
7218 }
7219 ios.width(25);
7220 right(ios);
7221 {
7222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7223 std::string ex(str, iter.base());
7224 assert(ex == "**************1;23457e+09");
7225 assert(ios.width() == 0);
7226 }
7227 ios.width(25);
7228 internal(ios);
7229 {
7230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7231 std::string ex(str, iter.base());
7232 assert(ex == "**************1;23457e+09");
7233 assert(ios.width() == 0);
7234 }
7235 }
7236 }
7237 showpoint(ios);
7238 {
7239 ios.imbue(lc);
7240 {
7241 ios.width(0);
7242 {
7243 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7244 std::string ex(str, iter.base());
7245 assert(ex == "1.23457e+09");
7246 assert(ios.width() == 0);
7247 }
7248 ios.width(25);
7249 left(ios);
7250 {
7251 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7252 std::string ex(str, iter.base());
7253 assert(ex == "1.23457e+09**************");
7254 assert(ios.width() == 0);
7255 }
7256 ios.width(25);
7257 right(ios);
7258 {
7259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7260 std::string ex(str, iter.base());
7261 assert(ex == "**************1.23457e+09");
7262 assert(ios.width() == 0);
7263 }
7264 ios.width(25);
7265 internal(ios);
7266 {
7267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7268 std::string ex(str, iter.base());
7269 assert(ex == "**************1.23457e+09");
7270 assert(ios.width() == 0);
7271 }
7272 }
7273 ios.imbue(lg);
7274 {
7275 ios.width(0);
7276 {
7277 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7278 std::string ex(str, iter.base());
7279 assert(ex == "1;23457e+09");
7280 assert(ios.width() == 0);
7281 }
7282 ios.width(25);
7283 left(ios);
7284 {
7285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7286 std::string ex(str, iter.base());
7287 assert(ex == "1;23457e+09**************");
7288 assert(ios.width() == 0);
7289 }
7290 ios.width(25);
7291 right(ios);
7292 {
7293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7294 std::string ex(str, iter.base());
7295 assert(ex == "**************1;23457e+09");
7296 assert(ios.width() == 0);
7297 }
7298 ios.width(25);
7299 internal(ios);
7300 {
7301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7302 std::string ex(str, iter.base());
7303 assert(ex == "**************1;23457e+09");
7304 assert(ios.width() == 0);
7305 }
7306 }
7307 }
7308 }
7309 showpos(ios);
7310 {
7311 noshowpoint(ios);
7312 {
7313 ios.imbue(lc);
7314 {
7315 ios.width(0);
7316 {
7317 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7318 std::string ex(str, iter.base());
7319 assert(ex == "+1.23457e+09");
7320 assert(ios.width() == 0);
7321 }
7322 ios.width(25);
7323 left(ios);
7324 {
7325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7326 std::string ex(str, iter.base());
7327 assert(ex == "+1.23457e+09*************");
7328 assert(ios.width() == 0);
7329 }
7330 ios.width(25);
7331 right(ios);
7332 {
7333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7334 std::string ex(str, iter.base());
7335 assert(ex == "*************+1.23457e+09");
7336 assert(ios.width() == 0);
7337 }
7338 ios.width(25);
7339 internal(ios);
7340 {
7341 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7342 std::string ex(str, iter.base());
7343 assert(ex == "+*************1.23457e+09");
7344 assert(ios.width() == 0);
7345 }
7346 }
7347 ios.imbue(lg);
7348 {
7349 ios.width(0);
7350 {
7351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7352 std::string ex(str, iter.base());
7353 assert(ex == "+1;23457e+09");
7354 assert(ios.width() == 0);
7355 }
7356 ios.width(25);
7357 left(ios);
7358 {
7359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7360 std::string ex(str, iter.base());
7361 assert(ex == "+1;23457e+09*************");
7362 assert(ios.width() == 0);
7363 }
7364 ios.width(25);
7365 right(ios);
7366 {
7367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7368 std::string ex(str, iter.base());
7369 assert(ex == "*************+1;23457e+09");
7370 assert(ios.width() == 0);
7371 }
7372 ios.width(25);
7373 internal(ios);
7374 {
7375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7376 std::string ex(str, iter.base());
7377 assert(ex == "+*************1;23457e+09");
7378 assert(ios.width() == 0);
7379 }
7380 }
7381 }
7382 showpoint(ios);
7383 {
7384 ios.imbue(lc);
7385 {
7386 ios.width(0);
7387 {
7388 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7389 std::string ex(str, iter.base());
7390 assert(ex == "+1.23457e+09");
7391 assert(ios.width() == 0);
7392 }
7393 ios.width(25);
7394 left(ios);
7395 {
7396 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7397 std::string ex(str, iter.base());
7398 assert(ex == "+1.23457e+09*************");
7399 assert(ios.width() == 0);
7400 }
7401 ios.width(25);
7402 right(ios);
7403 {
7404 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7405 std::string ex(str, iter.base());
7406 assert(ex == "*************+1.23457e+09");
7407 assert(ios.width() == 0);
7408 }
7409 ios.width(25);
7410 internal(ios);
7411 {
7412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7413 std::string ex(str, iter.base());
7414 assert(ex == "+*************1.23457e+09");
7415 assert(ios.width() == 0);
7416 }
7417 }
7418 ios.imbue(lg);
7419 {
7420 ios.width(0);
7421 {
7422 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7423 std::string ex(str, iter.base());
7424 assert(ex == "+1;23457e+09");
7425 assert(ios.width() == 0);
7426 }
7427 ios.width(25);
7428 left(ios);
7429 {
7430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7431 std::string ex(str, iter.base());
7432 assert(ex == "+1;23457e+09*************");
7433 assert(ios.width() == 0);
7434 }
7435 ios.width(25);
7436 right(ios);
7437 {
7438 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7439 std::string ex(str, iter.base());
7440 assert(ex == "*************+1;23457e+09");
7441 assert(ios.width() == 0);
7442 }
7443 ios.width(25);
7444 internal(ios);
7445 {
7446 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7447 std::string ex(str, iter.base());
7448 assert(ex == "+*************1;23457e+09");
7449 assert(ios.width() == 0);
7450 }
7451 }
7452 }
7453 }
7454 }
7455 uppercase(ios);
7456 {
7457 noshowpos(ios);
7458 {
7459 noshowpoint(ios);
7460 {
7461 ios.imbue(lc);
7462 {
7463 ios.width(0);
7464 {
7465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7466 std::string ex(str, iter.base());
7467 assert(ex == "1.23457E+09");
7468 assert(ios.width() == 0);
7469 }
7470 ios.width(25);
7471 left(ios);
7472 {
7473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7474 std::string ex(str, iter.base());
7475 assert(ex == "1.23457E+09**************");
7476 assert(ios.width() == 0);
7477 }
7478 ios.width(25);
7479 right(ios);
7480 {
7481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7482 std::string ex(str, iter.base());
7483 assert(ex == "**************1.23457E+09");
7484 assert(ios.width() == 0);
7485 }
7486 ios.width(25);
7487 internal(ios);
7488 {
7489 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7490 std::string ex(str, iter.base());
7491 assert(ex == "**************1.23457E+09");
7492 assert(ios.width() == 0);
7493 }
7494 }
7495 ios.imbue(lg);
7496 {
7497 ios.width(0);
7498 {
7499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7500 std::string ex(str, iter.base());
7501 assert(ex == "1;23457E+09");
7502 assert(ios.width() == 0);
7503 }
7504 ios.width(25);
7505 left(ios);
7506 {
7507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7508 std::string ex(str, iter.base());
7509 assert(ex == "1;23457E+09**************");
7510 assert(ios.width() == 0);
7511 }
7512 ios.width(25);
7513 right(ios);
7514 {
7515 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7516 std::string ex(str, iter.base());
7517 assert(ex == "**************1;23457E+09");
7518 assert(ios.width() == 0);
7519 }
7520 ios.width(25);
7521 internal(ios);
7522 {
7523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7524 std::string ex(str, iter.base());
7525 assert(ex == "**************1;23457E+09");
7526 assert(ios.width() == 0);
7527 }
7528 }
7529 }
7530 showpoint(ios);
7531 {
7532 ios.imbue(lc);
7533 {
7534 ios.width(0);
7535 {
7536 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7537 std::string ex(str, iter.base());
7538 assert(ex == "1.23457E+09");
7539 assert(ios.width() == 0);
7540 }
7541 ios.width(25);
7542 left(ios);
7543 {
7544 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7545 std::string ex(str, iter.base());
7546 assert(ex == "1.23457E+09**************");
7547 assert(ios.width() == 0);
7548 }
7549 ios.width(25);
7550 right(ios);
7551 {
7552 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7553 std::string ex(str, iter.base());
7554 assert(ex == "**************1.23457E+09");
7555 assert(ios.width() == 0);
7556 }
7557 ios.width(25);
7558 internal(ios);
7559 {
7560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7561 std::string ex(str, iter.base());
7562 assert(ex == "**************1.23457E+09");
7563 assert(ios.width() == 0);
7564 }
7565 }
7566 ios.imbue(lg);
7567 {
7568 ios.width(0);
7569 {
7570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7571 std::string ex(str, iter.base());
7572 assert(ex == "1;23457E+09");
7573 assert(ios.width() == 0);
7574 }
7575 ios.width(25);
7576 left(ios);
7577 {
7578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7579 std::string ex(str, iter.base());
7580 assert(ex == "1;23457E+09**************");
7581 assert(ios.width() == 0);
7582 }
7583 ios.width(25);
7584 right(ios);
7585 {
7586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7587 std::string ex(str, iter.base());
7588 assert(ex == "**************1;23457E+09");
7589 assert(ios.width() == 0);
7590 }
7591 ios.width(25);
7592 internal(ios);
7593 {
7594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7595 std::string ex(str, iter.base());
7596 assert(ex == "**************1;23457E+09");
7597 assert(ios.width() == 0);
7598 }
7599 }
7600 }
7601 }
7602 showpos(ios);
7603 {
7604 noshowpoint(ios);
7605 {
7606 ios.imbue(lc);
7607 {
7608 ios.width(0);
7609 {
7610 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7611 std::string ex(str, iter.base());
7612 assert(ex == "+1.23457E+09");
7613 assert(ios.width() == 0);
7614 }
7615 ios.width(25);
7616 left(ios);
7617 {
7618 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7619 std::string ex(str, iter.base());
7620 assert(ex == "+1.23457E+09*************");
7621 assert(ios.width() == 0);
7622 }
7623 ios.width(25);
7624 right(ios);
7625 {
7626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7627 std::string ex(str, iter.base());
7628 assert(ex == "*************+1.23457E+09");
7629 assert(ios.width() == 0);
7630 }
7631 ios.width(25);
7632 internal(ios);
7633 {
7634 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7635 std::string ex(str, iter.base());
7636 assert(ex == "+*************1.23457E+09");
7637 assert(ios.width() == 0);
7638 }
7639 }
7640 ios.imbue(lg);
7641 {
7642 ios.width(0);
7643 {
7644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7645 std::string ex(str, iter.base());
7646 assert(ex == "+1;23457E+09");
7647 assert(ios.width() == 0);
7648 }
7649 ios.width(25);
7650 left(ios);
7651 {
7652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7653 std::string ex(str, iter.base());
7654 assert(ex == "+1;23457E+09*************");
7655 assert(ios.width() == 0);
7656 }
7657 ios.width(25);
7658 right(ios);
7659 {
7660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7661 std::string ex(str, iter.base());
7662 assert(ex == "*************+1;23457E+09");
7663 assert(ios.width() == 0);
7664 }
7665 ios.width(25);
7666 internal(ios);
7667 {
7668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7669 std::string ex(str, iter.base());
7670 assert(ex == "+*************1;23457E+09");
7671 assert(ios.width() == 0);
7672 }
7673 }
7674 }
7675 showpoint(ios);
7676 {
7677 ios.imbue(lc);
7678 {
7679 ios.width(0);
7680 {
7681 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7682 std::string ex(str, iter.base());
7683 assert(ex == "+1.23457E+09");
7684 assert(ios.width() == 0);
7685 }
7686 ios.width(25);
7687 left(ios);
7688 {
7689 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7690 std::string ex(str, iter.base());
7691 assert(ex == "+1.23457E+09*************");
7692 assert(ios.width() == 0);
7693 }
7694 ios.width(25);
7695 right(ios);
7696 {
7697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7698 std::string ex(str, iter.base());
7699 assert(ex == "*************+1.23457E+09");
7700 assert(ios.width() == 0);
7701 }
7702 ios.width(25);
7703 internal(ios);
7704 {
7705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7706 std::string ex(str, iter.base());
7707 assert(ex == "+*************1.23457E+09");
7708 assert(ios.width() == 0);
7709 }
7710 }
7711 ios.imbue(lg);
7712 {
7713 ios.width(0);
7714 {
7715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7716 std::string ex(str, iter.base());
7717 assert(ex == "+1;23457E+09");
7718 assert(ios.width() == 0);
7719 }
7720 ios.width(25);
7721 left(ios);
7722 {
7723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7724 std::string ex(str, iter.base());
7725 assert(ex == "+1;23457E+09*************");
7726 assert(ios.width() == 0);
7727 }
7728 ios.width(25);
7729 right(ios);
7730 {
7731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7732 std::string ex(str, iter.base());
7733 assert(ex == "*************+1;23457E+09");
7734 assert(ios.width() == 0);
7735 }
7736 ios.width(25);
7737 internal(ios);
7738 {
7739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7740 std::string ex(str, iter.base());
7741 assert(ex == "+*************1;23457E+09");
7742 assert(ios.width() == 0);
7743 }
7744 }
7745 }
7746 }
7747 }
7748 }
7749 ios.precision(16);
7750 {
7751 nouppercase(ios);
7752 {
7753 noshowpos(ios);
7754 {
7755 noshowpoint(ios);
7756 {
7757 ios.imbue(lc);
7758 {
7759 ios.width(0);
7760 {
7761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7762 std::string ex(str, iter.base());
7763 assert(ex == "1234567890.125");
7764 assert(ios.width() == 0);
7765 }
7766 ios.width(25);
7767 left(ios);
7768 {
7769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7770 std::string ex(str, iter.base());
7771 assert(ex == "1234567890.125***********");
7772 assert(ios.width() == 0);
7773 }
7774 ios.width(25);
7775 right(ios);
7776 {
7777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7778 std::string ex(str, iter.base());
7779 assert(ex == "***********1234567890.125");
7780 assert(ios.width() == 0);
7781 }
7782 ios.width(25);
7783 internal(ios);
7784 {
7785 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7786 std::string ex(str, iter.base());
7787 assert(ex == "***********1234567890.125");
7788 assert(ios.width() == 0);
7789 }
7790 }
7791 ios.imbue(lg);
7792 {
7793 ios.width(0);
7794 {
7795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7796 std::string ex(str, iter.base());
7797 assert(ex == "1_234_567_89_0;125");
7798 assert(ios.width() == 0);
7799 }
7800 ios.width(25);
7801 left(ios);
7802 {
7803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7804 std::string ex(str, iter.base());
7805 assert(ex == "1_234_567_89_0;125*******");
7806 assert(ios.width() == 0);
7807 }
7808 ios.width(25);
7809 right(ios);
7810 {
7811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7812 std::string ex(str, iter.base());
7813 assert(ex == "*******1_234_567_89_0;125");
7814 assert(ios.width() == 0);
7815 }
7816 ios.width(25);
7817 internal(ios);
7818 {
7819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7820 std::string ex(str, iter.base());
7821 assert(ex == "*******1_234_567_89_0;125");
7822 assert(ios.width() == 0);
7823 }
7824 }
7825 }
7826 showpoint(ios);
7827 {
7828 ios.imbue(lc);
7829 {
7830 ios.width(0);
7831 {
7832 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7833 std::string ex(str, iter.base());
7834 assert(ex == "1234567890.125000");
7835 assert(ios.width() == 0);
7836 }
7837 ios.width(25);
7838 left(ios);
7839 {
7840 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7841 std::string ex(str, iter.base());
7842 assert(ex == "1234567890.125000********");
7843 assert(ios.width() == 0);
7844 }
7845 ios.width(25);
7846 right(ios);
7847 {
7848 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7849 std::string ex(str, iter.base());
7850 assert(ex == "********1234567890.125000");
7851 assert(ios.width() == 0);
7852 }
7853 ios.width(25);
7854 internal(ios);
7855 {
7856 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7857 std::string ex(str, iter.base());
7858 assert(ex == "********1234567890.125000");
7859 assert(ios.width() == 0);
7860 }
7861 }
7862 ios.imbue(lg);
7863 {
7864 ios.width(0);
7865 {
7866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7867 std::string ex(str, iter.base());
7868 assert(ex == "1_234_567_89_0;125000");
7869 assert(ios.width() == 0);
7870 }
7871 ios.width(25);
7872 left(ios);
7873 {
7874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7875 std::string ex(str, iter.base());
7876 assert(ex == "1_234_567_89_0;125000****");
7877 assert(ios.width() == 0);
7878 }
7879 ios.width(25);
7880 right(ios);
7881 {
7882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7883 std::string ex(str, iter.base());
7884 assert(ex == "****1_234_567_89_0;125000");
7885 assert(ios.width() == 0);
7886 }
7887 ios.width(25);
7888 internal(ios);
7889 {
7890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7891 std::string ex(str, iter.base());
7892 assert(ex == "****1_234_567_89_0;125000");
7893 assert(ios.width() == 0);
7894 }
7895 }
7896 }
7897 }
7898 showpos(ios);
7899 {
7900 noshowpoint(ios);
7901 {
7902 ios.imbue(lc);
7903 {
7904 ios.width(0);
7905 {
7906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7907 std::string ex(str, iter.base());
7908 assert(ex == "+1234567890.125");
7909 assert(ios.width() == 0);
7910 }
7911 ios.width(25);
7912 left(ios);
7913 {
7914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7915 std::string ex(str, iter.base());
7916 assert(ex == "+1234567890.125**********");
7917 assert(ios.width() == 0);
7918 }
7919 ios.width(25);
7920 right(ios);
7921 {
7922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7923 std::string ex(str, iter.base());
7924 assert(ex == "**********+1234567890.125");
7925 assert(ios.width() == 0);
7926 }
7927 ios.width(25);
7928 internal(ios);
7929 {
7930 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7931 std::string ex(str, iter.base());
7932 assert(ex == "+**********1234567890.125");
7933 assert(ios.width() == 0);
7934 }
7935 }
7936 ios.imbue(lg);
7937 {
7938 ios.width(0);
7939 {
7940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7941 std::string ex(str, iter.base());
7942 assert(ex == "+1_234_567_89_0;125");
7943 assert(ios.width() == 0);
7944 }
7945 ios.width(25);
7946 left(ios);
7947 {
7948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7949 std::string ex(str, iter.base());
7950 assert(ex == "+1_234_567_89_0;125******");
7951 assert(ios.width() == 0);
7952 }
7953 ios.width(25);
7954 right(ios);
7955 {
7956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7957 std::string ex(str, iter.base());
7958 assert(ex == "******+1_234_567_89_0;125");
7959 assert(ios.width() == 0);
7960 }
7961 ios.width(25);
7962 internal(ios);
7963 {
7964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7965 std::string ex(str, iter.base());
7966 assert(ex == "+******1_234_567_89_0;125");
7967 assert(ios.width() == 0);
7968 }
7969 }
7970 }
7971 showpoint(ios);
7972 {
7973 ios.imbue(lc);
7974 {
7975 ios.width(0);
7976 {
7977 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7978 std::string ex(str, iter.base());
7979 assert(ex == "+1234567890.125000");
7980 assert(ios.width() == 0);
7981 }
7982 ios.width(25);
7983 left(ios);
7984 {
7985 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7986 std::string ex(str, iter.base());
7987 assert(ex == "+1234567890.125000*******");
7988 assert(ios.width() == 0);
7989 }
7990 ios.width(25);
7991 right(ios);
7992 {
7993 iter = f.put(output_iterator<char*>(str), ios, '*', v);
7994 std::string ex(str, iter.base());
7995 assert(ex == "*******+1234567890.125000");
7996 assert(ios.width() == 0);
7997 }
7998 ios.width(25);
7999 internal(ios);
8000 {
8001 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8002 std::string ex(str, iter.base());
8003 assert(ex == "+*******1234567890.125000");
8004 assert(ios.width() == 0);
8005 }
8006 }
8007 ios.imbue(lg);
8008 {
8009 ios.width(0);
8010 {
8011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8012 std::string ex(str, iter.base());
8013 assert(ex == "+1_234_567_89_0;125000");
8014 assert(ios.width() == 0);
8015 }
8016 ios.width(25);
8017 left(ios);
8018 {
8019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8020 std::string ex(str, iter.base());
8021 assert(ex == "+1_234_567_89_0;125000***");
8022 assert(ios.width() == 0);
8023 }
8024 ios.width(25);
8025 right(ios);
8026 {
8027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8028 std::string ex(str, iter.base());
8029 assert(ex == "***+1_234_567_89_0;125000");
8030 assert(ios.width() == 0);
8031 }
8032 ios.width(25);
8033 internal(ios);
8034 {
8035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8036 std::string ex(str, iter.base());
8037 assert(ex == "+***1_234_567_89_0;125000");
8038 assert(ios.width() == 0);
8039 }
8040 }
8041 }
8042 }
8043 }
8044 uppercase(ios);
8045 {
8046 noshowpos(ios);
8047 {
8048 noshowpoint(ios);
8049 {
8050 ios.imbue(lc);
8051 {
8052 ios.width(0);
8053 {
8054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8055 std::string ex(str, iter.base());
8056 assert(ex == "1234567890.125");
8057 assert(ios.width() == 0);
8058 }
8059 ios.width(25);
8060 left(ios);
8061 {
8062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8063 std::string ex(str, iter.base());
8064 assert(ex == "1234567890.125***********");
8065 assert(ios.width() == 0);
8066 }
8067 ios.width(25);
8068 right(ios);
8069 {
8070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8071 std::string ex(str, iter.base());
8072 assert(ex == "***********1234567890.125");
8073 assert(ios.width() == 0);
8074 }
8075 ios.width(25);
8076 internal(ios);
8077 {
8078 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8079 std::string ex(str, iter.base());
8080 assert(ex == "***********1234567890.125");
8081 assert(ios.width() == 0);
8082 }
8083 }
8084 ios.imbue(lg);
8085 {
8086 ios.width(0);
8087 {
8088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8089 std::string ex(str, iter.base());
8090 assert(ex == "1_234_567_89_0;125");
8091 assert(ios.width() == 0);
8092 }
8093 ios.width(25);
8094 left(ios);
8095 {
8096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8097 std::string ex(str, iter.base());
8098 assert(ex == "1_234_567_89_0;125*******");
8099 assert(ios.width() == 0);
8100 }
8101 ios.width(25);
8102 right(ios);
8103 {
8104 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8105 std::string ex(str, iter.base());
8106 assert(ex == "*******1_234_567_89_0;125");
8107 assert(ios.width() == 0);
8108 }
8109 ios.width(25);
8110 internal(ios);
8111 {
8112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8113 std::string ex(str, iter.base());
8114 assert(ex == "*******1_234_567_89_0;125");
8115 assert(ios.width() == 0);
8116 }
8117 }
8118 }
8119 showpoint(ios);
8120 {
8121 ios.imbue(lc);
8122 {
8123 ios.width(0);
8124 {
8125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8126 std::string ex(str, iter.base());
8127 assert(ex == "1234567890.125000");
8128 assert(ios.width() == 0);
8129 }
8130 ios.width(25);
8131 left(ios);
8132 {
8133 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8134 std::string ex(str, iter.base());
8135 assert(ex == "1234567890.125000********");
8136 assert(ios.width() == 0);
8137 }
8138 ios.width(25);
8139 right(ios);
8140 {
8141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8142 std::string ex(str, iter.base());
8143 assert(ex == "********1234567890.125000");
8144 assert(ios.width() == 0);
8145 }
8146 ios.width(25);
8147 internal(ios);
8148 {
8149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8150 std::string ex(str, iter.base());
8151 assert(ex == "********1234567890.125000");
8152 assert(ios.width() == 0);
8153 }
8154 }
8155 ios.imbue(lg);
8156 {
8157 ios.width(0);
8158 {
8159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8160 std::string ex(str, iter.base());
8161 assert(ex == "1_234_567_89_0;125000");
8162 assert(ios.width() == 0);
8163 }
8164 ios.width(25);
8165 left(ios);
8166 {
8167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8168 std::string ex(str, iter.base());
8169 assert(ex == "1_234_567_89_0;125000****");
8170 assert(ios.width() == 0);
8171 }
8172 ios.width(25);
8173 right(ios);
8174 {
8175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8176 std::string ex(str, iter.base());
8177 assert(ex == "****1_234_567_89_0;125000");
8178 assert(ios.width() == 0);
8179 }
8180 ios.width(25);
8181 internal(ios);
8182 {
8183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8184 std::string ex(str, iter.base());
8185 assert(ex == "****1_234_567_89_0;125000");
8186 assert(ios.width() == 0);
8187 }
8188 }
8189 }
8190 }
8191 showpos(ios);
8192 {
8193 noshowpoint(ios);
8194 {
8195 ios.imbue(lc);
8196 {
8197 ios.width(0);
8198 {
8199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8200 std::string ex(str, iter.base());
8201 assert(ex == "+1234567890.125");
8202 assert(ios.width() == 0);
8203 }
8204 ios.width(25);
8205 left(ios);
8206 {
8207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8208 std::string ex(str, iter.base());
8209 assert(ex == "+1234567890.125**********");
8210 assert(ios.width() == 0);
8211 }
8212 ios.width(25);
8213 right(ios);
8214 {
8215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8216 std::string ex(str, iter.base());
8217 assert(ex == "**********+1234567890.125");
8218 assert(ios.width() == 0);
8219 }
8220 ios.width(25);
8221 internal(ios);
8222 {
8223 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8224 std::string ex(str, iter.base());
8225 assert(ex == "+**********1234567890.125");
8226 assert(ios.width() == 0);
8227 }
8228 }
8229 ios.imbue(lg);
8230 {
8231 ios.width(0);
8232 {
8233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8234 std::string ex(str, iter.base());
8235 assert(ex == "+1_234_567_89_0;125");
8236 assert(ios.width() == 0);
8237 }
8238 ios.width(25);
8239 left(ios);
8240 {
8241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8242 std::string ex(str, iter.base());
8243 assert(ex == "+1_234_567_89_0;125******");
8244 assert(ios.width() == 0);
8245 }
8246 ios.width(25);
8247 right(ios);
8248 {
8249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8250 std::string ex(str, iter.base());
8251 assert(ex == "******+1_234_567_89_0;125");
8252 assert(ios.width() == 0);
8253 }
8254 ios.width(25);
8255 internal(ios);
8256 {
8257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8258 std::string ex(str, iter.base());
8259 assert(ex == "+******1_234_567_89_0;125");
8260 assert(ios.width() == 0);
8261 }
8262 }
8263 }
8264 showpoint(ios);
8265 {
8266 ios.imbue(lc);
8267 {
8268 ios.width(0);
8269 {
8270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8271 std::string ex(str, iter.base());
8272 assert(ex == "+1234567890.125000");
8273 assert(ios.width() == 0);
8274 }
8275 ios.width(25);
8276 left(ios);
8277 {
8278 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8279 std::string ex(str, iter.base());
8280 assert(ex == "+1234567890.125000*******");
8281 assert(ios.width() == 0);
8282 }
8283 ios.width(25);
8284 right(ios);
8285 {
8286 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8287 std::string ex(str, iter.base());
8288 assert(ex == "*******+1234567890.125000");
8289 assert(ios.width() == 0);
8290 }
8291 ios.width(25);
8292 internal(ios);
8293 {
8294 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8295 std::string ex(str, iter.base());
8296 assert(ex == "+*******1234567890.125000");
8297 assert(ios.width() == 0);
8298 }
8299 }
8300 ios.imbue(lg);
8301 {
8302 ios.width(0);
8303 {
8304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8305 std::string ex(str, iter.base());
8306 assert(ex == "+1_234_567_89_0;125000");
8307 assert(ios.width() == 0);
8308 }
8309 ios.width(25);
8310 left(ios);
8311 {
8312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8313 std::string ex(str, iter.base());
8314 assert(ex == "+1_234_567_89_0;125000***");
8315 assert(ios.width() == 0);
8316 }
8317 ios.width(25);
8318 right(ios);
8319 {
8320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8321 std::string ex(str, iter.base());
8322 assert(ex == "***+1_234_567_89_0;125000");
8323 assert(ios.width() == 0);
8324 }
8325 ios.width(25);
8326 internal(ios);
8327 {
8328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8329 std::string ex(str, iter.base());
8330 assert(ex == "+***1_234_567_89_0;125000");
8331 assert(ios.width() == 0);
8332 }
8333 }
8334 }
8335 }
8336 }
8337 }
8338 ios.precision(60);
8339 {
8340 nouppercase(ios);
8341 {
8342 noshowpos(ios);
8343 {
8344 noshowpoint(ios);
8345 {
8346 ios.imbue(lc);
8347 {
8348 ios.width(0);
8349 {
8350 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8351 std::string ex(str, iter.base());
8352 assert(ex == "1234567890.125");
8353 assert(ios.width() == 0);
8354 }
8355 ios.width(25);
8356 left(ios);
8357 {
8358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8359 std::string ex(str, iter.base());
8360 assert(ex == "1234567890.125***********");
8361 assert(ios.width() == 0);
8362 }
8363 ios.width(25);
8364 right(ios);
8365 {
8366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8367 std::string ex(str, iter.base());
8368 assert(ex == "***********1234567890.125");
8369 assert(ios.width() == 0);
8370 }
8371 ios.width(25);
8372 internal(ios);
8373 {
8374 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8375 std::string ex(str, iter.base());
8376 assert(ex == "***********1234567890.125");
8377 assert(ios.width() == 0);
8378 }
8379 }
8380 ios.imbue(lg);
8381 {
8382 ios.width(0);
8383 {
8384 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8385 std::string ex(str, iter.base());
8386 assert(ex == "1_234_567_89_0;125");
8387 assert(ios.width() == 0);
8388 }
8389 ios.width(25);
8390 left(ios);
8391 {
8392 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8393 std::string ex(str, iter.base());
8394 assert(ex == "1_234_567_89_0;125*******");
8395 assert(ios.width() == 0);
8396 }
8397 ios.width(25);
8398 right(ios);
8399 {
8400 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8401 std::string ex(str, iter.base());
8402 assert(ex == "*******1_234_567_89_0;125");
8403 assert(ios.width() == 0);
8404 }
8405 ios.width(25);
8406 internal(ios);
8407 {
8408 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8409 std::string ex(str, iter.base());
8410 assert(ex == "*******1_234_567_89_0;125");
8411 assert(ios.width() == 0);
8412 }
8413 }
8414 }
8415 showpoint(ios);
8416 {
8417 ios.imbue(lc);
8418 {
8419 ios.width(0);
8420 {
8421 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8422 std::string ex(str, iter.base());
8423 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8424 assert(ios.width() == 0);
8425 }
8426 ios.width(25);
8427 left(ios);
8428 {
8429 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8430 std::string ex(str, iter.base());
8431 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8432 assert(ios.width() == 0);
8433 }
8434 ios.width(25);
8435 right(ios);
8436 {
8437 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8438 std::string ex(str, iter.base());
8439 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8440 assert(ios.width() == 0);
8441 }
8442 ios.width(25);
8443 internal(ios);
8444 {
8445 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8446 std::string ex(str, iter.base());
8447 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8448 assert(ios.width() == 0);
8449 }
8450 }
8451 ios.imbue(lg);
8452 {
8453 ios.width(0);
8454 {
8455 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8456 std::string ex(str, iter.base());
8457 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8458 assert(ios.width() == 0);
8459 }
8460 ios.width(25);
8461 left(ios);
8462 {
8463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8464 std::string ex(str, iter.base());
8465 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8466 assert(ios.width() == 0);
8467 }
8468 ios.width(25);
8469 right(ios);
8470 {
8471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8472 std::string ex(str, iter.base());
8473 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8474 assert(ios.width() == 0);
8475 }
8476 ios.width(25);
8477 internal(ios);
8478 {
8479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8480 std::string ex(str, iter.base());
8481 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8482 assert(ios.width() == 0);
8483 }
8484 }
8485 }
8486 }
8487 showpos(ios);
8488 {
8489 noshowpoint(ios);
8490 {
8491 ios.imbue(lc);
8492 {
8493 ios.width(0);
8494 {
8495 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8496 std::string ex(str, iter.base());
8497 assert(ex == "+1234567890.125");
8498 assert(ios.width() == 0);
8499 }
8500 ios.width(25);
8501 left(ios);
8502 {
8503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8504 std::string ex(str, iter.base());
8505 assert(ex == "+1234567890.125**********");
8506 assert(ios.width() == 0);
8507 }
8508 ios.width(25);
8509 right(ios);
8510 {
8511 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8512 std::string ex(str, iter.base());
8513 assert(ex == "**********+1234567890.125");
8514 assert(ios.width() == 0);
8515 }
8516 ios.width(25);
8517 internal(ios);
8518 {
8519 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8520 std::string ex(str, iter.base());
8521 assert(ex == "+**********1234567890.125");
8522 assert(ios.width() == 0);
8523 }
8524 }
8525 ios.imbue(lg);
8526 {
8527 ios.width(0);
8528 {
8529 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8530 std::string ex(str, iter.base());
8531 assert(ex == "+1_234_567_89_0;125");
8532 assert(ios.width() == 0);
8533 }
8534 ios.width(25);
8535 left(ios);
8536 {
8537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8538 std::string ex(str, iter.base());
8539 assert(ex == "+1_234_567_89_0;125******");
8540 assert(ios.width() == 0);
8541 }
8542 ios.width(25);
8543 right(ios);
8544 {
8545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8546 std::string ex(str, iter.base());
8547 assert(ex == "******+1_234_567_89_0;125");
8548 assert(ios.width() == 0);
8549 }
8550 ios.width(25);
8551 internal(ios);
8552 {
8553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8554 std::string ex(str, iter.base());
8555 assert(ex == "+******1_234_567_89_0;125");
8556 assert(ios.width() == 0);
8557 }
8558 }
8559 }
8560 showpoint(ios);
8561 {
8562 ios.imbue(lc);
8563 {
8564 ios.width(0);
8565 {
8566 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8567 std::string ex(str, iter.base());
8568 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8569 assert(ios.width() == 0);
8570 }
8571 ios.width(25);
8572 left(ios);
8573 {
8574 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8575 std::string ex(str, iter.base());
8576 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8577 assert(ios.width() == 0);
8578 }
8579 ios.width(25);
8580 right(ios);
8581 {
8582 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8583 std::string ex(str, iter.base());
8584 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8585 assert(ios.width() == 0);
8586 }
8587 ios.width(25);
8588 internal(ios);
8589 {
8590 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8591 std::string ex(str, iter.base());
8592 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8593 assert(ios.width() == 0);
8594 }
8595 }
8596 ios.imbue(lg);
8597 {
8598 ios.width(0);
8599 {
8600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8601 std::string ex(str, iter.base());
8602 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8603 assert(ios.width() == 0);
8604 }
8605 ios.width(25);
8606 left(ios);
8607 {
8608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8609 std::string ex(str, iter.base());
8610 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8611 assert(ios.width() == 0);
8612 }
8613 ios.width(25);
8614 right(ios);
8615 {
8616 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8617 std::string ex(str, iter.base());
8618 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8619 assert(ios.width() == 0);
8620 }
8621 ios.width(25);
8622 internal(ios);
8623 {
8624 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8625 std::string ex(str, iter.base());
8626 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8627 assert(ios.width() == 0);
8628 }
8629 }
8630 }
8631 }
8632 }
8633 uppercase(ios);
8634 {
8635 noshowpos(ios);
8636 {
8637 noshowpoint(ios);
8638 {
8639 ios.imbue(lc);
8640 {
8641 ios.width(0);
8642 {
8643 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8644 std::string ex(str, iter.base());
8645 assert(ex == "1234567890.125");
8646 assert(ios.width() == 0);
8647 }
8648 ios.width(25);
8649 left(ios);
8650 {
8651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8652 std::string ex(str, iter.base());
8653 assert(ex == "1234567890.125***********");
8654 assert(ios.width() == 0);
8655 }
8656 ios.width(25);
8657 right(ios);
8658 {
8659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8660 std::string ex(str, iter.base());
8661 assert(ex == "***********1234567890.125");
8662 assert(ios.width() == 0);
8663 }
8664 ios.width(25);
8665 internal(ios);
8666 {
8667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8668 std::string ex(str, iter.base());
8669 assert(ex == "***********1234567890.125");
8670 assert(ios.width() == 0);
8671 }
8672 }
8673 ios.imbue(lg);
8674 {
8675 ios.width(0);
8676 {
8677 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8678 std::string ex(str, iter.base());
8679 assert(ex == "1_234_567_89_0;125");
8680 assert(ios.width() == 0);
8681 }
8682 ios.width(25);
8683 left(ios);
8684 {
8685 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8686 std::string ex(str, iter.base());
8687 assert(ex == "1_234_567_89_0;125*******");
8688 assert(ios.width() == 0);
8689 }
8690 ios.width(25);
8691 right(ios);
8692 {
8693 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8694 std::string ex(str, iter.base());
8695 assert(ex == "*******1_234_567_89_0;125");
8696 assert(ios.width() == 0);
8697 }
8698 ios.width(25);
8699 internal(ios);
8700 {
8701 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8702 std::string ex(str, iter.base());
8703 assert(ex == "*******1_234_567_89_0;125");
8704 assert(ios.width() == 0);
8705 }
8706 }
8707 }
8708 showpoint(ios);
8709 {
8710 ios.imbue(lc);
8711 {
8712 ios.width(0);
8713 {
8714 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8715 std::string ex(str, iter.base());
8716 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8717 assert(ios.width() == 0);
8718 }
8719 ios.width(25);
8720 left(ios);
8721 {
8722 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8723 std::string ex(str, iter.base());
8724 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8725 assert(ios.width() == 0);
8726 }
8727 ios.width(25);
8728 right(ios);
8729 {
8730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8731 std::string ex(str, iter.base());
8732 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8733 assert(ios.width() == 0);
8734 }
8735 ios.width(25);
8736 internal(ios);
8737 {
8738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8739 std::string ex(str, iter.base());
8740 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8741 assert(ios.width() == 0);
8742 }
8743 }
8744 ios.imbue(lg);
8745 {
8746 ios.width(0);
8747 {
8748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8749 std::string ex(str, iter.base());
8750 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8751 assert(ios.width() == 0);
8752 }
8753 ios.width(25);
8754 left(ios);
8755 {
8756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8757 std::string ex(str, iter.base());
8758 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8759 assert(ios.width() == 0);
8760 }
8761 ios.width(25);
8762 right(ios);
8763 {
8764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8765 std::string ex(str, iter.base());
8766 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8767 assert(ios.width() == 0);
8768 }
8769 ios.width(25);
8770 internal(ios);
8771 {
8772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8773 std::string ex(str, iter.base());
8774 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8775 assert(ios.width() == 0);
8776 }
8777 }
8778 }
8779 }
8780 showpos(ios);
8781 {
8782 noshowpoint(ios);
8783 {
8784 ios.imbue(lc);
8785 {
8786 ios.width(0);
8787 {
8788 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8789 std::string ex(str, iter.base());
8790 assert(ex == "+1234567890.125");
8791 assert(ios.width() == 0);
8792 }
8793 ios.width(25);
8794 left(ios);
8795 {
8796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8797 std::string ex(str, iter.base());
8798 assert(ex == "+1234567890.125**********");
8799 assert(ios.width() == 0);
8800 }
8801 ios.width(25);
8802 right(ios);
8803 {
8804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8805 std::string ex(str, iter.base());
8806 assert(ex == "**********+1234567890.125");
8807 assert(ios.width() == 0);
8808 }
8809 ios.width(25);
8810 internal(ios);
8811 {
8812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8813 std::string ex(str, iter.base());
8814 assert(ex == "+**********1234567890.125");
8815 assert(ios.width() == 0);
8816 }
8817 }
8818 ios.imbue(lg);
8819 {
8820 ios.width(0);
8821 {
8822 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8823 std::string ex(str, iter.base());
8824 assert(ex == "+1_234_567_89_0;125");
8825 assert(ios.width() == 0);
8826 }
8827 ios.width(25);
8828 left(ios);
8829 {
8830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8831 std::string ex(str, iter.base());
8832 assert(ex == "+1_234_567_89_0;125******");
8833 assert(ios.width() == 0);
8834 }
8835 ios.width(25);
8836 right(ios);
8837 {
8838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8839 std::string ex(str, iter.base());
8840 assert(ex == "******+1_234_567_89_0;125");
8841 assert(ios.width() == 0);
8842 }
8843 ios.width(25);
8844 internal(ios);
8845 {
8846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8847 std::string ex(str, iter.base());
8848 assert(ex == "+******1_234_567_89_0;125");
8849 assert(ios.width() == 0);
8850 }
8851 }
8852 }
8853 showpoint(ios);
8854 {
8855 ios.imbue(lc);
8856 {
8857 ios.width(0);
8858 {
8859 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8860 std::string ex(str, iter.base());
8861 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8862 assert(ios.width() == 0);
8863 }
8864 ios.width(25);
8865 left(ios);
8866 {
8867 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8868 std::string ex(str, iter.base());
8869 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8870 assert(ios.width() == 0);
8871 }
8872 ios.width(25);
8873 right(ios);
8874 {
8875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8876 std::string ex(str, iter.base());
8877 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8878 assert(ios.width() == 0);
8879 }
8880 ios.width(25);
8881 internal(ios);
8882 {
8883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8884 std::string ex(str, iter.base());
8885 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8886 assert(ios.width() == 0);
8887 }
8888 }
8889 ios.imbue(lg);
8890 {
8891 ios.width(0);
8892 {
8893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8894 std::string ex(str, iter.base());
8895 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8896 assert(ios.width() == 0);
8897 }
8898 ios.width(25);
8899 left(ios);
8900 {
8901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8902 std::string ex(str, iter.base());
8903 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8904 assert(ios.width() == 0);
8905 }
8906 ios.width(25);
8907 right(ios);
8908 {
8909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8910 std::string ex(str, iter.base());
8911 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8912 assert(ios.width() == 0);
8913 }
8914 ios.width(25);
8915 internal(ios);
8916 {
8917 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8918 std::string ex(str, iter.base());
8919 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8920 assert(ios.width() == 0);
8921 }
8922 }
8923 }
8924 }
8925 }
8926 }
8927 }
8928 }
8929 }
8930
test4()8931 void test4()
8932 {
8933 char str[200];
8934 output_iterator<char*> iter;
8935 std::locale lc = std::locale::classic();
8936 std::locale lg(lc, new my_numpunct);
8937 const my_facet f(1);
8938 {
8939 long double v = -INFINITY;
8940 std::ios ios(0);
8941 // %g
8942 {
8943 ios.precision(0);
8944 {
8945 nouppercase(ios);
8946 {
8947 noshowpos(ios);
8948 {
8949 noshowpoint(ios);
8950 {
8951 ios.imbue(lc);
8952 {
8953 ios.width(0);
8954 {
8955 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8956 std::string ex(str, iter.base());
8957 assert(ex == "-inf");
8958 assert(ios.width() == 0);
8959 }
8960 ios.width(25);
8961 left(ios);
8962 {
8963 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8964 std::string ex(str, iter.base());
8965 assert(ex == "-inf*********************");
8966 assert(ios.width() == 0);
8967 }
8968 ios.width(25);
8969 right(ios);
8970 {
8971 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8972 std::string ex(str, iter.base());
8973 assert(ex == "*********************-inf");
8974 assert(ios.width() == 0);
8975 }
8976 ios.width(25);
8977 internal(ios);
8978 {
8979 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8980 std::string ex(str, iter.base());
8981 assert(ex == "-*********************inf");
8982 assert(ios.width() == 0);
8983 }
8984 }
8985 ios.imbue(lg);
8986 {
8987 ios.width(0);
8988 {
8989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8990 std::string ex(str, iter.base());
8991 assert(ex == "-inf");
8992 assert(ios.width() == 0);
8993 }
8994 ios.width(25);
8995 left(ios);
8996 {
8997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
8998 std::string ex(str, iter.base());
8999 assert(ex == "-inf*********************");
9000 assert(ios.width() == 0);
9001 }
9002 ios.width(25);
9003 right(ios);
9004 {
9005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9006 std::string ex(str, iter.base());
9007 assert(ex == "*********************-inf");
9008 assert(ios.width() == 0);
9009 }
9010 ios.width(25);
9011 internal(ios);
9012 {
9013 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9014 std::string ex(str, iter.base());
9015 assert(ex == "-*********************inf");
9016 assert(ios.width() == 0);
9017 }
9018 }
9019 }
9020 showpoint(ios);
9021 {
9022 ios.imbue(lc);
9023 {
9024 ios.width(0);
9025 {
9026 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9027 std::string ex(str, iter.base());
9028 assert(ex == "-inf");
9029 assert(ios.width() == 0);
9030 }
9031 ios.width(25);
9032 left(ios);
9033 {
9034 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9035 std::string ex(str, iter.base());
9036 assert(ex == "-inf*********************");
9037 assert(ios.width() == 0);
9038 }
9039 ios.width(25);
9040 right(ios);
9041 {
9042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9043 std::string ex(str, iter.base());
9044 assert(ex == "*********************-inf");
9045 assert(ios.width() == 0);
9046 }
9047 ios.width(25);
9048 internal(ios);
9049 {
9050 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9051 std::string ex(str, iter.base());
9052 assert(ex == "-*********************inf");
9053 assert(ios.width() == 0);
9054 }
9055 }
9056 ios.imbue(lg);
9057 {
9058 ios.width(0);
9059 {
9060 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9061 std::string ex(str, iter.base());
9062 assert(ex == "-inf");
9063 assert(ios.width() == 0);
9064 }
9065 ios.width(25);
9066 left(ios);
9067 {
9068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9069 std::string ex(str, iter.base());
9070 assert(ex == "-inf*********************");
9071 assert(ios.width() == 0);
9072 }
9073 ios.width(25);
9074 right(ios);
9075 {
9076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9077 std::string ex(str, iter.base());
9078 assert(ex == "*********************-inf");
9079 assert(ios.width() == 0);
9080 }
9081 ios.width(25);
9082 internal(ios);
9083 {
9084 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9085 std::string ex(str, iter.base());
9086 assert(ex == "-*********************inf");
9087 assert(ios.width() == 0);
9088 }
9089 }
9090 }
9091 }
9092 showpos(ios);
9093 {
9094 noshowpoint(ios);
9095 {
9096 ios.imbue(lc);
9097 {
9098 ios.width(0);
9099 {
9100 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9101 std::string ex(str, iter.base());
9102 assert(ex == "-inf");
9103 assert(ios.width() == 0);
9104 }
9105 ios.width(25);
9106 left(ios);
9107 {
9108 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9109 std::string ex(str, iter.base());
9110 assert(ex == "-inf*********************");
9111 assert(ios.width() == 0);
9112 }
9113 ios.width(25);
9114 right(ios);
9115 {
9116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9117 std::string ex(str, iter.base());
9118 assert(ex == "*********************-inf");
9119 assert(ios.width() == 0);
9120 }
9121 ios.width(25);
9122 internal(ios);
9123 {
9124 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9125 std::string ex(str, iter.base());
9126 assert(ex == "-*********************inf");
9127 assert(ios.width() == 0);
9128 }
9129 }
9130 ios.imbue(lg);
9131 {
9132 ios.width(0);
9133 {
9134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9135 std::string ex(str, iter.base());
9136 assert(ex == "-inf");
9137 assert(ios.width() == 0);
9138 }
9139 ios.width(25);
9140 left(ios);
9141 {
9142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9143 std::string ex(str, iter.base());
9144 assert(ex == "-inf*********************");
9145 assert(ios.width() == 0);
9146 }
9147 ios.width(25);
9148 right(ios);
9149 {
9150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9151 std::string ex(str, iter.base());
9152 assert(ex == "*********************-inf");
9153 assert(ios.width() == 0);
9154 }
9155 ios.width(25);
9156 internal(ios);
9157 {
9158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9159 std::string ex(str, iter.base());
9160 assert(ex == "-*********************inf");
9161 assert(ios.width() == 0);
9162 }
9163 }
9164 }
9165 showpoint(ios);
9166 {
9167 ios.imbue(lc);
9168 {
9169 ios.width(0);
9170 {
9171 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9172 std::string ex(str, iter.base());
9173 assert(ex == "-inf");
9174 assert(ios.width() == 0);
9175 }
9176 ios.width(25);
9177 left(ios);
9178 {
9179 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9180 std::string ex(str, iter.base());
9181 assert(ex == "-inf*********************");
9182 assert(ios.width() == 0);
9183 }
9184 ios.width(25);
9185 right(ios);
9186 {
9187 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9188 std::string ex(str, iter.base());
9189 assert(ex == "*********************-inf");
9190 assert(ios.width() == 0);
9191 }
9192 ios.width(25);
9193 internal(ios);
9194 {
9195 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9196 std::string ex(str, iter.base());
9197 assert(ex == "-*********************inf");
9198 assert(ios.width() == 0);
9199 }
9200 }
9201 ios.imbue(lg);
9202 {
9203 ios.width(0);
9204 {
9205 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9206 std::string ex(str, iter.base());
9207 assert(ex == "-inf");
9208 assert(ios.width() == 0);
9209 }
9210 ios.width(25);
9211 left(ios);
9212 {
9213 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9214 std::string ex(str, iter.base());
9215 assert(ex == "-inf*********************");
9216 assert(ios.width() == 0);
9217 }
9218 ios.width(25);
9219 right(ios);
9220 {
9221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9222 std::string ex(str, iter.base());
9223 assert(ex == "*********************-inf");
9224 assert(ios.width() == 0);
9225 }
9226 ios.width(25);
9227 internal(ios);
9228 {
9229 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9230 std::string ex(str, iter.base());
9231 assert(ex == "-*********************inf");
9232 assert(ios.width() == 0);
9233 }
9234 }
9235 }
9236 }
9237 }
9238 uppercase(ios);
9239 {
9240 noshowpos(ios);
9241 {
9242 noshowpoint(ios);
9243 {
9244 ios.imbue(lc);
9245 {
9246 ios.width(0);
9247 {
9248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9249 std::string ex(str, iter.base());
9250 assert(ex == "-INF");
9251 assert(ios.width() == 0);
9252 }
9253 ios.width(25);
9254 left(ios);
9255 {
9256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9257 std::string ex(str, iter.base());
9258 assert(ex == "-INF*********************");
9259 assert(ios.width() == 0);
9260 }
9261 ios.width(25);
9262 right(ios);
9263 {
9264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9265 std::string ex(str, iter.base());
9266 assert(ex == "*********************-INF");
9267 assert(ios.width() == 0);
9268 }
9269 ios.width(25);
9270 internal(ios);
9271 {
9272 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9273 std::string ex(str, iter.base());
9274 assert(ex == "-*********************INF");
9275 assert(ios.width() == 0);
9276 }
9277 }
9278 ios.imbue(lg);
9279 {
9280 ios.width(0);
9281 {
9282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9283 std::string ex(str, iter.base());
9284 assert(ex == "-INF");
9285 assert(ios.width() == 0);
9286 }
9287 ios.width(25);
9288 left(ios);
9289 {
9290 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9291 std::string ex(str, iter.base());
9292 assert(ex == "-INF*********************");
9293 assert(ios.width() == 0);
9294 }
9295 ios.width(25);
9296 right(ios);
9297 {
9298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9299 std::string ex(str, iter.base());
9300 assert(ex == "*********************-INF");
9301 assert(ios.width() == 0);
9302 }
9303 ios.width(25);
9304 internal(ios);
9305 {
9306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9307 std::string ex(str, iter.base());
9308 assert(ex == "-*********************INF");
9309 assert(ios.width() == 0);
9310 }
9311 }
9312 }
9313 showpoint(ios);
9314 {
9315 ios.imbue(lc);
9316 {
9317 ios.width(0);
9318 {
9319 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9320 std::string ex(str, iter.base());
9321 assert(ex == "-INF");
9322 assert(ios.width() == 0);
9323 }
9324 ios.width(25);
9325 left(ios);
9326 {
9327 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9328 std::string ex(str, iter.base());
9329 assert(ex == "-INF*********************");
9330 assert(ios.width() == 0);
9331 }
9332 ios.width(25);
9333 right(ios);
9334 {
9335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9336 std::string ex(str, iter.base());
9337 assert(ex == "*********************-INF");
9338 assert(ios.width() == 0);
9339 }
9340 ios.width(25);
9341 internal(ios);
9342 {
9343 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9344 std::string ex(str, iter.base());
9345 assert(ex == "-*********************INF");
9346 assert(ios.width() == 0);
9347 }
9348 }
9349 ios.imbue(lg);
9350 {
9351 ios.width(0);
9352 {
9353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9354 std::string ex(str, iter.base());
9355 assert(ex == "-INF");
9356 assert(ios.width() == 0);
9357 }
9358 ios.width(25);
9359 left(ios);
9360 {
9361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9362 std::string ex(str, iter.base());
9363 assert(ex == "-INF*********************");
9364 assert(ios.width() == 0);
9365 }
9366 ios.width(25);
9367 right(ios);
9368 {
9369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9370 std::string ex(str, iter.base());
9371 assert(ex == "*********************-INF");
9372 assert(ios.width() == 0);
9373 }
9374 ios.width(25);
9375 internal(ios);
9376 {
9377 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9378 std::string ex(str, iter.base());
9379 assert(ex == "-*********************INF");
9380 assert(ios.width() == 0);
9381 }
9382 }
9383 }
9384 }
9385 showpos(ios);
9386 {
9387 noshowpoint(ios);
9388 {
9389 ios.imbue(lc);
9390 {
9391 ios.width(0);
9392 {
9393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9394 std::string ex(str, iter.base());
9395 assert(ex == "-INF");
9396 assert(ios.width() == 0);
9397 }
9398 ios.width(25);
9399 left(ios);
9400 {
9401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9402 std::string ex(str, iter.base());
9403 assert(ex == "-INF*********************");
9404 assert(ios.width() == 0);
9405 }
9406 ios.width(25);
9407 right(ios);
9408 {
9409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9410 std::string ex(str, iter.base());
9411 assert(ex == "*********************-INF");
9412 assert(ios.width() == 0);
9413 }
9414 ios.width(25);
9415 internal(ios);
9416 {
9417 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9418 std::string ex(str, iter.base());
9419 assert(ex == "-*********************INF");
9420 assert(ios.width() == 0);
9421 }
9422 }
9423 ios.imbue(lg);
9424 {
9425 ios.width(0);
9426 {
9427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9428 std::string ex(str, iter.base());
9429 assert(ex == "-INF");
9430 assert(ios.width() == 0);
9431 }
9432 ios.width(25);
9433 left(ios);
9434 {
9435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9436 std::string ex(str, iter.base());
9437 assert(ex == "-INF*********************");
9438 assert(ios.width() == 0);
9439 }
9440 ios.width(25);
9441 right(ios);
9442 {
9443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9444 std::string ex(str, iter.base());
9445 assert(ex == "*********************-INF");
9446 assert(ios.width() == 0);
9447 }
9448 ios.width(25);
9449 internal(ios);
9450 {
9451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9452 std::string ex(str, iter.base());
9453 assert(ex == "-*********************INF");
9454 assert(ios.width() == 0);
9455 }
9456 }
9457 }
9458 showpoint(ios);
9459 {
9460 ios.imbue(lc);
9461 {
9462 ios.width(0);
9463 {
9464 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9465 std::string ex(str, iter.base());
9466 assert(ex == "-INF");
9467 assert(ios.width() == 0);
9468 }
9469 ios.width(25);
9470 left(ios);
9471 {
9472 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9473 std::string ex(str, iter.base());
9474 assert(ex == "-INF*********************");
9475 assert(ios.width() == 0);
9476 }
9477 ios.width(25);
9478 right(ios);
9479 {
9480 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9481 std::string ex(str, iter.base());
9482 assert(ex == "*********************-INF");
9483 assert(ios.width() == 0);
9484 }
9485 ios.width(25);
9486 internal(ios);
9487 {
9488 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9489 std::string ex(str, iter.base());
9490 assert(ex == "-*********************INF");
9491 assert(ios.width() == 0);
9492 }
9493 }
9494 ios.imbue(lg);
9495 {
9496 ios.width(0);
9497 {
9498 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9499 std::string ex(str, iter.base());
9500 assert(ex == "-INF");
9501 assert(ios.width() == 0);
9502 }
9503 ios.width(25);
9504 left(ios);
9505 {
9506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9507 std::string ex(str, iter.base());
9508 assert(ex == "-INF*********************");
9509 assert(ios.width() == 0);
9510 }
9511 ios.width(25);
9512 right(ios);
9513 {
9514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9515 std::string ex(str, iter.base());
9516 assert(ex == "*********************-INF");
9517 assert(ios.width() == 0);
9518 }
9519 ios.width(25);
9520 internal(ios);
9521 {
9522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9523 std::string ex(str, iter.base());
9524 assert(ex == "-*********************INF");
9525 assert(ios.width() == 0);
9526 }
9527 }
9528 }
9529 }
9530 }
9531 }
9532 ios.precision(1);
9533 {
9534 nouppercase(ios);
9535 {
9536 noshowpos(ios);
9537 {
9538 noshowpoint(ios);
9539 {
9540 ios.imbue(lc);
9541 {
9542 ios.width(0);
9543 {
9544 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9545 std::string ex(str, iter.base());
9546 assert(ex == "-inf");
9547 assert(ios.width() == 0);
9548 }
9549 ios.width(25);
9550 left(ios);
9551 {
9552 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9553 std::string ex(str, iter.base());
9554 assert(ex == "-inf*********************");
9555 assert(ios.width() == 0);
9556 }
9557 ios.width(25);
9558 right(ios);
9559 {
9560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9561 std::string ex(str, iter.base());
9562 assert(ex == "*********************-inf");
9563 assert(ios.width() == 0);
9564 }
9565 ios.width(25);
9566 internal(ios);
9567 {
9568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9569 std::string ex(str, iter.base());
9570 assert(ex == "-*********************inf");
9571 assert(ios.width() == 0);
9572 }
9573 }
9574 ios.imbue(lg);
9575 {
9576 ios.width(0);
9577 {
9578 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9579 std::string ex(str, iter.base());
9580 assert(ex == "-inf");
9581 assert(ios.width() == 0);
9582 }
9583 ios.width(25);
9584 left(ios);
9585 {
9586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9587 std::string ex(str, iter.base());
9588 assert(ex == "-inf*********************");
9589 assert(ios.width() == 0);
9590 }
9591 ios.width(25);
9592 right(ios);
9593 {
9594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9595 std::string ex(str, iter.base());
9596 assert(ex == "*********************-inf");
9597 assert(ios.width() == 0);
9598 }
9599 ios.width(25);
9600 internal(ios);
9601 {
9602 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9603 std::string ex(str, iter.base());
9604 assert(ex == "-*********************inf");
9605 assert(ios.width() == 0);
9606 }
9607 }
9608 }
9609 showpoint(ios);
9610 {
9611 ios.imbue(lc);
9612 {
9613 ios.width(0);
9614 {
9615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9616 std::string ex(str, iter.base());
9617 assert(ex == "-inf");
9618 assert(ios.width() == 0);
9619 }
9620 ios.width(25);
9621 left(ios);
9622 {
9623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9624 std::string ex(str, iter.base());
9625 assert(ex == "-inf*********************");
9626 assert(ios.width() == 0);
9627 }
9628 ios.width(25);
9629 right(ios);
9630 {
9631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9632 std::string ex(str, iter.base());
9633 assert(ex == "*********************-inf");
9634 assert(ios.width() == 0);
9635 }
9636 ios.width(25);
9637 internal(ios);
9638 {
9639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9640 std::string ex(str, iter.base());
9641 assert(ex == "-*********************inf");
9642 assert(ios.width() == 0);
9643 }
9644 }
9645 ios.imbue(lg);
9646 {
9647 ios.width(0);
9648 {
9649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9650 std::string ex(str, iter.base());
9651 assert(ex == "-inf");
9652 assert(ios.width() == 0);
9653 }
9654 ios.width(25);
9655 left(ios);
9656 {
9657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9658 std::string ex(str, iter.base());
9659 assert(ex == "-inf*********************");
9660 assert(ios.width() == 0);
9661 }
9662 ios.width(25);
9663 right(ios);
9664 {
9665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9666 std::string ex(str, iter.base());
9667 assert(ex == "*********************-inf");
9668 assert(ios.width() == 0);
9669 }
9670 ios.width(25);
9671 internal(ios);
9672 {
9673 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9674 std::string ex(str, iter.base());
9675 assert(ex == "-*********************inf");
9676 assert(ios.width() == 0);
9677 }
9678 }
9679 }
9680 }
9681 showpos(ios);
9682 {
9683 noshowpoint(ios);
9684 {
9685 ios.imbue(lc);
9686 {
9687 ios.width(0);
9688 {
9689 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9690 std::string ex(str, iter.base());
9691 assert(ex == "-inf");
9692 assert(ios.width() == 0);
9693 }
9694 ios.width(25);
9695 left(ios);
9696 {
9697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9698 std::string ex(str, iter.base());
9699 assert(ex == "-inf*********************");
9700 assert(ios.width() == 0);
9701 }
9702 ios.width(25);
9703 right(ios);
9704 {
9705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9706 std::string ex(str, iter.base());
9707 assert(ex == "*********************-inf");
9708 assert(ios.width() == 0);
9709 }
9710 ios.width(25);
9711 internal(ios);
9712 {
9713 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9714 std::string ex(str, iter.base());
9715 assert(ex == "-*********************inf");
9716 assert(ios.width() == 0);
9717 }
9718 }
9719 ios.imbue(lg);
9720 {
9721 ios.width(0);
9722 {
9723 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9724 std::string ex(str, iter.base());
9725 assert(ex == "-inf");
9726 assert(ios.width() == 0);
9727 }
9728 ios.width(25);
9729 left(ios);
9730 {
9731 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9732 std::string ex(str, iter.base());
9733 assert(ex == "-inf*********************");
9734 assert(ios.width() == 0);
9735 }
9736 ios.width(25);
9737 right(ios);
9738 {
9739 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9740 std::string ex(str, iter.base());
9741 assert(ex == "*********************-inf");
9742 assert(ios.width() == 0);
9743 }
9744 ios.width(25);
9745 internal(ios);
9746 {
9747 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9748 std::string ex(str, iter.base());
9749 assert(ex == "-*********************inf");
9750 assert(ios.width() == 0);
9751 }
9752 }
9753 }
9754 showpoint(ios);
9755 {
9756 ios.imbue(lc);
9757 {
9758 ios.width(0);
9759 {
9760 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9761 std::string ex(str, iter.base());
9762 assert(ex == "-inf");
9763 assert(ios.width() == 0);
9764 }
9765 ios.width(25);
9766 left(ios);
9767 {
9768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9769 std::string ex(str, iter.base());
9770 assert(ex == "-inf*********************");
9771 assert(ios.width() == 0);
9772 }
9773 ios.width(25);
9774 right(ios);
9775 {
9776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9777 std::string ex(str, iter.base());
9778 assert(ex == "*********************-inf");
9779 assert(ios.width() == 0);
9780 }
9781 ios.width(25);
9782 internal(ios);
9783 {
9784 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9785 std::string ex(str, iter.base());
9786 assert(ex == "-*********************inf");
9787 assert(ios.width() == 0);
9788 }
9789 }
9790 ios.imbue(lg);
9791 {
9792 ios.width(0);
9793 {
9794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9795 std::string ex(str, iter.base());
9796 assert(ex == "-inf");
9797 assert(ios.width() == 0);
9798 }
9799 ios.width(25);
9800 left(ios);
9801 {
9802 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9803 std::string ex(str, iter.base());
9804 assert(ex == "-inf*********************");
9805 assert(ios.width() == 0);
9806 }
9807 ios.width(25);
9808 right(ios);
9809 {
9810 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9811 std::string ex(str, iter.base());
9812 assert(ex == "*********************-inf");
9813 assert(ios.width() == 0);
9814 }
9815 ios.width(25);
9816 internal(ios);
9817 {
9818 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9819 std::string ex(str, iter.base());
9820 assert(ex == "-*********************inf");
9821 assert(ios.width() == 0);
9822 }
9823 }
9824 }
9825 }
9826 }
9827 uppercase(ios);
9828 {
9829 noshowpos(ios);
9830 {
9831 noshowpoint(ios);
9832 {
9833 ios.imbue(lc);
9834 {
9835 ios.width(0);
9836 {
9837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9838 std::string ex(str, iter.base());
9839 assert(ex == "-INF");
9840 assert(ios.width() == 0);
9841 }
9842 ios.width(25);
9843 left(ios);
9844 {
9845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9846 std::string ex(str, iter.base());
9847 assert(ex == "-INF*********************");
9848 assert(ios.width() == 0);
9849 }
9850 ios.width(25);
9851 right(ios);
9852 {
9853 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9854 std::string ex(str, iter.base());
9855 assert(ex == "*********************-INF");
9856 assert(ios.width() == 0);
9857 }
9858 ios.width(25);
9859 internal(ios);
9860 {
9861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9862 std::string ex(str, iter.base());
9863 assert(ex == "-*********************INF");
9864 assert(ios.width() == 0);
9865 }
9866 }
9867 ios.imbue(lg);
9868 {
9869 ios.width(0);
9870 {
9871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9872 std::string ex(str, iter.base());
9873 assert(ex == "-INF");
9874 assert(ios.width() == 0);
9875 }
9876 ios.width(25);
9877 left(ios);
9878 {
9879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9880 std::string ex(str, iter.base());
9881 assert(ex == "-INF*********************");
9882 assert(ios.width() == 0);
9883 }
9884 ios.width(25);
9885 right(ios);
9886 {
9887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9888 std::string ex(str, iter.base());
9889 assert(ex == "*********************-INF");
9890 assert(ios.width() == 0);
9891 }
9892 ios.width(25);
9893 internal(ios);
9894 {
9895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9896 std::string ex(str, iter.base());
9897 assert(ex == "-*********************INF");
9898 assert(ios.width() == 0);
9899 }
9900 }
9901 }
9902 showpoint(ios);
9903 {
9904 ios.imbue(lc);
9905 {
9906 ios.width(0);
9907 {
9908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9909 std::string ex(str, iter.base());
9910 assert(ex == "-INF");
9911 assert(ios.width() == 0);
9912 }
9913 ios.width(25);
9914 left(ios);
9915 {
9916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9917 std::string ex(str, iter.base());
9918 assert(ex == "-INF*********************");
9919 assert(ios.width() == 0);
9920 }
9921 ios.width(25);
9922 right(ios);
9923 {
9924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9925 std::string ex(str, iter.base());
9926 assert(ex == "*********************-INF");
9927 assert(ios.width() == 0);
9928 }
9929 ios.width(25);
9930 internal(ios);
9931 {
9932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9933 std::string ex(str, iter.base());
9934 assert(ex == "-*********************INF");
9935 assert(ios.width() == 0);
9936 }
9937 }
9938 ios.imbue(lg);
9939 {
9940 ios.width(0);
9941 {
9942 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9943 std::string ex(str, iter.base());
9944 assert(ex == "-INF");
9945 assert(ios.width() == 0);
9946 }
9947 ios.width(25);
9948 left(ios);
9949 {
9950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9951 std::string ex(str, iter.base());
9952 assert(ex == "-INF*********************");
9953 assert(ios.width() == 0);
9954 }
9955 ios.width(25);
9956 right(ios);
9957 {
9958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9959 std::string ex(str, iter.base());
9960 assert(ex == "*********************-INF");
9961 assert(ios.width() == 0);
9962 }
9963 ios.width(25);
9964 internal(ios);
9965 {
9966 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9967 std::string ex(str, iter.base());
9968 assert(ex == "-*********************INF");
9969 assert(ios.width() == 0);
9970 }
9971 }
9972 }
9973 }
9974 showpos(ios);
9975 {
9976 noshowpoint(ios);
9977 {
9978 ios.imbue(lc);
9979 {
9980 ios.width(0);
9981 {
9982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9983 std::string ex(str, iter.base());
9984 assert(ex == "-INF");
9985 assert(ios.width() == 0);
9986 }
9987 ios.width(25);
9988 left(ios);
9989 {
9990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9991 std::string ex(str, iter.base());
9992 assert(ex == "-INF*********************");
9993 assert(ios.width() == 0);
9994 }
9995 ios.width(25);
9996 right(ios);
9997 {
9998 iter = f.put(output_iterator<char*>(str), ios, '*', v);
9999 std::string ex(str, iter.base());
10000 assert(ex == "*********************-INF");
10001 assert(ios.width() == 0);
10002 }
10003 ios.width(25);
10004 internal(ios);
10005 {
10006 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10007 std::string ex(str, iter.base());
10008 assert(ex == "-*********************INF");
10009 assert(ios.width() == 0);
10010 }
10011 }
10012 ios.imbue(lg);
10013 {
10014 ios.width(0);
10015 {
10016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10017 std::string ex(str, iter.base());
10018 assert(ex == "-INF");
10019 assert(ios.width() == 0);
10020 }
10021 ios.width(25);
10022 left(ios);
10023 {
10024 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10025 std::string ex(str, iter.base());
10026 assert(ex == "-INF*********************");
10027 assert(ios.width() == 0);
10028 }
10029 ios.width(25);
10030 right(ios);
10031 {
10032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10033 std::string ex(str, iter.base());
10034 assert(ex == "*********************-INF");
10035 assert(ios.width() == 0);
10036 }
10037 ios.width(25);
10038 internal(ios);
10039 {
10040 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10041 std::string ex(str, iter.base());
10042 assert(ex == "-*********************INF");
10043 assert(ios.width() == 0);
10044 }
10045 }
10046 }
10047 showpoint(ios);
10048 {
10049 ios.imbue(lc);
10050 {
10051 ios.width(0);
10052 {
10053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10054 std::string ex(str, iter.base());
10055 assert(ex == "-INF");
10056 assert(ios.width() == 0);
10057 }
10058 ios.width(25);
10059 left(ios);
10060 {
10061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10062 std::string ex(str, iter.base());
10063 assert(ex == "-INF*********************");
10064 assert(ios.width() == 0);
10065 }
10066 ios.width(25);
10067 right(ios);
10068 {
10069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10070 std::string ex(str, iter.base());
10071 assert(ex == "*********************-INF");
10072 assert(ios.width() == 0);
10073 }
10074 ios.width(25);
10075 internal(ios);
10076 {
10077 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10078 std::string ex(str, iter.base());
10079 assert(ex == "-*********************INF");
10080 assert(ios.width() == 0);
10081 }
10082 }
10083 ios.imbue(lg);
10084 {
10085 ios.width(0);
10086 {
10087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10088 std::string ex(str, iter.base());
10089 assert(ex == "-INF");
10090 assert(ios.width() == 0);
10091 }
10092 ios.width(25);
10093 left(ios);
10094 {
10095 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10096 std::string ex(str, iter.base());
10097 assert(ex == "-INF*********************");
10098 assert(ios.width() == 0);
10099 }
10100 ios.width(25);
10101 right(ios);
10102 {
10103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10104 std::string ex(str, iter.base());
10105 assert(ex == "*********************-INF");
10106 assert(ios.width() == 0);
10107 }
10108 ios.width(25);
10109 internal(ios);
10110 {
10111 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10112 std::string ex(str, iter.base());
10113 assert(ex == "-*********************INF");
10114 assert(ios.width() == 0);
10115 }
10116 }
10117 }
10118 }
10119 }
10120 }
10121 ios.precision(6);
10122 {
10123 nouppercase(ios);
10124 {
10125 noshowpos(ios);
10126 {
10127 noshowpoint(ios);
10128 {
10129 ios.imbue(lc);
10130 {
10131 ios.width(0);
10132 {
10133 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10134 std::string ex(str, iter.base());
10135 assert(ex == "-inf");
10136 assert(ios.width() == 0);
10137 }
10138 ios.width(25);
10139 left(ios);
10140 {
10141 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10142 std::string ex(str, iter.base());
10143 assert(ex == "-inf*********************");
10144 assert(ios.width() == 0);
10145 }
10146 ios.width(25);
10147 right(ios);
10148 {
10149 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10150 std::string ex(str, iter.base());
10151 assert(ex == "*********************-inf");
10152 assert(ios.width() == 0);
10153 }
10154 ios.width(25);
10155 internal(ios);
10156 {
10157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10158 std::string ex(str, iter.base());
10159 assert(ex == "-*********************inf");
10160 assert(ios.width() == 0);
10161 }
10162 }
10163 ios.imbue(lg);
10164 {
10165 ios.width(0);
10166 {
10167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10168 std::string ex(str, iter.base());
10169 assert(ex == "-inf");
10170 assert(ios.width() == 0);
10171 }
10172 ios.width(25);
10173 left(ios);
10174 {
10175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10176 std::string ex(str, iter.base());
10177 assert(ex == "-inf*********************");
10178 assert(ios.width() == 0);
10179 }
10180 ios.width(25);
10181 right(ios);
10182 {
10183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10184 std::string ex(str, iter.base());
10185 assert(ex == "*********************-inf");
10186 assert(ios.width() == 0);
10187 }
10188 ios.width(25);
10189 internal(ios);
10190 {
10191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10192 std::string ex(str, iter.base());
10193 assert(ex == "-*********************inf");
10194 assert(ios.width() == 0);
10195 }
10196 }
10197 }
10198 showpoint(ios);
10199 {
10200 ios.imbue(lc);
10201 {
10202 ios.width(0);
10203 {
10204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10205 std::string ex(str, iter.base());
10206 assert(ex == "-inf");
10207 assert(ios.width() == 0);
10208 }
10209 ios.width(25);
10210 left(ios);
10211 {
10212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10213 std::string ex(str, iter.base());
10214 assert(ex == "-inf*********************");
10215 assert(ios.width() == 0);
10216 }
10217 ios.width(25);
10218 right(ios);
10219 {
10220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10221 std::string ex(str, iter.base());
10222 assert(ex == "*********************-inf");
10223 assert(ios.width() == 0);
10224 }
10225 ios.width(25);
10226 internal(ios);
10227 {
10228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10229 std::string ex(str, iter.base());
10230 assert(ex == "-*********************inf");
10231 assert(ios.width() == 0);
10232 }
10233 }
10234 ios.imbue(lg);
10235 {
10236 ios.width(0);
10237 {
10238 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10239 std::string ex(str, iter.base());
10240 assert(ex == "-inf");
10241 assert(ios.width() == 0);
10242 }
10243 ios.width(25);
10244 left(ios);
10245 {
10246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10247 std::string ex(str, iter.base());
10248 assert(ex == "-inf*********************");
10249 assert(ios.width() == 0);
10250 }
10251 ios.width(25);
10252 right(ios);
10253 {
10254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10255 std::string ex(str, iter.base());
10256 assert(ex == "*********************-inf");
10257 assert(ios.width() == 0);
10258 }
10259 ios.width(25);
10260 internal(ios);
10261 {
10262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10263 std::string ex(str, iter.base());
10264 assert(ex == "-*********************inf");
10265 assert(ios.width() == 0);
10266 }
10267 }
10268 }
10269 }
10270 showpos(ios);
10271 {
10272 noshowpoint(ios);
10273 {
10274 ios.imbue(lc);
10275 {
10276 ios.width(0);
10277 {
10278 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10279 std::string ex(str, iter.base());
10280 assert(ex == "-inf");
10281 assert(ios.width() == 0);
10282 }
10283 ios.width(25);
10284 left(ios);
10285 {
10286 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10287 std::string ex(str, iter.base());
10288 assert(ex == "-inf*********************");
10289 assert(ios.width() == 0);
10290 }
10291 ios.width(25);
10292 right(ios);
10293 {
10294 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10295 std::string ex(str, iter.base());
10296 assert(ex == "*********************-inf");
10297 assert(ios.width() == 0);
10298 }
10299 ios.width(25);
10300 internal(ios);
10301 {
10302 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10303 std::string ex(str, iter.base());
10304 assert(ex == "-*********************inf");
10305 assert(ios.width() == 0);
10306 }
10307 }
10308 ios.imbue(lg);
10309 {
10310 ios.width(0);
10311 {
10312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10313 std::string ex(str, iter.base());
10314 assert(ex == "-inf");
10315 assert(ios.width() == 0);
10316 }
10317 ios.width(25);
10318 left(ios);
10319 {
10320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10321 std::string ex(str, iter.base());
10322 assert(ex == "-inf*********************");
10323 assert(ios.width() == 0);
10324 }
10325 ios.width(25);
10326 right(ios);
10327 {
10328 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10329 std::string ex(str, iter.base());
10330 assert(ex == "*********************-inf");
10331 assert(ios.width() == 0);
10332 }
10333 ios.width(25);
10334 internal(ios);
10335 {
10336 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10337 std::string ex(str, iter.base());
10338 assert(ex == "-*********************inf");
10339 assert(ios.width() == 0);
10340 }
10341 }
10342 }
10343 showpoint(ios);
10344 {
10345 ios.imbue(lc);
10346 {
10347 ios.width(0);
10348 {
10349 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10350 std::string ex(str, iter.base());
10351 assert(ex == "-inf");
10352 assert(ios.width() == 0);
10353 }
10354 ios.width(25);
10355 left(ios);
10356 {
10357 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10358 std::string ex(str, iter.base());
10359 assert(ex == "-inf*********************");
10360 assert(ios.width() == 0);
10361 }
10362 ios.width(25);
10363 right(ios);
10364 {
10365 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10366 std::string ex(str, iter.base());
10367 assert(ex == "*********************-inf");
10368 assert(ios.width() == 0);
10369 }
10370 ios.width(25);
10371 internal(ios);
10372 {
10373 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10374 std::string ex(str, iter.base());
10375 assert(ex == "-*********************inf");
10376 assert(ios.width() == 0);
10377 }
10378 }
10379 ios.imbue(lg);
10380 {
10381 ios.width(0);
10382 {
10383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10384 std::string ex(str, iter.base());
10385 assert(ex == "-inf");
10386 assert(ios.width() == 0);
10387 }
10388 ios.width(25);
10389 left(ios);
10390 {
10391 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10392 std::string ex(str, iter.base());
10393 assert(ex == "-inf*********************");
10394 assert(ios.width() == 0);
10395 }
10396 ios.width(25);
10397 right(ios);
10398 {
10399 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10400 std::string ex(str, iter.base());
10401 assert(ex == "*********************-inf");
10402 assert(ios.width() == 0);
10403 }
10404 ios.width(25);
10405 internal(ios);
10406 {
10407 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10408 std::string ex(str, iter.base());
10409 assert(ex == "-*********************inf");
10410 assert(ios.width() == 0);
10411 }
10412 }
10413 }
10414 }
10415 }
10416 uppercase(ios);
10417 {
10418 noshowpos(ios);
10419 {
10420 noshowpoint(ios);
10421 {
10422 ios.imbue(lc);
10423 {
10424 ios.width(0);
10425 {
10426 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10427 std::string ex(str, iter.base());
10428 assert(ex == "-INF");
10429 assert(ios.width() == 0);
10430 }
10431 ios.width(25);
10432 left(ios);
10433 {
10434 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10435 std::string ex(str, iter.base());
10436 assert(ex == "-INF*********************");
10437 assert(ios.width() == 0);
10438 }
10439 ios.width(25);
10440 right(ios);
10441 {
10442 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10443 std::string ex(str, iter.base());
10444 assert(ex == "*********************-INF");
10445 assert(ios.width() == 0);
10446 }
10447 ios.width(25);
10448 internal(ios);
10449 {
10450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10451 std::string ex(str, iter.base());
10452 assert(ex == "-*********************INF");
10453 assert(ios.width() == 0);
10454 }
10455 }
10456 ios.imbue(lg);
10457 {
10458 ios.width(0);
10459 {
10460 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10461 std::string ex(str, iter.base());
10462 assert(ex == "-INF");
10463 assert(ios.width() == 0);
10464 }
10465 ios.width(25);
10466 left(ios);
10467 {
10468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10469 std::string ex(str, iter.base());
10470 assert(ex == "-INF*********************");
10471 assert(ios.width() == 0);
10472 }
10473 ios.width(25);
10474 right(ios);
10475 {
10476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10477 std::string ex(str, iter.base());
10478 assert(ex == "*********************-INF");
10479 assert(ios.width() == 0);
10480 }
10481 ios.width(25);
10482 internal(ios);
10483 {
10484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10485 std::string ex(str, iter.base());
10486 assert(ex == "-*********************INF");
10487 assert(ios.width() == 0);
10488 }
10489 }
10490 }
10491 showpoint(ios);
10492 {
10493 ios.imbue(lc);
10494 {
10495 ios.width(0);
10496 {
10497 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10498 std::string ex(str, iter.base());
10499 assert(ex == "-INF");
10500 assert(ios.width() == 0);
10501 }
10502 ios.width(25);
10503 left(ios);
10504 {
10505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10506 std::string ex(str, iter.base());
10507 assert(ex == "-INF*********************");
10508 assert(ios.width() == 0);
10509 }
10510 ios.width(25);
10511 right(ios);
10512 {
10513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10514 std::string ex(str, iter.base());
10515 assert(ex == "*********************-INF");
10516 assert(ios.width() == 0);
10517 }
10518 ios.width(25);
10519 internal(ios);
10520 {
10521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10522 std::string ex(str, iter.base());
10523 assert(ex == "-*********************INF");
10524 assert(ios.width() == 0);
10525 }
10526 }
10527 ios.imbue(lg);
10528 {
10529 ios.width(0);
10530 {
10531 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10532 std::string ex(str, iter.base());
10533 assert(ex == "-INF");
10534 assert(ios.width() == 0);
10535 }
10536 ios.width(25);
10537 left(ios);
10538 {
10539 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10540 std::string ex(str, iter.base());
10541 assert(ex == "-INF*********************");
10542 assert(ios.width() == 0);
10543 }
10544 ios.width(25);
10545 right(ios);
10546 {
10547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10548 std::string ex(str, iter.base());
10549 assert(ex == "*********************-INF");
10550 assert(ios.width() == 0);
10551 }
10552 ios.width(25);
10553 internal(ios);
10554 {
10555 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10556 std::string ex(str, iter.base());
10557 assert(ex == "-*********************INF");
10558 assert(ios.width() == 0);
10559 }
10560 }
10561 }
10562 }
10563 showpos(ios);
10564 {
10565 noshowpoint(ios);
10566 {
10567 ios.imbue(lc);
10568 {
10569 ios.width(0);
10570 {
10571 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10572 std::string ex(str, iter.base());
10573 assert(ex == "-INF");
10574 assert(ios.width() == 0);
10575 }
10576 ios.width(25);
10577 left(ios);
10578 {
10579 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10580 std::string ex(str, iter.base());
10581 assert(ex == "-INF*********************");
10582 assert(ios.width() == 0);
10583 }
10584 ios.width(25);
10585 right(ios);
10586 {
10587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10588 std::string ex(str, iter.base());
10589 assert(ex == "*********************-INF");
10590 assert(ios.width() == 0);
10591 }
10592 ios.width(25);
10593 internal(ios);
10594 {
10595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10596 std::string ex(str, iter.base());
10597 assert(ex == "-*********************INF");
10598 assert(ios.width() == 0);
10599 }
10600 }
10601 ios.imbue(lg);
10602 {
10603 ios.width(0);
10604 {
10605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10606 std::string ex(str, iter.base());
10607 assert(ex == "-INF");
10608 assert(ios.width() == 0);
10609 }
10610 ios.width(25);
10611 left(ios);
10612 {
10613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10614 std::string ex(str, iter.base());
10615 assert(ex == "-INF*********************");
10616 assert(ios.width() == 0);
10617 }
10618 ios.width(25);
10619 right(ios);
10620 {
10621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10622 std::string ex(str, iter.base());
10623 assert(ex == "*********************-INF");
10624 assert(ios.width() == 0);
10625 }
10626 ios.width(25);
10627 internal(ios);
10628 {
10629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10630 std::string ex(str, iter.base());
10631 assert(ex == "-*********************INF");
10632 assert(ios.width() == 0);
10633 }
10634 }
10635 }
10636 showpoint(ios);
10637 {
10638 ios.imbue(lc);
10639 {
10640 ios.width(0);
10641 {
10642 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10643 std::string ex(str, iter.base());
10644 assert(ex == "-INF");
10645 assert(ios.width() == 0);
10646 }
10647 ios.width(25);
10648 left(ios);
10649 {
10650 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10651 std::string ex(str, iter.base());
10652 assert(ex == "-INF*********************");
10653 assert(ios.width() == 0);
10654 }
10655 ios.width(25);
10656 right(ios);
10657 {
10658 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10659 std::string ex(str, iter.base());
10660 assert(ex == "*********************-INF");
10661 assert(ios.width() == 0);
10662 }
10663 ios.width(25);
10664 internal(ios);
10665 {
10666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10667 std::string ex(str, iter.base());
10668 assert(ex == "-*********************INF");
10669 assert(ios.width() == 0);
10670 }
10671 }
10672 ios.imbue(lg);
10673 {
10674 ios.width(0);
10675 {
10676 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10677 std::string ex(str, iter.base());
10678 assert(ex == "-INF");
10679 assert(ios.width() == 0);
10680 }
10681 ios.width(25);
10682 left(ios);
10683 {
10684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10685 std::string ex(str, iter.base());
10686 assert(ex == "-INF*********************");
10687 assert(ios.width() == 0);
10688 }
10689 ios.width(25);
10690 right(ios);
10691 {
10692 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10693 std::string ex(str, iter.base());
10694 assert(ex == "*********************-INF");
10695 assert(ios.width() == 0);
10696 }
10697 ios.width(25);
10698 internal(ios);
10699 {
10700 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10701 std::string ex(str, iter.base());
10702 assert(ex == "-*********************INF");
10703 assert(ios.width() == 0);
10704 }
10705 }
10706 }
10707 }
10708 }
10709 }
10710 ios.precision(16);
10711 {}
10712 ios.precision(60);
10713 {}
10714 }
10715 }
10716 }
10717
test5()10718 void test5()
10719 {
10720 char str[200];
10721 output_iterator<char*> iter;
10722 std::locale lc = std::locale::classic();
10723 std::locale lg(lc, new my_numpunct);
10724 const my_facet f(1);
10725 {
10726 long double v = std::nan("");
10727 std::ios ios(0);
10728 // %g
10729 {
10730 ios.precision(0);
10731 {
10732 nouppercase(ios);
10733 {
10734 noshowpos(ios);
10735 {
10736 noshowpoint(ios);
10737 {
10738 ios.imbue(lc);
10739 {
10740 ios.width(0);
10741 {
10742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10743 std::string ex(str, iter.base());
10744 assert(ex == "nan");
10745 assert(ios.width() == 0);
10746 }
10747 ios.width(25);
10748 left(ios);
10749 {
10750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10751 std::string ex(str, iter.base());
10752 assert(ex == "nan**********************");
10753 assert(ios.width() == 0);
10754 }
10755 ios.width(25);
10756 right(ios);
10757 {
10758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10759 std::string ex(str, iter.base());
10760 assert(ex == "**********************nan");
10761 assert(ios.width() == 0);
10762 }
10763 ios.width(25);
10764 internal(ios);
10765 {
10766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10767 std::string ex(str, iter.base());
10768 assert(ex == "**********************nan");
10769 assert(ios.width() == 0);
10770 }
10771 }
10772 ios.imbue(lg);
10773 {
10774 ios.width(0);
10775 {
10776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10777 std::string ex(str, iter.base());
10778 assert(ex == "nan");
10779 assert(ios.width() == 0);
10780 }
10781 ios.width(25);
10782 left(ios);
10783 {
10784 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10785 std::string ex(str, iter.base());
10786 assert(ex == "nan**********************");
10787 assert(ios.width() == 0);
10788 }
10789 ios.width(25);
10790 right(ios);
10791 {
10792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10793 std::string ex(str, iter.base());
10794 assert(ex == "**********************nan");
10795 assert(ios.width() == 0);
10796 }
10797 ios.width(25);
10798 internal(ios);
10799 {
10800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10801 std::string ex(str, iter.base());
10802 assert(ex == "**********************nan");
10803 assert(ios.width() == 0);
10804 }
10805 }
10806 }
10807 showpoint(ios);
10808 {
10809 ios.imbue(lc);
10810 {
10811 ios.width(0);
10812 {
10813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10814 std::string ex(str, iter.base());
10815 assert(ex == "nan");
10816 assert(ios.width() == 0);
10817 }
10818 ios.width(25);
10819 left(ios);
10820 {
10821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10822 std::string ex(str, iter.base());
10823 assert(ex == "nan**********************");
10824 assert(ios.width() == 0);
10825 }
10826 ios.width(25);
10827 right(ios);
10828 {
10829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10830 std::string ex(str, iter.base());
10831 assert(ex == "**********************nan");
10832 assert(ios.width() == 0);
10833 }
10834 ios.width(25);
10835 internal(ios);
10836 {
10837 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10838 std::string ex(str, iter.base());
10839 assert(ex == "**********************nan");
10840 assert(ios.width() == 0);
10841 }
10842 }
10843 ios.imbue(lg);
10844 {
10845 ios.width(0);
10846 {
10847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10848 std::string ex(str, iter.base());
10849 assert(ex == "nan");
10850 assert(ios.width() == 0);
10851 }
10852 ios.width(25);
10853 left(ios);
10854 {
10855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10856 std::string ex(str, iter.base());
10857 assert(ex == "nan**********************");
10858 assert(ios.width() == 0);
10859 }
10860 ios.width(25);
10861 right(ios);
10862 {
10863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10864 std::string ex(str, iter.base());
10865 assert(ex == "**********************nan");
10866 assert(ios.width() == 0);
10867 }
10868 ios.width(25);
10869 internal(ios);
10870 {
10871 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10872 std::string ex(str, iter.base());
10873 assert(ex == "**********************nan");
10874 assert(ios.width() == 0);
10875 }
10876 }
10877 }
10878 }
10879 showpos(ios);
10880 {
10881 noshowpoint(ios);
10882 {
10883 ios.imbue(lc);
10884 {
10885 ios.width(0);
10886 {
10887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10888 std::string ex(str, iter.base());
10889 assert(ex == "nan");
10890 assert(ios.width() == 0);
10891 }
10892 ios.width(25);
10893 left(ios);
10894 {
10895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10896 std::string ex(str, iter.base());
10897 assert(ex == "nan**********************");
10898 assert(ios.width() == 0);
10899 }
10900 ios.width(25);
10901 right(ios);
10902 {
10903 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10904 std::string ex(str, iter.base());
10905 assert(ex == "**********************nan");
10906 assert(ios.width() == 0);
10907 }
10908 ios.width(25);
10909 internal(ios);
10910 {
10911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10912 std::string ex(str, iter.base());
10913 assert(ex == "**********************nan");
10914 assert(ios.width() == 0);
10915 }
10916 }
10917 ios.imbue(lg);
10918 {
10919 ios.width(0);
10920 {
10921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10922 std::string ex(str, iter.base());
10923 assert(ex == "nan");
10924 assert(ios.width() == 0);
10925 }
10926 ios.width(25);
10927 left(ios);
10928 {
10929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10930 std::string ex(str, iter.base());
10931 assert(ex == "nan**********************");
10932 assert(ios.width() == 0);
10933 }
10934 ios.width(25);
10935 right(ios);
10936 {
10937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10938 std::string ex(str, iter.base());
10939 assert(ex == "**********************nan");
10940 assert(ios.width() == 0);
10941 }
10942 ios.width(25);
10943 internal(ios);
10944 {
10945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10946 std::string ex(str, iter.base());
10947 assert(ex == "**********************nan");
10948 assert(ios.width() == 0);
10949 }
10950 }
10951 }
10952 showpoint(ios);
10953 {
10954 ios.imbue(lc);
10955 {
10956 ios.width(0);
10957 {
10958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10959 std::string ex(str, iter.base());
10960 assert(ex == "nan");
10961 assert(ios.width() == 0);
10962 }
10963 ios.width(25);
10964 left(ios);
10965 {
10966 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10967 std::string ex(str, iter.base());
10968 assert(ex == "nan**********************");
10969 assert(ios.width() == 0);
10970 }
10971 ios.width(25);
10972 right(ios);
10973 {
10974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10975 std::string ex(str, iter.base());
10976 assert(ex == "**********************nan");
10977 assert(ios.width() == 0);
10978 }
10979 ios.width(25);
10980 internal(ios);
10981 {
10982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10983 std::string ex(str, iter.base());
10984 assert(ex == "**********************nan");
10985 assert(ios.width() == 0);
10986 }
10987 }
10988 ios.imbue(lg);
10989 {
10990 ios.width(0);
10991 {
10992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
10993 std::string ex(str, iter.base());
10994 assert(ex == "nan");
10995 assert(ios.width() == 0);
10996 }
10997 ios.width(25);
10998 left(ios);
10999 {
11000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11001 std::string ex(str, iter.base());
11002 assert(ex == "nan**********************");
11003 assert(ios.width() == 0);
11004 }
11005 ios.width(25);
11006 right(ios);
11007 {
11008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11009 std::string ex(str, iter.base());
11010 assert(ex == "**********************nan");
11011 assert(ios.width() == 0);
11012 }
11013 ios.width(25);
11014 internal(ios);
11015 {
11016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11017 std::string ex(str, iter.base());
11018 assert(ex == "**********************nan");
11019 assert(ios.width() == 0);
11020 }
11021 }
11022 }
11023 }
11024 }
11025 uppercase(ios);
11026 {
11027 noshowpos(ios);
11028 {
11029 noshowpoint(ios);
11030 {
11031 ios.imbue(lc);
11032 {
11033 ios.width(0);
11034 {
11035 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11036 std::string ex(str, iter.base());
11037 assert(ex == "NAN");
11038 assert(ios.width() == 0);
11039 }
11040 ios.width(25);
11041 left(ios);
11042 {
11043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11044 std::string ex(str, iter.base());
11045 assert(ex == "NAN**********************");
11046 assert(ios.width() == 0);
11047 }
11048 ios.width(25);
11049 right(ios);
11050 {
11051 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11052 std::string ex(str, iter.base());
11053 assert(ex == "**********************NAN");
11054 assert(ios.width() == 0);
11055 }
11056 ios.width(25);
11057 internal(ios);
11058 {
11059 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11060 std::string ex(str, iter.base());
11061 assert(ex == "**********************NAN");
11062 assert(ios.width() == 0);
11063 }
11064 }
11065 ios.imbue(lg);
11066 {
11067 ios.width(0);
11068 {
11069 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11070 std::string ex(str, iter.base());
11071 assert(ex == "NAN");
11072 assert(ios.width() == 0);
11073 }
11074 ios.width(25);
11075 left(ios);
11076 {
11077 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11078 std::string ex(str, iter.base());
11079 assert(ex == "NAN**********************");
11080 assert(ios.width() == 0);
11081 }
11082 ios.width(25);
11083 right(ios);
11084 {
11085 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11086 std::string ex(str, iter.base());
11087 assert(ex == "**********************NAN");
11088 assert(ios.width() == 0);
11089 }
11090 ios.width(25);
11091 internal(ios);
11092 {
11093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11094 std::string ex(str, iter.base());
11095 assert(ex == "**********************NAN");
11096 assert(ios.width() == 0);
11097 }
11098 }
11099 }
11100 showpoint(ios);
11101 {
11102 ios.imbue(lc);
11103 {
11104 ios.width(0);
11105 {
11106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11107 std::string ex(str, iter.base());
11108 assert(ex == "NAN");
11109 assert(ios.width() == 0);
11110 }
11111 ios.width(25);
11112 left(ios);
11113 {
11114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11115 std::string ex(str, iter.base());
11116 assert(ex == "NAN**********************");
11117 assert(ios.width() == 0);
11118 }
11119 ios.width(25);
11120 right(ios);
11121 {
11122 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11123 std::string ex(str, iter.base());
11124 assert(ex == "**********************NAN");
11125 assert(ios.width() == 0);
11126 }
11127 ios.width(25);
11128 internal(ios);
11129 {
11130 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11131 std::string ex(str, iter.base());
11132 assert(ex == "**********************NAN");
11133 assert(ios.width() == 0);
11134 }
11135 }
11136 ios.imbue(lg);
11137 {
11138 ios.width(0);
11139 {
11140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11141 std::string ex(str, iter.base());
11142 assert(ex == "NAN");
11143 assert(ios.width() == 0);
11144 }
11145 ios.width(25);
11146 left(ios);
11147 {
11148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11149 std::string ex(str, iter.base());
11150 assert(ex == "NAN**********************");
11151 assert(ios.width() == 0);
11152 }
11153 ios.width(25);
11154 right(ios);
11155 {
11156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11157 std::string ex(str, iter.base());
11158 assert(ex == "**********************NAN");
11159 assert(ios.width() == 0);
11160 }
11161 ios.width(25);
11162 internal(ios);
11163 {
11164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11165 std::string ex(str, iter.base());
11166 assert(ex == "**********************NAN");
11167 assert(ios.width() == 0);
11168 }
11169 }
11170 }
11171 }
11172 showpos(ios);
11173 {
11174 noshowpoint(ios);
11175 {
11176 ios.imbue(lc);
11177 {
11178 ios.width(0);
11179 {
11180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11181 std::string ex(str, iter.base());
11182 assert(ex == "NAN");
11183 assert(ios.width() == 0);
11184 }
11185 ios.width(25);
11186 left(ios);
11187 {
11188 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11189 std::string ex(str, iter.base());
11190 assert(ex == "NAN**********************");
11191 assert(ios.width() == 0);
11192 }
11193 ios.width(25);
11194 right(ios);
11195 {
11196 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11197 std::string ex(str, iter.base());
11198 assert(ex == "**********************NAN");
11199 assert(ios.width() == 0);
11200 }
11201 ios.width(25);
11202 internal(ios);
11203 {
11204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11205 std::string ex(str, iter.base());
11206 assert(ex == "**********************NAN");
11207 assert(ios.width() == 0);
11208 }
11209 }
11210 ios.imbue(lg);
11211 {
11212 ios.width(0);
11213 {
11214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11215 std::string ex(str, iter.base());
11216 assert(ex == "NAN");
11217 assert(ios.width() == 0);
11218 }
11219 ios.width(25);
11220 left(ios);
11221 {
11222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11223 std::string ex(str, iter.base());
11224 assert(ex == "NAN**********************");
11225 assert(ios.width() == 0);
11226 }
11227 ios.width(25);
11228 right(ios);
11229 {
11230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11231 std::string ex(str, iter.base());
11232 assert(ex == "**********************NAN");
11233 assert(ios.width() == 0);
11234 }
11235 ios.width(25);
11236 internal(ios);
11237 {
11238 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11239 std::string ex(str, iter.base());
11240 assert(ex == "**********************NAN");
11241 assert(ios.width() == 0);
11242 }
11243 }
11244 }
11245 showpoint(ios);
11246 {
11247 ios.imbue(lc);
11248 {
11249 ios.width(0);
11250 {
11251 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11252 std::string ex(str, iter.base());
11253 assert(ex == "NAN");
11254 assert(ios.width() == 0);
11255 }
11256 ios.width(25);
11257 left(ios);
11258 {
11259 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11260 std::string ex(str, iter.base());
11261 assert(ex == "NAN**********************");
11262 assert(ios.width() == 0);
11263 }
11264 ios.width(25);
11265 right(ios);
11266 {
11267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11268 std::string ex(str, iter.base());
11269 assert(ex == "**********************NAN");
11270 assert(ios.width() == 0);
11271 }
11272 ios.width(25);
11273 internal(ios);
11274 {
11275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11276 std::string ex(str, iter.base());
11277 assert(ex == "**********************NAN");
11278 assert(ios.width() == 0);
11279 }
11280 }
11281 ios.imbue(lg);
11282 {
11283 ios.width(0);
11284 {
11285 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11286 std::string ex(str, iter.base());
11287 assert(ex == "NAN");
11288 assert(ios.width() == 0);
11289 }
11290 ios.width(25);
11291 left(ios);
11292 {
11293 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11294 std::string ex(str, iter.base());
11295 assert(ex == "NAN**********************");
11296 assert(ios.width() == 0);
11297 }
11298 ios.width(25);
11299 right(ios);
11300 {
11301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11302 std::string ex(str, iter.base());
11303 assert(ex == "**********************NAN");
11304 assert(ios.width() == 0);
11305 }
11306 ios.width(25);
11307 internal(ios);
11308 {
11309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11310 std::string ex(str, iter.base());
11311 assert(ex == "**********************NAN");
11312 assert(ios.width() == 0);
11313 }
11314 }
11315 }
11316 }
11317 }
11318 }
11319 ios.precision(1);
11320 {}
11321 ios.precision(6);
11322 {}
11323 ios.precision(16);
11324 {}
11325 ios.precision(60);
11326 {}
11327 }
11328 }
11329 }
11330
test6()11331 void test6()
11332 {
11333 char str[200];
11334 output_iterator<char*> iter;
11335 std::locale lc = std::locale::classic();
11336 std::locale lg(lc, new my_numpunct);
11337 const my_facet f(1);
11338 {
11339 long double v = +0.;
11340 std::ios ios(0);
11341 fixed(ios);
11342 // %f
11343 {
11344 ios.precision(0);
11345 {
11346 nouppercase(ios);
11347 {
11348 noshowpos(ios);
11349 {
11350 noshowpoint(ios);
11351 {
11352 ios.imbue(lc);
11353 {
11354 ios.width(0);
11355 {
11356 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11357 std::string ex(str, iter.base());
11358 assert(ex == "0");
11359 assert(ios.width() == 0);
11360 }
11361 ios.width(25);
11362 left(ios);
11363 {
11364 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11365 std::string ex(str, iter.base());
11366 assert(ex == "0************************");
11367 assert(ios.width() == 0);
11368 }
11369 ios.width(25);
11370 right(ios);
11371 {
11372 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11373 std::string ex(str, iter.base());
11374 assert(ex == "************************0");
11375 assert(ios.width() == 0);
11376 }
11377 ios.width(25);
11378 internal(ios);
11379 {
11380 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11381 std::string ex(str, iter.base());
11382 assert(ex == "************************0");
11383 assert(ios.width() == 0);
11384 }
11385 }
11386 ios.imbue(lg);
11387 {
11388 ios.width(0);
11389 {
11390 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11391 std::string ex(str, iter.base());
11392 assert(ex == "0");
11393 assert(ios.width() == 0);
11394 }
11395 ios.width(25);
11396 left(ios);
11397 {
11398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11399 std::string ex(str, iter.base());
11400 assert(ex == "0************************");
11401 assert(ios.width() == 0);
11402 }
11403 ios.width(25);
11404 right(ios);
11405 {
11406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11407 std::string ex(str, iter.base());
11408 assert(ex == "************************0");
11409 assert(ios.width() == 0);
11410 }
11411 ios.width(25);
11412 internal(ios);
11413 {
11414 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11415 std::string ex(str, iter.base());
11416 assert(ex == "************************0");
11417 assert(ios.width() == 0);
11418 }
11419 }
11420 }
11421 showpoint(ios);
11422 {
11423 ios.imbue(lc);
11424 {
11425 ios.width(0);
11426 {
11427 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11428 std::string ex(str, iter.base());
11429 assert(ex == "0.");
11430 assert(ios.width() == 0);
11431 }
11432 ios.width(25);
11433 left(ios);
11434 {
11435 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11436 std::string ex(str, iter.base());
11437 assert(ex == "0.***********************");
11438 assert(ios.width() == 0);
11439 }
11440 ios.width(25);
11441 right(ios);
11442 {
11443 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11444 std::string ex(str, iter.base());
11445 assert(ex == "***********************0.");
11446 assert(ios.width() == 0);
11447 }
11448 ios.width(25);
11449 internal(ios);
11450 {
11451 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11452 std::string ex(str, iter.base());
11453 assert(ex == "***********************0.");
11454 assert(ios.width() == 0);
11455 }
11456 }
11457 ios.imbue(lg);
11458 {
11459 ios.width(0);
11460 {
11461 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11462 std::string ex(str, iter.base());
11463 assert(ex == "0;");
11464 assert(ios.width() == 0);
11465 }
11466 ios.width(25);
11467 left(ios);
11468 {
11469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11470 std::string ex(str, iter.base());
11471 assert(ex == "0;***********************");
11472 assert(ios.width() == 0);
11473 }
11474 ios.width(25);
11475 right(ios);
11476 {
11477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11478 std::string ex(str, iter.base());
11479 assert(ex == "***********************0;");
11480 assert(ios.width() == 0);
11481 }
11482 ios.width(25);
11483 internal(ios);
11484 {
11485 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11486 std::string ex(str, iter.base());
11487 assert(ex == "***********************0;");
11488 assert(ios.width() == 0);
11489 }
11490 }
11491 }
11492 }
11493 showpos(ios);
11494 {
11495 noshowpoint(ios);
11496 {
11497 ios.imbue(lc);
11498 {
11499 ios.width(0);
11500 {
11501 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11502 std::string ex(str, iter.base());
11503 assert(ex == "+0");
11504 assert(ios.width() == 0);
11505 }
11506 ios.width(25);
11507 left(ios);
11508 {
11509 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11510 std::string ex(str, iter.base());
11511 assert(ex == "+0***********************");
11512 assert(ios.width() == 0);
11513 }
11514 ios.width(25);
11515 right(ios);
11516 {
11517 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11518 std::string ex(str, iter.base());
11519 assert(ex == "***********************+0");
11520 assert(ios.width() == 0);
11521 }
11522 ios.width(25);
11523 internal(ios);
11524 {
11525 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11526 std::string ex(str, iter.base());
11527 assert(ex == "+***********************0");
11528 assert(ios.width() == 0);
11529 }
11530 }
11531 ios.imbue(lg);
11532 {
11533 ios.width(0);
11534 {
11535 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11536 std::string ex(str, iter.base());
11537 assert(ex == "+0");
11538 assert(ios.width() == 0);
11539 }
11540 ios.width(25);
11541 left(ios);
11542 {
11543 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11544 std::string ex(str, iter.base());
11545 assert(ex == "+0***********************");
11546 assert(ios.width() == 0);
11547 }
11548 ios.width(25);
11549 right(ios);
11550 {
11551 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11552 std::string ex(str, iter.base());
11553 assert(ex == "***********************+0");
11554 assert(ios.width() == 0);
11555 }
11556 ios.width(25);
11557 internal(ios);
11558 {
11559 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11560 std::string ex(str, iter.base());
11561 assert(ex == "+***********************0");
11562 assert(ios.width() == 0);
11563 }
11564 }
11565 }
11566 showpoint(ios);
11567 {
11568 ios.imbue(lc);
11569 {
11570 ios.width(0);
11571 {
11572 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11573 std::string ex(str, iter.base());
11574 assert(ex == "+0.");
11575 assert(ios.width() == 0);
11576 }
11577 ios.width(25);
11578 left(ios);
11579 {
11580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11581 std::string ex(str, iter.base());
11582 assert(ex == "+0.**********************");
11583 assert(ios.width() == 0);
11584 }
11585 ios.width(25);
11586 right(ios);
11587 {
11588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11589 std::string ex(str, iter.base());
11590 assert(ex == "**********************+0.");
11591 assert(ios.width() == 0);
11592 }
11593 ios.width(25);
11594 internal(ios);
11595 {
11596 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11597 std::string ex(str, iter.base());
11598 assert(ex == "+**********************0.");
11599 assert(ios.width() == 0);
11600 }
11601 }
11602 ios.imbue(lg);
11603 {
11604 ios.width(0);
11605 {
11606 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11607 std::string ex(str, iter.base());
11608 assert(ex == "+0;");
11609 assert(ios.width() == 0);
11610 }
11611 ios.width(25);
11612 left(ios);
11613 {
11614 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11615 std::string ex(str, iter.base());
11616 assert(ex == "+0;**********************");
11617 assert(ios.width() == 0);
11618 }
11619 ios.width(25);
11620 right(ios);
11621 {
11622 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11623 std::string ex(str, iter.base());
11624 assert(ex == "**********************+0;");
11625 assert(ios.width() == 0);
11626 }
11627 ios.width(25);
11628 internal(ios);
11629 {
11630 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11631 std::string ex(str, iter.base());
11632 assert(ex == "+**********************0;");
11633 assert(ios.width() == 0);
11634 }
11635 }
11636 }
11637 }
11638 }
11639 uppercase(ios);
11640 {
11641 noshowpos(ios);
11642 {
11643 noshowpoint(ios);
11644 {
11645 ios.imbue(lc);
11646 {
11647 ios.width(0);
11648 {
11649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11650 std::string ex(str, iter.base());
11651 assert(ex == "0");
11652 assert(ios.width() == 0);
11653 }
11654 ios.width(25);
11655 left(ios);
11656 {
11657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11658 std::string ex(str, iter.base());
11659 assert(ex == "0************************");
11660 assert(ios.width() == 0);
11661 }
11662 ios.width(25);
11663 right(ios);
11664 {
11665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11666 std::string ex(str, iter.base());
11667 assert(ex == "************************0");
11668 assert(ios.width() == 0);
11669 }
11670 ios.width(25);
11671 internal(ios);
11672 {
11673 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11674 std::string ex(str, iter.base());
11675 assert(ex == "************************0");
11676 assert(ios.width() == 0);
11677 }
11678 }
11679 ios.imbue(lg);
11680 {
11681 ios.width(0);
11682 {
11683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11684 std::string ex(str, iter.base());
11685 assert(ex == "0");
11686 assert(ios.width() == 0);
11687 }
11688 ios.width(25);
11689 left(ios);
11690 {
11691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11692 std::string ex(str, iter.base());
11693 assert(ex == "0************************");
11694 assert(ios.width() == 0);
11695 }
11696 ios.width(25);
11697 right(ios);
11698 {
11699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11700 std::string ex(str, iter.base());
11701 assert(ex == "************************0");
11702 assert(ios.width() == 0);
11703 }
11704 ios.width(25);
11705 internal(ios);
11706 {
11707 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11708 std::string ex(str, iter.base());
11709 assert(ex == "************************0");
11710 assert(ios.width() == 0);
11711 }
11712 }
11713 }
11714 showpoint(ios);
11715 {
11716 ios.imbue(lc);
11717 {
11718 ios.width(0);
11719 {
11720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11721 std::string ex(str, iter.base());
11722 assert(ex == "0.");
11723 assert(ios.width() == 0);
11724 }
11725 ios.width(25);
11726 left(ios);
11727 {
11728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11729 std::string ex(str, iter.base());
11730 assert(ex == "0.***********************");
11731 assert(ios.width() == 0);
11732 }
11733 ios.width(25);
11734 right(ios);
11735 {
11736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11737 std::string ex(str, iter.base());
11738 assert(ex == "***********************0.");
11739 assert(ios.width() == 0);
11740 }
11741 ios.width(25);
11742 internal(ios);
11743 {
11744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11745 std::string ex(str, iter.base());
11746 assert(ex == "***********************0.");
11747 assert(ios.width() == 0);
11748 }
11749 }
11750 ios.imbue(lg);
11751 {
11752 ios.width(0);
11753 {
11754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11755 std::string ex(str, iter.base());
11756 assert(ex == "0;");
11757 assert(ios.width() == 0);
11758 }
11759 ios.width(25);
11760 left(ios);
11761 {
11762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11763 std::string ex(str, iter.base());
11764 assert(ex == "0;***********************");
11765 assert(ios.width() == 0);
11766 }
11767 ios.width(25);
11768 right(ios);
11769 {
11770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11771 std::string ex(str, iter.base());
11772 assert(ex == "***********************0;");
11773 assert(ios.width() == 0);
11774 }
11775 ios.width(25);
11776 internal(ios);
11777 {
11778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11779 std::string ex(str, iter.base());
11780 assert(ex == "***********************0;");
11781 assert(ios.width() == 0);
11782 }
11783 }
11784 }
11785 }
11786 showpos(ios);
11787 {
11788 noshowpoint(ios);
11789 {
11790 ios.imbue(lc);
11791 {
11792 ios.width(0);
11793 {
11794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11795 std::string ex(str, iter.base());
11796 assert(ex == "+0");
11797 assert(ios.width() == 0);
11798 }
11799 ios.width(25);
11800 left(ios);
11801 {
11802 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11803 std::string ex(str, iter.base());
11804 assert(ex == "+0***********************");
11805 assert(ios.width() == 0);
11806 }
11807 ios.width(25);
11808 right(ios);
11809 {
11810 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11811 std::string ex(str, iter.base());
11812 assert(ex == "***********************+0");
11813 assert(ios.width() == 0);
11814 }
11815 ios.width(25);
11816 internal(ios);
11817 {
11818 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11819 std::string ex(str, iter.base());
11820 assert(ex == "+***********************0");
11821 assert(ios.width() == 0);
11822 }
11823 }
11824 ios.imbue(lg);
11825 {
11826 ios.width(0);
11827 {
11828 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11829 std::string ex(str, iter.base());
11830 assert(ex == "+0");
11831 assert(ios.width() == 0);
11832 }
11833 ios.width(25);
11834 left(ios);
11835 {
11836 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11837 std::string ex(str, iter.base());
11838 assert(ex == "+0***********************");
11839 assert(ios.width() == 0);
11840 }
11841 ios.width(25);
11842 right(ios);
11843 {
11844 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11845 std::string ex(str, iter.base());
11846 assert(ex == "***********************+0");
11847 assert(ios.width() == 0);
11848 }
11849 ios.width(25);
11850 internal(ios);
11851 {
11852 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11853 std::string ex(str, iter.base());
11854 assert(ex == "+***********************0");
11855 assert(ios.width() == 0);
11856 }
11857 }
11858 }
11859 showpoint(ios);
11860 {
11861 ios.imbue(lc);
11862 {
11863 ios.width(0);
11864 {
11865 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11866 std::string ex(str, iter.base());
11867 assert(ex == "+0.");
11868 assert(ios.width() == 0);
11869 }
11870 ios.width(25);
11871 left(ios);
11872 {
11873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11874 std::string ex(str, iter.base());
11875 assert(ex == "+0.**********************");
11876 assert(ios.width() == 0);
11877 }
11878 ios.width(25);
11879 right(ios);
11880 {
11881 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11882 std::string ex(str, iter.base());
11883 assert(ex == "**********************+0.");
11884 assert(ios.width() == 0);
11885 }
11886 ios.width(25);
11887 internal(ios);
11888 {
11889 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11890 std::string ex(str, iter.base());
11891 assert(ex == "+**********************0.");
11892 assert(ios.width() == 0);
11893 }
11894 }
11895 ios.imbue(lg);
11896 {
11897 ios.width(0);
11898 {
11899 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11900 std::string ex(str, iter.base());
11901 assert(ex == "+0;");
11902 assert(ios.width() == 0);
11903 }
11904 ios.width(25);
11905 left(ios);
11906 {
11907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11908 std::string ex(str, iter.base());
11909 assert(ex == "+0;**********************");
11910 assert(ios.width() == 0);
11911 }
11912 ios.width(25);
11913 right(ios);
11914 {
11915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11916 std::string ex(str, iter.base());
11917 assert(ex == "**********************+0;");
11918 assert(ios.width() == 0);
11919 }
11920 ios.width(25);
11921 internal(ios);
11922 {
11923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11924 std::string ex(str, iter.base());
11925 assert(ex == "+**********************0;");
11926 assert(ios.width() == 0);
11927 }
11928 }
11929 }
11930 }
11931 }
11932 }
11933 ios.precision(1);
11934 {
11935 nouppercase(ios);
11936 {
11937 noshowpos(ios);
11938 {
11939 noshowpoint(ios);
11940 {
11941 ios.imbue(lc);
11942 {
11943 ios.width(0);
11944 {
11945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11946 std::string ex(str, iter.base());
11947 assert(ex == "0.0");
11948 assert(ios.width() == 0);
11949 }
11950 ios.width(25);
11951 left(ios);
11952 {
11953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11954 std::string ex(str, iter.base());
11955 assert(ex == "0.0**********************");
11956 assert(ios.width() == 0);
11957 }
11958 ios.width(25);
11959 right(ios);
11960 {
11961 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11962 std::string ex(str, iter.base());
11963 assert(ex == "**********************0.0");
11964 assert(ios.width() == 0);
11965 }
11966 ios.width(25);
11967 internal(ios);
11968 {
11969 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11970 std::string ex(str, iter.base());
11971 assert(ex == "**********************0.0");
11972 assert(ios.width() == 0);
11973 }
11974 }
11975 ios.imbue(lg);
11976 {
11977 ios.width(0);
11978 {
11979 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11980 std::string ex(str, iter.base());
11981 assert(ex == "0;0");
11982 assert(ios.width() == 0);
11983 }
11984 ios.width(25);
11985 left(ios);
11986 {
11987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11988 std::string ex(str, iter.base());
11989 assert(ex == "0;0**********************");
11990 assert(ios.width() == 0);
11991 }
11992 ios.width(25);
11993 right(ios);
11994 {
11995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
11996 std::string ex(str, iter.base());
11997 assert(ex == "**********************0;0");
11998 assert(ios.width() == 0);
11999 }
12000 ios.width(25);
12001 internal(ios);
12002 {
12003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12004 std::string ex(str, iter.base());
12005 assert(ex == "**********************0;0");
12006 assert(ios.width() == 0);
12007 }
12008 }
12009 }
12010 showpoint(ios);
12011 {
12012 ios.imbue(lc);
12013 {
12014 ios.width(0);
12015 {
12016 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12017 std::string ex(str, iter.base());
12018 assert(ex == "0.0");
12019 assert(ios.width() == 0);
12020 }
12021 ios.width(25);
12022 left(ios);
12023 {
12024 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12025 std::string ex(str, iter.base());
12026 assert(ex == "0.0**********************");
12027 assert(ios.width() == 0);
12028 }
12029 ios.width(25);
12030 right(ios);
12031 {
12032 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12033 std::string ex(str, iter.base());
12034 assert(ex == "**********************0.0");
12035 assert(ios.width() == 0);
12036 }
12037 ios.width(25);
12038 internal(ios);
12039 {
12040 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12041 std::string ex(str, iter.base());
12042 assert(ex == "**********************0.0");
12043 assert(ios.width() == 0);
12044 }
12045 }
12046 ios.imbue(lg);
12047 {
12048 ios.width(0);
12049 {
12050 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12051 std::string ex(str, iter.base());
12052 assert(ex == "0;0");
12053 assert(ios.width() == 0);
12054 }
12055 ios.width(25);
12056 left(ios);
12057 {
12058 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12059 std::string ex(str, iter.base());
12060 assert(ex == "0;0**********************");
12061 assert(ios.width() == 0);
12062 }
12063 ios.width(25);
12064 right(ios);
12065 {
12066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12067 std::string ex(str, iter.base());
12068 assert(ex == "**********************0;0");
12069 assert(ios.width() == 0);
12070 }
12071 ios.width(25);
12072 internal(ios);
12073 {
12074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12075 std::string ex(str, iter.base());
12076 assert(ex == "**********************0;0");
12077 assert(ios.width() == 0);
12078 }
12079 }
12080 }
12081 }
12082 showpos(ios);
12083 {
12084 noshowpoint(ios);
12085 {
12086 ios.imbue(lc);
12087 {
12088 ios.width(0);
12089 {
12090 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12091 std::string ex(str, iter.base());
12092 assert(ex == "+0.0");
12093 assert(ios.width() == 0);
12094 }
12095 ios.width(25);
12096 left(ios);
12097 {
12098 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12099 std::string ex(str, iter.base());
12100 assert(ex == "+0.0*********************");
12101 assert(ios.width() == 0);
12102 }
12103 ios.width(25);
12104 right(ios);
12105 {
12106 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12107 std::string ex(str, iter.base());
12108 assert(ex == "*********************+0.0");
12109 assert(ios.width() == 0);
12110 }
12111 ios.width(25);
12112 internal(ios);
12113 {
12114 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12115 std::string ex(str, iter.base());
12116 assert(ex == "+*********************0.0");
12117 assert(ios.width() == 0);
12118 }
12119 }
12120 ios.imbue(lg);
12121 {
12122 ios.width(0);
12123 {
12124 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12125 std::string ex(str, iter.base());
12126 assert(ex == "+0;0");
12127 assert(ios.width() == 0);
12128 }
12129 ios.width(25);
12130 left(ios);
12131 {
12132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12133 std::string ex(str, iter.base());
12134 assert(ex == "+0;0*********************");
12135 assert(ios.width() == 0);
12136 }
12137 ios.width(25);
12138 right(ios);
12139 {
12140 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12141 std::string ex(str, iter.base());
12142 assert(ex == "*********************+0;0");
12143 assert(ios.width() == 0);
12144 }
12145 ios.width(25);
12146 internal(ios);
12147 {
12148 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12149 std::string ex(str, iter.base());
12150 assert(ex == "+*********************0;0");
12151 assert(ios.width() == 0);
12152 }
12153 }
12154 }
12155 showpoint(ios);
12156 {
12157 ios.imbue(lc);
12158 {
12159 ios.width(0);
12160 {
12161 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12162 std::string ex(str, iter.base());
12163 assert(ex == "+0.0");
12164 assert(ios.width() == 0);
12165 }
12166 ios.width(25);
12167 left(ios);
12168 {
12169 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12170 std::string ex(str, iter.base());
12171 assert(ex == "+0.0*********************");
12172 assert(ios.width() == 0);
12173 }
12174 ios.width(25);
12175 right(ios);
12176 {
12177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12178 std::string ex(str, iter.base());
12179 assert(ex == "*********************+0.0");
12180 assert(ios.width() == 0);
12181 }
12182 ios.width(25);
12183 internal(ios);
12184 {
12185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12186 std::string ex(str, iter.base());
12187 assert(ex == "+*********************0.0");
12188 assert(ios.width() == 0);
12189 }
12190 }
12191 ios.imbue(lg);
12192 {
12193 ios.width(0);
12194 {
12195 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12196 std::string ex(str, iter.base());
12197 assert(ex == "+0;0");
12198 assert(ios.width() == 0);
12199 }
12200 ios.width(25);
12201 left(ios);
12202 {
12203 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12204 std::string ex(str, iter.base());
12205 assert(ex == "+0;0*********************");
12206 assert(ios.width() == 0);
12207 }
12208 ios.width(25);
12209 right(ios);
12210 {
12211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12212 std::string ex(str, iter.base());
12213 assert(ex == "*********************+0;0");
12214 assert(ios.width() == 0);
12215 }
12216 ios.width(25);
12217 internal(ios);
12218 {
12219 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12220 std::string ex(str, iter.base());
12221 assert(ex == "+*********************0;0");
12222 assert(ios.width() == 0);
12223 }
12224 }
12225 }
12226 }
12227 }
12228 uppercase(ios);
12229 {
12230 noshowpos(ios);
12231 {
12232 noshowpoint(ios);
12233 {
12234 ios.imbue(lc);
12235 {
12236 ios.width(0);
12237 {
12238 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12239 std::string ex(str, iter.base());
12240 assert(ex == "0.0");
12241 assert(ios.width() == 0);
12242 }
12243 ios.width(25);
12244 left(ios);
12245 {
12246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12247 std::string ex(str, iter.base());
12248 assert(ex == "0.0**********************");
12249 assert(ios.width() == 0);
12250 }
12251 ios.width(25);
12252 right(ios);
12253 {
12254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12255 std::string ex(str, iter.base());
12256 assert(ex == "**********************0.0");
12257 assert(ios.width() == 0);
12258 }
12259 ios.width(25);
12260 internal(ios);
12261 {
12262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12263 std::string ex(str, iter.base());
12264 assert(ex == "**********************0.0");
12265 assert(ios.width() == 0);
12266 }
12267 }
12268 ios.imbue(lg);
12269 {
12270 ios.width(0);
12271 {
12272 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12273 std::string ex(str, iter.base());
12274 assert(ex == "0;0");
12275 assert(ios.width() == 0);
12276 }
12277 ios.width(25);
12278 left(ios);
12279 {
12280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12281 std::string ex(str, iter.base());
12282 assert(ex == "0;0**********************");
12283 assert(ios.width() == 0);
12284 }
12285 ios.width(25);
12286 right(ios);
12287 {
12288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12289 std::string ex(str, iter.base());
12290 assert(ex == "**********************0;0");
12291 assert(ios.width() == 0);
12292 }
12293 ios.width(25);
12294 internal(ios);
12295 {
12296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12297 std::string ex(str, iter.base());
12298 assert(ex == "**********************0;0");
12299 assert(ios.width() == 0);
12300 }
12301 }
12302 }
12303 showpoint(ios);
12304 {
12305 ios.imbue(lc);
12306 {
12307 ios.width(0);
12308 {
12309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12310 std::string ex(str, iter.base());
12311 assert(ex == "0.0");
12312 assert(ios.width() == 0);
12313 }
12314 ios.width(25);
12315 left(ios);
12316 {
12317 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12318 std::string ex(str, iter.base());
12319 assert(ex == "0.0**********************");
12320 assert(ios.width() == 0);
12321 }
12322 ios.width(25);
12323 right(ios);
12324 {
12325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12326 std::string ex(str, iter.base());
12327 assert(ex == "**********************0.0");
12328 assert(ios.width() == 0);
12329 }
12330 ios.width(25);
12331 internal(ios);
12332 {
12333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12334 std::string ex(str, iter.base());
12335 assert(ex == "**********************0.0");
12336 assert(ios.width() == 0);
12337 }
12338 }
12339 ios.imbue(lg);
12340 {
12341 ios.width(0);
12342 {
12343 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12344 std::string ex(str, iter.base());
12345 assert(ex == "0;0");
12346 assert(ios.width() == 0);
12347 }
12348 ios.width(25);
12349 left(ios);
12350 {
12351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12352 std::string ex(str, iter.base());
12353 assert(ex == "0;0**********************");
12354 assert(ios.width() == 0);
12355 }
12356 ios.width(25);
12357 right(ios);
12358 {
12359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12360 std::string ex(str, iter.base());
12361 assert(ex == "**********************0;0");
12362 assert(ios.width() == 0);
12363 }
12364 ios.width(25);
12365 internal(ios);
12366 {
12367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12368 std::string ex(str, iter.base());
12369 assert(ex == "**********************0;0");
12370 assert(ios.width() == 0);
12371 }
12372 }
12373 }
12374 }
12375 showpos(ios);
12376 {
12377 noshowpoint(ios);
12378 {
12379 ios.imbue(lc);
12380 {
12381 ios.width(0);
12382 {
12383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12384 std::string ex(str, iter.base());
12385 assert(ex == "+0.0");
12386 assert(ios.width() == 0);
12387 }
12388 ios.width(25);
12389 left(ios);
12390 {
12391 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12392 std::string ex(str, iter.base());
12393 assert(ex == "+0.0*********************");
12394 assert(ios.width() == 0);
12395 }
12396 ios.width(25);
12397 right(ios);
12398 {
12399 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12400 std::string ex(str, iter.base());
12401 assert(ex == "*********************+0.0");
12402 assert(ios.width() == 0);
12403 }
12404 ios.width(25);
12405 internal(ios);
12406 {
12407 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12408 std::string ex(str, iter.base());
12409 assert(ex == "+*********************0.0");
12410 assert(ios.width() == 0);
12411 }
12412 }
12413 ios.imbue(lg);
12414 {
12415 ios.width(0);
12416 {
12417 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12418 std::string ex(str, iter.base());
12419 assert(ex == "+0;0");
12420 assert(ios.width() == 0);
12421 }
12422 ios.width(25);
12423 left(ios);
12424 {
12425 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12426 std::string ex(str, iter.base());
12427 assert(ex == "+0;0*********************");
12428 assert(ios.width() == 0);
12429 }
12430 ios.width(25);
12431 right(ios);
12432 {
12433 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12434 std::string ex(str, iter.base());
12435 assert(ex == "*********************+0;0");
12436 assert(ios.width() == 0);
12437 }
12438 ios.width(25);
12439 internal(ios);
12440 {
12441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12442 std::string ex(str, iter.base());
12443 assert(ex == "+*********************0;0");
12444 assert(ios.width() == 0);
12445 }
12446 }
12447 }
12448 showpoint(ios);
12449 {
12450 ios.imbue(lc);
12451 {
12452 ios.width(0);
12453 {
12454 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12455 std::string ex(str, iter.base());
12456 assert(ex == "+0.0");
12457 assert(ios.width() == 0);
12458 }
12459 ios.width(25);
12460 left(ios);
12461 {
12462 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12463 std::string ex(str, iter.base());
12464 assert(ex == "+0.0*********************");
12465 assert(ios.width() == 0);
12466 }
12467 ios.width(25);
12468 right(ios);
12469 {
12470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12471 std::string ex(str, iter.base());
12472 assert(ex == "*********************+0.0");
12473 assert(ios.width() == 0);
12474 }
12475 ios.width(25);
12476 internal(ios);
12477 {
12478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12479 std::string ex(str, iter.base());
12480 assert(ex == "+*********************0.0");
12481 assert(ios.width() == 0);
12482 }
12483 }
12484 ios.imbue(lg);
12485 {
12486 ios.width(0);
12487 {
12488 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12489 std::string ex(str, iter.base());
12490 assert(ex == "+0;0");
12491 assert(ios.width() == 0);
12492 }
12493 ios.width(25);
12494 left(ios);
12495 {
12496 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12497 std::string ex(str, iter.base());
12498 assert(ex == "+0;0*********************");
12499 assert(ios.width() == 0);
12500 }
12501 ios.width(25);
12502 right(ios);
12503 {
12504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12505 std::string ex(str, iter.base());
12506 assert(ex == "*********************+0;0");
12507 assert(ios.width() == 0);
12508 }
12509 ios.width(25);
12510 internal(ios);
12511 {
12512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12513 std::string ex(str, iter.base());
12514 assert(ex == "+*********************0;0");
12515 assert(ios.width() == 0);
12516 }
12517 }
12518 }
12519 }
12520 }
12521 }
12522 ios.precision(6);
12523 {
12524 nouppercase(ios);
12525 {
12526 noshowpos(ios);
12527 {
12528 noshowpoint(ios);
12529 {
12530 ios.imbue(lc);
12531 {
12532 ios.width(0);
12533 {
12534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12535 std::string ex(str, iter.base());
12536 assert(ex == "0.000000");
12537 assert(ios.width() == 0);
12538 }
12539 ios.width(25);
12540 left(ios);
12541 {
12542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12543 std::string ex(str, iter.base());
12544 assert(ex == "0.000000*****************");
12545 assert(ios.width() == 0);
12546 }
12547 ios.width(25);
12548 right(ios);
12549 {
12550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12551 std::string ex(str, iter.base());
12552 assert(ex == "*****************0.000000");
12553 assert(ios.width() == 0);
12554 }
12555 ios.width(25);
12556 internal(ios);
12557 {
12558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12559 std::string ex(str, iter.base());
12560 assert(ex == "*****************0.000000");
12561 assert(ios.width() == 0);
12562 }
12563 }
12564 ios.imbue(lg);
12565 {
12566 ios.width(0);
12567 {
12568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12569 std::string ex(str, iter.base());
12570 assert(ex == "0;000000");
12571 assert(ios.width() == 0);
12572 }
12573 ios.width(25);
12574 left(ios);
12575 {
12576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12577 std::string ex(str, iter.base());
12578 assert(ex == "0;000000*****************");
12579 assert(ios.width() == 0);
12580 }
12581 ios.width(25);
12582 right(ios);
12583 {
12584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12585 std::string ex(str, iter.base());
12586 assert(ex == "*****************0;000000");
12587 assert(ios.width() == 0);
12588 }
12589 ios.width(25);
12590 internal(ios);
12591 {
12592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12593 std::string ex(str, iter.base());
12594 assert(ex == "*****************0;000000");
12595 assert(ios.width() == 0);
12596 }
12597 }
12598 }
12599 showpoint(ios);
12600 {
12601 ios.imbue(lc);
12602 {
12603 ios.width(0);
12604 {
12605 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12606 std::string ex(str, iter.base());
12607 assert(ex == "0.000000");
12608 assert(ios.width() == 0);
12609 }
12610 ios.width(25);
12611 left(ios);
12612 {
12613 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12614 std::string ex(str, iter.base());
12615 assert(ex == "0.000000*****************");
12616 assert(ios.width() == 0);
12617 }
12618 ios.width(25);
12619 right(ios);
12620 {
12621 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12622 std::string ex(str, iter.base());
12623 assert(ex == "*****************0.000000");
12624 assert(ios.width() == 0);
12625 }
12626 ios.width(25);
12627 internal(ios);
12628 {
12629 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12630 std::string ex(str, iter.base());
12631 assert(ex == "*****************0.000000");
12632 assert(ios.width() == 0);
12633 }
12634 }
12635 ios.imbue(lg);
12636 {
12637 ios.width(0);
12638 {
12639 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12640 std::string ex(str, iter.base());
12641 assert(ex == "0;000000");
12642 assert(ios.width() == 0);
12643 }
12644 ios.width(25);
12645 left(ios);
12646 {
12647 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12648 std::string ex(str, iter.base());
12649 assert(ex == "0;000000*****************");
12650 assert(ios.width() == 0);
12651 }
12652 ios.width(25);
12653 right(ios);
12654 {
12655 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12656 std::string ex(str, iter.base());
12657 assert(ex == "*****************0;000000");
12658 assert(ios.width() == 0);
12659 }
12660 ios.width(25);
12661 internal(ios);
12662 {
12663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12664 std::string ex(str, iter.base());
12665 assert(ex == "*****************0;000000");
12666 assert(ios.width() == 0);
12667 }
12668 }
12669 }
12670 }
12671 showpos(ios);
12672 {
12673 noshowpoint(ios);
12674 {
12675 ios.imbue(lc);
12676 {
12677 ios.width(0);
12678 {
12679 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12680 std::string ex(str, iter.base());
12681 assert(ex == "+0.000000");
12682 assert(ios.width() == 0);
12683 }
12684 ios.width(25);
12685 left(ios);
12686 {
12687 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12688 std::string ex(str, iter.base());
12689 assert(ex == "+0.000000****************");
12690 assert(ios.width() == 0);
12691 }
12692 ios.width(25);
12693 right(ios);
12694 {
12695 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12696 std::string ex(str, iter.base());
12697 assert(ex == "****************+0.000000");
12698 assert(ios.width() == 0);
12699 }
12700 ios.width(25);
12701 internal(ios);
12702 {
12703 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12704 std::string ex(str, iter.base());
12705 assert(ex == "+****************0.000000");
12706 assert(ios.width() == 0);
12707 }
12708 }
12709 ios.imbue(lg);
12710 {
12711 ios.width(0);
12712 {
12713 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12714 std::string ex(str, iter.base());
12715 assert(ex == "+0;000000");
12716 assert(ios.width() == 0);
12717 }
12718 ios.width(25);
12719 left(ios);
12720 {
12721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12722 std::string ex(str, iter.base());
12723 assert(ex == "+0;000000****************");
12724 assert(ios.width() == 0);
12725 }
12726 ios.width(25);
12727 right(ios);
12728 {
12729 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12730 std::string ex(str, iter.base());
12731 assert(ex == "****************+0;000000");
12732 assert(ios.width() == 0);
12733 }
12734 ios.width(25);
12735 internal(ios);
12736 {
12737 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12738 std::string ex(str, iter.base());
12739 assert(ex == "+****************0;000000");
12740 assert(ios.width() == 0);
12741 }
12742 }
12743 }
12744 showpoint(ios);
12745 {
12746 ios.imbue(lc);
12747 {
12748 ios.width(0);
12749 {
12750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12751 std::string ex(str, iter.base());
12752 assert(ex == "+0.000000");
12753 assert(ios.width() == 0);
12754 }
12755 ios.width(25);
12756 left(ios);
12757 {
12758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12759 std::string ex(str, iter.base());
12760 assert(ex == "+0.000000****************");
12761 assert(ios.width() == 0);
12762 }
12763 ios.width(25);
12764 right(ios);
12765 {
12766 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12767 std::string ex(str, iter.base());
12768 assert(ex == "****************+0.000000");
12769 assert(ios.width() == 0);
12770 }
12771 ios.width(25);
12772 internal(ios);
12773 {
12774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12775 std::string ex(str, iter.base());
12776 assert(ex == "+****************0.000000");
12777 assert(ios.width() == 0);
12778 }
12779 }
12780 ios.imbue(lg);
12781 {
12782 ios.width(0);
12783 {
12784 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12785 std::string ex(str, iter.base());
12786 assert(ex == "+0;000000");
12787 assert(ios.width() == 0);
12788 }
12789 ios.width(25);
12790 left(ios);
12791 {
12792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12793 std::string ex(str, iter.base());
12794 assert(ex == "+0;000000****************");
12795 assert(ios.width() == 0);
12796 }
12797 ios.width(25);
12798 right(ios);
12799 {
12800 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12801 std::string ex(str, iter.base());
12802 assert(ex == "****************+0;000000");
12803 assert(ios.width() == 0);
12804 }
12805 ios.width(25);
12806 internal(ios);
12807 {
12808 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12809 std::string ex(str, iter.base());
12810 assert(ex == "+****************0;000000");
12811 assert(ios.width() == 0);
12812 }
12813 }
12814 }
12815 }
12816 }
12817 uppercase(ios);
12818 {
12819 noshowpos(ios);
12820 {
12821 noshowpoint(ios);
12822 {
12823 ios.imbue(lc);
12824 {
12825 ios.width(0);
12826 {
12827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12828 std::string ex(str, iter.base());
12829 assert(ex == "0.000000");
12830 assert(ios.width() == 0);
12831 }
12832 ios.width(25);
12833 left(ios);
12834 {
12835 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12836 std::string ex(str, iter.base());
12837 assert(ex == "0.000000*****************");
12838 assert(ios.width() == 0);
12839 }
12840 ios.width(25);
12841 right(ios);
12842 {
12843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12844 std::string ex(str, iter.base());
12845 assert(ex == "*****************0.000000");
12846 assert(ios.width() == 0);
12847 }
12848 ios.width(25);
12849 internal(ios);
12850 {
12851 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12852 std::string ex(str, iter.base());
12853 assert(ex == "*****************0.000000");
12854 assert(ios.width() == 0);
12855 }
12856 }
12857 ios.imbue(lg);
12858 {
12859 ios.width(0);
12860 {
12861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12862 std::string ex(str, iter.base());
12863 assert(ex == "0;000000");
12864 assert(ios.width() == 0);
12865 }
12866 ios.width(25);
12867 left(ios);
12868 {
12869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12870 std::string ex(str, iter.base());
12871 assert(ex == "0;000000*****************");
12872 assert(ios.width() == 0);
12873 }
12874 ios.width(25);
12875 right(ios);
12876 {
12877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12878 std::string ex(str, iter.base());
12879 assert(ex == "*****************0;000000");
12880 assert(ios.width() == 0);
12881 }
12882 ios.width(25);
12883 internal(ios);
12884 {
12885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12886 std::string ex(str, iter.base());
12887 assert(ex == "*****************0;000000");
12888 assert(ios.width() == 0);
12889 }
12890 }
12891 }
12892 showpoint(ios);
12893 {
12894 ios.imbue(lc);
12895 {
12896 ios.width(0);
12897 {
12898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12899 std::string ex(str, iter.base());
12900 assert(ex == "0.000000");
12901 assert(ios.width() == 0);
12902 }
12903 ios.width(25);
12904 left(ios);
12905 {
12906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12907 std::string ex(str, iter.base());
12908 assert(ex == "0.000000*****************");
12909 assert(ios.width() == 0);
12910 }
12911 ios.width(25);
12912 right(ios);
12913 {
12914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12915 std::string ex(str, iter.base());
12916 assert(ex == "*****************0.000000");
12917 assert(ios.width() == 0);
12918 }
12919 ios.width(25);
12920 internal(ios);
12921 {
12922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12923 std::string ex(str, iter.base());
12924 assert(ex == "*****************0.000000");
12925 assert(ios.width() == 0);
12926 }
12927 }
12928 ios.imbue(lg);
12929 {
12930 ios.width(0);
12931 {
12932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12933 std::string ex(str, iter.base());
12934 assert(ex == "0;000000");
12935 assert(ios.width() == 0);
12936 }
12937 ios.width(25);
12938 left(ios);
12939 {
12940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12941 std::string ex(str, iter.base());
12942 assert(ex == "0;000000*****************");
12943 assert(ios.width() == 0);
12944 }
12945 ios.width(25);
12946 right(ios);
12947 {
12948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12949 std::string ex(str, iter.base());
12950 assert(ex == "*****************0;000000");
12951 assert(ios.width() == 0);
12952 }
12953 ios.width(25);
12954 internal(ios);
12955 {
12956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12957 std::string ex(str, iter.base());
12958 assert(ex == "*****************0;000000");
12959 assert(ios.width() == 0);
12960 }
12961 }
12962 }
12963 }
12964 showpos(ios);
12965 {
12966 noshowpoint(ios);
12967 {
12968 ios.imbue(lc);
12969 {
12970 ios.width(0);
12971 {
12972 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12973 std::string ex(str, iter.base());
12974 assert(ex == "+0.000000");
12975 assert(ios.width() == 0);
12976 }
12977 ios.width(25);
12978 left(ios);
12979 {
12980 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12981 std::string ex(str, iter.base());
12982 assert(ex == "+0.000000****************");
12983 assert(ios.width() == 0);
12984 }
12985 ios.width(25);
12986 right(ios);
12987 {
12988 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12989 std::string ex(str, iter.base());
12990 assert(ex == "****************+0.000000");
12991 assert(ios.width() == 0);
12992 }
12993 ios.width(25);
12994 internal(ios);
12995 {
12996 iter = f.put(output_iterator<char*>(str), ios, '*', v);
12997 std::string ex(str, iter.base());
12998 assert(ex == "+****************0.000000");
12999 assert(ios.width() == 0);
13000 }
13001 }
13002 ios.imbue(lg);
13003 {
13004 ios.width(0);
13005 {
13006 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13007 std::string ex(str, iter.base());
13008 assert(ex == "+0;000000");
13009 assert(ios.width() == 0);
13010 }
13011 ios.width(25);
13012 left(ios);
13013 {
13014 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13015 std::string ex(str, iter.base());
13016 assert(ex == "+0;000000****************");
13017 assert(ios.width() == 0);
13018 }
13019 ios.width(25);
13020 right(ios);
13021 {
13022 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13023 std::string ex(str, iter.base());
13024 assert(ex == "****************+0;000000");
13025 assert(ios.width() == 0);
13026 }
13027 ios.width(25);
13028 internal(ios);
13029 {
13030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13031 std::string ex(str, iter.base());
13032 assert(ex == "+****************0;000000");
13033 assert(ios.width() == 0);
13034 }
13035 }
13036 }
13037 showpoint(ios);
13038 {
13039 ios.imbue(lc);
13040 {
13041 ios.width(0);
13042 {
13043 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13044 std::string ex(str, iter.base());
13045 assert(ex == "+0.000000");
13046 assert(ios.width() == 0);
13047 }
13048 ios.width(25);
13049 left(ios);
13050 {
13051 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13052 std::string ex(str, iter.base());
13053 assert(ex == "+0.000000****************");
13054 assert(ios.width() == 0);
13055 }
13056 ios.width(25);
13057 right(ios);
13058 {
13059 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13060 std::string ex(str, iter.base());
13061 assert(ex == "****************+0.000000");
13062 assert(ios.width() == 0);
13063 }
13064 ios.width(25);
13065 internal(ios);
13066 {
13067 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13068 std::string ex(str, iter.base());
13069 assert(ex == "+****************0.000000");
13070 assert(ios.width() == 0);
13071 }
13072 }
13073 ios.imbue(lg);
13074 {
13075 ios.width(0);
13076 {
13077 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13078 std::string ex(str, iter.base());
13079 assert(ex == "+0;000000");
13080 assert(ios.width() == 0);
13081 }
13082 ios.width(25);
13083 left(ios);
13084 {
13085 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13086 std::string ex(str, iter.base());
13087 assert(ex == "+0;000000****************");
13088 assert(ios.width() == 0);
13089 }
13090 ios.width(25);
13091 right(ios);
13092 {
13093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13094 std::string ex(str, iter.base());
13095 assert(ex == "****************+0;000000");
13096 assert(ios.width() == 0);
13097 }
13098 ios.width(25);
13099 internal(ios);
13100 {
13101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13102 std::string ex(str, iter.base());
13103 assert(ex == "+****************0;000000");
13104 assert(ios.width() == 0);
13105 }
13106 }
13107 }
13108 }
13109 }
13110 }
13111 ios.precision(16);
13112 {
13113 nouppercase(ios);
13114 {
13115 noshowpos(ios);
13116 {
13117 noshowpoint(ios);
13118 {
13119 ios.imbue(lc);
13120 {
13121 ios.width(0);
13122 {
13123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13124 std::string ex(str, iter.base());
13125 assert(ex == "0.0000000000000000");
13126 assert(ios.width() == 0);
13127 }
13128 ios.width(25);
13129 left(ios);
13130 {
13131 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13132 std::string ex(str, iter.base());
13133 assert(ex == "0.0000000000000000*******");
13134 assert(ios.width() == 0);
13135 }
13136 ios.width(25);
13137 right(ios);
13138 {
13139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13140 std::string ex(str, iter.base());
13141 assert(ex == "*******0.0000000000000000");
13142 assert(ios.width() == 0);
13143 }
13144 ios.width(25);
13145 internal(ios);
13146 {
13147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13148 std::string ex(str, iter.base());
13149 assert(ex == "*******0.0000000000000000");
13150 assert(ios.width() == 0);
13151 }
13152 }
13153 ios.imbue(lg);
13154 {
13155 ios.width(0);
13156 {
13157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13158 std::string ex(str, iter.base());
13159 assert(ex == "0;0000000000000000");
13160 assert(ios.width() == 0);
13161 }
13162 ios.width(25);
13163 left(ios);
13164 {
13165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13166 std::string ex(str, iter.base());
13167 assert(ex == "0;0000000000000000*******");
13168 assert(ios.width() == 0);
13169 }
13170 ios.width(25);
13171 right(ios);
13172 {
13173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13174 std::string ex(str, iter.base());
13175 assert(ex == "*******0;0000000000000000");
13176 assert(ios.width() == 0);
13177 }
13178 ios.width(25);
13179 internal(ios);
13180 {
13181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13182 std::string ex(str, iter.base());
13183 assert(ex == "*******0;0000000000000000");
13184 assert(ios.width() == 0);
13185 }
13186 }
13187 }
13188 showpoint(ios);
13189 {
13190 ios.imbue(lc);
13191 {
13192 ios.width(0);
13193 {
13194 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13195 std::string ex(str, iter.base());
13196 assert(ex == "0.0000000000000000");
13197 assert(ios.width() == 0);
13198 }
13199 ios.width(25);
13200 left(ios);
13201 {
13202 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13203 std::string ex(str, iter.base());
13204 assert(ex == "0.0000000000000000*******");
13205 assert(ios.width() == 0);
13206 }
13207 ios.width(25);
13208 right(ios);
13209 {
13210 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13211 std::string ex(str, iter.base());
13212 assert(ex == "*******0.0000000000000000");
13213 assert(ios.width() == 0);
13214 }
13215 ios.width(25);
13216 internal(ios);
13217 {
13218 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13219 std::string ex(str, iter.base());
13220 assert(ex == "*******0.0000000000000000");
13221 assert(ios.width() == 0);
13222 }
13223 }
13224 ios.imbue(lg);
13225 {
13226 ios.width(0);
13227 {
13228 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13229 std::string ex(str, iter.base());
13230 assert(ex == "0;0000000000000000");
13231 assert(ios.width() == 0);
13232 }
13233 ios.width(25);
13234 left(ios);
13235 {
13236 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13237 std::string ex(str, iter.base());
13238 assert(ex == "0;0000000000000000*******");
13239 assert(ios.width() == 0);
13240 }
13241 ios.width(25);
13242 right(ios);
13243 {
13244 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13245 std::string ex(str, iter.base());
13246 assert(ex == "*******0;0000000000000000");
13247 assert(ios.width() == 0);
13248 }
13249 ios.width(25);
13250 internal(ios);
13251 {
13252 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13253 std::string ex(str, iter.base());
13254 assert(ex == "*******0;0000000000000000");
13255 assert(ios.width() == 0);
13256 }
13257 }
13258 }
13259 }
13260 showpos(ios);
13261 {
13262 noshowpoint(ios);
13263 {
13264 ios.imbue(lc);
13265 {
13266 ios.width(0);
13267 {
13268 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13269 std::string ex(str, iter.base());
13270 assert(ex == "+0.0000000000000000");
13271 assert(ios.width() == 0);
13272 }
13273 ios.width(25);
13274 left(ios);
13275 {
13276 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13277 std::string ex(str, iter.base());
13278 assert(ex == "+0.0000000000000000******");
13279 assert(ios.width() == 0);
13280 }
13281 ios.width(25);
13282 right(ios);
13283 {
13284 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13285 std::string ex(str, iter.base());
13286 assert(ex == "******+0.0000000000000000");
13287 assert(ios.width() == 0);
13288 }
13289 ios.width(25);
13290 internal(ios);
13291 {
13292 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13293 std::string ex(str, iter.base());
13294 assert(ex == "+******0.0000000000000000");
13295 assert(ios.width() == 0);
13296 }
13297 }
13298 ios.imbue(lg);
13299 {
13300 ios.width(0);
13301 {
13302 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13303 std::string ex(str, iter.base());
13304 assert(ex == "+0;0000000000000000");
13305 assert(ios.width() == 0);
13306 }
13307 ios.width(25);
13308 left(ios);
13309 {
13310 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13311 std::string ex(str, iter.base());
13312 assert(ex == "+0;0000000000000000******");
13313 assert(ios.width() == 0);
13314 }
13315 ios.width(25);
13316 right(ios);
13317 {
13318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13319 std::string ex(str, iter.base());
13320 assert(ex == "******+0;0000000000000000");
13321 assert(ios.width() == 0);
13322 }
13323 ios.width(25);
13324 internal(ios);
13325 {
13326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13327 std::string ex(str, iter.base());
13328 assert(ex == "+******0;0000000000000000");
13329 assert(ios.width() == 0);
13330 }
13331 }
13332 }
13333 showpoint(ios);
13334 {
13335 ios.imbue(lc);
13336 {
13337 ios.width(0);
13338 {
13339 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13340 std::string ex(str, iter.base());
13341 assert(ex == "+0.0000000000000000");
13342 assert(ios.width() == 0);
13343 }
13344 ios.width(25);
13345 left(ios);
13346 {
13347 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13348 std::string ex(str, iter.base());
13349 assert(ex == "+0.0000000000000000******");
13350 assert(ios.width() == 0);
13351 }
13352 ios.width(25);
13353 right(ios);
13354 {
13355 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13356 std::string ex(str, iter.base());
13357 assert(ex == "******+0.0000000000000000");
13358 assert(ios.width() == 0);
13359 }
13360 ios.width(25);
13361 internal(ios);
13362 {
13363 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13364 std::string ex(str, iter.base());
13365 assert(ex == "+******0.0000000000000000");
13366 assert(ios.width() == 0);
13367 }
13368 }
13369 ios.imbue(lg);
13370 {
13371 ios.width(0);
13372 {
13373 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13374 std::string ex(str, iter.base());
13375 assert(ex == "+0;0000000000000000");
13376 assert(ios.width() == 0);
13377 }
13378 ios.width(25);
13379 left(ios);
13380 {
13381 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13382 std::string ex(str, iter.base());
13383 assert(ex == "+0;0000000000000000******");
13384 assert(ios.width() == 0);
13385 }
13386 ios.width(25);
13387 right(ios);
13388 {
13389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13390 std::string ex(str, iter.base());
13391 assert(ex == "******+0;0000000000000000");
13392 assert(ios.width() == 0);
13393 }
13394 ios.width(25);
13395 internal(ios);
13396 {
13397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13398 std::string ex(str, iter.base());
13399 assert(ex == "+******0;0000000000000000");
13400 assert(ios.width() == 0);
13401 }
13402 }
13403 }
13404 }
13405 }
13406 uppercase(ios);
13407 {
13408 noshowpos(ios);
13409 {
13410 noshowpoint(ios);
13411 {
13412 ios.imbue(lc);
13413 {
13414 ios.width(0);
13415 {
13416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13417 std::string ex(str, iter.base());
13418 assert(ex == "0.0000000000000000");
13419 assert(ios.width() == 0);
13420 }
13421 ios.width(25);
13422 left(ios);
13423 {
13424 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13425 std::string ex(str, iter.base());
13426 assert(ex == "0.0000000000000000*******");
13427 assert(ios.width() == 0);
13428 }
13429 ios.width(25);
13430 right(ios);
13431 {
13432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13433 std::string ex(str, iter.base());
13434 assert(ex == "*******0.0000000000000000");
13435 assert(ios.width() == 0);
13436 }
13437 ios.width(25);
13438 internal(ios);
13439 {
13440 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13441 std::string ex(str, iter.base());
13442 assert(ex == "*******0.0000000000000000");
13443 assert(ios.width() == 0);
13444 }
13445 }
13446 ios.imbue(lg);
13447 {
13448 ios.width(0);
13449 {
13450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13451 std::string ex(str, iter.base());
13452 assert(ex == "0;0000000000000000");
13453 assert(ios.width() == 0);
13454 }
13455 ios.width(25);
13456 left(ios);
13457 {
13458 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13459 std::string ex(str, iter.base());
13460 assert(ex == "0;0000000000000000*******");
13461 assert(ios.width() == 0);
13462 }
13463 ios.width(25);
13464 right(ios);
13465 {
13466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13467 std::string ex(str, iter.base());
13468 assert(ex == "*******0;0000000000000000");
13469 assert(ios.width() == 0);
13470 }
13471 ios.width(25);
13472 internal(ios);
13473 {
13474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13475 std::string ex(str, iter.base());
13476 assert(ex == "*******0;0000000000000000");
13477 assert(ios.width() == 0);
13478 }
13479 }
13480 }
13481 showpoint(ios);
13482 {
13483 ios.imbue(lc);
13484 {
13485 ios.width(0);
13486 {
13487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13488 std::string ex(str, iter.base());
13489 assert(ex == "0.0000000000000000");
13490 assert(ios.width() == 0);
13491 }
13492 ios.width(25);
13493 left(ios);
13494 {
13495 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13496 std::string ex(str, iter.base());
13497 assert(ex == "0.0000000000000000*******");
13498 assert(ios.width() == 0);
13499 }
13500 ios.width(25);
13501 right(ios);
13502 {
13503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13504 std::string ex(str, iter.base());
13505 assert(ex == "*******0.0000000000000000");
13506 assert(ios.width() == 0);
13507 }
13508 ios.width(25);
13509 internal(ios);
13510 {
13511 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13512 std::string ex(str, iter.base());
13513 assert(ex == "*******0.0000000000000000");
13514 assert(ios.width() == 0);
13515 }
13516 }
13517 ios.imbue(lg);
13518 {
13519 ios.width(0);
13520 {
13521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13522 std::string ex(str, iter.base());
13523 assert(ex == "0;0000000000000000");
13524 assert(ios.width() == 0);
13525 }
13526 ios.width(25);
13527 left(ios);
13528 {
13529 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13530 std::string ex(str, iter.base());
13531 assert(ex == "0;0000000000000000*******");
13532 assert(ios.width() == 0);
13533 }
13534 ios.width(25);
13535 right(ios);
13536 {
13537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13538 std::string ex(str, iter.base());
13539 assert(ex == "*******0;0000000000000000");
13540 assert(ios.width() == 0);
13541 }
13542 ios.width(25);
13543 internal(ios);
13544 {
13545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13546 std::string ex(str, iter.base());
13547 assert(ex == "*******0;0000000000000000");
13548 assert(ios.width() == 0);
13549 }
13550 }
13551 }
13552 }
13553 showpos(ios);
13554 {
13555 noshowpoint(ios);
13556 {
13557 ios.imbue(lc);
13558 {
13559 ios.width(0);
13560 {
13561 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13562 std::string ex(str, iter.base());
13563 assert(ex == "+0.0000000000000000");
13564 assert(ios.width() == 0);
13565 }
13566 ios.width(25);
13567 left(ios);
13568 {
13569 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13570 std::string ex(str, iter.base());
13571 assert(ex == "+0.0000000000000000******");
13572 assert(ios.width() == 0);
13573 }
13574 ios.width(25);
13575 right(ios);
13576 {
13577 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13578 std::string ex(str, iter.base());
13579 assert(ex == "******+0.0000000000000000");
13580 assert(ios.width() == 0);
13581 }
13582 ios.width(25);
13583 internal(ios);
13584 {
13585 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13586 std::string ex(str, iter.base());
13587 assert(ex == "+******0.0000000000000000");
13588 assert(ios.width() == 0);
13589 }
13590 }
13591 ios.imbue(lg);
13592 {
13593 ios.width(0);
13594 {
13595 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13596 std::string ex(str, iter.base());
13597 assert(ex == "+0;0000000000000000");
13598 assert(ios.width() == 0);
13599 }
13600 ios.width(25);
13601 left(ios);
13602 {
13603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13604 std::string ex(str, iter.base());
13605 assert(ex == "+0;0000000000000000******");
13606 assert(ios.width() == 0);
13607 }
13608 ios.width(25);
13609 right(ios);
13610 {
13611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13612 std::string ex(str, iter.base());
13613 assert(ex == "******+0;0000000000000000");
13614 assert(ios.width() == 0);
13615 }
13616 ios.width(25);
13617 internal(ios);
13618 {
13619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13620 std::string ex(str, iter.base());
13621 assert(ex == "+******0;0000000000000000");
13622 assert(ios.width() == 0);
13623 }
13624 }
13625 }
13626 showpoint(ios);
13627 {
13628 ios.imbue(lc);
13629 {
13630 ios.width(0);
13631 {
13632 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13633 std::string ex(str, iter.base());
13634 assert(ex == "+0.0000000000000000");
13635 assert(ios.width() == 0);
13636 }
13637 ios.width(25);
13638 left(ios);
13639 {
13640 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13641 std::string ex(str, iter.base());
13642 assert(ex == "+0.0000000000000000******");
13643 assert(ios.width() == 0);
13644 }
13645 ios.width(25);
13646 right(ios);
13647 {
13648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13649 std::string ex(str, iter.base());
13650 assert(ex == "******+0.0000000000000000");
13651 assert(ios.width() == 0);
13652 }
13653 ios.width(25);
13654 internal(ios);
13655 {
13656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13657 std::string ex(str, iter.base());
13658 assert(ex == "+******0.0000000000000000");
13659 assert(ios.width() == 0);
13660 }
13661 }
13662 ios.imbue(lg);
13663 {
13664 ios.width(0);
13665 {
13666 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13667 std::string ex(str, iter.base());
13668 assert(ex == "+0;0000000000000000");
13669 assert(ios.width() == 0);
13670 }
13671 ios.width(25);
13672 left(ios);
13673 {
13674 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13675 std::string ex(str, iter.base());
13676 assert(ex == "+0;0000000000000000******");
13677 assert(ios.width() == 0);
13678 }
13679 ios.width(25);
13680 right(ios);
13681 {
13682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13683 std::string ex(str, iter.base());
13684 assert(ex == "******+0;0000000000000000");
13685 assert(ios.width() == 0);
13686 }
13687 ios.width(25);
13688 internal(ios);
13689 {
13690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13691 std::string ex(str, iter.base());
13692 assert(ex == "+******0;0000000000000000");
13693 assert(ios.width() == 0);
13694 }
13695 }
13696 }
13697 }
13698 }
13699 }
13700 ios.precision(60);
13701 {
13702 nouppercase(ios);
13703 {
13704 noshowpos(ios);
13705 {
13706 noshowpoint(ios);
13707 {
13708 ios.imbue(lc);
13709 {
13710 ios.width(0);
13711 {
13712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13713 std::string ex(str, iter.base());
13714 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13715 assert(ios.width() == 0);
13716 }
13717 ios.width(25);
13718 left(ios);
13719 {
13720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13721 std::string ex(str, iter.base());
13722 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13723 assert(ios.width() == 0);
13724 }
13725 ios.width(25);
13726 right(ios);
13727 {
13728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13729 std::string ex(str, iter.base());
13730 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13731 assert(ios.width() == 0);
13732 }
13733 ios.width(25);
13734 internal(ios);
13735 {
13736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13737 std::string ex(str, iter.base());
13738 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13739 assert(ios.width() == 0);
13740 }
13741 }
13742 ios.imbue(lg);
13743 {
13744 ios.width(0);
13745 {
13746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13747 std::string ex(str, iter.base());
13748 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13749 assert(ios.width() == 0);
13750 }
13751 ios.width(25);
13752 left(ios);
13753 {
13754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13755 std::string ex(str, iter.base());
13756 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13757 assert(ios.width() == 0);
13758 }
13759 ios.width(25);
13760 right(ios);
13761 {
13762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13763 std::string ex(str, iter.base());
13764 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13765 assert(ios.width() == 0);
13766 }
13767 ios.width(25);
13768 internal(ios);
13769 {
13770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13771 std::string ex(str, iter.base());
13772 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13773 assert(ios.width() == 0);
13774 }
13775 }
13776 }
13777 showpoint(ios);
13778 {
13779 ios.imbue(lc);
13780 {
13781 ios.width(0);
13782 {
13783 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13784 std::string ex(str, iter.base());
13785 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13786 assert(ios.width() == 0);
13787 }
13788 ios.width(25);
13789 left(ios);
13790 {
13791 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13792 std::string ex(str, iter.base());
13793 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13794 assert(ios.width() == 0);
13795 }
13796 ios.width(25);
13797 right(ios);
13798 {
13799 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13800 std::string ex(str, iter.base());
13801 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13802 assert(ios.width() == 0);
13803 }
13804 ios.width(25);
13805 internal(ios);
13806 {
13807 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13808 std::string ex(str, iter.base());
13809 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13810 assert(ios.width() == 0);
13811 }
13812 }
13813 ios.imbue(lg);
13814 {
13815 ios.width(0);
13816 {
13817 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13818 std::string ex(str, iter.base());
13819 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13820 assert(ios.width() == 0);
13821 }
13822 ios.width(25);
13823 left(ios);
13824 {
13825 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13826 std::string ex(str, iter.base());
13827 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13828 assert(ios.width() == 0);
13829 }
13830 ios.width(25);
13831 right(ios);
13832 {
13833 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13834 std::string ex(str, iter.base());
13835 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13836 assert(ios.width() == 0);
13837 }
13838 ios.width(25);
13839 internal(ios);
13840 {
13841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13842 std::string ex(str, iter.base());
13843 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13844 assert(ios.width() == 0);
13845 }
13846 }
13847 }
13848 }
13849 showpos(ios);
13850 {
13851 noshowpoint(ios);
13852 {
13853 ios.imbue(lc);
13854 {
13855 ios.width(0);
13856 {
13857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13858 std::string ex(str, iter.base());
13859 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13860 assert(ios.width() == 0);
13861 }
13862 ios.width(25);
13863 left(ios);
13864 {
13865 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13866 std::string ex(str, iter.base());
13867 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13868 assert(ios.width() == 0);
13869 }
13870 ios.width(25);
13871 right(ios);
13872 {
13873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13874 std::string ex(str, iter.base());
13875 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13876 assert(ios.width() == 0);
13877 }
13878 ios.width(25);
13879 internal(ios);
13880 {
13881 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13882 std::string ex(str, iter.base());
13883 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13884 assert(ios.width() == 0);
13885 }
13886 }
13887 ios.imbue(lg);
13888 {
13889 ios.width(0);
13890 {
13891 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13892 std::string ex(str, iter.base());
13893 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13894 assert(ios.width() == 0);
13895 }
13896 ios.width(25);
13897 left(ios);
13898 {
13899 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13900 std::string ex(str, iter.base());
13901 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13902 assert(ios.width() == 0);
13903 }
13904 ios.width(25);
13905 right(ios);
13906 {
13907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13908 std::string ex(str, iter.base());
13909 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13910 assert(ios.width() == 0);
13911 }
13912 ios.width(25);
13913 internal(ios);
13914 {
13915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13916 std::string ex(str, iter.base());
13917 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13918 assert(ios.width() == 0);
13919 }
13920 }
13921 }
13922 showpoint(ios);
13923 {
13924 ios.imbue(lc);
13925 {
13926 ios.width(0);
13927 {
13928 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13929 std::string ex(str, iter.base());
13930 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13931 assert(ios.width() == 0);
13932 }
13933 ios.width(25);
13934 left(ios);
13935 {
13936 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13937 std::string ex(str, iter.base());
13938 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13939 assert(ios.width() == 0);
13940 }
13941 ios.width(25);
13942 right(ios);
13943 {
13944 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13945 std::string ex(str, iter.base());
13946 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13947 assert(ios.width() == 0);
13948 }
13949 ios.width(25);
13950 internal(ios);
13951 {
13952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13953 std::string ex(str, iter.base());
13954 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13955 assert(ios.width() == 0);
13956 }
13957 }
13958 ios.imbue(lg);
13959 {
13960 ios.width(0);
13961 {
13962 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13963 std::string ex(str, iter.base());
13964 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13965 assert(ios.width() == 0);
13966 }
13967 ios.width(25);
13968 left(ios);
13969 {
13970 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13971 std::string ex(str, iter.base());
13972 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13973 assert(ios.width() == 0);
13974 }
13975 ios.width(25);
13976 right(ios);
13977 {
13978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13979 std::string ex(str, iter.base());
13980 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13981 assert(ios.width() == 0);
13982 }
13983 ios.width(25);
13984 internal(ios);
13985 {
13986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
13987 std::string ex(str, iter.base());
13988 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13989 assert(ios.width() == 0);
13990 }
13991 }
13992 }
13993 }
13994 }
13995 uppercase(ios);
13996 {
13997 noshowpos(ios);
13998 {
13999 noshowpoint(ios);
14000 {
14001 ios.imbue(lc);
14002 {
14003 ios.width(0);
14004 {
14005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14006 std::string ex(str, iter.base());
14007 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14008 assert(ios.width() == 0);
14009 }
14010 ios.width(25);
14011 left(ios);
14012 {
14013 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14014 std::string ex(str, iter.base());
14015 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14016 assert(ios.width() == 0);
14017 }
14018 ios.width(25);
14019 right(ios);
14020 {
14021 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14022 std::string ex(str, iter.base());
14023 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14024 assert(ios.width() == 0);
14025 }
14026 ios.width(25);
14027 internal(ios);
14028 {
14029 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14030 std::string ex(str, iter.base());
14031 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14032 assert(ios.width() == 0);
14033 }
14034 }
14035 ios.imbue(lg);
14036 {
14037 ios.width(0);
14038 {
14039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14040 std::string ex(str, iter.base());
14041 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14042 assert(ios.width() == 0);
14043 }
14044 ios.width(25);
14045 left(ios);
14046 {
14047 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14048 std::string ex(str, iter.base());
14049 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14050 assert(ios.width() == 0);
14051 }
14052 ios.width(25);
14053 right(ios);
14054 {
14055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14056 std::string ex(str, iter.base());
14057 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14058 assert(ios.width() == 0);
14059 }
14060 ios.width(25);
14061 internal(ios);
14062 {
14063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14064 std::string ex(str, iter.base());
14065 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14066 assert(ios.width() == 0);
14067 }
14068 }
14069 }
14070 showpoint(ios);
14071 {
14072 ios.imbue(lc);
14073 {
14074 ios.width(0);
14075 {
14076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14077 std::string ex(str, iter.base());
14078 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14079 assert(ios.width() == 0);
14080 }
14081 ios.width(25);
14082 left(ios);
14083 {
14084 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14085 std::string ex(str, iter.base());
14086 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14087 assert(ios.width() == 0);
14088 }
14089 ios.width(25);
14090 right(ios);
14091 {
14092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14093 std::string ex(str, iter.base());
14094 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14095 assert(ios.width() == 0);
14096 }
14097 ios.width(25);
14098 internal(ios);
14099 {
14100 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14101 std::string ex(str, iter.base());
14102 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14103 assert(ios.width() == 0);
14104 }
14105 }
14106 ios.imbue(lg);
14107 {
14108 ios.width(0);
14109 {
14110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14111 std::string ex(str, iter.base());
14112 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14113 assert(ios.width() == 0);
14114 }
14115 ios.width(25);
14116 left(ios);
14117 {
14118 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14119 std::string ex(str, iter.base());
14120 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14121 assert(ios.width() == 0);
14122 }
14123 ios.width(25);
14124 right(ios);
14125 {
14126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14127 std::string ex(str, iter.base());
14128 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14129 assert(ios.width() == 0);
14130 }
14131 ios.width(25);
14132 internal(ios);
14133 {
14134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14135 std::string ex(str, iter.base());
14136 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14137 assert(ios.width() == 0);
14138 }
14139 }
14140 }
14141 }
14142 showpos(ios);
14143 {
14144 noshowpoint(ios);
14145 {
14146 ios.imbue(lc);
14147 {
14148 ios.width(0);
14149 {
14150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14151 std::string ex(str, iter.base());
14152 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14153 assert(ios.width() == 0);
14154 }
14155 ios.width(25);
14156 left(ios);
14157 {
14158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14159 std::string ex(str, iter.base());
14160 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14161 assert(ios.width() == 0);
14162 }
14163 ios.width(25);
14164 right(ios);
14165 {
14166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14167 std::string ex(str, iter.base());
14168 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14169 assert(ios.width() == 0);
14170 }
14171 ios.width(25);
14172 internal(ios);
14173 {
14174 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14175 std::string ex(str, iter.base());
14176 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14177 assert(ios.width() == 0);
14178 }
14179 }
14180 ios.imbue(lg);
14181 {
14182 ios.width(0);
14183 {
14184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14185 std::string ex(str, iter.base());
14186 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14187 assert(ios.width() == 0);
14188 }
14189 ios.width(25);
14190 left(ios);
14191 {
14192 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14193 std::string ex(str, iter.base());
14194 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14195 assert(ios.width() == 0);
14196 }
14197 ios.width(25);
14198 right(ios);
14199 {
14200 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14201 std::string ex(str, iter.base());
14202 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14203 assert(ios.width() == 0);
14204 }
14205 ios.width(25);
14206 internal(ios);
14207 {
14208 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14209 std::string ex(str, iter.base());
14210 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14211 assert(ios.width() == 0);
14212 }
14213 }
14214 }
14215 showpoint(ios);
14216 {
14217 ios.imbue(lc);
14218 {
14219 ios.width(0);
14220 {
14221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14222 std::string ex(str, iter.base());
14223 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14224 assert(ios.width() == 0);
14225 }
14226 ios.width(25);
14227 left(ios);
14228 {
14229 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14230 std::string ex(str, iter.base());
14231 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14232 assert(ios.width() == 0);
14233 }
14234 ios.width(25);
14235 right(ios);
14236 {
14237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14238 std::string ex(str, iter.base());
14239 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14240 assert(ios.width() == 0);
14241 }
14242 ios.width(25);
14243 internal(ios);
14244 {
14245 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14246 std::string ex(str, iter.base());
14247 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14248 assert(ios.width() == 0);
14249 }
14250 }
14251 ios.imbue(lg);
14252 {
14253 ios.width(0);
14254 {
14255 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14256 std::string ex(str, iter.base());
14257 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14258 assert(ios.width() == 0);
14259 }
14260 ios.width(25);
14261 left(ios);
14262 {
14263 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14264 std::string ex(str, iter.base());
14265 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14266 assert(ios.width() == 0);
14267 }
14268 ios.width(25);
14269 right(ios);
14270 {
14271 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14272 std::string ex(str, iter.base());
14273 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14274 assert(ios.width() == 0);
14275 }
14276 ios.width(25);
14277 internal(ios);
14278 {
14279 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14280 std::string ex(str, iter.base());
14281 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14282 assert(ios.width() == 0);
14283 }
14284 }
14285 }
14286 }
14287 }
14288 }
14289 }
14290 }
14291 }
14292
test7()14293 void test7()
14294 {
14295 char str[200];
14296 output_iterator<char*> iter;
14297 std::locale lc = std::locale::classic();
14298 std::locale lg(lc, new my_numpunct);
14299 const my_facet f(1);
14300 {
14301 long double v = -0.;
14302 std::ios ios(0);
14303 fixed(ios);
14304 // %f
14305 {
14306 ios.precision(0);
14307 {
14308 nouppercase(ios);
14309 {
14310 noshowpos(ios);
14311 {
14312 noshowpoint(ios);
14313 {
14314 ios.imbue(lc);
14315 {
14316 ios.width(0);
14317 {
14318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14319 std::string ex(str, iter.base());
14320 assert(ex == "-0");
14321 assert(ios.width() == 0);
14322 }
14323 ios.width(25);
14324 left(ios);
14325 {
14326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14327 std::string ex(str, iter.base());
14328 assert(ex == "-0***********************");
14329 assert(ios.width() == 0);
14330 }
14331 ios.width(25);
14332 right(ios);
14333 {
14334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14335 std::string ex(str, iter.base());
14336 assert(ex == "***********************-0");
14337 assert(ios.width() == 0);
14338 }
14339 ios.width(25);
14340 internal(ios);
14341 {
14342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14343 std::string ex(str, iter.base());
14344 assert(ex == "-***********************0");
14345 assert(ios.width() == 0);
14346 }
14347 }
14348 ios.imbue(lg);
14349 {
14350 ios.width(0);
14351 {
14352 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14353 std::string ex(str, iter.base());
14354 assert(ex == "-0");
14355 assert(ios.width() == 0);
14356 }
14357 ios.width(25);
14358 left(ios);
14359 {
14360 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14361 std::string ex(str, iter.base());
14362 assert(ex == "-0***********************");
14363 assert(ios.width() == 0);
14364 }
14365 ios.width(25);
14366 right(ios);
14367 {
14368 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14369 std::string ex(str, iter.base());
14370 assert(ex == "***********************-0");
14371 assert(ios.width() == 0);
14372 }
14373 ios.width(25);
14374 internal(ios);
14375 {
14376 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14377 std::string ex(str, iter.base());
14378 assert(ex == "-***********************0");
14379 assert(ios.width() == 0);
14380 }
14381 }
14382 }
14383 showpoint(ios);
14384 {
14385 ios.imbue(lc);
14386 {
14387 ios.width(0);
14388 {
14389 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14390 std::string ex(str, iter.base());
14391 assert(ex == "-0.");
14392 assert(ios.width() == 0);
14393 }
14394 ios.width(25);
14395 left(ios);
14396 {
14397 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14398 std::string ex(str, iter.base());
14399 assert(ex == "-0.**********************");
14400 assert(ios.width() == 0);
14401 }
14402 ios.width(25);
14403 right(ios);
14404 {
14405 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14406 std::string ex(str, iter.base());
14407 assert(ex == "**********************-0.");
14408 assert(ios.width() == 0);
14409 }
14410 ios.width(25);
14411 internal(ios);
14412 {
14413 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14414 std::string ex(str, iter.base());
14415 assert(ex == "-**********************0.");
14416 assert(ios.width() == 0);
14417 }
14418 }
14419 ios.imbue(lg);
14420 {
14421 ios.width(0);
14422 {
14423 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14424 std::string ex(str, iter.base());
14425 assert(ex == "-0;");
14426 assert(ios.width() == 0);
14427 }
14428 ios.width(25);
14429 left(ios);
14430 {
14431 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14432 std::string ex(str, iter.base());
14433 assert(ex == "-0;**********************");
14434 assert(ios.width() == 0);
14435 }
14436 ios.width(25);
14437 right(ios);
14438 {
14439 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14440 std::string ex(str, iter.base());
14441 assert(ex == "**********************-0;");
14442 assert(ios.width() == 0);
14443 }
14444 ios.width(25);
14445 internal(ios);
14446 {
14447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14448 std::string ex(str, iter.base());
14449 assert(ex == "-**********************0;");
14450 assert(ios.width() == 0);
14451 }
14452 }
14453 }
14454 }
14455 showpos(ios);
14456 {
14457 noshowpoint(ios);
14458 {
14459 ios.imbue(lc);
14460 {
14461 ios.width(0);
14462 {
14463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14464 std::string ex(str, iter.base());
14465 assert(ex == "-0");
14466 assert(ios.width() == 0);
14467 }
14468 ios.width(25);
14469 left(ios);
14470 {
14471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14472 std::string ex(str, iter.base());
14473 assert(ex == "-0***********************");
14474 assert(ios.width() == 0);
14475 }
14476 ios.width(25);
14477 right(ios);
14478 {
14479 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14480 std::string ex(str, iter.base());
14481 assert(ex == "***********************-0");
14482 assert(ios.width() == 0);
14483 }
14484 ios.width(25);
14485 internal(ios);
14486 {
14487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14488 std::string ex(str, iter.base());
14489 assert(ex == "-***********************0");
14490 assert(ios.width() == 0);
14491 }
14492 }
14493 ios.imbue(lg);
14494 {
14495 ios.width(0);
14496 {
14497 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14498 std::string ex(str, iter.base());
14499 assert(ex == "-0");
14500 assert(ios.width() == 0);
14501 }
14502 ios.width(25);
14503 left(ios);
14504 {
14505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14506 std::string ex(str, iter.base());
14507 assert(ex == "-0***********************");
14508 assert(ios.width() == 0);
14509 }
14510 ios.width(25);
14511 right(ios);
14512 {
14513 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14514 std::string ex(str, iter.base());
14515 assert(ex == "***********************-0");
14516 assert(ios.width() == 0);
14517 }
14518 ios.width(25);
14519 internal(ios);
14520 {
14521 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14522 std::string ex(str, iter.base());
14523 assert(ex == "-***********************0");
14524 assert(ios.width() == 0);
14525 }
14526 }
14527 }
14528 showpoint(ios);
14529 {
14530 ios.imbue(lc);
14531 {
14532 ios.width(0);
14533 {
14534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14535 std::string ex(str, iter.base());
14536 assert(ex == "-0.");
14537 assert(ios.width() == 0);
14538 }
14539 ios.width(25);
14540 left(ios);
14541 {
14542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14543 std::string ex(str, iter.base());
14544 assert(ex == "-0.**********************");
14545 assert(ios.width() == 0);
14546 }
14547 ios.width(25);
14548 right(ios);
14549 {
14550 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14551 std::string ex(str, iter.base());
14552 assert(ex == "**********************-0.");
14553 assert(ios.width() == 0);
14554 }
14555 ios.width(25);
14556 internal(ios);
14557 {
14558 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14559 std::string ex(str, iter.base());
14560 assert(ex == "-**********************0.");
14561 assert(ios.width() == 0);
14562 }
14563 }
14564 ios.imbue(lg);
14565 {
14566 ios.width(0);
14567 {
14568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14569 std::string ex(str, iter.base());
14570 assert(ex == "-0;");
14571 assert(ios.width() == 0);
14572 }
14573 ios.width(25);
14574 left(ios);
14575 {
14576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14577 std::string ex(str, iter.base());
14578 assert(ex == "-0;**********************");
14579 assert(ios.width() == 0);
14580 }
14581 ios.width(25);
14582 right(ios);
14583 {
14584 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14585 std::string ex(str, iter.base());
14586 assert(ex == "**********************-0;");
14587 assert(ios.width() == 0);
14588 }
14589 ios.width(25);
14590 internal(ios);
14591 {
14592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14593 std::string ex(str, iter.base());
14594 assert(ex == "-**********************0;");
14595 assert(ios.width() == 0);
14596 }
14597 }
14598 }
14599 }
14600 }
14601 uppercase(ios);
14602 {
14603 noshowpos(ios);
14604 {
14605 noshowpoint(ios);
14606 {
14607 ios.imbue(lc);
14608 {
14609 ios.width(0);
14610 {
14611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14612 std::string ex(str, iter.base());
14613 assert(ex == "-0");
14614 assert(ios.width() == 0);
14615 }
14616 ios.width(25);
14617 left(ios);
14618 {
14619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14620 std::string ex(str, iter.base());
14621 assert(ex == "-0***********************");
14622 assert(ios.width() == 0);
14623 }
14624 ios.width(25);
14625 right(ios);
14626 {
14627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14628 std::string ex(str, iter.base());
14629 assert(ex == "***********************-0");
14630 assert(ios.width() == 0);
14631 }
14632 ios.width(25);
14633 internal(ios);
14634 {
14635 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14636 std::string ex(str, iter.base());
14637 assert(ex == "-***********************0");
14638 assert(ios.width() == 0);
14639 }
14640 }
14641 ios.imbue(lg);
14642 {
14643 ios.width(0);
14644 {
14645 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14646 std::string ex(str, iter.base());
14647 assert(ex == "-0");
14648 assert(ios.width() == 0);
14649 }
14650 ios.width(25);
14651 left(ios);
14652 {
14653 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14654 std::string ex(str, iter.base());
14655 assert(ex == "-0***********************");
14656 assert(ios.width() == 0);
14657 }
14658 ios.width(25);
14659 right(ios);
14660 {
14661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14662 std::string ex(str, iter.base());
14663 assert(ex == "***********************-0");
14664 assert(ios.width() == 0);
14665 }
14666 ios.width(25);
14667 internal(ios);
14668 {
14669 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14670 std::string ex(str, iter.base());
14671 assert(ex == "-***********************0");
14672 assert(ios.width() == 0);
14673 }
14674 }
14675 }
14676 showpoint(ios);
14677 {
14678 ios.imbue(lc);
14679 {
14680 ios.width(0);
14681 {
14682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14683 std::string ex(str, iter.base());
14684 assert(ex == "-0.");
14685 assert(ios.width() == 0);
14686 }
14687 ios.width(25);
14688 left(ios);
14689 {
14690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14691 std::string ex(str, iter.base());
14692 assert(ex == "-0.**********************");
14693 assert(ios.width() == 0);
14694 }
14695 ios.width(25);
14696 right(ios);
14697 {
14698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14699 std::string ex(str, iter.base());
14700 assert(ex == "**********************-0.");
14701 assert(ios.width() == 0);
14702 }
14703 ios.width(25);
14704 internal(ios);
14705 {
14706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14707 std::string ex(str, iter.base());
14708 assert(ex == "-**********************0.");
14709 assert(ios.width() == 0);
14710 }
14711 }
14712 ios.imbue(lg);
14713 {
14714 ios.width(0);
14715 {
14716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14717 std::string ex(str, iter.base());
14718 assert(ex == "-0;");
14719 assert(ios.width() == 0);
14720 }
14721 ios.width(25);
14722 left(ios);
14723 {
14724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14725 std::string ex(str, iter.base());
14726 assert(ex == "-0;**********************");
14727 assert(ios.width() == 0);
14728 }
14729 ios.width(25);
14730 right(ios);
14731 {
14732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14733 std::string ex(str, iter.base());
14734 assert(ex == "**********************-0;");
14735 assert(ios.width() == 0);
14736 }
14737 ios.width(25);
14738 internal(ios);
14739 {
14740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14741 std::string ex(str, iter.base());
14742 assert(ex == "-**********************0;");
14743 assert(ios.width() == 0);
14744 }
14745 }
14746 }
14747 }
14748 showpos(ios);
14749 {
14750 noshowpoint(ios);
14751 {
14752 ios.imbue(lc);
14753 {
14754 ios.width(0);
14755 {
14756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14757 std::string ex(str, iter.base());
14758 assert(ex == "-0");
14759 assert(ios.width() == 0);
14760 }
14761 ios.width(25);
14762 left(ios);
14763 {
14764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14765 std::string ex(str, iter.base());
14766 assert(ex == "-0***********************");
14767 assert(ios.width() == 0);
14768 }
14769 ios.width(25);
14770 right(ios);
14771 {
14772 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14773 std::string ex(str, iter.base());
14774 assert(ex == "***********************-0");
14775 assert(ios.width() == 0);
14776 }
14777 ios.width(25);
14778 internal(ios);
14779 {
14780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14781 std::string ex(str, iter.base());
14782 assert(ex == "-***********************0");
14783 assert(ios.width() == 0);
14784 }
14785 }
14786 ios.imbue(lg);
14787 {
14788 ios.width(0);
14789 {
14790 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14791 std::string ex(str, iter.base());
14792 assert(ex == "-0");
14793 assert(ios.width() == 0);
14794 }
14795 ios.width(25);
14796 left(ios);
14797 {
14798 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14799 std::string ex(str, iter.base());
14800 assert(ex == "-0***********************");
14801 assert(ios.width() == 0);
14802 }
14803 ios.width(25);
14804 right(ios);
14805 {
14806 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14807 std::string ex(str, iter.base());
14808 assert(ex == "***********************-0");
14809 assert(ios.width() == 0);
14810 }
14811 ios.width(25);
14812 internal(ios);
14813 {
14814 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14815 std::string ex(str, iter.base());
14816 assert(ex == "-***********************0");
14817 assert(ios.width() == 0);
14818 }
14819 }
14820 }
14821 showpoint(ios);
14822 {
14823 ios.imbue(lc);
14824 {
14825 ios.width(0);
14826 {
14827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14828 std::string ex(str, iter.base());
14829 assert(ex == "-0.");
14830 assert(ios.width() == 0);
14831 }
14832 ios.width(25);
14833 left(ios);
14834 {
14835 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14836 std::string ex(str, iter.base());
14837 assert(ex == "-0.**********************");
14838 assert(ios.width() == 0);
14839 }
14840 ios.width(25);
14841 right(ios);
14842 {
14843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14844 std::string ex(str, iter.base());
14845 assert(ex == "**********************-0.");
14846 assert(ios.width() == 0);
14847 }
14848 ios.width(25);
14849 internal(ios);
14850 {
14851 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14852 std::string ex(str, iter.base());
14853 assert(ex == "-**********************0.");
14854 assert(ios.width() == 0);
14855 }
14856 }
14857 ios.imbue(lg);
14858 {
14859 ios.width(0);
14860 {
14861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14862 std::string ex(str, iter.base());
14863 assert(ex == "-0;");
14864 assert(ios.width() == 0);
14865 }
14866 ios.width(25);
14867 left(ios);
14868 {
14869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14870 std::string ex(str, iter.base());
14871 assert(ex == "-0;**********************");
14872 assert(ios.width() == 0);
14873 }
14874 ios.width(25);
14875 right(ios);
14876 {
14877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14878 std::string ex(str, iter.base());
14879 assert(ex == "**********************-0;");
14880 assert(ios.width() == 0);
14881 }
14882 ios.width(25);
14883 internal(ios);
14884 {
14885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14886 std::string ex(str, iter.base());
14887 assert(ex == "-**********************0;");
14888 assert(ios.width() == 0);
14889 }
14890 }
14891 }
14892 }
14893 }
14894 }
14895 ios.precision(1);
14896 {
14897 nouppercase(ios);
14898 {
14899 noshowpos(ios);
14900 {
14901 noshowpoint(ios);
14902 {
14903 ios.imbue(lc);
14904 {
14905 ios.width(0);
14906 {
14907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14908 std::string ex(str, iter.base());
14909 assert(ex == "-0.0");
14910 assert(ios.width() == 0);
14911 }
14912 ios.width(25);
14913 left(ios);
14914 {
14915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14916 std::string ex(str, iter.base());
14917 assert(ex == "-0.0*********************");
14918 assert(ios.width() == 0);
14919 }
14920 ios.width(25);
14921 right(ios);
14922 {
14923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14924 std::string ex(str, iter.base());
14925 assert(ex == "*********************-0.0");
14926 assert(ios.width() == 0);
14927 }
14928 ios.width(25);
14929 internal(ios);
14930 {
14931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14932 std::string ex(str, iter.base());
14933 assert(ex == "-*********************0.0");
14934 assert(ios.width() == 0);
14935 }
14936 }
14937 ios.imbue(lg);
14938 {
14939 ios.width(0);
14940 {
14941 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14942 std::string ex(str, iter.base());
14943 assert(ex == "-0;0");
14944 assert(ios.width() == 0);
14945 }
14946 ios.width(25);
14947 left(ios);
14948 {
14949 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14950 std::string ex(str, iter.base());
14951 assert(ex == "-0;0*********************");
14952 assert(ios.width() == 0);
14953 }
14954 ios.width(25);
14955 right(ios);
14956 {
14957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14958 std::string ex(str, iter.base());
14959 assert(ex == "*********************-0;0");
14960 assert(ios.width() == 0);
14961 }
14962 ios.width(25);
14963 internal(ios);
14964 {
14965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14966 std::string ex(str, iter.base());
14967 assert(ex == "-*********************0;0");
14968 assert(ios.width() == 0);
14969 }
14970 }
14971 }
14972 showpoint(ios);
14973 {
14974 ios.imbue(lc);
14975 {
14976 ios.width(0);
14977 {
14978 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14979 std::string ex(str, iter.base());
14980 assert(ex == "-0.0");
14981 assert(ios.width() == 0);
14982 }
14983 ios.width(25);
14984 left(ios);
14985 {
14986 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14987 std::string ex(str, iter.base());
14988 assert(ex == "-0.0*********************");
14989 assert(ios.width() == 0);
14990 }
14991 ios.width(25);
14992 right(ios);
14993 {
14994 iter = f.put(output_iterator<char*>(str), ios, '*', v);
14995 std::string ex(str, iter.base());
14996 assert(ex == "*********************-0.0");
14997 assert(ios.width() == 0);
14998 }
14999 ios.width(25);
15000 internal(ios);
15001 {
15002 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15003 std::string ex(str, iter.base());
15004 assert(ex == "-*********************0.0");
15005 assert(ios.width() == 0);
15006 }
15007 }
15008 ios.imbue(lg);
15009 {
15010 ios.width(0);
15011 {
15012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15013 std::string ex(str, iter.base());
15014 assert(ex == "-0;0");
15015 assert(ios.width() == 0);
15016 }
15017 ios.width(25);
15018 left(ios);
15019 {
15020 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15021 std::string ex(str, iter.base());
15022 assert(ex == "-0;0*********************");
15023 assert(ios.width() == 0);
15024 }
15025 ios.width(25);
15026 right(ios);
15027 {
15028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15029 std::string ex(str, iter.base());
15030 assert(ex == "*********************-0;0");
15031 assert(ios.width() == 0);
15032 }
15033 ios.width(25);
15034 internal(ios);
15035 {
15036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15037 std::string ex(str, iter.base());
15038 assert(ex == "-*********************0;0");
15039 assert(ios.width() == 0);
15040 }
15041 }
15042 }
15043 }
15044 showpos(ios);
15045 {
15046 noshowpoint(ios);
15047 {
15048 ios.imbue(lc);
15049 {
15050 ios.width(0);
15051 {
15052 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15053 std::string ex(str, iter.base());
15054 assert(ex == "-0.0");
15055 assert(ios.width() == 0);
15056 }
15057 ios.width(25);
15058 left(ios);
15059 {
15060 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15061 std::string ex(str, iter.base());
15062 assert(ex == "-0.0*********************");
15063 assert(ios.width() == 0);
15064 }
15065 ios.width(25);
15066 right(ios);
15067 {
15068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15069 std::string ex(str, iter.base());
15070 assert(ex == "*********************-0.0");
15071 assert(ios.width() == 0);
15072 }
15073 ios.width(25);
15074 internal(ios);
15075 {
15076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15077 std::string ex(str, iter.base());
15078 assert(ex == "-*********************0.0");
15079 assert(ios.width() == 0);
15080 }
15081 }
15082 ios.imbue(lg);
15083 {
15084 ios.width(0);
15085 {
15086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15087 std::string ex(str, iter.base());
15088 assert(ex == "-0;0");
15089 assert(ios.width() == 0);
15090 }
15091 ios.width(25);
15092 left(ios);
15093 {
15094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15095 std::string ex(str, iter.base());
15096 assert(ex == "-0;0*********************");
15097 assert(ios.width() == 0);
15098 }
15099 ios.width(25);
15100 right(ios);
15101 {
15102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15103 std::string ex(str, iter.base());
15104 assert(ex == "*********************-0;0");
15105 assert(ios.width() == 0);
15106 }
15107 ios.width(25);
15108 internal(ios);
15109 {
15110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15111 std::string ex(str, iter.base());
15112 assert(ex == "-*********************0;0");
15113 assert(ios.width() == 0);
15114 }
15115 }
15116 }
15117 showpoint(ios);
15118 {
15119 ios.imbue(lc);
15120 {
15121 ios.width(0);
15122 {
15123 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15124 std::string ex(str, iter.base());
15125 assert(ex == "-0.0");
15126 assert(ios.width() == 0);
15127 }
15128 ios.width(25);
15129 left(ios);
15130 {
15131 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15132 std::string ex(str, iter.base());
15133 assert(ex == "-0.0*********************");
15134 assert(ios.width() == 0);
15135 }
15136 ios.width(25);
15137 right(ios);
15138 {
15139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15140 std::string ex(str, iter.base());
15141 assert(ex == "*********************-0.0");
15142 assert(ios.width() == 0);
15143 }
15144 ios.width(25);
15145 internal(ios);
15146 {
15147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15148 std::string ex(str, iter.base());
15149 assert(ex == "-*********************0.0");
15150 assert(ios.width() == 0);
15151 }
15152 }
15153 ios.imbue(lg);
15154 {
15155 ios.width(0);
15156 {
15157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15158 std::string ex(str, iter.base());
15159 assert(ex == "-0;0");
15160 assert(ios.width() == 0);
15161 }
15162 ios.width(25);
15163 left(ios);
15164 {
15165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15166 std::string ex(str, iter.base());
15167 assert(ex == "-0;0*********************");
15168 assert(ios.width() == 0);
15169 }
15170 ios.width(25);
15171 right(ios);
15172 {
15173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15174 std::string ex(str, iter.base());
15175 assert(ex == "*********************-0;0");
15176 assert(ios.width() == 0);
15177 }
15178 ios.width(25);
15179 internal(ios);
15180 {
15181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15182 std::string ex(str, iter.base());
15183 assert(ex == "-*********************0;0");
15184 assert(ios.width() == 0);
15185 }
15186 }
15187 }
15188 }
15189 }
15190 uppercase(ios);
15191 {
15192 noshowpos(ios);
15193 {
15194 noshowpoint(ios);
15195 {
15196 ios.imbue(lc);
15197 {
15198 ios.width(0);
15199 {
15200 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15201 std::string ex(str, iter.base());
15202 assert(ex == "-0.0");
15203 assert(ios.width() == 0);
15204 }
15205 ios.width(25);
15206 left(ios);
15207 {
15208 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15209 std::string ex(str, iter.base());
15210 assert(ex == "-0.0*********************");
15211 assert(ios.width() == 0);
15212 }
15213 ios.width(25);
15214 right(ios);
15215 {
15216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15217 std::string ex(str, iter.base());
15218 assert(ex == "*********************-0.0");
15219 assert(ios.width() == 0);
15220 }
15221 ios.width(25);
15222 internal(ios);
15223 {
15224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15225 std::string ex(str, iter.base());
15226 assert(ex == "-*********************0.0");
15227 assert(ios.width() == 0);
15228 }
15229 }
15230 ios.imbue(lg);
15231 {
15232 ios.width(0);
15233 {
15234 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15235 std::string ex(str, iter.base());
15236 assert(ex == "-0;0");
15237 assert(ios.width() == 0);
15238 }
15239 ios.width(25);
15240 left(ios);
15241 {
15242 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15243 std::string ex(str, iter.base());
15244 assert(ex == "-0;0*********************");
15245 assert(ios.width() == 0);
15246 }
15247 ios.width(25);
15248 right(ios);
15249 {
15250 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15251 std::string ex(str, iter.base());
15252 assert(ex == "*********************-0;0");
15253 assert(ios.width() == 0);
15254 }
15255 ios.width(25);
15256 internal(ios);
15257 {
15258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15259 std::string ex(str, iter.base());
15260 assert(ex == "-*********************0;0");
15261 assert(ios.width() == 0);
15262 }
15263 }
15264 }
15265 showpoint(ios);
15266 {
15267 ios.imbue(lc);
15268 {
15269 ios.width(0);
15270 {
15271 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15272 std::string ex(str, iter.base());
15273 assert(ex == "-0.0");
15274 assert(ios.width() == 0);
15275 }
15276 ios.width(25);
15277 left(ios);
15278 {
15279 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15280 std::string ex(str, iter.base());
15281 assert(ex == "-0.0*********************");
15282 assert(ios.width() == 0);
15283 }
15284 ios.width(25);
15285 right(ios);
15286 {
15287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15288 std::string ex(str, iter.base());
15289 assert(ex == "*********************-0.0");
15290 assert(ios.width() == 0);
15291 }
15292 ios.width(25);
15293 internal(ios);
15294 {
15295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15296 std::string ex(str, iter.base());
15297 assert(ex == "-*********************0.0");
15298 assert(ios.width() == 0);
15299 }
15300 }
15301 ios.imbue(lg);
15302 {
15303 ios.width(0);
15304 {
15305 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15306 std::string ex(str, iter.base());
15307 assert(ex == "-0;0");
15308 assert(ios.width() == 0);
15309 }
15310 ios.width(25);
15311 left(ios);
15312 {
15313 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15314 std::string ex(str, iter.base());
15315 assert(ex == "-0;0*********************");
15316 assert(ios.width() == 0);
15317 }
15318 ios.width(25);
15319 right(ios);
15320 {
15321 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15322 std::string ex(str, iter.base());
15323 assert(ex == "*********************-0;0");
15324 assert(ios.width() == 0);
15325 }
15326 ios.width(25);
15327 internal(ios);
15328 {
15329 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15330 std::string ex(str, iter.base());
15331 assert(ex == "-*********************0;0");
15332 assert(ios.width() == 0);
15333 }
15334 }
15335 }
15336 }
15337 showpos(ios);
15338 {
15339 noshowpoint(ios);
15340 {
15341 ios.imbue(lc);
15342 {
15343 ios.width(0);
15344 {
15345 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15346 std::string ex(str, iter.base());
15347 assert(ex == "-0.0");
15348 assert(ios.width() == 0);
15349 }
15350 ios.width(25);
15351 left(ios);
15352 {
15353 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15354 std::string ex(str, iter.base());
15355 assert(ex == "-0.0*********************");
15356 assert(ios.width() == 0);
15357 }
15358 ios.width(25);
15359 right(ios);
15360 {
15361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15362 std::string ex(str, iter.base());
15363 assert(ex == "*********************-0.0");
15364 assert(ios.width() == 0);
15365 }
15366 ios.width(25);
15367 internal(ios);
15368 {
15369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15370 std::string ex(str, iter.base());
15371 assert(ex == "-*********************0.0");
15372 assert(ios.width() == 0);
15373 }
15374 }
15375 ios.imbue(lg);
15376 {
15377 ios.width(0);
15378 {
15379 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15380 std::string ex(str, iter.base());
15381 assert(ex == "-0;0");
15382 assert(ios.width() == 0);
15383 }
15384 ios.width(25);
15385 left(ios);
15386 {
15387 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15388 std::string ex(str, iter.base());
15389 assert(ex == "-0;0*********************");
15390 assert(ios.width() == 0);
15391 }
15392 ios.width(25);
15393 right(ios);
15394 {
15395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15396 std::string ex(str, iter.base());
15397 assert(ex == "*********************-0;0");
15398 assert(ios.width() == 0);
15399 }
15400 ios.width(25);
15401 internal(ios);
15402 {
15403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15404 std::string ex(str, iter.base());
15405 assert(ex == "-*********************0;0");
15406 assert(ios.width() == 0);
15407 }
15408 }
15409 }
15410 showpoint(ios);
15411 {
15412 ios.imbue(lc);
15413 {
15414 ios.width(0);
15415 {
15416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15417 std::string ex(str, iter.base());
15418 assert(ex == "-0.0");
15419 assert(ios.width() == 0);
15420 }
15421 ios.width(25);
15422 left(ios);
15423 {
15424 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15425 std::string ex(str, iter.base());
15426 assert(ex == "-0.0*********************");
15427 assert(ios.width() == 0);
15428 }
15429 ios.width(25);
15430 right(ios);
15431 {
15432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15433 std::string ex(str, iter.base());
15434 assert(ex == "*********************-0.0");
15435 assert(ios.width() == 0);
15436 }
15437 ios.width(25);
15438 internal(ios);
15439 {
15440 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15441 std::string ex(str, iter.base());
15442 assert(ex == "-*********************0.0");
15443 assert(ios.width() == 0);
15444 }
15445 }
15446 ios.imbue(lg);
15447 {
15448 ios.width(0);
15449 {
15450 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15451 std::string ex(str, iter.base());
15452 assert(ex == "-0;0");
15453 assert(ios.width() == 0);
15454 }
15455 ios.width(25);
15456 left(ios);
15457 {
15458 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15459 std::string ex(str, iter.base());
15460 assert(ex == "-0;0*********************");
15461 assert(ios.width() == 0);
15462 }
15463 ios.width(25);
15464 right(ios);
15465 {
15466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15467 std::string ex(str, iter.base());
15468 assert(ex == "*********************-0;0");
15469 assert(ios.width() == 0);
15470 }
15471 ios.width(25);
15472 internal(ios);
15473 {
15474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15475 std::string ex(str, iter.base());
15476 assert(ex == "-*********************0;0");
15477 assert(ios.width() == 0);
15478 }
15479 }
15480 }
15481 }
15482 }
15483 }
15484 ios.precision(6);
15485 {
15486 nouppercase(ios);
15487 {
15488 noshowpos(ios);
15489 {
15490 noshowpoint(ios);
15491 {
15492 ios.imbue(lc);
15493 {
15494 ios.width(0);
15495 {
15496 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15497 std::string ex(str, iter.base());
15498 assert(ex == "-0.000000");
15499 assert(ios.width() == 0);
15500 }
15501 ios.width(25);
15502 left(ios);
15503 {
15504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15505 std::string ex(str, iter.base());
15506 assert(ex == "-0.000000****************");
15507 assert(ios.width() == 0);
15508 }
15509 ios.width(25);
15510 right(ios);
15511 {
15512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15513 std::string ex(str, iter.base());
15514 assert(ex == "****************-0.000000");
15515 assert(ios.width() == 0);
15516 }
15517 ios.width(25);
15518 internal(ios);
15519 {
15520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15521 std::string ex(str, iter.base());
15522 assert(ex == "-****************0.000000");
15523 assert(ios.width() == 0);
15524 }
15525 }
15526 ios.imbue(lg);
15527 {
15528 ios.width(0);
15529 {
15530 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15531 std::string ex(str, iter.base());
15532 assert(ex == "-0;000000");
15533 assert(ios.width() == 0);
15534 }
15535 ios.width(25);
15536 left(ios);
15537 {
15538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15539 std::string ex(str, iter.base());
15540 assert(ex == "-0;000000****************");
15541 assert(ios.width() == 0);
15542 }
15543 ios.width(25);
15544 right(ios);
15545 {
15546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15547 std::string ex(str, iter.base());
15548 assert(ex == "****************-0;000000");
15549 assert(ios.width() == 0);
15550 }
15551 ios.width(25);
15552 internal(ios);
15553 {
15554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15555 std::string ex(str, iter.base());
15556 assert(ex == "-****************0;000000");
15557 assert(ios.width() == 0);
15558 }
15559 }
15560 }
15561 showpoint(ios);
15562 {
15563 ios.imbue(lc);
15564 {
15565 ios.width(0);
15566 {
15567 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15568 std::string ex(str, iter.base());
15569 assert(ex == "-0.000000");
15570 assert(ios.width() == 0);
15571 }
15572 ios.width(25);
15573 left(ios);
15574 {
15575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15576 std::string ex(str, iter.base());
15577 assert(ex == "-0.000000****************");
15578 assert(ios.width() == 0);
15579 }
15580 ios.width(25);
15581 right(ios);
15582 {
15583 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15584 std::string ex(str, iter.base());
15585 assert(ex == "****************-0.000000");
15586 assert(ios.width() == 0);
15587 }
15588 ios.width(25);
15589 internal(ios);
15590 {
15591 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15592 std::string ex(str, iter.base());
15593 assert(ex == "-****************0.000000");
15594 assert(ios.width() == 0);
15595 }
15596 }
15597 ios.imbue(lg);
15598 {
15599 ios.width(0);
15600 {
15601 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15602 std::string ex(str, iter.base());
15603 assert(ex == "-0;000000");
15604 assert(ios.width() == 0);
15605 }
15606 ios.width(25);
15607 left(ios);
15608 {
15609 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15610 std::string ex(str, iter.base());
15611 assert(ex == "-0;000000****************");
15612 assert(ios.width() == 0);
15613 }
15614 ios.width(25);
15615 right(ios);
15616 {
15617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15618 std::string ex(str, iter.base());
15619 assert(ex == "****************-0;000000");
15620 assert(ios.width() == 0);
15621 }
15622 ios.width(25);
15623 internal(ios);
15624 {
15625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15626 std::string ex(str, iter.base());
15627 assert(ex == "-****************0;000000");
15628 assert(ios.width() == 0);
15629 }
15630 }
15631 }
15632 }
15633 showpos(ios);
15634 {
15635 noshowpoint(ios);
15636 {
15637 ios.imbue(lc);
15638 {
15639 ios.width(0);
15640 {
15641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15642 std::string ex(str, iter.base());
15643 assert(ex == "-0.000000");
15644 assert(ios.width() == 0);
15645 }
15646 ios.width(25);
15647 left(ios);
15648 {
15649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15650 std::string ex(str, iter.base());
15651 assert(ex == "-0.000000****************");
15652 assert(ios.width() == 0);
15653 }
15654 ios.width(25);
15655 right(ios);
15656 {
15657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15658 std::string ex(str, iter.base());
15659 assert(ex == "****************-0.000000");
15660 assert(ios.width() == 0);
15661 }
15662 ios.width(25);
15663 internal(ios);
15664 {
15665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15666 std::string ex(str, iter.base());
15667 assert(ex == "-****************0.000000");
15668 assert(ios.width() == 0);
15669 }
15670 }
15671 ios.imbue(lg);
15672 {
15673 ios.width(0);
15674 {
15675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15676 std::string ex(str, iter.base());
15677 assert(ex == "-0;000000");
15678 assert(ios.width() == 0);
15679 }
15680 ios.width(25);
15681 left(ios);
15682 {
15683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15684 std::string ex(str, iter.base());
15685 assert(ex == "-0;000000****************");
15686 assert(ios.width() == 0);
15687 }
15688 ios.width(25);
15689 right(ios);
15690 {
15691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15692 std::string ex(str, iter.base());
15693 assert(ex == "****************-0;000000");
15694 assert(ios.width() == 0);
15695 }
15696 ios.width(25);
15697 internal(ios);
15698 {
15699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15700 std::string ex(str, iter.base());
15701 assert(ex == "-****************0;000000");
15702 assert(ios.width() == 0);
15703 }
15704 }
15705 }
15706 showpoint(ios);
15707 {
15708 ios.imbue(lc);
15709 {
15710 ios.width(0);
15711 {
15712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15713 std::string ex(str, iter.base());
15714 assert(ex == "-0.000000");
15715 assert(ios.width() == 0);
15716 }
15717 ios.width(25);
15718 left(ios);
15719 {
15720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15721 std::string ex(str, iter.base());
15722 assert(ex == "-0.000000****************");
15723 assert(ios.width() == 0);
15724 }
15725 ios.width(25);
15726 right(ios);
15727 {
15728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15729 std::string ex(str, iter.base());
15730 assert(ex == "****************-0.000000");
15731 assert(ios.width() == 0);
15732 }
15733 ios.width(25);
15734 internal(ios);
15735 {
15736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15737 std::string ex(str, iter.base());
15738 assert(ex == "-****************0.000000");
15739 assert(ios.width() == 0);
15740 }
15741 }
15742 ios.imbue(lg);
15743 {
15744 ios.width(0);
15745 {
15746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15747 std::string ex(str, iter.base());
15748 assert(ex == "-0;000000");
15749 assert(ios.width() == 0);
15750 }
15751 ios.width(25);
15752 left(ios);
15753 {
15754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15755 std::string ex(str, iter.base());
15756 assert(ex == "-0;000000****************");
15757 assert(ios.width() == 0);
15758 }
15759 ios.width(25);
15760 right(ios);
15761 {
15762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15763 std::string ex(str, iter.base());
15764 assert(ex == "****************-0;000000");
15765 assert(ios.width() == 0);
15766 }
15767 ios.width(25);
15768 internal(ios);
15769 {
15770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15771 std::string ex(str, iter.base());
15772 assert(ex == "-****************0;000000");
15773 assert(ios.width() == 0);
15774 }
15775 }
15776 }
15777 }
15778 }
15779 uppercase(ios);
15780 {
15781 noshowpos(ios);
15782 {
15783 noshowpoint(ios);
15784 {
15785 ios.imbue(lc);
15786 {
15787 ios.width(0);
15788 {
15789 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15790 std::string ex(str, iter.base());
15791 assert(ex == "-0.000000");
15792 assert(ios.width() == 0);
15793 }
15794 ios.width(25);
15795 left(ios);
15796 {
15797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15798 std::string ex(str, iter.base());
15799 assert(ex == "-0.000000****************");
15800 assert(ios.width() == 0);
15801 }
15802 ios.width(25);
15803 right(ios);
15804 {
15805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15806 std::string ex(str, iter.base());
15807 assert(ex == "****************-0.000000");
15808 assert(ios.width() == 0);
15809 }
15810 ios.width(25);
15811 internal(ios);
15812 {
15813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15814 std::string ex(str, iter.base());
15815 assert(ex == "-****************0.000000");
15816 assert(ios.width() == 0);
15817 }
15818 }
15819 ios.imbue(lg);
15820 {
15821 ios.width(0);
15822 {
15823 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15824 std::string ex(str, iter.base());
15825 assert(ex == "-0;000000");
15826 assert(ios.width() == 0);
15827 }
15828 ios.width(25);
15829 left(ios);
15830 {
15831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15832 std::string ex(str, iter.base());
15833 assert(ex == "-0;000000****************");
15834 assert(ios.width() == 0);
15835 }
15836 ios.width(25);
15837 right(ios);
15838 {
15839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15840 std::string ex(str, iter.base());
15841 assert(ex == "****************-0;000000");
15842 assert(ios.width() == 0);
15843 }
15844 ios.width(25);
15845 internal(ios);
15846 {
15847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15848 std::string ex(str, iter.base());
15849 assert(ex == "-****************0;000000");
15850 assert(ios.width() == 0);
15851 }
15852 }
15853 }
15854 showpoint(ios);
15855 {
15856 ios.imbue(lc);
15857 {
15858 ios.width(0);
15859 {
15860 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15861 std::string ex(str, iter.base());
15862 assert(ex == "-0.000000");
15863 assert(ios.width() == 0);
15864 }
15865 ios.width(25);
15866 left(ios);
15867 {
15868 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15869 std::string ex(str, iter.base());
15870 assert(ex == "-0.000000****************");
15871 assert(ios.width() == 0);
15872 }
15873 ios.width(25);
15874 right(ios);
15875 {
15876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15877 std::string ex(str, iter.base());
15878 assert(ex == "****************-0.000000");
15879 assert(ios.width() == 0);
15880 }
15881 ios.width(25);
15882 internal(ios);
15883 {
15884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15885 std::string ex(str, iter.base());
15886 assert(ex == "-****************0.000000");
15887 assert(ios.width() == 0);
15888 }
15889 }
15890 ios.imbue(lg);
15891 {
15892 ios.width(0);
15893 {
15894 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15895 std::string ex(str, iter.base());
15896 assert(ex == "-0;000000");
15897 assert(ios.width() == 0);
15898 }
15899 ios.width(25);
15900 left(ios);
15901 {
15902 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15903 std::string ex(str, iter.base());
15904 assert(ex == "-0;000000****************");
15905 assert(ios.width() == 0);
15906 }
15907 ios.width(25);
15908 right(ios);
15909 {
15910 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15911 std::string ex(str, iter.base());
15912 assert(ex == "****************-0;000000");
15913 assert(ios.width() == 0);
15914 }
15915 ios.width(25);
15916 internal(ios);
15917 {
15918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15919 std::string ex(str, iter.base());
15920 assert(ex == "-****************0;000000");
15921 assert(ios.width() == 0);
15922 }
15923 }
15924 }
15925 }
15926 showpos(ios);
15927 {
15928 noshowpoint(ios);
15929 {
15930 ios.imbue(lc);
15931 {
15932 ios.width(0);
15933 {
15934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15935 std::string ex(str, iter.base());
15936 assert(ex == "-0.000000");
15937 assert(ios.width() == 0);
15938 }
15939 ios.width(25);
15940 left(ios);
15941 {
15942 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15943 std::string ex(str, iter.base());
15944 assert(ex == "-0.000000****************");
15945 assert(ios.width() == 0);
15946 }
15947 ios.width(25);
15948 right(ios);
15949 {
15950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15951 std::string ex(str, iter.base());
15952 assert(ex == "****************-0.000000");
15953 assert(ios.width() == 0);
15954 }
15955 ios.width(25);
15956 internal(ios);
15957 {
15958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15959 std::string ex(str, iter.base());
15960 assert(ex == "-****************0.000000");
15961 assert(ios.width() == 0);
15962 }
15963 }
15964 ios.imbue(lg);
15965 {
15966 ios.width(0);
15967 {
15968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15969 std::string ex(str, iter.base());
15970 assert(ex == "-0;000000");
15971 assert(ios.width() == 0);
15972 }
15973 ios.width(25);
15974 left(ios);
15975 {
15976 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15977 std::string ex(str, iter.base());
15978 assert(ex == "-0;000000****************");
15979 assert(ios.width() == 0);
15980 }
15981 ios.width(25);
15982 right(ios);
15983 {
15984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15985 std::string ex(str, iter.base());
15986 assert(ex == "****************-0;000000");
15987 assert(ios.width() == 0);
15988 }
15989 ios.width(25);
15990 internal(ios);
15991 {
15992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
15993 std::string ex(str, iter.base());
15994 assert(ex == "-****************0;000000");
15995 assert(ios.width() == 0);
15996 }
15997 }
15998 }
15999 showpoint(ios);
16000 {
16001 ios.imbue(lc);
16002 {
16003 ios.width(0);
16004 {
16005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16006 std::string ex(str, iter.base());
16007 assert(ex == "-0.000000");
16008 assert(ios.width() == 0);
16009 }
16010 ios.width(25);
16011 left(ios);
16012 {
16013 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16014 std::string ex(str, iter.base());
16015 assert(ex == "-0.000000****************");
16016 assert(ios.width() == 0);
16017 }
16018 ios.width(25);
16019 right(ios);
16020 {
16021 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16022 std::string ex(str, iter.base());
16023 assert(ex == "****************-0.000000");
16024 assert(ios.width() == 0);
16025 }
16026 ios.width(25);
16027 internal(ios);
16028 {
16029 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16030 std::string ex(str, iter.base());
16031 assert(ex == "-****************0.000000");
16032 assert(ios.width() == 0);
16033 }
16034 }
16035 ios.imbue(lg);
16036 {
16037 ios.width(0);
16038 {
16039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16040 std::string ex(str, iter.base());
16041 assert(ex == "-0;000000");
16042 assert(ios.width() == 0);
16043 }
16044 ios.width(25);
16045 left(ios);
16046 {
16047 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16048 std::string ex(str, iter.base());
16049 assert(ex == "-0;000000****************");
16050 assert(ios.width() == 0);
16051 }
16052 ios.width(25);
16053 right(ios);
16054 {
16055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16056 std::string ex(str, iter.base());
16057 assert(ex == "****************-0;000000");
16058 assert(ios.width() == 0);
16059 }
16060 ios.width(25);
16061 internal(ios);
16062 {
16063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16064 std::string ex(str, iter.base());
16065 assert(ex == "-****************0;000000");
16066 assert(ios.width() == 0);
16067 }
16068 }
16069 }
16070 }
16071 }
16072 }
16073 ios.precision(16);
16074 {
16075 nouppercase(ios);
16076 {
16077 noshowpos(ios);
16078 {
16079 noshowpoint(ios);
16080 {
16081 ios.imbue(lc);
16082 {
16083 ios.width(0);
16084 {
16085 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16086 std::string ex(str, iter.base());
16087 assert(ex == "-0.0000000000000000");
16088 assert(ios.width() == 0);
16089 }
16090 ios.width(25);
16091 left(ios);
16092 {
16093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16094 std::string ex(str, iter.base());
16095 assert(ex == "-0.0000000000000000******");
16096 assert(ios.width() == 0);
16097 }
16098 ios.width(25);
16099 right(ios);
16100 {
16101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16102 std::string ex(str, iter.base());
16103 assert(ex == "******-0.0000000000000000");
16104 assert(ios.width() == 0);
16105 }
16106 ios.width(25);
16107 internal(ios);
16108 {
16109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16110 std::string ex(str, iter.base());
16111 assert(ex == "-******0.0000000000000000");
16112 assert(ios.width() == 0);
16113 }
16114 }
16115 ios.imbue(lg);
16116 {
16117 ios.width(0);
16118 {
16119 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16120 std::string ex(str, iter.base());
16121 assert(ex == "-0;0000000000000000");
16122 assert(ios.width() == 0);
16123 }
16124 ios.width(25);
16125 left(ios);
16126 {
16127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16128 std::string ex(str, iter.base());
16129 assert(ex == "-0;0000000000000000******");
16130 assert(ios.width() == 0);
16131 }
16132 ios.width(25);
16133 right(ios);
16134 {
16135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16136 std::string ex(str, iter.base());
16137 assert(ex == "******-0;0000000000000000");
16138 assert(ios.width() == 0);
16139 }
16140 ios.width(25);
16141 internal(ios);
16142 {
16143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16144 std::string ex(str, iter.base());
16145 assert(ex == "-******0;0000000000000000");
16146 assert(ios.width() == 0);
16147 }
16148 }
16149 }
16150 showpoint(ios);
16151 {
16152 ios.imbue(lc);
16153 {
16154 ios.width(0);
16155 {
16156 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16157 std::string ex(str, iter.base());
16158 assert(ex == "-0.0000000000000000");
16159 assert(ios.width() == 0);
16160 }
16161 ios.width(25);
16162 left(ios);
16163 {
16164 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16165 std::string ex(str, iter.base());
16166 assert(ex == "-0.0000000000000000******");
16167 assert(ios.width() == 0);
16168 }
16169 ios.width(25);
16170 right(ios);
16171 {
16172 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16173 std::string ex(str, iter.base());
16174 assert(ex == "******-0.0000000000000000");
16175 assert(ios.width() == 0);
16176 }
16177 ios.width(25);
16178 internal(ios);
16179 {
16180 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16181 std::string ex(str, iter.base());
16182 assert(ex == "-******0.0000000000000000");
16183 assert(ios.width() == 0);
16184 }
16185 }
16186 ios.imbue(lg);
16187 {
16188 ios.width(0);
16189 {
16190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16191 std::string ex(str, iter.base());
16192 assert(ex == "-0;0000000000000000");
16193 assert(ios.width() == 0);
16194 }
16195 ios.width(25);
16196 left(ios);
16197 {
16198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16199 std::string ex(str, iter.base());
16200 assert(ex == "-0;0000000000000000******");
16201 assert(ios.width() == 0);
16202 }
16203 ios.width(25);
16204 right(ios);
16205 {
16206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16207 std::string ex(str, iter.base());
16208 assert(ex == "******-0;0000000000000000");
16209 assert(ios.width() == 0);
16210 }
16211 ios.width(25);
16212 internal(ios);
16213 {
16214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16215 std::string ex(str, iter.base());
16216 assert(ex == "-******0;0000000000000000");
16217 assert(ios.width() == 0);
16218 }
16219 }
16220 }
16221 }
16222 showpos(ios);
16223 {
16224 noshowpoint(ios);
16225 {
16226 ios.imbue(lc);
16227 {
16228 ios.width(0);
16229 {
16230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16231 std::string ex(str, iter.base());
16232 assert(ex == "-0.0000000000000000");
16233 assert(ios.width() == 0);
16234 }
16235 ios.width(25);
16236 left(ios);
16237 {
16238 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16239 std::string ex(str, iter.base());
16240 assert(ex == "-0.0000000000000000******");
16241 assert(ios.width() == 0);
16242 }
16243 ios.width(25);
16244 right(ios);
16245 {
16246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16247 std::string ex(str, iter.base());
16248 assert(ex == "******-0.0000000000000000");
16249 assert(ios.width() == 0);
16250 }
16251 ios.width(25);
16252 internal(ios);
16253 {
16254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16255 std::string ex(str, iter.base());
16256 assert(ex == "-******0.0000000000000000");
16257 assert(ios.width() == 0);
16258 }
16259 }
16260 ios.imbue(lg);
16261 {
16262 ios.width(0);
16263 {
16264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16265 std::string ex(str, iter.base());
16266 assert(ex == "-0;0000000000000000");
16267 assert(ios.width() == 0);
16268 }
16269 ios.width(25);
16270 left(ios);
16271 {
16272 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16273 std::string ex(str, iter.base());
16274 assert(ex == "-0;0000000000000000******");
16275 assert(ios.width() == 0);
16276 }
16277 ios.width(25);
16278 right(ios);
16279 {
16280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16281 std::string ex(str, iter.base());
16282 assert(ex == "******-0;0000000000000000");
16283 assert(ios.width() == 0);
16284 }
16285 ios.width(25);
16286 internal(ios);
16287 {
16288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16289 std::string ex(str, iter.base());
16290 assert(ex == "-******0;0000000000000000");
16291 assert(ios.width() == 0);
16292 }
16293 }
16294 }
16295 showpoint(ios);
16296 {
16297 ios.imbue(lc);
16298 {
16299 ios.width(0);
16300 {
16301 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16302 std::string ex(str, iter.base());
16303 assert(ex == "-0.0000000000000000");
16304 assert(ios.width() == 0);
16305 }
16306 ios.width(25);
16307 left(ios);
16308 {
16309 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16310 std::string ex(str, iter.base());
16311 assert(ex == "-0.0000000000000000******");
16312 assert(ios.width() == 0);
16313 }
16314 ios.width(25);
16315 right(ios);
16316 {
16317 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16318 std::string ex(str, iter.base());
16319 assert(ex == "******-0.0000000000000000");
16320 assert(ios.width() == 0);
16321 }
16322 ios.width(25);
16323 internal(ios);
16324 {
16325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16326 std::string ex(str, iter.base());
16327 assert(ex == "-******0.0000000000000000");
16328 assert(ios.width() == 0);
16329 }
16330 }
16331 ios.imbue(lg);
16332 {
16333 ios.width(0);
16334 {
16335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16336 std::string ex(str, iter.base());
16337 assert(ex == "-0;0000000000000000");
16338 assert(ios.width() == 0);
16339 }
16340 ios.width(25);
16341 left(ios);
16342 {
16343 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16344 std::string ex(str, iter.base());
16345 assert(ex == "-0;0000000000000000******");
16346 assert(ios.width() == 0);
16347 }
16348 ios.width(25);
16349 right(ios);
16350 {
16351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16352 std::string ex(str, iter.base());
16353 assert(ex == "******-0;0000000000000000");
16354 assert(ios.width() == 0);
16355 }
16356 ios.width(25);
16357 internal(ios);
16358 {
16359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16360 std::string ex(str, iter.base());
16361 assert(ex == "-******0;0000000000000000");
16362 assert(ios.width() == 0);
16363 }
16364 }
16365 }
16366 }
16367 }
16368 uppercase(ios);
16369 {
16370 noshowpos(ios);
16371 {
16372 noshowpoint(ios);
16373 {
16374 ios.imbue(lc);
16375 {
16376 ios.width(0);
16377 {
16378 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16379 std::string ex(str, iter.base());
16380 assert(ex == "-0.0000000000000000");
16381 assert(ios.width() == 0);
16382 }
16383 ios.width(25);
16384 left(ios);
16385 {
16386 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16387 std::string ex(str, iter.base());
16388 assert(ex == "-0.0000000000000000******");
16389 assert(ios.width() == 0);
16390 }
16391 ios.width(25);
16392 right(ios);
16393 {
16394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16395 std::string ex(str, iter.base());
16396 assert(ex == "******-0.0000000000000000");
16397 assert(ios.width() == 0);
16398 }
16399 ios.width(25);
16400 internal(ios);
16401 {
16402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16403 std::string ex(str, iter.base());
16404 assert(ex == "-******0.0000000000000000");
16405 assert(ios.width() == 0);
16406 }
16407 }
16408 ios.imbue(lg);
16409 {
16410 ios.width(0);
16411 {
16412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16413 std::string ex(str, iter.base());
16414 assert(ex == "-0;0000000000000000");
16415 assert(ios.width() == 0);
16416 }
16417 ios.width(25);
16418 left(ios);
16419 {
16420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16421 std::string ex(str, iter.base());
16422 assert(ex == "-0;0000000000000000******");
16423 assert(ios.width() == 0);
16424 }
16425 ios.width(25);
16426 right(ios);
16427 {
16428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16429 std::string ex(str, iter.base());
16430 assert(ex == "******-0;0000000000000000");
16431 assert(ios.width() == 0);
16432 }
16433 ios.width(25);
16434 internal(ios);
16435 {
16436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16437 std::string ex(str, iter.base());
16438 assert(ex == "-******0;0000000000000000");
16439 assert(ios.width() == 0);
16440 }
16441 }
16442 }
16443 showpoint(ios);
16444 {
16445 ios.imbue(lc);
16446 {
16447 ios.width(0);
16448 {
16449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16450 std::string ex(str, iter.base());
16451 assert(ex == "-0.0000000000000000");
16452 assert(ios.width() == 0);
16453 }
16454 ios.width(25);
16455 left(ios);
16456 {
16457 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16458 std::string ex(str, iter.base());
16459 assert(ex == "-0.0000000000000000******");
16460 assert(ios.width() == 0);
16461 }
16462 ios.width(25);
16463 right(ios);
16464 {
16465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16466 std::string ex(str, iter.base());
16467 assert(ex == "******-0.0000000000000000");
16468 assert(ios.width() == 0);
16469 }
16470 ios.width(25);
16471 internal(ios);
16472 {
16473 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16474 std::string ex(str, iter.base());
16475 assert(ex == "-******0.0000000000000000");
16476 assert(ios.width() == 0);
16477 }
16478 }
16479 ios.imbue(lg);
16480 {
16481 ios.width(0);
16482 {
16483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16484 std::string ex(str, iter.base());
16485 assert(ex == "-0;0000000000000000");
16486 assert(ios.width() == 0);
16487 }
16488 ios.width(25);
16489 left(ios);
16490 {
16491 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16492 std::string ex(str, iter.base());
16493 assert(ex == "-0;0000000000000000******");
16494 assert(ios.width() == 0);
16495 }
16496 ios.width(25);
16497 right(ios);
16498 {
16499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16500 std::string ex(str, iter.base());
16501 assert(ex == "******-0;0000000000000000");
16502 assert(ios.width() == 0);
16503 }
16504 ios.width(25);
16505 internal(ios);
16506 {
16507 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16508 std::string ex(str, iter.base());
16509 assert(ex == "-******0;0000000000000000");
16510 assert(ios.width() == 0);
16511 }
16512 }
16513 }
16514 }
16515 showpos(ios);
16516 {
16517 noshowpoint(ios);
16518 {
16519 ios.imbue(lc);
16520 {
16521 ios.width(0);
16522 {
16523 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16524 std::string ex(str, iter.base());
16525 assert(ex == "-0.0000000000000000");
16526 assert(ios.width() == 0);
16527 }
16528 ios.width(25);
16529 left(ios);
16530 {
16531 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16532 std::string ex(str, iter.base());
16533 assert(ex == "-0.0000000000000000******");
16534 assert(ios.width() == 0);
16535 }
16536 ios.width(25);
16537 right(ios);
16538 {
16539 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16540 std::string ex(str, iter.base());
16541 assert(ex == "******-0.0000000000000000");
16542 assert(ios.width() == 0);
16543 }
16544 ios.width(25);
16545 internal(ios);
16546 {
16547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16548 std::string ex(str, iter.base());
16549 assert(ex == "-******0.0000000000000000");
16550 assert(ios.width() == 0);
16551 }
16552 }
16553 ios.imbue(lg);
16554 {
16555 ios.width(0);
16556 {
16557 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16558 std::string ex(str, iter.base());
16559 assert(ex == "-0;0000000000000000");
16560 assert(ios.width() == 0);
16561 }
16562 ios.width(25);
16563 left(ios);
16564 {
16565 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16566 std::string ex(str, iter.base());
16567 assert(ex == "-0;0000000000000000******");
16568 assert(ios.width() == 0);
16569 }
16570 ios.width(25);
16571 right(ios);
16572 {
16573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16574 std::string ex(str, iter.base());
16575 assert(ex == "******-0;0000000000000000");
16576 assert(ios.width() == 0);
16577 }
16578 ios.width(25);
16579 internal(ios);
16580 {
16581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16582 std::string ex(str, iter.base());
16583 assert(ex == "-******0;0000000000000000");
16584 assert(ios.width() == 0);
16585 }
16586 }
16587 }
16588 showpoint(ios);
16589 {
16590 ios.imbue(lc);
16591 {
16592 ios.width(0);
16593 {
16594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16595 std::string ex(str, iter.base());
16596 assert(ex == "-0.0000000000000000");
16597 assert(ios.width() == 0);
16598 }
16599 ios.width(25);
16600 left(ios);
16601 {
16602 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16603 std::string ex(str, iter.base());
16604 assert(ex == "-0.0000000000000000******");
16605 assert(ios.width() == 0);
16606 }
16607 ios.width(25);
16608 right(ios);
16609 {
16610 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16611 std::string ex(str, iter.base());
16612 assert(ex == "******-0.0000000000000000");
16613 assert(ios.width() == 0);
16614 }
16615 ios.width(25);
16616 internal(ios);
16617 {
16618 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16619 std::string ex(str, iter.base());
16620 assert(ex == "-******0.0000000000000000");
16621 assert(ios.width() == 0);
16622 }
16623 }
16624 ios.imbue(lg);
16625 {
16626 ios.width(0);
16627 {
16628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16629 std::string ex(str, iter.base());
16630 assert(ex == "-0;0000000000000000");
16631 assert(ios.width() == 0);
16632 }
16633 ios.width(25);
16634 left(ios);
16635 {
16636 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16637 std::string ex(str, iter.base());
16638 assert(ex == "-0;0000000000000000******");
16639 assert(ios.width() == 0);
16640 }
16641 ios.width(25);
16642 right(ios);
16643 {
16644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16645 std::string ex(str, iter.base());
16646 assert(ex == "******-0;0000000000000000");
16647 assert(ios.width() == 0);
16648 }
16649 ios.width(25);
16650 internal(ios);
16651 {
16652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16653 std::string ex(str, iter.base());
16654 assert(ex == "-******0;0000000000000000");
16655 assert(ios.width() == 0);
16656 }
16657 }
16658 }
16659 }
16660 }
16661 }
16662 ios.precision(60);
16663 {
16664 nouppercase(ios);
16665 {
16666 noshowpos(ios);
16667 {
16668 noshowpoint(ios);
16669 {
16670 ios.imbue(lc);
16671 {
16672 ios.width(0);
16673 {
16674 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16675 std::string ex(str, iter.base());
16676 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16677 assert(ios.width() == 0);
16678 }
16679 ios.width(25);
16680 left(ios);
16681 {
16682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16683 std::string ex(str, iter.base());
16684 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16685 assert(ios.width() == 0);
16686 }
16687 ios.width(25);
16688 right(ios);
16689 {
16690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16691 std::string ex(str, iter.base());
16692 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16693 assert(ios.width() == 0);
16694 }
16695 ios.width(25);
16696 internal(ios);
16697 {
16698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16699 std::string ex(str, iter.base());
16700 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16701 assert(ios.width() == 0);
16702 }
16703 }
16704 ios.imbue(lg);
16705 {
16706 ios.width(0);
16707 {
16708 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16709 std::string ex(str, iter.base());
16710 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16711 assert(ios.width() == 0);
16712 }
16713 ios.width(25);
16714 left(ios);
16715 {
16716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16717 std::string ex(str, iter.base());
16718 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16719 assert(ios.width() == 0);
16720 }
16721 ios.width(25);
16722 right(ios);
16723 {
16724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16725 std::string ex(str, iter.base());
16726 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16727 assert(ios.width() == 0);
16728 }
16729 ios.width(25);
16730 internal(ios);
16731 {
16732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16733 std::string ex(str, iter.base());
16734 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16735 assert(ios.width() == 0);
16736 }
16737 }
16738 }
16739 showpoint(ios);
16740 {
16741 ios.imbue(lc);
16742 {
16743 ios.width(0);
16744 {
16745 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16746 std::string ex(str, iter.base());
16747 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16748 assert(ios.width() == 0);
16749 }
16750 ios.width(25);
16751 left(ios);
16752 {
16753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16754 std::string ex(str, iter.base());
16755 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16756 assert(ios.width() == 0);
16757 }
16758 ios.width(25);
16759 right(ios);
16760 {
16761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16762 std::string ex(str, iter.base());
16763 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16764 assert(ios.width() == 0);
16765 }
16766 ios.width(25);
16767 internal(ios);
16768 {
16769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16770 std::string ex(str, iter.base());
16771 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16772 assert(ios.width() == 0);
16773 }
16774 }
16775 ios.imbue(lg);
16776 {
16777 ios.width(0);
16778 {
16779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16780 std::string ex(str, iter.base());
16781 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16782 assert(ios.width() == 0);
16783 }
16784 ios.width(25);
16785 left(ios);
16786 {
16787 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16788 std::string ex(str, iter.base());
16789 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16790 assert(ios.width() == 0);
16791 }
16792 ios.width(25);
16793 right(ios);
16794 {
16795 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16796 std::string ex(str, iter.base());
16797 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16798 assert(ios.width() == 0);
16799 }
16800 ios.width(25);
16801 internal(ios);
16802 {
16803 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16804 std::string ex(str, iter.base());
16805 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16806 assert(ios.width() == 0);
16807 }
16808 }
16809 }
16810 }
16811 showpos(ios);
16812 {
16813 noshowpoint(ios);
16814 {
16815 ios.imbue(lc);
16816 {
16817 ios.width(0);
16818 {
16819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16820 std::string ex(str, iter.base());
16821 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16822 assert(ios.width() == 0);
16823 }
16824 ios.width(25);
16825 left(ios);
16826 {
16827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16828 std::string ex(str, iter.base());
16829 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16830 assert(ios.width() == 0);
16831 }
16832 ios.width(25);
16833 right(ios);
16834 {
16835 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16836 std::string ex(str, iter.base());
16837 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16838 assert(ios.width() == 0);
16839 }
16840 ios.width(25);
16841 internal(ios);
16842 {
16843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16844 std::string ex(str, iter.base());
16845 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16846 assert(ios.width() == 0);
16847 }
16848 }
16849 ios.imbue(lg);
16850 {
16851 ios.width(0);
16852 {
16853 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16854 std::string ex(str, iter.base());
16855 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16856 assert(ios.width() == 0);
16857 }
16858 ios.width(25);
16859 left(ios);
16860 {
16861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16862 std::string ex(str, iter.base());
16863 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16864 assert(ios.width() == 0);
16865 }
16866 ios.width(25);
16867 right(ios);
16868 {
16869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16870 std::string ex(str, iter.base());
16871 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16872 assert(ios.width() == 0);
16873 }
16874 ios.width(25);
16875 internal(ios);
16876 {
16877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16878 std::string ex(str, iter.base());
16879 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16880 assert(ios.width() == 0);
16881 }
16882 }
16883 }
16884 showpoint(ios);
16885 {
16886 ios.imbue(lc);
16887 {
16888 ios.width(0);
16889 {
16890 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16891 std::string ex(str, iter.base());
16892 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16893 assert(ios.width() == 0);
16894 }
16895 ios.width(25);
16896 left(ios);
16897 {
16898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16899 std::string ex(str, iter.base());
16900 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16901 assert(ios.width() == 0);
16902 }
16903 ios.width(25);
16904 right(ios);
16905 {
16906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16907 std::string ex(str, iter.base());
16908 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16909 assert(ios.width() == 0);
16910 }
16911 ios.width(25);
16912 internal(ios);
16913 {
16914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16915 std::string ex(str, iter.base());
16916 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16917 assert(ios.width() == 0);
16918 }
16919 }
16920 ios.imbue(lg);
16921 {
16922 ios.width(0);
16923 {
16924 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16925 std::string ex(str, iter.base());
16926 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16927 assert(ios.width() == 0);
16928 }
16929 ios.width(25);
16930 left(ios);
16931 {
16932 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16933 std::string ex(str, iter.base());
16934 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16935 assert(ios.width() == 0);
16936 }
16937 ios.width(25);
16938 right(ios);
16939 {
16940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16941 std::string ex(str, iter.base());
16942 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16943 assert(ios.width() == 0);
16944 }
16945 ios.width(25);
16946 internal(ios);
16947 {
16948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16949 std::string ex(str, iter.base());
16950 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16951 assert(ios.width() == 0);
16952 }
16953 }
16954 }
16955 }
16956 }
16957 uppercase(ios);
16958 {
16959 noshowpos(ios);
16960 {
16961 noshowpoint(ios);
16962 {
16963 ios.imbue(lc);
16964 {
16965 ios.width(0);
16966 {
16967 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16968 std::string ex(str, iter.base());
16969 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16970 assert(ios.width() == 0);
16971 }
16972 ios.width(25);
16973 left(ios);
16974 {
16975 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16976 std::string ex(str, iter.base());
16977 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16978 assert(ios.width() == 0);
16979 }
16980 ios.width(25);
16981 right(ios);
16982 {
16983 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16984 std::string ex(str, iter.base());
16985 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16986 assert(ios.width() == 0);
16987 }
16988 ios.width(25);
16989 internal(ios);
16990 {
16991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
16992 std::string ex(str, iter.base());
16993 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16994 assert(ios.width() == 0);
16995 }
16996 }
16997 ios.imbue(lg);
16998 {
16999 ios.width(0);
17000 {
17001 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17002 std::string ex(str, iter.base());
17003 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17004 assert(ios.width() == 0);
17005 }
17006 ios.width(25);
17007 left(ios);
17008 {
17009 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17010 std::string ex(str, iter.base());
17011 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17012 assert(ios.width() == 0);
17013 }
17014 ios.width(25);
17015 right(ios);
17016 {
17017 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17018 std::string ex(str, iter.base());
17019 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17020 assert(ios.width() == 0);
17021 }
17022 ios.width(25);
17023 internal(ios);
17024 {
17025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17026 std::string ex(str, iter.base());
17027 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17028 assert(ios.width() == 0);
17029 }
17030 }
17031 }
17032 showpoint(ios);
17033 {
17034 ios.imbue(lc);
17035 {
17036 ios.width(0);
17037 {
17038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17039 std::string ex(str, iter.base());
17040 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17041 assert(ios.width() == 0);
17042 }
17043 ios.width(25);
17044 left(ios);
17045 {
17046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17047 std::string ex(str, iter.base());
17048 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17049 assert(ios.width() == 0);
17050 }
17051 ios.width(25);
17052 right(ios);
17053 {
17054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17055 std::string ex(str, iter.base());
17056 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17057 assert(ios.width() == 0);
17058 }
17059 ios.width(25);
17060 internal(ios);
17061 {
17062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17063 std::string ex(str, iter.base());
17064 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17065 assert(ios.width() == 0);
17066 }
17067 }
17068 ios.imbue(lg);
17069 {
17070 ios.width(0);
17071 {
17072 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17073 std::string ex(str, iter.base());
17074 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17075 assert(ios.width() == 0);
17076 }
17077 ios.width(25);
17078 left(ios);
17079 {
17080 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17081 std::string ex(str, iter.base());
17082 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17083 assert(ios.width() == 0);
17084 }
17085 ios.width(25);
17086 right(ios);
17087 {
17088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17089 std::string ex(str, iter.base());
17090 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17091 assert(ios.width() == 0);
17092 }
17093 ios.width(25);
17094 internal(ios);
17095 {
17096 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17097 std::string ex(str, iter.base());
17098 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17099 assert(ios.width() == 0);
17100 }
17101 }
17102 }
17103 }
17104 showpos(ios);
17105 {
17106 noshowpoint(ios);
17107 {
17108 ios.imbue(lc);
17109 {
17110 ios.width(0);
17111 {
17112 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17113 std::string ex(str, iter.base());
17114 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17115 assert(ios.width() == 0);
17116 }
17117 ios.width(25);
17118 left(ios);
17119 {
17120 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17121 std::string ex(str, iter.base());
17122 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17123 assert(ios.width() == 0);
17124 }
17125 ios.width(25);
17126 right(ios);
17127 {
17128 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17129 std::string ex(str, iter.base());
17130 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17131 assert(ios.width() == 0);
17132 }
17133 ios.width(25);
17134 internal(ios);
17135 {
17136 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17137 std::string ex(str, iter.base());
17138 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17139 assert(ios.width() == 0);
17140 }
17141 }
17142 ios.imbue(lg);
17143 {
17144 ios.width(0);
17145 {
17146 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17147 std::string ex(str, iter.base());
17148 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17149 assert(ios.width() == 0);
17150 }
17151 ios.width(25);
17152 left(ios);
17153 {
17154 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17155 std::string ex(str, iter.base());
17156 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17157 assert(ios.width() == 0);
17158 }
17159 ios.width(25);
17160 right(ios);
17161 {
17162 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17163 std::string ex(str, iter.base());
17164 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17165 assert(ios.width() == 0);
17166 }
17167 ios.width(25);
17168 internal(ios);
17169 {
17170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17171 std::string ex(str, iter.base());
17172 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17173 assert(ios.width() == 0);
17174 }
17175 }
17176 }
17177 showpoint(ios);
17178 {
17179 ios.imbue(lc);
17180 {
17181 ios.width(0);
17182 {
17183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17184 std::string ex(str, iter.base());
17185 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17186 assert(ios.width() == 0);
17187 }
17188 ios.width(25);
17189 left(ios);
17190 {
17191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17192 std::string ex(str, iter.base());
17193 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17194 assert(ios.width() == 0);
17195 }
17196 ios.width(25);
17197 right(ios);
17198 {
17199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17200 std::string ex(str, iter.base());
17201 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17202 assert(ios.width() == 0);
17203 }
17204 ios.width(25);
17205 internal(ios);
17206 {
17207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17208 std::string ex(str, iter.base());
17209 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17210 assert(ios.width() == 0);
17211 }
17212 }
17213 ios.imbue(lg);
17214 {
17215 ios.width(0);
17216 {
17217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17218 std::string ex(str, iter.base());
17219 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17220 assert(ios.width() == 0);
17221 }
17222 ios.width(25);
17223 left(ios);
17224 {
17225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17226 std::string ex(str, iter.base());
17227 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17228 assert(ios.width() == 0);
17229 }
17230 ios.width(25);
17231 right(ios);
17232 {
17233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17234 std::string ex(str, iter.base());
17235 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17236 assert(ios.width() == 0);
17237 }
17238 ios.width(25);
17239 internal(ios);
17240 {
17241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17242 std::string ex(str, iter.base());
17243 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17244 assert(ios.width() == 0);
17245 }
17246 }
17247 }
17248 }
17249 }
17250 }
17251 }
17252 }
17253 }
17254
test8()17255 void test8()
17256 {
17257 char str[200];
17258 output_iterator<char*> iter;
17259 std::locale lc = std::locale::classic();
17260 std::locale lg(lc, new my_numpunct);
17261 const my_facet f(1);
17262 {
17263 long double v = 1234567890.125;
17264 std::ios ios(0);
17265 fixed(ios);
17266 // %f
17267 {
17268 ios.precision(0);
17269 {
17270 nouppercase(ios);
17271 {
17272 noshowpos(ios);
17273 {
17274 noshowpoint(ios);
17275 {
17276 ios.imbue(lc);
17277 {
17278 ios.width(0);
17279 {
17280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17281 std::string ex(str, iter.base());
17282 assert(ex == "1234567890");
17283 assert(ios.width() == 0);
17284 }
17285 ios.width(25);
17286 left(ios);
17287 {
17288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17289 std::string ex(str, iter.base());
17290 assert(ex == "1234567890***************");
17291 assert(ios.width() == 0);
17292 }
17293 ios.width(25);
17294 right(ios);
17295 {
17296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17297 std::string ex(str, iter.base());
17298 assert(ex == "***************1234567890");
17299 assert(ios.width() == 0);
17300 }
17301 ios.width(25);
17302 internal(ios);
17303 {
17304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17305 std::string ex(str, iter.base());
17306 assert(ex == "***************1234567890");
17307 assert(ios.width() == 0);
17308 }
17309 }
17310 ios.imbue(lg);
17311 {
17312 ios.width(0);
17313 {
17314 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17315 std::string ex(str, iter.base());
17316 assert(ex == "1_234_567_89_0");
17317 assert(ios.width() == 0);
17318 }
17319 ios.width(25);
17320 left(ios);
17321 {
17322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17323 std::string ex(str, iter.base());
17324 assert(ex == "1_234_567_89_0***********");
17325 assert(ios.width() == 0);
17326 }
17327 ios.width(25);
17328 right(ios);
17329 {
17330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17331 std::string ex(str, iter.base());
17332 assert(ex == "***********1_234_567_89_0");
17333 assert(ios.width() == 0);
17334 }
17335 ios.width(25);
17336 internal(ios);
17337 {
17338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17339 std::string ex(str, iter.base());
17340 assert(ex == "***********1_234_567_89_0");
17341 assert(ios.width() == 0);
17342 }
17343 }
17344 }
17345 showpoint(ios);
17346 {
17347 ios.imbue(lc);
17348 {
17349 ios.width(0);
17350 {
17351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17352 std::string ex(str, iter.base());
17353 assert(ex == "1234567890.");
17354 assert(ios.width() == 0);
17355 }
17356 ios.width(25);
17357 left(ios);
17358 {
17359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17360 std::string ex(str, iter.base());
17361 assert(ex == "1234567890.**************");
17362 assert(ios.width() == 0);
17363 }
17364 ios.width(25);
17365 right(ios);
17366 {
17367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17368 std::string ex(str, iter.base());
17369 assert(ex == "**************1234567890.");
17370 assert(ios.width() == 0);
17371 }
17372 ios.width(25);
17373 internal(ios);
17374 {
17375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17376 std::string ex(str, iter.base());
17377 assert(ex == "**************1234567890.");
17378 assert(ios.width() == 0);
17379 }
17380 }
17381 ios.imbue(lg);
17382 {
17383 ios.width(0);
17384 {
17385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17386 std::string ex(str, iter.base());
17387 assert(ex == "1_234_567_89_0;");
17388 assert(ios.width() == 0);
17389 }
17390 ios.width(25);
17391 left(ios);
17392 {
17393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17394 std::string ex(str, iter.base());
17395 assert(ex == "1_234_567_89_0;**********");
17396 assert(ios.width() == 0);
17397 }
17398 ios.width(25);
17399 right(ios);
17400 {
17401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17402 std::string ex(str, iter.base());
17403 assert(ex == "**********1_234_567_89_0;");
17404 assert(ios.width() == 0);
17405 }
17406 ios.width(25);
17407 internal(ios);
17408 {
17409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17410 std::string ex(str, iter.base());
17411 assert(ex == "**********1_234_567_89_0;");
17412 assert(ios.width() == 0);
17413 }
17414 }
17415 }
17416 }
17417 showpos(ios);
17418 {
17419 noshowpoint(ios);
17420 {
17421 ios.imbue(lc);
17422 {
17423 ios.width(0);
17424 {
17425 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17426 std::string ex(str, iter.base());
17427 assert(ex == "+1234567890");
17428 assert(ios.width() == 0);
17429 }
17430 ios.width(25);
17431 left(ios);
17432 {
17433 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17434 std::string ex(str, iter.base());
17435 assert(ex == "+1234567890**************");
17436 assert(ios.width() == 0);
17437 }
17438 ios.width(25);
17439 right(ios);
17440 {
17441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17442 std::string ex(str, iter.base());
17443 assert(ex == "**************+1234567890");
17444 assert(ios.width() == 0);
17445 }
17446 ios.width(25);
17447 internal(ios);
17448 {
17449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17450 std::string ex(str, iter.base());
17451 assert(ex == "+**************1234567890");
17452 assert(ios.width() == 0);
17453 }
17454 }
17455 ios.imbue(lg);
17456 {
17457 ios.width(0);
17458 {
17459 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17460 std::string ex(str, iter.base());
17461 assert(ex == "+1_234_567_89_0");
17462 assert(ios.width() == 0);
17463 }
17464 ios.width(25);
17465 left(ios);
17466 {
17467 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17468 std::string ex(str, iter.base());
17469 assert(ex == "+1_234_567_89_0**********");
17470 assert(ios.width() == 0);
17471 }
17472 ios.width(25);
17473 right(ios);
17474 {
17475 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17476 std::string ex(str, iter.base());
17477 assert(ex == "**********+1_234_567_89_0");
17478 assert(ios.width() == 0);
17479 }
17480 ios.width(25);
17481 internal(ios);
17482 {
17483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17484 std::string ex(str, iter.base());
17485 assert(ex == "+**********1_234_567_89_0");
17486 assert(ios.width() == 0);
17487 }
17488 }
17489 }
17490 showpoint(ios);
17491 {
17492 ios.imbue(lc);
17493 {
17494 ios.width(0);
17495 {
17496 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17497 std::string ex(str, iter.base());
17498 assert(ex == "+1234567890.");
17499 assert(ios.width() == 0);
17500 }
17501 ios.width(25);
17502 left(ios);
17503 {
17504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17505 std::string ex(str, iter.base());
17506 assert(ex == "+1234567890.*************");
17507 assert(ios.width() == 0);
17508 }
17509 ios.width(25);
17510 right(ios);
17511 {
17512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17513 std::string ex(str, iter.base());
17514 assert(ex == "*************+1234567890.");
17515 assert(ios.width() == 0);
17516 }
17517 ios.width(25);
17518 internal(ios);
17519 {
17520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17521 std::string ex(str, iter.base());
17522 assert(ex == "+*************1234567890.");
17523 assert(ios.width() == 0);
17524 }
17525 }
17526 ios.imbue(lg);
17527 {
17528 ios.width(0);
17529 {
17530 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17531 std::string ex(str, iter.base());
17532 assert(ex == "+1_234_567_89_0;");
17533 assert(ios.width() == 0);
17534 }
17535 ios.width(25);
17536 left(ios);
17537 {
17538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17539 std::string ex(str, iter.base());
17540 assert(ex == "+1_234_567_89_0;*********");
17541 assert(ios.width() == 0);
17542 }
17543 ios.width(25);
17544 right(ios);
17545 {
17546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17547 std::string ex(str, iter.base());
17548 assert(ex == "*********+1_234_567_89_0;");
17549 assert(ios.width() == 0);
17550 }
17551 ios.width(25);
17552 internal(ios);
17553 {
17554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17555 std::string ex(str, iter.base());
17556 assert(ex == "+*********1_234_567_89_0;");
17557 assert(ios.width() == 0);
17558 }
17559 }
17560 }
17561 }
17562 }
17563 uppercase(ios);
17564 {
17565 noshowpos(ios);
17566 {
17567 noshowpoint(ios);
17568 {
17569 ios.imbue(lc);
17570 {
17571 ios.width(0);
17572 {
17573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17574 std::string ex(str, iter.base());
17575 assert(ex == "1234567890");
17576 assert(ios.width() == 0);
17577 }
17578 ios.width(25);
17579 left(ios);
17580 {
17581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17582 std::string ex(str, iter.base());
17583 assert(ex == "1234567890***************");
17584 assert(ios.width() == 0);
17585 }
17586 ios.width(25);
17587 right(ios);
17588 {
17589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17590 std::string ex(str, iter.base());
17591 assert(ex == "***************1234567890");
17592 assert(ios.width() == 0);
17593 }
17594 ios.width(25);
17595 internal(ios);
17596 {
17597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17598 std::string ex(str, iter.base());
17599 assert(ex == "***************1234567890");
17600 assert(ios.width() == 0);
17601 }
17602 }
17603 ios.imbue(lg);
17604 {
17605 ios.width(0);
17606 {
17607 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17608 std::string ex(str, iter.base());
17609 assert(ex == "1_234_567_89_0");
17610 assert(ios.width() == 0);
17611 }
17612 ios.width(25);
17613 left(ios);
17614 {
17615 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17616 std::string ex(str, iter.base());
17617 assert(ex == "1_234_567_89_0***********");
17618 assert(ios.width() == 0);
17619 }
17620 ios.width(25);
17621 right(ios);
17622 {
17623 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17624 std::string ex(str, iter.base());
17625 assert(ex == "***********1_234_567_89_0");
17626 assert(ios.width() == 0);
17627 }
17628 ios.width(25);
17629 internal(ios);
17630 {
17631 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17632 std::string ex(str, iter.base());
17633 assert(ex == "***********1_234_567_89_0");
17634 assert(ios.width() == 0);
17635 }
17636 }
17637 }
17638 showpoint(ios);
17639 {
17640 ios.imbue(lc);
17641 {
17642 ios.width(0);
17643 {
17644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17645 std::string ex(str, iter.base());
17646 assert(ex == "1234567890.");
17647 assert(ios.width() == 0);
17648 }
17649 ios.width(25);
17650 left(ios);
17651 {
17652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17653 std::string ex(str, iter.base());
17654 assert(ex == "1234567890.**************");
17655 assert(ios.width() == 0);
17656 }
17657 ios.width(25);
17658 right(ios);
17659 {
17660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17661 std::string ex(str, iter.base());
17662 assert(ex == "**************1234567890.");
17663 assert(ios.width() == 0);
17664 }
17665 ios.width(25);
17666 internal(ios);
17667 {
17668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17669 std::string ex(str, iter.base());
17670 assert(ex == "**************1234567890.");
17671 assert(ios.width() == 0);
17672 }
17673 }
17674 ios.imbue(lg);
17675 {
17676 ios.width(0);
17677 {
17678 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17679 std::string ex(str, iter.base());
17680 assert(ex == "1_234_567_89_0;");
17681 assert(ios.width() == 0);
17682 }
17683 ios.width(25);
17684 left(ios);
17685 {
17686 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17687 std::string ex(str, iter.base());
17688 assert(ex == "1_234_567_89_0;**********");
17689 assert(ios.width() == 0);
17690 }
17691 ios.width(25);
17692 right(ios);
17693 {
17694 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17695 std::string ex(str, iter.base());
17696 assert(ex == "**********1_234_567_89_0;");
17697 assert(ios.width() == 0);
17698 }
17699 ios.width(25);
17700 internal(ios);
17701 {
17702 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17703 std::string ex(str, iter.base());
17704 assert(ex == "**********1_234_567_89_0;");
17705 assert(ios.width() == 0);
17706 }
17707 }
17708 }
17709 }
17710 showpos(ios);
17711 {
17712 noshowpoint(ios);
17713 {
17714 ios.imbue(lc);
17715 {
17716 ios.width(0);
17717 {
17718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17719 std::string ex(str, iter.base());
17720 assert(ex == "+1234567890");
17721 assert(ios.width() == 0);
17722 }
17723 ios.width(25);
17724 left(ios);
17725 {
17726 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17727 std::string ex(str, iter.base());
17728 assert(ex == "+1234567890**************");
17729 assert(ios.width() == 0);
17730 }
17731 ios.width(25);
17732 right(ios);
17733 {
17734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17735 std::string ex(str, iter.base());
17736 assert(ex == "**************+1234567890");
17737 assert(ios.width() == 0);
17738 }
17739 ios.width(25);
17740 internal(ios);
17741 {
17742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17743 std::string ex(str, iter.base());
17744 assert(ex == "+**************1234567890");
17745 assert(ios.width() == 0);
17746 }
17747 }
17748 ios.imbue(lg);
17749 {
17750 ios.width(0);
17751 {
17752 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17753 std::string ex(str, iter.base());
17754 assert(ex == "+1_234_567_89_0");
17755 assert(ios.width() == 0);
17756 }
17757 ios.width(25);
17758 left(ios);
17759 {
17760 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17761 std::string ex(str, iter.base());
17762 assert(ex == "+1_234_567_89_0**********");
17763 assert(ios.width() == 0);
17764 }
17765 ios.width(25);
17766 right(ios);
17767 {
17768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17769 std::string ex(str, iter.base());
17770 assert(ex == "**********+1_234_567_89_0");
17771 assert(ios.width() == 0);
17772 }
17773 ios.width(25);
17774 internal(ios);
17775 {
17776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17777 std::string ex(str, iter.base());
17778 assert(ex == "+**********1_234_567_89_0");
17779 assert(ios.width() == 0);
17780 }
17781 }
17782 }
17783 showpoint(ios);
17784 {
17785 ios.imbue(lc);
17786 {
17787 ios.width(0);
17788 {
17789 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17790 std::string ex(str, iter.base());
17791 assert(ex == "+1234567890.");
17792 assert(ios.width() == 0);
17793 }
17794 ios.width(25);
17795 left(ios);
17796 {
17797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17798 std::string ex(str, iter.base());
17799 assert(ex == "+1234567890.*************");
17800 assert(ios.width() == 0);
17801 }
17802 ios.width(25);
17803 right(ios);
17804 {
17805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17806 std::string ex(str, iter.base());
17807 assert(ex == "*************+1234567890.");
17808 assert(ios.width() == 0);
17809 }
17810 ios.width(25);
17811 internal(ios);
17812 {
17813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17814 std::string ex(str, iter.base());
17815 assert(ex == "+*************1234567890.");
17816 assert(ios.width() == 0);
17817 }
17818 }
17819 ios.imbue(lg);
17820 {
17821 ios.width(0);
17822 {
17823 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17824 std::string ex(str, iter.base());
17825 assert(ex == "+1_234_567_89_0;");
17826 assert(ios.width() == 0);
17827 }
17828 ios.width(25);
17829 left(ios);
17830 {
17831 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17832 std::string ex(str, iter.base());
17833 assert(ex == "+1_234_567_89_0;*********");
17834 assert(ios.width() == 0);
17835 }
17836 ios.width(25);
17837 right(ios);
17838 {
17839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17840 std::string ex(str, iter.base());
17841 assert(ex == "*********+1_234_567_89_0;");
17842 assert(ios.width() == 0);
17843 }
17844 ios.width(25);
17845 internal(ios);
17846 {
17847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17848 std::string ex(str, iter.base());
17849 assert(ex == "+*********1_234_567_89_0;");
17850 assert(ios.width() == 0);
17851 }
17852 }
17853 }
17854 }
17855 }
17856 }
17857 ios.precision(1);
17858 {
17859 nouppercase(ios);
17860 {
17861 noshowpos(ios);
17862 {
17863 noshowpoint(ios);
17864 {
17865 ios.imbue(lc);
17866 {
17867 ios.width(0);
17868 {
17869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17870 std::string ex(str, iter.base());
17871 assert(ex == "1234567890.1");
17872 assert(ios.width() == 0);
17873 }
17874 ios.width(25);
17875 left(ios);
17876 {
17877 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17878 std::string ex(str, iter.base());
17879 assert(ex == "1234567890.1*************");
17880 assert(ios.width() == 0);
17881 }
17882 ios.width(25);
17883 right(ios);
17884 {
17885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17886 std::string ex(str, iter.base());
17887 assert(ex == "*************1234567890.1");
17888 assert(ios.width() == 0);
17889 }
17890 ios.width(25);
17891 internal(ios);
17892 {
17893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17894 std::string ex(str, iter.base());
17895 assert(ex == "*************1234567890.1");
17896 assert(ios.width() == 0);
17897 }
17898 }
17899 ios.imbue(lg);
17900 {
17901 ios.width(0);
17902 {
17903 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17904 std::string ex(str, iter.base());
17905 assert(ex == "1_234_567_89_0;1");
17906 assert(ios.width() == 0);
17907 }
17908 ios.width(25);
17909 left(ios);
17910 {
17911 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17912 std::string ex(str, iter.base());
17913 assert(ex == "1_234_567_89_0;1*********");
17914 assert(ios.width() == 0);
17915 }
17916 ios.width(25);
17917 right(ios);
17918 {
17919 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17920 std::string ex(str, iter.base());
17921 assert(ex == "*********1_234_567_89_0;1");
17922 assert(ios.width() == 0);
17923 }
17924 ios.width(25);
17925 internal(ios);
17926 {
17927 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17928 std::string ex(str, iter.base());
17929 assert(ex == "*********1_234_567_89_0;1");
17930 assert(ios.width() == 0);
17931 }
17932 }
17933 }
17934 showpoint(ios);
17935 {
17936 ios.imbue(lc);
17937 {
17938 ios.width(0);
17939 {
17940 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17941 std::string ex(str, iter.base());
17942 assert(ex == "1234567890.1");
17943 assert(ios.width() == 0);
17944 }
17945 ios.width(25);
17946 left(ios);
17947 {
17948 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17949 std::string ex(str, iter.base());
17950 assert(ex == "1234567890.1*************");
17951 assert(ios.width() == 0);
17952 }
17953 ios.width(25);
17954 right(ios);
17955 {
17956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17957 std::string ex(str, iter.base());
17958 assert(ex == "*************1234567890.1");
17959 assert(ios.width() == 0);
17960 }
17961 ios.width(25);
17962 internal(ios);
17963 {
17964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17965 std::string ex(str, iter.base());
17966 assert(ex == "*************1234567890.1");
17967 assert(ios.width() == 0);
17968 }
17969 }
17970 ios.imbue(lg);
17971 {
17972 ios.width(0);
17973 {
17974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17975 std::string ex(str, iter.base());
17976 assert(ex == "1_234_567_89_0;1");
17977 assert(ios.width() == 0);
17978 }
17979 ios.width(25);
17980 left(ios);
17981 {
17982 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17983 std::string ex(str, iter.base());
17984 assert(ex == "1_234_567_89_0;1*********");
17985 assert(ios.width() == 0);
17986 }
17987 ios.width(25);
17988 right(ios);
17989 {
17990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17991 std::string ex(str, iter.base());
17992 assert(ex == "*********1_234_567_89_0;1");
17993 assert(ios.width() == 0);
17994 }
17995 ios.width(25);
17996 internal(ios);
17997 {
17998 iter = f.put(output_iterator<char*>(str), ios, '*', v);
17999 std::string ex(str, iter.base());
18000 assert(ex == "*********1_234_567_89_0;1");
18001 assert(ios.width() == 0);
18002 }
18003 }
18004 }
18005 }
18006 showpos(ios);
18007 {
18008 noshowpoint(ios);
18009 {
18010 ios.imbue(lc);
18011 {
18012 ios.width(0);
18013 {
18014 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18015 std::string ex(str, iter.base());
18016 assert(ex == "+1234567890.1");
18017 assert(ios.width() == 0);
18018 }
18019 ios.width(25);
18020 left(ios);
18021 {
18022 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18023 std::string ex(str, iter.base());
18024 assert(ex == "+1234567890.1************");
18025 assert(ios.width() == 0);
18026 }
18027 ios.width(25);
18028 right(ios);
18029 {
18030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18031 std::string ex(str, iter.base());
18032 assert(ex == "************+1234567890.1");
18033 assert(ios.width() == 0);
18034 }
18035 ios.width(25);
18036 internal(ios);
18037 {
18038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18039 std::string ex(str, iter.base());
18040 assert(ex == "+************1234567890.1");
18041 assert(ios.width() == 0);
18042 }
18043 }
18044 ios.imbue(lg);
18045 {
18046 ios.width(0);
18047 {
18048 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18049 std::string ex(str, iter.base());
18050 assert(ex == "+1_234_567_89_0;1");
18051 assert(ios.width() == 0);
18052 }
18053 ios.width(25);
18054 left(ios);
18055 {
18056 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18057 std::string ex(str, iter.base());
18058 assert(ex == "+1_234_567_89_0;1********");
18059 assert(ios.width() == 0);
18060 }
18061 ios.width(25);
18062 right(ios);
18063 {
18064 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18065 std::string ex(str, iter.base());
18066 assert(ex == "********+1_234_567_89_0;1");
18067 assert(ios.width() == 0);
18068 }
18069 ios.width(25);
18070 internal(ios);
18071 {
18072 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18073 std::string ex(str, iter.base());
18074 assert(ex == "+********1_234_567_89_0;1");
18075 assert(ios.width() == 0);
18076 }
18077 }
18078 }
18079 showpoint(ios);
18080 {
18081 ios.imbue(lc);
18082 {
18083 ios.width(0);
18084 {
18085 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18086 std::string ex(str, iter.base());
18087 assert(ex == "+1234567890.1");
18088 assert(ios.width() == 0);
18089 }
18090 ios.width(25);
18091 left(ios);
18092 {
18093 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18094 std::string ex(str, iter.base());
18095 assert(ex == "+1234567890.1************");
18096 assert(ios.width() == 0);
18097 }
18098 ios.width(25);
18099 right(ios);
18100 {
18101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18102 std::string ex(str, iter.base());
18103 assert(ex == "************+1234567890.1");
18104 assert(ios.width() == 0);
18105 }
18106 ios.width(25);
18107 internal(ios);
18108 {
18109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18110 std::string ex(str, iter.base());
18111 assert(ex == "+************1234567890.1");
18112 assert(ios.width() == 0);
18113 }
18114 }
18115 ios.imbue(lg);
18116 {
18117 ios.width(0);
18118 {
18119 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18120 std::string ex(str, iter.base());
18121 assert(ex == "+1_234_567_89_0;1");
18122 assert(ios.width() == 0);
18123 }
18124 ios.width(25);
18125 left(ios);
18126 {
18127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18128 std::string ex(str, iter.base());
18129 assert(ex == "+1_234_567_89_0;1********");
18130 assert(ios.width() == 0);
18131 }
18132 ios.width(25);
18133 right(ios);
18134 {
18135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18136 std::string ex(str, iter.base());
18137 assert(ex == "********+1_234_567_89_0;1");
18138 assert(ios.width() == 0);
18139 }
18140 ios.width(25);
18141 internal(ios);
18142 {
18143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18144 std::string ex(str, iter.base());
18145 assert(ex == "+********1_234_567_89_0;1");
18146 assert(ios.width() == 0);
18147 }
18148 }
18149 }
18150 }
18151 }
18152 uppercase(ios);
18153 {
18154 noshowpos(ios);
18155 {
18156 noshowpoint(ios);
18157 {
18158 ios.imbue(lc);
18159 {
18160 ios.width(0);
18161 {
18162 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18163 std::string ex(str, iter.base());
18164 assert(ex == "1234567890.1");
18165 assert(ios.width() == 0);
18166 }
18167 ios.width(25);
18168 left(ios);
18169 {
18170 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18171 std::string ex(str, iter.base());
18172 assert(ex == "1234567890.1*************");
18173 assert(ios.width() == 0);
18174 }
18175 ios.width(25);
18176 right(ios);
18177 {
18178 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18179 std::string ex(str, iter.base());
18180 assert(ex == "*************1234567890.1");
18181 assert(ios.width() == 0);
18182 }
18183 ios.width(25);
18184 internal(ios);
18185 {
18186 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18187 std::string ex(str, iter.base());
18188 assert(ex == "*************1234567890.1");
18189 assert(ios.width() == 0);
18190 }
18191 }
18192 ios.imbue(lg);
18193 {
18194 ios.width(0);
18195 {
18196 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18197 std::string ex(str, iter.base());
18198 assert(ex == "1_234_567_89_0;1");
18199 assert(ios.width() == 0);
18200 }
18201 ios.width(25);
18202 left(ios);
18203 {
18204 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18205 std::string ex(str, iter.base());
18206 assert(ex == "1_234_567_89_0;1*********");
18207 assert(ios.width() == 0);
18208 }
18209 ios.width(25);
18210 right(ios);
18211 {
18212 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18213 std::string ex(str, iter.base());
18214 assert(ex == "*********1_234_567_89_0;1");
18215 assert(ios.width() == 0);
18216 }
18217 ios.width(25);
18218 internal(ios);
18219 {
18220 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18221 std::string ex(str, iter.base());
18222 assert(ex == "*********1_234_567_89_0;1");
18223 assert(ios.width() == 0);
18224 }
18225 }
18226 }
18227 showpoint(ios);
18228 {
18229 ios.imbue(lc);
18230 {
18231 ios.width(0);
18232 {
18233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18234 std::string ex(str, iter.base());
18235 assert(ex == "1234567890.1");
18236 assert(ios.width() == 0);
18237 }
18238 ios.width(25);
18239 left(ios);
18240 {
18241 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18242 std::string ex(str, iter.base());
18243 assert(ex == "1234567890.1*************");
18244 assert(ios.width() == 0);
18245 }
18246 ios.width(25);
18247 right(ios);
18248 {
18249 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18250 std::string ex(str, iter.base());
18251 assert(ex == "*************1234567890.1");
18252 assert(ios.width() == 0);
18253 }
18254 ios.width(25);
18255 internal(ios);
18256 {
18257 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18258 std::string ex(str, iter.base());
18259 assert(ex == "*************1234567890.1");
18260 assert(ios.width() == 0);
18261 }
18262 }
18263 ios.imbue(lg);
18264 {
18265 ios.width(0);
18266 {
18267 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18268 std::string ex(str, iter.base());
18269 assert(ex == "1_234_567_89_0;1");
18270 assert(ios.width() == 0);
18271 }
18272 ios.width(25);
18273 left(ios);
18274 {
18275 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18276 std::string ex(str, iter.base());
18277 assert(ex == "1_234_567_89_0;1*********");
18278 assert(ios.width() == 0);
18279 }
18280 ios.width(25);
18281 right(ios);
18282 {
18283 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18284 std::string ex(str, iter.base());
18285 assert(ex == "*********1_234_567_89_0;1");
18286 assert(ios.width() == 0);
18287 }
18288 ios.width(25);
18289 internal(ios);
18290 {
18291 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18292 std::string ex(str, iter.base());
18293 assert(ex == "*********1_234_567_89_0;1");
18294 assert(ios.width() == 0);
18295 }
18296 }
18297 }
18298 }
18299 showpos(ios);
18300 {
18301 noshowpoint(ios);
18302 {
18303 ios.imbue(lc);
18304 {
18305 ios.width(0);
18306 {
18307 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18308 std::string ex(str, iter.base());
18309 assert(ex == "+1234567890.1");
18310 assert(ios.width() == 0);
18311 }
18312 ios.width(25);
18313 left(ios);
18314 {
18315 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18316 std::string ex(str, iter.base());
18317 assert(ex == "+1234567890.1************");
18318 assert(ios.width() == 0);
18319 }
18320 ios.width(25);
18321 right(ios);
18322 {
18323 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18324 std::string ex(str, iter.base());
18325 assert(ex == "************+1234567890.1");
18326 assert(ios.width() == 0);
18327 }
18328 ios.width(25);
18329 internal(ios);
18330 {
18331 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18332 std::string ex(str, iter.base());
18333 assert(ex == "+************1234567890.1");
18334 assert(ios.width() == 0);
18335 }
18336 }
18337 ios.imbue(lg);
18338 {
18339 ios.width(0);
18340 {
18341 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18342 std::string ex(str, iter.base());
18343 assert(ex == "+1_234_567_89_0;1");
18344 assert(ios.width() == 0);
18345 }
18346 ios.width(25);
18347 left(ios);
18348 {
18349 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18350 std::string ex(str, iter.base());
18351 assert(ex == "+1_234_567_89_0;1********");
18352 assert(ios.width() == 0);
18353 }
18354 ios.width(25);
18355 right(ios);
18356 {
18357 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18358 std::string ex(str, iter.base());
18359 assert(ex == "********+1_234_567_89_0;1");
18360 assert(ios.width() == 0);
18361 }
18362 ios.width(25);
18363 internal(ios);
18364 {
18365 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18366 std::string ex(str, iter.base());
18367 assert(ex == "+********1_234_567_89_0;1");
18368 assert(ios.width() == 0);
18369 }
18370 }
18371 }
18372 showpoint(ios);
18373 {
18374 ios.imbue(lc);
18375 {
18376 ios.width(0);
18377 {
18378 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18379 std::string ex(str, iter.base());
18380 assert(ex == "+1234567890.1");
18381 assert(ios.width() == 0);
18382 }
18383 ios.width(25);
18384 left(ios);
18385 {
18386 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18387 std::string ex(str, iter.base());
18388 assert(ex == "+1234567890.1************");
18389 assert(ios.width() == 0);
18390 }
18391 ios.width(25);
18392 right(ios);
18393 {
18394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18395 std::string ex(str, iter.base());
18396 assert(ex == "************+1234567890.1");
18397 assert(ios.width() == 0);
18398 }
18399 ios.width(25);
18400 internal(ios);
18401 {
18402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18403 std::string ex(str, iter.base());
18404 assert(ex == "+************1234567890.1");
18405 assert(ios.width() == 0);
18406 }
18407 }
18408 ios.imbue(lg);
18409 {
18410 ios.width(0);
18411 {
18412 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18413 std::string ex(str, iter.base());
18414 assert(ex == "+1_234_567_89_0;1");
18415 assert(ios.width() == 0);
18416 }
18417 ios.width(25);
18418 left(ios);
18419 {
18420 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18421 std::string ex(str, iter.base());
18422 assert(ex == "+1_234_567_89_0;1********");
18423 assert(ios.width() == 0);
18424 }
18425 ios.width(25);
18426 right(ios);
18427 {
18428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18429 std::string ex(str, iter.base());
18430 assert(ex == "********+1_234_567_89_0;1");
18431 assert(ios.width() == 0);
18432 }
18433 ios.width(25);
18434 internal(ios);
18435 {
18436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18437 std::string ex(str, iter.base());
18438 assert(ex == "+********1_234_567_89_0;1");
18439 assert(ios.width() == 0);
18440 }
18441 }
18442 }
18443 }
18444 }
18445 }
18446 ios.precision(6);
18447 {
18448 nouppercase(ios);
18449 {
18450 noshowpos(ios);
18451 {
18452 noshowpoint(ios);
18453 {
18454 ios.imbue(lc);
18455 {
18456 ios.width(0);
18457 {
18458 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18459 std::string ex(str, iter.base());
18460 assert(ex == "1234567890.125000");
18461 assert(ios.width() == 0);
18462 }
18463 ios.width(25);
18464 left(ios);
18465 {
18466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18467 std::string ex(str, iter.base());
18468 assert(ex == "1234567890.125000********");
18469 assert(ios.width() == 0);
18470 }
18471 ios.width(25);
18472 right(ios);
18473 {
18474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18475 std::string ex(str, iter.base());
18476 assert(ex == "********1234567890.125000");
18477 assert(ios.width() == 0);
18478 }
18479 ios.width(25);
18480 internal(ios);
18481 {
18482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18483 std::string ex(str, iter.base());
18484 assert(ex == "********1234567890.125000");
18485 assert(ios.width() == 0);
18486 }
18487 }
18488 ios.imbue(lg);
18489 {
18490 ios.width(0);
18491 {
18492 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18493 std::string ex(str, iter.base());
18494 assert(ex == "1_234_567_89_0;125000");
18495 assert(ios.width() == 0);
18496 }
18497 ios.width(25);
18498 left(ios);
18499 {
18500 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18501 std::string ex(str, iter.base());
18502 assert(ex == "1_234_567_89_0;125000****");
18503 assert(ios.width() == 0);
18504 }
18505 ios.width(25);
18506 right(ios);
18507 {
18508 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18509 std::string ex(str, iter.base());
18510 assert(ex == "****1_234_567_89_0;125000");
18511 assert(ios.width() == 0);
18512 }
18513 ios.width(25);
18514 internal(ios);
18515 {
18516 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18517 std::string ex(str, iter.base());
18518 assert(ex == "****1_234_567_89_0;125000");
18519 assert(ios.width() == 0);
18520 }
18521 }
18522 }
18523 showpoint(ios);
18524 {
18525 ios.imbue(lc);
18526 {
18527 ios.width(0);
18528 {
18529 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18530 std::string ex(str, iter.base());
18531 assert(ex == "1234567890.125000");
18532 assert(ios.width() == 0);
18533 }
18534 ios.width(25);
18535 left(ios);
18536 {
18537 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18538 std::string ex(str, iter.base());
18539 assert(ex == "1234567890.125000********");
18540 assert(ios.width() == 0);
18541 }
18542 ios.width(25);
18543 right(ios);
18544 {
18545 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18546 std::string ex(str, iter.base());
18547 assert(ex == "********1234567890.125000");
18548 assert(ios.width() == 0);
18549 }
18550 ios.width(25);
18551 internal(ios);
18552 {
18553 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18554 std::string ex(str, iter.base());
18555 assert(ex == "********1234567890.125000");
18556 assert(ios.width() == 0);
18557 }
18558 }
18559 ios.imbue(lg);
18560 {
18561 ios.width(0);
18562 {
18563 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18564 std::string ex(str, iter.base());
18565 assert(ex == "1_234_567_89_0;125000");
18566 assert(ios.width() == 0);
18567 }
18568 ios.width(25);
18569 left(ios);
18570 {
18571 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18572 std::string ex(str, iter.base());
18573 assert(ex == "1_234_567_89_0;125000****");
18574 assert(ios.width() == 0);
18575 }
18576 ios.width(25);
18577 right(ios);
18578 {
18579 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18580 std::string ex(str, iter.base());
18581 assert(ex == "****1_234_567_89_0;125000");
18582 assert(ios.width() == 0);
18583 }
18584 ios.width(25);
18585 internal(ios);
18586 {
18587 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18588 std::string ex(str, iter.base());
18589 assert(ex == "****1_234_567_89_0;125000");
18590 assert(ios.width() == 0);
18591 }
18592 }
18593 }
18594 }
18595 showpos(ios);
18596 {
18597 noshowpoint(ios);
18598 {
18599 ios.imbue(lc);
18600 {
18601 ios.width(0);
18602 {
18603 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18604 std::string ex(str, iter.base());
18605 assert(ex == "+1234567890.125000");
18606 assert(ios.width() == 0);
18607 }
18608 ios.width(25);
18609 left(ios);
18610 {
18611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18612 std::string ex(str, iter.base());
18613 assert(ex == "+1234567890.125000*******");
18614 assert(ios.width() == 0);
18615 }
18616 ios.width(25);
18617 right(ios);
18618 {
18619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18620 std::string ex(str, iter.base());
18621 assert(ex == "*******+1234567890.125000");
18622 assert(ios.width() == 0);
18623 }
18624 ios.width(25);
18625 internal(ios);
18626 {
18627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18628 std::string ex(str, iter.base());
18629 assert(ex == "+*******1234567890.125000");
18630 assert(ios.width() == 0);
18631 }
18632 }
18633 ios.imbue(lg);
18634 {
18635 ios.width(0);
18636 {
18637 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18638 std::string ex(str, iter.base());
18639 assert(ex == "+1_234_567_89_0;125000");
18640 assert(ios.width() == 0);
18641 }
18642 ios.width(25);
18643 left(ios);
18644 {
18645 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18646 std::string ex(str, iter.base());
18647 assert(ex == "+1_234_567_89_0;125000***");
18648 assert(ios.width() == 0);
18649 }
18650 ios.width(25);
18651 right(ios);
18652 {
18653 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18654 std::string ex(str, iter.base());
18655 assert(ex == "***+1_234_567_89_0;125000");
18656 assert(ios.width() == 0);
18657 }
18658 ios.width(25);
18659 internal(ios);
18660 {
18661 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18662 std::string ex(str, iter.base());
18663 assert(ex == "+***1_234_567_89_0;125000");
18664 assert(ios.width() == 0);
18665 }
18666 }
18667 }
18668 showpoint(ios);
18669 {
18670 ios.imbue(lc);
18671 {
18672 ios.width(0);
18673 {
18674 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18675 std::string ex(str, iter.base());
18676 assert(ex == "+1234567890.125000");
18677 assert(ios.width() == 0);
18678 }
18679 ios.width(25);
18680 left(ios);
18681 {
18682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18683 std::string ex(str, iter.base());
18684 assert(ex == "+1234567890.125000*******");
18685 assert(ios.width() == 0);
18686 }
18687 ios.width(25);
18688 right(ios);
18689 {
18690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18691 std::string ex(str, iter.base());
18692 assert(ex == "*******+1234567890.125000");
18693 assert(ios.width() == 0);
18694 }
18695 ios.width(25);
18696 internal(ios);
18697 {
18698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18699 std::string ex(str, iter.base());
18700 assert(ex == "+*******1234567890.125000");
18701 assert(ios.width() == 0);
18702 }
18703 }
18704 ios.imbue(lg);
18705 {
18706 ios.width(0);
18707 {
18708 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18709 std::string ex(str, iter.base());
18710 assert(ex == "+1_234_567_89_0;125000");
18711 assert(ios.width() == 0);
18712 }
18713 ios.width(25);
18714 left(ios);
18715 {
18716 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18717 std::string ex(str, iter.base());
18718 assert(ex == "+1_234_567_89_0;125000***");
18719 assert(ios.width() == 0);
18720 }
18721 ios.width(25);
18722 right(ios);
18723 {
18724 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18725 std::string ex(str, iter.base());
18726 assert(ex == "***+1_234_567_89_0;125000");
18727 assert(ios.width() == 0);
18728 }
18729 ios.width(25);
18730 internal(ios);
18731 {
18732 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18733 std::string ex(str, iter.base());
18734 assert(ex == "+***1_234_567_89_0;125000");
18735 assert(ios.width() == 0);
18736 }
18737 }
18738 }
18739 }
18740 }
18741 uppercase(ios);
18742 {
18743 noshowpos(ios);
18744 {
18745 noshowpoint(ios);
18746 {
18747 ios.imbue(lc);
18748 {
18749 ios.width(0);
18750 {
18751 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18752 std::string ex(str, iter.base());
18753 assert(ex == "1234567890.125000");
18754 assert(ios.width() == 0);
18755 }
18756 ios.width(25);
18757 left(ios);
18758 {
18759 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18760 std::string ex(str, iter.base());
18761 assert(ex == "1234567890.125000********");
18762 assert(ios.width() == 0);
18763 }
18764 ios.width(25);
18765 right(ios);
18766 {
18767 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18768 std::string ex(str, iter.base());
18769 assert(ex == "********1234567890.125000");
18770 assert(ios.width() == 0);
18771 }
18772 ios.width(25);
18773 internal(ios);
18774 {
18775 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18776 std::string ex(str, iter.base());
18777 assert(ex == "********1234567890.125000");
18778 assert(ios.width() == 0);
18779 }
18780 }
18781 ios.imbue(lg);
18782 {
18783 ios.width(0);
18784 {
18785 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18786 std::string ex(str, iter.base());
18787 assert(ex == "1_234_567_89_0;125000");
18788 assert(ios.width() == 0);
18789 }
18790 ios.width(25);
18791 left(ios);
18792 {
18793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18794 std::string ex(str, iter.base());
18795 assert(ex == "1_234_567_89_0;125000****");
18796 assert(ios.width() == 0);
18797 }
18798 ios.width(25);
18799 right(ios);
18800 {
18801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18802 std::string ex(str, iter.base());
18803 assert(ex == "****1_234_567_89_0;125000");
18804 assert(ios.width() == 0);
18805 }
18806 ios.width(25);
18807 internal(ios);
18808 {
18809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18810 std::string ex(str, iter.base());
18811 assert(ex == "****1_234_567_89_0;125000");
18812 assert(ios.width() == 0);
18813 }
18814 }
18815 }
18816 showpoint(ios);
18817 {
18818 ios.imbue(lc);
18819 {
18820 ios.width(0);
18821 {
18822 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18823 std::string ex(str, iter.base());
18824 assert(ex == "1234567890.125000");
18825 assert(ios.width() == 0);
18826 }
18827 ios.width(25);
18828 left(ios);
18829 {
18830 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18831 std::string ex(str, iter.base());
18832 assert(ex == "1234567890.125000********");
18833 assert(ios.width() == 0);
18834 }
18835 ios.width(25);
18836 right(ios);
18837 {
18838 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18839 std::string ex(str, iter.base());
18840 assert(ex == "********1234567890.125000");
18841 assert(ios.width() == 0);
18842 }
18843 ios.width(25);
18844 internal(ios);
18845 {
18846 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18847 std::string ex(str, iter.base());
18848 assert(ex == "********1234567890.125000");
18849 assert(ios.width() == 0);
18850 }
18851 }
18852 ios.imbue(lg);
18853 {
18854 ios.width(0);
18855 {
18856 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18857 std::string ex(str, iter.base());
18858 assert(ex == "1_234_567_89_0;125000");
18859 assert(ios.width() == 0);
18860 }
18861 ios.width(25);
18862 left(ios);
18863 {
18864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18865 std::string ex(str, iter.base());
18866 assert(ex == "1_234_567_89_0;125000****");
18867 assert(ios.width() == 0);
18868 }
18869 ios.width(25);
18870 right(ios);
18871 {
18872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18873 std::string ex(str, iter.base());
18874 assert(ex == "****1_234_567_89_0;125000");
18875 assert(ios.width() == 0);
18876 }
18877 ios.width(25);
18878 internal(ios);
18879 {
18880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18881 std::string ex(str, iter.base());
18882 assert(ex == "****1_234_567_89_0;125000");
18883 assert(ios.width() == 0);
18884 }
18885 }
18886 }
18887 }
18888 showpos(ios);
18889 {
18890 noshowpoint(ios);
18891 {
18892 ios.imbue(lc);
18893 {
18894 ios.width(0);
18895 {
18896 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18897 std::string ex(str, iter.base());
18898 assert(ex == "+1234567890.125000");
18899 assert(ios.width() == 0);
18900 }
18901 ios.width(25);
18902 left(ios);
18903 {
18904 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18905 std::string ex(str, iter.base());
18906 assert(ex == "+1234567890.125000*******");
18907 assert(ios.width() == 0);
18908 }
18909 ios.width(25);
18910 right(ios);
18911 {
18912 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18913 std::string ex(str, iter.base());
18914 assert(ex == "*******+1234567890.125000");
18915 assert(ios.width() == 0);
18916 }
18917 ios.width(25);
18918 internal(ios);
18919 {
18920 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18921 std::string ex(str, iter.base());
18922 assert(ex == "+*******1234567890.125000");
18923 assert(ios.width() == 0);
18924 }
18925 }
18926 ios.imbue(lg);
18927 {
18928 ios.width(0);
18929 {
18930 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18931 std::string ex(str, iter.base());
18932 assert(ex == "+1_234_567_89_0;125000");
18933 assert(ios.width() == 0);
18934 }
18935 ios.width(25);
18936 left(ios);
18937 {
18938 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18939 std::string ex(str, iter.base());
18940 assert(ex == "+1_234_567_89_0;125000***");
18941 assert(ios.width() == 0);
18942 }
18943 ios.width(25);
18944 right(ios);
18945 {
18946 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18947 std::string ex(str, iter.base());
18948 assert(ex == "***+1_234_567_89_0;125000");
18949 assert(ios.width() == 0);
18950 }
18951 ios.width(25);
18952 internal(ios);
18953 {
18954 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18955 std::string ex(str, iter.base());
18956 assert(ex == "+***1_234_567_89_0;125000");
18957 assert(ios.width() == 0);
18958 }
18959 }
18960 }
18961 showpoint(ios);
18962 {
18963 ios.imbue(lc);
18964 {
18965 ios.width(0);
18966 {
18967 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18968 std::string ex(str, iter.base());
18969 assert(ex == "+1234567890.125000");
18970 assert(ios.width() == 0);
18971 }
18972 ios.width(25);
18973 left(ios);
18974 {
18975 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18976 std::string ex(str, iter.base());
18977 assert(ex == "+1234567890.125000*******");
18978 assert(ios.width() == 0);
18979 }
18980 ios.width(25);
18981 right(ios);
18982 {
18983 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18984 std::string ex(str, iter.base());
18985 assert(ex == "*******+1234567890.125000");
18986 assert(ios.width() == 0);
18987 }
18988 ios.width(25);
18989 internal(ios);
18990 {
18991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
18992 std::string ex(str, iter.base());
18993 assert(ex == "+*******1234567890.125000");
18994 assert(ios.width() == 0);
18995 }
18996 }
18997 ios.imbue(lg);
18998 {
18999 ios.width(0);
19000 {
19001 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19002 std::string ex(str, iter.base());
19003 assert(ex == "+1_234_567_89_0;125000");
19004 assert(ios.width() == 0);
19005 }
19006 ios.width(25);
19007 left(ios);
19008 {
19009 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19010 std::string ex(str, iter.base());
19011 assert(ex == "+1_234_567_89_0;125000***");
19012 assert(ios.width() == 0);
19013 }
19014 ios.width(25);
19015 right(ios);
19016 {
19017 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19018 std::string ex(str, iter.base());
19019 assert(ex == "***+1_234_567_89_0;125000");
19020 assert(ios.width() == 0);
19021 }
19022 ios.width(25);
19023 internal(ios);
19024 {
19025 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19026 std::string ex(str, iter.base());
19027 assert(ex == "+***1_234_567_89_0;125000");
19028 assert(ios.width() == 0);
19029 }
19030 }
19031 }
19032 }
19033 }
19034 }
19035 ios.precision(16);
19036 {}
19037 ios.precision(60);
19038 {}
19039 }
19040 }
19041 }
19042
test9()19043 void test9()
19044 {
19045 char str[200];
19046 output_iterator<char*> iter;
19047 std::locale lc = std::locale::classic();
19048 std::locale lg(lc, new my_numpunct);
19049 const my_facet f(1);
19050 {
19051 long double v = -0.;
19052 std::ios ios(0);
19053 scientific(ios);
19054 // %e
19055 {
19056 ios.precision(0);
19057 {
19058 nouppercase(ios);
19059 {
19060 noshowpos(ios);
19061 {
19062 noshowpoint(ios);
19063 {
19064 ios.imbue(lc);
19065 {
19066 ios.width(0);
19067 {
19068 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19069 std::string ex(str, iter.base());
19070 assert(ex == "-0e+00");
19071 assert(ios.width() == 0);
19072 }
19073 ios.width(25);
19074 left(ios);
19075 {
19076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19077 std::string ex(str, iter.base());
19078 assert(ex == "-0e+00*******************");
19079 assert(ios.width() == 0);
19080 }
19081 ios.width(25);
19082 right(ios);
19083 {
19084 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19085 std::string ex(str, iter.base());
19086 assert(ex == "*******************-0e+00");
19087 assert(ios.width() == 0);
19088 }
19089 ios.width(25);
19090 internal(ios);
19091 {
19092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19093 std::string ex(str, iter.base());
19094 assert(ex == "-*******************0e+00");
19095 assert(ios.width() == 0);
19096 }
19097 }
19098 ios.imbue(lg);
19099 {
19100 ios.width(0);
19101 {
19102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19103 std::string ex(str, iter.base());
19104 assert(ex == "-0e+00");
19105 assert(ios.width() == 0);
19106 }
19107 ios.width(25);
19108 left(ios);
19109 {
19110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19111 std::string ex(str, iter.base());
19112 assert(ex == "-0e+00*******************");
19113 assert(ios.width() == 0);
19114 }
19115 ios.width(25);
19116 right(ios);
19117 {
19118 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19119 std::string ex(str, iter.base());
19120 assert(ex == "*******************-0e+00");
19121 assert(ios.width() == 0);
19122 }
19123 ios.width(25);
19124 internal(ios);
19125 {
19126 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19127 std::string ex(str, iter.base());
19128 assert(ex == "-*******************0e+00");
19129 assert(ios.width() == 0);
19130 }
19131 }
19132 }
19133 showpoint(ios);
19134 {
19135 ios.imbue(lc);
19136 {
19137 ios.width(0);
19138 {
19139 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19140 std::string ex(str, iter.base());
19141 assert(ex == "-0.e+00");
19142 assert(ios.width() == 0);
19143 }
19144 ios.width(25);
19145 left(ios);
19146 {
19147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19148 std::string ex(str, iter.base());
19149 assert(ex == "-0.e+00******************");
19150 assert(ios.width() == 0);
19151 }
19152 ios.width(25);
19153 right(ios);
19154 {
19155 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19156 std::string ex(str, iter.base());
19157 assert(ex == "******************-0.e+00");
19158 assert(ios.width() == 0);
19159 }
19160 ios.width(25);
19161 internal(ios);
19162 {
19163 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19164 std::string ex(str, iter.base());
19165 assert(ex == "-******************0.e+00");
19166 assert(ios.width() == 0);
19167 }
19168 }
19169 ios.imbue(lg);
19170 {
19171 ios.width(0);
19172 {
19173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19174 std::string ex(str, iter.base());
19175 assert(ex == "-0;e+00");
19176 assert(ios.width() == 0);
19177 }
19178 ios.width(25);
19179 left(ios);
19180 {
19181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19182 std::string ex(str, iter.base());
19183 assert(ex == "-0;e+00******************");
19184 assert(ios.width() == 0);
19185 }
19186 ios.width(25);
19187 right(ios);
19188 {
19189 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19190 std::string ex(str, iter.base());
19191 assert(ex == "******************-0;e+00");
19192 assert(ios.width() == 0);
19193 }
19194 ios.width(25);
19195 internal(ios);
19196 {
19197 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19198 std::string ex(str, iter.base());
19199 assert(ex == "-******************0;e+00");
19200 assert(ios.width() == 0);
19201 }
19202 }
19203 }
19204 }
19205 showpos(ios);
19206 {
19207 noshowpoint(ios);
19208 {
19209 ios.imbue(lc);
19210 {
19211 ios.width(0);
19212 {
19213 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19214 std::string ex(str, iter.base());
19215 assert(ex == "-0e+00");
19216 assert(ios.width() == 0);
19217 }
19218 ios.width(25);
19219 left(ios);
19220 {
19221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19222 std::string ex(str, iter.base());
19223 assert(ex == "-0e+00*******************");
19224 assert(ios.width() == 0);
19225 }
19226 ios.width(25);
19227 right(ios);
19228 {
19229 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19230 std::string ex(str, iter.base());
19231 assert(ex == "*******************-0e+00");
19232 assert(ios.width() == 0);
19233 }
19234 ios.width(25);
19235 internal(ios);
19236 {
19237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19238 std::string ex(str, iter.base());
19239 assert(ex == "-*******************0e+00");
19240 assert(ios.width() == 0);
19241 }
19242 }
19243 ios.imbue(lg);
19244 {
19245 ios.width(0);
19246 {
19247 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19248 std::string ex(str, iter.base());
19249 assert(ex == "-0e+00");
19250 assert(ios.width() == 0);
19251 }
19252 ios.width(25);
19253 left(ios);
19254 {
19255 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19256 std::string ex(str, iter.base());
19257 assert(ex == "-0e+00*******************");
19258 assert(ios.width() == 0);
19259 }
19260 ios.width(25);
19261 right(ios);
19262 {
19263 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19264 std::string ex(str, iter.base());
19265 assert(ex == "*******************-0e+00");
19266 assert(ios.width() == 0);
19267 }
19268 ios.width(25);
19269 internal(ios);
19270 {
19271 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19272 std::string ex(str, iter.base());
19273 assert(ex == "-*******************0e+00");
19274 assert(ios.width() == 0);
19275 }
19276 }
19277 }
19278 showpoint(ios);
19279 {
19280 ios.imbue(lc);
19281 {
19282 ios.width(0);
19283 {
19284 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19285 std::string ex(str, iter.base());
19286 assert(ex == "-0.e+00");
19287 assert(ios.width() == 0);
19288 }
19289 ios.width(25);
19290 left(ios);
19291 {
19292 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19293 std::string ex(str, iter.base());
19294 assert(ex == "-0.e+00******************");
19295 assert(ios.width() == 0);
19296 }
19297 ios.width(25);
19298 right(ios);
19299 {
19300 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19301 std::string ex(str, iter.base());
19302 assert(ex == "******************-0.e+00");
19303 assert(ios.width() == 0);
19304 }
19305 ios.width(25);
19306 internal(ios);
19307 {
19308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19309 std::string ex(str, iter.base());
19310 assert(ex == "-******************0.e+00");
19311 assert(ios.width() == 0);
19312 }
19313 }
19314 ios.imbue(lg);
19315 {
19316 ios.width(0);
19317 {
19318 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19319 std::string ex(str, iter.base());
19320 assert(ex == "-0;e+00");
19321 assert(ios.width() == 0);
19322 }
19323 ios.width(25);
19324 left(ios);
19325 {
19326 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19327 std::string ex(str, iter.base());
19328 assert(ex == "-0;e+00******************");
19329 assert(ios.width() == 0);
19330 }
19331 ios.width(25);
19332 right(ios);
19333 {
19334 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19335 std::string ex(str, iter.base());
19336 assert(ex == "******************-0;e+00");
19337 assert(ios.width() == 0);
19338 }
19339 ios.width(25);
19340 internal(ios);
19341 {
19342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19343 std::string ex(str, iter.base());
19344 assert(ex == "-******************0;e+00");
19345 assert(ios.width() == 0);
19346 }
19347 }
19348 }
19349 }
19350 }
19351 uppercase(ios);
19352 {
19353 noshowpos(ios);
19354 {
19355 noshowpoint(ios);
19356 {
19357 ios.imbue(lc);
19358 {
19359 ios.width(0);
19360 {
19361 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19362 std::string ex(str, iter.base());
19363 assert(ex == "-0E+00");
19364 assert(ios.width() == 0);
19365 }
19366 ios.width(25);
19367 left(ios);
19368 {
19369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19370 std::string ex(str, iter.base());
19371 assert(ex == "-0E+00*******************");
19372 assert(ios.width() == 0);
19373 }
19374 ios.width(25);
19375 right(ios);
19376 {
19377 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19378 std::string ex(str, iter.base());
19379 assert(ex == "*******************-0E+00");
19380 assert(ios.width() == 0);
19381 }
19382 ios.width(25);
19383 internal(ios);
19384 {
19385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19386 std::string ex(str, iter.base());
19387 assert(ex == "-*******************0E+00");
19388 assert(ios.width() == 0);
19389 }
19390 }
19391 ios.imbue(lg);
19392 {
19393 ios.width(0);
19394 {
19395 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19396 std::string ex(str, iter.base());
19397 assert(ex == "-0E+00");
19398 assert(ios.width() == 0);
19399 }
19400 ios.width(25);
19401 left(ios);
19402 {
19403 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19404 std::string ex(str, iter.base());
19405 assert(ex == "-0E+00*******************");
19406 assert(ios.width() == 0);
19407 }
19408 ios.width(25);
19409 right(ios);
19410 {
19411 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19412 std::string ex(str, iter.base());
19413 assert(ex == "*******************-0E+00");
19414 assert(ios.width() == 0);
19415 }
19416 ios.width(25);
19417 internal(ios);
19418 {
19419 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19420 std::string ex(str, iter.base());
19421 assert(ex == "-*******************0E+00");
19422 assert(ios.width() == 0);
19423 }
19424 }
19425 }
19426 showpoint(ios);
19427 {
19428 ios.imbue(lc);
19429 {
19430 ios.width(0);
19431 {
19432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19433 std::string ex(str, iter.base());
19434 assert(ex == "-0.E+00");
19435 assert(ios.width() == 0);
19436 }
19437 ios.width(25);
19438 left(ios);
19439 {
19440 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19441 std::string ex(str, iter.base());
19442 assert(ex == "-0.E+00******************");
19443 assert(ios.width() == 0);
19444 }
19445 ios.width(25);
19446 right(ios);
19447 {
19448 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19449 std::string ex(str, iter.base());
19450 assert(ex == "******************-0.E+00");
19451 assert(ios.width() == 0);
19452 }
19453 ios.width(25);
19454 internal(ios);
19455 {
19456 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19457 std::string ex(str, iter.base());
19458 assert(ex == "-******************0.E+00");
19459 assert(ios.width() == 0);
19460 }
19461 }
19462 ios.imbue(lg);
19463 {
19464 ios.width(0);
19465 {
19466 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19467 std::string ex(str, iter.base());
19468 assert(ex == "-0;E+00");
19469 assert(ios.width() == 0);
19470 }
19471 ios.width(25);
19472 left(ios);
19473 {
19474 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19475 std::string ex(str, iter.base());
19476 assert(ex == "-0;E+00******************");
19477 assert(ios.width() == 0);
19478 }
19479 ios.width(25);
19480 right(ios);
19481 {
19482 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19483 std::string ex(str, iter.base());
19484 assert(ex == "******************-0;E+00");
19485 assert(ios.width() == 0);
19486 }
19487 ios.width(25);
19488 internal(ios);
19489 {
19490 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19491 std::string ex(str, iter.base());
19492 assert(ex == "-******************0;E+00");
19493 assert(ios.width() == 0);
19494 }
19495 }
19496 }
19497 }
19498 showpos(ios);
19499 {
19500 noshowpoint(ios);
19501 {
19502 ios.imbue(lc);
19503 {
19504 ios.width(0);
19505 {
19506 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19507 std::string ex(str, iter.base());
19508 assert(ex == "-0E+00");
19509 assert(ios.width() == 0);
19510 }
19511 ios.width(25);
19512 left(ios);
19513 {
19514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19515 std::string ex(str, iter.base());
19516 assert(ex == "-0E+00*******************");
19517 assert(ios.width() == 0);
19518 }
19519 ios.width(25);
19520 right(ios);
19521 {
19522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19523 std::string ex(str, iter.base());
19524 assert(ex == "*******************-0E+00");
19525 assert(ios.width() == 0);
19526 }
19527 ios.width(25);
19528 internal(ios);
19529 {
19530 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19531 std::string ex(str, iter.base());
19532 assert(ex == "-*******************0E+00");
19533 assert(ios.width() == 0);
19534 }
19535 }
19536 ios.imbue(lg);
19537 {
19538 ios.width(0);
19539 {
19540 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19541 std::string ex(str, iter.base());
19542 assert(ex == "-0E+00");
19543 assert(ios.width() == 0);
19544 }
19545 ios.width(25);
19546 left(ios);
19547 {
19548 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19549 std::string ex(str, iter.base());
19550 assert(ex == "-0E+00*******************");
19551 assert(ios.width() == 0);
19552 }
19553 ios.width(25);
19554 right(ios);
19555 {
19556 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19557 std::string ex(str, iter.base());
19558 assert(ex == "*******************-0E+00");
19559 assert(ios.width() == 0);
19560 }
19561 ios.width(25);
19562 internal(ios);
19563 {
19564 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19565 std::string ex(str, iter.base());
19566 assert(ex == "-*******************0E+00");
19567 assert(ios.width() == 0);
19568 }
19569 }
19570 }
19571 showpoint(ios);
19572 {
19573 ios.imbue(lc);
19574 {
19575 ios.width(0);
19576 {
19577 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19578 std::string ex(str, iter.base());
19579 assert(ex == "-0.E+00");
19580 assert(ios.width() == 0);
19581 }
19582 ios.width(25);
19583 left(ios);
19584 {
19585 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19586 std::string ex(str, iter.base());
19587 assert(ex == "-0.E+00******************");
19588 assert(ios.width() == 0);
19589 }
19590 ios.width(25);
19591 right(ios);
19592 {
19593 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19594 std::string ex(str, iter.base());
19595 assert(ex == "******************-0.E+00");
19596 assert(ios.width() == 0);
19597 }
19598 ios.width(25);
19599 internal(ios);
19600 {
19601 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19602 std::string ex(str, iter.base());
19603 assert(ex == "-******************0.E+00");
19604 assert(ios.width() == 0);
19605 }
19606 }
19607 ios.imbue(lg);
19608 {
19609 ios.width(0);
19610 {
19611 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19612 std::string ex(str, iter.base());
19613 assert(ex == "-0;E+00");
19614 assert(ios.width() == 0);
19615 }
19616 ios.width(25);
19617 left(ios);
19618 {
19619 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19620 std::string ex(str, iter.base());
19621 assert(ex == "-0;E+00******************");
19622 assert(ios.width() == 0);
19623 }
19624 ios.width(25);
19625 right(ios);
19626 {
19627 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19628 std::string ex(str, iter.base());
19629 assert(ex == "******************-0;E+00");
19630 assert(ios.width() == 0);
19631 }
19632 ios.width(25);
19633 internal(ios);
19634 {
19635 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19636 std::string ex(str, iter.base());
19637 assert(ex == "-******************0;E+00");
19638 assert(ios.width() == 0);
19639 }
19640 }
19641 }
19642 }
19643 }
19644 }
19645 ios.precision(1);
19646 {
19647 nouppercase(ios);
19648 {
19649 noshowpos(ios);
19650 {
19651 noshowpoint(ios);
19652 {
19653 ios.imbue(lc);
19654 {
19655 ios.width(0);
19656 {
19657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19658 std::string ex(str, iter.base());
19659 assert(ex == "-0.0e+00");
19660 assert(ios.width() == 0);
19661 }
19662 ios.width(25);
19663 left(ios);
19664 {
19665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19666 std::string ex(str, iter.base());
19667 assert(ex == "-0.0e+00*****************");
19668 assert(ios.width() == 0);
19669 }
19670 ios.width(25);
19671 right(ios);
19672 {
19673 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19674 std::string ex(str, iter.base());
19675 assert(ex == "*****************-0.0e+00");
19676 assert(ios.width() == 0);
19677 }
19678 ios.width(25);
19679 internal(ios);
19680 {
19681 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19682 std::string ex(str, iter.base());
19683 assert(ex == "-*****************0.0e+00");
19684 assert(ios.width() == 0);
19685 }
19686 }
19687 ios.imbue(lg);
19688 {
19689 ios.width(0);
19690 {
19691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19692 std::string ex(str, iter.base());
19693 assert(ex == "-0;0e+00");
19694 assert(ios.width() == 0);
19695 }
19696 ios.width(25);
19697 left(ios);
19698 {
19699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19700 std::string ex(str, iter.base());
19701 assert(ex == "-0;0e+00*****************");
19702 assert(ios.width() == 0);
19703 }
19704 ios.width(25);
19705 right(ios);
19706 {
19707 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19708 std::string ex(str, iter.base());
19709 assert(ex == "*****************-0;0e+00");
19710 assert(ios.width() == 0);
19711 }
19712 ios.width(25);
19713 internal(ios);
19714 {
19715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19716 std::string ex(str, iter.base());
19717 assert(ex == "-*****************0;0e+00");
19718 assert(ios.width() == 0);
19719 }
19720 }
19721 }
19722 showpoint(ios);
19723 {
19724 ios.imbue(lc);
19725 {
19726 ios.width(0);
19727 {
19728 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19729 std::string ex(str, iter.base());
19730 assert(ex == "-0.0e+00");
19731 assert(ios.width() == 0);
19732 }
19733 ios.width(25);
19734 left(ios);
19735 {
19736 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19737 std::string ex(str, iter.base());
19738 assert(ex == "-0.0e+00*****************");
19739 assert(ios.width() == 0);
19740 }
19741 ios.width(25);
19742 right(ios);
19743 {
19744 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19745 std::string ex(str, iter.base());
19746 assert(ex == "*****************-0.0e+00");
19747 assert(ios.width() == 0);
19748 }
19749 ios.width(25);
19750 internal(ios);
19751 {
19752 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19753 std::string ex(str, iter.base());
19754 assert(ex == "-*****************0.0e+00");
19755 assert(ios.width() == 0);
19756 }
19757 }
19758 ios.imbue(lg);
19759 {
19760 ios.width(0);
19761 {
19762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19763 std::string ex(str, iter.base());
19764 assert(ex == "-0;0e+00");
19765 assert(ios.width() == 0);
19766 }
19767 ios.width(25);
19768 left(ios);
19769 {
19770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19771 std::string ex(str, iter.base());
19772 assert(ex == "-0;0e+00*****************");
19773 assert(ios.width() == 0);
19774 }
19775 ios.width(25);
19776 right(ios);
19777 {
19778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19779 std::string ex(str, iter.base());
19780 assert(ex == "*****************-0;0e+00");
19781 assert(ios.width() == 0);
19782 }
19783 ios.width(25);
19784 internal(ios);
19785 {
19786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19787 std::string ex(str, iter.base());
19788 assert(ex == "-*****************0;0e+00");
19789 assert(ios.width() == 0);
19790 }
19791 }
19792 }
19793 }
19794 showpos(ios);
19795 {
19796 noshowpoint(ios);
19797 {
19798 ios.imbue(lc);
19799 {
19800 ios.width(0);
19801 {
19802 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19803 std::string ex(str, iter.base());
19804 assert(ex == "-0.0e+00");
19805 assert(ios.width() == 0);
19806 }
19807 ios.width(25);
19808 left(ios);
19809 {
19810 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19811 std::string ex(str, iter.base());
19812 assert(ex == "-0.0e+00*****************");
19813 assert(ios.width() == 0);
19814 }
19815 ios.width(25);
19816 right(ios);
19817 {
19818 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19819 std::string ex(str, iter.base());
19820 assert(ex == "*****************-0.0e+00");
19821 assert(ios.width() == 0);
19822 }
19823 ios.width(25);
19824 internal(ios);
19825 {
19826 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19827 std::string ex(str, iter.base());
19828 assert(ex == "-*****************0.0e+00");
19829 assert(ios.width() == 0);
19830 }
19831 }
19832 ios.imbue(lg);
19833 {
19834 ios.width(0);
19835 {
19836 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19837 std::string ex(str, iter.base());
19838 assert(ex == "-0;0e+00");
19839 assert(ios.width() == 0);
19840 }
19841 ios.width(25);
19842 left(ios);
19843 {
19844 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19845 std::string ex(str, iter.base());
19846 assert(ex == "-0;0e+00*****************");
19847 assert(ios.width() == 0);
19848 }
19849 ios.width(25);
19850 right(ios);
19851 {
19852 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19853 std::string ex(str, iter.base());
19854 assert(ex == "*****************-0;0e+00");
19855 assert(ios.width() == 0);
19856 }
19857 ios.width(25);
19858 internal(ios);
19859 {
19860 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19861 std::string ex(str, iter.base());
19862 assert(ex == "-*****************0;0e+00");
19863 assert(ios.width() == 0);
19864 }
19865 }
19866 }
19867 showpoint(ios);
19868 {
19869 ios.imbue(lc);
19870 {
19871 ios.width(0);
19872 {
19873 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19874 std::string ex(str, iter.base());
19875 assert(ex == "-0.0e+00");
19876 assert(ios.width() == 0);
19877 }
19878 ios.width(25);
19879 left(ios);
19880 {
19881 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19882 std::string ex(str, iter.base());
19883 assert(ex == "-0.0e+00*****************");
19884 assert(ios.width() == 0);
19885 }
19886 ios.width(25);
19887 right(ios);
19888 {
19889 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19890 std::string ex(str, iter.base());
19891 assert(ex == "*****************-0.0e+00");
19892 assert(ios.width() == 0);
19893 }
19894 ios.width(25);
19895 internal(ios);
19896 {
19897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19898 std::string ex(str, iter.base());
19899 assert(ex == "-*****************0.0e+00");
19900 assert(ios.width() == 0);
19901 }
19902 }
19903 ios.imbue(lg);
19904 {
19905 ios.width(0);
19906 {
19907 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19908 std::string ex(str, iter.base());
19909 assert(ex == "-0;0e+00");
19910 assert(ios.width() == 0);
19911 }
19912 ios.width(25);
19913 left(ios);
19914 {
19915 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19916 std::string ex(str, iter.base());
19917 assert(ex == "-0;0e+00*****************");
19918 assert(ios.width() == 0);
19919 }
19920 ios.width(25);
19921 right(ios);
19922 {
19923 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19924 std::string ex(str, iter.base());
19925 assert(ex == "*****************-0;0e+00");
19926 assert(ios.width() == 0);
19927 }
19928 ios.width(25);
19929 internal(ios);
19930 {
19931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19932 std::string ex(str, iter.base());
19933 assert(ex == "-*****************0;0e+00");
19934 assert(ios.width() == 0);
19935 }
19936 }
19937 }
19938 }
19939 }
19940 uppercase(ios);
19941 {
19942 noshowpos(ios);
19943 {
19944 noshowpoint(ios);
19945 {
19946 ios.imbue(lc);
19947 {
19948 ios.width(0);
19949 {
19950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19951 std::string ex(str, iter.base());
19952 assert(ex == "-0.0E+00");
19953 assert(ios.width() == 0);
19954 }
19955 ios.width(25);
19956 left(ios);
19957 {
19958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19959 std::string ex(str, iter.base());
19960 assert(ex == "-0.0E+00*****************");
19961 assert(ios.width() == 0);
19962 }
19963 ios.width(25);
19964 right(ios);
19965 {
19966 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19967 std::string ex(str, iter.base());
19968 assert(ex == "*****************-0.0E+00");
19969 assert(ios.width() == 0);
19970 }
19971 ios.width(25);
19972 internal(ios);
19973 {
19974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19975 std::string ex(str, iter.base());
19976 assert(ex == "-*****************0.0E+00");
19977 assert(ios.width() == 0);
19978 }
19979 }
19980 ios.imbue(lg);
19981 {
19982 ios.width(0);
19983 {
19984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19985 std::string ex(str, iter.base());
19986 assert(ex == "-0;0E+00");
19987 assert(ios.width() == 0);
19988 }
19989 ios.width(25);
19990 left(ios);
19991 {
19992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
19993 std::string ex(str, iter.base());
19994 assert(ex == "-0;0E+00*****************");
19995 assert(ios.width() == 0);
19996 }
19997 ios.width(25);
19998 right(ios);
19999 {
20000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20001 std::string ex(str, iter.base());
20002 assert(ex == "*****************-0;0E+00");
20003 assert(ios.width() == 0);
20004 }
20005 ios.width(25);
20006 internal(ios);
20007 {
20008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20009 std::string ex(str, iter.base());
20010 assert(ex == "-*****************0;0E+00");
20011 assert(ios.width() == 0);
20012 }
20013 }
20014 }
20015 showpoint(ios);
20016 {
20017 ios.imbue(lc);
20018 {
20019 ios.width(0);
20020 {
20021 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20022 std::string ex(str, iter.base());
20023 assert(ex == "-0.0E+00");
20024 assert(ios.width() == 0);
20025 }
20026 ios.width(25);
20027 left(ios);
20028 {
20029 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20030 std::string ex(str, iter.base());
20031 assert(ex == "-0.0E+00*****************");
20032 assert(ios.width() == 0);
20033 }
20034 ios.width(25);
20035 right(ios);
20036 {
20037 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20038 std::string ex(str, iter.base());
20039 assert(ex == "*****************-0.0E+00");
20040 assert(ios.width() == 0);
20041 }
20042 ios.width(25);
20043 internal(ios);
20044 {
20045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20046 std::string ex(str, iter.base());
20047 assert(ex == "-*****************0.0E+00");
20048 assert(ios.width() == 0);
20049 }
20050 }
20051 ios.imbue(lg);
20052 {
20053 ios.width(0);
20054 {
20055 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20056 std::string ex(str, iter.base());
20057 assert(ex == "-0;0E+00");
20058 assert(ios.width() == 0);
20059 }
20060 ios.width(25);
20061 left(ios);
20062 {
20063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20064 std::string ex(str, iter.base());
20065 assert(ex == "-0;0E+00*****************");
20066 assert(ios.width() == 0);
20067 }
20068 ios.width(25);
20069 right(ios);
20070 {
20071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20072 std::string ex(str, iter.base());
20073 assert(ex == "*****************-0;0E+00");
20074 assert(ios.width() == 0);
20075 }
20076 ios.width(25);
20077 internal(ios);
20078 {
20079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20080 std::string ex(str, iter.base());
20081 assert(ex == "-*****************0;0E+00");
20082 assert(ios.width() == 0);
20083 }
20084 }
20085 }
20086 }
20087 showpos(ios);
20088 {
20089 noshowpoint(ios);
20090 {
20091 ios.imbue(lc);
20092 {
20093 ios.width(0);
20094 {
20095 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20096 std::string ex(str, iter.base());
20097 assert(ex == "-0.0E+00");
20098 assert(ios.width() == 0);
20099 }
20100 ios.width(25);
20101 left(ios);
20102 {
20103 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20104 std::string ex(str, iter.base());
20105 assert(ex == "-0.0E+00*****************");
20106 assert(ios.width() == 0);
20107 }
20108 ios.width(25);
20109 right(ios);
20110 {
20111 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20112 std::string ex(str, iter.base());
20113 assert(ex == "*****************-0.0E+00");
20114 assert(ios.width() == 0);
20115 }
20116 ios.width(25);
20117 internal(ios);
20118 {
20119 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20120 std::string ex(str, iter.base());
20121 assert(ex == "-*****************0.0E+00");
20122 assert(ios.width() == 0);
20123 }
20124 }
20125 ios.imbue(lg);
20126 {
20127 ios.width(0);
20128 {
20129 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20130 std::string ex(str, iter.base());
20131 assert(ex == "-0;0E+00");
20132 assert(ios.width() == 0);
20133 }
20134 ios.width(25);
20135 left(ios);
20136 {
20137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20138 std::string ex(str, iter.base());
20139 assert(ex == "-0;0E+00*****************");
20140 assert(ios.width() == 0);
20141 }
20142 ios.width(25);
20143 right(ios);
20144 {
20145 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20146 std::string ex(str, iter.base());
20147 assert(ex == "*****************-0;0E+00");
20148 assert(ios.width() == 0);
20149 }
20150 ios.width(25);
20151 internal(ios);
20152 {
20153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20154 std::string ex(str, iter.base());
20155 assert(ex == "-*****************0;0E+00");
20156 assert(ios.width() == 0);
20157 }
20158 }
20159 }
20160 showpoint(ios);
20161 {
20162 ios.imbue(lc);
20163 {
20164 ios.width(0);
20165 {
20166 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20167 std::string ex(str, iter.base());
20168 assert(ex == "-0.0E+00");
20169 assert(ios.width() == 0);
20170 }
20171 ios.width(25);
20172 left(ios);
20173 {
20174 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20175 std::string ex(str, iter.base());
20176 assert(ex == "-0.0E+00*****************");
20177 assert(ios.width() == 0);
20178 }
20179 ios.width(25);
20180 right(ios);
20181 {
20182 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20183 std::string ex(str, iter.base());
20184 assert(ex == "*****************-0.0E+00");
20185 assert(ios.width() == 0);
20186 }
20187 ios.width(25);
20188 internal(ios);
20189 {
20190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20191 std::string ex(str, iter.base());
20192 assert(ex == "-*****************0.0E+00");
20193 assert(ios.width() == 0);
20194 }
20195 }
20196 ios.imbue(lg);
20197 {
20198 ios.width(0);
20199 {
20200 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20201 std::string ex(str, iter.base());
20202 assert(ex == "-0;0E+00");
20203 assert(ios.width() == 0);
20204 }
20205 ios.width(25);
20206 left(ios);
20207 {
20208 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20209 std::string ex(str, iter.base());
20210 assert(ex == "-0;0E+00*****************");
20211 assert(ios.width() == 0);
20212 }
20213 ios.width(25);
20214 right(ios);
20215 {
20216 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20217 std::string ex(str, iter.base());
20218 assert(ex == "*****************-0;0E+00");
20219 assert(ios.width() == 0);
20220 }
20221 ios.width(25);
20222 internal(ios);
20223 {
20224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20225 std::string ex(str, iter.base());
20226 assert(ex == "-*****************0;0E+00");
20227 assert(ios.width() == 0);
20228 }
20229 }
20230 }
20231 }
20232 }
20233 }
20234 ios.precision(6);
20235 {
20236 nouppercase(ios);
20237 {
20238 noshowpos(ios);
20239 {
20240 noshowpoint(ios);
20241 {
20242 ios.imbue(lc);
20243 {
20244 ios.width(0);
20245 {
20246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20247 std::string ex(str, iter.base());
20248 assert(ex == "-0.000000e+00");
20249 assert(ios.width() == 0);
20250 }
20251 ios.width(25);
20252 left(ios);
20253 {
20254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20255 std::string ex(str, iter.base());
20256 assert(ex == "-0.000000e+00************");
20257 assert(ios.width() == 0);
20258 }
20259 ios.width(25);
20260 right(ios);
20261 {
20262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20263 std::string ex(str, iter.base());
20264 assert(ex == "************-0.000000e+00");
20265 assert(ios.width() == 0);
20266 }
20267 ios.width(25);
20268 internal(ios);
20269 {
20270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20271 std::string ex(str, iter.base());
20272 assert(ex == "-************0.000000e+00");
20273 assert(ios.width() == 0);
20274 }
20275 }
20276 ios.imbue(lg);
20277 {
20278 ios.width(0);
20279 {
20280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20281 std::string ex(str, iter.base());
20282 assert(ex == "-0;000000e+00");
20283 assert(ios.width() == 0);
20284 }
20285 ios.width(25);
20286 left(ios);
20287 {
20288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20289 std::string ex(str, iter.base());
20290 assert(ex == "-0;000000e+00************");
20291 assert(ios.width() == 0);
20292 }
20293 ios.width(25);
20294 right(ios);
20295 {
20296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20297 std::string ex(str, iter.base());
20298 assert(ex == "************-0;000000e+00");
20299 assert(ios.width() == 0);
20300 }
20301 ios.width(25);
20302 internal(ios);
20303 {
20304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20305 std::string ex(str, iter.base());
20306 assert(ex == "-************0;000000e+00");
20307 assert(ios.width() == 0);
20308 }
20309 }
20310 }
20311 showpoint(ios);
20312 {
20313 ios.imbue(lc);
20314 {
20315 ios.width(0);
20316 {
20317 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20318 std::string ex(str, iter.base());
20319 assert(ex == "-0.000000e+00");
20320 assert(ios.width() == 0);
20321 }
20322 ios.width(25);
20323 left(ios);
20324 {
20325 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20326 std::string ex(str, iter.base());
20327 assert(ex == "-0.000000e+00************");
20328 assert(ios.width() == 0);
20329 }
20330 ios.width(25);
20331 right(ios);
20332 {
20333 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20334 std::string ex(str, iter.base());
20335 assert(ex == "************-0.000000e+00");
20336 assert(ios.width() == 0);
20337 }
20338 ios.width(25);
20339 internal(ios);
20340 {
20341 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20342 std::string ex(str, iter.base());
20343 assert(ex == "-************0.000000e+00");
20344 assert(ios.width() == 0);
20345 }
20346 }
20347 ios.imbue(lg);
20348 {
20349 ios.width(0);
20350 {
20351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20352 std::string ex(str, iter.base());
20353 assert(ex == "-0;000000e+00");
20354 assert(ios.width() == 0);
20355 }
20356 ios.width(25);
20357 left(ios);
20358 {
20359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20360 std::string ex(str, iter.base());
20361 assert(ex == "-0;000000e+00************");
20362 assert(ios.width() == 0);
20363 }
20364 ios.width(25);
20365 right(ios);
20366 {
20367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20368 std::string ex(str, iter.base());
20369 assert(ex == "************-0;000000e+00");
20370 assert(ios.width() == 0);
20371 }
20372 ios.width(25);
20373 internal(ios);
20374 {
20375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20376 std::string ex(str, iter.base());
20377 assert(ex == "-************0;000000e+00");
20378 assert(ios.width() == 0);
20379 }
20380 }
20381 }
20382 }
20383 showpos(ios);
20384 {
20385 noshowpoint(ios);
20386 {
20387 ios.imbue(lc);
20388 {
20389 ios.width(0);
20390 {
20391 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20392 std::string ex(str, iter.base());
20393 assert(ex == "-0.000000e+00");
20394 assert(ios.width() == 0);
20395 }
20396 ios.width(25);
20397 left(ios);
20398 {
20399 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20400 std::string ex(str, iter.base());
20401 assert(ex == "-0.000000e+00************");
20402 assert(ios.width() == 0);
20403 }
20404 ios.width(25);
20405 right(ios);
20406 {
20407 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20408 std::string ex(str, iter.base());
20409 assert(ex == "************-0.000000e+00");
20410 assert(ios.width() == 0);
20411 }
20412 ios.width(25);
20413 internal(ios);
20414 {
20415 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20416 std::string ex(str, iter.base());
20417 assert(ex == "-************0.000000e+00");
20418 assert(ios.width() == 0);
20419 }
20420 }
20421 ios.imbue(lg);
20422 {
20423 ios.width(0);
20424 {
20425 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20426 std::string ex(str, iter.base());
20427 assert(ex == "-0;000000e+00");
20428 assert(ios.width() == 0);
20429 }
20430 ios.width(25);
20431 left(ios);
20432 {
20433 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20434 std::string ex(str, iter.base());
20435 assert(ex == "-0;000000e+00************");
20436 assert(ios.width() == 0);
20437 }
20438 ios.width(25);
20439 right(ios);
20440 {
20441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20442 std::string ex(str, iter.base());
20443 assert(ex == "************-0;000000e+00");
20444 assert(ios.width() == 0);
20445 }
20446 ios.width(25);
20447 internal(ios);
20448 {
20449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20450 std::string ex(str, iter.base());
20451 assert(ex == "-************0;000000e+00");
20452 assert(ios.width() == 0);
20453 }
20454 }
20455 }
20456 showpoint(ios);
20457 {
20458 ios.imbue(lc);
20459 {
20460 ios.width(0);
20461 {
20462 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20463 std::string ex(str, iter.base());
20464 assert(ex == "-0.000000e+00");
20465 assert(ios.width() == 0);
20466 }
20467 ios.width(25);
20468 left(ios);
20469 {
20470 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20471 std::string ex(str, iter.base());
20472 assert(ex == "-0.000000e+00************");
20473 assert(ios.width() == 0);
20474 }
20475 ios.width(25);
20476 right(ios);
20477 {
20478 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20479 std::string ex(str, iter.base());
20480 assert(ex == "************-0.000000e+00");
20481 assert(ios.width() == 0);
20482 }
20483 ios.width(25);
20484 internal(ios);
20485 {
20486 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20487 std::string ex(str, iter.base());
20488 assert(ex == "-************0.000000e+00");
20489 assert(ios.width() == 0);
20490 }
20491 }
20492 ios.imbue(lg);
20493 {
20494 ios.width(0);
20495 {
20496 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20497 std::string ex(str, iter.base());
20498 assert(ex == "-0;000000e+00");
20499 assert(ios.width() == 0);
20500 }
20501 ios.width(25);
20502 left(ios);
20503 {
20504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20505 std::string ex(str, iter.base());
20506 assert(ex == "-0;000000e+00************");
20507 assert(ios.width() == 0);
20508 }
20509 ios.width(25);
20510 right(ios);
20511 {
20512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20513 std::string ex(str, iter.base());
20514 assert(ex == "************-0;000000e+00");
20515 assert(ios.width() == 0);
20516 }
20517 ios.width(25);
20518 internal(ios);
20519 {
20520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20521 std::string ex(str, iter.base());
20522 assert(ex == "-************0;000000e+00");
20523 assert(ios.width() == 0);
20524 }
20525 }
20526 }
20527 }
20528 }
20529 uppercase(ios);
20530 {
20531 noshowpos(ios);
20532 {
20533 noshowpoint(ios);
20534 {
20535 ios.imbue(lc);
20536 {
20537 ios.width(0);
20538 {
20539 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20540 std::string ex(str, iter.base());
20541 assert(ex == "-0.000000E+00");
20542 assert(ios.width() == 0);
20543 }
20544 ios.width(25);
20545 left(ios);
20546 {
20547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20548 std::string ex(str, iter.base());
20549 assert(ex == "-0.000000E+00************");
20550 assert(ios.width() == 0);
20551 }
20552 ios.width(25);
20553 right(ios);
20554 {
20555 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20556 std::string ex(str, iter.base());
20557 assert(ex == "************-0.000000E+00");
20558 assert(ios.width() == 0);
20559 }
20560 ios.width(25);
20561 internal(ios);
20562 {
20563 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20564 std::string ex(str, iter.base());
20565 assert(ex == "-************0.000000E+00");
20566 assert(ios.width() == 0);
20567 }
20568 }
20569 ios.imbue(lg);
20570 {
20571 ios.width(0);
20572 {
20573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20574 std::string ex(str, iter.base());
20575 assert(ex == "-0;000000E+00");
20576 assert(ios.width() == 0);
20577 }
20578 ios.width(25);
20579 left(ios);
20580 {
20581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20582 std::string ex(str, iter.base());
20583 assert(ex == "-0;000000E+00************");
20584 assert(ios.width() == 0);
20585 }
20586 ios.width(25);
20587 right(ios);
20588 {
20589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20590 std::string ex(str, iter.base());
20591 assert(ex == "************-0;000000E+00");
20592 assert(ios.width() == 0);
20593 }
20594 ios.width(25);
20595 internal(ios);
20596 {
20597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20598 std::string ex(str, iter.base());
20599 assert(ex == "-************0;000000E+00");
20600 assert(ios.width() == 0);
20601 }
20602 }
20603 }
20604 showpoint(ios);
20605 {
20606 ios.imbue(lc);
20607 {
20608 ios.width(0);
20609 {
20610 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20611 std::string ex(str, iter.base());
20612 assert(ex == "-0.000000E+00");
20613 assert(ios.width() == 0);
20614 }
20615 ios.width(25);
20616 left(ios);
20617 {
20618 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20619 std::string ex(str, iter.base());
20620 assert(ex == "-0.000000E+00************");
20621 assert(ios.width() == 0);
20622 }
20623 ios.width(25);
20624 right(ios);
20625 {
20626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20627 std::string ex(str, iter.base());
20628 assert(ex == "************-0.000000E+00");
20629 assert(ios.width() == 0);
20630 }
20631 ios.width(25);
20632 internal(ios);
20633 {
20634 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20635 std::string ex(str, iter.base());
20636 assert(ex == "-************0.000000E+00");
20637 assert(ios.width() == 0);
20638 }
20639 }
20640 ios.imbue(lg);
20641 {
20642 ios.width(0);
20643 {
20644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20645 std::string ex(str, iter.base());
20646 assert(ex == "-0;000000E+00");
20647 assert(ios.width() == 0);
20648 }
20649 ios.width(25);
20650 left(ios);
20651 {
20652 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20653 std::string ex(str, iter.base());
20654 assert(ex == "-0;000000E+00************");
20655 assert(ios.width() == 0);
20656 }
20657 ios.width(25);
20658 right(ios);
20659 {
20660 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20661 std::string ex(str, iter.base());
20662 assert(ex == "************-0;000000E+00");
20663 assert(ios.width() == 0);
20664 }
20665 ios.width(25);
20666 internal(ios);
20667 {
20668 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20669 std::string ex(str, iter.base());
20670 assert(ex == "-************0;000000E+00");
20671 assert(ios.width() == 0);
20672 }
20673 }
20674 }
20675 }
20676 showpos(ios);
20677 {
20678 noshowpoint(ios);
20679 {
20680 ios.imbue(lc);
20681 {
20682 ios.width(0);
20683 {
20684 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20685 std::string ex(str, iter.base());
20686 assert(ex == "-0.000000E+00");
20687 assert(ios.width() == 0);
20688 }
20689 ios.width(25);
20690 left(ios);
20691 {
20692 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20693 std::string ex(str, iter.base());
20694 assert(ex == "-0.000000E+00************");
20695 assert(ios.width() == 0);
20696 }
20697 ios.width(25);
20698 right(ios);
20699 {
20700 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20701 std::string ex(str, iter.base());
20702 assert(ex == "************-0.000000E+00");
20703 assert(ios.width() == 0);
20704 }
20705 ios.width(25);
20706 internal(ios);
20707 {
20708 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20709 std::string ex(str, iter.base());
20710 assert(ex == "-************0.000000E+00");
20711 assert(ios.width() == 0);
20712 }
20713 }
20714 ios.imbue(lg);
20715 {
20716 ios.width(0);
20717 {
20718 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20719 std::string ex(str, iter.base());
20720 assert(ex == "-0;000000E+00");
20721 assert(ios.width() == 0);
20722 }
20723 ios.width(25);
20724 left(ios);
20725 {
20726 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20727 std::string ex(str, iter.base());
20728 assert(ex == "-0;000000E+00************");
20729 assert(ios.width() == 0);
20730 }
20731 ios.width(25);
20732 right(ios);
20733 {
20734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20735 std::string ex(str, iter.base());
20736 assert(ex == "************-0;000000E+00");
20737 assert(ios.width() == 0);
20738 }
20739 ios.width(25);
20740 internal(ios);
20741 {
20742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20743 std::string ex(str, iter.base());
20744 assert(ex == "-************0;000000E+00");
20745 assert(ios.width() == 0);
20746 }
20747 }
20748 }
20749 showpoint(ios);
20750 {
20751 ios.imbue(lc);
20752 {
20753 ios.width(0);
20754 {
20755 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20756 std::string ex(str, iter.base());
20757 assert(ex == "-0.000000E+00");
20758 assert(ios.width() == 0);
20759 }
20760 ios.width(25);
20761 left(ios);
20762 {
20763 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20764 std::string ex(str, iter.base());
20765 assert(ex == "-0.000000E+00************");
20766 assert(ios.width() == 0);
20767 }
20768 ios.width(25);
20769 right(ios);
20770 {
20771 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20772 std::string ex(str, iter.base());
20773 assert(ex == "************-0.000000E+00");
20774 assert(ios.width() == 0);
20775 }
20776 ios.width(25);
20777 internal(ios);
20778 {
20779 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20780 std::string ex(str, iter.base());
20781 assert(ex == "-************0.000000E+00");
20782 assert(ios.width() == 0);
20783 }
20784 }
20785 ios.imbue(lg);
20786 {
20787 ios.width(0);
20788 {
20789 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20790 std::string ex(str, iter.base());
20791 assert(ex == "-0;000000E+00");
20792 assert(ios.width() == 0);
20793 }
20794 ios.width(25);
20795 left(ios);
20796 {
20797 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20798 std::string ex(str, iter.base());
20799 assert(ex == "-0;000000E+00************");
20800 assert(ios.width() == 0);
20801 }
20802 ios.width(25);
20803 right(ios);
20804 {
20805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20806 std::string ex(str, iter.base());
20807 assert(ex == "************-0;000000E+00");
20808 assert(ios.width() == 0);
20809 }
20810 ios.width(25);
20811 internal(ios);
20812 {
20813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20814 std::string ex(str, iter.base());
20815 assert(ex == "-************0;000000E+00");
20816 assert(ios.width() == 0);
20817 }
20818 }
20819 }
20820 }
20821 }
20822 }
20823 ios.precision(16);
20824 {
20825 }
20826 ios.precision(60);
20827 {
20828 }
20829 }
20830 }
20831 }
20832
test10()20833 void test10()
20834 {
20835 char str[200];
20836 output_iterator<char*> iter;
20837 std::locale lc = std::locale::classic();
20838 std::locale lg(lc, new my_numpunct);
20839 const my_facet f(1);
20840 {
20841 long double v = 1234567890.125;
20842 std::ios ios(0);
20843 scientific(ios);
20844 // %e
20845 {
20846 ios.precision(0);
20847 {
20848 nouppercase(ios);
20849 {
20850 noshowpos(ios);
20851 {
20852 noshowpoint(ios);
20853 {
20854 ios.imbue(lc);
20855 {
20856 ios.width(0);
20857 {
20858 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20859 std::string ex(str, iter.base());
20860 assert(ex == "1e+09");
20861 assert(ios.width() == 0);
20862 }
20863 ios.width(25);
20864 left(ios);
20865 {
20866 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20867 std::string ex(str, iter.base());
20868 assert(ex == "1e+09********************");
20869 assert(ios.width() == 0);
20870 }
20871 ios.width(25);
20872 right(ios);
20873 {
20874 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20875 std::string ex(str, iter.base());
20876 assert(ex == "********************1e+09");
20877 assert(ios.width() == 0);
20878 }
20879 ios.width(25);
20880 internal(ios);
20881 {
20882 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20883 std::string ex(str, iter.base());
20884 assert(ex == "********************1e+09");
20885 assert(ios.width() == 0);
20886 }
20887 }
20888 ios.imbue(lg);
20889 {
20890 ios.width(0);
20891 {
20892 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20893 std::string ex(str, iter.base());
20894 assert(ex == "1e+09");
20895 assert(ios.width() == 0);
20896 }
20897 ios.width(25);
20898 left(ios);
20899 {
20900 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20901 std::string ex(str, iter.base());
20902 assert(ex == "1e+09********************");
20903 assert(ios.width() == 0);
20904 }
20905 ios.width(25);
20906 right(ios);
20907 {
20908 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20909 std::string ex(str, iter.base());
20910 assert(ex == "********************1e+09");
20911 assert(ios.width() == 0);
20912 }
20913 ios.width(25);
20914 internal(ios);
20915 {
20916 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20917 std::string ex(str, iter.base());
20918 assert(ex == "********************1e+09");
20919 assert(ios.width() == 0);
20920 }
20921 }
20922 }
20923 showpoint(ios);
20924 {
20925 ios.imbue(lc);
20926 {
20927 ios.width(0);
20928 {
20929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20930 std::string ex(str, iter.base());
20931 assert(ex == "1.e+09");
20932 assert(ios.width() == 0);
20933 }
20934 ios.width(25);
20935 left(ios);
20936 {
20937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20938 std::string ex(str, iter.base());
20939 assert(ex == "1.e+09*******************");
20940 assert(ios.width() == 0);
20941 }
20942 ios.width(25);
20943 right(ios);
20944 {
20945 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20946 std::string ex(str, iter.base());
20947 assert(ex == "*******************1.e+09");
20948 assert(ios.width() == 0);
20949 }
20950 ios.width(25);
20951 internal(ios);
20952 {
20953 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20954 std::string ex(str, iter.base());
20955 assert(ex == "*******************1.e+09");
20956 assert(ios.width() == 0);
20957 }
20958 }
20959 ios.imbue(lg);
20960 {
20961 ios.width(0);
20962 {
20963 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20964 std::string ex(str, iter.base());
20965 assert(ex == "1;e+09");
20966 assert(ios.width() == 0);
20967 }
20968 ios.width(25);
20969 left(ios);
20970 {
20971 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20972 std::string ex(str, iter.base());
20973 assert(ex == "1;e+09*******************");
20974 assert(ios.width() == 0);
20975 }
20976 ios.width(25);
20977 right(ios);
20978 {
20979 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20980 std::string ex(str, iter.base());
20981 assert(ex == "*******************1;e+09");
20982 assert(ios.width() == 0);
20983 }
20984 ios.width(25);
20985 internal(ios);
20986 {
20987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
20988 std::string ex(str, iter.base());
20989 assert(ex == "*******************1;e+09");
20990 assert(ios.width() == 0);
20991 }
20992 }
20993 }
20994 }
20995 showpos(ios);
20996 {
20997 noshowpoint(ios);
20998 {
20999 ios.imbue(lc);
21000 {
21001 ios.width(0);
21002 {
21003 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21004 std::string ex(str, iter.base());
21005 assert(ex == "+1e+09");
21006 assert(ios.width() == 0);
21007 }
21008 ios.width(25);
21009 left(ios);
21010 {
21011 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21012 std::string ex(str, iter.base());
21013 assert(ex == "+1e+09*******************");
21014 assert(ios.width() == 0);
21015 }
21016 ios.width(25);
21017 right(ios);
21018 {
21019 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21020 std::string ex(str, iter.base());
21021 assert(ex == "*******************+1e+09");
21022 assert(ios.width() == 0);
21023 }
21024 ios.width(25);
21025 internal(ios);
21026 {
21027 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21028 std::string ex(str, iter.base());
21029 assert(ex == "+*******************1e+09");
21030 assert(ios.width() == 0);
21031 }
21032 }
21033 ios.imbue(lg);
21034 {
21035 ios.width(0);
21036 {
21037 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21038 std::string ex(str, iter.base());
21039 assert(ex == "+1e+09");
21040 assert(ios.width() == 0);
21041 }
21042 ios.width(25);
21043 left(ios);
21044 {
21045 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21046 std::string ex(str, iter.base());
21047 assert(ex == "+1e+09*******************");
21048 assert(ios.width() == 0);
21049 }
21050 ios.width(25);
21051 right(ios);
21052 {
21053 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21054 std::string ex(str, iter.base());
21055 assert(ex == "*******************+1e+09");
21056 assert(ios.width() == 0);
21057 }
21058 ios.width(25);
21059 internal(ios);
21060 {
21061 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21062 std::string ex(str, iter.base());
21063 assert(ex == "+*******************1e+09");
21064 assert(ios.width() == 0);
21065 }
21066 }
21067 }
21068 showpoint(ios);
21069 {
21070 ios.imbue(lc);
21071 {
21072 ios.width(0);
21073 {
21074 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21075 std::string ex(str, iter.base());
21076 assert(ex == "+1.e+09");
21077 assert(ios.width() == 0);
21078 }
21079 ios.width(25);
21080 left(ios);
21081 {
21082 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21083 std::string ex(str, iter.base());
21084 assert(ex == "+1.e+09******************");
21085 assert(ios.width() == 0);
21086 }
21087 ios.width(25);
21088 right(ios);
21089 {
21090 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21091 std::string ex(str, iter.base());
21092 assert(ex == "******************+1.e+09");
21093 assert(ios.width() == 0);
21094 }
21095 ios.width(25);
21096 internal(ios);
21097 {
21098 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21099 std::string ex(str, iter.base());
21100 assert(ex == "+******************1.e+09");
21101 assert(ios.width() == 0);
21102 }
21103 }
21104 ios.imbue(lg);
21105 {
21106 ios.width(0);
21107 {
21108 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21109 std::string ex(str, iter.base());
21110 assert(ex == "+1;e+09");
21111 assert(ios.width() == 0);
21112 }
21113 ios.width(25);
21114 left(ios);
21115 {
21116 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21117 std::string ex(str, iter.base());
21118 assert(ex == "+1;e+09******************");
21119 assert(ios.width() == 0);
21120 }
21121 ios.width(25);
21122 right(ios);
21123 {
21124 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21125 std::string ex(str, iter.base());
21126 assert(ex == "******************+1;e+09");
21127 assert(ios.width() == 0);
21128 }
21129 ios.width(25);
21130 internal(ios);
21131 {
21132 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21133 std::string ex(str, iter.base());
21134 assert(ex == "+******************1;e+09");
21135 assert(ios.width() == 0);
21136 }
21137 }
21138 }
21139 }
21140 }
21141 uppercase(ios);
21142 {
21143 noshowpos(ios);
21144 {
21145 noshowpoint(ios);
21146 {
21147 ios.imbue(lc);
21148 {
21149 ios.width(0);
21150 {
21151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21152 std::string ex(str, iter.base());
21153 assert(ex == "1E+09");
21154 assert(ios.width() == 0);
21155 }
21156 ios.width(25);
21157 left(ios);
21158 {
21159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21160 std::string ex(str, iter.base());
21161 assert(ex == "1E+09********************");
21162 assert(ios.width() == 0);
21163 }
21164 ios.width(25);
21165 right(ios);
21166 {
21167 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21168 std::string ex(str, iter.base());
21169 assert(ex == "********************1E+09");
21170 assert(ios.width() == 0);
21171 }
21172 ios.width(25);
21173 internal(ios);
21174 {
21175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21176 std::string ex(str, iter.base());
21177 assert(ex == "********************1E+09");
21178 assert(ios.width() == 0);
21179 }
21180 }
21181 ios.imbue(lg);
21182 {
21183 ios.width(0);
21184 {
21185 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21186 std::string ex(str, iter.base());
21187 assert(ex == "1E+09");
21188 assert(ios.width() == 0);
21189 }
21190 ios.width(25);
21191 left(ios);
21192 {
21193 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21194 std::string ex(str, iter.base());
21195 assert(ex == "1E+09********************");
21196 assert(ios.width() == 0);
21197 }
21198 ios.width(25);
21199 right(ios);
21200 {
21201 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21202 std::string ex(str, iter.base());
21203 assert(ex == "********************1E+09");
21204 assert(ios.width() == 0);
21205 }
21206 ios.width(25);
21207 internal(ios);
21208 {
21209 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21210 std::string ex(str, iter.base());
21211 assert(ex == "********************1E+09");
21212 assert(ios.width() == 0);
21213 }
21214 }
21215 }
21216 showpoint(ios);
21217 {
21218 ios.imbue(lc);
21219 {
21220 ios.width(0);
21221 {
21222 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21223 std::string ex(str, iter.base());
21224 assert(ex == "1.E+09");
21225 assert(ios.width() == 0);
21226 }
21227 ios.width(25);
21228 left(ios);
21229 {
21230 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21231 std::string ex(str, iter.base());
21232 assert(ex == "1.E+09*******************");
21233 assert(ios.width() == 0);
21234 }
21235 ios.width(25);
21236 right(ios);
21237 {
21238 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21239 std::string ex(str, iter.base());
21240 assert(ex == "*******************1.E+09");
21241 assert(ios.width() == 0);
21242 }
21243 ios.width(25);
21244 internal(ios);
21245 {
21246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21247 std::string ex(str, iter.base());
21248 assert(ex == "*******************1.E+09");
21249 assert(ios.width() == 0);
21250 }
21251 }
21252 ios.imbue(lg);
21253 {
21254 ios.width(0);
21255 {
21256 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21257 std::string ex(str, iter.base());
21258 assert(ex == "1;E+09");
21259 assert(ios.width() == 0);
21260 }
21261 ios.width(25);
21262 left(ios);
21263 {
21264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21265 std::string ex(str, iter.base());
21266 assert(ex == "1;E+09*******************");
21267 assert(ios.width() == 0);
21268 }
21269 ios.width(25);
21270 right(ios);
21271 {
21272 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21273 std::string ex(str, iter.base());
21274 assert(ex == "*******************1;E+09");
21275 assert(ios.width() == 0);
21276 }
21277 ios.width(25);
21278 internal(ios);
21279 {
21280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21281 std::string ex(str, iter.base());
21282 assert(ex == "*******************1;E+09");
21283 assert(ios.width() == 0);
21284 }
21285 }
21286 }
21287 }
21288 showpos(ios);
21289 {
21290 noshowpoint(ios);
21291 {
21292 ios.imbue(lc);
21293 {
21294 ios.width(0);
21295 {
21296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21297 std::string ex(str, iter.base());
21298 assert(ex == "+1E+09");
21299 assert(ios.width() == 0);
21300 }
21301 ios.width(25);
21302 left(ios);
21303 {
21304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21305 std::string ex(str, iter.base());
21306 assert(ex == "+1E+09*******************");
21307 assert(ios.width() == 0);
21308 }
21309 ios.width(25);
21310 right(ios);
21311 {
21312 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21313 std::string ex(str, iter.base());
21314 assert(ex == "*******************+1E+09");
21315 assert(ios.width() == 0);
21316 }
21317 ios.width(25);
21318 internal(ios);
21319 {
21320 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21321 std::string ex(str, iter.base());
21322 assert(ex == "+*******************1E+09");
21323 assert(ios.width() == 0);
21324 }
21325 }
21326 ios.imbue(lg);
21327 {
21328 ios.width(0);
21329 {
21330 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21331 std::string ex(str, iter.base());
21332 assert(ex == "+1E+09");
21333 assert(ios.width() == 0);
21334 }
21335 ios.width(25);
21336 left(ios);
21337 {
21338 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21339 std::string ex(str, iter.base());
21340 assert(ex == "+1E+09*******************");
21341 assert(ios.width() == 0);
21342 }
21343 ios.width(25);
21344 right(ios);
21345 {
21346 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21347 std::string ex(str, iter.base());
21348 assert(ex == "*******************+1E+09");
21349 assert(ios.width() == 0);
21350 }
21351 ios.width(25);
21352 internal(ios);
21353 {
21354 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21355 std::string ex(str, iter.base());
21356 assert(ex == "+*******************1E+09");
21357 assert(ios.width() == 0);
21358 }
21359 }
21360 }
21361 showpoint(ios);
21362 {
21363 ios.imbue(lc);
21364 {
21365 ios.width(0);
21366 {
21367 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21368 std::string ex(str, iter.base());
21369 assert(ex == "+1.E+09");
21370 assert(ios.width() == 0);
21371 }
21372 ios.width(25);
21373 left(ios);
21374 {
21375 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21376 std::string ex(str, iter.base());
21377 assert(ex == "+1.E+09******************");
21378 assert(ios.width() == 0);
21379 }
21380 ios.width(25);
21381 right(ios);
21382 {
21383 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21384 std::string ex(str, iter.base());
21385 assert(ex == "******************+1.E+09");
21386 assert(ios.width() == 0);
21387 }
21388 ios.width(25);
21389 internal(ios);
21390 {
21391 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21392 std::string ex(str, iter.base());
21393 assert(ex == "+******************1.E+09");
21394 assert(ios.width() == 0);
21395 }
21396 }
21397 ios.imbue(lg);
21398 {
21399 ios.width(0);
21400 {
21401 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21402 std::string ex(str, iter.base());
21403 assert(ex == "+1;E+09");
21404 assert(ios.width() == 0);
21405 }
21406 ios.width(25);
21407 left(ios);
21408 {
21409 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21410 std::string ex(str, iter.base());
21411 assert(ex == "+1;E+09******************");
21412 assert(ios.width() == 0);
21413 }
21414 ios.width(25);
21415 right(ios);
21416 {
21417 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21418 std::string ex(str, iter.base());
21419 assert(ex == "******************+1;E+09");
21420 assert(ios.width() == 0);
21421 }
21422 ios.width(25);
21423 internal(ios);
21424 {
21425 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21426 std::string ex(str, iter.base());
21427 assert(ex == "+******************1;E+09");
21428 assert(ios.width() == 0);
21429 }
21430 }
21431 }
21432 }
21433 }
21434 }
21435 ios.precision(1);
21436 {
21437 nouppercase(ios);
21438 {
21439 noshowpos(ios);
21440 {
21441 noshowpoint(ios);
21442 {
21443 ios.imbue(lc);
21444 {
21445 ios.width(0);
21446 {
21447 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21448 std::string ex(str, iter.base());
21449 assert(ex == "1.2e+09");
21450 assert(ios.width() == 0);
21451 }
21452 ios.width(25);
21453 left(ios);
21454 {
21455 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21456 std::string ex(str, iter.base());
21457 assert(ex == "1.2e+09******************");
21458 assert(ios.width() == 0);
21459 }
21460 ios.width(25);
21461 right(ios);
21462 {
21463 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21464 std::string ex(str, iter.base());
21465 assert(ex == "******************1.2e+09");
21466 assert(ios.width() == 0);
21467 }
21468 ios.width(25);
21469 internal(ios);
21470 {
21471 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21472 std::string ex(str, iter.base());
21473 assert(ex == "******************1.2e+09");
21474 assert(ios.width() == 0);
21475 }
21476 }
21477 ios.imbue(lg);
21478 {
21479 ios.width(0);
21480 {
21481 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21482 std::string ex(str, iter.base());
21483 assert(ex == "1;2e+09");
21484 assert(ios.width() == 0);
21485 }
21486 ios.width(25);
21487 left(ios);
21488 {
21489 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21490 std::string ex(str, iter.base());
21491 assert(ex == "1;2e+09******************");
21492 assert(ios.width() == 0);
21493 }
21494 ios.width(25);
21495 right(ios);
21496 {
21497 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21498 std::string ex(str, iter.base());
21499 assert(ex == "******************1;2e+09");
21500 assert(ios.width() == 0);
21501 }
21502 ios.width(25);
21503 internal(ios);
21504 {
21505 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21506 std::string ex(str, iter.base());
21507 assert(ex == "******************1;2e+09");
21508 assert(ios.width() == 0);
21509 }
21510 }
21511 }
21512 showpoint(ios);
21513 {
21514 ios.imbue(lc);
21515 {
21516 ios.width(0);
21517 {
21518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21519 std::string ex(str, iter.base());
21520 assert(ex == "1.2e+09");
21521 assert(ios.width() == 0);
21522 }
21523 ios.width(25);
21524 left(ios);
21525 {
21526 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21527 std::string ex(str, iter.base());
21528 assert(ex == "1.2e+09******************");
21529 assert(ios.width() == 0);
21530 }
21531 ios.width(25);
21532 right(ios);
21533 {
21534 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21535 std::string ex(str, iter.base());
21536 assert(ex == "******************1.2e+09");
21537 assert(ios.width() == 0);
21538 }
21539 ios.width(25);
21540 internal(ios);
21541 {
21542 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21543 std::string ex(str, iter.base());
21544 assert(ex == "******************1.2e+09");
21545 assert(ios.width() == 0);
21546 }
21547 }
21548 ios.imbue(lg);
21549 {
21550 ios.width(0);
21551 {
21552 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21553 std::string ex(str, iter.base());
21554 assert(ex == "1;2e+09");
21555 assert(ios.width() == 0);
21556 }
21557 ios.width(25);
21558 left(ios);
21559 {
21560 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21561 std::string ex(str, iter.base());
21562 assert(ex == "1;2e+09******************");
21563 assert(ios.width() == 0);
21564 }
21565 ios.width(25);
21566 right(ios);
21567 {
21568 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21569 std::string ex(str, iter.base());
21570 assert(ex == "******************1;2e+09");
21571 assert(ios.width() == 0);
21572 }
21573 ios.width(25);
21574 internal(ios);
21575 {
21576 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21577 std::string ex(str, iter.base());
21578 assert(ex == "******************1;2e+09");
21579 assert(ios.width() == 0);
21580 }
21581 }
21582 }
21583 }
21584 showpos(ios);
21585 {
21586 noshowpoint(ios);
21587 {
21588 ios.imbue(lc);
21589 {
21590 ios.width(0);
21591 {
21592 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21593 std::string ex(str, iter.base());
21594 assert(ex == "+1.2e+09");
21595 assert(ios.width() == 0);
21596 }
21597 ios.width(25);
21598 left(ios);
21599 {
21600 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21601 std::string ex(str, iter.base());
21602 assert(ex == "+1.2e+09*****************");
21603 assert(ios.width() == 0);
21604 }
21605 ios.width(25);
21606 right(ios);
21607 {
21608 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21609 std::string ex(str, iter.base());
21610 assert(ex == "*****************+1.2e+09");
21611 assert(ios.width() == 0);
21612 }
21613 ios.width(25);
21614 internal(ios);
21615 {
21616 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21617 std::string ex(str, iter.base());
21618 assert(ex == "+*****************1.2e+09");
21619 assert(ios.width() == 0);
21620 }
21621 }
21622 ios.imbue(lg);
21623 {
21624 ios.width(0);
21625 {
21626 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21627 std::string ex(str, iter.base());
21628 assert(ex == "+1;2e+09");
21629 assert(ios.width() == 0);
21630 }
21631 ios.width(25);
21632 left(ios);
21633 {
21634 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21635 std::string ex(str, iter.base());
21636 assert(ex == "+1;2e+09*****************");
21637 assert(ios.width() == 0);
21638 }
21639 ios.width(25);
21640 right(ios);
21641 {
21642 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21643 std::string ex(str, iter.base());
21644 assert(ex == "*****************+1;2e+09");
21645 assert(ios.width() == 0);
21646 }
21647 ios.width(25);
21648 internal(ios);
21649 {
21650 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21651 std::string ex(str, iter.base());
21652 assert(ex == "+*****************1;2e+09");
21653 assert(ios.width() == 0);
21654 }
21655 }
21656 }
21657 showpoint(ios);
21658 {
21659 ios.imbue(lc);
21660 {
21661 ios.width(0);
21662 {
21663 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21664 std::string ex(str, iter.base());
21665 assert(ex == "+1.2e+09");
21666 assert(ios.width() == 0);
21667 }
21668 ios.width(25);
21669 left(ios);
21670 {
21671 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21672 std::string ex(str, iter.base());
21673 assert(ex == "+1.2e+09*****************");
21674 assert(ios.width() == 0);
21675 }
21676 ios.width(25);
21677 right(ios);
21678 {
21679 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21680 std::string ex(str, iter.base());
21681 assert(ex == "*****************+1.2e+09");
21682 assert(ios.width() == 0);
21683 }
21684 ios.width(25);
21685 internal(ios);
21686 {
21687 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21688 std::string ex(str, iter.base());
21689 assert(ex == "+*****************1.2e+09");
21690 assert(ios.width() == 0);
21691 }
21692 }
21693 ios.imbue(lg);
21694 {
21695 ios.width(0);
21696 {
21697 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21698 std::string ex(str, iter.base());
21699 assert(ex == "+1;2e+09");
21700 assert(ios.width() == 0);
21701 }
21702 ios.width(25);
21703 left(ios);
21704 {
21705 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21706 std::string ex(str, iter.base());
21707 assert(ex == "+1;2e+09*****************");
21708 assert(ios.width() == 0);
21709 }
21710 ios.width(25);
21711 right(ios);
21712 {
21713 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21714 std::string ex(str, iter.base());
21715 assert(ex == "*****************+1;2e+09");
21716 assert(ios.width() == 0);
21717 }
21718 ios.width(25);
21719 internal(ios);
21720 {
21721 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21722 std::string ex(str, iter.base());
21723 assert(ex == "+*****************1;2e+09");
21724 assert(ios.width() == 0);
21725 }
21726 }
21727 }
21728 }
21729 }
21730 uppercase(ios);
21731 {
21732 noshowpos(ios);
21733 {
21734 noshowpoint(ios);
21735 {
21736 ios.imbue(lc);
21737 {
21738 ios.width(0);
21739 {
21740 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21741 std::string ex(str, iter.base());
21742 assert(ex == "1.2E+09");
21743 assert(ios.width() == 0);
21744 }
21745 ios.width(25);
21746 left(ios);
21747 {
21748 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21749 std::string ex(str, iter.base());
21750 assert(ex == "1.2E+09******************");
21751 assert(ios.width() == 0);
21752 }
21753 ios.width(25);
21754 right(ios);
21755 {
21756 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21757 std::string ex(str, iter.base());
21758 assert(ex == "******************1.2E+09");
21759 assert(ios.width() == 0);
21760 }
21761 ios.width(25);
21762 internal(ios);
21763 {
21764 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21765 std::string ex(str, iter.base());
21766 assert(ex == "******************1.2E+09");
21767 assert(ios.width() == 0);
21768 }
21769 }
21770 ios.imbue(lg);
21771 {
21772 ios.width(0);
21773 {
21774 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21775 std::string ex(str, iter.base());
21776 assert(ex == "1;2E+09");
21777 assert(ios.width() == 0);
21778 }
21779 ios.width(25);
21780 left(ios);
21781 {
21782 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21783 std::string ex(str, iter.base());
21784 assert(ex == "1;2E+09******************");
21785 assert(ios.width() == 0);
21786 }
21787 ios.width(25);
21788 right(ios);
21789 {
21790 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21791 std::string ex(str, iter.base());
21792 assert(ex == "******************1;2E+09");
21793 assert(ios.width() == 0);
21794 }
21795 ios.width(25);
21796 internal(ios);
21797 {
21798 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21799 std::string ex(str, iter.base());
21800 assert(ex == "******************1;2E+09");
21801 assert(ios.width() == 0);
21802 }
21803 }
21804 }
21805 showpoint(ios);
21806 {
21807 ios.imbue(lc);
21808 {
21809 ios.width(0);
21810 {
21811 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21812 std::string ex(str, iter.base());
21813 assert(ex == "1.2E+09");
21814 assert(ios.width() == 0);
21815 }
21816 ios.width(25);
21817 left(ios);
21818 {
21819 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21820 std::string ex(str, iter.base());
21821 assert(ex == "1.2E+09******************");
21822 assert(ios.width() == 0);
21823 }
21824 ios.width(25);
21825 right(ios);
21826 {
21827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21828 std::string ex(str, iter.base());
21829 assert(ex == "******************1.2E+09");
21830 assert(ios.width() == 0);
21831 }
21832 ios.width(25);
21833 internal(ios);
21834 {
21835 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21836 std::string ex(str, iter.base());
21837 assert(ex == "******************1.2E+09");
21838 assert(ios.width() == 0);
21839 }
21840 }
21841 ios.imbue(lg);
21842 {
21843 ios.width(0);
21844 {
21845 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21846 std::string ex(str, iter.base());
21847 assert(ex == "1;2E+09");
21848 assert(ios.width() == 0);
21849 }
21850 ios.width(25);
21851 left(ios);
21852 {
21853 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21854 std::string ex(str, iter.base());
21855 assert(ex == "1;2E+09******************");
21856 assert(ios.width() == 0);
21857 }
21858 ios.width(25);
21859 right(ios);
21860 {
21861 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21862 std::string ex(str, iter.base());
21863 assert(ex == "******************1;2E+09");
21864 assert(ios.width() == 0);
21865 }
21866 ios.width(25);
21867 internal(ios);
21868 {
21869 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21870 std::string ex(str, iter.base());
21871 assert(ex == "******************1;2E+09");
21872 assert(ios.width() == 0);
21873 }
21874 }
21875 }
21876 }
21877 showpos(ios);
21878 {
21879 noshowpoint(ios);
21880 {
21881 ios.imbue(lc);
21882 {
21883 ios.width(0);
21884 {
21885 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21886 std::string ex(str, iter.base());
21887 assert(ex == "+1.2E+09");
21888 assert(ios.width() == 0);
21889 }
21890 ios.width(25);
21891 left(ios);
21892 {
21893 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21894 std::string ex(str, iter.base());
21895 assert(ex == "+1.2E+09*****************");
21896 assert(ios.width() == 0);
21897 }
21898 ios.width(25);
21899 right(ios);
21900 {
21901 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21902 std::string ex(str, iter.base());
21903 assert(ex == "*****************+1.2E+09");
21904 assert(ios.width() == 0);
21905 }
21906 ios.width(25);
21907 internal(ios);
21908 {
21909 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21910 std::string ex(str, iter.base());
21911 assert(ex == "+*****************1.2E+09");
21912 assert(ios.width() == 0);
21913 }
21914 }
21915 ios.imbue(lg);
21916 {
21917 ios.width(0);
21918 {
21919 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21920 std::string ex(str, iter.base());
21921 assert(ex == "+1;2E+09");
21922 assert(ios.width() == 0);
21923 }
21924 ios.width(25);
21925 left(ios);
21926 {
21927 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21928 std::string ex(str, iter.base());
21929 assert(ex == "+1;2E+09*****************");
21930 assert(ios.width() == 0);
21931 }
21932 ios.width(25);
21933 right(ios);
21934 {
21935 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21936 std::string ex(str, iter.base());
21937 assert(ex == "*****************+1;2E+09");
21938 assert(ios.width() == 0);
21939 }
21940 ios.width(25);
21941 internal(ios);
21942 {
21943 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21944 std::string ex(str, iter.base());
21945 assert(ex == "+*****************1;2E+09");
21946 assert(ios.width() == 0);
21947 }
21948 }
21949 }
21950 showpoint(ios);
21951 {
21952 ios.imbue(lc);
21953 {
21954 ios.width(0);
21955 {
21956 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21957 std::string ex(str, iter.base());
21958 assert(ex == "+1.2E+09");
21959 assert(ios.width() == 0);
21960 }
21961 ios.width(25);
21962 left(ios);
21963 {
21964 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21965 std::string ex(str, iter.base());
21966 assert(ex == "+1.2E+09*****************");
21967 assert(ios.width() == 0);
21968 }
21969 ios.width(25);
21970 right(ios);
21971 {
21972 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21973 std::string ex(str, iter.base());
21974 assert(ex == "*****************+1.2E+09");
21975 assert(ios.width() == 0);
21976 }
21977 ios.width(25);
21978 internal(ios);
21979 {
21980 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21981 std::string ex(str, iter.base());
21982 assert(ex == "+*****************1.2E+09");
21983 assert(ios.width() == 0);
21984 }
21985 }
21986 ios.imbue(lg);
21987 {
21988 ios.width(0);
21989 {
21990 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21991 std::string ex(str, iter.base());
21992 assert(ex == "+1;2E+09");
21993 assert(ios.width() == 0);
21994 }
21995 ios.width(25);
21996 left(ios);
21997 {
21998 iter = f.put(output_iterator<char*>(str), ios, '*', v);
21999 std::string ex(str, iter.base());
22000 assert(ex == "+1;2E+09*****************");
22001 assert(ios.width() == 0);
22002 }
22003 ios.width(25);
22004 right(ios);
22005 {
22006 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22007 std::string ex(str, iter.base());
22008 assert(ex == "*****************+1;2E+09");
22009 assert(ios.width() == 0);
22010 }
22011 ios.width(25);
22012 internal(ios);
22013 {
22014 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22015 std::string ex(str, iter.base());
22016 assert(ex == "+*****************1;2E+09");
22017 assert(ios.width() == 0);
22018 }
22019 }
22020 }
22021 }
22022 }
22023 }
22024 ios.precision(6);
22025 {
22026 }
22027 ios.precision(16);
22028 {
22029 }
22030 ios.precision(60);
22031 {
22032 nouppercase(ios);
22033 {
22034 noshowpos(ios);
22035 {
22036 noshowpoint(ios);
22037 {
22038 ios.imbue(lc);
22039 {
22040 ios.width(0);
22041 {
22042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22043 std::string ex(str, iter.base());
22044 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22045 assert(ios.width() == 0);
22046 }
22047 ios.width(25);
22048 left(ios);
22049 {
22050 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22051 std::string ex(str, iter.base());
22052 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22053 assert(ios.width() == 0);
22054 }
22055 ios.width(25);
22056 right(ios);
22057 {
22058 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22059 std::string ex(str, iter.base());
22060 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22061 assert(ios.width() == 0);
22062 }
22063 ios.width(25);
22064 internal(ios);
22065 {
22066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22067 std::string ex(str, iter.base());
22068 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22069 assert(ios.width() == 0);
22070 }
22071 }
22072 ios.imbue(lg);
22073 {
22074 ios.width(0);
22075 {
22076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22077 std::string ex(str, iter.base());
22078 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22079 assert(ios.width() == 0);
22080 }
22081 ios.width(25);
22082 left(ios);
22083 {
22084 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22085 std::string ex(str, iter.base());
22086 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22087 assert(ios.width() == 0);
22088 }
22089 ios.width(25);
22090 right(ios);
22091 {
22092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22093 std::string ex(str, iter.base());
22094 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22095 assert(ios.width() == 0);
22096 }
22097 ios.width(25);
22098 internal(ios);
22099 {
22100 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22101 std::string ex(str, iter.base());
22102 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22103 assert(ios.width() == 0);
22104 }
22105 }
22106 }
22107 showpoint(ios);
22108 {
22109 ios.imbue(lc);
22110 {
22111 ios.width(0);
22112 {
22113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22114 std::string ex(str, iter.base());
22115 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22116 assert(ios.width() == 0);
22117 }
22118 ios.width(25);
22119 left(ios);
22120 {
22121 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22122 std::string ex(str, iter.base());
22123 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22124 assert(ios.width() == 0);
22125 }
22126 ios.width(25);
22127 right(ios);
22128 {
22129 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22130 std::string ex(str, iter.base());
22131 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22132 assert(ios.width() == 0);
22133 }
22134 ios.width(25);
22135 internal(ios);
22136 {
22137 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22138 std::string ex(str, iter.base());
22139 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22140 assert(ios.width() == 0);
22141 }
22142 }
22143 ios.imbue(lg);
22144 {
22145 ios.width(0);
22146 {
22147 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22148 std::string ex(str, iter.base());
22149 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22150 assert(ios.width() == 0);
22151 }
22152 ios.width(25);
22153 left(ios);
22154 {
22155 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22156 std::string ex(str, iter.base());
22157 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22158 assert(ios.width() == 0);
22159 }
22160 ios.width(25);
22161 right(ios);
22162 {
22163 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22164 std::string ex(str, iter.base());
22165 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22166 assert(ios.width() == 0);
22167 }
22168 ios.width(25);
22169 internal(ios);
22170 {
22171 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22172 std::string ex(str, iter.base());
22173 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22174 assert(ios.width() == 0);
22175 }
22176 }
22177 }
22178 }
22179 showpos(ios);
22180 {
22181 noshowpoint(ios);
22182 {
22183 ios.imbue(lc);
22184 {
22185 ios.width(0);
22186 {
22187 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22188 std::string ex(str, iter.base());
22189 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22190 assert(ios.width() == 0);
22191 }
22192 ios.width(25);
22193 left(ios);
22194 {
22195 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22196 std::string ex(str, iter.base());
22197 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22198 assert(ios.width() == 0);
22199 }
22200 ios.width(25);
22201 right(ios);
22202 {
22203 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22204 std::string ex(str, iter.base());
22205 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22206 assert(ios.width() == 0);
22207 }
22208 ios.width(25);
22209 internal(ios);
22210 {
22211 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22212 std::string ex(str, iter.base());
22213 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22214 assert(ios.width() == 0);
22215 }
22216 }
22217 ios.imbue(lg);
22218 {
22219 ios.width(0);
22220 {
22221 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22222 std::string ex(str, iter.base());
22223 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22224 assert(ios.width() == 0);
22225 }
22226 ios.width(25);
22227 left(ios);
22228 {
22229 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22230 std::string ex(str, iter.base());
22231 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22232 assert(ios.width() == 0);
22233 }
22234 ios.width(25);
22235 right(ios);
22236 {
22237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22238 std::string ex(str, iter.base());
22239 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22240 assert(ios.width() == 0);
22241 }
22242 ios.width(25);
22243 internal(ios);
22244 {
22245 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22246 std::string ex(str, iter.base());
22247 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22248 assert(ios.width() == 0);
22249 }
22250 }
22251 }
22252 showpoint(ios);
22253 {
22254 ios.imbue(lc);
22255 {
22256 ios.width(0);
22257 {
22258 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22259 std::string ex(str, iter.base());
22260 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22261 assert(ios.width() == 0);
22262 }
22263 ios.width(25);
22264 left(ios);
22265 {
22266 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22267 std::string ex(str, iter.base());
22268 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22269 assert(ios.width() == 0);
22270 }
22271 ios.width(25);
22272 right(ios);
22273 {
22274 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22275 std::string ex(str, iter.base());
22276 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22277 assert(ios.width() == 0);
22278 }
22279 ios.width(25);
22280 internal(ios);
22281 {
22282 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22283 std::string ex(str, iter.base());
22284 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22285 assert(ios.width() == 0);
22286 }
22287 }
22288 ios.imbue(lg);
22289 {
22290 ios.width(0);
22291 {
22292 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22293 std::string ex(str, iter.base());
22294 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22295 assert(ios.width() == 0);
22296 }
22297 ios.width(25);
22298 left(ios);
22299 {
22300 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22301 std::string ex(str, iter.base());
22302 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22303 assert(ios.width() == 0);
22304 }
22305 ios.width(25);
22306 right(ios);
22307 {
22308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22309 std::string ex(str, iter.base());
22310 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22311 assert(ios.width() == 0);
22312 }
22313 ios.width(25);
22314 internal(ios);
22315 {
22316 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22317 std::string ex(str, iter.base());
22318 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22319 assert(ios.width() == 0);
22320 }
22321 }
22322 }
22323 }
22324 }
22325 uppercase(ios);
22326 {
22327 noshowpos(ios);
22328 {
22329 noshowpoint(ios);
22330 {
22331 ios.imbue(lc);
22332 {
22333 ios.width(0);
22334 {
22335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22336 std::string ex(str, iter.base());
22337 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22338 assert(ios.width() == 0);
22339 }
22340 ios.width(25);
22341 left(ios);
22342 {
22343 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22344 std::string ex(str, iter.base());
22345 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22346 assert(ios.width() == 0);
22347 }
22348 ios.width(25);
22349 right(ios);
22350 {
22351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22352 std::string ex(str, iter.base());
22353 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22354 assert(ios.width() == 0);
22355 }
22356 ios.width(25);
22357 internal(ios);
22358 {
22359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22360 std::string ex(str, iter.base());
22361 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22362 assert(ios.width() == 0);
22363 }
22364 }
22365 ios.imbue(lg);
22366 {
22367 ios.width(0);
22368 {
22369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22370 std::string ex(str, iter.base());
22371 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22372 assert(ios.width() == 0);
22373 }
22374 ios.width(25);
22375 left(ios);
22376 {
22377 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22378 std::string ex(str, iter.base());
22379 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22380 assert(ios.width() == 0);
22381 }
22382 ios.width(25);
22383 right(ios);
22384 {
22385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22386 std::string ex(str, iter.base());
22387 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22388 assert(ios.width() == 0);
22389 }
22390 ios.width(25);
22391 internal(ios);
22392 {
22393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22394 std::string ex(str, iter.base());
22395 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22396 assert(ios.width() == 0);
22397 }
22398 }
22399 }
22400 showpoint(ios);
22401 {
22402 ios.imbue(lc);
22403 {
22404 ios.width(0);
22405 {
22406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22407 std::string ex(str, iter.base());
22408 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22409 assert(ios.width() == 0);
22410 }
22411 ios.width(25);
22412 left(ios);
22413 {
22414 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22415 std::string ex(str, iter.base());
22416 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22417 assert(ios.width() == 0);
22418 }
22419 ios.width(25);
22420 right(ios);
22421 {
22422 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22423 std::string ex(str, iter.base());
22424 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22425 assert(ios.width() == 0);
22426 }
22427 ios.width(25);
22428 internal(ios);
22429 {
22430 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22431 std::string ex(str, iter.base());
22432 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22433 assert(ios.width() == 0);
22434 }
22435 }
22436 ios.imbue(lg);
22437 {
22438 ios.width(0);
22439 {
22440 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22441 std::string ex(str, iter.base());
22442 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22443 assert(ios.width() == 0);
22444 }
22445 ios.width(25);
22446 left(ios);
22447 {
22448 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22449 std::string ex(str, iter.base());
22450 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22451 assert(ios.width() == 0);
22452 }
22453 ios.width(25);
22454 right(ios);
22455 {
22456 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22457 std::string ex(str, iter.base());
22458 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22459 assert(ios.width() == 0);
22460 }
22461 ios.width(25);
22462 internal(ios);
22463 {
22464 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22465 std::string ex(str, iter.base());
22466 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22467 assert(ios.width() == 0);
22468 }
22469 }
22470 }
22471 }
22472 showpos(ios);
22473 {
22474 noshowpoint(ios);
22475 {
22476 ios.imbue(lc);
22477 {
22478 ios.width(0);
22479 {
22480 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22481 std::string ex(str, iter.base());
22482 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22483 assert(ios.width() == 0);
22484 }
22485 ios.width(25);
22486 left(ios);
22487 {
22488 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22489 std::string ex(str, iter.base());
22490 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22491 assert(ios.width() == 0);
22492 }
22493 ios.width(25);
22494 right(ios);
22495 {
22496 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22497 std::string ex(str, iter.base());
22498 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22499 assert(ios.width() == 0);
22500 }
22501 ios.width(25);
22502 internal(ios);
22503 {
22504 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22505 std::string ex(str, iter.base());
22506 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22507 assert(ios.width() == 0);
22508 }
22509 }
22510 ios.imbue(lg);
22511 {
22512 ios.width(0);
22513 {
22514 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22515 std::string ex(str, iter.base());
22516 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22517 assert(ios.width() == 0);
22518 }
22519 ios.width(25);
22520 left(ios);
22521 {
22522 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22523 std::string ex(str, iter.base());
22524 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22525 assert(ios.width() == 0);
22526 }
22527 ios.width(25);
22528 right(ios);
22529 {
22530 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22531 std::string ex(str, iter.base());
22532 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22533 assert(ios.width() == 0);
22534 }
22535 ios.width(25);
22536 internal(ios);
22537 {
22538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22539 std::string ex(str, iter.base());
22540 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22541 assert(ios.width() == 0);
22542 }
22543 }
22544 }
22545 showpoint(ios);
22546 {
22547 ios.imbue(lc);
22548 {
22549 ios.width(0);
22550 {
22551 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22552 std::string ex(str, iter.base());
22553 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22554 assert(ios.width() == 0);
22555 }
22556 ios.width(25);
22557 left(ios);
22558 {
22559 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22560 std::string ex(str, iter.base());
22561 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22562 assert(ios.width() == 0);
22563 }
22564 ios.width(25);
22565 right(ios);
22566 {
22567 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22568 std::string ex(str, iter.base());
22569 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22570 assert(ios.width() == 0);
22571 }
22572 ios.width(25);
22573 internal(ios);
22574 {
22575 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22576 std::string ex(str, iter.base());
22577 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22578 assert(ios.width() == 0);
22579 }
22580 }
22581 ios.imbue(lg);
22582 {
22583 ios.width(0);
22584 {
22585 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22586 std::string ex(str, iter.base());
22587 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22588 assert(ios.width() == 0);
22589 }
22590 ios.width(25);
22591 left(ios);
22592 {
22593 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22594 std::string ex(str, iter.base());
22595 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22596 assert(ios.width() == 0);
22597 }
22598 ios.width(25);
22599 right(ios);
22600 {
22601 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22602 std::string ex(str, iter.base());
22603 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22604 assert(ios.width() == 0);
22605 }
22606 ios.width(25);
22607 internal(ios);
22608 {
22609 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22610 std::string ex(str, iter.base());
22611 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22612 assert(ios.width() == 0);
22613 }
22614 }
22615 }
22616 }
22617 }
22618 }
22619 }
22620 }
22621 }
22622
test11()22623 void test11()
22624 {
22625 char str[200];
22626 output_iterator<char*> iter;
22627 std::locale lc = std::locale::classic();
22628 std::locale lg(lc, new my_numpunct);
22629 const my_facet f(1);
22630 {
22631 long double v = -0.;
22632 std::ios ios(0);
22633 hexfloat(ios);
22634 // %a
22635 {
22636 ios.precision(0);
22637 {
22638 nouppercase(ios);
22639 {
22640 noshowpos(ios);
22641 {
22642 noshowpoint(ios);
22643 {
22644 ios.imbue(lc);
22645 {
22646 ios.width(0);
22647 {
22648 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22649 std::string ex(str, iter.base());
22650 assert(ex == "-0x0p+0");
22651 assert(ios.width() == 0);
22652 }
22653 ios.width(25);
22654 left(ios);
22655 {
22656 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22657 std::string ex(str, iter.base());
22658 assert(ex == "-0x0p+0******************");
22659 assert(ios.width() == 0);
22660 }
22661 ios.width(25);
22662 right(ios);
22663 {
22664 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22665 std::string ex(str, iter.base());
22666 assert(ex == "******************-0x0p+0");
22667 assert(ios.width() == 0);
22668 }
22669 ios.width(25);
22670 internal(ios);
22671 {
22672 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22673 std::string ex(str, iter.base());
22674 assert(ex == "-******************0x0p+0");
22675 assert(ios.width() == 0);
22676 }
22677 }
22678 ios.imbue(lg);
22679 {
22680 ios.width(0);
22681 {
22682 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22683 std::string ex(str, iter.base());
22684 assert(ex == "-0x0p+0");
22685 assert(ios.width() == 0);
22686 }
22687 ios.width(25);
22688 left(ios);
22689 {
22690 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22691 std::string ex(str, iter.base());
22692 assert(ex == "-0x0p+0******************");
22693 assert(ios.width() == 0);
22694 }
22695 ios.width(25);
22696 right(ios);
22697 {
22698 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22699 std::string ex(str, iter.base());
22700 assert(ex == "******************-0x0p+0");
22701 assert(ios.width() == 0);
22702 }
22703 ios.width(25);
22704 internal(ios);
22705 {
22706 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22707 std::string ex(str, iter.base());
22708 assert(ex == "-******************0x0p+0");
22709 assert(ios.width() == 0);
22710 }
22711 }
22712 }
22713 showpoint(ios);
22714 {
22715 ios.imbue(lc);
22716 {
22717 ios.width(0);
22718 {
22719 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22720 std::string ex(str, iter.base());
22721 assert(ex == "-0x0.p+0");
22722 assert(ios.width() == 0);
22723 }
22724 ios.width(25);
22725 left(ios);
22726 {
22727 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22728 std::string ex(str, iter.base());
22729 assert(ex == "-0x0.p+0*****************");
22730 assert(ios.width() == 0);
22731 }
22732 ios.width(25);
22733 right(ios);
22734 {
22735 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22736 std::string ex(str, iter.base());
22737 assert(ex == "*****************-0x0.p+0");
22738 assert(ios.width() == 0);
22739 }
22740 ios.width(25);
22741 internal(ios);
22742 {
22743 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22744 std::string ex(str, iter.base());
22745 assert(ex == "-*****************0x0.p+0");
22746 assert(ios.width() == 0);
22747 }
22748 }
22749 ios.imbue(lg);
22750 {
22751 ios.width(0);
22752 {
22753 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22754 std::string ex(str, iter.base());
22755 assert(ex == "-0x0;p+0");
22756 assert(ios.width() == 0);
22757 }
22758 ios.width(25);
22759 left(ios);
22760 {
22761 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22762 std::string ex(str, iter.base());
22763 assert(ex == "-0x0;p+0*****************");
22764 assert(ios.width() == 0);
22765 }
22766 ios.width(25);
22767 right(ios);
22768 {
22769 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22770 std::string ex(str, iter.base());
22771 assert(ex == "*****************-0x0;p+0");
22772 assert(ios.width() == 0);
22773 }
22774 ios.width(25);
22775 internal(ios);
22776 {
22777 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22778 std::string ex(str, iter.base());
22779 assert(ex == "-*****************0x0;p+0");
22780 assert(ios.width() == 0);
22781 }
22782 }
22783 }
22784 }
22785 showpos(ios);
22786 {
22787 noshowpoint(ios);
22788 {
22789 ios.imbue(lc);
22790 {
22791 ios.width(0);
22792 {
22793 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22794 std::string ex(str, iter.base());
22795 assert(ex == "-0x0p+0");
22796 assert(ios.width() == 0);
22797 }
22798 ios.width(25);
22799 left(ios);
22800 {
22801 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22802 std::string ex(str, iter.base());
22803 assert(ex == "-0x0p+0******************");
22804 assert(ios.width() == 0);
22805 }
22806 ios.width(25);
22807 right(ios);
22808 {
22809 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22810 std::string ex(str, iter.base());
22811 assert(ex == "******************-0x0p+0");
22812 assert(ios.width() == 0);
22813 }
22814 ios.width(25);
22815 internal(ios);
22816 {
22817 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22818 std::string ex(str, iter.base());
22819 assert(ex == "-******************0x0p+0");
22820 assert(ios.width() == 0);
22821 }
22822 }
22823 ios.imbue(lg);
22824 {
22825 ios.width(0);
22826 {
22827 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22828 std::string ex(str, iter.base());
22829 assert(ex == "-0x0p+0");
22830 assert(ios.width() == 0);
22831 }
22832 ios.width(25);
22833 left(ios);
22834 {
22835 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22836 std::string ex(str, iter.base());
22837 assert(ex == "-0x0p+0******************");
22838 assert(ios.width() == 0);
22839 }
22840 ios.width(25);
22841 right(ios);
22842 {
22843 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22844 std::string ex(str, iter.base());
22845 assert(ex == "******************-0x0p+0");
22846 assert(ios.width() == 0);
22847 }
22848 ios.width(25);
22849 internal(ios);
22850 {
22851 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22852 std::string ex(str, iter.base());
22853 assert(ex == "-******************0x0p+0");
22854 assert(ios.width() == 0);
22855 }
22856 }
22857 }
22858 showpoint(ios);
22859 {
22860 ios.imbue(lc);
22861 {
22862 ios.width(0);
22863 {
22864 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22865 std::string ex(str, iter.base());
22866 assert(ex == "-0x0.p+0");
22867 assert(ios.width() == 0);
22868 }
22869 ios.width(25);
22870 left(ios);
22871 {
22872 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22873 std::string ex(str, iter.base());
22874 assert(ex == "-0x0.p+0*****************");
22875 assert(ios.width() == 0);
22876 }
22877 ios.width(25);
22878 right(ios);
22879 {
22880 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22881 std::string ex(str, iter.base());
22882 assert(ex == "*****************-0x0.p+0");
22883 assert(ios.width() == 0);
22884 }
22885 ios.width(25);
22886 internal(ios);
22887 {
22888 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22889 std::string ex(str, iter.base());
22890 assert(ex == "-*****************0x0.p+0");
22891 assert(ios.width() == 0);
22892 }
22893 }
22894 ios.imbue(lg);
22895 {
22896 ios.width(0);
22897 {
22898 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22899 std::string ex(str, iter.base());
22900 assert(ex == "-0x0;p+0");
22901 assert(ios.width() == 0);
22902 }
22903 ios.width(25);
22904 left(ios);
22905 {
22906 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22907 std::string ex(str, iter.base());
22908 assert(ex == "-0x0;p+0*****************");
22909 assert(ios.width() == 0);
22910 }
22911 ios.width(25);
22912 right(ios);
22913 {
22914 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22915 std::string ex(str, iter.base());
22916 assert(ex == "*****************-0x0;p+0");
22917 assert(ios.width() == 0);
22918 }
22919 ios.width(25);
22920 internal(ios);
22921 {
22922 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22923 std::string ex(str, iter.base());
22924 assert(ex == "-*****************0x0;p+0");
22925 assert(ios.width() == 0);
22926 }
22927 }
22928 }
22929 }
22930 }
22931 uppercase(ios);
22932 {
22933 noshowpos(ios);
22934 {
22935 noshowpoint(ios);
22936 {
22937 ios.imbue(lc);
22938 {
22939 ios.width(0);
22940 {
22941 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22942 std::string ex(str, iter.base());
22943 assert(ex == "-0X0P+0");
22944 assert(ios.width() == 0);
22945 }
22946 ios.width(25);
22947 left(ios);
22948 {
22949 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22950 std::string ex(str, iter.base());
22951 assert(ex == "-0X0P+0******************");
22952 assert(ios.width() == 0);
22953 }
22954 ios.width(25);
22955 right(ios);
22956 {
22957 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22958 std::string ex(str, iter.base());
22959 assert(ex == "******************-0X0P+0");
22960 assert(ios.width() == 0);
22961 }
22962 ios.width(25);
22963 internal(ios);
22964 {
22965 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22966 std::string ex(str, iter.base());
22967 assert(ex == "-******************0X0P+0");
22968 assert(ios.width() == 0);
22969 }
22970 }
22971 ios.imbue(lg);
22972 {
22973 ios.width(0);
22974 {
22975 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22976 std::string ex(str, iter.base());
22977 assert(ex == "-0X0P+0");
22978 assert(ios.width() == 0);
22979 }
22980 ios.width(25);
22981 left(ios);
22982 {
22983 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22984 std::string ex(str, iter.base());
22985 assert(ex == "-0X0P+0******************");
22986 assert(ios.width() == 0);
22987 }
22988 ios.width(25);
22989 right(ios);
22990 {
22991 iter = f.put(output_iterator<char*>(str), ios, '*', v);
22992 std::string ex(str, iter.base());
22993 assert(ex == "******************-0X0P+0");
22994 assert(ios.width() == 0);
22995 }
22996 ios.width(25);
22997 internal(ios);
22998 {
22999 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23000 std::string ex(str, iter.base());
23001 assert(ex == "-******************0X0P+0");
23002 assert(ios.width() == 0);
23003 }
23004 }
23005 }
23006 showpoint(ios);
23007 {
23008 ios.imbue(lc);
23009 {
23010 ios.width(0);
23011 {
23012 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23013 std::string ex(str, iter.base());
23014 assert(ex == "-0X0.P+0");
23015 assert(ios.width() == 0);
23016 }
23017 ios.width(25);
23018 left(ios);
23019 {
23020 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23021 std::string ex(str, iter.base());
23022 assert(ex == "-0X0.P+0*****************");
23023 assert(ios.width() == 0);
23024 }
23025 ios.width(25);
23026 right(ios);
23027 {
23028 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23029 std::string ex(str, iter.base());
23030 assert(ex == "*****************-0X0.P+0");
23031 assert(ios.width() == 0);
23032 }
23033 ios.width(25);
23034 internal(ios);
23035 {
23036 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23037 std::string ex(str, iter.base());
23038 assert(ex == "-*****************0X0.P+0");
23039 assert(ios.width() == 0);
23040 }
23041 }
23042 ios.imbue(lg);
23043 {
23044 ios.width(0);
23045 {
23046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23047 std::string ex(str, iter.base());
23048 assert(ex == "-0X0;P+0");
23049 assert(ios.width() == 0);
23050 }
23051 ios.width(25);
23052 left(ios);
23053 {
23054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23055 std::string ex(str, iter.base());
23056 assert(ex == "-0X0;P+0*****************");
23057 assert(ios.width() == 0);
23058 }
23059 ios.width(25);
23060 right(ios);
23061 {
23062 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23063 std::string ex(str, iter.base());
23064 assert(ex == "*****************-0X0;P+0");
23065 assert(ios.width() == 0);
23066 }
23067 ios.width(25);
23068 internal(ios);
23069 {
23070 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23071 std::string ex(str, iter.base());
23072 assert(ex == "-*****************0X0;P+0");
23073 assert(ios.width() == 0);
23074 }
23075 }
23076 }
23077 }
23078 showpos(ios);
23079 {
23080 noshowpoint(ios);
23081 {
23082 ios.imbue(lc);
23083 {
23084 ios.width(0);
23085 {
23086 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23087 std::string ex(str, iter.base());
23088 assert(ex == "-0X0P+0");
23089 assert(ios.width() == 0);
23090 }
23091 ios.width(25);
23092 left(ios);
23093 {
23094 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23095 std::string ex(str, iter.base());
23096 assert(ex == "-0X0P+0******************");
23097 assert(ios.width() == 0);
23098 }
23099 ios.width(25);
23100 right(ios);
23101 {
23102 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23103 std::string ex(str, iter.base());
23104 assert(ex == "******************-0X0P+0");
23105 assert(ios.width() == 0);
23106 }
23107 ios.width(25);
23108 internal(ios);
23109 {
23110 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23111 std::string ex(str, iter.base());
23112 assert(ex == "-******************0X0P+0");
23113 assert(ios.width() == 0);
23114 }
23115 }
23116 ios.imbue(lg);
23117 {
23118 ios.width(0);
23119 {
23120 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23121 std::string ex(str, iter.base());
23122 assert(ex == "-0X0P+0");
23123 assert(ios.width() == 0);
23124 }
23125 ios.width(25);
23126 left(ios);
23127 {
23128 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23129 std::string ex(str, iter.base());
23130 assert(ex == "-0X0P+0******************");
23131 assert(ios.width() == 0);
23132 }
23133 ios.width(25);
23134 right(ios);
23135 {
23136 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23137 std::string ex(str, iter.base());
23138 assert(ex == "******************-0X0P+0");
23139 assert(ios.width() == 0);
23140 }
23141 ios.width(25);
23142 internal(ios);
23143 {
23144 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23145 std::string ex(str, iter.base());
23146 assert(ex == "-******************0X0P+0");
23147 assert(ios.width() == 0);
23148 }
23149 }
23150 }
23151 showpoint(ios);
23152 {
23153 ios.imbue(lc);
23154 {
23155 ios.width(0);
23156 {
23157 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23158 std::string ex(str, iter.base());
23159 assert(ex == "-0X0.P+0");
23160 assert(ios.width() == 0);
23161 }
23162 ios.width(25);
23163 left(ios);
23164 {
23165 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23166 std::string ex(str, iter.base());
23167 assert(ex == "-0X0.P+0*****************");
23168 assert(ios.width() == 0);
23169 }
23170 ios.width(25);
23171 right(ios);
23172 {
23173 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23174 std::string ex(str, iter.base());
23175 assert(ex == "*****************-0X0.P+0");
23176 assert(ios.width() == 0);
23177 }
23178 ios.width(25);
23179 internal(ios);
23180 {
23181 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23182 std::string ex(str, iter.base());
23183 assert(ex == "-*****************0X0.P+0");
23184 assert(ios.width() == 0);
23185 }
23186 }
23187 ios.imbue(lg);
23188 {
23189 ios.width(0);
23190 {
23191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23192 std::string ex(str, iter.base());
23193 assert(ex == "-0X0;P+0");
23194 assert(ios.width() == 0);
23195 }
23196 ios.width(25);
23197 left(ios);
23198 {
23199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23200 std::string ex(str, iter.base());
23201 assert(ex == "-0X0;P+0*****************");
23202 assert(ios.width() == 0);
23203 }
23204 ios.width(25);
23205 right(ios);
23206 {
23207 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23208 std::string ex(str, iter.base());
23209 assert(ex == "*****************-0X0;P+0");
23210 assert(ios.width() == 0);
23211 }
23212 ios.width(25);
23213 internal(ios);
23214 {
23215 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23216 std::string ex(str, iter.base());
23217 assert(ex == "-*****************0X0;P+0");
23218 assert(ios.width() == 0);
23219 }
23220 }
23221 }
23222 }
23223 }
23224 }
23225 ios.precision(1);
23226 {
23227 nouppercase(ios);
23228 {
23229 noshowpos(ios);
23230 {
23231 noshowpoint(ios);
23232 {
23233 ios.imbue(lc);
23234 {
23235 ios.width(0);
23236 {
23237 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23238 std::string ex(str, iter.base());
23239 assert(ex == "-0x0p+0");
23240 assert(ios.width() == 0);
23241 }
23242 ios.width(25);
23243 left(ios);
23244 {
23245 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23246 std::string ex(str, iter.base());
23247 assert(ex == "-0x0p+0******************");
23248 assert(ios.width() == 0);
23249 }
23250 ios.width(25);
23251 right(ios);
23252 {
23253 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23254 std::string ex(str, iter.base());
23255 assert(ex == "******************-0x0p+0");
23256 assert(ios.width() == 0);
23257 }
23258 ios.width(25);
23259 internal(ios);
23260 {
23261 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23262 std::string ex(str, iter.base());
23263 assert(ex == "-******************0x0p+0");
23264 assert(ios.width() == 0);
23265 }
23266 }
23267 ios.imbue(lg);
23268 {
23269 ios.width(0);
23270 {
23271 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23272 std::string ex(str, iter.base());
23273 assert(ex == "-0x0p+0");
23274 assert(ios.width() == 0);
23275 }
23276 ios.width(25);
23277 left(ios);
23278 {
23279 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23280 std::string ex(str, iter.base());
23281 assert(ex == "-0x0p+0******************");
23282 assert(ios.width() == 0);
23283 }
23284 ios.width(25);
23285 right(ios);
23286 {
23287 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23288 std::string ex(str, iter.base());
23289 assert(ex == "******************-0x0p+0");
23290 assert(ios.width() == 0);
23291 }
23292 ios.width(25);
23293 internal(ios);
23294 {
23295 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23296 std::string ex(str, iter.base());
23297 assert(ex == "-******************0x0p+0");
23298 assert(ios.width() == 0);
23299 }
23300 }
23301 }
23302 showpoint(ios);
23303 {
23304 ios.imbue(lc);
23305 {
23306 ios.width(0);
23307 {
23308 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23309 std::string ex(str, iter.base());
23310 assert(ex == "-0x0.p+0");
23311 assert(ios.width() == 0);
23312 }
23313 ios.width(25);
23314 left(ios);
23315 {
23316 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23317 std::string ex(str, iter.base());
23318 assert(ex == "-0x0.p+0*****************");
23319 assert(ios.width() == 0);
23320 }
23321 ios.width(25);
23322 right(ios);
23323 {
23324 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23325 std::string ex(str, iter.base());
23326 assert(ex == "*****************-0x0.p+0");
23327 assert(ios.width() == 0);
23328 }
23329 ios.width(25);
23330 internal(ios);
23331 {
23332 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23333 std::string ex(str, iter.base());
23334 assert(ex == "-*****************0x0.p+0");
23335 assert(ios.width() == 0);
23336 }
23337 }
23338 ios.imbue(lg);
23339 {
23340 ios.width(0);
23341 {
23342 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23343 std::string ex(str, iter.base());
23344 assert(ex == "-0x0;p+0");
23345 assert(ios.width() == 0);
23346 }
23347 ios.width(25);
23348 left(ios);
23349 {
23350 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23351 std::string ex(str, iter.base());
23352 assert(ex == "-0x0;p+0*****************");
23353 assert(ios.width() == 0);
23354 }
23355 ios.width(25);
23356 right(ios);
23357 {
23358 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23359 std::string ex(str, iter.base());
23360 assert(ex == "*****************-0x0;p+0");
23361 assert(ios.width() == 0);
23362 }
23363 ios.width(25);
23364 internal(ios);
23365 {
23366 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23367 std::string ex(str, iter.base());
23368 assert(ex == "-*****************0x0;p+0");
23369 assert(ios.width() == 0);
23370 }
23371 }
23372 }
23373 }
23374 showpos(ios);
23375 {
23376 noshowpoint(ios);
23377 {
23378 ios.imbue(lc);
23379 {
23380 ios.width(0);
23381 {
23382 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23383 std::string ex(str, iter.base());
23384 assert(ex == "-0x0p+0");
23385 assert(ios.width() == 0);
23386 }
23387 ios.width(25);
23388 left(ios);
23389 {
23390 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23391 std::string ex(str, iter.base());
23392 assert(ex == "-0x0p+0******************");
23393 assert(ios.width() == 0);
23394 }
23395 ios.width(25);
23396 right(ios);
23397 {
23398 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23399 std::string ex(str, iter.base());
23400 assert(ex == "******************-0x0p+0");
23401 assert(ios.width() == 0);
23402 }
23403 ios.width(25);
23404 internal(ios);
23405 {
23406 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23407 std::string ex(str, iter.base());
23408 assert(ex == "-******************0x0p+0");
23409 assert(ios.width() == 0);
23410 }
23411 }
23412 ios.imbue(lg);
23413 {
23414 ios.width(0);
23415 {
23416 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23417 std::string ex(str, iter.base());
23418 assert(ex == "-0x0p+0");
23419 assert(ios.width() == 0);
23420 }
23421 ios.width(25);
23422 left(ios);
23423 {
23424 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23425 std::string ex(str, iter.base());
23426 assert(ex == "-0x0p+0******************");
23427 assert(ios.width() == 0);
23428 }
23429 ios.width(25);
23430 right(ios);
23431 {
23432 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23433 std::string ex(str, iter.base());
23434 assert(ex == "******************-0x0p+0");
23435 assert(ios.width() == 0);
23436 }
23437 ios.width(25);
23438 internal(ios);
23439 {
23440 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23441 std::string ex(str, iter.base());
23442 assert(ex == "-******************0x0p+0");
23443 assert(ios.width() == 0);
23444 }
23445 }
23446 }
23447 showpoint(ios);
23448 {
23449 ios.imbue(lc);
23450 {
23451 ios.width(0);
23452 {
23453 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23454 std::string ex(str, iter.base());
23455 assert(ex == "-0x0.p+0");
23456 assert(ios.width() == 0);
23457 }
23458 ios.width(25);
23459 left(ios);
23460 {
23461 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23462 std::string ex(str, iter.base());
23463 assert(ex == "-0x0.p+0*****************");
23464 assert(ios.width() == 0);
23465 }
23466 ios.width(25);
23467 right(ios);
23468 {
23469 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23470 std::string ex(str, iter.base());
23471 assert(ex == "*****************-0x0.p+0");
23472 assert(ios.width() == 0);
23473 }
23474 ios.width(25);
23475 internal(ios);
23476 {
23477 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23478 std::string ex(str, iter.base());
23479 assert(ex == "-*****************0x0.p+0");
23480 assert(ios.width() == 0);
23481 }
23482 }
23483 ios.imbue(lg);
23484 {
23485 ios.width(0);
23486 {
23487 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23488 std::string ex(str, iter.base());
23489 assert(ex == "-0x0;p+0");
23490 assert(ios.width() == 0);
23491 }
23492 ios.width(25);
23493 left(ios);
23494 {
23495 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23496 std::string ex(str, iter.base());
23497 assert(ex == "-0x0;p+0*****************");
23498 assert(ios.width() == 0);
23499 }
23500 ios.width(25);
23501 right(ios);
23502 {
23503 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23504 std::string ex(str, iter.base());
23505 assert(ex == "*****************-0x0;p+0");
23506 assert(ios.width() == 0);
23507 }
23508 ios.width(25);
23509 internal(ios);
23510 {
23511 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23512 std::string ex(str, iter.base());
23513 assert(ex == "-*****************0x0;p+0");
23514 assert(ios.width() == 0);
23515 }
23516 }
23517 }
23518 }
23519 }
23520 uppercase(ios);
23521 {
23522 noshowpos(ios);
23523 {
23524 noshowpoint(ios);
23525 {
23526 ios.imbue(lc);
23527 {
23528 ios.width(0);
23529 {
23530 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23531 std::string ex(str, iter.base());
23532 assert(ex == "-0X0P+0");
23533 assert(ios.width() == 0);
23534 }
23535 ios.width(25);
23536 left(ios);
23537 {
23538 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23539 std::string ex(str, iter.base());
23540 assert(ex == "-0X0P+0******************");
23541 assert(ios.width() == 0);
23542 }
23543 ios.width(25);
23544 right(ios);
23545 {
23546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23547 std::string ex(str, iter.base());
23548 assert(ex == "******************-0X0P+0");
23549 assert(ios.width() == 0);
23550 }
23551 ios.width(25);
23552 internal(ios);
23553 {
23554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23555 std::string ex(str, iter.base());
23556 assert(ex == "-******************0X0P+0");
23557 assert(ios.width() == 0);
23558 }
23559 }
23560 ios.imbue(lg);
23561 {
23562 ios.width(0);
23563 {
23564 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23565 std::string ex(str, iter.base());
23566 assert(ex == "-0X0P+0");
23567 assert(ios.width() == 0);
23568 }
23569 ios.width(25);
23570 left(ios);
23571 {
23572 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23573 std::string ex(str, iter.base());
23574 assert(ex == "-0X0P+0******************");
23575 assert(ios.width() == 0);
23576 }
23577 ios.width(25);
23578 right(ios);
23579 {
23580 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23581 std::string ex(str, iter.base());
23582 assert(ex == "******************-0X0P+0");
23583 assert(ios.width() == 0);
23584 }
23585 ios.width(25);
23586 internal(ios);
23587 {
23588 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23589 std::string ex(str, iter.base());
23590 assert(ex == "-******************0X0P+0");
23591 assert(ios.width() == 0);
23592 }
23593 }
23594 }
23595 showpoint(ios);
23596 {
23597 ios.imbue(lc);
23598 {
23599 ios.width(0);
23600 {
23601 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23602 std::string ex(str, iter.base());
23603 assert(ex == "-0X0.P+0");
23604 assert(ios.width() == 0);
23605 }
23606 ios.width(25);
23607 left(ios);
23608 {
23609 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23610 std::string ex(str, iter.base());
23611 assert(ex == "-0X0.P+0*****************");
23612 assert(ios.width() == 0);
23613 }
23614 ios.width(25);
23615 right(ios);
23616 {
23617 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23618 std::string ex(str, iter.base());
23619 assert(ex == "*****************-0X0.P+0");
23620 assert(ios.width() == 0);
23621 }
23622 ios.width(25);
23623 internal(ios);
23624 {
23625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23626 std::string ex(str, iter.base());
23627 assert(ex == "-*****************0X0.P+0");
23628 assert(ios.width() == 0);
23629 }
23630 }
23631 ios.imbue(lg);
23632 {
23633 ios.width(0);
23634 {
23635 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23636 std::string ex(str, iter.base());
23637 assert(ex == "-0X0;P+0");
23638 assert(ios.width() == 0);
23639 }
23640 ios.width(25);
23641 left(ios);
23642 {
23643 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23644 std::string ex(str, iter.base());
23645 assert(ex == "-0X0;P+0*****************");
23646 assert(ios.width() == 0);
23647 }
23648 ios.width(25);
23649 right(ios);
23650 {
23651 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23652 std::string ex(str, iter.base());
23653 assert(ex == "*****************-0X0;P+0");
23654 assert(ios.width() == 0);
23655 }
23656 ios.width(25);
23657 internal(ios);
23658 {
23659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23660 std::string ex(str, iter.base());
23661 assert(ex == "-*****************0X0;P+0");
23662 assert(ios.width() == 0);
23663 }
23664 }
23665 }
23666 }
23667 showpos(ios);
23668 {
23669 noshowpoint(ios);
23670 {
23671 ios.imbue(lc);
23672 {
23673 ios.width(0);
23674 {
23675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23676 std::string ex(str, iter.base());
23677 assert(ex == "-0X0P+0");
23678 assert(ios.width() == 0);
23679 }
23680 ios.width(25);
23681 left(ios);
23682 {
23683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23684 std::string ex(str, iter.base());
23685 assert(ex == "-0X0P+0******************");
23686 assert(ios.width() == 0);
23687 }
23688 ios.width(25);
23689 right(ios);
23690 {
23691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23692 std::string ex(str, iter.base());
23693 assert(ex == "******************-0X0P+0");
23694 assert(ios.width() == 0);
23695 }
23696 ios.width(25);
23697 internal(ios);
23698 {
23699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23700 std::string ex(str, iter.base());
23701 assert(ex == "-******************0X0P+0");
23702 assert(ios.width() == 0);
23703 }
23704 }
23705 ios.imbue(lg);
23706 {
23707 ios.width(0);
23708 {
23709 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23710 std::string ex(str, iter.base());
23711 assert(ex == "-0X0P+0");
23712 assert(ios.width() == 0);
23713 }
23714 ios.width(25);
23715 left(ios);
23716 {
23717 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23718 std::string ex(str, iter.base());
23719 assert(ex == "-0X0P+0******************");
23720 assert(ios.width() == 0);
23721 }
23722 ios.width(25);
23723 right(ios);
23724 {
23725 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23726 std::string ex(str, iter.base());
23727 assert(ex == "******************-0X0P+0");
23728 assert(ios.width() == 0);
23729 }
23730 ios.width(25);
23731 internal(ios);
23732 {
23733 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23734 std::string ex(str, iter.base());
23735 assert(ex == "-******************0X0P+0");
23736 assert(ios.width() == 0);
23737 }
23738 }
23739 }
23740 showpoint(ios);
23741 {
23742 ios.imbue(lc);
23743 {
23744 ios.width(0);
23745 {
23746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23747 std::string ex(str, iter.base());
23748 assert(ex == "-0X0.P+0");
23749 assert(ios.width() == 0);
23750 }
23751 ios.width(25);
23752 left(ios);
23753 {
23754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23755 std::string ex(str, iter.base());
23756 assert(ex == "-0X0.P+0*****************");
23757 assert(ios.width() == 0);
23758 }
23759 ios.width(25);
23760 right(ios);
23761 {
23762 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23763 std::string ex(str, iter.base());
23764 assert(ex == "*****************-0X0.P+0");
23765 assert(ios.width() == 0);
23766 }
23767 ios.width(25);
23768 internal(ios);
23769 {
23770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23771 std::string ex(str, iter.base());
23772 assert(ex == "-*****************0X0.P+0");
23773 assert(ios.width() == 0);
23774 }
23775 }
23776 ios.imbue(lg);
23777 {
23778 ios.width(0);
23779 {
23780 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23781 std::string ex(str, iter.base());
23782 assert(ex == "-0X0;P+0");
23783 assert(ios.width() == 0);
23784 }
23785 ios.width(25);
23786 left(ios);
23787 {
23788 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23789 std::string ex(str, iter.base());
23790 assert(ex == "-0X0;P+0*****************");
23791 assert(ios.width() == 0);
23792 }
23793 ios.width(25);
23794 right(ios);
23795 {
23796 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23797 std::string ex(str, iter.base());
23798 assert(ex == "*****************-0X0;P+0");
23799 assert(ios.width() == 0);
23800 }
23801 ios.width(25);
23802 internal(ios);
23803 {
23804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23805 std::string ex(str, iter.base());
23806 assert(ex == "-*****************0X0;P+0");
23807 assert(ios.width() == 0);
23808 }
23809 }
23810 }
23811 }
23812 }
23813 }
23814 ios.precision(6);
23815 {
23816 nouppercase(ios);
23817 {
23818 noshowpos(ios);
23819 {
23820 noshowpoint(ios);
23821 {
23822 ios.imbue(lc);
23823 {
23824 ios.width(0);
23825 {
23826 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23827 std::string ex(str, iter.base());
23828 assert(ex == "-0x0p+0");
23829 assert(ios.width() == 0);
23830 }
23831 ios.width(25);
23832 left(ios);
23833 {
23834 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23835 std::string ex(str, iter.base());
23836 assert(ex == "-0x0p+0******************");
23837 assert(ios.width() == 0);
23838 }
23839 ios.width(25);
23840 right(ios);
23841 {
23842 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23843 std::string ex(str, iter.base());
23844 assert(ex == "******************-0x0p+0");
23845 assert(ios.width() == 0);
23846 }
23847 ios.width(25);
23848 internal(ios);
23849 {
23850 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23851 std::string ex(str, iter.base());
23852 assert(ex == "-******************0x0p+0");
23853 assert(ios.width() == 0);
23854 }
23855 }
23856 ios.imbue(lg);
23857 {
23858 ios.width(0);
23859 {
23860 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23861 std::string ex(str, iter.base());
23862 assert(ex == "-0x0p+0");
23863 assert(ios.width() == 0);
23864 }
23865 ios.width(25);
23866 left(ios);
23867 {
23868 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23869 std::string ex(str, iter.base());
23870 assert(ex == "-0x0p+0******************");
23871 assert(ios.width() == 0);
23872 }
23873 ios.width(25);
23874 right(ios);
23875 {
23876 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23877 std::string ex(str, iter.base());
23878 assert(ex == "******************-0x0p+0");
23879 assert(ios.width() == 0);
23880 }
23881 ios.width(25);
23882 internal(ios);
23883 {
23884 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23885 std::string ex(str, iter.base());
23886 assert(ex == "-******************0x0p+0");
23887 assert(ios.width() == 0);
23888 }
23889 }
23890 }
23891 showpoint(ios);
23892 {
23893 ios.imbue(lc);
23894 {
23895 ios.width(0);
23896 {
23897 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23898 std::string ex(str, iter.base());
23899 assert(ex == "-0x0.p+0");
23900 assert(ios.width() == 0);
23901 }
23902 ios.width(25);
23903 left(ios);
23904 {
23905 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23906 std::string ex(str, iter.base());
23907 assert(ex == "-0x0.p+0*****************");
23908 assert(ios.width() == 0);
23909 }
23910 ios.width(25);
23911 right(ios);
23912 {
23913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23914 std::string ex(str, iter.base());
23915 assert(ex == "*****************-0x0.p+0");
23916 assert(ios.width() == 0);
23917 }
23918 ios.width(25);
23919 internal(ios);
23920 {
23921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23922 std::string ex(str, iter.base());
23923 assert(ex == "-*****************0x0.p+0");
23924 assert(ios.width() == 0);
23925 }
23926 }
23927 ios.imbue(lg);
23928 {
23929 ios.width(0);
23930 {
23931 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23932 std::string ex(str, iter.base());
23933 assert(ex == "-0x0;p+0");
23934 assert(ios.width() == 0);
23935 }
23936 ios.width(25);
23937 left(ios);
23938 {
23939 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23940 std::string ex(str, iter.base());
23941 assert(ex == "-0x0;p+0*****************");
23942 assert(ios.width() == 0);
23943 }
23944 ios.width(25);
23945 right(ios);
23946 {
23947 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23948 std::string ex(str, iter.base());
23949 assert(ex == "*****************-0x0;p+0");
23950 assert(ios.width() == 0);
23951 }
23952 ios.width(25);
23953 internal(ios);
23954 {
23955 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23956 std::string ex(str, iter.base());
23957 assert(ex == "-*****************0x0;p+0");
23958 assert(ios.width() == 0);
23959 }
23960 }
23961 }
23962 }
23963 showpos(ios);
23964 {
23965 noshowpoint(ios);
23966 {
23967 ios.imbue(lc);
23968 {
23969 ios.width(0);
23970 {
23971 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23972 std::string ex(str, iter.base());
23973 assert(ex == "-0x0p+0");
23974 assert(ios.width() == 0);
23975 }
23976 ios.width(25);
23977 left(ios);
23978 {
23979 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23980 std::string ex(str, iter.base());
23981 assert(ex == "-0x0p+0******************");
23982 assert(ios.width() == 0);
23983 }
23984 ios.width(25);
23985 right(ios);
23986 {
23987 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23988 std::string ex(str, iter.base());
23989 assert(ex == "******************-0x0p+0");
23990 assert(ios.width() == 0);
23991 }
23992 ios.width(25);
23993 internal(ios);
23994 {
23995 iter = f.put(output_iterator<char*>(str), ios, '*', v);
23996 std::string ex(str, iter.base());
23997 assert(ex == "-******************0x0p+0");
23998 assert(ios.width() == 0);
23999 }
24000 }
24001 ios.imbue(lg);
24002 {
24003 ios.width(0);
24004 {
24005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24006 std::string ex(str, iter.base());
24007 assert(ex == "-0x0p+0");
24008 assert(ios.width() == 0);
24009 }
24010 ios.width(25);
24011 left(ios);
24012 {
24013 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24014 std::string ex(str, iter.base());
24015 assert(ex == "-0x0p+0******************");
24016 assert(ios.width() == 0);
24017 }
24018 ios.width(25);
24019 right(ios);
24020 {
24021 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24022 std::string ex(str, iter.base());
24023 assert(ex == "******************-0x0p+0");
24024 assert(ios.width() == 0);
24025 }
24026 ios.width(25);
24027 internal(ios);
24028 {
24029 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24030 std::string ex(str, iter.base());
24031 assert(ex == "-******************0x0p+0");
24032 assert(ios.width() == 0);
24033 }
24034 }
24035 }
24036 showpoint(ios);
24037 {
24038 ios.imbue(lc);
24039 {
24040 ios.width(0);
24041 {
24042 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24043 std::string ex(str, iter.base());
24044 assert(ex == "-0x0.p+0");
24045 assert(ios.width() == 0);
24046 }
24047 ios.width(25);
24048 left(ios);
24049 {
24050 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24051 std::string ex(str, iter.base());
24052 assert(ex == "-0x0.p+0*****************");
24053 assert(ios.width() == 0);
24054 }
24055 ios.width(25);
24056 right(ios);
24057 {
24058 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24059 std::string ex(str, iter.base());
24060 assert(ex == "*****************-0x0.p+0");
24061 assert(ios.width() == 0);
24062 }
24063 ios.width(25);
24064 internal(ios);
24065 {
24066 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24067 std::string ex(str, iter.base());
24068 assert(ex == "-*****************0x0.p+0");
24069 assert(ios.width() == 0);
24070 }
24071 }
24072 ios.imbue(lg);
24073 {
24074 ios.width(0);
24075 {
24076 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24077 std::string ex(str, iter.base());
24078 assert(ex == "-0x0;p+0");
24079 assert(ios.width() == 0);
24080 }
24081 ios.width(25);
24082 left(ios);
24083 {
24084 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24085 std::string ex(str, iter.base());
24086 assert(ex == "-0x0;p+0*****************");
24087 assert(ios.width() == 0);
24088 }
24089 ios.width(25);
24090 right(ios);
24091 {
24092 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24093 std::string ex(str, iter.base());
24094 assert(ex == "*****************-0x0;p+0");
24095 assert(ios.width() == 0);
24096 }
24097 ios.width(25);
24098 internal(ios);
24099 {
24100 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24101 std::string ex(str, iter.base());
24102 assert(ex == "-*****************0x0;p+0");
24103 assert(ios.width() == 0);
24104 }
24105 }
24106 }
24107 }
24108 }
24109 uppercase(ios);
24110 {
24111 noshowpos(ios);
24112 {
24113 noshowpoint(ios);
24114 {
24115 ios.imbue(lc);
24116 {
24117 ios.width(0);
24118 {
24119 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24120 std::string ex(str, iter.base());
24121 assert(ex == "-0X0P+0");
24122 assert(ios.width() == 0);
24123 }
24124 ios.width(25);
24125 left(ios);
24126 {
24127 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24128 std::string ex(str, iter.base());
24129 assert(ex == "-0X0P+0******************");
24130 assert(ios.width() == 0);
24131 }
24132 ios.width(25);
24133 right(ios);
24134 {
24135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24136 std::string ex(str, iter.base());
24137 assert(ex == "******************-0X0P+0");
24138 assert(ios.width() == 0);
24139 }
24140 ios.width(25);
24141 internal(ios);
24142 {
24143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24144 std::string ex(str, iter.base());
24145 assert(ex == "-******************0X0P+0");
24146 assert(ios.width() == 0);
24147 }
24148 }
24149 ios.imbue(lg);
24150 {
24151 ios.width(0);
24152 {
24153 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24154 std::string ex(str, iter.base());
24155 assert(ex == "-0X0P+0");
24156 assert(ios.width() == 0);
24157 }
24158 ios.width(25);
24159 left(ios);
24160 {
24161 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24162 std::string ex(str, iter.base());
24163 assert(ex == "-0X0P+0******************");
24164 assert(ios.width() == 0);
24165 }
24166 ios.width(25);
24167 right(ios);
24168 {
24169 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24170 std::string ex(str, iter.base());
24171 assert(ex == "******************-0X0P+0");
24172 assert(ios.width() == 0);
24173 }
24174 ios.width(25);
24175 internal(ios);
24176 {
24177 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24178 std::string ex(str, iter.base());
24179 assert(ex == "-******************0X0P+0");
24180 assert(ios.width() == 0);
24181 }
24182 }
24183 }
24184 showpoint(ios);
24185 {
24186 ios.imbue(lc);
24187 {
24188 ios.width(0);
24189 {
24190 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24191 std::string ex(str, iter.base());
24192 assert(ex == "-0X0.P+0");
24193 assert(ios.width() == 0);
24194 }
24195 ios.width(25);
24196 left(ios);
24197 {
24198 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24199 std::string ex(str, iter.base());
24200 assert(ex == "-0X0.P+0*****************");
24201 assert(ios.width() == 0);
24202 }
24203 ios.width(25);
24204 right(ios);
24205 {
24206 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24207 std::string ex(str, iter.base());
24208 assert(ex == "*****************-0X0.P+0");
24209 assert(ios.width() == 0);
24210 }
24211 ios.width(25);
24212 internal(ios);
24213 {
24214 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24215 std::string ex(str, iter.base());
24216 assert(ex == "-*****************0X0.P+0");
24217 assert(ios.width() == 0);
24218 }
24219 }
24220 ios.imbue(lg);
24221 {
24222 ios.width(0);
24223 {
24224 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24225 std::string ex(str, iter.base());
24226 assert(ex == "-0X0;P+0");
24227 assert(ios.width() == 0);
24228 }
24229 ios.width(25);
24230 left(ios);
24231 {
24232 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24233 std::string ex(str, iter.base());
24234 assert(ex == "-0X0;P+0*****************");
24235 assert(ios.width() == 0);
24236 }
24237 ios.width(25);
24238 right(ios);
24239 {
24240 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24241 std::string ex(str, iter.base());
24242 assert(ex == "*****************-0X0;P+0");
24243 assert(ios.width() == 0);
24244 }
24245 ios.width(25);
24246 internal(ios);
24247 {
24248 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24249 std::string ex(str, iter.base());
24250 assert(ex == "-*****************0X0;P+0");
24251 assert(ios.width() == 0);
24252 }
24253 }
24254 }
24255 }
24256 showpos(ios);
24257 {
24258 noshowpoint(ios);
24259 {
24260 ios.imbue(lc);
24261 {
24262 ios.width(0);
24263 {
24264 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24265 std::string ex(str, iter.base());
24266 assert(ex == "-0X0P+0");
24267 assert(ios.width() == 0);
24268 }
24269 ios.width(25);
24270 left(ios);
24271 {
24272 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24273 std::string ex(str, iter.base());
24274 assert(ex == "-0X0P+0******************");
24275 assert(ios.width() == 0);
24276 }
24277 ios.width(25);
24278 right(ios);
24279 {
24280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24281 std::string ex(str, iter.base());
24282 assert(ex == "******************-0X0P+0");
24283 assert(ios.width() == 0);
24284 }
24285 ios.width(25);
24286 internal(ios);
24287 {
24288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24289 std::string ex(str, iter.base());
24290 assert(ex == "-******************0X0P+0");
24291 assert(ios.width() == 0);
24292 }
24293 }
24294 ios.imbue(lg);
24295 {
24296 ios.width(0);
24297 {
24298 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24299 std::string ex(str, iter.base());
24300 assert(ex == "-0X0P+0");
24301 assert(ios.width() == 0);
24302 }
24303 ios.width(25);
24304 left(ios);
24305 {
24306 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24307 std::string ex(str, iter.base());
24308 assert(ex == "-0X0P+0******************");
24309 assert(ios.width() == 0);
24310 }
24311 ios.width(25);
24312 right(ios);
24313 {
24314 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24315 std::string ex(str, iter.base());
24316 assert(ex == "******************-0X0P+0");
24317 assert(ios.width() == 0);
24318 }
24319 ios.width(25);
24320 internal(ios);
24321 {
24322 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24323 std::string ex(str, iter.base());
24324 assert(ex == "-******************0X0P+0");
24325 assert(ios.width() == 0);
24326 }
24327 }
24328 }
24329 showpoint(ios);
24330 {
24331 ios.imbue(lc);
24332 {
24333 ios.width(0);
24334 {
24335 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24336 std::string ex(str, iter.base());
24337 assert(ex == "-0X0.P+0");
24338 assert(ios.width() == 0);
24339 }
24340 ios.width(25);
24341 left(ios);
24342 {
24343 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24344 std::string ex(str, iter.base());
24345 assert(ex == "-0X0.P+0*****************");
24346 assert(ios.width() == 0);
24347 }
24348 ios.width(25);
24349 right(ios);
24350 {
24351 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24352 std::string ex(str, iter.base());
24353 assert(ex == "*****************-0X0.P+0");
24354 assert(ios.width() == 0);
24355 }
24356 ios.width(25);
24357 internal(ios);
24358 {
24359 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24360 std::string ex(str, iter.base());
24361 assert(ex == "-*****************0X0.P+0");
24362 assert(ios.width() == 0);
24363 }
24364 }
24365 ios.imbue(lg);
24366 {
24367 ios.width(0);
24368 {
24369 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24370 std::string ex(str, iter.base());
24371 assert(ex == "-0X0;P+0");
24372 assert(ios.width() == 0);
24373 }
24374 ios.width(25);
24375 left(ios);
24376 {
24377 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24378 std::string ex(str, iter.base());
24379 assert(ex == "-0X0;P+0*****************");
24380 assert(ios.width() == 0);
24381 }
24382 ios.width(25);
24383 right(ios);
24384 {
24385 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24386 std::string ex(str, iter.base());
24387 assert(ex == "*****************-0X0;P+0");
24388 assert(ios.width() == 0);
24389 }
24390 ios.width(25);
24391 internal(ios);
24392 {
24393 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24394 std::string ex(str, iter.base());
24395 assert(ex == "-*****************0X0;P+0");
24396 assert(ios.width() == 0);
24397 }
24398 }
24399 }
24400 }
24401 }
24402 }
24403 ios.precision(16);
24404 {
24405 }
24406 ios.precision(60);
24407 {
24408 }
24409 }
24410 }
24411 }
24412
test12()24413 void test12()
24414 {
24415 output_iterator<char*> iter;
24416 std::locale lc = std::locale::classic();
24417 std::locale lg(lc, new my_numpunct);
24418 #if defined(__APPLE__) && defined(__x86_64__)
24419 // This test is failing on FreeBSD, possibly due to different representations
24420 // of the floating point numbers.
24421 const my_facet f(1);
24422 char str[200];
24423 {
24424 long double v = 1234567890.125;
24425 std::ios ios(0);
24426 hexfloat(ios);
24427 // %a
24428 {
24429 ios.precision(0);
24430 {
24431 nouppercase(ios);
24432 {
24433 noshowpos(ios);
24434 {
24435 noshowpoint(ios);
24436 {
24437 ios.width(0);
24438 ios.imbue(lc);
24439 {
24440 {
24441 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24442 std::string ex(str, iter.base());
24443 assert(ex == "0x9.32c05a44p+27");
24444 assert(ios.width() == 0);
24445 }
24446 ios.width(25);
24447 left(ios);
24448 {
24449 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24450 std::string ex(str, iter.base());
24451 assert(ex == "0x9.32c05a44p+27*********");
24452 assert(ios.width() == 0);
24453 }
24454 ios.width(25);
24455 right(ios);
24456 {
24457 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24458 std::string ex(str, iter.base());
24459 assert(ex == "*********0x9.32c05a44p+27");
24460 assert(ios.width() == 0);
24461 }
24462 ios.width(25);
24463 internal(ios);
24464 {
24465 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24466 std::string ex(str, iter.base());
24467 assert(ex == "0x*********9.32c05a44p+27");
24468 assert(ios.width() == 0);
24469 }
24470 }
24471 ios.imbue(lg);
24472 {
24473 ios.width(0);
24474 {
24475 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24476 std::string ex(str, iter.base());
24477 assert(ex == "0x9;32c05a44p+27");
24478 assert(ios.width() == 0);
24479 }
24480 ios.width(25);
24481 left(ios);
24482 {
24483 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24484 std::string ex(str, iter.base());
24485 assert(ex == "0x9;32c05a44p+27*********");
24486 assert(ios.width() == 0);
24487 }
24488 ios.width(25);
24489 right(ios);
24490 {
24491 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24492 std::string ex(str, iter.base());
24493 assert(ex == "*********0x9;32c05a44p+27");
24494 assert(ios.width() == 0);
24495 }
24496 ios.width(25);
24497 internal(ios);
24498 {
24499 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24500 std::string ex(str, iter.base());
24501 assert(ex == "0x*********9;32c05a44p+27");
24502 assert(ios.width() == 0);
24503 }
24504 }
24505 }
24506 showpoint(ios);
24507 {
24508 ios.imbue(lc);
24509 {
24510 ios.width(0);
24511 {
24512 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24513 std::string ex(str, iter.base());
24514 assert(ex == "0x9.32c05a44p+27");
24515 assert(ios.width() == 0);
24516 }
24517 ios.width(25);
24518 left(ios);
24519 {
24520 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24521 std::string ex(str, iter.base());
24522 assert(ex == "0x9.32c05a44p+27*********");
24523 assert(ios.width() == 0);
24524 }
24525 ios.width(25);
24526 right(ios);
24527 {
24528 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24529 std::string ex(str, iter.base());
24530 assert(ex == "*********0x9.32c05a44p+27");
24531 assert(ios.width() == 0);
24532 }
24533 ios.width(25);
24534 internal(ios);
24535 {
24536 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24537 std::string ex(str, iter.base());
24538 assert(ex == "0x*********9.32c05a44p+27");
24539 assert(ios.width() == 0);
24540 }
24541 }
24542 ios.imbue(lg);
24543 {
24544 ios.width(0);
24545 {
24546 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24547 std::string ex(str, iter.base());
24548 assert(ex == "0x9;32c05a44p+27");
24549 assert(ios.width() == 0);
24550 }
24551 ios.width(25);
24552 left(ios);
24553 {
24554 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24555 std::string ex(str, iter.base());
24556 assert(ex == "0x9;32c05a44p+27*********");
24557 assert(ios.width() == 0);
24558 }
24559 ios.width(25);
24560 right(ios);
24561 {
24562 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24563 std::string ex(str, iter.base());
24564 assert(ex == "*********0x9;32c05a44p+27");
24565 assert(ios.width() == 0);
24566 }
24567 ios.width(25);
24568 internal(ios);
24569 {
24570 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24571 std::string ex(str, iter.base());
24572 assert(ex == "0x*********9;32c05a44p+27");
24573 assert(ios.width() == 0);
24574 }
24575 }
24576 }
24577 }
24578 showpos(ios);
24579 {
24580 noshowpoint(ios);
24581 {
24582 ios.imbue(lc);
24583 {
24584 ios.width(0);
24585 {
24586 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24587 std::string ex(str, iter.base());
24588 assert(ex == "+0x9.32c05a44p+27");
24589 assert(ios.width() == 0);
24590 }
24591 ios.width(25);
24592 left(ios);
24593 {
24594 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24595 std::string ex(str, iter.base());
24596 assert(ex == "+0x9.32c05a44p+27********");
24597 assert(ios.width() == 0);
24598 }
24599 ios.width(25);
24600 right(ios);
24601 {
24602 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24603 std::string ex(str, iter.base());
24604 assert(ex == "********+0x9.32c05a44p+27");
24605 assert(ios.width() == 0);
24606 }
24607 ios.width(25);
24608 internal(ios);
24609 {
24610 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24611 std::string ex(str, iter.base());
24612 assert(ex == "+********0x9.32c05a44p+27");
24613 assert(ios.width() == 0);
24614 }
24615 }
24616 ios.imbue(lg);
24617 {
24618 ios.width(0);
24619 {
24620 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24621 std::string ex(str, iter.base());
24622 assert(ex == "+0x9;32c05a44p+27");
24623 assert(ios.width() == 0);
24624 }
24625 ios.width(25);
24626 left(ios);
24627 {
24628 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24629 std::string ex(str, iter.base());
24630 assert(ex == "+0x9;32c05a44p+27********");
24631 assert(ios.width() == 0);
24632 }
24633 ios.width(25);
24634 right(ios);
24635 {
24636 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24637 std::string ex(str, iter.base());
24638 assert(ex == "********+0x9;32c05a44p+27");
24639 assert(ios.width() == 0);
24640 }
24641 ios.width(25);
24642 internal(ios);
24643 {
24644 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24645 std::string ex(str, iter.base());
24646 assert(ex == "+********0x9;32c05a44p+27");
24647 assert(ios.width() == 0);
24648 }
24649 }
24650 }
24651 showpoint(ios);
24652 {
24653 ios.imbue(lc);
24654 {
24655 ios.width(0);
24656 {
24657 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24658 std::string ex(str, iter.base());
24659 assert(ex == "+0x9.32c05a44p+27");
24660 assert(ios.width() == 0);
24661 }
24662 ios.width(25);
24663 left(ios);
24664 {
24665 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24666 std::string ex(str, iter.base());
24667 assert(ex == "+0x9.32c05a44p+27********");
24668 assert(ios.width() == 0);
24669 }
24670 ios.width(25);
24671 right(ios);
24672 {
24673 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24674 std::string ex(str, iter.base());
24675 assert(ex == "********+0x9.32c05a44p+27");
24676 assert(ios.width() == 0);
24677 }
24678 ios.width(25);
24679 internal(ios);
24680 {
24681 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24682 std::string ex(str, iter.base());
24683 assert(ex == "+********0x9.32c05a44p+27");
24684 assert(ios.width() == 0);
24685 }
24686 }
24687 ios.imbue(lg);
24688 {
24689 ios.width(0);
24690 {
24691 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24692 std::string ex(str, iter.base());
24693 assert(ex == "+0x9;32c05a44p+27");
24694 assert(ios.width() == 0);
24695 }
24696 ios.width(25);
24697 left(ios);
24698 {
24699 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24700 std::string ex(str, iter.base());
24701 assert(ex == "+0x9;32c05a44p+27********");
24702 assert(ios.width() == 0);
24703 }
24704 ios.width(25);
24705 right(ios);
24706 {
24707 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24708 std::string ex(str, iter.base());
24709 assert(ex == "********+0x9;32c05a44p+27");
24710 assert(ios.width() == 0);
24711 }
24712 ios.width(25);
24713 internal(ios);
24714 {
24715 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24716 std::string ex(str, iter.base());
24717 assert(ex == "+********0x9;32c05a44p+27");
24718 assert(ios.width() == 0);
24719 }
24720 }
24721 }
24722 }
24723 }
24724 uppercase(ios);
24725 {
24726 noshowpos(ios);
24727 {
24728 noshowpoint(ios);
24729 {
24730 ios.imbue(lc);
24731 {
24732 ios.width(0);
24733 {
24734 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24735 std::string ex(str, iter.base());
24736 assert(ex == "0X9.32C05A44P+27");
24737 assert(ios.width() == 0);
24738 }
24739 ios.width(25);
24740 left(ios);
24741 {
24742 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24743 std::string ex(str, iter.base());
24744 assert(ex == "0X9.32C05A44P+27*********");
24745 assert(ios.width() == 0);
24746 }
24747 ios.width(25);
24748 right(ios);
24749 {
24750 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24751 std::string ex(str, iter.base());
24752 assert(ex == "*********0X9.32C05A44P+27");
24753 assert(ios.width() == 0);
24754 }
24755 ios.width(25);
24756 internal(ios);
24757 {
24758 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24759 std::string ex(str, iter.base());
24760 assert(ex == "0X*********9.32C05A44P+27");
24761 assert(ios.width() == 0);
24762 }
24763 }
24764 ios.imbue(lg);
24765 {
24766 ios.width(0);
24767 {
24768 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24769 std::string ex(str, iter.base());
24770 assert(ex == "0X9;32C05A44P+27");
24771 assert(ios.width() == 0);
24772 }
24773 ios.width(25);
24774 left(ios);
24775 {
24776 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24777 std::string ex(str, iter.base());
24778 assert(ex == "0X9;32C05A44P+27*********");
24779 assert(ios.width() == 0);
24780 }
24781 ios.width(25);
24782 right(ios);
24783 {
24784 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24785 std::string ex(str, iter.base());
24786 assert(ex == "*********0X9;32C05A44P+27");
24787 assert(ios.width() == 0);
24788 }
24789 ios.width(25);
24790 internal(ios);
24791 {
24792 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24793 std::string ex(str, iter.base());
24794 assert(ex == "0X*********9;32C05A44P+27");
24795 assert(ios.width() == 0);
24796 }
24797 }
24798 }
24799 showpoint(ios);
24800 {
24801 ios.imbue(lc);
24802 {
24803 ios.width(0);
24804 {
24805 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24806 std::string ex(str, iter.base());
24807 assert(ex == "0X9.32C05A44P+27");
24808 assert(ios.width() == 0);
24809 }
24810 ios.width(25);
24811 left(ios);
24812 {
24813 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24814 std::string ex(str, iter.base());
24815 assert(ex == "0X9.32C05A44P+27*********");
24816 assert(ios.width() == 0);
24817 }
24818 ios.width(25);
24819 right(ios);
24820 {
24821 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24822 std::string ex(str, iter.base());
24823 assert(ex == "*********0X9.32C05A44P+27");
24824 assert(ios.width() == 0);
24825 }
24826 ios.width(25);
24827 internal(ios);
24828 {
24829 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24830 std::string ex(str, iter.base());
24831 assert(ex == "0X*********9.32C05A44P+27");
24832 assert(ios.width() == 0);
24833 }
24834 }
24835 ios.imbue(lg);
24836 {
24837 ios.width(0);
24838 {
24839 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24840 std::string ex(str, iter.base());
24841 assert(ex == "0X9;32C05A44P+27");
24842 assert(ios.width() == 0);
24843 }
24844 ios.width(25);
24845 left(ios);
24846 {
24847 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24848 std::string ex(str, iter.base());
24849 assert(ex == "0X9;32C05A44P+27*********");
24850 assert(ios.width() == 0);
24851 }
24852 ios.width(25);
24853 right(ios);
24854 {
24855 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24856 std::string ex(str, iter.base());
24857 assert(ex == "*********0X9;32C05A44P+27");
24858 assert(ios.width() == 0);
24859 }
24860 ios.width(25);
24861 internal(ios);
24862 {
24863 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24864 std::string ex(str, iter.base());
24865 assert(ex == "0X*********9;32C05A44P+27");
24866 assert(ios.width() == 0);
24867 }
24868 }
24869 }
24870 }
24871 showpos(ios);
24872 {
24873 noshowpoint(ios);
24874 {
24875 ios.imbue(lc);
24876 {
24877 ios.width(0);
24878 {
24879 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24880 std::string ex(str, iter.base());
24881 assert(ex == "+0X9.32C05A44P+27");
24882 assert(ios.width() == 0);
24883 }
24884 ios.width(25);
24885 left(ios);
24886 {
24887 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24888 std::string ex(str, iter.base());
24889 assert(ex == "+0X9.32C05A44P+27********");
24890 assert(ios.width() == 0);
24891 }
24892 ios.width(25);
24893 right(ios);
24894 {
24895 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24896 std::string ex(str, iter.base());
24897 assert(ex == "********+0X9.32C05A44P+27");
24898 assert(ios.width() == 0);
24899 }
24900 ios.width(25);
24901 internal(ios);
24902 {
24903 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24904 std::string ex(str, iter.base());
24905 assert(ex == "+********0X9.32C05A44P+27");
24906 assert(ios.width() == 0);
24907 }
24908 }
24909 ios.imbue(lg);
24910 {
24911 ios.width(0);
24912 {
24913 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24914 std::string ex(str, iter.base());
24915 assert(ex == "+0X9;32C05A44P+27");
24916 assert(ios.width() == 0);
24917 }
24918 ios.width(25);
24919 left(ios);
24920 {
24921 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24922 std::string ex(str, iter.base());
24923 assert(ex == "+0X9;32C05A44P+27********");
24924 assert(ios.width() == 0);
24925 }
24926 ios.width(25);
24927 right(ios);
24928 {
24929 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24930 std::string ex(str, iter.base());
24931 assert(ex == "********+0X9;32C05A44P+27");
24932 assert(ios.width() == 0);
24933 }
24934 ios.width(25);
24935 internal(ios);
24936 {
24937 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24938 std::string ex(str, iter.base());
24939 assert(ex == "+********0X9;32C05A44P+27");
24940 assert(ios.width() == 0);
24941 }
24942 }
24943 }
24944 showpoint(ios);
24945 {
24946 ios.imbue(lc);
24947 {
24948 ios.width(0);
24949 {
24950 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24951 std::string ex(str, iter.base());
24952 assert(ex == "+0X9.32C05A44P+27");
24953 assert(ios.width() == 0);
24954 }
24955 ios.width(25);
24956 left(ios);
24957 {
24958 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24959 std::string ex(str, iter.base());
24960 assert(ex == "+0X9.32C05A44P+27********");
24961 assert(ios.width() == 0);
24962 }
24963 ios.width(25);
24964 right(ios);
24965 {
24966 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24967 std::string ex(str, iter.base());
24968 assert(ex == "********+0X9.32C05A44P+27");
24969 assert(ios.width() == 0);
24970 }
24971 ios.width(25);
24972 internal(ios);
24973 {
24974 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24975 std::string ex(str, iter.base());
24976 assert(ex == "+********0X9.32C05A44P+27");
24977 assert(ios.width() == 0);
24978 }
24979 }
24980 ios.imbue(lg);
24981 {
24982 ios.width(0);
24983 {
24984 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24985 std::string ex(str, iter.base());
24986 assert(ex == "+0X9;32C05A44P+27");
24987 assert(ios.width() == 0);
24988 }
24989 ios.width(25);
24990 left(ios);
24991 {
24992 iter = f.put(output_iterator<char*>(str), ios, '*', v);
24993 std::string ex(str, iter.base());
24994 assert(ex == "+0X9;32C05A44P+27********");
24995 assert(ios.width() == 0);
24996 }
24997 ios.width(25);
24998 right(ios);
24999 {
25000 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25001 std::string ex(str, iter.base());
25002 assert(ex == "********+0X9;32C05A44P+27");
25003 assert(ios.width() == 0);
25004 }
25005 ios.width(25);
25006 internal(ios);
25007 {
25008 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25009 std::string ex(str, iter.base());
25010 assert(ex == "+********0X9;32C05A44P+27");
25011 assert(ios.width() == 0);
25012 }
25013 }
25014 }
25015 }
25016 }
25017 }
25018 ios.precision(1);
25019 {
25020 nouppercase(ios);
25021 {
25022 noshowpos(ios);
25023 {
25024 noshowpoint(ios);
25025 {
25026 ios.imbue(lc);
25027 {
25028 ios.width(0);
25029 {
25030 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25031 std::string ex(str, iter.base());
25032 assert(ex == "0x9.32c05a44p+27");
25033 assert(ios.width() == 0);
25034 }
25035 ios.width(25);
25036 left(ios);
25037 {
25038 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25039 std::string ex(str, iter.base());
25040 assert(ex == "0x9.32c05a44p+27*********");
25041 assert(ios.width() == 0);
25042 }
25043 ios.width(25);
25044 right(ios);
25045 {
25046 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25047 std::string ex(str, iter.base());
25048 assert(ex == "*********0x9.32c05a44p+27");
25049 assert(ios.width() == 0);
25050 }
25051 ios.width(25);
25052 internal(ios);
25053 {
25054 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25055 std::string ex(str, iter.base());
25056 assert(ex == "0x*********9.32c05a44p+27");
25057 assert(ios.width() == 0);
25058 }
25059 }
25060 ios.imbue(lg);
25061 {
25062 ios.width(0);
25063 {
25064 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25065 std::string ex(str, iter.base());
25066 assert(ex == "0x9;32c05a44p+27");
25067 assert(ios.width() == 0);
25068 }
25069 ios.width(25);
25070 left(ios);
25071 {
25072 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25073 std::string ex(str, iter.base());
25074 assert(ex == "0x9;32c05a44p+27*********");
25075 assert(ios.width() == 0);
25076 }
25077 ios.width(25);
25078 right(ios);
25079 {
25080 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25081 std::string ex(str, iter.base());
25082 assert(ex == "*********0x9;32c05a44p+27");
25083 assert(ios.width() == 0);
25084 }
25085 ios.width(25);
25086 internal(ios);
25087 {
25088 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25089 std::string ex(str, iter.base());
25090 assert(ex == "0x*********9;32c05a44p+27");
25091 assert(ios.width() == 0);
25092 }
25093 }
25094 }
25095 showpoint(ios);
25096 {
25097 ios.imbue(lc);
25098 {
25099 ios.width(0);
25100 {
25101 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25102 std::string ex(str, iter.base());
25103 assert(ex == "0x9.32c05a44p+27");
25104 assert(ios.width() == 0);
25105 }
25106 ios.width(25);
25107 left(ios);
25108 {
25109 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25110 std::string ex(str, iter.base());
25111 assert(ex == "0x9.32c05a44p+27*********");
25112 assert(ios.width() == 0);
25113 }
25114 ios.width(25);
25115 right(ios);
25116 {
25117 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25118 std::string ex(str, iter.base());
25119 assert(ex == "*********0x9.32c05a44p+27");
25120 assert(ios.width() == 0);
25121 }
25122 ios.width(25);
25123 internal(ios);
25124 {
25125 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25126 std::string ex(str, iter.base());
25127 assert(ex == "0x*********9.32c05a44p+27");
25128 assert(ios.width() == 0);
25129 }
25130 }
25131 ios.imbue(lg);
25132 {
25133 ios.width(0);
25134 {
25135 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25136 std::string ex(str, iter.base());
25137 assert(ex == "0x9;32c05a44p+27");
25138 assert(ios.width() == 0);
25139 }
25140 ios.width(25);
25141 left(ios);
25142 {
25143 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25144 std::string ex(str, iter.base());
25145 assert(ex == "0x9;32c05a44p+27*********");
25146 assert(ios.width() == 0);
25147 }
25148 ios.width(25);
25149 right(ios);
25150 {
25151 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25152 std::string ex(str, iter.base());
25153 assert(ex == "*********0x9;32c05a44p+27");
25154 assert(ios.width() == 0);
25155 }
25156 ios.width(25);
25157 internal(ios);
25158 {
25159 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25160 std::string ex(str, iter.base());
25161 assert(ex == "0x*********9;32c05a44p+27");
25162 assert(ios.width() == 0);
25163 }
25164 }
25165 }
25166 }
25167 showpos(ios);
25168 {
25169 noshowpoint(ios);
25170 {
25171 ios.imbue(lc);
25172 {
25173 ios.width(0);
25174 {
25175 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25176 std::string ex(str, iter.base());
25177 assert(ex == "+0x9.32c05a44p+27");
25178 assert(ios.width() == 0);
25179 }
25180 ios.width(25);
25181 left(ios);
25182 {
25183 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25184 std::string ex(str, iter.base());
25185 assert(ex == "+0x9.32c05a44p+27********");
25186 assert(ios.width() == 0);
25187 }
25188 ios.width(25);
25189 right(ios);
25190 {
25191 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25192 std::string ex(str, iter.base());
25193 assert(ex == "********+0x9.32c05a44p+27");
25194 assert(ios.width() == 0);
25195 }
25196 ios.width(25);
25197 internal(ios);
25198 {
25199 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25200 std::string ex(str, iter.base());
25201 assert(ex == "+********0x9.32c05a44p+27");
25202 assert(ios.width() == 0);
25203 }
25204 }
25205 ios.imbue(lg);
25206 {
25207 ios.width(0);
25208 {
25209 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25210 std::string ex(str, iter.base());
25211 assert(ex == "+0x9;32c05a44p+27");
25212 assert(ios.width() == 0);
25213 }
25214 ios.width(25);
25215 left(ios);
25216 {
25217 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25218 std::string ex(str, iter.base());
25219 assert(ex == "+0x9;32c05a44p+27********");
25220 assert(ios.width() == 0);
25221 }
25222 ios.width(25);
25223 right(ios);
25224 {
25225 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25226 std::string ex(str, iter.base());
25227 assert(ex == "********+0x9;32c05a44p+27");
25228 assert(ios.width() == 0);
25229 }
25230 ios.width(25);
25231 internal(ios);
25232 {
25233 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25234 std::string ex(str, iter.base());
25235 assert(ex == "+********0x9;32c05a44p+27");
25236 assert(ios.width() == 0);
25237 }
25238 }
25239 }
25240 showpoint(ios);
25241 {
25242 ios.imbue(lc);
25243 {
25244 ios.width(0);
25245 {
25246 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25247 std::string ex(str, iter.base());
25248 assert(ex == "+0x9.32c05a44p+27");
25249 assert(ios.width() == 0);
25250 }
25251 ios.width(25);
25252 left(ios);
25253 {
25254 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25255 std::string ex(str, iter.base());
25256 assert(ex == "+0x9.32c05a44p+27********");
25257 assert(ios.width() == 0);
25258 }
25259 ios.width(25);
25260 right(ios);
25261 {
25262 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25263 std::string ex(str, iter.base());
25264 assert(ex == "********+0x9.32c05a44p+27");
25265 assert(ios.width() == 0);
25266 }
25267 ios.width(25);
25268 internal(ios);
25269 {
25270 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25271 std::string ex(str, iter.base());
25272 assert(ex == "+********0x9.32c05a44p+27");
25273 assert(ios.width() == 0);
25274 }
25275 }
25276 ios.imbue(lg);
25277 {
25278 ios.width(0);
25279 {
25280 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25281 std::string ex(str, iter.base());
25282 assert(ex == "+0x9;32c05a44p+27");
25283 assert(ios.width() == 0);
25284 }
25285 ios.width(25);
25286 left(ios);
25287 {
25288 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25289 std::string ex(str, iter.base());
25290 assert(ex == "+0x9;32c05a44p+27********");
25291 assert(ios.width() == 0);
25292 }
25293 ios.width(25);
25294 right(ios);
25295 {
25296 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25297 std::string ex(str, iter.base());
25298 assert(ex == "********+0x9;32c05a44p+27");
25299 assert(ios.width() == 0);
25300 }
25301 ios.width(25);
25302 internal(ios);
25303 {
25304 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25305 std::string ex(str, iter.base());
25306 assert(ex == "+********0x9;32c05a44p+27");
25307 assert(ios.width() == 0);
25308 }
25309 }
25310 }
25311 }
25312 }
25313 uppercase(ios);
25314 {
25315 noshowpos(ios);
25316 {
25317 noshowpoint(ios);
25318 {
25319 ios.imbue(lc);
25320 {
25321 ios.width(0);
25322 {
25323 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25324 std::string ex(str, iter.base());
25325 assert(ex == "0X9.32C05A44P+27");
25326 assert(ios.width() == 0);
25327 }
25328 ios.width(25);
25329 left(ios);
25330 {
25331 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25332 std::string ex(str, iter.base());
25333 assert(ex == "0X9.32C05A44P+27*********");
25334 assert(ios.width() == 0);
25335 }
25336 ios.width(25);
25337 right(ios);
25338 {
25339 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25340 std::string ex(str, iter.base());
25341 assert(ex == "*********0X9.32C05A44P+27");
25342 assert(ios.width() == 0);
25343 }
25344 ios.width(25);
25345 internal(ios);
25346 {
25347 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25348 std::string ex(str, iter.base());
25349 assert(ex == "0X*********9.32C05A44P+27");
25350 assert(ios.width() == 0);
25351 }
25352 }
25353 ios.imbue(lg);
25354 {
25355 ios.width(0);
25356 {
25357 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25358 std::string ex(str, iter.base());
25359 assert(ex == "0X9;32C05A44P+27");
25360 assert(ios.width() == 0);
25361 }
25362 ios.width(25);
25363 left(ios);
25364 {
25365 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25366 std::string ex(str, iter.base());
25367 assert(ex == "0X9;32C05A44P+27*********");
25368 assert(ios.width() == 0);
25369 }
25370 ios.width(25);
25371 right(ios);
25372 {
25373 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25374 std::string ex(str, iter.base());
25375 assert(ex == "*********0X9;32C05A44P+27");
25376 assert(ios.width() == 0);
25377 }
25378 ios.width(25);
25379 internal(ios);
25380 {
25381 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25382 std::string ex(str, iter.base());
25383 assert(ex == "0X*********9;32C05A44P+27");
25384 assert(ios.width() == 0);
25385 }
25386 }
25387 }
25388 showpoint(ios);
25389 {
25390 ios.imbue(lc);
25391 {
25392 ios.width(0);
25393 {
25394 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25395 std::string ex(str, iter.base());
25396 assert(ex == "0X9.32C05A44P+27");
25397 assert(ios.width() == 0);
25398 }
25399 ios.width(25);
25400 left(ios);
25401 {
25402 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25403 std::string ex(str, iter.base());
25404 assert(ex == "0X9.32C05A44P+27*********");
25405 assert(ios.width() == 0);
25406 }
25407 ios.width(25);
25408 right(ios);
25409 {
25410 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25411 std::string ex(str, iter.base());
25412 assert(ex == "*********0X9.32C05A44P+27");
25413 assert(ios.width() == 0);
25414 }
25415 ios.width(25);
25416 internal(ios);
25417 {
25418 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25419 std::string ex(str, iter.base());
25420 assert(ex == "0X*********9.32C05A44P+27");
25421 assert(ios.width() == 0);
25422 }
25423 }
25424 ios.imbue(lg);
25425 {
25426 ios.width(0);
25427 {
25428 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25429 std::string ex(str, iter.base());
25430 assert(ex == "0X9;32C05A44P+27");
25431 assert(ios.width() == 0);
25432 }
25433 ios.width(25);
25434 left(ios);
25435 {
25436 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25437 std::string ex(str, iter.base());
25438 assert(ex == "0X9;32C05A44P+27*********");
25439 assert(ios.width() == 0);
25440 }
25441 ios.width(25);
25442 right(ios);
25443 {
25444 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25445 std::string ex(str, iter.base());
25446 assert(ex == "*********0X9;32C05A44P+27");
25447 assert(ios.width() == 0);
25448 }
25449 ios.width(25);
25450 internal(ios);
25451 {
25452 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25453 std::string ex(str, iter.base());
25454 assert(ex == "0X*********9;32C05A44P+27");
25455 assert(ios.width() == 0);
25456 }
25457 }
25458 }
25459 }
25460 showpos(ios);
25461 {
25462 noshowpoint(ios);
25463 {
25464 ios.imbue(lc);
25465 {
25466 ios.width(0);
25467 {
25468 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25469 std::string ex(str, iter.base());
25470 assert(ex == "+0X9.32C05A44P+27");
25471 assert(ios.width() == 0);
25472 }
25473 ios.width(25);
25474 left(ios);
25475 {
25476 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25477 std::string ex(str, iter.base());
25478 assert(ex == "+0X9.32C05A44P+27********");
25479 assert(ios.width() == 0);
25480 }
25481 ios.width(25);
25482 right(ios);
25483 {
25484 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25485 std::string ex(str, iter.base());
25486 assert(ex == "********+0X9.32C05A44P+27");
25487 assert(ios.width() == 0);
25488 }
25489 ios.width(25);
25490 internal(ios);
25491 {
25492 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25493 std::string ex(str, iter.base());
25494 assert(ex == "+********0X9.32C05A44P+27");
25495 assert(ios.width() == 0);
25496 }
25497 }
25498 ios.imbue(lg);
25499 {
25500 ios.width(0);
25501 {
25502 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25503 std::string ex(str, iter.base());
25504 assert(ex == "+0X9;32C05A44P+27");
25505 assert(ios.width() == 0);
25506 }
25507 ios.width(25);
25508 left(ios);
25509 {
25510 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25511 std::string ex(str, iter.base());
25512 assert(ex == "+0X9;32C05A44P+27********");
25513 assert(ios.width() == 0);
25514 }
25515 ios.width(25);
25516 right(ios);
25517 {
25518 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25519 std::string ex(str, iter.base());
25520 assert(ex == "********+0X9;32C05A44P+27");
25521 assert(ios.width() == 0);
25522 }
25523 ios.width(25);
25524 internal(ios);
25525 {
25526 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25527 std::string ex(str, iter.base());
25528 assert(ex == "+********0X9;32C05A44P+27");
25529 assert(ios.width() == 0);
25530 }
25531 }
25532 }
25533 showpoint(ios);
25534 {
25535 ios.imbue(lc);
25536 {
25537 ios.width(0);
25538 {
25539 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25540 std::string ex(str, iter.base());
25541 assert(ex == "+0X9.32C05A44P+27");
25542 assert(ios.width() == 0);
25543 }
25544 ios.width(25);
25545 left(ios);
25546 {
25547 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25548 std::string ex(str, iter.base());
25549 assert(ex == "+0X9.32C05A44P+27********");
25550 assert(ios.width() == 0);
25551 }
25552 ios.width(25);
25553 right(ios);
25554 {
25555 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25556 std::string ex(str, iter.base());
25557 assert(ex == "********+0X9.32C05A44P+27");
25558 assert(ios.width() == 0);
25559 }
25560 ios.width(25);
25561 internal(ios);
25562 {
25563 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25564 std::string ex(str, iter.base());
25565 assert(ex == "+********0X9.32C05A44P+27");
25566 assert(ios.width() == 0);
25567 }
25568 }
25569 ios.imbue(lg);
25570 {
25571 ios.width(0);
25572 {
25573 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25574 std::string ex(str, iter.base());
25575 assert(ex == "+0X9;32C05A44P+27");
25576 assert(ios.width() == 0);
25577 }
25578 ios.width(25);
25579 left(ios);
25580 {
25581 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25582 std::string ex(str, iter.base());
25583 assert(ex == "+0X9;32C05A44P+27********");
25584 assert(ios.width() == 0);
25585 }
25586 ios.width(25);
25587 right(ios);
25588 {
25589 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25590 std::string ex(str, iter.base());
25591 assert(ex == "********+0X9;32C05A44P+27");
25592 assert(ios.width() == 0);
25593 }
25594 ios.width(25);
25595 internal(ios);
25596 {
25597 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25598 std::string ex(str, iter.base());
25599 assert(ex == "+********0X9;32C05A44P+27");
25600 assert(ios.width() == 0);
25601 }
25602 }
25603 }
25604 }
25605 }
25606 }
25607 ios.precision(6);
25608 {
25609 }
25610 ios.precision(16);
25611 {
25612 }
25613 ios.precision(60);
25614 {
25615 nouppercase(ios);
25616 {
25617 noshowpos(ios);
25618 {
25619 noshowpoint(ios);
25620 {
25621 ios.imbue(lc);
25622 {
25623 ios.width(0);
25624 {
25625 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25626 std::string ex(str, iter.base());
25627 assert(ex == "0x9.32c05a44p+27");
25628 assert(ios.width() == 0);
25629 }
25630 ios.width(25);
25631 left(ios);
25632 {
25633 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25634 std::string ex(str, iter.base());
25635 assert(ex == "0x9.32c05a44p+27*********");
25636 assert(ios.width() == 0);
25637 }
25638 ios.width(25);
25639 right(ios);
25640 {
25641 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25642 std::string ex(str, iter.base());
25643 assert(ex == "*********0x9.32c05a44p+27");
25644 assert(ios.width() == 0);
25645 }
25646 ios.width(25);
25647 internal(ios);
25648 {
25649 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25650 std::string ex(str, iter.base());
25651 assert(ex == "0x*********9.32c05a44p+27");
25652 assert(ios.width() == 0);
25653 }
25654 }
25655 ios.imbue(lg);
25656 {
25657 ios.width(0);
25658 {
25659 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25660 std::string ex(str, iter.base());
25661 assert(ex == "0x9;32c05a44p+27");
25662 assert(ios.width() == 0);
25663 }
25664 ios.width(25);
25665 left(ios);
25666 {
25667 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25668 std::string ex(str, iter.base());
25669 assert(ex == "0x9;32c05a44p+27*********");
25670 assert(ios.width() == 0);
25671 }
25672 ios.width(25);
25673 right(ios);
25674 {
25675 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25676 std::string ex(str, iter.base());
25677 assert(ex == "*********0x9;32c05a44p+27");
25678 assert(ios.width() == 0);
25679 }
25680 ios.width(25);
25681 internal(ios);
25682 {
25683 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25684 std::string ex(str, iter.base());
25685 assert(ex == "0x*********9;32c05a44p+27");
25686 assert(ios.width() == 0);
25687 }
25688 }
25689 }
25690 showpoint(ios);
25691 {
25692 ios.imbue(lc);
25693 {
25694 ios.width(0);
25695 {
25696 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25697 std::string ex(str, iter.base());
25698 assert(ex == "0x9.32c05a44p+27");
25699 assert(ios.width() == 0);
25700 }
25701 ios.width(25);
25702 left(ios);
25703 {
25704 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25705 std::string ex(str, iter.base());
25706 assert(ex == "0x9.32c05a44p+27*********");
25707 assert(ios.width() == 0);
25708 }
25709 ios.width(25);
25710 right(ios);
25711 {
25712 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25713 std::string ex(str, iter.base());
25714 assert(ex == "*********0x9.32c05a44p+27");
25715 assert(ios.width() == 0);
25716 }
25717 ios.width(25);
25718 internal(ios);
25719 {
25720 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25721 std::string ex(str, iter.base());
25722 assert(ex == "0x*********9.32c05a44p+27");
25723 assert(ios.width() == 0);
25724 }
25725 }
25726 ios.imbue(lg);
25727 {
25728 ios.width(0);
25729 {
25730 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25731 std::string ex(str, iter.base());
25732 assert(ex == "0x9;32c05a44p+27");
25733 assert(ios.width() == 0);
25734 }
25735 ios.width(25);
25736 left(ios);
25737 {
25738 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25739 std::string ex(str, iter.base());
25740 assert(ex == "0x9;32c05a44p+27*********");
25741 assert(ios.width() == 0);
25742 }
25743 ios.width(25);
25744 right(ios);
25745 {
25746 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25747 std::string ex(str, iter.base());
25748 assert(ex == "*********0x9;32c05a44p+27");
25749 assert(ios.width() == 0);
25750 }
25751 ios.width(25);
25752 internal(ios);
25753 {
25754 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25755 std::string ex(str, iter.base());
25756 assert(ex == "0x*********9;32c05a44p+27");
25757 assert(ios.width() == 0);
25758 }
25759 }
25760 }
25761 }
25762 showpos(ios);
25763 {
25764 noshowpoint(ios);
25765 {
25766 ios.imbue(lc);
25767 {
25768 ios.width(0);
25769 {
25770 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25771 std::string ex(str, iter.base());
25772 assert(ex == "+0x9.32c05a44p+27");
25773 assert(ios.width() == 0);
25774 }
25775 ios.width(25);
25776 left(ios);
25777 {
25778 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25779 std::string ex(str, iter.base());
25780 assert(ex == "+0x9.32c05a44p+27********");
25781 assert(ios.width() == 0);
25782 }
25783 ios.width(25);
25784 right(ios);
25785 {
25786 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25787 std::string ex(str, iter.base());
25788 assert(ex == "********+0x9.32c05a44p+27");
25789 assert(ios.width() == 0);
25790 }
25791 ios.width(25);
25792 internal(ios);
25793 {
25794 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25795 std::string ex(str, iter.base());
25796 assert(ex == "+********0x9.32c05a44p+27");
25797 assert(ios.width() == 0);
25798 }
25799 }
25800 ios.imbue(lg);
25801 {
25802 ios.width(0);
25803 {
25804 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25805 std::string ex(str, iter.base());
25806 assert(ex == "+0x9;32c05a44p+27");
25807 assert(ios.width() == 0);
25808 }
25809 ios.width(25);
25810 left(ios);
25811 {
25812 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25813 std::string ex(str, iter.base());
25814 assert(ex == "+0x9;32c05a44p+27********");
25815 assert(ios.width() == 0);
25816 }
25817 ios.width(25);
25818 right(ios);
25819 {
25820 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25821 std::string ex(str, iter.base());
25822 assert(ex == "********+0x9;32c05a44p+27");
25823 assert(ios.width() == 0);
25824 }
25825 ios.width(25);
25826 internal(ios);
25827 {
25828 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25829 std::string ex(str, iter.base());
25830 assert(ex == "+********0x9;32c05a44p+27");
25831 assert(ios.width() == 0);
25832 }
25833 }
25834 }
25835 showpoint(ios);
25836 {
25837 ios.imbue(lc);
25838 {
25839 ios.width(0);
25840 {
25841 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25842 std::string ex(str, iter.base());
25843 assert(ex == "+0x9.32c05a44p+27");
25844 assert(ios.width() == 0);
25845 }
25846 ios.width(25);
25847 left(ios);
25848 {
25849 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25850 std::string ex(str, iter.base());
25851 assert(ex == "+0x9.32c05a44p+27********");
25852 assert(ios.width() == 0);
25853 }
25854 ios.width(25);
25855 right(ios);
25856 {
25857 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25858 std::string ex(str, iter.base());
25859 assert(ex == "********+0x9.32c05a44p+27");
25860 assert(ios.width() == 0);
25861 }
25862 ios.width(25);
25863 internal(ios);
25864 {
25865 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25866 std::string ex(str, iter.base());
25867 assert(ex == "+********0x9.32c05a44p+27");
25868 assert(ios.width() == 0);
25869 }
25870 }
25871 ios.imbue(lg);
25872 {
25873 ios.width(0);
25874 {
25875 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25876 std::string ex(str, iter.base());
25877 assert(ex == "+0x9;32c05a44p+27");
25878 assert(ios.width() == 0);
25879 }
25880 ios.width(25);
25881 left(ios);
25882 {
25883 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25884 std::string ex(str, iter.base());
25885 assert(ex == "+0x9;32c05a44p+27********");
25886 assert(ios.width() == 0);
25887 }
25888 ios.width(25);
25889 right(ios);
25890 {
25891 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25892 std::string ex(str, iter.base());
25893 assert(ex == "********+0x9;32c05a44p+27");
25894 assert(ios.width() == 0);
25895 }
25896 ios.width(25);
25897 internal(ios);
25898 {
25899 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25900 std::string ex(str, iter.base());
25901 assert(ex == "+********0x9;32c05a44p+27");
25902 assert(ios.width() == 0);
25903 }
25904 }
25905 }
25906 }
25907 }
25908 uppercase(ios);
25909 {
25910 noshowpos(ios);
25911 {
25912 noshowpoint(ios);
25913 {
25914 ios.imbue(lc);
25915 {
25916 ios.width(0);
25917 {
25918 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25919 std::string ex(str, iter.base());
25920 assert(ex == "0X9.32C05A44P+27");
25921 assert(ios.width() == 0);
25922 }
25923 ios.width(25);
25924 left(ios);
25925 {
25926 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25927 std::string ex(str, iter.base());
25928 assert(ex == "0X9.32C05A44P+27*********");
25929 assert(ios.width() == 0);
25930 }
25931 ios.width(25);
25932 right(ios);
25933 {
25934 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25935 std::string ex(str, iter.base());
25936 assert(ex == "*********0X9.32C05A44P+27");
25937 assert(ios.width() == 0);
25938 }
25939 ios.width(25);
25940 internal(ios);
25941 {
25942 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25943 std::string ex(str, iter.base());
25944 assert(ex == "0X*********9.32C05A44P+27");
25945 assert(ios.width() == 0);
25946 }
25947 }
25948 ios.imbue(lg);
25949 {
25950 ios.width(0);
25951 {
25952 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25953 std::string ex(str, iter.base());
25954 assert(ex == "0X9;32C05A44P+27");
25955 assert(ios.width() == 0);
25956 }
25957 ios.width(25);
25958 left(ios);
25959 {
25960 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25961 std::string ex(str, iter.base());
25962 assert(ex == "0X9;32C05A44P+27*********");
25963 assert(ios.width() == 0);
25964 }
25965 ios.width(25);
25966 right(ios);
25967 {
25968 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25969 std::string ex(str, iter.base());
25970 assert(ex == "*********0X9;32C05A44P+27");
25971 assert(ios.width() == 0);
25972 }
25973 ios.width(25);
25974 internal(ios);
25975 {
25976 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25977 std::string ex(str, iter.base());
25978 assert(ex == "0X*********9;32C05A44P+27");
25979 assert(ios.width() == 0);
25980 }
25981 }
25982 }
25983 showpoint(ios);
25984 {
25985 ios.imbue(lc);
25986 {
25987 ios.width(0);
25988 {
25989 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25990 std::string ex(str, iter.base());
25991 assert(ex == "0X9.32C05A44P+27");
25992 assert(ios.width() == 0);
25993 }
25994 ios.width(25);
25995 left(ios);
25996 {
25997 iter = f.put(output_iterator<char*>(str), ios, '*', v);
25998 std::string ex(str, iter.base());
25999 assert(ex == "0X9.32C05A44P+27*********");
26000 assert(ios.width() == 0);
26001 }
26002 ios.width(25);
26003 right(ios);
26004 {
26005 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26006 std::string ex(str, iter.base());
26007 assert(ex == "*********0X9.32C05A44P+27");
26008 assert(ios.width() == 0);
26009 }
26010 ios.width(25);
26011 internal(ios);
26012 {
26013 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26014 std::string ex(str, iter.base());
26015 assert(ex == "0X*********9.32C05A44P+27");
26016 assert(ios.width() == 0);
26017 }
26018 }
26019 ios.imbue(lg);
26020 {
26021 ios.width(0);
26022 {
26023 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26024 std::string ex(str, iter.base());
26025 assert(ex == "0X9;32C05A44P+27");
26026 assert(ios.width() == 0);
26027 }
26028 ios.width(25);
26029 left(ios);
26030 {
26031 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26032 std::string ex(str, iter.base());
26033 assert(ex == "0X9;32C05A44P+27*********");
26034 assert(ios.width() == 0);
26035 }
26036 ios.width(25);
26037 right(ios);
26038 {
26039 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26040 std::string ex(str, iter.base());
26041 assert(ex == "*********0X9;32C05A44P+27");
26042 assert(ios.width() == 0);
26043 }
26044 ios.width(25);
26045 internal(ios);
26046 {
26047 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26048 std::string ex(str, iter.base());
26049 assert(ex == "0X*********9;32C05A44P+27");
26050 assert(ios.width() == 0);
26051 }
26052 }
26053 }
26054 }
26055 showpos(ios);
26056 {
26057 noshowpoint(ios);
26058 {
26059 ios.imbue(lc);
26060 {
26061 ios.width(0);
26062 {
26063 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26064 std::string ex(str, iter.base());
26065 assert(ex == "+0X9.32C05A44P+27");
26066 assert(ios.width() == 0);
26067 }
26068 ios.width(25);
26069 left(ios);
26070 {
26071 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26072 std::string ex(str, iter.base());
26073 assert(ex == "+0X9.32C05A44P+27********");
26074 assert(ios.width() == 0);
26075 }
26076 ios.width(25);
26077 right(ios);
26078 {
26079 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26080 std::string ex(str, iter.base());
26081 assert(ex == "********+0X9.32C05A44P+27");
26082 assert(ios.width() == 0);
26083 }
26084 ios.width(25);
26085 internal(ios);
26086 {
26087 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26088 std::string ex(str, iter.base());
26089 assert(ex == "+********0X9.32C05A44P+27");
26090 assert(ios.width() == 0);
26091 }
26092 }
26093 ios.imbue(lg);
26094 {
26095 ios.width(0);
26096 {
26097 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26098 std::string ex(str, iter.base());
26099 assert(ex == "+0X9;32C05A44P+27");
26100 assert(ios.width() == 0);
26101 }
26102 ios.width(25);
26103 left(ios);
26104 {
26105 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26106 std::string ex(str, iter.base());
26107 assert(ex == "+0X9;32C05A44P+27********");
26108 assert(ios.width() == 0);
26109 }
26110 ios.width(25);
26111 right(ios);
26112 {
26113 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26114 std::string ex(str, iter.base());
26115 assert(ex == "********+0X9;32C05A44P+27");
26116 assert(ios.width() == 0);
26117 }
26118 ios.width(25);
26119 internal(ios);
26120 {
26121 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26122 std::string ex(str, iter.base());
26123 assert(ex == "+********0X9;32C05A44P+27");
26124 assert(ios.width() == 0);
26125 }
26126 }
26127 }
26128 showpoint(ios);
26129 {
26130 ios.imbue(lc);
26131 {
26132 ios.width(0);
26133 {
26134 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26135 std::string ex(str, iter.base());
26136 assert(ex == "+0X9.32C05A44P+27");
26137 assert(ios.width() == 0);
26138 }
26139 ios.width(25);
26140 left(ios);
26141 {
26142 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26143 std::string ex(str, iter.base());
26144 assert(ex == "+0X9.32C05A44P+27********");
26145 assert(ios.width() == 0);
26146 }
26147 ios.width(25);
26148 right(ios);
26149 {
26150 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26151 std::string ex(str, iter.base());
26152 assert(ex == "********+0X9.32C05A44P+27");
26153 assert(ios.width() == 0);
26154 }
26155 ios.width(25);
26156 internal(ios);
26157 {
26158 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26159 std::string ex(str, iter.base());
26160 assert(ex == "+********0X9.32C05A44P+27");
26161 assert(ios.width() == 0);
26162 }
26163 }
26164 ios.imbue(lg);
26165 {
26166 ios.width(0);
26167 {
26168 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26169 std::string ex(str, iter.base());
26170 assert(ex == "+0X9;32C05A44P+27");
26171 assert(ios.width() == 0);
26172 }
26173 ios.width(25);
26174 left(ios);
26175 {
26176 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26177 std::string ex(str, iter.base());
26178 assert(ex == "+0X9;32C05A44P+27********");
26179 assert(ios.width() == 0);
26180 }
26181 ios.width(25);
26182 right(ios);
26183 {
26184 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26185 std::string ex(str, iter.base());
26186 assert(ex == "********+0X9;32C05A44P+27");
26187 assert(ios.width() == 0);
26188 }
26189 ios.width(25);
26190 internal(ios);
26191 {
26192 iter = f.put(output_iterator<char*>(str), ios, '*', v);
26193 std::string ex(str, iter.base());
26194 assert(ex == "+********0X9;32C05A44P+27");
26195 assert(ios.width() == 0);
26196 }
26197 }
26198 }
26199 }
26200 }
26201 }
26202 }
26203 }
26204 #endif
26205 }
26206
main(int,char **)26207 int main(int, char**)
26208 {
26209 test1();
26210 test2();
26211 test3();
26212 test4();
26213 test5();
26214 test6();
26215 test7();
26216 test8();
26217 test9();
26218 test10();
26219 test11();
26220 test12();
26221 output_iterator<char*> iter;
26222 std::locale lc = std::locale::classic();
26223 std::locale lg(lc, new my_numpunct);
26224 const my_facet f(1);
26225 {
26226 long double v = -INFINITY; ((void)v);
26227 }
26228 {
26229 long double v = std::nan(""); ((void)v);
26230 }
26231
26232 {
26233 long double v = +0.; ((void)v);
26234 }
26235 {
26236 long double v = -INFINITY; ((void)v);
26237 }
26238 {
26239 long double v = std::nan(""); ((void)v);
26240 }
26241 {
26242 long double v = -INFINITY; ((void)v);
26243 }
26244 {
26245 long double v = std::nan(""); ((void)v);
26246 }
26247
26248 return 0;
26249 }
26250