1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // XFAIL: android 11 12 // <locale> 13 14 // class num_put<charT, OutputIterator> 15 16 // iter_type put(iter_type s, ios_base& iob, char_type fill, long double v) const; 17 18 // TODO GLIBC uses a different string for positive and negative NAN numbers. 19 // XFAIL: linux-gnu 20 21 #include <locale> 22 #include <ios> 23 #include <cassert> 24 #include <streambuf> 25 #include <cmath> 26 #include "test_iterators.h" 27 28 typedef std::num_put<char, output_iterator<char*> > F; 29 30 class my_facet 31 : public F 32 { 33 public: 34 explicit my_facet(std::size_t refs = 0) 35 : F(refs) {} 36 }; 37 38 class my_numpunct 39 : public std::numpunct<char> 40 { 41 public: 42 my_numpunct() : std::numpunct<char>() {} 43 44 protected: 45 virtual char_type do_decimal_point() const {return ';';} 46 virtual char_type do_thousands_sep() const {return '_';} 47 virtual std::string do_grouping() const {return std::string("\1\2\3");} 48 }; 49 50 void test1() 51 { 52 char str[200]; 53 output_iterator<char*> iter; 54 std::locale lc = std::locale::classic(); 55 std::locale lg(lc, new my_numpunct); 56 const my_facet f(1); 57 { 58 long double v = +0.; 59 std::ios ios(0); 60 // %g 61 { 62 ios.precision(0); 63 { 64 nouppercase(ios); 65 { 66 noshowpos(ios); 67 { 68 noshowpoint(ios); 69 { 70 ios.imbue(lc); 71 { 72 ios.width(0); 73 { 74 iter = f.put(output_iterator<char*>(str), ios, '*', v); 75 std::string ex(str, iter.base()); 76 assert(ex == "0"); 77 assert(ios.width() == 0); 78 } 79 ios.width(25); 80 left(ios); 81 { 82 iter = f.put(output_iterator<char*>(str), ios, '*', v); 83 std::string ex(str, iter.base()); 84 assert(ex == "0************************"); 85 assert(ios.width() == 0); 86 } 87 ios.width(25); 88 right(ios); 89 { 90 iter = f.put(output_iterator<char*>(str), ios, '*', v); 91 std::string ex(str, iter.base()); 92 assert(ex == "************************0"); 93 assert(ios.width() == 0); 94 } 95 ios.width(25); 96 internal(ios); 97 { 98 iter = f.put(output_iterator<char*>(str), ios, '*', v); 99 std::string ex(str, iter.base()); 100 assert(ex == "************************0"); 101 assert(ios.width() == 0); 102 } 103 } 104 ios.imbue(lg); 105 { 106 ios.width(0); 107 { 108 iter = f.put(output_iterator<char*>(str), ios, '*', v); 109 std::string ex(str, iter.base()); 110 assert(ex == "0"); 111 assert(ios.width() == 0); 112 } 113 ios.width(25); 114 left(ios); 115 { 116 iter = f.put(output_iterator<char*>(str), ios, '*', v); 117 std::string ex(str, iter.base()); 118 assert(ex == "0************************"); 119 assert(ios.width() == 0); 120 } 121 ios.width(25); 122 right(ios); 123 { 124 iter = f.put(output_iterator<char*>(str), ios, '*', v); 125 std::string ex(str, iter.base()); 126 assert(ex == "************************0"); 127 assert(ios.width() == 0); 128 } 129 ios.width(25); 130 internal(ios); 131 { 132 iter = f.put(output_iterator<char*>(str), ios, '*', v); 133 std::string ex(str, iter.base()); 134 assert(ex == "************************0"); 135 assert(ios.width() == 0); 136 } 137 } 138 } 139 showpoint(ios); 140 { 141 ios.imbue(lc); 142 { 143 ios.width(0); 144 { 145 iter = f.put(output_iterator<char*>(str), ios, '*', v); 146 std::string ex(str, iter.base()); 147 assert(ex == "0."); 148 assert(ios.width() == 0); 149 } 150 ios.width(25); 151 left(ios); 152 { 153 iter = f.put(output_iterator<char*>(str), ios, '*', v); 154 std::string ex(str, iter.base()); 155 assert(ex == "0.***********************"); 156 assert(ios.width() == 0); 157 } 158 ios.width(25); 159 right(ios); 160 { 161 iter = f.put(output_iterator<char*>(str), ios, '*', v); 162 std::string ex(str, iter.base()); 163 assert(ex == "***********************0."); 164 assert(ios.width() == 0); 165 } 166 ios.width(25); 167 internal(ios); 168 { 169 iter = f.put(output_iterator<char*>(str), ios, '*', v); 170 std::string ex(str, iter.base()); 171 assert(ex == "***********************0."); 172 assert(ios.width() == 0); 173 } 174 } 175 ios.imbue(lg); 176 { 177 ios.width(0); 178 { 179 iter = f.put(output_iterator<char*>(str), ios, '*', v); 180 std::string ex(str, iter.base()); 181 assert(ex == "0;"); 182 assert(ios.width() == 0); 183 } 184 ios.width(25); 185 left(ios); 186 { 187 iter = f.put(output_iterator<char*>(str), ios, '*', v); 188 std::string ex(str, iter.base()); 189 assert(ex == "0;***********************"); 190 assert(ios.width() == 0); 191 } 192 ios.width(25); 193 right(ios); 194 { 195 iter = f.put(output_iterator<char*>(str), ios, '*', v); 196 std::string ex(str, iter.base()); 197 assert(ex == "***********************0;"); 198 assert(ios.width() == 0); 199 } 200 ios.width(25); 201 internal(ios); 202 { 203 iter = f.put(output_iterator<char*>(str), ios, '*', v); 204 std::string ex(str, iter.base()); 205 assert(ex == "***********************0;"); 206 assert(ios.width() == 0); 207 } 208 } 209 } 210 } 211 showpos(ios); 212 { 213 noshowpoint(ios); 214 { 215 ios.imbue(lc); 216 { 217 ios.width(0); 218 { 219 iter = f.put(output_iterator<char*>(str), ios, '*', v); 220 std::string ex(str, iter.base()); 221 assert(ex == "+0"); 222 assert(ios.width() == 0); 223 } 224 ios.width(25); 225 left(ios); 226 { 227 iter = f.put(output_iterator<char*>(str), ios, '*', v); 228 std::string ex(str, iter.base()); 229 assert(ex == "+0***********************"); 230 assert(ios.width() == 0); 231 } 232 ios.width(25); 233 right(ios); 234 { 235 iter = f.put(output_iterator<char*>(str), ios, '*', v); 236 std::string ex(str, iter.base()); 237 assert(ex == "***********************+0"); 238 assert(ios.width() == 0); 239 } 240 ios.width(25); 241 internal(ios); 242 { 243 iter = f.put(output_iterator<char*>(str), ios, '*', v); 244 std::string ex(str, iter.base()); 245 assert(ex == "+***********************0"); 246 assert(ios.width() == 0); 247 } 248 } 249 ios.imbue(lg); 250 { 251 ios.width(0); 252 { 253 iter = f.put(output_iterator<char*>(str), ios, '*', v); 254 std::string ex(str, iter.base()); 255 assert(ex == "+0"); 256 assert(ios.width() == 0); 257 } 258 ios.width(25); 259 left(ios); 260 { 261 iter = f.put(output_iterator<char*>(str), ios, '*', v); 262 std::string ex(str, iter.base()); 263 assert(ex == "+0***********************"); 264 assert(ios.width() == 0); 265 } 266 ios.width(25); 267 right(ios); 268 { 269 iter = f.put(output_iterator<char*>(str), ios, '*', v); 270 std::string ex(str, iter.base()); 271 assert(ex == "***********************+0"); 272 assert(ios.width() == 0); 273 } 274 ios.width(25); 275 internal(ios); 276 { 277 iter = f.put(output_iterator<char*>(str), ios, '*', v); 278 std::string ex(str, iter.base()); 279 assert(ex == "+***********************0"); 280 assert(ios.width() == 0); 281 } 282 } 283 } 284 showpoint(ios); 285 { 286 ios.imbue(lc); 287 { 288 ios.width(0); 289 { 290 iter = f.put(output_iterator<char*>(str), ios, '*', v); 291 std::string ex(str, iter.base()); 292 assert(ex == "+0."); 293 assert(ios.width() == 0); 294 } 295 ios.width(25); 296 left(ios); 297 { 298 iter = f.put(output_iterator<char*>(str), ios, '*', v); 299 std::string ex(str, iter.base()); 300 assert(ex == "+0.**********************"); 301 assert(ios.width() == 0); 302 } 303 ios.width(25); 304 right(ios); 305 { 306 iter = f.put(output_iterator<char*>(str), ios, '*', v); 307 std::string ex(str, iter.base()); 308 assert(ex == "**********************+0."); 309 assert(ios.width() == 0); 310 } 311 ios.width(25); 312 internal(ios); 313 { 314 iter = f.put(output_iterator<char*>(str), ios, '*', v); 315 std::string ex(str, iter.base()); 316 assert(ex == "+**********************0."); 317 assert(ios.width() == 0); 318 } 319 } 320 ios.imbue(lg); 321 { 322 ios.width(0); 323 { 324 iter = f.put(output_iterator<char*>(str), ios, '*', v); 325 std::string ex(str, iter.base()); 326 assert(ex == "+0;"); 327 assert(ios.width() == 0); 328 } 329 ios.width(25); 330 left(ios); 331 { 332 iter = f.put(output_iterator<char*>(str), ios, '*', v); 333 std::string ex(str, iter.base()); 334 assert(ex == "+0;**********************"); 335 assert(ios.width() == 0); 336 } 337 ios.width(25); 338 right(ios); 339 { 340 iter = f.put(output_iterator<char*>(str), ios, '*', v); 341 std::string ex(str, iter.base()); 342 assert(ex == "**********************+0;"); 343 assert(ios.width() == 0); 344 } 345 ios.width(25); 346 internal(ios); 347 { 348 iter = f.put(output_iterator<char*>(str), ios, '*', v); 349 std::string ex(str, iter.base()); 350 assert(ex == "+**********************0;"); 351 assert(ios.width() == 0); 352 } 353 } 354 } 355 } 356 } 357 uppercase(ios); 358 { 359 noshowpos(ios); 360 { 361 noshowpoint(ios); 362 { 363 ios.imbue(lc); 364 { 365 ios.width(0); 366 { 367 iter = f.put(output_iterator<char*>(str), ios, '*', v); 368 std::string ex(str, iter.base()); 369 assert(ex == "0"); 370 assert(ios.width() == 0); 371 } 372 ios.width(25); 373 left(ios); 374 { 375 iter = f.put(output_iterator<char*>(str), ios, '*', v); 376 std::string ex(str, iter.base()); 377 assert(ex == "0************************"); 378 assert(ios.width() == 0); 379 } 380 ios.width(25); 381 right(ios); 382 { 383 iter = f.put(output_iterator<char*>(str), ios, '*', v); 384 std::string ex(str, iter.base()); 385 assert(ex == "************************0"); 386 assert(ios.width() == 0); 387 } 388 ios.width(25); 389 internal(ios); 390 { 391 iter = f.put(output_iterator<char*>(str), ios, '*', v); 392 std::string ex(str, iter.base()); 393 assert(ex == "************************0"); 394 assert(ios.width() == 0); 395 } 396 } 397 ios.imbue(lg); 398 { 399 ios.width(0); 400 { 401 iter = f.put(output_iterator<char*>(str), ios, '*', v); 402 std::string ex(str, iter.base()); 403 assert(ex == "0"); 404 assert(ios.width() == 0); 405 } 406 ios.width(25); 407 left(ios); 408 { 409 iter = f.put(output_iterator<char*>(str), ios, '*', v); 410 std::string ex(str, iter.base()); 411 assert(ex == "0************************"); 412 assert(ios.width() == 0); 413 } 414 ios.width(25); 415 right(ios); 416 { 417 iter = f.put(output_iterator<char*>(str), ios, '*', v); 418 std::string ex(str, iter.base()); 419 assert(ex == "************************0"); 420 assert(ios.width() == 0); 421 } 422 ios.width(25); 423 internal(ios); 424 { 425 iter = f.put(output_iterator<char*>(str), ios, '*', v); 426 std::string ex(str, iter.base()); 427 assert(ex == "************************0"); 428 assert(ios.width() == 0); 429 } 430 } 431 } 432 showpoint(ios); 433 { 434 ios.imbue(lc); 435 { 436 ios.width(0); 437 { 438 iter = f.put(output_iterator<char*>(str), ios, '*', v); 439 std::string ex(str, iter.base()); 440 assert(ex == "0."); 441 assert(ios.width() == 0); 442 } 443 ios.width(25); 444 left(ios); 445 { 446 iter = f.put(output_iterator<char*>(str), ios, '*', v); 447 std::string ex(str, iter.base()); 448 assert(ex == "0.***********************"); 449 assert(ios.width() == 0); 450 } 451 ios.width(25); 452 right(ios); 453 { 454 iter = f.put(output_iterator<char*>(str), ios, '*', v); 455 std::string ex(str, iter.base()); 456 assert(ex == "***********************0."); 457 assert(ios.width() == 0); 458 } 459 ios.width(25); 460 internal(ios); 461 { 462 iter = f.put(output_iterator<char*>(str), ios, '*', v); 463 std::string ex(str, iter.base()); 464 assert(ex == "***********************0."); 465 assert(ios.width() == 0); 466 } 467 } 468 ios.imbue(lg); 469 { 470 ios.width(0); 471 { 472 iter = f.put(output_iterator<char*>(str), ios, '*', v); 473 std::string ex(str, iter.base()); 474 assert(ex == "0;"); 475 assert(ios.width() == 0); 476 } 477 ios.width(25); 478 left(ios); 479 { 480 iter = f.put(output_iterator<char*>(str), ios, '*', v); 481 std::string ex(str, iter.base()); 482 assert(ex == "0;***********************"); 483 assert(ios.width() == 0); 484 } 485 ios.width(25); 486 right(ios); 487 { 488 iter = f.put(output_iterator<char*>(str), ios, '*', v); 489 std::string ex(str, iter.base()); 490 assert(ex == "***********************0;"); 491 assert(ios.width() == 0); 492 } 493 ios.width(25); 494 internal(ios); 495 { 496 iter = f.put(output_iterator<char*>(str), ios, '*', v); 497 std::string ex(str, iter.base()); 498 assert(ex == "***********************0;"); 499 assert(ios.width() == 0); 500 } 501 } 502 } 503 } 504 showpos(ios); 505 { 506 noshowpoint(ios); 507 { 508 ios.imbue(lc); 509 { 510 ios.width(0); 511 { 512 iter = f.put(output_iterator<char*>(str), ios, '*', v); 513 std::string ex(str, iter.base()); 514 assert(ex == "+0"); 515 assert(ios.width() == 0); 516 } 517 ios.width(25); 518 left(ios); 519 { 520 iter = f.put(output_iterator<char*>(str), ios, '*', v); 521 std::string ex(str, iter.base()); 522 assert(ex == "+0***********************"); 523 assert(ios.width() == 0); 524 } 525 ios.width(25); 526 right(ios); 527 { 528 iter = f.put(output_iterator<char*>(str), ios, '*', v); 529 std::string ex(str, iter.base()); 530 assert(ex == "***********************+0"); 531 assert(ios.width() == 0); 532 } 533 ios.width(25); 534 internal(ios); 535 { 536 iter = f.put(output_iterator<char*>(str), ios, '*', v); 537 std::string ex(str, iter.base()); 538 assert(ex == "+***********************0"); 539 assert(ios.width() == 0); 540 } 541 } 542 ios.imbue(lg); 543 { 544 ios.width(0); 545 { 546 iter = f.put(output_iterator<char*>(str), ios, '*', v); 547 std::string ex(str, iter.base()); 548 assert(ex == "+0"); 549 assert(ios.width() == 0); 550 } 551 ios.width(25); 552 left(ios); 553 { 554 iter = f.put(output_iterator<char*>(str), ios, '*', v); 555 std::string ex(str, iter.base()); 556 assert(ex == "+0***********************"); 557 assert(ios.width() == 0); 558 } 559 ios.width(25); 560 right(ios); 561 { 562 iter = f.put(output_iterator<char*>(str), ios, '*', v); 563 std::string ex(str, iter.base()); 564 assert(ex == "***********************+0"); 565 assert(ios.width() == 0); 566 } 567 ios.width(25); 568 internal(ios); 569 { 570 iter = f.put(output_iterator<char*>(str), ios, '*', v); 571 std::string ex(str, iter.base()); 572 assert(ex == "+***********************0"); 573 assert(ios.width() == 0); 574 } 575 } 576 } 577 showpoint(ios); 578 { 579 ios.imbue(lc); 580 { 581 ios.width(0); 582 { 583 iter = f.put(output_iterator<char*>(str), ios, '*', v); 584 std::string ex(str, iter.base()); 585 assert(ex == "+0."); 586 assert(ios.width() == 0); 587 } 588 ios.width(25); 589 left(ios); 590 { 591 iter = f.put(output_iterator<char*>(str), ios, '*', v); 592 std::string ex(str, iter.base()); 593 assert(ex == "+0.**********************"); 594 assert(ios.width() == 0); 595 } 596 ios.width(25); 597 right(ios); 598 { 599 iter = f.put(output_iterator<char*>(str), ios, '*', v); 600 std::string ex(str, iter.base()); 601 assert(ex == "**********************+0."); 602 assert(ios.width() == 0); 603 } 604 ios.width(25); 605 internal(ios); 606 { 607 iter = f.put(output_iterator<char*>(str), ios, '*', v); 608 std::string ex(str, iter.base()); 609 assert(ex == "+**********************0."); 610 assert(ios.width() == 0); 611 } 612 } 613 ios.imbue(lg); 614 { 615 ios.width(0); 616 { 617 iter = f.put(output_iterator<char*>(str), ios, '*', v); 618 std::string ex(str, iter.base()); 619 assert(ex == "+0;"); 620 assert(ios.width() == 0); 621 } 622 ios.width(25); 623 left(ios); 624 { 625 iter = f.put(output_iterator<char*>(str), ios, '*', v); 626 std::string ex(str, iter.base()); 627 assert(ex == "+0;**********************"); 628 assert(ios.width() == 0); 629 } 630 ios.width(25); 631 right(ios); 632 { 633 iter = f.put(output_iterator<char*>(str), ios, '*', v); 634 std::string ex(str, iter.base()); 635 assert(ex == "**********************+0;"); 636 assert(ios.width() == 0); 637 } 638 ios.width(25); 639 internal(ios); 640 { 641 iter = f.put(output_iterator<char*>(str), ios, '*', v); 642 std::string ex(str, iter.base()); 643 assert(ex == "+**********************0;"); 644 assert(ios.width() == 0); 645 } 646 } 647 } 648 } 649 } 650 } 651 ios.precision(1); 652 { 653 nouppercase(ios); 654 { 655 noshowpos(ios); 656 { 657 noshowpoint(ios); 658 { 659 ios.imbue(lc); 660 { 661 ios.width(0); 662 { 663 iter = f.put(output_iterator<char*>(str), ios, '*', v); 664 std::string ex(str, iter.base()); 665 assert(ex == "0"); 666 assert(ios.width() == 0); 667 } 668 ios.width(25); 669 left(ios); 670 { 671 iter = f.put(output_iterator<char*>(str), ios, '*', v); 672 std::string ex(str, iter.base()); 673 assert(ex == "0************************"); 674 assert(ios.width() == 0); 675 } 676 ios.width(25); 677 right(ios); 678 { 679 iter = f.put(output_iterator<char*>(str), ios, '*', v); 680 std::string ex(str, iter.base()); 681 assert(ex == "************************0"); 682 assert(ios.width() == 0); 683 } 684 ios.width(25); 685 internal(ios); 686 { 687 iter = f.put(output_iterator<char*>(str), ios, '*', v); 688 std::string ex(str, iter.base()); 689 assert(ex == "************************0"); 690 assert(ios.width() == 0); 691 } 692 } 693 ios.imbue(lg); 694 { 695 ios.width(0); 696 { 697 iter = f.put(output_iterator<char*>(str), ios, '*', v); 698 std::string ex(str, iter.base()); 699 assert(ex == "0"); 700 assert(ios.width() == 0); 701 } 702 ios.width(25); 703 left(ios); 704 { 705 iter = f.put(output_iterator<char*>(str), ios, '*', v); 706 std::string ex(str, iter.base()); 707 assert(ex == "0************************"); 708 assert(ios.width() == 0); 709 } 710 ios.width(25); 711 right(ios); 712 { 713 iter = f.put(output_iterator<char*>(str), ios, '*', v); 714 std::string ex(str, iter.base()); 715 assert(ex == "************************0"); 716 assert(ios.width() == 0); 717 } 718 ios.width(25); 719 internal(ios); 720 { 721 iter = f.put(output_iterator<char*>(str), ios, '*', v); 722 std::string ex(str, iter.base()); 723 assert(ex == "************************0"); 724 assert(ios.width() == 0); 725 } 726 } 727 } 728 showpoint(ios); 729 { 730 ios.imbue(lc); 731 { 732 ios.width(0); 733 { 734 iter = f.put(output_iterator<char*>(str), ios, '*', v); 735 std::string ex(str, iter.base()); 736 assert(ex == "0."); 737 assert(ios.width() == 0); 738 } 739 ios.width(25); 740 left(ios); 741 { 742 iter = f.put(output_iterator<char*>(str), ios, '*', v); 743 std::string ex(str, iter.base()); 744 assert(ex == "0.***********************"); 745 assert(ios.width() == 0); 746 } 747 ios.width(25); 748 right(ios); 749 { 750 iter = f.put(output_iterator<char*>(str), ios, '*', v); 751 std::string ex(str, iter.base()); 752 assert(ex == "***********************0."); 753 assert(ios.width() == 0); 754 } 755 ios.width(25); 756 internal(ios); 757 { 758 iter = f.put(output_iterator<char*>(str), ios, '*', v); 759 std::string ex(str, iter.base()); 760 assert(ex == "***********************0."); 761 assert(ios.width() == 0); 762 } 763 } 764 ios.imbue(lg); 765 { 766 ios.width(0); 767 { 768 iter = f.put(output_iterator<char*>(str), ios, '*', v); 769 std::string ex(str, iter.base()); 770 assert(ex == "0;"); 771 assert(ios.width() == 0); 772 } 773 ios.width(25); 774 left(ios); 775 { 776 iter = f.put(output_iterator<char*>(str), ios, '*', v); 777 std::string ex(str, iter.base()); 778 assert(ex == "0;***********************"); 779 assert(ios.width() == 0); 780 } 781 ios.width(25); 782 right(ios); 783 { 784 iter = f.put(output_iterator<char*>(str), ios, '*', v); 785 std::string ex(str, iter.base()); 786 assert(ex == "***********************0;"); 787 assert(ios.width() == 0); 788 } 789 ios.width(25); 790 internal(ios); 791 { 792 iter = f.put(output_iterator<char*>(str), ios, '*', v); 793 std::string ex(str, iter.base()); 794 assert(ex == "***********************0;"); 795 assert(ios.width() == 0); 796 } 797 } 798 } 799 } 800 showpos(ios); 801 { 802 noshowpoint(ios); 803 { 804 ios.imbue(lc); 805 { 806 ios.width(0); 807 { 808 iter = f.put(output_iterator<char*>(str), ios, '*', v); 809 std::string ex(str, iter.base()); 810 assert(ex == "+0"); 811 assert(ios.width() == 0); 812 } 813 ios.width(25); 814 left(ios); 815 { 816 iter = f.put(output_iterator<char*>(str), ios, '*', v); 817 std::string ex(str, iter.base()); 818 assert(ex == "+0***********************"); 819 assert(ios.width() == 0); 820 } 821 ios.width(25); 822 right(ios); 823 { 824 iter = f.put(output_iterator<char*>(str), ios, '*', v); 825 std::string ex(str, iter.base()); 826 assert(ex == "***********************+0"); 827 assert(ios.width() == 0); 828 } 829 ios.width(25); 830 internal(ios); 831 { 832 iter = f.put(output_iterator<char*>(str), ios, '*', v); 833 std::string ex(str, iter.base()); 834 assert(ex == "+***********************0"); 835 assert(ios.width() == 0); 836 } 837 } 838 ios.imbue(lg); 839 { 840 ios.width(0); 841 { 842 iter = f.put(output_iterator<char*>(str), ios, '*', v); 843 std::string ex(str, iter.base()); 844 assert(ex == "+0"); 845 assert(ios.width() == 0); 846 } 847 ios.width(25); 848 left(ios); 849 { 850 iter = f.put(output_iterator<char*>(str), ios, '*', v); 851 std::string ex(str, iter.base()); 852 assert(ex == "+0***********************"); 853 assert(ios.width() == 0); 854 } 855 ios.width(25); 856 right(ios); 857 { 858 iter = f.put(output_iterator<char*>(str), ios, '*', v); 859 std::string ex(str, iter.base()); 860 assert(ex == "***********************+0"); 861 assert(ios.width() == 0); 862 } 863 ios.width(25); 864 internal(ios); 865 { 866 iter = f.put(output_iterator<char*>(str), ios, '*', v); 867 std::string ex(str, iter.base()); 868 assert(ex == "+***********************0"); 869 assert(ios.width() == 0); 870 } 871 } 872 } 873 showpoint(ios); 874 { 875 ios.imbue(lc); 876 { 877 ios.width(0); 878 { 879 iter = f.put(output_iterator<char*>(str), ios, '*', v); 880 std::string ex(str, iter.base()); 881 assert(ex == "+0."); 882 assert(ios.width() == 0); 883 } 884 ios.width(25); 885 left(ios); 886 { 887 iter = f.put(output_iterator<char*>(str), ios, '*', v); 888 std::string ex(str, iter.base()); 889 assert(ex == "+0.**********************"); 890 assert(ios.width() == 0); 891 } 892 ios.width(25); 893 right(ios); 894 { 895 iter = f.put(output_iterator<char*>(str), ios, '*', v); 896 std::string ex(str, iter.base()); 897 assert(ex == "**********************+0."); 898 assert(ios.width() == 0); 899 } 900 ios.width(25); 901 internal(ios); 902 { 903 iter = f.put(output_iterator<char*>(str), ios, '*', v); 904 std::string ex(str, iter.base()); 905 assert(ex == "+**********************0."); 906 assert(ios.width() == 0); 907 } 908 } 909 ios.imbue(lg); 910 { 911 ios.width(0); 912 { 913 iter = f.put(output_iterator<char*>(str), ios, '*', v); 914 std::string ex(str, iter.base()); 915 assert(ex == "+0;"); 916 assert(ios.width() == 0); 917 } 918 ios.width(25); 919 left(ios); 920 { 921 iter = f.put(output_iterator<char*>(str), ios, '*', v); 922 std::string ex(str, iter.base()); 923 assert(ex == "+0;**********************"); 924 assert(ios.width() == 0); 925 } 926 ios.width(25); 927 right(ios); 928 { 929 iter = f.put(output_iterator<char*>(str), ios, '*', v); 930 std::string ex(str, iter.base()); 931 assert(ex == "**********************+0;"); 932 assert(ios.width() == 0); 933 } 934 ios.width(25); 935 internal(ios); 936 { 937 iter = f.put(output_iterator<char*>(str), ios, '*', v); 938 std::string ex(str, iter.base()); 939 assert(ex == "+**********************0;"); 940 assert(ios.width() == 0); 941 } 942 } 943 } 944 } 945 } 946 uppercase(ios); 947 { 948 noshowpos(ios); 949 { 950 noshowpoint(ios); 951 { 952 ios.imbue(lc); 953 { 954 ios.width(0); 955 { 956 iter = f.put(output_iterator<char*>(str), ios, '*', v); 957 std::string ex(str, iter.base()); 958 assert(ex == "0"); 959 assert(ios.width() == 0); 960 } 961 ios.width(25); 962 left(ios); 963 { 964 iter = f.put(output_iterator<char*>(str), ios, '*', v); 965 std::string ex(str, iter.base()); 966 assert(ex == "0************************"); 967 assert(ios.width() == 0); 968 } 969 ios.width(25); 970 right(ios); 971 { 972 iter = f.put(output_iterator<char*>(str), ios, '*', v); 973 std::string ex(str, iter.base()); 974 assert(ex == "************************0"); 975 assert(ios.width() == 0); 976 } 977 ios.width(25); 978 internal(ios); 979 { 980 iter = f.put(output_iterator<char*>(str), ios, '*', v); 981 std::string ex(str, iter.base()); 982 assert(ex == "************************0"); 983 assert(ios.width() == 0); 984 } 985 } 986 ios.imbue(lg); 987 { 988 ios.width(0); 989 { 990 iter = f.put(output_iterator<char*>(str), ios, '*', v); 991 std::string ex(str, iter.base()); 992 assert(ex == "0"); 993 assert(ios.width() == 0); 994 } 995 ios.width(25); 996 left(ios); 997 { 998 iter = f.put(output_iterator<char*>(str), ios, '*', v); 999 std::string ex(str, iter.base()); 1000 assert(ex == "0************************"); 1001 assert(ios.width() == 0); 1002 } 1003 ios.width(25); 1004 right(ios); 1005 { 1006 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1007 std::string ex(str, iter.base()); 1008 assert(ex == "************************0"); 1009 assert(ios.width() == 0); 1010 } 1011 ios.width(25); 1012 internal(ios); 1013 { 1014 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1015 std::string ex(str, iter.base()); 1016 assert(ex == "************************0"); 1017 assert(ios.width() == 0); 1018 } 1019 } 1020 } 1021 showpoint(ios); 1022 { 1023 ios.imbue(lc); 1024 { 1025 ios.width(0); 1026 { 1027 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1028 std::string ex(str, iter.base()); 1029 assert(ex == "0."); 1030 assert(ios.width() == 0); 1031 } 1032 ios.width(25); 1033 left(ios); 1034 { 1035 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1036 std::string ex(str, iter.base()); 1037 assert(ex == "0.***********************"); 1038 assert(ios.width() == 0); 1039 } 1040 ios.width(25); 1041 right(ios); 1042 { 1043 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1044 std::string ex(str, iter.base()); 1045 assert(ex == "***********************0."); 1046 assert(ios.width() == 0); 1047 } 1048 ios.width(25); 1049 internal(ios); 1050 { 1051 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1052 std::string ex(str, iter.base()); 1053 assert(ex == "***********************0."); 1054 assert(ios.width() == 0); 1055 } 1056 } 1057 ios.imbue(lg); 1058 { 1059 ios.width(0); 1060 { 1061 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1062 std::string ex(str, iter.base()); 1063 assert(ex == "0;"); 1064 assert(ios.width() == 0); 1065 } 1066 ios.width(25); 1067 left(ios); 1068 { 1069 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1070 std::string ex(str, iter.base()); 1071 assert(ex == "0;***********************"); 1072 assert(ios.width() == 0); 1073 } 1074 ios.width(25); 1075 right(ios); 1076 { 1077 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1078 std::string ex(str, iter.base()); 1079 assert(ex == "***********************0;"); 1080 assert(ios.width() == 0); 1081 } 1082 ios.width(25); 1083 internal(ios); 1084 { 1085 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1086 std::string ex(str, iter.base()); 1087 assert(ex == "***********************0;"); 1088 assert(ios.width() == 0); 1089 } 1090 } 1091 } 1092 } 1093 showpos(ios); 1094 { 1095 noshowpoint(ios); 1096 { 1097 ios.imbue(lc); 1098 { 1099 ios.width(0); 1100 { 1101 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1102 std::string ex(str, iter.base()); 1103 assert(ex == "+0"); 1104 assert(ios.width() == 0); 1105 } 1106 ios.width(25); 1107 left(ios); 1108 { 1109 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1110 std::string ex(str, iter.base()); 1111 assert(ex == "+0***********************"); 1112 assert(ios.width() == 0); 1113 } 1114 ios.width(25); 1115 right(ios); 1116 { 1117 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1118 std::string ex(str, iter.base()); 1119 assert(ex == "***********************+0"); 1120 assert(ios.width() == 0); 1121 } 1122 ios.width(25); 1123 internal(ios); 1124 { 1125 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1126 std::string ex(str, iter.base()); 1127 assert(ex == "+***********************0"); 1128 assert(ios.width() == 0); 1129 } 1130 } 1131 ios.imbue(lg); 1132 { 1133 ios.width(0); 1134 { 1135 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1136 std::string ex(str, iter.base()); 1137 assert(ex == "+0"); 1138 assert(ios.width() == 0); 1139 } 1140 ios.width(25); 1141 left(ios); 1142 { 1143 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1144 std::string ex(str, iter.base()); 1145 assert(ex == "+0***********************"); 1146 assert(ios.width() == 0); 1147 } 1148 ios.width(25); 1149 right(ios); 1150 { 1151 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1152 std::string ex(str, iter.base()); 1153 assert(ex == "***********************+0"); 1154 assert(ios.width() == 0); 1155 } 1156 ios.width(25); 1157 internal(ios); 1158 { 1159 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1160 std::string ex(str, iter.base()); 1161 assert(ex == "+***********************0"); 1162 assert(ios.width() == 0); 1163 } 1164 } 1165 } 1166 showpoint(ios); 1167 { 1168 ios.imbue(lc); 1169 { 1170 ios.width(0); 1171 { 1172 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1173 std::string ex(str, iter.base()); 1174 assert(ex == "+0."); 1175 assert(ios.width() == 0); 1176 } 1177 ios.width(25); 1178 left(ios); 1179 { 1180 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1181 std::string ex(str, iter.base()); 1182 assert(ex == "+0.**********************"); 1183 assert(ios.width() == 0); 1184 } 1185 ios.width(25); 1186 right(ios); 1187 { 1188 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1189 std::string ex(str, iter.base()); 1190 assert(ex == "**********************+0."); 1191 assert(ios.width() == 0); 1192 } 1193 ios.width(25); 1194 internal(ios); 1195 { 1196 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1197 std::string ex(str, iter.base()); 1198 assert(ex == "+**********************0."); 1199 assert(ios.width() == 0); 1200 } 1201 } 1202 ios.imbue(lg); 1203 { 1204 ios.width(0); 1205 { 1206 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1207 std::string ex(str, iter.base()); 1208 assert(ex == "+0;"); 1209 assert(ios.width() == 0); 1210 } 1211 ios.width(25); 1212 left(ios); 1213 { 1214 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1215 std::string ex(str, iter.base()); 1216 assert(ex == "+0;**********************"); 1217 assert(ios.width() == 0); 1218 } 1219 ios.width(25); 1220 right(ios); 1221 { 1222 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1223 std::string ex(str, iter.base()); 1224 assert(ex == "**********************+0;"); 1225 assert(ios.width() == 0); 1226 } 1227 ios.width(25); 1228 internal(ios); 1229 { 1230 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1231 std::string ex(str, iter.base()); 1232 assert(ex == "+**********************0;"); 1233 assert(ios.width() == 0); 1234 } 1235 } 1236 } 1237 } 1238 } 1239 } 1240 ios.precision(6); 1241 { 1242 nouppercase(ios); 1243 { 1244 noshowpos(ios); 1245 { 1246 noshowpoint(ios); 1247 { 1248 ios.imbue(lc); 1249 { 1250 ios.width(0); 1251 { 1252 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1253 std::string ex(str, iter.base()); 1254 assert(ex == "0"); 1255 assert(ios.width() == 0); 1256 } 1257 ios.width(25); 1258 left(ios); 1259 { 1260 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1261 std::string ex(str, iter.base()); 1262 assert(ex == "0************************"); 1263 assert(ios.width() == 0); 1264 } 1265 ios.width(25); 1266 right(ios); 1267 { 1268 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1269 std::string ex(str, iter.base()); 1270 assert(ex == "************************0"); 1271 assert(ios.width() == 0); 1272 } 1273 ios.width(25); 1274 internal(ios); 1275 { 1276 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1277 std::string ex(str, iter.base()); 1278 assert(ex == "************************0"); 1279 assert(ios.width() == 0); 1280 } 1281 } 1282 ios.imbue(lg); 1283 { 1284 ios.width(0); 1285 { 1286 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1287 std::string ex(str, iter.base()); 1288 assert(ex == "0"); 1289 assert(ios.width() == 0); 1290 } 1291 ios.width(25); 1292 left(ios); 1293 { 1294 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1295 std::string ex(str, iter.base()); 1296 assert(ex == "0************************"); 1297 assert(ios.width() == 0); 1298 } 1299 ios.width(25); 1300 right(ios); 1301 { 1302 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1303 std::string ex(str, iter.base()); 1304 assert(ex == "************************0"); 1305 assert(ios.width() == 0); 1306 } 1307 ios.width(25); 1308 internal(ios); 1309 { 1310 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1311 std::string ex(str, iter.base()); 1312 assert(ex == "************************0"); 1313 assert(ios.width() == 0); 1314 } 1315 } 1316 } 1317 showpoint(ios); 1318 { 1319 ios.imbue(lc); 1320 { 1321 ios.width(0); 1322 { 1323 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1324 std::string ex(str, iter.base()); 1325 assert(ex == "0.00000"); 1326 assert(ios.width() == 0); 1327 } 1328 ios.width(25); 1329 left(ios); 1330 { 1331 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1332 std::string ex(str, iter.base()); 1333 assert(ex == "0.00000******************"); 1334 assert(ios.width() == 0); 1335 } 1336 ios.width(25); 1337 right(ios); 1338 { 1339 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1340 std::string ex(str, iter.base()); 1341 assert(ex == "******************0.00000"); 1342 assert(ios.width() == 0); 1343 } 1344 ios.width(25); 1345 internal(ios); 1346 { 1347 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1348 std::string ex(str, iter.base()); 1349 assert(ex == "******************0.00000"); 1350 assert(ios.width() == 0); 1351 } 1352 } 1353 ios.imbue(lg); 1354 { 1355 ios.width(0); 1356 { 1357 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1358 std::string ex(str, iter.base()); 1359 assert(ex == "0;00000"); 1360 assert(ios.width() == 0); 1361 } 1362 ios.width(25); 1363 left(ios); 1364 { 1365 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1366 std::string ex(str, iter.base()); 1367 assert(ex == "0;00000******************"); 1368 assert(ios.width() == 0); 1369 } 1370 ios.width(25); 1371 right(ios); 1372 { 1373 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1374 std::string ex(str, iter.base()); 1375 assert(ex == "******************0;00000"); 1376 assert(ios.width() == 0); 1377 } 1378 ios.width(25); 1379 internal(ios); 1380 { 1381 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1382 std::string ex(str, iter.base()); 1383 assert(ex == "******************0;00000"); 1384 assert(ios.width() == 0); 1385 } 1386 } 1387 } 1388 } 1389 showpos(ios); 1390 { 1391 noshowpoint(ios); 1392 { 1393 ios.imbue(lc); 1394 { 1395 ios.width(0); 1396 { 1397 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1398 std::string ex(str, iter.base()); 1399 assert(ex == "+0"); 1400 assert(ios.width() == 0); 1401 } 1402 ios.width(25); 1403 left(ios); 1404 { 1405 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1406 std::string ex(str, iter.base()); 1407 assert(ex == "+0***********************"); 1408 assert(ios.width() == 0); 1409 } 1410 ios.width(25); 1411 right(ios); 1412 { 1413 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1414 std::string ex(str, iter.base()); 1415 assert(ex == "***********************+0"); 1416 assert(ios.width() == 0); 1417 } 1418 ios.width(25); 1419 internal(ios); 1420 { 1421 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1422 std::string ex(str, iter.base()); 1423 assert(ex == "+***********************0"); 1424 assert(ios.width() == 0); 1425 } 1426 } 1427 ios.imbue(lg); 1428 { 1429 ios.width(0); 1430 { 1431 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1432 std::string ex(str, iter.base()); 1433 assert(ex == "+0"); 1434 assert(ios.width() == 0); 1435 } 1436 ios.width(25); 1437 left(ios); 1438 { 1439 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1440 std::string ex(str, iter.base()); 1441 assert(ex == "+0***********************"); 1442 assert(ios.width() == 0); 1443 } 1444 ios.width(25); 1445 right(ios); 1446 { 1447 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1448 std::string ex(str, iter.base()); 1449 assert(ex == "***********************+0"); 1450 assert(ios.width() == 0); 1451 } 1452 ios.width(25); 1453 internal(ios); 1454 { 1455 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1456 std::string ex(str, iter.base()); 1457 assert(ex == "+***********************0"); 1458 assert(ios.width() == 0); 1459 } 1460 } 1461 } 1462 showpoint(ios); 1463 { 1464 ios.imbue(lc); 1465 { 1466 ios.width(0); 1467 { 1468 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1469 std::string ex(str, iter.base()); 1470 assert(ex == "+0.00000"); 1471 assert(ios.width() == 0); 1472 } 1473 ios.width(25); 1474 left(ios); 1475 { 1476 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1477 std::string ex(str, iter.base()); 1478 assert(ex == "+0.00000*****************"); 1479 assert(ios.width() == 0); 1480 } 1481 ios.width(25); 1482 right(ios); 1483 { 1484 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1485 std::string ex(str, iter.base()); 1486 assert(ex == "*****************+0.00000"); 1487 assert(ios.width() == 0); 1488 } 1489 ios.width(25); 1490 internal(ios); 1491 { 1492 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1493 std::string ex(str, iter.base()); 1494 assert(ex == "+*****************0.00000"); 1495 assert(ios.width() == 0); 1496 } 1497 } 1498 ios.imbue(lg); 1499 { 1500 ios.width(0); 1501 { 1502 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1503 std::string ex(str, iter.base()); 1504 assert(ex == "+0;00000"); 1505 assert(ios.width() == 0); 1506 } 1507 ios.width(25); 1508 left(ios); 1509 { 1510 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1511 std::string ex(str, iter.base()); 1512 assert(ex == "+0;00000*****************"); 1513 assert(ios.width() == 0); 1514 } 1515 ios.width(25); 1516 right(ios); 1517 { 1518 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1519 std::string ex(str, iter.base()); 1520 assert(ex == "*****************+0;00000"); 1521 assert(ios.width() == 0); 1522 } 1523 ios.width(25); 1524 internal(ios); 1525 { 1526 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1527 std::string ex(str, iter.base()); 1528 assert(ex == "+*****************0;00000"); 1529 assert(ios.width() == 0); 1530 } 1531 } 1532 } 1533 } 1534 } 1535 uppercase(ios); 1536 { 1537 noshowpos(ios); 1538 { 1539 noshowpoint(ios); 1540 { 1541 ios.imbue(lc); 1542 { 1543 ios.width(0); 1544 { 1545 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1546 std::string ex(str, iter.base()); 1547 assert(ex == "0"); 1548 assert(ios.width() == 0); 1549 } 1550 ios.width(25); 1551 left(ios); 1552 { 1553 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1554 std::string ex(str, iter.base()); 1555 assert(ex == "0************************"); 1556 assert(ios.width() == 0); 1557 } 1558 ios.width(25); 1559 right(ios); 1560 { 1561 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1562 std::string ex(str, iter.base()); 1563 assert(ex == "************************0"); 1564 assert(ios.width() == 0); 1565 } 1566 ios.width(25); 1567 internal(ios); 1568 { 1569 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1570 std::string ex(str, iter.base()); 1571 assert(ex == "************************0"); 1572 assert(ios.width() == 0); 1573 } 1574 } 1575 ios.imbue(lg); 1576 { 1577 ios.width(0); 1578 { 1579 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1580 std::string ex(str, iter.base()); 1581 assert(ex == "0"); 1582 assert(ios.width() == 0); 1583 } 1584 ios.width(25); 1585 left(ios); 1586 { 1587 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1588 std::string ex(str, iter.base()); 1589 assert(ex == "0************************"); 1590 assert(ios.width() == 0); 1591 } 1592 ios.width(25); 1593 right(ios); 1594 { 1595 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1596 std::string ex(str, iter.base()); 1597 assert(ex == "************************0"); 1598 assert(ios.width() == 0); 1599 } 1600 ios.width(25); 1601 internal(ios); 1602 { 1603 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1604 std::string ex(str, iter.base()); 1605 assert(ex == "************************0"); 1606 assert(ios.width() == 0); 1607 } 1608 } 1609 } 1610 showpoint(ios); 1611 { 1612 ios.imbue(lc); 1613 { 1614 ios.width(0); 1615 { 1616 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1617 std::string ex(str, iter.base()); 1618 assert(ex == "0.00000"); 1619 assert(ios.width() == 0); 1620 } 1621 ios.width(25); 1622 left(ios); 1623 { 1624 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1625 std::string ex(str, iter.base()); 1626 assert(ex == "0.00000******************"); 1627 assert(ios.width() == 0); 1628 } 1629 ios.width(25); 1630 right(ios); 1631 { 1632 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1633 std::string ex(str, iter.base()); 1634 assert(ex == "******************0.00000"); 1635 assert(ios.width() == 0); 1636 } 1637 ios.width(25); 1638 internal(ios); 1639 { 1640 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1641 std::string ex(str, iter.base()); 1642 assert(ex == "******************0.00000"); 1643 assert(ios.width() == 0); 1644 } 1645 } 1646 ios.imbue(lg); 1647 { 1648 ios.width(0); 1649 { 1650 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1651 std::string ex(str, iter.base()); 1652 assert(ex == "0;00000"); 1653 assert(ios.width() == 0); 1654 } 1655 ios.width(25); 1656 left(ios); 1657 { 1658 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1659 std::string ex(str, iter.base()); 1660 assert(ex == "0;00000******************"); 1661 assert(ios.width() == 0); 1662 } 1663 ios.width(25); 1664 right(ios); 1665 { 1666 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1667 std::string ex(str, iter.base()); 1668 assert(ex == "******************0;00000"); 1669 assert(ios.width() == 0); 1670 } 1671 ios.width(25); 1672 internal(ios); 1673 { 1674 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1675 std::string ex(str, iter.base()); 1676 assert(ex == "******************0;00000"); 1677 assert(ios.width() == 0); 1678 } 1679 } 1680 } 1681 } 1682 showpos(ios); 1683 { 1684 noshowpoint(ios); 1685 { 1686 ios.imbue(lc); 1687 { 1688 ios.width(0); 1689 { 1690 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1691 std::string ex(str, iter.base()); 1692 assert(ex == "+0"); 1693 assert(ios.width() == 0); 1694 } 1695 ios.width(25); 1696 left(ios); 1697 { 1698 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1699 std::string ex(str, iter.base()); 1700 assert(ex == "+0***********************"); 1701 assert(ios.width() == 0); 1702 } 1703 ios.width(25); 1704 right(ios); 1705 { 1706 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1707 std::string ex(str, iter.base()); 1708 assert(ex == "***********************+0"); 1709 assert(ios.width() == 0); 1710 } 1711 ios.width(25); 1712 internal(ios); 1713 { 1714 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1715 std::string ex(str, iter.base()); 1716 assert(ex == "+***********************0"); 1717 assert(ios.width() == 0); 1718 } 1719 } 1720 ios.imbue(lg); 1721 { 1722 ios.width(0); 1723 { 1724 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1725 std::string ex(str, iter.base()); 1726 assert(ex == "+0"); 1727 assert(ios.width() == 0); 1728 } 1729 ios.width(25); 1730 left(ios); 1731 { 1732 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1733 std::string ex(str, iter.base()); 1734 assert(ex == "+0***********************"); 1735 assert(ios.width() == 0); 1736 } 1737 ios.width(25); 1738 right(ios); 1739 { 1740 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1741 std::string ex(str, iter.base()); 1742 assert(ex == "***********************+0"); 1743 assert(ios.width() == 0); 1744 } 1745 ios.width(25); 1746 internal(ios); 1747 { 1748 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1749 std::string ex(str, iter.base()); 1750 assert(ex == "+***********************0"); 1751 assert(ios.width() == 0); 1752 } 1753 } 1754 } 1755 showpoint(ios); 1756 { 1757 ios.imbue(lc); 1758 { 1759 ios.width(0); 1760 { 1761 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1762 std::string ex(str, iter.base()); 1763 assert(ex == "+0.00000"); 1764 assert(ios.width() == 0); 1765 } 1766 ios.width(25); 1767 left(ios); 1768 { 1769 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1770 std::string ex(str, iter.base()); 1771 assert(ex == "+0.00000*****************"); 1772 assert(ios.width() == 0); 1773 } 1774 ios.width(25); 1775 right(ios); 1776 { 1777 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1778 std::string ex(str, iter.base()); 1779 assert(ex == "*****************+0.00000"); 1780 assert(ios.width() == 0); 1781 } 1782 ios.width(25); 1783 internal(ios); 1784 { 1785 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1786 std::string ex(str, iter.base()); 1787 assert(ex == "+*****************0.00000"); 1788 assert(ios.width() == 0); 1789 } 1790 } 1791 ios.imbue(lg); 1792 { 1793 ios.width(0); 1794 { 1795 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1796 std::string ex(str, iter.base()); 1797 assert(ex == "+0;00000"); 1798 assert(ios.width() == 0); 1799 } 1800 ios.width(25); 1801 left(ios); 1802 { 1803 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1804 std::string ex(str, iter.base()); 1805 assert(ex == "+0;00000*****************"); 1806 assert(ios.width() == 0); 1807 } 1808 ios.width(25); 1809 right(ios); 1810 { 1811 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1812 std::string ex(str, iter.base()); 1813 assert(ex == "*****************+0;00000"); 1814 assert(ios.width() == 0); 1815 } 1816 ios.width(25); 1817 internal(ios); 1818 { 1819 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1820 std::string ex(str, iter.base()); 1821 assert(ex == "+*****************0;00000"); 1822 assert(ios.width() == 0); 1823 } 1824 } 1825 } 1826 } 1827 } 1828 } 1829 ios.precision(16); 1830 { 1831 nouppercase(ios); 1832 { 1833 noshowpos(ios); 1834 { 1835 noshowpoint(ios); 1836 { 1837 ios.imbue(lc); 1838 { 1839 ios.width(0); 1840 { 1841 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1842 std::string ex(str, iter.base()); 1843 assert(ex == "0"); 1844 assert(ios.width() == 0); 1845 } 1846 ios.width(25); 1847 left(ios); 1848 { 1849 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1850 std::string ex(str, iter.base()); 1851 assert(ex == "0************************"); 1852 assert(ios.width() == 0); 1853 } 1854 ios.width(25); 1855 right(ios); 1856 { 1857 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1858 std::string ex(str, iter.base()); 1859 assert(ex == "************************0"); 1860 assert(ios.width() == 0); 1861 } 1862 ios.width(25); 1863 internal(ios); 1864 { 1865 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1866 std::string ex(str, iter.base()); 1867 assert(ex == "************************0"); 1868 assert(ios.width() == 0); 1869 } 1870 } 1871 ios.imbue(lg); 1872 { 1873 ios.width(0); 1874 { 1875 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1876 std::string ex(str, iter.base()); 1877 assert(ex == "0"); 1878 assert(ios.width() == 0); 1879 } 1880 ios.width(25); 1881 left(ios); 1882 { 1883 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1884 std::string ex(str, iter.base()); 1885 assert(ex == "0************************"); 1886 assert(ios.width() == 0); 1887 } 1888 ios.width(25); 1889 right(ios); 1890 { 1891 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1892 std::string ex(str, iter.base()); 1893 assert(ex == "************************0"); 1894 assert(ios.width() == 0); 1895 } 1896 ios.width(25); 1897 internal(ios); 1898 { 1899 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1900 std::string ex(str, iter.base()); 1901 assert(ex == "************************0"); 1902 assert(ios.width() == 0); 1903 } 1904 } 1905 } 1906 showpoint(ios); 1907 { 1908 ios.imbue(lc); 1909 { 1910 ios.width(0); 1911 { 1912 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1913 std::string ex(str, iter.base()); 1914 assert(ex == "0.000000000000000"); 1915 assert(ios.width() == 0); 1916 } 1917 ios.width(25); 1918 left(ios); 1919 { 1920 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1921 std::string ex(str, iter.base()); 1922 assert(ex == "0.000000000000000********"); 1923 assert(ios.width() == 0); 1924 } 1925 ios.width(25); 1926 right(ios); 1927 { 1928 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1929 std::string ex(str, iter.base()); 1930 assert(ex == "********0.000000000000000"); 1931 assert(ios.width() == 0); 1932 } 1933 ios.width(25); 1934 internal(ios); 1935 { 1936 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1937 std::string ex(str, iter.base()); 1938 assert(ex == "********0.000000000000000"); 1939 assert(ios.width() == 0); 1940 } 1941 } 1942 ios.imbue(lg); 1943 { 1944 ios.width(0); 1945 { 1946 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1947 std::string ex(str, iter.base()); 1948 assert(ex == "0;000000000000000"); 1949 assert(ios.width() == 0); 1950 } 1951 ios.width(25); 1952 left(ios); 1953 { 1954 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1955 std::string ex(str, iter.base()); 1956 assert(ex == "0;000000000000000********"); 1957 assert(ios.width() == 0); 1958 } 1959 ios.width(25); 1960 right(ios); 1961 { 1962 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1963 std::string ex(str, iter.base()); 1964 assert(ex == "********0;000000000000000"); 1965 assert(ios.width() == 0); 1966 } 1967 ios.width(25); 1968 internal(ios); 1969 { 1970 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1971 std::string ex(str, iter.base()); 1972 assert(ex == "********0;000000000000000"); 1973 assert(ios.width() == 0); 1974 } 1975 } 1976 } 1977 } 1978 showpos(ios); 1979 { 1980 noshowpoint(ios); 1981 { 1982 ios.imbue(lc); 1983 { 1984 ios.width(0); 1985 { 1986 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1987 std::string ex(str, iter.base()); 1988 assert(ex == "+0"); 1989 assert(ios.width() == 0); 1990 } 1991 ios.width(25); 1992 left(ios); 1993 { 1994 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1995 std::string ex(str, iter.base()); 1996 assert(ex == "+0***********************"); 1997 assert(ios.width() == 0); 1998 } 1999 ios.width(25); 2000 right(ios); 2001 { 2002 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2003 std::string ex(str, iter.base()); 2004 assert(ex == "***********************+0"); 2005 assert(ios.width() == 0); 2006 } 2007 ios.width(25); 2008 internal(ios); 2009 { 2010 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2011 std::string ex(str, iter.base()); 2012 assert(ex == "+***********************0"); 2013 assert(ios.width() == 0); 2014 } 2015 } 2016 ios.imbue(lg); 2017 { 2018 ios.width(0); 2019 { 2020 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2021 std::string ex(str, iter.base()); 2022 assert(ex == "+0"); 2023 assert(ios.width() == 0); 2024 } 2025 ios.width(25); 2026 left(ios); 2027 { 2028 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2029 std::string ex(str, iter.base()); 2030 assert(ex == "+0***********************"); 2031 assert(ios.width() == 0); 2032 } 2033 ios.width(25); 2034 right(ios); 2035 { 2036 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2037 std::string ex(str, iter.base()); 2038 assert(ex == "***********************+0"); 2039 assert(ios.width() == 0); 2040 } 2041 ios.width(25); 2042 internal(ios); 2043 { 2044 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2045 std::string ex(str, iter.base()); 2046 assert(ex == "+***********************0"); 2047 assert(ios.width() == 0); 2048 } 2049 } 2050 } 2051 showpoint(ios); 2052 { 2053 ios.imbue(lc); 2054 { 2055 ios.width(0); 2056 { 2057 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2058 std::string ex(str, iter.base()); 2059 assert(ex == "+0.000000000000000"); 2060 assert(ios.width() == 0); 2061 } 2062 ios.width(25); 2063 left(ios); 2064 { 2065 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2066 std::string ex(str, iter.base()); 2067 assert(ex == "+0.000000000000000*******"); 2068 assert(ios.width() == 0); 2069 } 2070 ios.width(25); 2071 right(ios); 2072 { 2073 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2074 std::string ex(str, iter.base()); 2075 assert(ex == "*******+0.000000000000000"); 2076 assert(ios.width() == 0); 2077 } 2078 ios.width(25); 2079 internal(ios); 2080 { 2081 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2082 std::string ex(str, iter.base()); 2083 assert(ex == "+*******0.000000000000000"); 2084 assert(ios.width() == 0); 2085 } 2086 } 2087 ios.imbue(lg); 2088 { 2089 ios.width(0); 2090 { 2091 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2092 std::string ex(str, iter.base()); 2093 assert(ex == "+0;000000000000000"); 2094 assert(ios.width() == 0); 2095 } 2096 ios.width(25); 2097 left(ios); 2098 { 2099 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2100 std::string ex(str, iter.base()); 2101 assert(ex == "+0;000000000000000*******"); 2102 assert(ios.width() == 0); 2103 } 2104 ios.width(25); 2105 right(ios); 2106 { 2107 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2108 std::string ex(str, iter.base()); 2109 assert(ex == "*******+0;000000000000000"); 2110 assert(ios.width() == 0); 2111 } 2112 ios.width(25); 2113 internal(ios); 2114 { 2115 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2116 std::string ex(str, iter.base()); 2117 assert(ex == "+*******0;000000000000000"); 2118 assert(ios.width() == 0); 2119 } 2120 } 2121 } 2122 } 2123 } 2124 uppercase(ios); 2125 { 2126 noshowpos(ios); 2127 { 2128 noshowpoint(ios); 2129 { 2130 ios.imbue(lc); 2131 { 2132 ios.width(0); 2133 { 2134 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2135 std::string ex(str, iter.base()); 2136 assert(ex == "0"); 2137 assert(ios.width() == 0); 2138 } 2139 ios.width(25); 2140 left(ios); 2141 { 2142 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2143 std::string ex(str, iter.base()); 2144 assert(ex == "0************************"); 2145 assert(ios.width() == 0); 2146 } 2147 ios.width(25); 2148 right(ios); 2149 { 2150 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2151 std::string ex(str, iter.base()); 2152 assert(ex == "************************0"); 2153 assert(ios.width() == 0); 2154 } 2155 ios.width(25); 2156 internal(ios); 2157 { 2158 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2159 std::string ex(str, iter.base()); 2160 assert(ex == "************************0"); 2161 assert(ios.width() == 0); 2162 } 2163 } 2164 ios.imbue(lg); 2165 { 2166 ios.width(0); 2167 { 2168 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2169 std::string ex(str, iter.base()); 2170 assert(ex == "0"); 2171 assert(ios.width() == 0); 2172 } 2173 ios.width(25); 2174 left(ios); 2175 { 2176 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2177 std::string ex(str, iter.base()); 2178 assert(ex == "0************************"); 2179 assert(ios.width() == 0); 2180 } 2181 ios.width(25); 2182 right(ios); 2183 { 2184 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2185 std::string ex(str, iter.base()); 2186 assert(ex == "************************0"); 2187 assert(ios.width() == 0); 2188 } 2189 ios.width(25); 2190 internal(ios); 2191 { 2192 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2193 std::string ex(str, iter.base()); 2194 assert(ex == "************************0"); 2195 assert(ios.width() == 0); 2196 } 2197 } 2198 } 2199 showpoint(ios); 2200 { 2201 ios.imbue(lc); 2202 { 2203 ios.width(0); 2204 { 2205 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2206 std::string ex(str, iter.base()); 2207 assert(ex == "0.000000000000000"); 2208 assert(ios.width() == 0); 2209 } 2210 ios.width(25); 2211 left(ios); 2212 { 2213 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2214 std::string ex(str, iter.base()); 2215 assert(ex == "0.000000000000000********"); 2216 assert(ios.width() == 0); 2217 } 2218 ios.width(25); 2219 right(ios); 2220 { 2221 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2222 std::string ex(str, iter.base()); 2223 assert(ex == "********0.000000000000000"); 2224 assert(ios.width() == 0); 2225 } 2226 ios.width(25); 2227 internal(ios); 2228 { 2229 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2230 std::string ex(str, iter.base()); 2231 assert(ex == "********0.000000000000000"); 2232 assert(ios.width() == 0); 2233 } 2234 } 2235 ios.imbue(lg); 2236 { 2237 ios.width(0); 2238 { 2239 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2240 std::string ex(str, iter.base()); 2241 assert(ex == "0;000000000000000"); 2242 assert(ios.width() == 0); 2243 } 2244 ios.width(25); 2245 left(ios); 2246 { 2247 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2248 std::string ex(str, iter.base()); 2249 assert(ex == "0;000000000000000********"); 2250 assert(ios.width() == 0); 2251 } 2252 ios.width(25); 2253 right(ios); 2254 { 2255 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2256 std::string ex(str, iter.base()); 2257 assert(ex == "********0;000000000000000"); 2258 assert(ios.width() == 0); 2259 } 2260 ios.width(25); 2261 internal(ios); 2262 { 2263 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2264 std::string ex(str, iter.base()); 2265 assert(ex == "********0;000000000000000"); 2266 assert(ios.width() == 0); 2267 } 2268 } 2269 } 2270 } 2271 showpos(ios); 2272 { 2273 noshowpoint(ios); 2274 { 2275 ios.imbue(lc); 2276 { 2277 ios.width(0); 2278 { 2279 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2280 std::string ex(str, iter.base()); 2281 assert(ex == "+0"); 2282 assert(ios.width() == 0); 2283 } 2284 ios.width(25); 2285 left(ios); 2286 { 2287 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2288 std::string ex(str, iter.base()); 2289 assert(ex == "+0***********************"); 2290 assert(ios.width() == 0); 2291 } 2292 ios.width(25); 2293 right(ios); 2294 { 2295 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2296 std::string ex(str, iter.base()); 2297 assert(ex == "***********************+0"); 2298 assert(ios.width() == 0); 2299 } 2300 ios.width(25); 2301 internal(ios); 2302 { 2303 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2304 std::string ex(str, iter.base()); 2305 assert(ex == "+***********************0"); 2306 assert(ios.width() == 0); 2307 } 2308 } 2309 ios.imbue(lg); 2310 { 2311 ios.width(0); 2312 { 2313 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2314 std::string ex(str, iter.base()); 2315 assert(ex == "+0"); 2316 assert(ios.width() == 0); 2317 } 2318 ios.width(25); 2319 left(ios); 2320 { 2321 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2322 std::string ex(str, iter.base()); 2323 assert(ex == "+0***********************"); 2324 assert(ios.width() == 0); 2325 } 2326 ios.width(25); 2327 right(ios); 2328 { 2329 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2330 std::string ex(str, iter.base()); 2331 assert(ex == "***********************+0"); 2332 assert(ios.width() == 0); 2333 } 2334 ios.width(25); 2335 internal(ios); 2336 { 2337 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2338 std::string ex(str, iter.base()); 2339 assert(ex == "+***********************0"); 2340 assert(ios.width() == 0); 2341 } 2342 } 2343 } 2344 showpoint(ios); 2345 { 2346 ios.imbue(lc); 2347 { 2348 ios.width(0); 2349 { 2350 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2351 std::string ex(str, iter.base()); 2352 assert(ex == "+0.000000000000000"); 2353 assert(ios.width() == 0); 2354 } 2355 ios.width(25); 2356 left(ios); 2357 { 2358 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2359 std::string ex(str, iter.base()); 2360 assert(ex == "+0.000000000000000*******"); 2361 assert(ios.width() == 0); 2362 } 2363 ios.width(25); 2364 right(ios); 2365 { 2366 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2367 std::string ex(str, iter.base()); 2368 assert(ex == "*******+0.000000000000000"); 2369 assert(ios.width() == 0); 2370 } 2371 ios.width(25); 2372 internal(ios); 2373 { 2374 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2375 std::string ex(str, iter.base()); 2376 assert(ex == "+*******0.000000000000000"); 2377 assert(ios.width() == 0); 2378 } 2379 } 2380 ios.imbue(lg); 2381 { 2382 ios.width(0); 2383 { 2384 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2385 std::string ex(str, iter.base()); 2386 assert(ex == "+0;000000000000000"); 2387 assert(ios.width() == 0); 2388 } 2389 ios.width(25); 2390 left(ios); 2391 { 2392 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2393 std::string ex(str, iter.base()); 2394 assert(ex == "+0;000000000000000*******"); 2395 assert(ios.width() == 0); 2396 } 2397 ios.width(25); 2398 right(ios); 2399 { 2400 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2401 std::string ex(str, iter.base()); 2402 assert(ex == "*******+0;000000000000000"); 2403 assert(ios.width() == 0); 2404 } 2405 ios.width(25); 2406 internal(ios); 2407 { 2408 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2409 std::string ex(str, iter.base()); 2410 assert(ex == "+*******0;000000000000000"); 2411 assert(ios.width() == 0); 2412 } 2413 } 2414 } 2415 } 2416 } 2417 } 2418 ios.precision(60); 2419 { 2420 nouppercase(ios); 2421 { 2422 noshowpos(ios); 2423 { 2424 noshowpoint(ios); 2425 { 2426 ios.imbue(lc); 2427 { 2428 ios.width(0); 2429 { 2430 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2431 std::string ex(str, iter.base()); 2432 assert(ex == "0"); 2433 assert(ios.width() == 0); 2434 } 2435 ios.width(25); 2436 left(ios); 2437 { 2438 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2439 std::string ex(str, iter.base()); 2440 assert(ex == "0************************"); 2441 assert(ios.width() == 0); 2442 } 2443 ios.width(25); 2444 right(ios); 2445 { 2446 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2447 std::string ex(str, iter.base()); 2448 assert(ex == "************************0"); 2449 assert(ios.width() == 0); 2450 } 2451 ios.width(25); 2452 internal(ios); 2453 { 2454 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2455 std::string ex(str, iter.base()); 2456 assert(ex == "************************0"); 2457 assert(ios.width() == 0); 2458 } 2459 } 2460 ios.imbue(lg); 2461 { 2462 ios.width(0); 2463 { 2464 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2465 std::string ex(str, iter.base()); 2466 assert(ex == "0"); 2467 assert(ios.width() == 0); 2468 } 2469 ios.width(25); 2470 left(ios); 2471 { 2472 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2473 std::string ex(str, iter.base()); 2474 assert(ex == "0************************"); 2475 assert(ios.width() == 0); 2476 } 2477 ios.width(25); 2478 right(ios); 2479 { 2480 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2481 std::string ex(str, iter.base()); 2482 assert(ex == "************************0"); 2483 assert(ios.width() == 0); 2484 } 2485 ios.width(25); 2486 internal(ios); 2487 { 2488 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2489 std::string ex(str, iter.base()); 2490 assert(ex == "************************0"); 2491 assert(ios.width() == 0); 2492 } 2493 } 2494 } 2495 showpoint(ios); 2496 { 2497 ios.imbue(lc); 2498 { 2499 ios.width(0); 2500 { 2501 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2502 std::string ex(str, iter.base()); 2503 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2504 assert(ios.width() == 0); 2505 } 2506 ios.width(25); 2507 left(ios); 2508 { 2509 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2510 std::string ex(str, iter.base()); 2511 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2512 assert(ios.width() == 0); 2513 } 2514 ios.width(25); 2515 right(ios); 2516 { 2517 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2518 std::string ex(str, iter.base()); 2519 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2520 assert(ios.width() == 0); 2521 } 2522 ios.width(25); 2523 internal(ios); 2524 { 2525 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2526 std::string ex(str, iter.base()); 2527 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2528 assert(ios.width() == 0); 2529 } 2530 } 2531 ios.imbue(lg); 2532 { 2533 ios.width(0); 2534 { 2535 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2536 std::string ex(str, iter.base()); 2537 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2538 assert(ios.width() == 0); 2539 } 2540 ios.width(25); 2541 left(ios); 2542 { 2543 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2544 std::string ex(str, iter.base()); 2545 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2546 assert(ios.width() == 0); 2547 } 2548 ios.width(25); 2549 right(ios); 2550 { 2551 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2552 std::string ex(str, iter.base()); 2553 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2554 assert(ios.width() == 0); 2555 } 2556 ios.width(25); 2557 internal(ios); 2558 { 2559 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2560 std::string ex(str, iter.base()); 2561 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2562 assert(ios.width() == 0); 2563 } 2564 } 2565 } 2566 } 2567 showpos(ios); 2568 { 2569 noshowpoint(ios); 2570 { 2571 ios.imbue(lc); 2572 { 2573 ios.width(0); 2574 { 2575 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2576 std::string ex(str, iter.base()); 2577 assert(ex == "+0"); 2578 assert(ios.width() == 0); 2579 } 2580 ios.width(25); 2581 left(ios); 2582 { 2583 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2584 std::string ex(str, iter.base()); 2585 assert(ex == "+0***********************"); 2586 assert(ios.width() == 0); 2587 } 2588 ios.width(25); 2589 right(ios); 2590 { 2591 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2592 std::string ex(str, iter.base()); 2593 assert(ex == "***********************+0"); 2594 assert(ios.width() == 0); 2595 } 2596 ios.width(25); 2597 internal(ios); 2598 { 2599 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2600 std::string ex(str, iter.base()); 2601 assert(ex == "+***********************0"); 2602 assert(ios.width() == 0); 2603 } 2604 } 2605 ios.imbue(lg); 2606 { 2607 ios.width(0); 2608 { 2609 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2610 std::string ex(str, iter.base()); 2611 assert(ex == "+0"); 2612 assert(ios.width() == 0); 2613 } 2614 ios.width(25); 2615 left(ios); 2616 { 2617 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2618 std::string ex(str, iter.base()); 2619 assert(ex == "+0***********************"); 2620 assert(ios.width() == 0); 2621 } 2622 ios.width(25); 2623 right(ios); 2624 { 2625 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2626 std::string ex(str, iter.base()); 2627 assert(ex == "***********************+0"); 2628 assert(ios.width() == 0); 2629 } 2630 ios.width(25); 2631 internal(ios); 2632 { 2633 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2634 std::string ex(str, iter.base()); 2635 assert(ex == "+***********************0"); 2636 assert(ios.width() == 0); 2637 } 2638 } 2639 } 2640 showpoint(ios); 2641 { 2642 ios.imbue(lc); 2643 { 2644 ios.width(0); 2645 { 2646 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2647 std::string ex(str, iter.base()); 2648 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2649 assert(ios.width() == 0); 2650 } 2651 ios.width(25); 2652 left(ios); 2653 { 2654 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2655 std::string ex(str, iter.base()); 2656 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2657 assert(ios.width() == 0); 2658 } 2659 ios.width(25); 2660 right(ios); 2661 { 2662 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2663 std::string ex(str, iter.base()); 2664 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2665 assert(ios.width() == 0); 2666 } 2667 ios.width(25); 2668 internal(ios); 2669 { 2670 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2671 std::string ex(str, iter.base()); 2672 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2673 assert(ios.width() == 0); 2674 } 2675 } 2676 ios.imbue(lg); 2677 { 2678 ios.width(0); 2679 { 2680 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2681 std::string ex(str, iter.base()); 2682 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2683 assert(ios.width() == 0); 2684 } 2685 ios.width(25); 2686 left(ios); 2687 { 2688 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2689 std::string ex(str, iter.base()); 2690 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2691 assert(ios.width() == 0); 2692 } 2693 ios.width(25); 2694 right(ios); 2695 { 2696 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2697 std::string ex(str, iter.base()); 2698 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2699 assert(ios.width() == 0); 2700 } 2701 ios.width(25); 2702 internal(ios); 2703 { 2704 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2705 std::string ex(str, iter.base()); 2706 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2707 assert(ios.width() == 0); 2708 } 2709 } 2710 } 2711 } 2712 } 2713 uppercase(ios); 2714 { 2715 noshowpos(ios); 2716 { 2717 noshowpoint(ios); 2718 { 2719 ios.imbue(lc); 2720 { 2721 ios.width(0); 2722 { 2723 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2724 std::string ex(str, iter.base()); 2725 assert(ex == "0"); 2726 assert(ios.width() == 0); 2727 } 2728 ios.width(25); 2729 left(ios); 2730 { 2731 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2732 std::string ex(str, iter.base()); 2733 assert(ex == "0************************"); 2734 assert(ios.width() == 0); 2735 } 2736 ios.width(25); 2737 right(ios); 2738 { 2739 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2740 std::string ex(str, iter.base()); 2741 assert(ex == "************************0"); 2742 assert(ios.width() == 0); 2743 } 2744 ios.width(25); 2745 internal(ios); 2746 { 2747 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2748 std::string ex(str, iter.base()); 2749 assert(ex == "************************0"); 2750 assert(ios.width() == 0); 2751 } 2752 } 2753 ios.imbue(lg); 2754 { 2755 ios.width(0); 2756 { 2757 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2758 std::string ex(str, iter.base()); 2759 assert(ex == "0"); 2760 assert(ios.width() == 0); 2761 } 2762 ios.width(25); 2763 left(ios); 2764 { 2765 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2766 std::string ex(str, iter.base()); 2767 assert(ex == "0************************"); 2768 assert(ios.width() == 0); 2769 } 2770 ios.width(25); 2771 right(ios); 2772 { 2773 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2774 std::string ex(str, iter.base()); 2775 assert(ex == "************************0"); 2776 assert(ios.width() == 0); 2777 } 2778 ios.width(25); 2779 internal(ios); 2780 { 2781 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2782 std::string ex(str, iter.base()); 2783 assert(ex == "************************0"); 2784 assert(ios.width() == 0); 2785 } 2786 } 2787 } 2788 showpoint(ios); 2789 { 2790 ios.imbue(lc); 2791 { 2792 ios.width(0); 2793 { 2794 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2795 std::string ex(str, iter.base()); 2796 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2797 assert(ios.width() == 0); 2798 } 2799 ios.width(25); 2800 left(ios); 2801 { 2802 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2803 std::string ex(str, iter.base()); 2804 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2805 assert(ios.width() == 0); 2806 } 2807 ios.width(25); 2808 right(ios); 2809 { 2810 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2811 std::string ex(str, iter.base()); 2812 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2813 assert(ios.width() == 0); 2814 } 2815 ios.width(25); 2816 internal(ios); 2817 { 2818 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2819 std::string ex(str, iter.base()); 2820 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2821 assert(ios.width() == 0); 2822 } 2823 } 2824 ios.imbue(lg); 2825 { 2826 ios.width(0); 2827 { 2828 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2829 std::string ex(str, iter.base()); 2830 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2831 assert(ios.width() == 0); 2832 } 2833 ios.width(25); 2834 left(ios); 2835 { 2836 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2837 std::string ex(str, iter.base()); 2838 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2839 assert(ios.width() == 0); 2840 } 2841 ios.width(25); 2842 right(ios); 2843 { 2844 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2845 std::string ex(str, iter.base()); 2846 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2847 assert(ios.width() == 0); 2848 } 2849 ios.width(25); 2850 internal(ios); 2851 { 2852 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2853 std::string ex(str, iter.base()); 2854 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2855 assert(ios.width() == 0); 2856 } 2857 } 2858 } 2859 } 2860 showpos(ios); 2861 { 2862 noshowpoint(ios); 2863 { 2864 ios.imbue(lc); 2865 { 2866 ios.width(0); 2867 { 2868 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2869 std::string ex(str, iter.base()); 2870 assert(ex == "+0"); 2871 assert(ios.width() == 0); 2872 } 2873 ios.width(25); 2874 left(ios); 2875 { 2876 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2877 std::string ex(str, iter.base()); 2878 assert(ex == "+0***********************"); 2879 assert(ios.width() == 0); 2880 } 2881 ios.width(25); 2882 right(ios); 2883 { 2884 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2885 std::string ex(str, iter.base()); 2886 assert(ex == "***********************+0"); 2887 assert(ios.width() == 0); 2888 } 2889 ios.width(25); 2890 internal(ios); 2891 { 2892 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2893 std::string ex(str, iter.base()); 2894 assert(ex == "+***********************0"); 2895 assert(ios.width() == 0); 2896 } 2897 } 2898 ios.imbue(lg); 2899 { 2900 ios.width(0); 2901 { 2902 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2903 std::string ex(str, iter.base()); 2904 assert(ex == "+0"); 2905 assert(ios.width() == 0); 2906 } 2907 ios.width(25); 2908 left(ios); 2909 { 2910 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2911 std::string ex(str, iter.base()); 2912 assert(ex == "+0***********************"); 2913 assert(ios.width() == 0); 2914 } 2915 ios.width(25); 2916 right(ios); 2917 { 2918 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2919 std::string ex(str, iter.base()); 2920 assert(ex == "***********************+0"); 2921 assert(ios.width() == 0); 2922 } 2923 ios.width(25); 2924 internal(ios); 2925 { 2926 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2927 std::string ex(str, iter.base()); 2928 assert(ex == "+***********************0"); 2929 assert(ios.width() == 0); 2930 } 2931 } 2932 } 2933 showpoint(ios); 2934 { 2935 ios.imbue(lc); 2936 { 2937 ios.width(0); 2938 { 2939 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2940 std::string ex(str, iter.base()); 2941 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2942 assert(ios.width() == 0); 2943 } 2944 ios.width(25); 2945 left(ios); 2946 { 2947 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2948 std::string ex(str, iter.base()); 2949 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2950 assert(ios.width() == 0); 2951 } 2952 ios.width(25); 2953 right(ios); 2954 { 2955 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2956 std::string ex(str, iter.base()); 2957 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2958 assert(ios.width() == 0); 2959 } 2960 ios.width(25); 2961 internal(ios); 2962 { 2963 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2964 std::string ex(str, iter.base()); 2965 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2966 assert(ios.width() == 0); 2967 } 2968 } 2969 ios.imbue(lg); 2970 { 2971 ios.width(0); 2972 { 2973 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2974 std::string ex(str, iter.base()); 2975 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2976 assert(ios.width() == 0); 2977 } 2978 ios.width(25); 2979 left(ios); 2980 { 2981 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2982 std::string ex(str, iter.base()); 2983 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2984 assert(ios.width() == 0); 2985 } 2986 ios.width(25); 2987 right(ios); 2988 { 2989 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2990 std::string ex(str, iter.base()); 2991 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2992 assert(ios.width() == 0); 2993 } 2994 ios.width(25); 2995 internal(ios); 2996 { 2997 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2998 std::string ex(str, iter.base()); 2999 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 3000 assert(ios.width() == 0); 3001 } 3002 } 3003 } 3004 } 3005 } 3006 } 3007 } 3008 } 3009 } 3010 3011 void test2() 3012 { 3013 char str[200]; 3014 output_iterator<char*> iter; 3015 std::locale lc = std::locale::classic(); 3016 std::locale lg(lc, new my_numpunct); 3017 const my_facet f(1); 3018 { 3019 long double v = -0.; 3020 std::ios ios(0); 3021 // %g 3022 { 3023 ios.precision(0); 3024 { 3025 nouppercase(ios); 3026 { 3027 noshowpos(ios); 3028 { 3029 noshowpoint(ios); 3030 { 3031 ios.imbue(lc); 3032 { 3033 ios.width(0); 3034 { 3035 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3036 std::string ex(str, iter.base()); 3037 assert(ex == "-0"); 3038 assert(ios.width() == 0); 3039 } 3040 ios.width(25); 3041 left(ios); 3042 { 3043 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3044 std::string ex(str, iter.base()); 3045 assert(ex == "-0***********************"); 3046 assert(ios.width() == 0); 3047 } 3048 ios.width(25); 3049 right(ios); 3050 { 3051 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3052 std::string ex(str, iter.base()); 3053 assert(ex == "***********************-0"); 3054 assert(ios.width() == 0); 3055 } 3056 ios.width(25); 3057 internal(ios); 3058 { 3059 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3060 std::string ex(str, iter.base()); 3061 assert(ex == "-***********************0"); 3062 assert(ios.width() == 0); 3063 } 3064 } 3065 ios.imbue(lg); 3066 { 3067 ios.width(0); 3068 { 3069 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3070 std::string ex(str, iter.base()); 3071 assert(ex == "-0"); 3072 assert(ios.width() == 0); 3073 } 3074 ios.width(25); 3075 left(ios); 3076 { 3077 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3078 std::string ex(str, iter.base()); 3079 assert(ex == "-0***********************"); 3080 assert(ios.width() == 0); 3081 } 3082 ios.width(25); 3083 right(ios); 3084 { 3085 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3086 std::string ex(str, iter.base()); 3087 assert(ex == "***********************-0"); 3088 assert(ios.width() == 0); 3089 } 3090 ios.width(25); 3091 internal(ios); 3092 { 3093 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3094 std::string ex(str, iter.base()); 3095 assert(ex == "-***********************0"); 3096 assert(ios.width() == 0); 3097 } 3098 } 3099 } 3100 showpoint(ios); 3101 { 3102 ios.imbue(lc); 3103 { 3104 ios.width(0); 3105 { 3106 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3107 std::string ex(str, iter.base()); 3108 assert(ex == "-0."); 3109 assert(ios.width() == 0); 3110 } 3111 ios.width(25); 3112 left(ios); 3113 { 3114 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3115 std::string ex(str, iter.base()); 3116 assert(ex == "-0.**********************"); 3117 assert(ios.width() == 0); 3118 } 3119 ios.width(25); 3120 right(ios); 3121 { 3122 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3123 std::string ex(str, iter.base()); 3124 assert(ex == "**********************-0."); 3125 assert(ios.width() == 0); 3126 } 3127 ios.width(25); 3128 internal(ios); 3129 { 3130 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3131 std::string ex(str, iter.base()); 3132 assert(ex == "-**********************0."); 3133 assert(ios.width() == 0); 3134 } 3135 } 3136 ios.imbue(lg); 3137 { 3138 ios.width(0); 3139 { 3140 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3141 std::string ex(str, iter.base()); 3142 assert(ex == "-0;"); 3143 assert(ios.width() == 0); 3144 } 3145 ios.width(25); 3146 left(ios); 3147 { 3148 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3149 std::string ex(str, iter.base()); 3150 assert(ex == "-0;**********************"); 3151 assert(ios.width() == 0); 3152 } 3153 ios.width(25); 3154 right(ios); 3155 { 3156 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3157 std::string ex(str, iter.base()); 3158 assert(ex == "**********************-0;"); 3159 assert(ios.width() == 0); 3160 } 3161 ios.width(25); 3162 internal(ios); 3163 { 3164 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3165 std::string ex(str, iter.base()); 3166 assert(ex == "-**********************0;"); 3167 assert(ios.width() == 0); 3168 } 3169 } 3170 } 3171 } 3172 showpos(ios); 3173 { 3174 noshowpoint(ios); 3175 { 3176 ios.imbue(lc); 3177 { 3178 ios.width(0); 3179 { 3180 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3181 std::string ex(str, iter.base()); 3182 assert(ex == "-0"); 3183 assert(ios.width() == 0); 3184 } 3185 ios.width(25); 3186 left(ios); 3187 { 3188 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3189 std::string ex(str, iter.base()); 3190 assert(ex == "-0***********************"); 3191 assert(ios.width() == 0); 3192 } 3193 ios.width(25); 3194 right(ios); 3195 { 3196 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3197 std::string ex(str, iter.base()); 3198 assert(ex == "***********************-0"); 3199 assert(ios.width() == 0); 3200 } 3201 ios.width(25); 3202 internal(ios); 3203 { 3204 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3205 std::string ex(str, iter.base()); 3206 assert(ex == "-***********************0"); 3207 assert(ios.width() == 0); 3208 } 3209 } 3210 ios.imbue(lg); 3211 { 3212 ios.width(0); 3213 { 3214 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3215 std::string ex(str, iter.base()); 3216 assert(ex == "-0"); 3217 assert(ios.width() == 0); 3218 } 3219 ios.width(25); 3220 left(ios); 3221 { 3222 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3223 std::string ex(str, iter.base()); 3224 assert(ex == "-0***********************"); 3225 assert(ios.width() == 0); 3226 } 3227 ios.width(25); 3228 right(ios); 3229 { 3230 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3231 std::string ex(str, iter.base()); 3232 assert(ex == "***********************-0"); 3233 assert(ios.width() == 0); 3234 } 3235 ios.width(25); 3236 internal(ios); 3237 { 3238 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3239 std::string ex(str, iter.base()); 3240 assert(ex == "-***********************0"); 3241 assert(ios.width() == 0); 3242 } 3243 } 3244 } 3245 showpoint(ios); 3246 { 3247 ios.imbue(lc); 3248 { 3249 ios.width(0); 3250 { 3251 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3252 std::string ex(str, iter.base()); 3253 assert(ex == "-0."); 3254 assert(ios.width() == 0); 3255 } 3256 ios.width(25); 3257 left(ios); 3258 { 3259 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3260 std::string ex(str, iter.base()); 3261 assert(ex == "-0.**********************"); 3262 assert(ios.width() == 0); 3263 } 3264 ios.width(25); 3265 right(ios); 3266 { 3267 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3268 std::string ex(str, iter.base()); 3269 assert(ex == "**********************-0."); 3270 assert(ios.width() == 0); 3271 } 3272 ios.width(25); 3273 internal(ios); 3274 { 3275 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3276 std::string ex(str, iter.base()); 3277 assert(ex == "-**********************0."); 3278 assert(ios.width() == 0); 3279 } 3280 } 3281 ios.imbue(lg); 3282 { 3283 ios.width(0); 3284 { 3285 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3286 std::string ex(str, iter.base()); 3287 assert(ex == "-0;"); 3288 assert(ios.width() == 0); 3289 } 3290 ios.width(25); 3291 left(ios); 3292 { 3293 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3294 std::string ex(str, iter.base()); 3295 assert(ex == "-0;**********************"); 3296 assert(ios.width() == 0); 3297 } 3298 ios.width(25); 3299 right(ios); 3300 { 3301 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3302 std::string ex(str, iter.base()); 3303 assert(ex == "**********************-0;"); 3304 assert(ios.width() == 0); 3305 } 3306 ios.width(25); 3307 internal(ios); 3308 { 3309 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3310 std::string ex(str, iter.base()); 3311 assert(ex == "-**********************0;"); 3312 assert(ios.width() == 0); 3313 } 3314 } 3315 } 3316 } 3317 } 3318 uppercase(ios); 3319 { 3320 noshowpos(ios); 3321 { 3322 noshowpoint(ios); 3323 { 3324 ios.imbue(lc); 3325 { 3326 ios.width(0); 3327 { 3328 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3329 std::string ex(str, iter.base()); 3330 assert(ex == "-0"); 3331 assert(ios.width() == 0); 3332 } 3333 ios.width(25); 3334 left(ios); 3335 { 3336 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3337 std::string ex(str, iter.base()); 3338 assert(ex == "-0***********************"); 3339 assert(ios.width() == 0); 3340 } 3341 ios.width(25); 3342 right(ios); 3343 { 3344 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3345 std::string ex(str, iter.base()); 3346 assert(ex == "***********************-0"); 3347 assert(ios.width() == 0); 3348 } 3349 ios.width(25); 3350 internal(ios); 3351 { 3352 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3353 std::string ex(str, iter.base()); 3354 assert(ex == "-***********************0"); 3355 assert(ios.width() == 0); 3356 } 3357 } 3358 ios.imbue(lg); 3359 { 3360 ios.width(0); 3361 { 3362 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3363 std::string ex(str, iter.base()); 3364 assert(ex == "-0"); 3365 assert(ios.width() == 0); 3366 } 3367 ios.width(25); 3368 left(ios); 3369 { 3370 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3371 std::string ex(str, iter.base()); 3372 assert(ex == "-0***********************"); 3373 assert(ios.width() == 0); 3374 } 3375 ios.width(25); 3376 right(ios); 3377 { 3378 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3379 std::string ex(str, iter.base()); 3380 assert(ex == "***********************-0"); 3381 assert(ios.width() == 0); 3382 } 3383 ios.width(25); 3384 internal(ios); 3385 { 3386 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3387 std::string ex(str, iter.base()); 3388 assert(ex == "-***********************0"); 3389 assert(ios.width() == 0); 3390 } 3391 } 3392 } 3393 showpoint(ios); 3394 { 3395 ios.imbue(lc); 3396 { 3397 ios.width(0); 3398 { 3399 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3400 std::string ex(str, iter.base()); 3401 assert(ex == "-0."); 3402 assert(ios.width() == 0); 3403 } 3404 ios.width(25); 3405 left(ios); 3406 { 3407 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3408 std::string ex(str, iter.base()); 3409 assert(ex == "-0.**********************"); 3410 assert(ios.width() == 0); 3411 } 3412 ios.width(25); 3413 right(ios); 3414 { 3415 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3416 std::string ex(str, iter.base()); 3417 assert(ex == "**********************-0."); 3418 assert(ios.width() == 0); 3419 } 3420 ios.width(25); 3421 internal(ios); 3422 { 3423 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3424 std::string ex(str, iter.base()); 3425 assert(ex == "-**********************0."); 3426 assert(ios.width() == 0); 3427 } 3428 } 3429 ios.imbue(lg); 3430 { 3431 ios.width(0); 3432 { 3433 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3434 std::string ex(str, iter.base()); 3435 assert(ex == "-0;"); 3436 assert(ios.width() == 0); 3437 } 3438 ios.width(25); 3439 left(ios); 3440 { 3441 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3442 std::string ex(str, iter.base()); 3443 assert(ex == "-0;**********************"); 3444 assert(ios.width() == 0); 3445 } 3446 ios.width(25); 3447 right(ios); 3448 { 3449 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3450 std::string ex(str, iter.base()); 3451 assert(ex == "**********************-0;"); 3452 assert(ios.width() == 0); 3453 } 3454 ios.width(25); 3455 internal(ios); 3456 { 3457 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3458 std::string ex(str, iter.base()); 3459 assert(ex == "-**********************0;"); 3460 assert(ios.width() == 0); 3461 } 3462 } 3463 } 3464 } 3465 showpos(ios); 3466 { 3467 noshowpoint(ios); 3468 { 3469 ios.imbue(lc); 3470 { 3471 ios.width(0); 3472 { 3473 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3474 std::string ex(str, iter.base()); 3475 assert(ex == "-0"); 3476 assert(ios.width() == 0); 3477 } 3478 ios.width(25); 3479 left(ios); 3480 { 3481 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3482 std::string ex(str, iter.base()); 3483 assert(ex == "-0***********************"); 3484 assert(ios.width() == 0); 3485 } 3486 ios.width(25); 3487 right(ios); 3488 { 3489 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3490 std::string ex(str, iter.base()); 3491 assert(ex == "***********************-0"); 3492 assert(ios.width() == 0); 3493 } 3494 ios.width(25); 3495 internal(ios); 3496 { 3497 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3498 std::string ex(str, iter.base()); 3499 assert(ex == "-***********************0"); 3500 assert(ios.width() == 0); 3501 } 3502 } 3503 ios.imbue(lg); 3504 { 3505 ios.width(0); 3506 { 3507 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3508 std::string ex(str, iter.base()); 3509 assert(ex == "-0"); 3510 assert(ios.width() == 0); 3511 } 3512 ios.width(25); 3513 left(ios); 3514 { 3515 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3516 std::string ex(str, iter.base()); 3517 assert(ex == "-0***********************"); 3518 assert(ios.width() == 0); 3519 } 3520 ios.width(25); 3521 right(ios); 3522 { 3523 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3524 std::string ex(str, iter.base()); 3525 assert(ex == "***********************-0"); 3526 assert(ios.width() == 0); 3527 } 3528 ios.width(25); 3529 internal(ios); 3530 { 3531 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3532 std::string ex(str, iter.base()); 3533 assert(ex == "-***********************0"); 3534 assert(ios.width() == 0); 3535 } 3536 } 3537 } 3538 showpoint(ios); 3539 { 3540 ios.imbue(lc); 3541 { 3542 ios.width(0); 3543 { 3544 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3545 std::string ex(str, iter.base()); 3546 assert(ex == "-0."); 3547 assert(ios.width() == 0); 3548 } 3549 ios.width(25); 3550 left(ios); 3551 { 3552 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3553 std::string ex(str, iter.base()); 3554 assert(ex == "-0.**********************"); 3555 assert(ios.width() == 0); 3556 } 3557 ios.width(25); 3558 right(ios); 3559 { 3560 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3561 std::string ex(str, iter.base()); 3562 assert(ex == "**********************-0."); 3563 assert(ios.width() == 0); 3564 } 3565 ios.width(25); 3566 internal(ios); 3567 { 3568 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3569 std::string ex(str, iter.base()); 3570 assert(ex == "-**********************0."); 3571 assert(ios.width() == 0); 3572 } 3573 } 3574 ios.imbue(lg); 3575 { 3576 ios.width(0); 3577 { 3578 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3579 std::string ex(str, iter.base()); 3580 assert(ex == "-0;"); 3581 assert(ios.width() == 0); 3582 } 3583 ios.width(25); 3584 left(ios); 3585 { 3586 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3587 std::string ex(str, iter.base()); 3588 assert(ex == "-0;**********************"); 3589 assert(ios.width() == 0); 3590 } 3591 ios.width(25); 3592 right(ios); 3593 { 3594 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3595 std::string ex(str, iter.base()); 3596 assert(ex == "**********************-0;"); 3597 assert(ios.width() == 0); 3598 } 3599 ios.width(25); 3600 internal(ios); 3601 { 3602 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3603 std::string ex(str, iter.base()); 3604 assert(ex == "-**********************0;"); 3605 assert(ios.width() == 0); 3606 } 3607 } 3608 } 3609 } 3610 } 3611 } 3612 ios.precision(1); 3613 { 3614 nouppercase(ios); 3615 { 3616 noshowpos(ios); 3617 { 3618 noshowpoint(ios); 3619 { 3620 ios.imbue(lc); 3621 { 3622 ios.width(0); 3623 { 3624 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3625 std::string ex(str, iter.base()); 3626 assert(ex == "-0"); 3627 assert(ios.width() == 0); 3628 } 3629 ios.width(25); 3630 left(ios); 3631 { 3632 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3633 std::string ex(str, iter.base()); 3634 assert(ex == "-0***********************"); 3635 assert(ios.width() == 0); 3636 } 3637 ios.width(25); 3638 right(ios); 3639 { 3640 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3641 std::string ex(str, iter.base()); 3642 assert(ex == "***********************-0"); 3643 assert(ios.width() == 0); 3644 } 3645 ios.width(25); 3646 internal(ios); 3647 { 3648 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3649 std::string ex(str, iter.base()); 3650 assert(ex == "-***********************0"); 3651 assert(ios.width() == 0); 3652 } 3653 } 3654 ios.imbue(lg); 3655 { 3656 ios.width(0); 3657 { 3658 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3659 std::string ex(str, iter.base()); 3660 assert(ex == "-0"); 3661 assert(ios.width() == 0); 3662 } 3663 ios.width(25); 3664 left(ios); 3665 { 3666 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3667 std::string ex(str, iter.base()); 3668 assert(ex == "-0***********************"); 3669 assert(ios.width() == 0); 3670 } 3671 ios.width(25); 3672 right(ios); 3673 { 3674 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3675 std::string ex(str, iter.base()); 3676 assert(ex == "***********************-0"); 3677 assert(ios.width() == 0); 3678 } 3679 ios.width(25); 3680 internal(ios); 3681 { 3682 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3683 std::string ex(str, iter.base()); 3684 assert(ex == "-***********************0"); 3685 assert(ios.width() == 0); 3686 } 3687 } 3688 } 3689 showpoint(ios); 3690 { 3691 ios.imbue(lc); 3692 { 3693 ios.width(0); 3694 { 3695 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3696 std::string ex(str, iter.base()); 3697 assert(ex == "-0."); 3698 assert(ios.width() == 0); 3699 } 3700 ios.width(25); 3701 left(ios); 3702 { 3703 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3704 std::string ex(str, iter.base()); 3705 assert(ex == "-0.**********************"); 3706 assert(ios.width() == 0); 3707 } 3708 ios.width(25); 3709 right(ios); 3710 { 3711 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3712 std::string ex(str, iter.base()); 3713 assert(ex == "**********************-0."); 3714 assert(ios.width() == 0); 3715 } 3716 ios.width(25); 3717 internal(ios); 3718 { 3719 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3720 std::string ex(str, iter.base()); 3721 assert(ex == "-**********************0."); 3722 assert(ios.width() == 0); 3723 } 3724 } 3725 ios.imbue(lg); 3726 { 3727 ios.width(0); 3728 { 3729 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3730 std::string ex(str, iter.base()); 3731 assert(ex == "-0;"); 3732 assert(ios.width() == 0); 3733 } 3734 ios.width(25); 3735 left(ios); 3736 { 3737 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3738 std::string ex(str, iter.base()); 3739 assert(ex == "-0;**********************"); 3740 assert(ios.width() == 0); 3741 } 3742 ios.width(25); 3743 right(ios); 3744 { 3745 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3746 std::string ex(str, iter.base()); 3747 assert(ex == "**********************-0;"); 3748 assert(ios.width() == 0); 3749 } 3750 ios.width(25); 3751 internal(ios); 3752 { 3753 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3754 std::string ex(str, iter.base()); 3755 assert(ex == "-**********************0;"); 3756 assert(ios.width() == 0); 3757 } 3758 } 3759 } 3760 } 3761 showpos(ios); 3762 { 3763 noshowpoint(ios); 3764 { 3765 ios.imbue(lc); 3766 { 3767 ios.width(0); 3768 { 3769 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3770 std::string ex(str, iter.base()); 3771 assert(ex == "-0"); 3772 assert(ios.width() == 0); 3773 } 3774 ios.width(25); 3775 left(ios); 3776 { 3777 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3778 std::string ex(str, iter.base()); 3779 assert(ex == "-0***********************"); 3780 assert(ios.width() == 0); 3781 } 3782 ios.width(25); 3783 right(ios); 3784 { 3785 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3786 std::string ex(str, iter.base()); 3787 assert(ex == "***********************-0"); 3788 assert(ios.width() == 0); 3789 } 3790 ios.width(25); 3791 internal(ios); 3792 { 3793 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3794 std::string ex(str, iter.base()); 3795 assert(ex == "-***********************0"); 3796 assert(ios.width() == 0); 3797 } 3798 } 3799 ios.imbue(lg); 3800 { 3801 ios.width(0); 3802 { 3803 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3804 std::string ex(str, iter.base()); 3805 assert(ex == "-0"); 3806 assert(ios.width() == 0); 3807 } 3808 ios.width(25); 3809 left(ios); 3810 { 3811 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3812 std::string ex(str, iter.base()); 3813 assert(ex == "-0***********************"); 3814 assert(ios.width() == 0); 3815 } 3816 ios.width(25); 3817 right(ios); 3818 { 3819 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3820 std::string ex(str, iter.base()); 3821 assert(ex == "***********************-0"); 3822 assert(ios.width() == 0); 3823 } 3824 ios.width(25); 3825 internal(ios); 3826 { 3827 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3828 std::string ex(str, iter.base()); 3829 assert(ex == "-***********************0"); 3830 assert(ios.width() == 0); 3831 } 3832 } 3833 } 3834 showpoint(ios); 3835 { 3836 ios.imbue(lc); 3837 { 3838 ios.width(0); 3839 { 3840 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3841 std::string ex(str, iter.base()); 3842 assert(ex == "-0."); 3843 assert(ios.width() == 0); 3844 } 3845 ios.width(25); 3846 left(ios); 3847 { 3848 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3849 std::string ex(str, iter.base()); 3850 assert(ex == "-0.**********************"); 3851 assert(ios.width() == 0); 3852 } 3853 ios.width(25); 3854 right(ios); 3855 { 3856 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3857 std::string ex(str, iter.base()); 3858 assert(ex == "**********************-0."); 3859 assert(ios.width() == 0); 3860 } 3861 ios.width(25); 3862 internal(ios); 3863 { 3864 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3865 std::string ex(str, iter.base()); 3866 assert(ex == "-**********************0."); 3867 assert(ios.width() == 0); 3868 } 3869 } 3870 ios.imbue(lg); 3871 { 3872 ios.width(0); 3873 { 3874 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3875 std::string ex(str, iter.base()); 3876 assert(ex == "-0;"); 3877 assert(ios.width() == 0); 3878 } 3879 ios.width(25); 3880 left(ios); 3881 { 3882 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3883 std::string ex(str, iter.base()); 3884 assert(ex == "-0;**********************"); 3885 assert(ios.width() == 0); 3886 } 3887 ios.width(25); 3888 right(ios); 3889 { 3890 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3891 std::string ex(str, iter.base()); 3892 assert(ex == "**********************-0;"); 3893 assert(ios.width() == 0); 3894 } 3895 ios.width(25); 3896 internal(ios); 3897 { 3898 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3899 std::string ex(str, iter.base()); 3900 assert(ex == "-**********************0;"); 3901 assert(ios.width() == 0); 3902 } 3903 } 3904 } 3905 } 3906 } 3907 uppercase(ios); 3908 { 3909 noshowpos(ios); 3910 { 3911 noshowpoint(ios); 3912 { 3913 ios.imbue(lc); 3914 { 3915 ios.width(0); 3916 { 3917 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3918 std::string ex(str, iter.base()); 3919 assert(ex == "-0"); 3920 assert(ios.width() == 0); 3921 } 3922 ios.width(25); 3923 left(ios); 3924 { 3925 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3926 std::string ex(str, iter.base()); 3927 assert(ex == "-0***********************"); 3928 assert(ios.width() == 0); 3929 } 3930 ios.width(25); 3931 right(ios); 3932 { 3933 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3934 std::string ex(str, iter.base()); 3935 assert(ex == "***********************-0"); 3936 assert(ios.width() == 0); 3937 } 3938 ios.width(25); 3939 internal(ios); 3940 { 3941 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3942 std::string ex(str, iter.base()); 3943 assert(ex == "-***********************0"); 3944 assert(ios.width() == 0); 3945 } 3946 } 3947 ios.imbue(lg); 3948 { 3949 ios.width(0); 3950 { 3951 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3952 std::string ex(str, iter.base()); 3953 assert(ex == "-0"); 3954 assert(ios.width() == 0); 3955 } 3956 ios.width(25); 3957 left(ios); 3958 { 3959 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3960 std::string ex(str, iter.base()); 3961 assert(ex == "-0***********************"); 3962 assert(ios.width() == 0); 3963 } 3964 ios.width(25); 3965 right(ios); 3966 { 3967 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3968 std::string ex(str, iter.base()); 3969 assert(ex == "***********************-0"); 3970 assert(ios.width() == 0); 3971 } 3972 ios.width(25); 3973 internal(ios); 3974 { 3975 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3976 std::string ex(str, iter.base()); 3977 assert(ex == "-***********************0"); 3978 assert(ios.width() == 0); 3979 } 3980 } 3981 } 3982 showpoint(ios); 3983 { 3984 ios.imbue(lc); 3985 { 3986 ios.width(0); 3987 { 3988 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3989 std::string ex(str, iter.base()); 3990 assert(ex == "-0."); 3991 assert(ios.width() == 0); 3992 } 3993 ios.width(25); 3994 left(ios); 3995 { 3996 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3997 std::string ex(str, iter.base()); 3998 assert(ex == "-0.**********************"); 3999 assert(ios.width() == 0); 4000 } 4001 ios.width(25); 4002 right(ios); 4003 { 4004 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4005 std::string ex(str, iter.base()); 4006 assert(ex == "**********************-0."); 4007 assert(ios.width() == 0); 4008 } 4009 ios.width(25); 4010 internal(ios); 4011 { 4012 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4013 std::string ex(str, iter.base()); 4014 assert(ex == "-**********************0."); 4015 assert(ios.width() == 0); 4016 } 4017 } 4018 ios.imbue(lg); 4019 { 4020 ios.width(0); 4021 { 4022 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4023 std::string ex(str, iter.base()); 4024 assert(ex == "-0;"); 4025 assert(ios.width() == 0); 4026 } 4027 ios.width(25); 4028 left(ios); 4029 { 4030 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4031 std::string ex(str, iter.base()); 4032 assert(ex == "-0;**********************"); 4033 assert(ios.width() == 0); 4034 } 4035 ios.width(25); 4036 right(ios); 4037 { 4038 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4039 std::string ex(str, iter.base()); 4040 assert(ex == "**********************-0;"); 4041 assert(ios.width() == 0); 4042 } 4043 ios.width(25); 4044 internal(ios); 4045 { 4046 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4047 std::string ex(str, iter.base()); 4048 assert(ex == "-**********************0;"); 4049 assert(ios.width() == 0); 4050 } 4051 } 4052 } 4053 } 4054 showpos(ios); 4055 { 4056 noshowpoint(ios); 4057 { 4058 ios.imbue(lc); 4059 { 4060 ios.width(0); 4061 { 4062 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4063 std::string ex(str, iter.base()); 4064 assert(ex == "-0"); 4065 assert(ios.width() == 0); 4066 } 4067 ios.width(25); 4068 left(ios); 4069 { 4070 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4071 std::string ex(str, iter.base()); 4072 assert(ex == "-0***********************"); 4073 assert(ios.width() == 0); 4074 } 4075 ios.width(25); 4076 right(ios); 4077 { 4078 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4079 std::string ex(str, iter.base()); 4080 assert(ex == "***********************-0"); 4081 assert(ios.width() == 0); 4082 } 4083 ios.width(25); 4084 internal(ios); 4085 { 4086 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4087 std::string ex(str, iter.base()); 4088 assert(ex == "-***********************0"); 4089 assert(ios.width() == 0); 4090 } 4091 } 4092 ios.imbue(lg); 4093 { 4094 ios.width(0); 4095 { 4096 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4097 std::string ex(str, iter.base()); 4098 assert(ex == "-0"); 4099 assert(ios.width() == 0); 4100 } 4101 ios.width(25); 4102 left(ios); 4103 { 4104 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4105 std::string ex(str, iter.base()); 4106 assert(ex == "-0***********************"); 4107 assert(ios.width() == 0); 4108 } 4109 ios.width(25); 4110 right(ios); 4111 { 4112 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4113 std::string ex(str, iter.base()); 4114 assert(ex == "***********************-0"); 4115 assert(ios.width() == 0); 4116 } 4117 ios.width(25); 4118 internal(ios); 4119 { 4120 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4121 std::string ex(str, iter.base()); 4122 assert(ex == "-***********************0"); 4123 assert(ios.width() == 0); 4124 } 4125 } 4126 } 4127 showpoint(ios); 4128 { 4129 ios.imbue(lc); 4130 { 4131 ios.width(0); 4132 { 4133 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4134 std::string ex(str, iter.base()); 4135 assert(ex == "-0."); 4136 assert(ios.width() == 0); 4137 } 4138 ios.width(25); 4139 left(ios); 4140 { 4141 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4142 std::string ex(str, iter.base()); 4143 assert(ex == "-0.**********************"); 4144 assert(ios.width() == 0); 4145 } 4146 ios.width(25); 4147 right(ios); 4148 { 4149 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4150 std::string ex(str, iter.base()); 4151 assert(ex == "**********************-0."); 4152 assert(ios.width() == 0); 4153 } 4154 ios.width(25); 4155 internal(ios); 4156 { 4157 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4158 std::string ex(str, iter.base()); 4159 assert(ex == "-**********************0."); 4160 assert(ios.width() == 0); 4161 } 4162 } 4163 ios.imbue(lg); 4164 { 4165 ios.width(0); 4166 { 4167 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4168 std::string ex(str, iter.base()); 4169 assert(ex == "-0;"); 4170 assert(ios.width() == 0); 4171 } 4172 ios.width(25); 4173 left(ios); 4174 { 4175 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4176 std::string ex(str, iter.base()); 4177 assert(ex == "-0;**********************"); 4178 assert(ios.width() == 0); 4179 } 4180 ios.width(25); 4181 right(ios); 4182 { 4183 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4184 std::string ex(str, iter.base()); 4185 assert(ex == "**********************-0;"); 4186 assert(ios.width() == 0); 4187 } 4188 ios.width(25); 4189 internal(ios); 4190 { 4191 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4192 std::string ex(str, iter.base()); 4193 assert(ex == "-**********************0;"); 4194 assert(ios.width() == 0); 4195 } 4196 } 4197 } 4198 } 4199 } 4200 } 4201 ios.precision(6); 4202 { 4203 nouppercase(ios); 4204 { 4205 noshowpos(ios); 4206 { 4207 noshowpoint(ios); 4208 { 4209 ios.imbue(lc); 4210 { 4211 ios.width(0); 4212 { 4213 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4214 std::string ex(str, iter.base()); 4215 assert(ex == "-0"); 4216 assert(ios.width() == 0); 4217 } 4218 ios.width(25); 4219 left(ios); 4220 { 4221 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4222 std::string ex(str, iter.base()); 4223 assert(ex == "-0***********************"); 4224 assert(ios.width() == 0); 4225 } 4226 ios.width(25); 4227 right(ios); 4228 { 4229 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4230 std::string ex(str, iter.base()); 4231 assert(ex == "***********************-0"); 4232 assert(ios.width() == 0); 4233 } 4234 ios.width(25); 4235 internal(ios); 4236 { 4237 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4238 std::string ex(str, iter.base()); 4239 assert(ex == "-***********************0"); 4240 assert(ios.width() == 0); 4241 } 4242 } 4243 ios.imbue(lg); 4244 { 4245 ios.width(0); 4246 { 4247 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4248 std::string ex(str, iter.base()); 4249 assert(ex == "-0"); 4250 assert(ios.width() == 0); 4251 } 4252 ios.width(25); 4253 left(ios); 4254 { 4255 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4256 std::string ex(str, iter.base()); 4257 assert(ex == "-0***********************"); 4258 assert(ios.width() == 0); 4259 } 4260 ios.width(25); 4261 right(ios); 4262 { 4263 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4264 std::string ex(str, iter.base()); 4265 assert(ex == "***********************-0"); 4266 assert(ios.width() == 0); 4267 } 4268 ios.width(25); 4269 internal(ios); 4270 { 4271 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4272 std::string ex(str, iter.base()); 4273 assert(ex == "-***********************0"); 4274 assert(ios.width() == 0); 4275 } 4276 } 4277 } 4278 showpoint(ios); 4279 { 4280 ios.imbue(lc); 4281 { 4282 ios.width(0); 4283 { 4284 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4285 std::string ex(str, iter.base()); 4286 assert(ex == "-0.00000"); 4287 assert(ios.width() == 0); 4288 } 4289 ios.width(25); 4290 left(ios); 4291 { 4292 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4293 std::string ex(str, iter.base()); 4294 assert(ex == "-0.00000*****************"); 4295 assert(ios.width() == 0); 4296 } 4297 ios.width(25); 4298 right(ios); 4299 { 4300 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4301 std::string ex(str, iter.base()); 4302 assert(ex == "*****************-0.00000"); 4303 assert(ios.width() == 0); 4304 } 4305 ios.width(25); 4306 internal(ios); 4307 { 4308 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4309 std::string ex(str, iter.base()); 4310 assert(ex == "-*****************0.00000"); 4311 assert(ios.width() == 0); 4312 } 4313 } 4314 ios.imbue(lg); 4315 { 4316 ios.width(0); 4317 { 4318 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4319 std::string ex(str, iter.base()); 4320 assert(ex == "-0;00000"); 4321 assert(ios.width() == 0); 4322 } 4323 ios.width(25); 4324 left(ios); 4325 { 4326 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4327 std::string ex(str, iter.base()); 4328 assert(ex == "-0;00000*****************"); 4329 assert(ios.width() == 0); 4330 } 4331 ios.width(25); 4332 right(ios); 4333 { 4334 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4335 std::string ex(str, iter.base()); 4336 assert(ex == "*****************-0;00000"); 4337 assert(ios.width() == 0); 4338 } 4339 ios.width(25); 4340 internal(ios); 4341 { 4342 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4343 std::string ex(str, iter.base()); 4344 assert(ex == "-*****************0;00000"); 4345 assert(ios.width() == 0); 4346 } 4347 } 4348 } 4349 } 4350 showpos(ios); 4351 { 4352 noshowpoint(ios); 4353 { 4354 ios.imbue(lc); 4355 { 4356 ios.width(0); 4357 { 4358 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4359 std::string ex(str, iter.base()); 4360 assert(ex == "-0"); 4361 assert(ios.width() == 0); 4362 } 4363 ios.width(25); 4364 left(ios); 4365 { 4366 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4367 std::string ex(str, iter.base()); 4368 assert(ex == "-0***********************"); 4369 assert(ios.width() == 0); 4370 } 4371 ios.width(25); 4372 right(ios); 4373 { 4374 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4375 std::string ex(str, iter.base()); 4376 assert(ex == "***********************-0"); 4377 assert(ios.width() == 0); 4378 } 4379 ios.width(25); 4380 internal(ios); 4381 { 4382 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4383 std::string ex(str, iter.base()); 4384 assert(ex == "-***********************0"); 4385 assert(ios.width() == 0); 4386 } 4387 } 4388 ios.imbue(lg); 4389 { 4390 ios.width(0); 4391 { 4392 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4393 std::string ex(str, iter.base()); 4394 assert(ex == "-0"); 4395 assert(ios.width() == 0); 4396 } 4397 ios.width(25); 4398 left(ios); 4399 { 4400 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4401 std::string ex(str, iter.base()); 4402 assert(ex == "-0***********************"); 4403 assert(ios.width() == 0); 4404 } 4405 ios.width(25); 4406 right(ios); 4407 { 4408 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4409 std::string ex(str, iter.base()); 4410 assert(ex == "***********************-0"); 4411 assert(ios.width() == 0); 4412 } 4413 ios.width(25); 4414 internal(ios); 4415 { 4416 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4417 std::string ex(str, iter.base()); 4418 assert(ex == "-***********************0"); 4419 assert(ios.width() == 0); 4420 } 4421 } 4422 } 4423 showpoint(ios); 4424 { 4425 ios.imbue(lc); 4426 { 4427 ios.width(0); 4428 { 4429 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4430 std::string ex(str, iter.base()); 4431 assert(ex == "-0.00000"); 4432 assert(ios.width() == 0); 4433 } 4434 ios.width(25); 4435 left(ios); 4436 { 4437 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4438 std::string ex(str, iter.base()); 4439 assert(ex == "-0.00000*****************"); 4440 assert(ios.width() == 0); 4441 } 4442 ios.width(25); 4443 right(ios); 4444 { 4445 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4446 std::string ex(str, iter.base()); 4447 assert(ex == "*****************-0.00000"); 4448 assert(ios.width() == 0); 4449 } 4450 ios.width(25); 4451 internal(ios); 4452 { 4453 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4454 std::string ex(str, iter.base()); 4455 assert(ex == "-*****************0.00000"); 4456 assert(ios.width() == 0); 4457 } 4458 } 4459 ios.imbue(lg); 4460 { 4461 ios.width(0); 4462 { 4463 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4464 std::string ex(str, iter.base()); 4465 assert(ex == "-0;00000"); 4466 assert(ios.width() == 0); 4467 } 4468 ios.width(25); 4469 left(ios); 4470 { 4471 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4472 std::string ex(str, iter.base()); 4473 assert(ex == "-0;00000*****************"); 4474 assert(ios.width() == 0); 4475 } 4476 ios.width(25); 4477 right(ios); 4478 { 4479 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4480 std::string ex(str, iter.base()); 4481 assert(ex == "*****************-0;00000"); 4482 assert(ios.width() == 0); 4483 } 4484 ios.width(25); 4485 internal(ios); 4486 { 4487 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4488 std::string ex(str, iter.base()); 4489 assert(ex == "-*****************0;00000"); 4490 assert(ios.width() == 0); 4491 } 4492 } 4493 } 4494 } 4495 } 4496 uppercase(ios); 4497 { 4498 noshowpos(ios); 4499 { 4500 noshowpoint(ios); 4501 { 4502 ios.imbue(lc); 4503 { 4504 ios.width(0); 4505 { 4506 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4507 std::string ex(str, iter.base()); 4508 assert(ex == "-0"); 4509 assert(ios.width() == 0); 4510 } 4511 ios.width(25); 4512 left(ios); 4513 { 4514 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4515 std::string ex(str, iter.base()); 4516 assert(ex == "-0***********************"); 4517 assert(ios.width() == 0); 4518 } 4519 ios.width(25); 4520 right(ios); 4521 { 4522 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4523 std::string ex(str, iter.base()); 4524 assert(ex == "***********************-0"); 4525 assert(ios.width() == 0); 4526 } 4527 ios.width(25); 4528 internal(ios); 4529 { 4530 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4531 std::string ex(str, iter.base()); 4532 assert(ex == "-***********************0"); 4533 assert(ios.width() == 0); 4534 } 4535 } 4536 ios.imbue(lg); 4537 { 4538 ios.width(0); 4539 { 4540 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4541 std::string ex(str, iter.base()); 4542 assert(ex == "-0"); 4543 assert(ios.width() == 0); 4544 } 4545 ios.width(25); 4546 left(ios); 4547 { 4548 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4549 std::string ex(str, iter.base()); 4550 assert(ex == "-0***********************"); 4551 assert(ios.width() == 0); 4552 } 4553 ios.width(25); 4554 right(ios); 4555 { 4556 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4557 std::string ex(str, iter.base()); 4558 assert(ex == "***********************-0"); 4559 assert(ios.width() == 0); 4560 } 4561 ios.width(25); 4562 internal(ios); 4563 { 4564 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4565 std::string ex(str, iter.base()); 4566 assert(ex == "-***********************0"); 4567 assert(ios.width() == 0); 4568 } 4569 } 4570 } 4571 showpoint(ios); 4572 { 4573 ios.imbue(lc); 4574 { 4575 ios.width(0); 4576 { 4577 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4578 std::string ex(str, iter.base()); 4579 assert(ex == "-0.00000"); 4580 assert(ios.width() == 0); 4581 } 4582 ios.width(25); 4583 left(ios); 4584 { 4585 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4586 std::string ex(str, iter.base()); 4587 assert(ex == "-0.00000*****************"); 4588 assert(ios.width() == 0); 4589 } 4590 ios.width(25); 4591 right(ios); 4592 { 4593 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4594 std::string ex(str, iter.base()); 4595 assert(ex == "*****************-0.00000"); 4596 assert(ios.width() == 0); 4597 } 4598 ios.width(25); 4599 internal(ios); 4600 { 4601 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4602 std::string ex(str, iter.base()); 4603 assert(ex == "-*****************0.00000"); 4604 assert(ios.width() == 0); 4605 } 4606 } 4607 ios.imbue(lg); 4608 { 4609 ios.width(0); 4610 { 4611 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4612 std::string ex(str, iter.base()); 4613 assert(ex == "-0;00000"); 4614 assert(ios.width() == 0); 4615 } 4616 ios.width(25); 4617 left(ios); 4618 { 4619 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4620 std::string ex(str, iter.base()); 4621 assert(ex == "-0;00000*****************"); 4622 assert(ios.width() == 0); 4623 } 4624 ios.width(25); 4625 right(ios); 4626 { 4627 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4628 std::string ex(str, iter.base()); 4629 assert(ex == "*****************-0;00000"); 4630 assert(ios.width() == 0); 4631 } 4632 ios.width(25); 4633 internal(ios); 4634 { 4635 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4636 std::string ex(str, iter.base()); 4637 assert(ex == "-*****************0;00000"); 4638 assert(ios.width() == 0); 4639 } 4640 } 4641 } 4642 } 4643 showpos(ios); 4644 { 4645 noshowpoint(ios); 4646 { 4647 ios.imbue(lc); 4648 { 4649 ios.width(0); 4650 { 4651 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4652 std::string ex(str, iter.base()); 4653 assert(ex == "-0"); 4654 assert(ios.width() == 0); 4655 } 4656 ios.width(25); 4657 left(ios); 4658 { 4659 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4660 std::string ex(str, iter.base()); 4661 assert(ex == "-0***********************"); 4662 assert(ios.width() == 0); 4663 } 4664 ios.width(25); 4665 right(ios); 4666 { 4667 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4668 std::string ex(str, iter.base()); 4669 assert(ex == "***********************-0"); 4670 assert(ios.width() == 0); 4671 } 4672 ios.width(25); 4673 internal(ios); 4674 { 4675 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4676 std::string ex(str, iter.base()); 4677 assert(ex == "-***********************0"); 4678 assert(ios.width() == 0); 4679 } 4680 } 4681 ios.imbue(lg); 4682 { 4683 ios.width(0); 4684 { 4685 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4686 std::string ex(str, iter.base()); 4687 assert(ex == "-0"); 4688 assert(ios.width() == 0); 4689 } 4690 ios.width(25); 4691 left(ios); 4692 { 4693 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4694 std::string ex(str, iter.base()); 4695 assert(ex == "-0***********************"); 4696 assert(ios.width() == 0); 4697 } 4698 ios.width(25); 4699 right(ios); 4700 { 4701 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4702 std::string ex(str, iter.base()); 4703 assert(ex == "***********************-0"); 4704 assert(ios.width() == 0); 4705 } 4706 ios.width(25); 4707 internal(ios); 4708 { 4709 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4710 std::string ex(str, iter.base()); 4711 assert(ex == "-***********************0"); 4712 assert(ios.width() == 0); 4713 } 4714 } 4715 } 4716 showpoint(ios); 4717 { 4718 ios.imbue(lc); 4719 { 4720 ios.width(0); 4721 { 4722 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4723 std::string ex(str, iter.base()); 4724 assert(ex == "-0.00000"); 4725 assert(ios.width() == 0); 4726 } 4727 ios.width(25); 4728 left(ios); 4729 { 4730 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4731 std::string ex(str, iter.base()); 4732 assert(ex == "-0.00000*****************"); 4733 assert(ios.width() == 0); 4734 } 4735 ios.width(25); 4736 right(ios); 4737 { 4738 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4739 std::string ex(str, iter.base()); 4740 assert(ex == "*****************-0.00000"); 4741 assert(ios.width() == 0); 4742 } 4743 ios.width(25); 4744 internal(ios); 4745 { 4746 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4747 std::string ex(str, iter.base()); 4748 assert(ex == "-*****************0.00000"); 4749 assert(ios.width() == 0); 4750 } 4751 } 4752 ios.imbue(lg); 4753 { 4754 ios.width(0); 4755 { 4756 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4757 std::string ex(str, iter.base()); 4758 assert(ex == "-0;00000"); 4759 assert(ios.width() == 0); 4760 } 4761 ios.width(25); 4762 left(ios); 4763 { 4764 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4765 std::string ex(str, iter.base()); 4766 assert(ex == "-0;00000*****************"); 4767 assert(ios.width() == 0); 4768 } 4769 ios.width(25); 4770 right(ios); 4771 { 4772 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4773 std::string ex(str, iter.base()); 4774 assert(ex == "*****************-0;00000"); 4775 assert(ios.width() == 0); 4776 } 4777 ios.width(25); 4778 internal(ios); 4779 { 4780 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4781 std::string ex(str, iter.base()); 4782 assert(ex == "-*****************0;00000"); 4783 assert(ios.width() == 0); 4784 } 4785 } 4786 } 4787 } 4788 } 4789 } 4790 ios.precision(16); 4791 { 4792 nouppercase(ios); 4793 { 4794 noshowpos(ios); 4795 { 4796 noshowpoint(ios); 4797 { 4798 ios.imbue(lc); 4799 { 4800 ios.width(0); 4801 { 4802 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4803 std::string ex(str, iter.base()); 4804 assert(ex == "-0"); 4805 assert(ios.width() == 0); 4806 } 4807 ios.width(25); 4808 left(ios); 4809 { 4810 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4811 std::string ex(str, iter.base()); 4812 assert(ex == "-0***********************"); 4813 assert(ios.width() == 0); 4814 } 4815 ios.width(25); 4816 right(ios); 4817 { 4818 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4819 std::string ex(str, iter.base()); 4820 assert(ex == "***********************-0"); 4821 assert(ios.width() == 0); 4822 } 4823 ios.width(25); 4824 internal(ios); 4825 { 4826 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4827 std::string ex(str, iter.base()); 4828 assert(ex == "-***********************0"); 4829 assert(ios.width() == 0); 4830 } 4831 } 4832 ios.imbue(lg); 4833 { 4834 ios.width(0); 4835 { 4836 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4837 std::string ex(str, iter.base()); 4838 assert(ex == "-0"); 4839 assert(ios.width() == 0); 4840 } 4841 ios.width(25); 4842 left(ios); 4843 { 4844 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4845 std::string ex(str, iter.base()); 4846 assert(ex == "-0***********************"); 4847 assert(ios.width() == 0); 4848 } 4849 ios.width(25); 4850 right(ios); 4851 { 4852 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4853 std::string ex(str, iter.base()); 4854 assert(ex == "***********************-0"); 4855 assert(ios.width() == 0); 4856 } 4857 ios.width(25); 4858 internal(ios); 4859 { 4860 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4861 std::string ex(str, iter.base()); 4862 assert(ex == "-***********************0"); 4863 assert(ios.width() == 0); 4864 } 4865 } 4866 } 4867 showpoint(ios); 4868 { 4869 ios.imbue(lc); 4870 { 4871 ios.width(0); 4872 { 4873 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4874 std::string ex(str, iter.base()); 4875 assert(ex == "-0.000000000000000"); 4876 assert(ios.width() == 0); 4877 } 4878 ios.width(25); 4879 left(ios); 4880 { 4881 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4882 std::string ex(str, iter.base()); 4883 assert(ex == "-0.000000000000000*******"); 4884 assert(ios.width() == 0); 4885 } 4886 ios.width(25); 4887 right(ios); 4888 { 4889 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4890 std::string ex(str, iter.base()); 4891 assert(ex == "*******-0.000000000000000"); 4892 assert(ios.width() == 0); 4893 } 4894 ios.width(25); 4895 internal(ios); 4896 { 4897 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4898 std::string ex(str, iter.base()); 4899 assert(ex == "-*******0.000000000000000"); 4900 assert(ios.width() == 0); 4901 } 4902 } 4903 ios.imbue(lg); 4904 { 4905 ios.width(0); 4906 { 4907 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4908 std::string ex(str, iter.base()); 4909 assert(ex == "-0;000000000000000"); 4910 assert(ios.width() == 0); 4911 } 4912 ios.width(25); 4913 left(ios); 4914 { 4915 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4916 std::string ex(str, iter.base()); 4917 assert(ex == "-0;000000000000000*******"); 4918 assert(ios.width() == 0); 4919 } 4920 ios.width(25); 4921 right(ios); 4922 { 4923 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4924 std::string ex(str, iter.base()); 4925 assert(ex == "*******-0;000000000000000"); 4926 assert(ios.width() == 0); 4927 } 4928 ios.width(25); 4929 internal(ios); 4930 { 4931 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4932 std::string ex(str, iter.base()); 4933 assert(ex == "-*******0;000000000000000"); 4934 assert(ios.width() == 0); 4935 } 4936 } 4937 } 4938 } 4939 showpos(ios); 4940 { 4941 noshowpoint(ios); 4942 { 4943 ios.imbue(lc); 4944 { 4945 ios.width(0); 4946 { 4947 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4948 std::string ex(str, iter.base()); 4949 assert(ex == "-0"); 4950 assert(ios.width() == 0); 4951 } 4952 ios.width(25); 4953 left(ios); 4954 { 4955 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4956 std::string ex(str, iter.base()); 4957 assert(ex == "-0***********************"); 4958 assert(ios.width() == 0); 4959 } 4960 ios.width(25); 4961 right(ios); 4962 { 4963 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4964 std::string ex(str, iter.base()); 4965 assert(ex == "***********************-0"); 4966 assert(ios.width() == 0); 4967 } 4968 ios.width(25); 4969 internal(ios); 4970 { 4971 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4972 std::string ex(str, iter.base()); 4973 assert(ex == "-***********************0"); 4974 assert(ios.width() == 0); 4975 } 4976 } 4977 ios.imbue(lg); 4978 { 4979 ios.width(0); 4980 { 4981 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4982 std::string ex(str, iter.base()); 4983 assert(ex == "-0"); 4984 assert(ios.width() == 0); 4985 } 4986 ios.width(25); 4987 left(ios); 4988 { 4989 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4990 std::string ex(str, iter.base()); 4991 assert(ex == "-0***********************"); 4992 assert(ios.width() == 0); 4993 } 4994 ios.width(25); 4995 right(ios); 4996 { 4997 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4998 std::string ex(str, iter.base()); 4999 assert(ex == "***********************-0"); 5000 assert(ios.width() == 0); 5001 } 5002 ios.width(25); 5003 internal(ios); 5004 { 5005 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5006 std::string ex(str, iter.base()); 5007 assert(ex == "-***********************0"); 5008 assert(ios.width() == 0); 5009 } 5010 } 5011 } 5012 showpoint(ios); 5013 { 5014 ios.imbue(lc); 5015 { 5016 ios.width(0); 5017 { 5018 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5019 std::string ex(str, iter.base()); 5020 assert(ex == "-0.000000000000000"); 5021 assert(ios.width() == 0); 5022 } 5023 ios.width(25); 5024 left(ios); 5025 { 5026 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5027 std::string ex(str, iter.base()); 5028 assert(ex == "-0.000000000000000*******"); 5029 assert(ios.width() == 0); 5030 } 5031 ios.width(25); 5032 right(ios); 5033 { 5034 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5035 std::string ex(str, iter.base()); 5036 assert(ex == "*******-0.000000000000000"); 5037 assert(ios.width() == 0); 5038 } 5039 ios.width(25); 5040 internal(ios); 5041 { 5042 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5043 std::string ex(str, iter.base()); 5044 assert(ex == "-*******0.000000000000000"); 5045 assert(ios.width() == 0); 5046 } 5047 } 5048 ios.imbue(lg); 5049 { 5050 ios.width(0); 5051 { 5052 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5053 std::string ex(str, iter.base()); 5054 assert(ex == "-0;000000000000000"); 5055 assert(ios.width() == 0); 5056 } 5057 ios.width(25); 5058 left(ios); 5059 { 5060 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5061 std::string ex(str, iter.base()); 5062 assert(ex == "-0;000000000000000*******"); 5063 assert(ios.width() == 0); 5064 } 5065 ios.width(25); 5066 right(ios); 5067 { 5068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5069 std::string ex(str, iter.base()); 5070 assert(ex == "*******-0;000000000000000"); 5071 assert(ios.width() == 0); 5072 } 5073 ios.width(25); 5074 internal(ios); 5075 { 5076 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5077 std::string ex(str, iter.base()); 5078 assert(ex == "-*******0;000000000000000"); 5079 assert(ios.width() == 0); 5080 } 5081 } 5082 } 5083 } 5084 } 5085 uppercase(ios); 5086 { 5087 noshowpos(ios); 5088 { 5089 noshowpoint(ios); 5090 { 5091 ios.imbue(lc); 5092 { 5093 ios.width(0); 5094 { 5095 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5096 std::string ex(str, iter.base()); 5097 assert(ex == "-0"); 5098 assert(ios.width() == 0); 5099 } 5100 ios.width(25); 5101 left(ios); 5102 { 5103 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5104 std::string ex(str, iter.base()); 5105 assert(ex == "-0***********************"); 5106 assert(ios.width() == 0); 5107 } 5108 ios.width(25); 5109 right(ios); 5110 { 5111 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5112 std::string ex(str, iter.base()); 5113 assert(ex == "***********************-0"); 5114 assert(ios.width() == 0); 5115 } 5116 ios.width(25); 5117 internal(ios); 5118 { 5119 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5120 std::string ex(str, iter.base()); 5121 assert(ex == "-***********************0"); 5122 assert(ios.width() == 0); 5123 } 5124 } 5125 ios.imbue(lg); 5126 { 5127 ios.width(0); 5128 { 5129 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5130 std::string ex(str, iter.base()); 5131 assert(ex == "-0"); 5132 assert(ios.width() == 0); 5133 } 5134 ios.width(25); 5135 left(ios); 5136 { 5137 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5138 std::string ex(str, iter.base()); 5139 assert(ex == "-0***********************"); 5140 assert(ios.width() == 0); 5141 } 5142 ios.width(25); 5143 right(ios); 5144 { 5145 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5146 std::string ex(str, iter.base()); 5147 assert(ex == "***********************-0"); 5148 assert(ios.width() == 0); 5149 } 5150 ios.width(25); 5151 internal(ios); 5152 { 5153 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5154 std::string ex(str, iter.base()); 5155 assert(ex == "-***********************0"); 5156 assert(ios.width() == 0); 5157 } 5158 } 5159 } 5160 showpoint(ios); 5161 { 5162 ios.imbue(lc); 5163 { 5164 ios.width(0); 5165 { 5166 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5167 std::string ex(str, iter.base()); 5168 assert(ex == "-0.000000000000000"); 5169 assert(ios.width() == 0); 5170 } 5171 ios.width(25); 5172 left(ios); 5173 { 5174 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5175 std::string ex(str, iter.base()); 5176 assert(ex == "-0.000000000000000*******"); 5177 assert(ios.width() == 0); 5178 } 5179 ios.width(25); 5180 right(ios); 5181 { 5182 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5183 std::string ex(str, iter.base()); 5184 assert(ex == "*******-0.000000000000000"); 5185 assert(ios.width() == 0); 5186 } 5187 ios.width(25); 5188 internal(ios); 5189 { 5190 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5191 std::string ex(str, iter.base()); 5192 assert(ex == "-*******0.000000000000000"); 5193 assert(ios.width() == 0); 5194 } 5195 } 5196 ios.imbue(lg); 5197 { 5198 ios.width(0); 5199 { 5200 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5201 std::string ex(str, iter.base()); 5202 assert(ex == "-0;000000000000000"); 5203 assert(ios.width() == 0); 5204 } 5205 ios.width(25); 5206 left(ios); 5207 { 5208 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5209 std::string ex(str, iter.base()); 5210 assert(ex == "-0;000000000000000*******"); 5211 assert(ios.width() == 0); 5212 } 5213 ios.width(25); 5214 right(ios); 5215 { 5216 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5217 std::string ex(str, iter.base()); 5218 assert(ex == "*******-0;000000000000000"); 5219 assert(ios.width() == 0); 5220 } 5221 ios.width(25); 5222 internal(ios); 5223 { 5224 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5225 std::string ex(str, iter.base()); 5226 assert(ex == "-*******0;000000000000000"); 5227 assert(ios.width() == 0); 5228 } 5229 } 5230 } 5231 } 5232 showpos(ios); 5233 { 5234 noshowpoint(ios); 5235 { 5236 ios.imbue(lc); 5237 { 5238 ios.width(0); 5239 { 5240 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5241 std::string ex(str, iter.base()); 5242 assert(ex == "-0"); 5243 assert(ios.width() == 0); 5244 } 5245 ios.width(25); 5246 left(ios); 5247 { 5248 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5249 std::string ex(str, iter.base()); 5250 assert(ex == "-0***********************"); 5251 assert(ios.width() == 0); 5252 } 5253 ios.width(25); 5254 right(ios); 5255 { 5256 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5257 std::string ex(str, iter.base()); 5258 assert(ex == "***********************-0"); 5259 assert(ios.width() == 0); 5260 } 5261 ios.width(25); 5262 internal(ios); 5263 { 5264 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5265 std::string ex(str, iter.base()); 5266 assert(ex == "-***********************0"); 5267 assert(ios.width() == 0); 5268 } 5269 } 5270 ios.imbue(lg); 5271 { 5272 ios.width(0); 5273 { 5274 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5275 std::string ex(str, iter.base()); 5276 assert(ex == "-0"); 5277 assert(ios.width() == 0); 5278 } 5279 ios.width(25); 5280 left(ios); 5281 { 5282 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5283 std::string ex(str, iter.base()); 5284 assert(ex == "-0***********************"); 5285 assert(ios.width() == 0); 5286 } 5287 ios.width(25); 5288 right(ios); 5289 { 5290 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5291 std::string ex(str, iter.base()); 5292 assert(ex == "***********************-0"); 5293 assert(ios.width() == 0); 5294 } 5295 ios.width(25); 5296 internal(ios); 5297 { 5298 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5299 std::string ex(str, iter.base()); 5300 assert(ex == "-***********************0"); 5301 assert(ios.width() == 0); 5302 } 5303 } 5304 } 5305 showpoint(ios); 5306 { 5307 ios.imbue(lc); 5308 { 5309 ios.width(0); 5310 { 5311 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5312 std::string ex(str, iter.base()); 5313 assert(ex == "-0.000000000000000"); 5314 assert(ios.width() == 0); 5315 } 5316 ios.width(25); 5317 left(ios); 5318 { 5319 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5320 std::string ex(str, iter.base()); 5321 assert(ex == "-0.000000000000000*******"); 5322 assert(ios.width() == 0); 5323 } 5324 ios.width(25); 5325 right(ios); 5326 { 5327 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5328 std::string ex(str, iter.base()); 5329 assert(ex == "*******-0.000000000000000"); 5330 assert(ios.width() == 0); 5331 } 5332 ios.width(25); 5333 internal(ios); 5334 { 5335 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5336 std::string ex(str, iter.base()); 5337 assert(ex == "-*******0.000000000000000"); 5338 assert(ios.width() == 0); 5339 } 5340 } 5341 ios.imbue(lg); 5342 { 5343 ios.width(0); 5344 { 5345 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5346 std::string ex(str, iter.base()); 5347 assert(ex == "-0;000000000000000"); 5348 assert(ios.width() == 0); 5349 } 5350 ios.width(25); 5351 left(ios); 5352 { 5353 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5354 std::string ex(str, iter.base()); 5355 assert(ex == "-0;000000000000000*******"); 5356 assert(ios.width() == 0); 5357 } 5358 ios.width(25); 5359 right(ios); 5360 { 5361 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5362 std::string ex(str, iter.base()); 5363 assert(ex == "*******-0;000000000000000"); 5364 assert(ios.width() == 0); 5365 } 5366 ios.width(25); 5367 internal(ios); 5368 { 5369 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5370 std::string ex(str, iter.base()); 5371 assert(ex == "-*******0;000000000000000"); 5372 assert(ios.width() == 0); 5373 } 5374 } 5375 } 5376 } 5377 } 5378 } 5379 ios.precision(60); 5380 { 5381 nouppercase(ios); 5382 { 5383 noshowpos(ios); 5384 { 5385 noshowpoint(ios); 5386 { 5387 ios.imbue(lc); 5388 { 5389 ios.width(0); 5390 { 5391 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5392 std::string ex(str, iter.base()); 5393 assert(ex == "-0"); 5394 assert(ios.width() == 0); 5395 } 5396 ios.width(25); 5397 left(ios); 5398 { 5399 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5400 std::string ex(str, iter.base()); 5401 assert(ex == "-0***********************"); 5402 assert(ios.width() == 0); 5403 } 5404 ios.width(25); 5405 right(ios); 5406 { 5407 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5408 std::string ex(str, iter.base()); 5409 assert(ex == "***********************-0"); 5410 assert(ios.width() == 0); 5411 } 5412 ios.width(25); 5413 internal(ios); 5414 { 5415 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5416 std::string ex(str, iter.base()); 5417 assert(ex == "-***********************0"); 5418 assert(ios.width() == 0); 5419 } 5420 } 5421 ios.imbue(lg); 5422 { 5423 ios.width(0); 5424 { 5425 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5426 std::string ex(str, iter.base()); 5427 assert(ex == "-0"); 5428 assert(ios.width() == 0); 5429 } 5430 ios.width(25); 5431 left(ios); 5432 { 5433 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5434 std::string ex(str, iter.base()); 5435 assert(ex == "-0***********************"); 5436 assert(ios.width() == 0); 5437 } 5438 ios.width(25); 5439 right(ios); 5440 { 5441 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5442 std::string ex(str, iter.base()); 5443 assert(ex == "***********************-0"); 5444 assert(ios.width() == 0); 5445 } 5446 ios.width(25); 5447 internal(ios); 5448 { 5449 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5450 std::string ex(str, iter.base()); 5451 assert(ex == "-***********************0"); 5452 assert(ios.width() == 0); 5453 } 5454 } 5455 } 5456 showpoint(ios); 5457 { 5458 ios.imbue(lc); 5459 { 5460 ios.width(0); 5461 { 5462 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5463 std::string ex(str, iter.base()); 5464 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5465 assert(ios.width() == 0); 5466 } 5467 ios.width(25); 5468 left(ios); 5469 { 5470 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5471 std::string ex(str, iter.base()); 5472 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5473 assert(ios.width() == 0); 5474 } 5475 ios.width(25); 5476 right(ios); 5477 { 5478 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5479 std::string ex(str, iter.base()); 5480 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5481 assert(ios.width() == 0); 5482 } 5483 ios.width(25); 5484 internal(ios); 5485 { 5486 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5487 std::string ex(str, iter.base()); 5488 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5489 assert(ios.width() == 0); 5490 } 5491 } 5492 ios.imbue(lg); 5493 { 5494 ios.width(0); 5495 { 5496 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5497 std::string ex(str, iter.base()); 5498 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5499 assert(ios.width() == 0); 5500 } 5501 ios.width(25); 5502 left(ios); 5503 { 5504 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5505 std::string ex(str, iter.base()); 5506 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5507 assert(ios.width() == 0); 5508 } 5509 ios.width(25); 5510 right(ios); 5511 { 5512 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5513 std::string ex(str, iter.base()); 5514 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5515 assert(ios.width() == 0); 5516 } 5517 ios.width(25); 5518 internal(ios); 5519 { 5520 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5521 std::string ex(str, iter.base()); 5522 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5523 assert(ios.width() == 0); 5524 } 5525 } 5526 } 5527 } 5528 showpos(ios); 5529 { 5530 noshowpoint(ios); 5531 { 5532 ios.imbue(lc); 5533 { 5534 ios.width(0); 5535 { 5536 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5537 std::string ex(str, iter.base()); 5538 assert(ex == "-0"); 5539 assert(ios.width() == 0); 5540 } 5541 ios.width(25); 5542 left(ios); 5543 { 5544 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5545 std::string ex(str, iter.base()); 5546 assert(ex == "-0***********************"); 5547 assert(ios.width() == 0); 5548 } 5549 ios.width(25); 5550 right(ios); 5551 { 5552 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5553 std::string ex(str, iter.base()); 5554 assert(ex == "***********************-0"); 5555 assert(ios.width() == 0); 5556 } 5557 ios.width(25); 5558 internal(ios); 5559 { 5560 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5561 std::string ex(str, iter.base()); 5562 assert(ex == "-***********************0"); 5563 assert(ios.width() == 0); 5564 } 5565 } 5566 ios.imbue(lg); 5567 { 5568 ios.width(0); 5569 { 5570 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5571 std::string ex(str, iter.base()); 5572 assert(ex == "-0"); 5573 assert(ios.width() == 0); 5574 } 5575 ios.width(25); 5576 left(ios); 5577 { 5578 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5579 std::string ex(str, iter.base()); 5580 assert(ex == "-0***********************"); 5581 assert(ios.width() == 0); 5582 } 5583 ios.width(25); 5584 right(ios); 5585 { 5586 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5587 std::string ex(str, iter.base()); 5588 assert(ex == "***********************-0"); 5589 assert(ios.width() == 0); 5590 } 5591 ios.width(25); 5592 internal(ios); 5593 { 5594 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5595 std::string ex(str, iter.base()); 5596 assert(ex == "-***********************0"); 5597 assert(ios.width() == 0); 5598 } 5599 } 5600 } 5601 showpoint(ios); 5602 { 5603 ios.imbue(lc); 5604 { 5605 ios.width(0); 5606 { 5607 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5608 std::string ex(str, iter.base()); 5609 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5610 assert(ios.width() == 0); 5611 } 5612 ios.width(25); 5613 left(ios); 5614 { 5615 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5616 std::string ex(str, iter.base()); 5617 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5618 assert(ios.width() == 0); 5619 } 5620 ios.width(25); 5621 right(ios); 5622 { 5623 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5624 std::string ex(str, iter.base()); 5625 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5626 assert(ios.width() == 0); 5627 } 5628 ios.width(25); 5629 internal(ios); 5630 { 5631 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5632 std::string ex(str, iter.base()); 5633 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5634 assert(ios.width() == 0); 5635 } 5636 } 5637 ios.imbue(lg); 5638 { 5639 ios.width(0); 5640 { 5641 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5642 std::string ex(str, iter.base()); 5643 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5644 assert(ios.width() == 0); 5645 } 5646 ios.width(25); 5647 left(ios); 5648 { 5649 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5650 std::string ex(str, iter.base()); 5651 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5652 assert(ios.width() == 0); 5653 } 5654 ios.width(25); 5655 right(ios); 5656 { 5657 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5658 std::string ex(str, iter.base()); 5659 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5660 assert(ios.width() == 0); 5661 } 5662 ios.width(25); 5663 internal(ios); 5664 { 5665 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5666 std::string ex(str, iter.base()); 5667 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5668 assert(ios.width() == 0); 5669 } 5670 } 5671 } 5672 } 5673 } 5674 uppercase(ios); 5675 { 5676 noshowpos(ios); 5677 { 5678 noshowpoint(ios); 5679 { 5680 ios.imbue(lc); 5681 { 5682 ios.width(0); 5683 { 5684 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5685 std::string ex(str, iter.base()); 5686 assert(ex == "-0"); 5687 assert(ios.width() == 0); 5688 } 5689 ios.width(25); 5690 left(ios); 5691 { 5692 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5693 std::string ex(str, iter.base()); 5694 assert(ex == "-0***********************"); 5695 assert(ios.width() == 0); 5696 } 5697 ios.width(25); 5698 right(ios); 5699 { 5700 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5701 std::string ex(str, iter.base()); 5702 assert(ex == "***********************-0"); 5703 assert(ios.width() == 0); 5704 } 5705 ios.width(25); 5706 internal(ios); 5707 { 5708 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5709 std::string ex(str, iter.base()); 5710 assert(ex == "-***********************0"); 5711 assert(ios.width() == 0); 5712 } 5713 } 5714 ios.imbue(lg); 5715 { 5716 ios.width(0); 5717 { 5718 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5719 std::string ex(str, iter.base()); 5720 assert(ex == "-0"); 5721 assert(ios.width() == 0); 5722 } 5723 ios.width(25); 5724 left(ios); 5725 { 5726 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5727 std::string ex(str, iter.base()); 5728 assert(ex == "-0***********************"); 5729 assert(ios.width() == 0); 5730 } 5731 ios.width(25); 5732 right(ios); 5733 { 5734 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5735 std::string ex(str, iter.base()); 5736 assert(ex == "***********************-0"); 5737 assert(ios.width() == 0); 5738 } 5739 ios.width(25); 5740 internal(ios); 5741 { 5742 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5743 std::string ex(str, iter.base()); 5744 assert(ex == "-***********************0"); 5745 assert(ios.width() == 0); 5746 } 5747 } 5748 } 5749 showpoint(ios); 5750 { 5751 ios.imbue(lc); 5752 { 5753 ios.width(0); 5754 { 5755 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5756 std::string ex(str, iter.base()); 5757 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5758 assert(ios.width() == 0); 5759 } 5760 ios.width(25); 5761 left(ios); 5762 { 5763 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5764 std::string ex(str, iter.base()); 5765 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5766 assert(ios.width() == 0); 5767 } 5768 ios.width(25); 5769 right(ios); 5770 { 5771 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5772 std::string ex(str, iter.base()); 5773 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5774 assert(ios.width() == 0); 5775 } 5776 ios.width(25); 5777 internal(ios); 5778 { 5779 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5780 std::string ex(str, iter.base()); 5781 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5782 assert(ios.width() == 0); 5783 } 5784 } 5785 ios.imbue(lg); 5786 { 5787 ios.width(0); 5788 { 5789 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5790 std::string ex(str, iter.base()); 5791 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5792 assert(ios.width() == 0); 5793 } 5794 ios.width(25); 5795 left(ios); 5796 { 5797 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5798 std::string ex(str, iter.base()); 5799 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5800 assert(ios.width() == 0); 5801 } 5802 ios.width(25); 5803 right(ios); 5804 { 5805 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5806 std::string ex(str, iter.base()); 5807 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5808 assert(ios.width() == 0); 5809 } 5810 ios.width(25); 5811 internal(ios); 5812 { 5813 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5814 std::string ex(str, iter.base()); 5815 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5816 assert(ios.width() == 0); 5817 } 5818 } 5819 } 5820 } 5821 showpos(ios); 5822 { 5823 noshowpoint(ios); 5824 { 5825 ios.imbue(lc); 5826 { 5827 ios.width(0); 5828 { 5829 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5830 std::string ex(str, iter.base()); 5831 assert(ex == "-0"); 5832 assert(ios.width() == 0); 5833 } 5834 ios.width(25); 5835 left(ios); 5836 { 5837 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5838 std::string ex(str, iter.base()); 5839 assert(ex == "-0***********************"); 5840 assert(ios.width() == 0); 5841 } 5842 ios.width(25); 5843 right(ios); 5844 { 5845 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5846 std::string ex(str, iter.base()); 5847 assert(ex == "***********************-0"); 5848 assert(ios.width() == 0); 5849 } 5850 ios.width(25); 5851 internal(ios); 5852 { 5853 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5854 std::string ex(str, iter.base()); 5855 assert(ex == "-***********************0"); 5856 assert(ios.width() == 0); 5857 } 5858 } 5859 ios.imbue(lg); 5860 { 5861 ios.width(0); 5862 { 5863 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5864 std::string ex(str, iter.base()); 5865 assert(ex == "-0"); 5866 assert(ios.width() == 0); 5867 } 5868 ios.width(25); 5869 left(ios); 5870 { 5871 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5872 std::string ex(str, iter.base()); 5873 assert(ex == "-0***********************"); 5874 assert(ios.width() == 0); 5875 } 5876 ios.width(25); 5877 right(ios); 5878 { 5879 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5880 std::string ex(str, iter.base()); 5881 assert(ex == "***********************-0"); 5882 assert(ios.width() == 0); 5883 } 5884 ios.width(25); 5885 internal(ios); 5886 { 5887 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5888 std::string ex(str, iter.base()); 5889 assert(ex == "-***********************0"); 5890 assert(ios.width() == 0); 5891 } 5892 } 5893 } 5894 showpoint(ios); 5895 { 5896 ios.imbue(lc); 5897 { 5898 ios.width(0); 5899 { 5900 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5901 std::string ex(str, iter.base()); 5902 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5903 assert(ios.width() == 0); 5904 } 5905 ios.width(25); 5906 left(ios); 5907 { 5908 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5909 std::string ex(str, iter.base()); 5910 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5911 assert(ios.width() == 0); 5912 } 5913 ios.width(25); 5914 right(ios); 5915 { 5916 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5917 std::string ex(str, iter.base()); 5918 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5919 assert(ios.width() == 0); 5920 } 5921 ios.width(25); 5922 internal(ios); 5923 { 5924 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5925 std::string ex(str, iter.base()); 5926 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5927 assert(ios.width() == 0); 5928 } 5929 } 5930 ios.imbue(lg); 5931 { 5932 ios.width(0); 5933 { 5934 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5935 std::string ex(str, iter.base()); 5936 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5937 assert(ios.width() == 0); 5938 } 5939 ios.width(25); 5940 left(ios); 5941 { 5942 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5943 std::string ex(str, iter.base()); 5944 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5945 assert(ios.width() == 0); 5946 } 5947 ios.width(25); 5948 right(ios); 5949 { 5950 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5951 std::string ex(str, iter.base()); 5952 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5953 assert(ios.width() == 0); 5954 } 5955 ios.width(25); 5956 internal(ios); 5957 { 5958 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5959 std::string ex(str, iter.base()); 5960 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5961 assert(ios.width() == 0); 5962 } 5963 } 5964 } 5965 } 5966 } 5967 } 5968 } 5969 } 5970 } 5971 5972 void test3() 5973 { 5974 char str[200]; 5975 output_iterator<char*> iter; 5976 std::locale lc = std::locale::classic(); 5977 std::locale lg(lc, new my_numpunct); 5978 const my_facet f(1); 5979 { 5980 long double v = 1234567890.125; 5981 std::ios ios(0); 5982 // %g 5983 { 5984 ios.precision(0); 5985 { 5986 nouppercase(ios); 5987 { 5988 noshowpos(ios); 5989 { 5990 noshowpoint(ios); 5991 { 5992 ios.imbue(lc); 5993 { 5994 ios.width(0); 5995 { 5996 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5997 std::string ex(str, iter.base()); 5998 assert(ex == "1e+09"); 5999 assert(ios.width() == 0); 6000 } 6001 ios.width(25); 6002 left(ios); 6003 { 6004 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6005 std::string ex(str, iter.base()); 6006 assert(ex == "1e+09********************"); 6007 assert(ios.width() == 0); 6008 } 6009 ios.width(25); 6010 right(ios); 6011 { 6012 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6013 std::string ex(str, iter.base()); 6014 assert(ex == "********************1e+09"); 6015 assert(ios.width() == 0); 6016 } 6017 ios.width(25); 6018 internal(ios); 6019 { 6020 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6021 std::string ex(str, iter.base()); 6022 assert(ex == "********************1e+09"); 6023 assert(ios.width() == 0); 6024 } 6025 } 6026 ios.imbue(lg); 6027 { 6028 ios.width(0); 6029 { 6030 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6031 std::string ex(str, iter.base()); 6032 assert(ex == "1e+09"); 6033 assert(ios.width() == 0); 6034 } 6035 ios.width(25); 6036 left(ios); 6037 { 6038 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6039 std::string ex(str, iter.base()); 6040 assert(ex == "1e+09********************"); 6041 assert(ios.width() == 0); 6042 } 6043 ios.width(25); 6044 right(ios); 6045 { 6046 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6047 std::string ex(str, iter.base()); 6048 assert(ex == "********************1e+09"); 6049 assert(ios.width() == 0); 6050 } 6051 ios.width(25); 6052 internal(ios); 6053 { 6054 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6055 std::string ex(str, iter.base()); 6056 assert(ex == "********************1e+09"); 6057 assert(ios.width() == 0); 6058 } 6059 } 6060 } 6061 showpoint(ios); 6062 { 6063 ios.imbue(lc); 6064 { 6065 ios.width(0); 6066 { 6067 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6068 std::string ex(str, iter.base()); 6069 assert(ex == "1.e+09"); 6070 assert(ios.width() == 0); 6071 } 6072 ios.width(25); 6073 left(ios); 6074 { 6075 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6076 std::string ex(str, iter.base()); 6077 assert(ex == "1.e+09*******************"); 6078 assert(ios.width() == 0); 6079 } 6080 ios.width(25); 6081 right(ios); 6082 { 6083 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6084 std::string ex(str, iter.base()); 6085 assert(ex == "*******************1.e+09"); 6086 assert(ios.width() == 0); 6087 } 6088 ios.width(25); 6089 internal(ios); 6090 { 6091 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6092 std::string ex(str, iter.base()); 6093 assert(ex == "*******************1.e+09"); 6094 assert(ios.width() == 0); 6095 } 6096 } 6097 ios.imbue(lg); 6098 { 6099 ios.width(0); 6100 { 6101 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6102 std::string ex(str, iter.base()); 6103 assert(ex == "1;e+09"); 6104 assert(ios.width() == 0); 6105 } 6106 ios.width(25); 6107 left(ios); 6108 { 6109 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6110 std::string ex(str, iter.base()); 6111 assert(ex == "1;e+09*******************"); 6112 assert(ios.width() == 0); 6113 } 6114 ios.width(25); 6115 right(ios); 6116 { 6117 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6118 std::string ex(str, iter.base()); 6119 assert(ex == "*******************1;e+09"); 6120 assert(ios.width() == 0); 6121 } 6122 ios.width(25); 6123 internal(ios); 6124 { 6125 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6126 std::string ex(str, iter.base()); 6127 assert(ex == "*******************1;e+09"); 6128 assert(ios.width() == 0); 6129 } 6130 } 6131 } 6132 } 6133 showpos(ios); 6134 { 6135 noshowpoint(ios); 6136 { 6137 ios.imbue(lc); 6138 { 6139 ios.width(0); 6140 { 6141 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6142 std::string ex(str, iter.base()); 6143 assert(ex == "+1e+09"); 6144 assert(ios.width() == 0); 6145 } 6146 ios.width(25); 6147 left(ios); 6148 { 6149 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6150 std::string ex(str, iter.base()); 6151 assert(ex == "+1e+09*******************"); 6152 assert(ios.width() == 0); 6153 } 6154 ios.width(25); 6155 right(ios); 6156 { 6157 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6158 std::string ex(str, iter.base()); 6159 assert(ex == "*******************+1e+09"); 6160 assert(ios.width() == 0); 6161 } 6162 ios.width(25); 6163 internal(ios); 6164 { 6165 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6166 std::string ex(str, iter.base()); 6167 assert(ex == "+*******************1e+09"); 6168 assert(ios.width() == 0); 6169 } 6170 } 6171 ios.imbue(lg); 6172 { 6173 ios.width(0); 6174 { 6175 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6176 std::string ex(str, iter.base()); 6177 assert(ex == "+1e+09"); 6178 assert(ios.width() == 0); 6179 } 6180 ios.width(25); 6181 left(ios); 6182 { 6183 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6184 std::string ex(str, iter.base()); 6185 assert(ex == "+1e+09*******************"); 6186 assert(ios.width() == 0); 6187 } 6188 ios.width(25); 6189 right(ios); 6190 { 6191 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6192 std::string ex(str, iter.base()); 6193 assert(ex == "*******************+1e+09"); 6194 assert(ios.width() == 0); 6195 } 6196 ios.width(25); 6197 internal(ios); 6198 { 6199 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6200 std::string ex(str, iter.base()); 6201 assert(ex == "+*******************1e+09"); 6202 assert(ios.width() == 0); 6203 } 6204 } 6205 } 6206 showpoint(ios); 6207 { 6208 ios.imbue(lc); 6209 { 6210 ios.width(0); 6211 { 6212 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6213 std::string ex(str, iter.base()); 6214 assert(ex == "+1.e+09"); 6215 assert(ios.width() == 0); 6216 } 6217 ios.width(25); 6218 left(ios); 6219 { 6220 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6221 std::string ex(str, iter.base()); 6222 assert(ex == "+1.e+09******************"); 6223 assert(ios.width() == 0); 6224 } 6225 ios.width(25); 6226 right(ios); 6227 { 6228 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6229 std::string ex(str, iter.base()); 6230 assert(ex == "******************+1.e+09"); 6231 assert(ios.width() == 0); 6232 } 6233 ios.width(25); 6234 internal(ios); 6235 { 6236 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6237 std::string ex(str, iter.base()); 6238 assert(ex == "+******************1.e+09"); 6239 assert(ios.width() == 0); 6240 } 6241 } 6242 ios.imbue(lg); 6243 { 6244 ios.width(0); 6245 { 6246 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6247 std::string ex(str, iter.base()); 6248 assert(ex == "+1;e+09"); 6249 assert(ios.width() == 0); 6250 } 6251 ios.width(25); 6252 left(ios); 6253 { 6254 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6255 std::string ex(str, iter.base()); 6256 assert(ex == "+1;e+09******************"); 6257 assert(ios.width() == 0); 6258 } 6259 ios.width(25); 6260 right(ios); 6261 { 6262 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6263 std::string ex(str, iter.base()); 6264 assert(ex == "******************+1;e+09"); 6265 assert(ios.width() == 0); 6266 } 6267 ios.width(25); 6268 internal(ios); 6269 { 6270 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6271 std::string ex(str, iter.base()); 6272 assert(ex == "+******************1;e+09"); 6273 assert(ios.width() == 0); 6274 } 6275 } 6276 } 6277 } 6278 } 6279 uppercase(ios); 6280 { 6281 noshowpos(ios); 6282 { 6283 noshowpoint(ios); 6284 { 6285 ios.imbue(lc); 6286 { 6287 ios.width(0); 6288 { 6289 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6290 std::string ex(str, iter.base()); 6291 assert(ex == "1E+09"); 6292 assert(ios.width() == 0); 6293 } 6294 ios.width(25); 6295 left(ios); 6296 { 6297 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6298 std::string ex(str, iter.base()); 6299 assert(ex == "1E+09********************"); 6300 assert(ios.width() == 0); 6301 } 6302 ios.width(25); 6303 right(ios); 6304 { 6305 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6306 std::string ex(str, iter.base()); 6307 assert(ex == "********************1E+09"); 6308 assert(ios.width() == 0); 6309 } 6310 ios.width(25); 6311 internal(ios); 6312 { 6313 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6314 std::string ex(str, iter.base()); 6315 assert(ex == "********************1E+09"); 6316 assert(ios.width() == 0); 6317 } 6318 } 6319 ios.imbue(lg); 6320 { 6321 ios.width(0); 6322 { 6323 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6324 std::string ex(str, iter.base()); 6325 assert(ex == "1E+09"); 6326 assert(ios.width() == 0); 6327 } 6328 ios.width(25); 6329 left(ios); 6330 { 6331 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6332 std::string ex(str, iter.base()); 6333 assert(ex == "1E+09********************"); 6334 assert(ios.width() == 0); 6335 } 6336 ios.width(25); 6337 right(ios); 6338 { 6339 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6340 std::string ex(str, iter.base()); 6341 assert(ex == "********************1E+09"); 6342 assert(ios.width() == 0); 6343 } 6344 ios.width(25); 6345 internal(ios); 6346 { 6347 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6348 std::string ex(str, iter.base()); 6349 assert(ex == "********************1E+09"); 6350 assert(ios.width() == 0); 6351 } 6352 } 6353 } 6354 showpoint(ios); 6355 { 6356 ios.imbue(lc); 6357 { 6358 ios.width(0); 6359 { 6360 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6361 std::string ex(str, iter.base()); 6362 assert(ex == "1.E+09"); 6363 assert(ios.width() == 0); 6364 } 6365 ios.width(25); 6366 left(ios); 6367 { 6368 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6369 std::string ex(str, iter.base()); 6370 assert(ex == "1.E+09*******************"); 6371 assert(ios.width() == 0); 6372 } 6373 ios.width(25); 6374 right(ios); 6375 { 6376 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6377 std::string ex(str, iter.base()); 6378 assert(ex == "*******************1.E+09"); 6379 assert(ios.width() == 0); 6380 } 6381 ios.width(25); 6382 internal(ios); 6383 { 6384 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6385 std::string ex(str, iter.base()); 6386 assert(ex == "*******************1.E+09"); 6387 assert(ios.width() == 0); 6388 } 6389 } 6390 ios.imbue(lg); 6391 { 6392 ios.width(0); 6393 { 6394 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6395 std::string ex(str, iter.base()); 6396 assert(ex == "1;E+09"); 6397 assert(ios.width() == 0); 6398 } 6399 ios.width(25); 6400 left(ios); 6401 { 6402 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6403 std::string ex(str, iter.base()); 6404 assert(ex == "1;E+09*******************"); 6405 assert(ios.width() == 0); 6406 } 6407 ios.width(25); 6408 right(ios); 6409 { 6410 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6411 std::string ex(str, iter.base()); 6412 assert(ex == "*******************1;E+09"); 6413 assert(ios.width() == 0); 6414 } 6415 ios.width(25); 6416 internal(ios); 6417 { 6418 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6419 std::string ex(str, iter.base()); 6420 assert(ex == "*******************1;E+09"); 6421 assert(ios.width() == 0); 6422 } 6423 } 6424 } 6425 } 6426 showpos(ios); 6427 { 6428 noshowpoint(ios); 6429 { 6430 ios.imbue(lc); 6431 { 6432 ios.width(0); 6433 { 6434 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6435 std::string ex(str, iter.base()); 6436 assert(ex == "+1E+09"); 6437 assert(ios.width() == 0); 6438 } 6439 ios.width(25); 6440 left(ios); 6441 { 6442 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6443 std::string ex(str, iter.base()); 6444 assert(ex == "+1E+09*******************"); 6445 assert(ios.width() == 0); 6446 } 6447 ios.width(25); 6448 right(ios); 6449 { 6450 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6451 std::string ex(str, iter.base()); 6452 assert(ex == "*******************+1E+09"); 6453 assert(ios.width() == 0); 6454 } 6455 ios.width(25); 6456 internal(ios); 6457 { 6458 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6459 std::string ex(str, iter.base()); 6460 assert(ex == "+*******************1E+09"); 6461 assert(ios.width() == 0); 6462 } 6463 } 6464 ios.imbue(lg); 6465 { 6466 ios.width(0); 6467 { 6468 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6469 std::string ex(str, iter.base()); 6470 assert(ex == "+1E+09"); 6471 assert(ios.width() == 0); 6472 } 6473 ios.width(25); 6474 left(ios); 6475 { 6476 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6477 std::string ex(str, iter.base()); 6478 assert(ex == "+1E+09*******************"); 6479 assert(ios.width() == 0); 6480 } 6481 ios.width(25); 6482 right(ios); 6483 { 6484 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6485 std::string ex(str, iter.base()); 6486 assert(ex == "*******************+1E+09"); 6487 assert(ios.width() == 0); 6488 } 6489 ios.width(25); 6490 internal(ios); 6491 { 6492 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6493 std::string ex(str, iter.base()); 6494 assert(ex == "+*******************1E+09"); 6495 assert(ios.width() == 0); 6496 } 6497 } 6498 } 6499 showpoint(ios); 6500 { 6501 ios.imbue(lc); 6502 { 6503 ios.width(0); 6504 { 6505 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6506 std::string ex(str, iter.base()); 6507 assert(ex == "+1.E+09"); 6508 assert(ios.width() == 0); 6509 } 6510 ios.width(25); 6511 left(ios); 6512 { 6513 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6514 std::string ex(str, iter.base()); 6515 assert(ex == "+1.E+09******************"); 6516 assert(ios.width() == 0); 6517 } 6518 ios.width(25); 6519 right(ios); 6520 { 6521 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6522 std::string ex(str, iter.base()); 6523 assert(ex == "******************+1.E+09"); 6524 assert(ios.width() == 0); 6525 } 6526 ios.width(25); 6527 internal(ios); 6528 { 6529 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6530 std::string ex(str, iter.base()); 6531 assert(ex == "+******************1.E+09"); 6532 assert(ios.width() == 0); 6533 } 6534 } 6535 ios.imbue(lg); 6536 { 6537 ios.width(0); 6538 { 6539 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6540 std::string ex(str, iter.base()); 6541 assert(ex == "+1;E+09"); 6542 assert(ios.width() == 0); 6543 } 6544 ios.width(25); 6545 left(ios); 6546 { 6547 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6548 std::string ex(str, iter.base()); 6549 assert(ex == "+1;E+09******************"); 6550 assert(ios.width() == 0); 6551 } 6552 ios.width(25); 6553 right(ios); 6554 { 6555 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6556 std::string ex(str, iter.base()); 6557 assert(ex == "******************+1;E+09"); 6558 assert(ios.width() == 0); 6559 } 6560 ios.width(25); 6561 internal(ios); 6562 { 6563 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6564 std::string ex(str, iter.base()); 6565 assert(ex == "+******************1;E+09"); 6566 assert(ios.width() == 0); 6567 } 6568 } 6569 } 6570 } 6571 } 6572 } 6573 ios.precision(1); 6574 { 6575 nouppercase(ios); 6576 { 6577 noshowpos(ios); 6578 { 6579 noshowpoint(ios); 6580 { 6581 ios.imbue(lc); 6582 { 6583 ios.width(0); 6584 { 6585 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6586 std::string ex(str, iter.base()); 6587 assert(ex == "1e+09"); 6588 assert(ios.width() == 0); 6589 } 6590 ios.width(25); 6591 left(ios); 6592 { 6593 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6594 std::string ex(str, iter.base()); 6595 assert(ex == "1e+09********************"); 6596 assert(ios.width() == 0); 6597 } 6598 ios.width(25); 6599 right(ios); 6600 { 6601 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6602 std::string ex(str, iter.base()); 6603 assert(ex == "********************1e+09"); 6604 assert(ios.width() == 0); 6605 } 6606 ios.width(25); 6607 internal(ios); 6608 { 6609 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6610 std::string ex(str, iter.base()); 6611 assert(ex == "********************1e+09"); 6612 assert(ios.width() == 0); 6613 } 6614 } 6615 ios.imbue(lg); 6616 { 6617 ios.width(0); 6618 { 6619 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6620 std::string ex(str, iter.base()); 6621 assert(ex == "1e+09"); 6622 assert(ios.width() == 0); 6623 } 6624 ios.width(25); 6625 left(ios); 6626 { 6627 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6628 std::string ex(str, iter.base()); 6629 assert(ex == "1e+09********************"); 6630 assert(ios.width() == 0); 6631 } 6632 ios.width(25); 6633 right(ios); 6634 { 6635 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6636 std::string ex(str, iter.base()); 6637 assert(ex == "********************1e+09"); 6638 assert(ios.width() == 0); 6639 } 6640 ios.width(25); 6641 internal(ios); 6642 { 6643 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6644 std::string ex(str, iter.base()); 6645 assert(ex == "********************1e+09"); 6646 assert(ios.width() == 0); 6647 } 6648 } 6649 } 6650 showpoint(ios); 6651 { 6652 ios.imbue(lc); 6653 { 6654 ios.width(0); 6655 { 6656 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6657 std::string ex(str, iter.base()); 6658 assert(ex == "1.e+09"); 6659 assert(ios.width() == 0); 6660 } 6661 ios.width(25); 6662 left(ios); 6663 { 6664 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6665 std::string ex(str, iter.base()); 6666 assert(ex == "1.e+09*******************"); 6667 assert(ios.width() == 0); 6668 } 6669 ios.width(25); 6670 right(ios); 6671 { 6672 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6673 std::string ex(str, iter.base()); 6674 assert(ex == "*******************1.e+09"); 6675 assert(ios.width() == 0); 6676 } 6677 ios.width(25); 6678 internal(ios); 6679 { 6680 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6681 std::string ex(str, iter.base()); 6682 assert(ex == "*******************1.e+09"); 6683 assert(ios.width() == 0); 6684 } 6685 } 6686 ios.imbue(lg); 6687 { 6688 ios.width(0); 6689 { 6690 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6691 std::string ex(str, iter.base()); 6692 assert(ex == "1;e+09"); 6693 assert(ios.width() == 0); 6694 } 6695 ios.width(25); 6696 left(ios); 6697 { 6698 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6699 std::string ex(str, iter.base()); 6700 assert(ex == "1;e+09*******************"); 6701 assert(ios.width() == 0); 6702 } 6703 ios.width(25); 6704 right(ios); 6705 { 6706 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6707 std::string ex(str, iter.base()); 6708 assert(ex == "*******************1;e+09"); 6709 assert(ios.width() == 0); 6710 } 6711 ios.width(25); 6712 internal(ios); 6713 { 6714 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6715 std::string ex(str, iter.base()); 6716 assert(ex == "*******************1;e+09"); 6717 assert(ios.width() == 0); 6718 } 6719 } 6720 } 6721 } 6722 showpos(ios); 6723 { 6724 noshowpoint(ios); 6725 { 6726 ios.imbue(lc); 6727 { 6728 ios.width(0); 6729 { 6730 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6731 std::string ex(str, iter.base()); 6732 assert(ex == "+1e+09"); 6733 assert(ios.width() == 0); 6734 } 6735 ios.width(25); 6736 left(ios); 6737 { 6738 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6739 std::string ex(str, iter.base()); 6740 assert(ex == "+1e+09*******************"); 6741 assert(ios.width() == 0); 6742 } 6743 ios.width(25); 6744 right(ios); 6745 { 6746 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6747 std::string ex(str, iter.base()); 6748 assert(ex == "*******************+1e+09"); 6749 assert(ios.width() == 0); 6750 } 6751 ios.width(25); 6752 internal(ios); 6753 { 6754 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6755 std::string ex(str, iter.base()); 6756 assert(ex == "+*******************1e+09"); 6757 assert(ios.width() == 0); 6758 } 6759 } 6760 ios.imbue(lg); 6761 { 6762 ios.width(0); 6763 { 6764 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6765 std::string ex(str, iter.base()); 6766 assert(ex == "+1e+09"); 6767 assert(ios.width() == 0); 6768 } 6769 ios.width(25); 6770 left(ios); 6771 { 6772 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6773 std::string ex(str, iter.base()); 6774 assert(ex == "+1e+09*******************"); 6775 assert(ios.width() == 0); 6776 } 6777 ios.width(25); 6778 right(ios); 6779 { 6780 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6781 std::string ex(str, iter.base()); 6782 assert(ex == "*******************+1e+09"); 6783 assert(ios.width() == 0); 6784 } 6785 ios.width(25); 6786 internal(ios); 6787 { 6788 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6789 std::string ex(str, iter.base()); 6790 assert(ex == "+*******************1e+09"); 6791 assert(ios.width() == 0); 6792 } 6793 } 6794 } 6795 showpoint(ios); 6796 { 6797 ios.imbue(lc); 6798 { 6799 ios.width(0); 6800 { 6801 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6802 std::string ex(str, iter.base()); 6803 assert(ex == "+1.e+09"); 6804 assert(ios.width() == 0); 6805 } 6806 ios.width(25); 6807 left(ios); 6808 { 6809 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6810 std::string ex(str, iter.base()); 6811 assert(ex == "+1.e+09******************"); 6812 assert(ios.width() == 0); 6813 } 6814 ios.width(25); 6815 right(ios); 6816 { 6817 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6818 std::string ex(str, iter.base()); 6819 assert(ex == "******************+1.e+09"); 6820 assert(ios.width() == 0); 6821 } 6822 ios.width(25); 6823 internal(ios); 6824 { 6825 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6826 std::string ex(str, iter.base()); 6827 assert(ex == "+******************1.e+09"); 6828 assert(ios.width() == 0); 6829 } 6830 } 6831 ios.imbue(lg); 6832 { 6833 ios.width(0); 6834 { 6835 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6836 std::string ex(str, iter.base()); 6837 assert(ex == "+1;e+09"); 6838 assert(ios.width() == 0); 6839 } 6840 ios.width(25); 6841 left(ios); 6842 { 6843 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6844 std::string ex(str, iter.base()); 6845 assert(ex == "+1;e+09******************"); 6846 assert(ios.width() == 0); 6847 } 6848 ios.width(25); 6849 right(ios); 6850 { 6851 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6852 std::string ex(str, iter.base()); 6853 assert(ex == "******************+1;e+09"); 6854 assert(ios.width() == 0); 6855 } 6856 ios.width(25); 6857 internal(ios); 6858 { 6859 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6860 std::string ex(str, iter.base()); 6861 assert(ex == "+******************1;e+09"); 6862 assert(ios.width() == 0); 6863 } 6864 } 6865 } 6866 } 6867 } 6868 uppercase(ios); 6869 { 6870 noshowpos(ios); 6871 { 6872 noshowpoint(ios); 6873 { 6874 ios.imbue(lc); 6875 { 6876 ios.width(0); 6877 { 6878 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6879 std::string ex(str, iter.base()); 6880 assert(ex == "1E+09"); 6881 assert(ios.width() == 0); 6882 } 6883 ios.width(25); 6884 left(ios); 6885 { 6886 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6887 std::string ex(str, iter.base()); 6888 assert(ex == "1E+09********************"); 6889 assert(ios.width() == 0); 6890 } 6891 ios.width(25); 6892 right(ios); 6893 { 6894 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6895 std::string ex(str, iter.base()); 6896 assert(ex == "********************1E+09"); 6897 assert(ios.width() == 0); 6898 } 6899 ios.width(25); 6900 internal(ios); 6901 { 6902 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6903 std::string ex(str, iter.base()); 6904 assert(ex == "********************1E+09"); 6905 assert(ios.width() == 0); 6906 } 6907 } 6908 ios.imbue(lg); 6909 { 6910 ios.width(0); 6911 { 6912 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6913 std::string ex(str, iter.base()); 6914 assert(ex == "1E+09"); 6915 assert(ios.width() == 0); 6916 } 6917 ios.width(25); 6918 left(ios); 6919 { 6920 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6921 std::string ex(str, iter.base()); 6922 assert(ex == "1E+09********************"); 6923 assert(ios.width() == 0); 6924 } 6925 ios.width(25); 6926 right(ios); 6927 { 6928 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6929 std::string ex(str, iter.base()); 6930 assert(ex == "********************1E+09"); 6931 assert(ios.width() == 0); 6932 } 6933 ios.width(25); 6934 internal(ios); 6935 { 6936 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6937 std::string ex(str, iter.base()); 6938 assert(ex == "********************1E+09"); 6939 assert(ios.width() == 0); 6940 } 6941 } 6942 } 6943 showpoint(ios); 6944 { 6945 ios.imbue(lc); 6946 { 6947 ios.width(0); 6948 { 6949 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6950 std::string ex(str, iter.base()); 6951 assert(ex == "1.E+09"); 6952 assert(ios.width() == 0); 6953 } 6954 ios.width(25); 6955 left(ios); 6956 { 6957 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6958 std::string ex(str, iter.base()); 6959 assert(ex == "1.E+09*******************"); 6960 assert(ios.width() == 0); 6961 } 6962 ios.width(25); 6963 right(ios); 6964 { 6965 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6966 std::string ex(str, iter.base()); 6967 assert(ex == "*******************1.E+09"); 6968 assert(ios.width() == 0); 6969 } 6970 ios.width(25); 6971 internal(ios); 6972 { 6973 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6974 std::string ex(str, iter.base()); 6975 assert(ex == "*******************1.E+09"); 6976 assert(ios.width() == 0); 6977 } 6978 } 6979 ios.imbue(lg); 6980 { 6981 ios.width(0); 6982 { 6983 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6984 std::string ex(str, iter.base()); 6985 assert(ex == "1;E+09"); 6986 assert(ios.width() == 0); 6987 } 6988 ios.width(25); 6989 left(ios); 6990 { 6991 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6992 std::string ex(str, iter.base()); 6993 assert(ex == "1;E+09*******************"); 6994 assert(ios.width() == 0); 6995 } 6996 ios.width(25); 6997 right(ios); 6998 { 6999 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7000 std::string ex(str, iter.base()); 7001 assert(ex == "*******************1;E+09"); 7002 assert(ios.width() == 0); 7003 } 7004 ios.width(25); 7005 internal(ios); 7006 { 7007 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7008 std::string ex(str, iter.base()); 7009 assert(ex == "*******************1;E+09"); 7010 assert(ios.width() == 0); 7011 } 7012 } 7013 } 7014 } 7015 showpos(ios); 7016 { 7017 noshowpoint(ios); 7018 { 7019 ios.imbue(lc); 7020 { 7021 ios.width(0); 7022 { 7023 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7024 std::string ex(str, iter.base()); 7025 assert(ex == "+1E+09"); 7026 assert(ios.width() == 0); 7027 } 7028 ios.width(25); 7029 left(ios); 7030 { 7031 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7032 std::string ex(str, iter.base()); 7033 assert(ex == "+1E+09*******************"); 7034 assert(ios.width() == 0); 7035 } 7036 ios.width(25); 7037 right(ios); 7038 { 7039 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7040 std::string ex(str, iter.base()); 7041 assert(ex == "*******************+1E+09"); 7042 assert(ios.width() == 0); 7043 } 7044 ios.width(25); 7045 internal(ios); 7046 { 7047 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7048 std::string ex(str, iter.base()); 7049 assert(ex == "+*******************1E+09"); 7050 assert(ios.width() == 0); 7051 } 7052 } 7053 ios.imbue(lg); 7054 { 7055 ios.width(0); 7056 { 7057 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7058 std::string ex(str, iter.base()); 7059 assert(ex == "+1E+09"); 7060 assert(ios.width() == 0); 7061 } 7062 ios.width(25); 7063 left(ios); 7064 { 7065 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7066 std::string ex(str, iter.base()); 7067 assert(ex == "+1E+09*******************"); 7068 assert(ios.width() == 0); 7069 } 7070 ios.width(25); 7071 right(ios); 7072 { 7073 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7074 std::string ex(str, iter.base()); 7075 assert(ex == "*******************+1E+09"); 7076 assert(ios.width() == 0); 7077 } 7078 ios.width(25); 7079 internal(ios); 7080 { 7081 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7082 std::string ex(str, iter.base()); 7083 assert(ex == "+*******************1E+09"); 7084 assert(ios.width() == 0); 7085 } 7086 } 7087 } 7088 showpoint(ios); 7089 { 7090 ios.imbue(lc); 7091 { 7092 ios.width(0); 7093 { 7094 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7095 std::string ex(str, iter.base()); 7096 assert(ex == "+1.E+09"); 7097 assert(ios.width() == 0); 7098 } 7099 ios.width(25); 7100 left(ios); 7101 { 7102 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7103 std::string ex(str, iter.base()); 7104 assert(ex == "+1.E+09******************"); 7105 assert(ios.width() == 0); 7106 } 7107 ios.width(25); 7108 right(ios); 7109 { 7110 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7111 std::string ex(str, iter.base()); 7112 assert(ex == "******************+1.E+09"); 7113 assert(ios.width() == 0); 7114 } 7115 ios.width(25); 7116 internal(ios); 7117 { 7118 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7119 std::string ex(str, iter.base()); 7120 assert(ex == "+******************1.E+09"); 7121 assert(ios.width() == 0); 7122 } 7123 } 7124 ios.imbue(lg); 7125 { 7126 ios.width(0); 7127 { 7128 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7129 std::string ex(str, iter.base()); 7130 assert(ex == "+1;E+09"); 7131 assert(ios.width() == 0); 7132 } 7133 ios.width(25); 7134 left(ios); 7135 { 7136 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7137 std::string ex(str, iter.base()); 7138 assert(ex == "+1;E+09******************"); 7139 assert(ios.width() == 0); 7140 } 7141 ios.width(25); 7142 right(ios); 7143 { 7144 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7145 std::string ex(str, iter.base()); 7146 assert(ex == "******************+1;E+09"); 7147 assert(ios.width() == 0); 7148 } 7149 ios.width(25); 7150 internal(ios); 7151 { 7152 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7153 std::string ex(str, iter.base()); 7154 assert(ex == "+******************1;E+09"); 7155 assert(ios.width() == 0); 7156 } 7157 } 7158 } 7159 } 7160 } 7161 } 7162 ios.precision(6); 7163 { 7164 nouppercase(ios); 7165 { 7166 noshowpos(ios); 7167 { 7168 noshowpoint(ios); 7169 { 7170 ios.imbue(lc); 7171 { 7172 ios.width(0); 7173 { 7174 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7175 std::string ex(str, iter.base()); 7176 assert(ex == "1.23457e+09"); 7177 assert(ios.width() == 0); 7178 } 7179 ios.width(25); 7180 left(ios); 7181 { 7182 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7183 std::string ex(str, iter.base()); 7184 assert(ex == "1.23457e+09**************"); 7185 assert(ios.width() == 0); 7186 } 7187 ios.width(25); 7188 right(ios); 7189 { 7190 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7191 std::string ex(str, iter.base()); 7192 assert(ex == "**************1.23457e+09"); 7193 assert(ios.width() == 0); 7194 } 7195 ios.width(25); 7196 internal(ios); 7197 { 7198 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7199 std::string ex(str, iter.base()); 7200 assert(ex == "**************1.23457e+09"); 7201 assert(ios.width() == 0); 7202 } 7203 } 7204 ios.imbue(lg); 7205 { 7206 ios.width(0); 7207 { 7208 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7209 std::string ex(str, iter.base()); 7210 assert(ex == "1;23457e+09"); 7211 assert(ios.width() == 0); 7212 } 7213 ios.width(25); 7214 left(ios); 7215 { 7216 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7217 std::string ex(str, iter.base()); 7218 assert(ex == "1;23457e+09**************"); 7219 assert(ios.width() == 0); 7220 } 7221 ios.width(25); 7222 right(ios); 7223 { 7224 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7225 std::string ex(str, iter.base()); 7226 assert(ex == "**************1;23457e+09"); 7227 assert(ios.width() == 0); 7228 } 7229 ios.width(25); 7230 internal(ios); 7231 { 7232 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7233 std::string ex(str, iter.base()); 7234 assert(ex == "**************1;23457e+09"); 7235 assert(ios.width() == 0); 7236 } 7237 } 7238 } 7239 showpoint(ios); 7240 { 7241 ios.imbue(lc); 7242 { 7243 ios.width(0); 7244 { 7245 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7246 std::string ex(str, iter.base()); 7247 assert(ex == "1.23457e+09"); 7248 assert(ios.width() == 0); 7249 } 7250 ios.width(25); 7251 left(ios); 7252 { 7253 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7254 std::string ex(str, iter.base()); 7255 assert(ex == "1.23457e+09**************"); 7256 assert(ios.width() == 0); 7257 } 7258 ios.width(25); 7259 right(ios); 7260 { 7261 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7262 std::string ex(str, iter.base()); 7263 assert(ex == "**************1.23457e+09"); 7264 assert(ios.width() == 0); 7265 } 7266 ios.width(25); 7267 internal(ios); 7268 { 7269 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7270 std::string ex(str, iter.base()); 7271 assert(ex == "**************1.23457e+09"); 7272 assert(ios.width() == 0); 7273 } 7274 } 7275 ios.imbue(lg); 7276 { 7277 ios.width(0); 7278 { 7279 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7280 std::string ex(str, iter.base()); 7281 assert(ex == "1;23457e+09"); 7282 assert(ios.width() == 0); 7283 } 7284 ios.width(25); 7285 left(ios); 7286 { 7287 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7288 std::string ex(str, iter.base()); 7289 assert(ex == "1;23457e+09**************"); 7290 assert(ios.width() == 0); 7291 } 7292 ios.width(25); 7293 right(ios); 7294 { 7295 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7296 std::string ex(str, iter.base()); 7297 assert(ex == "**************1;23457e+09"); 7298 assert(ios.width() == 0); 7299 } 7300 ios.width(25); 7301 internal(ios); 7302 { 7303 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7304 std::string ex(str, iter.base()); 7305 assert(ex == "**************1;23457e+09"); 7306 assert(ios.width() == 0); 7307 } 7308 } 7309 } 7310 } 7311 showpos(ios); 7312 { 7313 noshowpoint(ios); 7314 { 7315 ios.imbue(lc); 7316 { 7317 ios.width(0); 7318 { 7319 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7320 std::string ex(str, iter.base()); 7321 assert(ex == "+1.23457e+09"); 7322 assert(ios.width() == 0); 7323 } 7324 ios.width(25); 7325 left(ios); 7326 { 7327 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7328 std::string ex(str, iter.base()); 7329 assert(ex == "+1.23457e+09*************"); 7330 assert(ios.width() == 0); 7331 } 7332 ios.width(25); 7333 right(ios); 7334 { 7335 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7336 std::string ex(str, iter.base()); 7337 assert(ex == "*************+1.23457e+09"); 7338 assert(ios.width() == 0); 7339 } 7340 ios.width(25); 7341 internal(ios); 7342 { 7343 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7344 std::string ex(str, iter.base()); 7345 assert(ex == "+*************1.23457e+09"); 7346 assert(ios.width() == 0); 7347 } 7348 } 7349 ios.imbue(lg); 7350 { 7351 ios.width(0); 7352 { 7353 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7354 std::string ex(str, iter.base()); 7355 assert(ex == "+1;23457e+09"); 7356 assert(ios.width() == 0); 7357 } 7358 ios.width(25); 7359 left(ios); 7360 { 7361 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7362 std::string ex(str, iter.base()); 7363 assert(ex == "+1;23457e+09*************"); 7364 assert(ios.width() == 0); 7365 } 7366 ios.width(25); 7367 right(ios); 7368 { 7369 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7370 std::string ex(str, iter.base()); 7371 assert(ex == "*************+1;23457e+09"); 7372 assert(ios.width() == 0); 7373 } 7374 ios.width(25); 7375 internal(ios); 7376 { 7377 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7378 std::string ex(str, iter.base()); 7379 assert(ex == "+*************1;23457e+09"); 7380 assert(ios.width() == 0); 7381 } 7382 } 7383 } 7384 showpoint(ios); 7385 { 7386 ios.imbue(lc); 7387 { 7388 ios.width(0); 7389 { 7390 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7391 std::string ex(str, iter.base()); 7392 assert(ex == "+1.23457e+09"); 7393 assert(ios.width() == 0); 7394 } 7395 ios.width(25); 7396 left(ios); 7397 { 7398 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7399 std::string ex(str, iter.base()); 7400 assert(ex == "+1.23457e+09*************"); 7401 assert(ios.width() == 0); 7402 } 7403 ios.width(25); 7404 right(ios); 7405 { 7406 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7407 std::string ex(str, iter.base()); 7408 assert(ex == "*************+1.23457e+09"); 7409 assert(ios.width() == 0); 7410 } 7411 ios.width(25); 7412 internal(ios); 7413 { 7414 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7415 std::string ex(str, iter.base()); 7416 assert(ex == "+*************1.23457e+09"); 7417 assert(ios.width() == 0); 7418 } 7419 } 7420 ios.imbue(lg); 7421 { 7422 ios.width(0); 7423 { 7424 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7425 std::string ex(str, iter.base()); 7426 assert(ex == "+1;23457e+09"); 7427 assert(ios.width() == 0); 7428 } 7429 ios.width(25); 7430 left(ios); 7431 { 7432 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7433 std::string ex(str, iter.base()); 7434 assert(ex == "+1;23457e+09*************"); 7435 assert(ios.width() == 0); 7436 } 7437 ios.width(25); 7438 right(ios); 7439 { 7440 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7441 std::string ex(str, iter.base()); 7442 assert(ex == "*************+1;23457e+09"); 7443 assert(ios.width() == 0); 7444 } 7445 ios.width(25); 7446 internal(ios); 7447 { 7448 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7449 std::string ex(str, iter.base()); 7450 assert(ex == "+*************1;23457e+09"); 7451 assert(ios.width() == 0); 7452 } 7453 } 7454 } 7455 } 7456 } 7457 uppercase(ios); 7458 { 7459 noshowpos(ios); 7460 { 7461 noshowpoint(ios); 7462 { 7463 ios.imbue(lc); 7464 { 7465 ios.width(0); 7466 { 7467 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7468 std::string ex(str, iter.base()); 7469 assert(ex == "1.23457E+09"); 7470 assert(ios.width() == 0); 7471 } 7472 ios.width(25); 7473 left(ios); 7474 { 7475 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7476 std::string ex(str, iter.base()); 7477 assert(ex == "1.23457E+09**************"); 7478 assert(ios.width() == 0); 7479 } 7480 ios.width(25); 7481 right(ios); 7482 { 7483 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7484 std::string ex(str, iter.base()); 7485 assert(ex == "**************1.23457E+09"); 7486 assert(ios.width() == 0); 7487 } 7488 ios.width(25); 7489 internal(ios); 7490 { 7491 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7492 std::string ex(str, iter.base()); 7493 assert(ex == "**************1.23457E+09"); 7494 assert(ios.width() == 0); 7495 } 7496 } 7497 ios.imbue(lg); 7498 { 7499 ios.width(0); 7500 { 7501 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7502 std::string ex(str, iter.base()); 7503 assert(ex == "1;23457E+09"); 7504 assert(ios.width() == 0); 7505 } 7506 ios.width(25); 7507 left(ios); 7508 { 7509 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7510 std::string ex(str, iter.base()); 7511 assert(ex == "1;23457E+09**************"); 7512 assert(ios.width() == 0); 7513 } 7514 ios.width(25); 7515 right(ios); 7516 { 7517 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7518 std::string ex(str, iter.base()); 7519 assert(ex == "**************1;23457E+09"); 7520 assert(ios.width() == 0); 7521 } 7522 ios.width(25); 7523 internal(ios); 7524 { 7525 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7526 std::string ex(str, iter.base()); 7527 assert(ex == "**************1;23457E+09"); 7528 assert(ios.width() == 0); 7529 } 7530 } 7531 } 7532 showpoint(ios); 7533 { 7534 ios.imbue(lc); 7535 { 7536 ios.width(0); 7537 { 7538 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7539 std::string ex(str, iter.base()); 7540 assert(ex == "1.23457E+09"); 7541 assert(ios.width() == 0); 7542 } 7543 ios.width(25); 7544 left(ios); 7545 { 7546 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7547 std::string ex(str, iter.base()); 7548 assert(ex == "1.23457E+09**************"); 7549 assert(ios.width() == 0); 7550 } 7551 ios.width(25); 7552 right(ios); 7553 { 7554 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7555 std::string ex(str, iter.base()); 7556 assert(ex == "**************1.23457E+09"); 7557 assert(ios.width() == 0); 7558 } 7559 ios.width(25); 7560 internal(ios); 7561 { 7562 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7563 std::string ex(str, iter.base()); 7564 assert(ex == "**************1.23457E+09"); 7565 assert(ios.width() == 0); 7566 } 7567 } 7568 ios.imbue(lg); 7569 { 7570 ios.width(0); 7571 { 7572 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7573 std::string ex(str, iter.base()); 7574 assert(ex == "1;23457E+09"); 7575 assert(ios.width() == 0); 7576 } 7577 ios.width(25); 7578 left(ios); 7579 { 7580 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7581 std::string ex(str, iter.base()); 7582 assert(ex == "1;23457E+09**************"); 7583 assert(ios.width() == 0); 7584 } 7585 ios.width(25); 7586 right(ios); 7587 { 7588 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7589 std::string ex(str, iter.base()); 7590 assert(ex == "**************1;23457E+09"); 7591 assert(ios.width() == 0); 7592 } 7593 ios.width(25); 7594 internal(ios); 7595 { 7596 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7597 std::string ex(str, iter.base()); 7598 assert(ex == "**************1;23457E+09"); 7599 assert(ios.width() == 0); 7600 } 7601 } 7602 } 7603 } 7604 showpos(ios); 7605 { 7606 noshowpoint(ios); 7607 { 7608 ios.imbue(lc); 7609 { 7610 ios.width(0); 7611 { 7612 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7613 std::string ex(str, iter.base()); 7614 assert(ex == "+1.23457E+09"); 7615 assert(ios.width() == 0); 7616 } 7617 ios.width(25); 7618 left(ios); 7619 { 7620 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7621 std::string ex(str, iter.base()); 7622 assert(ex == "+1.23457E+09*************"); 7623 assert(ios.width() == 0); 7624 } 7625 ios.width(25); 7626 right(ios); 7627 { 7628 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7629 std::string ex(str, iter.base()); 7630 assert(ex == "*************+1.23457E+09"); 7631 assert(ios.width() == 0); 7632 } 7633 ios.width(25); 7634 internal(ios); 7635 { 7636 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7637 std::string ex(str, iter.base()); 7638 assert(ex == "+*************1.23457E+09"); 7639 assert(ios.width() == 0); 7640 } 7641 } 7642 ios.imbue(lg); 7643 { 7644 ios.width(0); 7645 { 7646 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7647 std::string ex(str, iter.base()); 7648 assert(ex == "+1;23457E+09"); 7649 assert(ios.width() == 0); 7650 } 7651 ios.width(25); 7652 left(ios); 7653 { 7654 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7655 std::string ex(str, iter.base()); 7656 assert(ex == "+1;23457E+09*************"); 7657 assert(ios.width() == 0); 7658 } 7659 ios.width(25); 7660 right(ios); 7661 { 7662 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7663 std::string ex(str, iter.base()); 7664 assert(ex == "*************+1;23457E+09"); 7665 assert(ios.width() == 0); 7666 } 7667 ios.width(25); 7668 internal(ios); 7669 { 7670 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7671 std::string ex(str, iter.base()); 7672 assert(ex == "+*************1;23457E+09"); 7673 assert(ios.width() == 0); 7674 } 7675 } 7676 } 7677 showpoint(ios); 7678 { 7679 ios.imbue(lc); 7680 { 7681 ios.width(0); 7682 { 7683 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7684 std::string ex(str, iter.base()); 7685 assert(ex == "+1.23457E+09"); 7686 assert(ios.width() == 0); 7687 } 7688 ios.width(25); 7689 left(ios); 7690 { 7691 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7692 std::string ex(str, iter.base()); 7693 assert(ex == "+1.23457E+09*************"); 7694 assert(ios.width() == 0); 7695 } 7696 ios.width(25); 7697 right(ios); 7698 { 7699 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7700 std::string ex(str, iter.base()); 7701 assert(ex == "*************+1.23457E+09"); 7702 assert(ios.width() == 0); 7703 } 7704 ios.width(25); 7705 internal(ios); 7706 { 7707 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7708 std::string ex(str, iter.base()); 7709 assert(ex == "+*************1.23457E+09"); 7710 assert(ios.width() == 0); 7711 } 7712 } 7713 ios.imbue(lg); 7714 { 7715 ios.width(0); 7716 { 7717 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7718 std::string ex(str, iter.base()); 7719 assert(ex == "+1;23457E+09"); 7720 assert(ios.width() == 0); 7721 } 7722 ios.width(25); 7723 left(ios); 7724 { 7725 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7726 std::string ex(str, iter.base()); 7727 assert(ex == "+1;23457E+09*************"); 7728 assert(ios.width() == 0); 7729 } 7730 ios.width(25); 7731 right(ios); 7732 { 7733 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7734 std::string ex(str, iter.base()); 7735 assert(ex == "*************+1;23457E+09"); 7736 assert(ios.width() == 0); 7737 } 7738 ios.width(25); 7739 internal(ios); 7740 { 7741 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7742 std::string ex(str, iter.base()); 7743 assert(ex == "+*************1;23457E+09"); 7744 assert(ios.width() == 0); 7745 } 7746 } 7747 } 7748 } 7749 } 7750 } 7751 ios.precision(16); 7752 { 7753 nouppercase(ios); 7754 { 7755 noshowpos(ios); 7756 { 7757 noshowpoint(ios); 7758 { 7759 ios.imbue(lc); 7760 { 7761 ios.width(0); 7762 { 7763 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7764 std::string ex(str, iter.base()); 7765 assert(ex == "1234567890.125"); 7766 assert(ios.width() == 0); 7767 } 7768 ios.width(25); 7769 left(ios); 7770 { 7771 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7772 std::string ex(str, iter.base()); 7773 assert(ex == "1234567890.125***********"); 7774 assert(ios.width() == 0); 7775 } 7776 ios.width(25); 7777 right(ios); 7778 { 7779 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7780 std::string ex(str, iter.base()); 7781 assert(ex == "***********1234567890.125"); 7782 assert(ios.width() == 0); 7783 } 7784 ios.width(25); 7785 internal(ios); 7786 { 7787 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7788 std::string ex(str, iter.base()); 7789 assert(ex == "***********1234567890.125"); 7790 assert(ios.width() == 0); 7791 } 7792 } 7793 ios.imbue(lg); 7794 { 7795 ios.width(0); 7796 { 7797 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7798 std::string ex(str, iter.base()); 7799 assert(ex == "1_234_567_89_0;125"); 7800 assert(ios.width() == 0); 7801 } 7802 ios.width(25); 7803 left(ios); 7804 { 7805 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7806 std::string ex(str, iter.base()); 7807 assert(ex == "1_234_567_89_0;125*******"); 7808 assert(ios.width() == 0); 7809 } 7810 ios.width(25); 7811 right(ios); 7812 { 7813 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7814 std::string ex(str, iter.base()); 7815 assert(ex == "*******1_234_567_89_0;125"); 7816 assert(ios.width() == 0); 7817 } 7818 ios.width(25); 7819 internal(ios); 7820 { 7821 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7822 std::string ex(str, iter.base()); 7823 assert(ex == "*******1_234_567_89_0;125"); 7824 assert(ios.width() == 0); 7825 } 7826 } 7827 } 7828 showpoint(ios); 7829 { 7830 ios.imbue(lc); 7831 { 7832 ios.width(0); 7833 { 7834 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7835 std::string ex(str, iter.base()); 7836 assert(ex == "1234567890.125000"); 7837 assert(ios.width() == 0); 7838 } 7839 ios.width(25); 7840 left(ios); 7841 { 7842 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7843 std::string ex(str, iter.base()); 7844 assert(ex == "1234567890.125000********"); 7845 assert(ios.width() == 0); 7846 } 7847 ios.width(25); 7848 right(ios); 7849 { 7850 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7851 std::string ex(str, iter.base()); 7852 assert(ex == "********1234567890.125000"); 7853 assert(ios.width() == 0); 7854 } 7855 ios.width(25); 7856 internal(ios); 7857 { 7858 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7859 std::string ex(str, iter.base()); 7860 assert(ex == "********1234567890.125000"); 7861 assert(ios.width() == 0); 7862 } 7863 } 7864 ios.imbue(lg); 7865 { 7866 ios.width(0); 7867 { 7868 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7869 std::string ex(str, iter.base()); 7870 assert(ex == "1_234_567_89_0;125000"); 7871 assert(ios.width() == 0); 7872 } 7873 ios.width(25); 7874 left(ios); 7875 { 7876 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7877 std::string ex(str, iter.base()); 7878 assert(ex == "1_234_567_89_0;125000****"); 7879 assert(ios.width() == 0); 7880 } 7881 ios.width(25); 7882 right(ios); 7883 { 7884 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7885 std::string ex(str, iter.base()); 7886 assert(ex == "****1_234_567_89_0;125000"); 7887 assert(ios.width() == 0); 7888 } 7889 ios.width(25); 7890 internal(ios); 7891 { 7892 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7893 std::string ex(str, iter.base()); 7894 assert(ex == "****1_234_567_89_0;125000"); 7895 assert(ios.width() == 0); 7896 } 7897 } 7898 } 7899 } 7900 showpos(ios); 7901 { 7902 noshowpoint(ios); 7903 { 7904 ios.imbue(lc); 7905 { 7906 ios.width(0); 7907 { 7908 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7909 std::string ex(str, iter.base()); 7910 assert(ex == "+1234567890.125"); 7911 assert(ios.width() == 0); 7912 } 7913 ios.width(25); 7914 left(ios); 7915 { 7916 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7917 std::string ex(str, iter.base()); 7918 assert(ex == "+1234567890.125**********"); 7919 assert(ios.width() == 0); 7920 } 7921 ios.width(25); 7922 right(ios); 7923 { 7924 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7925 std::string ex(str, iter.base()); 7926 assert(ex == "**********+1234567890.125"); 7927 assert(ios.width() == 0); 7928 } 7929 ios.width(25); 7930 internal(ios); 7931 { 7932 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7933 std::string ex(str, iter.base()); 7934 assert(ex == "+**********1234567890.125"); 7935 assert(ios.width() == 0); 7936 } 7937 } 7938 ios.imbue(lg); 7939 { 7940 ios.width(0); 7941 { 7942 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7943 std::string ex(str, iter.base()); 7944 assert(ex == "+1_234_567_89_0;125"); 7945 assert(ios.width() == 0); 7946 } 7947 ios.width(25); 7948 left(ios); 7949 { 7950 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7951 std::string ex(str, iter.base()); 7952 assert(ex == "+1_234_567_89_0;125******"); 7953 assert(ios.width() == 0); 7954 } 7955 ios.width(25); 7956 right(ios); 7957 { 7958 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7959 std::string ex(str, iter.base()); 7960 assert(ex == "******+1_234_567_89_0;125"); 7961 assert(ios.width() == 0); 7962 } 7963 ios.width(25); 7964 internal(ios); 7965 { 7966 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7967 std::string ex(str, iter.base()); 7968 assert(ex == "+******1_234_567_89_0;125"); 7969 assert(ios.width() == 0); 7970 } 7971 } 7972 } 7973 showpoint(ios); 7974 { 7975 ios.imbue(lc); 7976 { 7977 ios.width(0); 7978 { 7979 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7980 std::string ex(str, iter.base()); 7981 assert(ex == "+1234567890.125000"); 7982 assert(ios.width() == 0); 7983 } 7984 ios.width(25); 7985 left(ios); 7986 { 7987 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7988 std::string ex(str, iter.base()); 7989 assert(ex == "+1234567890.125000*******"); 7990 assert(ios.width() == 0); 7991 } 7992 ios.width(25); 7993 right(ios); 7994 { 7995 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7996 std::string ex(str, iter.base()); 7997 assert(ex == "*******+1234567890.125000"); 7998 assert(ios.width() == 0); 7999 } 8000 ios.width(25); 8001 internal(ios); 8002 { 8003 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8004 std::string ex(str, iter.base()); 8005 assert(ex == "+*******1234567890.125000"); 8006 assert(ios.width() == 0); 8007 } 8008 } 8009 ios.imbue(lg); 8010 { 8011 ios.width(0); 8012 { 8013 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8014 std::string ex(str, iter.base()); 8015 assert(ex == "+1_234_567_89_0;125000"); 8016 assert(ios.width() == 0); 8017 } 8018 ios.width(25); 8019 left(ios); 8020 { 8021 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8022 std::string ex(str, iter.base()); 8023 assert(ex == "+1_234_567_89_0;125000***"); 8024 assert(ios.width() == 0); 8025 } 8026 ios.width(25); 8027 right(ios); 8028 { 8029 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8030 std::string ex(str, iter.base()); 8031 assert(ex == "***+1_234_567_89_0;125000"); 8032 assert(ios.width() == 0); 8033 } 8034 ios.width(25); 8035 internal(ios); 8036 { 8037 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8038 std::string ex(str, iter.base()); 8039 assert(ex == "+***1_234_567_89_0;125000"); 8040 assert(ios.width() == 0); 8041 } 8042 } 8043 } 8044 } 8045 } 8046 uppercase(ios); 8047 { 8048 noshowpos(ios); 8049 { 8050 noshowpoint(ios); 8051 { 8052 ios.imbue(lc); 8053 { 8054 ios.width(0); 8055 { 8056 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8057 std::string ex(str, iter.base()); 8058 assert(ex == "1234567890.125"); 8059 assert(ios.width() == 0); 8060 } 8061 ios.width(25); 8062 left(ios); 8063 { 8064 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8065 std::string ex(str, iter.base()); 8066 assert(ex == "1234567890.125***********"); 8067 assert(ios.width() == 0); 8068 } 8069 ios.width(25); 8070 right(ios); 8071 { 8072 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8073 std::string ex(str, iter.base()); 8074 assert(ex == "***********1234567890.125"); 8075 assert(ios.width() == 0); 8076 } 8077 ios.width(25); 8078 internal(ios); 8079 { 8080 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8081 std::string ex(str, iter.base()); 8082 assert(ex == "***********1234567890.125"); 8083 assert(ios.width() == 0); 8084 } 8085 } 8086 ios.imbue(lg); 8087 { 8088 ios.width(0); 8089 { 8090 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8091 std::string ex(str, iter.base()); 8092 assert(ex == "1_234_567_89_0;125"); 8093 assert(ios.width() == 0); 8094 } 8095 ios.width(25); 8096 left(ios); 8097 { 8098 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8099 std::string ex(str, iter.base()); 8100 assert(ex == "1_234_567_89_0;125*******"); 8101 assert(ios.width() == 0); 8102 } 8103 ios.width(25); 8104 right(ios); 8105 { 8106 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8107 std::string ex(str, iter.base()); 8108 assert(ex == "*******1_234_567_89_0;125"); 8109 assert(ios.width() == 0); 8110 } 8111 ios.width(25); 8112 internal(ios); 8113 { 8114 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8115 std::string ex(str, iter.base()); 8116 assert(ex == "*******1_234_567_89_0;125"); 8117 assert(ios.width() == 0); 8118 } 8119 } 8120 } 8121 showpoint(ios); 8122 { 8123 ios.imbue(lc); 8124 { 8125 ios.width(0); 8126 { 8127 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8128 std::string ex(str, iter.base()); 8129 assert(ex == "1234567890.125000"); 8130 assert(ios.width() == 0); 8131 } 8132 ios.width(25); 8133 left(ios); 8134 { 8135 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8136 std::string ex(str, iter.base()); 8137 assert(ex == "1234567890.125000********"); 8138 assert(ios.width() == 0); 8139 } 8140 ios.width(25); 8141 right(ios); 8142 { 8143 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8144 std::string ex(str, iter.base()); 8145 assert(ex == "********1234567890.125000"); 8146 assert(ios.width() == 0); 8147 } 8148 ios.width(25); 8149 internal(ios); 8150 { 8151 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8152 std::string ex(str, iter.base()); 8153 assert(ex == "********1234567890.125000"); 8154 assert(ios.width() == 0); 8155 } 8156 } 8157 ios.imbue(lg); 8158 { 8159 ios.width(0); 8160 { 8161 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8162 std::string ex(str, iter.base()); 8163 assert(ex == "1_234_567_89_0;125000"); 8164 assert(ios.width() == 0); 8165 } 8166 ios.width(25); 8167 left(ios); 8168 { 8169 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8170 std::string ex(str, iter.base()); 8171 assert(ex == "1_234_567_89_0;125000****"); 8172 assert(ios.width() == 0); 8173 } 8174 ios.width(25); 8175 right(ios); 8176 { 8177 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8178 std::string ex(str, iter.base()); 8179 assert(ex == "****1_234_567_89_0;125000"); 8180 assert(ios.width() == 0); 8181 } 8182 ios.width(25); 8183 internal(ios); 8184 { 8185 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8186 std::string ex(str, iter.base()); 8187 assert(ex == "****1_234_567_89_0;125000"); 8188 assert(ios.width() == 0); 8189 } 8190 } 8191 } 8192 } 8193 showpos(ios); 8194 { 8195 noshowpoint(ios); 8196 { 8197 ios.imbue(lc); 8198 { 8199 ios.width(0); 8200 { 8201 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8202 std::string ex(str, iter.base()); 8203 assert(ex == "+1234567890.125"); 8204 assert(ios.width() == 0); 8205 } 8206 ios.width(25); 8207 left(ios); 8208 { 8209 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8210 std::string ex(str, iter.base()); 8211 assert(ex == "+1234567890.125**********"); 8212 assert(ios.width() == 0); 8213 } 8214 ios.width(25); 8215 right(ios); 8216 { 8217 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8218 std::string ex(str, iter.base()); 8219 assert(ex == "**********+1234567890.125"); 8220 assert(ios.width() == 0); 8221 } 8222 ios.width(25); 8223 internal(ios); 8224 { 8225 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8226 std::string ex(str, iter.base()); 8227 assert(ex == "+**********1234567890.125"); 8228 assert(ios.width() == 0); 8229 } 8230 } 8231 ios.imbue(lg); 8232 { 8233 ios.width(0); 8234 { 8235 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8236 std::string ex(str, iter.base()); 8237 assert(ex == "+1_234_567_89_0;125"); 8238 assert(ios.width() == 0); 8239 } 8240 ios.width(25); 8241 left(ios); 8242 { 8243 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8244 std::string ex(str, iter.base()); 8245 assert(ex == "+1_234_567_89_0;125******"); 8246 assert(ios.width() == 0); 8247 } 8248 ios.width(25); 8249 right(ios); 8250 { 8251 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8252 std::string ex(str, iter.base()); 8253 assert(ex == "******+1_234_567_89_0;125"); 8254 assert(ios.width() == 0); 8255 } 8256 ios.width(25); 8257 internal(ios); 8258 { 8259 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8260 std::string ex(str, iter.base()); 8261 assert(ex == "+******1_234_567_89_0;125"); 8262 assert(ios.width() == 0); 8263 } 8264 } 8265 } 8266 showpoint(ios); 8267 { 8268 ios.imbue(lc); 8269 { 8270 ios.width(0); 8271 { 8272 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8273 std::string ex(str, iter.base()); 8274 assert(ex == "+1234567890.125000"); 8275 assert(ios.width() == 0); 8276 } 8277 ios.width(25); 8278 left(ios); 8279 { 8280 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8281 std::string ex(str, iter.base()); 8282 assert(ex == "+1234567890.125000*******"); 8283 assert(ios.width() == 0); 8284 } 8285 ios.width(25); 8286 right(ios); 8287 { 8288 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8289 std::string ex(str, iter.base()); 8290 assert(ex == "*******+1234567890.125000"); 8291 assert(ios.width() == 0); 8292 } 8293 ios.width(25); 8294 internal(ios); 8295 { 8296 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8297 std::string ex(str, iter.base()); 8298 assert(ex == "+*******1234567890.125000"); 8299 assert(ios.width() == 0); 8300 } 8301 } 8302 ios.imbue(lg); 8303 { 8304 ios.width(0); 8305 { 8306 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8307 std::string ex(str, iter.base()); 8308 assert(ex == "+1_234_567_89_0;125000"); 8309 assert(ios.width() == 0); 8310 } 8311 ios.width(25); 8312 left(ios); 8313 { 8314 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8315 std::string ex(str, iter.base()); 8316 assert(ex == "+1_234_567_89_0;125000***"); 8317 assert(ios.width() == 0); 8318 } 8319 ios.width(25); 8320 right(ios); 8321 { 8322 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8323 std::string ex(str, iter.base()); 8324 assert(ex == "***+1_234_567_89_0;125000"); 8325 assert(ios.width() == 0); 8326 } 8327 ios.width(25); 8328 internal(ios); 8329 { 8330 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8331 std::string ex(str, iter.base()); 8332 assert(ex == "+***1_234_567_89_0;125000"); 8333 assert(ios.width() == 0); 8334 } 8335 } 8336 } 8337 } 8338 } 8339 } 8340 ios.precision(60); 8341 { 8342 nouppercase(ios); 8343 { 8344 noshowpos(ios); 8345 { 8346 noshowpoint(ios); 8347 { 8348 ios.imbue(lc); 8349 { 8350 ios.width(0); 8351 { 8352 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8353 std::string ex(str, iter.base()); 8354 assert(ex == "1234567890.125"); 8355 assert(ios.width() == 0); 8356 } 8357 ios.width(25); 8358 left(ios); 8359 { 8360 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8361 std::string ex(str, iter.base()); 8362 assert(ex == "1234567890.125***********"); 8363 assert(ios.width() == 0); 8364 } 8365 ios.width(25); 8366 right(ios); 8367 { 8368 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8369 std::string ex(str, iter.base()); 8370 assert(ex == "***********1234567890.125"); 8371 assert(ios.width() == 0); 8372 } 8373 ios.width(25); 8374 internal(ios); 8375 { 8376 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8377 std::string ex(str, iter.base()); 8378 assert(ex == "***********1234567890.125"); 8379 assert(ios.width() == 0); 8380 } 8381 } 8382 ios.imbue(lg); 8383 { 8384 ios.width(0); 8385 { 8386 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8387 std::string ex(str, iter.base()); 8388 assert(ex == "1_234_567_89_0;125"); 8389 assert(ios.width() == 0); 8390 } 8391 ios.width(25); 8392 left(ios); 8393 { 8394 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8395 std::string ex(str, iter.base()); 8396 assert(ex == "1_234_567_89_0;125*******"); 8397 assert(ios.width() == 0); 8398 } 8399 ios.width(25); 8400 right(ios); 8401 { 8402 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8403 std::string ex(str, iter.base()); 8404 assert(ex == "*******1_234_567_89_0;125"); 8405 assert(ios.width() == 0); 8406 } 8407 ios.width(25); 8408 internal(ios); 8409 { 8410 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8411 std::string ex(str, iter.base()); 8412 assert(ex == "*******1_234_567_89_0;125"); 8413 assert(ios.width() == 0); 8414 } 8415 } 8416 } 8417 showpoint(ios); 8418 { 8419 ios.imbue(lc); 8420 { 8421 ios.width(0); 8422 { 8423 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8424 std::string ex(str, iter.base()); 8425 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8426 assert(ios.width() == 0); 8427 } 8428 ios.width(25); 8429 left(ios); 8430 { 8431 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8432 std::string ex(str, iter.base()); 8433 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8434 assert(ios.width() == 0); 8435 } 8436 ios.width(25); 8437 right(ios); 8438 { 8439 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8440 std::string ex(str, iter.base()); 8441 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8442 assert(ios.width() == 0); 8443 } 8444 ios.width(25); 8445 internal(ios); 8446 { 8447 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8448 std::string ex(str, iter.base()); 8449 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8450 assert(ios.width() == 0); 8451 } 8452 } 8453 ios.imbue(lg); 8454 { 8455 ios.width(0); 8456 { 8457 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8458 std::string ex(str, iter.base()); 8459 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8460 assert(ios.width() == 0); 8461 } 8462 ios.width(25); 8463 left(ios); 8464 { 8465 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8466 std::string ex(str, iter.base()); 8467 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8468 assert(ios.width() == 0); 8469 } 8470 ios.width(25); 8471 right(ios); 8472 { 8473 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8474 std::string ex(str, iter.base()); 8475 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8476 assert(ios.width() == 0); 8477 } 8478 ios.width(25); 8479 internal(ios); 8480 { 8481 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8482 std::string ex(str, iter.base()); 8483 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8484 assert(ios.width() == 0); 8485 } 8486 } 8487 } 8488 } 8489 showpos(ios); 8490 { 8491 noshowpoint(ios); 8492 { 8493 ios.imbue(lc); 8494 { 8495 ios.width(0); 8496 { 8497 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8498 std::string ex(str, iter.base()); 8499 assert(ex == "+1234567890.125"); 8500 assert(ios.width() == 0); 8501 } 8502 ios.width(25); 8503 left(ios); 8504 { 8505 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8506 std::string ex(str, iter.base()); 8507 assert(ex == "+1234567890.125**********"); 8508 assert(ios.width() == 0); 8509 } 8510 ios.width(25); 8511 right(ios); 8512 { 8513 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8514 std::string ex(str, iter.base()); 8515 assert(ex == "**********+1234567890.125"); 8516 assert(ios.width() == 0); 8517 } 8518 ios.width(25); 8519 internal(ios); 8520 { 8521 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8522 std::string ex(str, iter.base()); 8523 assert(ex == "+**********1234567890.125"); 8524 assert(ios.width() == 0); 8525 } 8526 } 8527 ios.imbue(lg); 8528 { 8529 ios.width(0); 8530 { 8531 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8532 std::string ex(str, iter.base()); 8533 assert(ex == "+1_234_567_89_0;125"); 8534 assert(ios.width() == 0); 8535 } 8536 ios.width(25); 8537 left(ios); 8538 { 8539 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8540 std::string ex(str, iter.base()); 8541 assert(ex == "+1_234_567_89_0;125******"); 8542 assert(ios.width() == 0); 8543 } 8544 ios.width(25); 8545 right(ios); 8546 { 8547 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8548 std::string ex(str, iter.base()); 8549 assert(ex == "******+1_234_567_89_0;125"); 8550 assert(ios.width() == 0); 8551 } 8552 ios.width(25); 8553 internal(ios); 8554 { 8555 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8556 std::string ex(str, iter.base()); 8557 assert(ex == "+******1_234_567_89_0;125"); 8558 assert(ios.width() == 0); 8559 } 8560 } 8561 } 8562 showpoint(ios); 8563 { 8564 ios.imbue(lc); 8565 { 8566 ios.width(0); 8567 { 8568 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8569 std::string ex(str, iter.base()); 8570 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8571 assert(ios.width() == 0); 8572 } 8573 ios.width(25); 8574 left(ios); 8575 { 8576 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8577 std::string ex(str, iter.base()); 8578 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8579 assert(ios.width() == 0); 8580 } 8581 ios.width(25); 8582 right(ios); 8583 { 8584 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8585 std::string ex(str, iter.base()); 8586 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8587 assert(ios.width() == 0); 8588 } 8589 ios.width(25); 8590 internal(ios); 8591 { 8592 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8593 std::string ex(str, iter.base()); 8594 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8595 assert(ios.width() == 0); 8596 } 8597 } 8598 ios.imbue(lg); 8599 { 8600 ios.width(0); 8601 { 8602 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8603 std::string ex(str, iter.base()); 8604 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8605 assert(ios.width() == 0); 8606 } 8607 ios.width(25); 8608 left(ios); 8609 { 8610 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8611 std::string ex(str, iter.base()); 8612 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8613 assert(ios.width() == 0); 8614 } 8615 ios.width(25); 8616 right(ios); 8617 { 8618 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8619 std::string ex(str, iter.base()); 8620 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8621 assert(ios.width() == 0); 8622 } 8623 ios.width(25); 8624 internal(ios); 8625 { 8626 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8627 std::string ex(str, iter.base()); 8628 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8629 assert(ios.width() == 0); 8630 } 8631 } 8632 } 8633 } 8634 } 8635 uppercase(ios); 8636 { 8637 noshowpos(ios); 8638 { 8639 noshowpoint(ios); 8640 { 8641 ios.imbue(lc); 8642 { 8643 ios.width(0); 8644 { 8645 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8646 std::string ex(str, iter.base()); 8647 assert(ex == "1234567890.125"); 8648 assert(ios.width() == 0); 8649 } 8650 ios.width(25); 8651 left(ios); 8652 { 8653 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8654 std::string ex(str, iter.base()); 8655 assert(ex == "1234567890.125***********"); 8656 assert(ios.width() == 0); 8657 } 8658 ios.width(25); 8659 right(ios); 8660 { 8661 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8662 std::string ex(str, iter.base()); 8663 assert(ex == "***********1234567890.125"); 8664 assert(ios.width() == 0); 8665 } 8666 ios.width(25); 8667 internal(ios); 8668 { 8669 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8670 std::string ex(str, iter.base()); 8671 assert(ex == "***********1234567890.125"); 8672 assert(ios.width() == 0); 8673 } 8674 } 8675 ios.imbue(lg); 8676 { 8677 ios.width(0); 8678 { 8679 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8680 std::string ex(str, iter.base()); 8681 assert(ex == "1_234_567_89_0;125"); 8682 assert(ios.width() == 0); 8683 } 8684 ios.width(25); 8685 left(ios); 8686 { 8687 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8688 std::string ex(str, iter.base()); 8689 assert(ex == "1_234_567_89_0;125*******"); 8690 assert(ios.width() == 0); 8691 } 8692 ios.width(25); 8693 right(ios); 8694 { 8695 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8696 std::string ex(str, iter.base()); 8697 assert(ex == "*******1_234_567_89_0;125"); 8698 assert(ios.width() == 0); 8699 } 8700 ios.width(25); 8701 internal(ios); 8702 { 8703 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8704 std::string ex(str, iter.base()); 8705 assert(ex == "*******1_234_567_89_0;125"); 8706 assert(ios.width() == 0); 8707 } 8708 } 8709 } 8710 showpoint(ios); 8711 { 8712 ios.imbue(lc); 8713 { 8714 ios.width(0); 8715 { 8716 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8717 std::string ex(str, iter.base()); 8718 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8719 assert(ios.width() == 0); 8720 } 8721 ios.width(25); 8722 left(ios); 8723 { 8724 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8725 std::string ex(str, iter.base()); 8726 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8727 assert(ios.width() == 0); 8728 } 8729 ios.width(25); 8730 right(ios); 8731 { 8732 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8733 std::string ex(str, iter.base()); 8734 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8735 assert(ios.width() == 0); 8736 } 8737 ios.width(25); 8738 internal(ios); 8739 { 8740 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8741 std::string ex(str, iter.base()); 8742 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8743 assert(ios.width() == 0); 8744 } 8745 } 8746 ios.imbue(lg); 8747 { 8748 ios.width(0); 8749 { 8750 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8751 std::string ex(str, iter.base()); 8752 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8753 assert(ios.width() == 0); 8754 } 8755 ios.width(25); 8756 left(ios); 8757 { 8758 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8759 std::string ex(str, iter.base()); 8760 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8761 assert(ios.width() == 0); 8762 } 8763 ios.width(25); 8764 right(ios); 8765 { 8766 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8767 std::string ex(str, iter.base()); 8768 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8769 assert(ios.width() == 0); 8770 } 8771 ios.width(25); 8772 internal(ios); 8773 { 8774 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8775 std::string ex(str, iter.base()); 8776 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8777 assert(ios.width() == 0); 8778 } 8779 } 8780 } 8781 } 8782 showpos(ios); 8783 { 8784 noshowpoint(ios); 8785 { 8786 ios.imbue(lc); 8787 { 8788 ios.width(0); 8789 { 8790 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8791 std::string ex(str, iter.base()); 8792 assert(ex == "+1234567890.125"); 8793 assert(ios.width() == 0); 8794 } 8795 ios.width(25); 8796 left(ios); 8797 { 8798 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8799 std::string ex(str, iter.base()); 8800 assert(ex == "+1234567890.125**********"); 8801 assert(ios.width() == 0); 8802 } 8803 ios.width(25); 8804 right(ios); 8805 { 8806 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8807 std::string ex(str, iter.base()); 8808 assert(ex == "**********+1234567890.125"); 8809 assert(ios.width() == 0); 8810 } 8811 ios.width(25); 8812 internal(ios); 8813 { 8814 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8815 std::string ex(str, iter.base()); 8816 assert(ex == "+**********1234567890.125"); 8817 assert(ios.width() == 0); 8818 } 8819 } 8820 ios.imbue(lg); 8821 { 8822 ios.width(0); 8823 { 8824 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8825 std::string ex(str, iter.base()); 8826 assert(ex == "+1_234_567_89_0;125"); 8827 assert(ios.width() == 0); 8828 } 8829 ios.width(25); 8830 left(ios); 8831 { 8832 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8833 std::string ex(str, iter.base()); 8834 assert(ex == "+1_234_567_89_0;125******"); 8835 assert(ios.width() == 0); 8836 } 8837 ios.width(25); 8838 right(ios); 8839 { 8840 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8841 std::string ex(str, iter.base()); 8842 assert(ex == "******+1_234_567_89_0;125"); 8843 assert(ios.width() == 0); 8844 } 8845 ios.width(25); 8846 internal(ios); 8847 { 8848 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8849 std::string ex(str, iter.base()); 8850 assert(ex == "+******1_234_567_89_0;125"); 8851 assert(ios.width() == 0); 8852 } 8853 } 8854 } 8855 showpoint(ios); 8856 { 8857 ios.imbue(lc); 8858 { 8859 ios.width(0); 8860 { 8861 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8862 std::string ex(str, iter.base()); 8863 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8864 assert(ios.width() == 0); 8865 } 8866 ios.width(25); 8867 left(ios); 8868 { 8869 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8870 std::string ex(str, iter.base()); 8871 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8872 assert(ios.width() == 0); 8873 } 8874 ios.width(25); 8875 right(ios); 8876 { 8877 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8878 std::string ex(str, iter.base()); 8879 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8880 assert(ios.width() == 0); 8881 } 8882 ios.width(25); 8883 internal(ios); 8884 { 8885 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8886 std::string ex(str, iter.base()); 8887 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8888 assert(ios.width() == 0); 8889 } 8890 } 8891 ios.imbue(lg); 8892 { 8893 ios.width(0); 8894 { 8895 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8896 std::string ex(str, iter.base()); 8897 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8898 assert(ios.width() == 0); 8899 } 8900 ios.width(25); 8901 left(ios); 8902 { 8903 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8904 std::string ex(str, iter.base()); 8905 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8906 assert(ios.width() == 0); 8907 } 8908 ios.width(25); 8909 right(ios); 8910 { 8911 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8912 std::string ex(str, iter.base()); 8913 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8914 assert(ios.width() == 0); 8915 } 8916 ios.width(25); 8917 internal(ios); 8918 { 8919 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8920 std::string ex(str, iter.base()); 8921 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8922 assert(ios.width() == 0); 8923 } 8924 } 8925 } 8926 } 8927 } 8928 } 8929 } 8930 } 8931 } 8932 8933 void test4() 8934 { 8935 char str[200]; 8936 output_iterator<char*> iter; 8937 std::locale lc = std::locale::classic(); 8938 std::locale lg(lc, new my_numpunct); 8939 const my_facet f(1); 8940 { 8941 long double v = -INFINITY; 8942 std::ios ios(0); 8943 // %g 8944 { 8945 ios.precision(0); 8946 { 8947 nouppercase(ios); 8948 { 8949 noshowpos(ios); 8950 { 8951 noshowpoint(ios); 8952 { 8953 ios.imbue(lc); 8954 { 8955 ios.width(0); 8956 { 8957 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8958 std::string ex(str, iter.base()); 8959 assert(ex == "-inf"); 8960 assert(ios.width() == 0); 8961 } 8962 ios.width(25); 8963 left(ios); 8964 { 8965 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8966 std::string ex(str, iter.base()); 8967 assert(ex == "-inf*********************"); 8968 assert(ios.width() == 0); 8969 } 8970 ios.width(25); 8971 right(ios); 8972 { 8973 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8974 std::string ex(str, iter.base()); 8975 assert(ex == "*********************-inf"); 8976 assert(ios.width() == 0); 8977 } 8978 ios.width(25); 8979 internal(ios); 8980 { 8981 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8982 std::string ex(str, iter.base()); 8983 assert(ex == "-*********************inf"); 8984 assert(ios.width() == 0); 8985 } 8986 } 8987 ios.imbue(lg); 8988 { 8989 ios.width(0); 8990 { 8991 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8992 std::string ex(str, iter.base()); 8993 assert(ex == "-inf"); 8994 assert(ios.width() == 0); 8995 } 8996 ios.width(25); 8997 left(ios); 8998 { 8999 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9000 std::string ex(str, iter.base()); 9001 assert(ex == "-inf*********************"); 9002 assert(ios.width() == 0); 9003 } 9004 ios.width(25); 9005 right(ios); 9006 { 9007 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9008 std::string ex(str, iter.base()); 9009 assert(ex == "*********************-inf"); 9010 assert(ios.width() == 0); 9011 } 9012 ios.width(25); 9013 internal(ios); 9014 { 9015 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9016 std::string ex(str, iter.base()); 9017 assert(ex == "-*********************inf"); 9018 assert(ios.width() == 0); 9019 } 9020 } 9021 } 9022 showpoint(ios); 9023 { 9024 ios.imbue(lc); 9025 { 9026 ios.width(0); 9027 { 9028 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9029 std::string ex(str, iter.base()); 9030 assert(ex == "-inf"); 9031 assert(ios.width() == 0); 9032 } 9033 ios.width(25); 9034 left(ios); 9035 { 9036 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9037 std::string ex(str, iter.base()); 9038 assert(ex == "-inf*********************"); 9039 assert(ios.width() == 0); 9040 } 9041 ios.width(25); 9042 right(ios); 9043 { 9044 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9045 std::string ex(str, iter.base()); 9046 assert(ex == "*********************-inf"); 9047 assert(ios.width() == 0); 9048 } 9049 ios.width(25); 9050 internal(ios); 9051 { 9052 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9053 std::string ex(str, iter.base()); 9054 assert(ex == "-*********************inf"); 9055 assert(ios.width() == 0); 9056 } 9057 } 9058 ios.imbue(lg); 9059 { 9060 ios.width(0); 9061 { 9062 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9063 std::string ex(str, iter.base()); 9064 assert(ex == "-inf"); 9065 assert(ios.width() == 0); 9066 } 9067 ios.width(25); 9068 left(ios); 9069 { 9070 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9071 std::string ex(str, iter.base()); 9072 assert(ex == "-inf*********************"); 9073 assert(ios.width() == 0); 9074 } 9075 ios.width(25); 9076 right(ios); 9077 { 9078 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9079 std::string ex(str, iter.base()); 9080 assert(ex == "*********************-inf"); 9081 assert(ios.width() == 0); 9082 } 9083 ios.width(25); 9084 internal(ios); 9085 { 9086 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9087 std::string ex(str, iter.base()); 9088 assert(ex == "-*********************inf"); 9089 assert(ios.width() == 0); 9090 } 9091 } 9092 } 9093 } 9094 showpos(ios); 9095 { 9096 noshowpoint(ios); 9097 { 9098 ios.imbue(lc); 9099 { 9100 ios.width(0); 9101 { 9102 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9103 std::string ex(str, iter.base()); 9104 assert(ex == "-inf"); 9105 assert(ios.width() == 0); 9106 } 9107 ios.width(25); 9108 left(ios); 9109 { 9110 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9111 std::string ex(str, iter.base()); 9112 assert(ex == "-inf*********************"); 9113 assert(ios.width() == 0); 9114 } 9115 ios.width(25); 9116 right(ios); 9117 { 9118 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9119 std::string ex(str, iter.base()); 9120 assert(ex == "*********************-inf"); 9121 assert(ios.width() == 0); 9122 } 9123 ios.width(25); 9124 internal(ios); 9125 { 9126 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9127 std::string ex(str, iter.base()); 9128 assert(ex == "-*********************inf"); 9129 assert(ios.width() == 0); 9130 } 9131 } 9132 ios.imbue(lg); 9133 { 9134 ios.width(0); 9135 { 9136 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9137 std::string ex(str, iter.base()); 9138 assert(ex == "-inf"); 9139 assert(ios.width() == 0); 9140 } 9141 ios.width(25); 9142 left(ios); 9143 { 9144 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9145 std::string ex(str, iter.base()); 9146 assert(ex == "-inf*********************"); 9147 assert(ios.width() == 0); 9148 } 9149 ios.width(25); 9150 right(ios); 9151 { 9152 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9153 std::string ex(str, iter.base()); 9154 assert(ex == "*********************-inf"); 9155 assert(ios.width() == 0); 9156 } 9157 ios.width(25); 9158 internal(ios); 9159 { 9160 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9161 std::string ex(str, iter.base()); 9162 assert(ex == "-*********************inf"); 9163 assert(ios.width() == 0); 9164 } 9165 } 9166 } 9167 showpoint(ios); 9168 { 9169 ios.imbue(lc); 9170 { 9171 ios.width(0); 9172 { 9173 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9174 std::string ex(str, iter.base()); 9175 assert(ex == "-inf"); 9176 assert(ios.width() == 0); 9177 } 9178 ios.width(25); 9179 left(ios); 9180 { 9181 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9182 std::string ex(str, iter.base()); 9183 assert(ex == "-inf*********************"); 9184 assert(ios.width() == 0); 9185 } 9186 ios.width(25); 9187 right(ios); 9188 { 9189 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9190 std::string ex(str, iter.base()); 9191 assert(ex == "*********************-inf"); 9192 assert(ios.width() == 0); 9193 } 9194 ios.width(25); 9195 internal(ios); 9196 { 9197 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9198 std::string ex(str, iter.base()); 9199 assert(ex == "-*********************inf"); 9200 assert(ios.width() == 0); 9201 } 9202 } 9203 ios.imbue(lg); 9204 { 9205 ios.width(0); 9206 { 9207 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9208 std::string ex(str, iter.base()); 9209 assert(ex == "-inf"); 9210 assert(ios.width() == 0); 9211 } 9212 ios.width(25); 9213 left(ios); 9214 { 9215 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9216 std::string ex(str, iter.base()); 9217 assert(ex == "-inf*********************"); 9218 assert(ios.width() == 0); 9219 } 9220 ios.width(25); 9221 right(ios); 9222 { 9223 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9224 std::string ex(str, iter.base()); 9225 assert(ex == "*********************-inf"); 9226 assert(ios.width() == 0); 9227 } 9228 ios.width(25); 9229 internal(ios); 9230 { 9231 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9232 std::string ex(str, iter.base()); 9233 assert(ex == "-*********************inf"); 9234 assert(ios.width() == 0); 9235 } 9236 } 9237 } 9238 } 9239 } 9240 uppercase(ios); 9241 { 9242 noshowpos(ios); 9243 { 9244 noshowpoint(ios); 9245 { 9246 ios.imbue(lc); 9247 { 9248 ios.width(0); 9249 { 9250 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9251 std::string ex(str, iter.base()); 9252 assert(ex == "-INF"); 9253 assert(ios.width() == 0); 9254 } 9255 ios.width(25); 9256 left(ios); 9257 { 9258 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9259 std::string ex(str, iter.base()); 9260 assert(ex == "-INF*********************"); 9261 assert(ios.width() == 0); 9262 } 9263 ios.width(25); 9264 right(ios); 9265 { 9266 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9267 std::string ex(str, iter.base()); 9268 assert(ex == "*********************-INF"); 9269 assert(ios.width() == 0); 9270 } 9271 ios.width(25); 9272 internal(ios); 9273 { 9274 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9275 std::string ex(str, iter.base()); 9276 assert(ex == "-*********************INF"); 9277 assert(ios.width() == 0); 9278 } 9279 } 9280 ios.imbue(lg); 9281 { 9282 ios.width(0); 9283 { 9284 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9285 std::string ex(str, iter.base()); 9286 assert(ex == "-INF"); 9287 assert(ios.width() == 0); 9288 } 9289 ios.width(25); 9290 left(ios); 9291 { 9292 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9293 std::string ex(str, iter.base()); 9294 assert(ex == "-INF*********************"); 9295 assert(ios.width() == 0); 9296 } 9297 ios.width(25); 9298 right(ios); 9299 { 9300 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9301 std::string ex(str, iter.base()); 9302 assert(ex == "*********************-INF"); 9303 assert(ios.width() == 0); 9304 } 9305 ios.width(25); 9306 internal(ios); 9307 { 9308 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9309 std::string ex(str, iter.base()); 9310 assert(ex == "-*********************INF"); 9311 assert(ios.width() == 0); 9312 } 9313 } 9314 } 9315 showpoint(ios); 9316 { 9317 ios.imbue(lc); 9318 { 9319 ios.width(0); 9320 { 9321 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9322 std::string ex(str, iter.base()); 9323 assert(ex == "-INF"); 9324 assert(ios.width() == 0); 9325 } 9326 ios.width(25); 9327 left(ios); 9328 { 9329 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9330 std::string ex(str, iter.base()); 9331 assert(ex == "-INF*********************"); 9332 assert(ios.width() == 0); 9333 } 9334 ios.width(25); 9335 right(ios); 9336 { 9337 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9338 std::string ex(str, iter.base()); 9339 assert(ex == "*********************-INF"); 9340 assert(ios.width() == 0); 9341 } 9342 ios.width(25); 9343 internal(ios); 9344 { 9345 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9346 std::string ex(str, iter.base()); 9347 assert(ex == "-*********************INF"); 9348 assert(ios.width() == 0); 9349 } 9350 } 9351 ios.imbue(lg); 9352 { 9353 ios.width(0); 9354 { 9355 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9356 std::string ex(str, iter.base()); 9357 assert(ex == "-INF"); 9358 assert(ios.width() == 0); 9359 } 9360 ios.width(25); 9361 left(ios); 9362 { 9363 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9364 std::string ex(str, iter.base()); 9365 assert(ex == "-INF*********************"); 9366 assert(ios.width() == 0); 9367 } 9368 ios.width(25); 9369 right(ios); 9370 { 9371 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9372 std::string ex(str, iter.base()); 9373 assert(ex == "*********************-INF"); 9374 assert(ios.width() == 0); 9375 } 9376 ios.width(25); 9377 internal(ios); 9378 { 9379 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9380 std::string ex(str, iter.base()); 9381 assert(ex == "-*********************INF"); 9382 assert(ios.width() == 0); 9383 } 9384 } 9385 } 9386 } 9387 showpos(ios); 9388 { 9389 noshowpoint(ios); 9390 { 9391 ios.imbue(lc); 9392 { 9393 ios.width(0); 9394 { 9395 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9396 std::string ex(str, iter.base()); 9397 assert(ex == "-INF"); 9398 assert(ios.width() == 0); 9399 } 9400 ios.width(25); 9401 left(ios); 9402 { 9403 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9404 std::string ex(str, iter.base()); 9405 assert(ex == "-INF*********************"); 9406 assert(ios.width() == 0); 9407 } 9408 ios.width(25); 9409 right(ios); 9410 { 9411 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9412 std::string ex(str, iter.base()); 9413 assert(ex == "*********************-INF"); 9414 assert(ios.width() == 0); 9415 } 9416 ios.width(25); 9417 internal(ios); 9418 { 9419 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9420 std::string ex(str, iter.base()); 9421 assert(ex == "-*********************INF"); 9422 assert(ios.width() == 0); 9423 } 9424 } 9425 ios.imbue(lg); 9426 { 9427 ios.width(0); 9428 { 9429 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9430 std::string ex(str, iter.base()); 9431 assert(ex == "-INF"); 9432 assert(ios.width() == 0); 9433 } 9434 ios.width(25); 9435 left(ios); 9436 { 9437 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9438 std::string ex(str, iter.base()); 9439 assert(ex == "-INF*********************"); 9440 assert(ios.width() == 0); 9441 } 9442 ios.width(25); 9443 right(ios); 9444 { 9445 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9446 std::string ex(str, iter.base()); 9447 assert(ex == "*********************-INF"); 9448 assert(ios.width() == 0); 9449 } 9450 ios.width(25); 9451 internal(ios); 9452 { 9453 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9454 std::string ex(str, iter.base()); 9455 assert(ex == "-*********************INF"); 9456 assert(ios.width() == 0); 9457 } 9458 } 9459 } 9460 showpoint(ios); 9461 { 9462 ios.imbue(lc); 9463 { 9464 ios.width(0); 9465 { 9466 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9467 std::string ex(str, iter.base()); 9468 assert(ex == "-INF"); 9469 assert(ios.width() == 0); 9470 } 9471 ios.width(25); 9472 left(ios); 9473 { 9474 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9475 std::string ex(str, iter.base()); 9476 assert(ex == "-INF*********************"); 9477 assert(ios.width() == 0); 9478 } 9479 ios.width(25); 9480 right(ios); 9481 { 9482 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9483 std::string ex(str, iter.base()); 9484 assert(ex == "*********************-INF"); 9485 assert(ios.width() == 0); 9486 } 9487 ios.width(25); 9488 internal(ios); 9489 { 9490 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9491 std::string ex(str, iter.base()); 9492 assert(ex == "-*********************INF"); 9493 assert(ios.width() == 0); 9494 } 9495 } 9496 ios.imbue(lg); 9497 { 9498 ios.width(0); 9499 { 9500 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9501 std::string ex(str, iter.base()); 9502 assert(ex == "-INF"); 9503 assert(ios.width() == 0); 9504 } 9505 ios.width(25); 9506 left(ios); 9507 { 9508 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9509 std::string ex(str, iter.base()); 9510 assert(ex == "-INF*********************"); 9511 assert(ios.width() == 0); 9512 } 9513 ios.width(25); 9514 right(ios); 9515 { 9516 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9517 std::string ex(str, iter.base()); 9518 assert(ex == "*********************-INF"); 9519 assert(ios.width() == 0); 9520 } 9521 ios.width(25); 9522 internal(ios); 9523 { 9524 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9525 std::string ex(str, iter.base()); 9526 assert(ex == "-*********************INF"); 9527 assert(ios.width() == 0); 9528 } 9529 } 9530 } 9531 } 9532 } 9533 } 9534 ios.precision(1); 9535 { 9536 nouppercase(ios); 9537 { 9538 noshowpos(ios); 9539 { 9540 noshowpoint(ios); 9541 { 9542 ios.imbue(lc); 9543 { 9544 ios.width(0); 9545 { 9546 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9547 std::string ex(str, iter.base()); 9548 assert(ex == "-inf"); 9549 assert(ios.width() == 0); 9550 } 9551 ios.width(25); 9552 left(ios); 9553 { 9554 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9555 std::string ex(str, iter.base()); 9556 assert(ex == "-inf*********************"); 9557 assert(ios.width() == 0); 9558 } 9559 ios.width(25); 9560 right(ios); 9561 { 9562 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9563 std::string ex(str, iter.base()); 9564 assert(ex == "*********************-inf"); 9565 assert(ios.width() == 0); 9566 } 9567 ios.width(25); 9568 internal(ios); 9569 { 9570 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9571 std::string ex(str, iter.base()); 9572 assert(ex == "-*********************inf"); 9573 assert(ios.width() == 0); 9574 } 9575 } 9576 ios.imbue(lg); 9577 { 9578 ios.width(0); 9579 { 9580 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9581 std::string ex(str, iter.base()); 9582 assert(ex == "-inf"); 9583 assert(ios.width() == 0); 9584 } 9585 ios.width(25); 9586 left(ios); 9587 { 9588 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9589 std::string ex(str, iter.base()); 9590 assert(ex == "-inf*********************"); 9591 assert(ios.width() == 0); 9592 } 9593 ios.width(25); 9594 right(ios); 9595 { 9596 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9597 std::string ex(str, iter.base()); 9598 assert(ex == "*********************-inf"); 9599 assert(ios.width() == 0); 9600 } 9601 ios.width(25); 9602 internal(ios); 9603 { 9604 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9605 std::string ex(str, iter.base()); 9606 assert(ex == "-*********************inf"); 9607 assert(ios.width() == 0); 9608 } 9609 } 9610 } 9611 showpoint(ios); 9612 { 9613 ios.imbue(lc); 9614 { 9615 ios.width(0); 9616 { 9617 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9618 std::string ex(str, iter.base()); 9619 assert(ex == "-inf"); 9620 assert(ios.width() == 0); 9621 } 9622 ios.width(25); 9623 left(ios); 9624 { 9625 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9626 std::string ex(str, iter.base()); 9627 assert(ex == "-inf*********************"); 9628 assert(ios.width() == 0); 9629 } 9630 ios.width(25); 9631 right(ios); 9632 { 9633 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9634 std::string ex(str, iter.base()); 9635 assert(ex == "*********************-inf"); 9636 assert(ios.width() == 0); 9637 } 9638 ios.width(25); 9639 internal(ios); 9640 { 9641 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9642 std::string ex(str, iter.base()); 9643 assert(ex == "-*********************inf"); 9644 assert(ios.width() == 0); 9645 } 9646 } 9647 ios.imbue(lg); 9648 { 9649 ios.width(0); 9650 { 9651 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9652 std::string ex(str, iter.base()); 9653 assert(ex == "-inf"); 9654 assert(ios.width() == 0); 9655 } 9656 ios.width(25); 9657 left(ios); 9658 { 9659 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9660 std::string ex(str, iter.base()); 9661 assert(ex == "-inf*********************"); 9662 assert(ios.width() == 0); 9663 } 9664 ios.width(25); 9665 right(ios); 9666 { 9667 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9668 std::string ex(str, iter.base()); 9669 assert(ex == "*********************-inf"); 9670 assert(ios.width() == 0); 9671 } 9672 ios.width(25); 9673 internal(ios); 9674 { 9675 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9676 std::string ex(str, iter.base()); 9677 assert(ex == "-*********************inf"); 9678 assert(ios.width() == 0); 9679 } 9680 } 9681 } 9682 } 9683 showpos(ios); 9684 { 9685 noshowpoint(ios); 9686 { 9687 ios.imbue(lc); 9688 { 9689 ios.width(0); 9690 { 9691 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9692 std::string ex(str, iter.base()); 9693 assert(ex == "-inf"); 9694 assert(ios.width() == 0); 9695 } 9696 ios.width(25); 9697 left(ios); 9698 { 9699 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9700 std::string ex(str, iter.base()); 9701 assert(ex == "-inf*********************"); 9702 assert(ios.width() == 0); 9703 } 9704 ios.width(25); 9705 right(ios); 9706 { 9707 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9708 std::string ex(str, iter.base()); 9709 assert(ex == "*********************-inf"); 9710 assert(ios.width() == 0); 9711 } 9712 ios.width(25); 9713 internal(ios); 9714 { 9715 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9716 std::string ex(str, iter.base()); 9717 assert(ex == "-*********************inf"); 9718 assert(ios.width() == 0); 9719 } 9720 } 9721 ios.imbue(lg); 9722 { 9723 ios.width(0); 9724 { 9725 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9726 std::string ex(str, iter.base()); 9727 assert(ex == "-inf"); 9728 assert(ios.width() == 0); 9729 } 9730 ios.width(25); 9731 left(ios); 9732 { 9733 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9734 std::string ex(str, iter.base()); 9735 assert(ex == "-inf*********************"); 9736 assert(ios.width() == 0); 9737 } 9738 ios.width(25); 9739 right(ios); 9740 { 9741 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9742 std::string ex(str, iter.base()); 9743 assert(ex == "*********************-inf"); 9744 assert(ios.width() == 0); 9745 } 9746 ios.width(25); 9747 internal(ios); 9748 { 9749 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9750 std::string ex(str, iter.base()); 9751 assert(ex == "-*********************inf"); 9752 assert(ios.width() == 0); 9753 } 9754 } 9755 } 9756 showpoint(ios); 9757 { 9758 ios.imbue(lc); 9759 { 9760 ios.width(0); 9761 { 9762 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9763 std::string ex(str, iter.base()); 9764 assert(ex == "-inf"); 9765 assert(ios.width() == 0); 9766 } 9767 ios.width(25); 9768 left(ios); 9769 { 9770 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9771 std::string ex(str, iter.base()); 9772 assert(ex == "-inf*********************"); 9773 assert(ios.width() == 0); 9774 } 9775 ios.width(25); 9776 right(ios); 9777 { 9778 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9779 std::string ex(str, iter.base()); 9780 assert(ex == "*********************-inf"); 9781 assert(ios.width() == 0); 9782 } 9783 ios.width(25); 9784 internal(ios); 9785 { 9786 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9787 std::string ex(str, iter.base()); 9788 assert(ex == "-*********************inf"); 9789 assert(ios.width() == 0); 9790 } 9791 } 9792 ios.imbue(lg); 9793 { 9794 ios.width(0); 9795 { 9796 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9797 std::string ex(str, iter.base()); 9798 assert(ex == "-inf"); 9799 assert(ios.width() == 0); 9800 } 9801 ios.width(25); 9802 left(ios); 9803 { 9804 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9805 std::string ex(str, iter.base()); 9806 assert(ex == "-inf*********************"); 9807 assert(ios.width() == 0); 9808 } 9809 ios.width(25); 9810 right(ios); 9811 { 9812 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9813 std::string ex(str, iter.base()); 9814 assert(ex == "*********************-inf"); 9815 assert(ios.width() == 0); 9816 } 9817 ios.width(25); 9818 internal(ios); 9819 { 9820 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9821 std::string ex(str, iter.base()); 9822 assert(ex == "-*********************inf"); 9823 assert(ios.width() == 0); 9824 } 9825 } 9826 } 9827 } 9828 } 9829 uppercase(ios); 9830 { 9831 noshowpos(ios); 9832 { 9833 noshowpoint(ios); 9834 { 9835 ios.imbue(lc); 9836 { 9837 ios.width(0); 9838 { 9839 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9840 std::string ex(str, iter.base()); 9841 assert(ex == "-INF"); 9842 assert(ios.width() == 0); 9843 } 9844 ios.width(25); 9845 left(ios); 9846 { 9847 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9848 std::string ex(str, iter.base()); 9849 assert(ex == "-INF*********************"); 9850 assert(ios.width() == 0); 9851 } 9852 ios.width(25); 9853 right(ios); 9854 { 9855 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9856 std::string ex(str, iter.base()); 9857 assert(ex == "*********************-INF"); 9858 assert(ios.width() == 0); 9859 } 9860 ios.width(25); 9861 internal(ios); 9862 { 9863 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9864 std::string ex(str, iter.base()); 9865 assert(ex == "-*********************INF"); 9866 assert(ios.width() == 0); 9867 } 9868 } 9869 ios.imbue(lg); 9870 { 9871 ios.width(0); 9872 { 9873 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9874 std::string ex(str, iter.base()); 9875 assert(ex == "-INF"); 9876 assert(ios.width() == 0); 9877 } 9878 ios.width(25); 9879 left(ios); 9880 { 9881 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9882 std::string ex(str, iter.base()); 9883 assert(ex == "-INF*********************"); 9884 assert(ios.width() == 0); 9885 } 9886 ios.width(25); 9887 right(ios); 9888 { 9889 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9890 std::string ex(str, iter.base()); 9891 assert(ex == "*********************-INF"); 9892 assert(ios.width() == 0); 9893 } 9894 ios.width(25); 9895 internal(ios); 9896 { 9897 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9898 std::string ex(str, iter.base()); 9899 assert(ex == "-*********************INF"); 9900 assert(ios.width() == 0); 9901 } 9902 } 9903 } 9904 showpoint(ios); 9905 { 9906 ios.imbue(lc); 9907 { 9908 ios.width(0); 9909 { 9910 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9911 std::string ex(str, iter.base()); 9912 assert(ex == "-INF"); 9913 assert(ios.width() == 0); 9914 } 9915 ios.width(25); 9916 left(ios); 9917 { 9918 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9919 std::string ex(str, iter.base()); 9920 assert(ex == "-INF*********************"); 9921 assert(ios.width() == 0); 9922 } 9923 ios.width(25); 9924 right(ios); 9925 { 9926 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9927 std::string ex(str, iter.base()); 9928 assert(ex == "*********************-INF"); 9929 assert(ios.width() == 0); 9930 } 9931 ios.width(25); 9932 internal(ios); 9933 { 9934 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9935 std::string ex(str, iter.base()); 9936 assert(ex == "-*********************INF"); 9937 assert(ios.width() == 0); 9938 } 9939 } 9940 ios.imbue(lg); 9941 { 9942 ios.width(0); 9943 { 9944 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9945 std::string ex(str, iter.base()); 9946 assert(ex == "-INF"); 9947 assert(ios.width() == 0); 9948 } 9949 ios.width(25); 9950 left(ios); 9951 { 9952 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9953 std::string ex(str, iter.base()); 9954 assert(ex == "-INF*********************"); 9955 assert(ios.width() == 0); 9956 } 9957 ios.width(25); 9958 right(ios); 9959 { 9960 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9961 std::string ex(str, iter.base()); 9962 assert(ex == "*********************-INF"); 9963 assert(ios.width() == 0); 9964 } 9965 ios.width(25); 9966 internal(ios); 9967 { 9968 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9969 std::string ex(str, iter.base()); 9970 assert(ex == "-*********************INF"); 9971 assert(ios.width() == 0); 9972 } 9973 } 9974 } 9975 } 9976 showpos(ios); 9977 { 9978 noshowpoint(ios); 9979 { 9980 ios.imbue(lc); 9981 { 9982 ios.width(0); 9983 { 9984 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9985 std::string ex(str, iter.base()); 9986 assert(ex == "-INF"); 9987 assert(ios.width() == 0); 9988 } 9989 ios.width(25); 9990 left(ios); 9991 { 9992 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9993 std::string ex(str, iter.base()); 9994 assert(ex == "-INF*********************"); 9995 assert(ios.width() == 0); 9996 } 9997 ios.width(25); 9998 right(ios); 9999 { 10000 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10001 std::string ex(str, iter.base()); 10002 assert(ex == "*********************-INF"); 10003 assert(ios.width() == 0); 10004 } 10005 ios.width(25); 10006 internal(ios); 10007 { 10008 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10009 std::string ex(str, iter.base()); 10010 assert(ex == "-*********************INF"); 10011 assert(ios.width() == 0); 10012 } 10013 } 10014 ios.imbue(lg); 10015 { 10016 ios.width(0); 10017 { 10018 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10019 std::string ex(str, iter.base()); 10020 assert(ex == "-INF"); 10021 assert(ios.width() == 0); 10022 } 10023 ios.width(25); 10024 left(ios); 10025 { 10026 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10027 std::string ex(str, iter.base()); 10028 assert(ex == "-INF*********************"); 10029 assert(ios.width() == 0); 10030 } 10031 ios.width(25); 10032 right(ios); 10033 { 10034 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10035 std::string ex(str, iter.base()); 10036 assert(ex == "*********************-INF"); 10037 assert(ios.width() == 0); 10038 } 10039 ios.width(25); 10040 internal(ios); 10041 { 10042 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10043 std::string ex(str, iter.base()); 10044 assert(ex == "-*********************INF"); 10045 assert(ios.width() == 0); 10046 } 10047 } 10048 } 10049 showpoint(ios); 10050 { 10051 ios.imbue(lc); 10052 { 10053 ios.width(0); 10054 { 10055 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10056 std::string ex(str, iter.base()); 10057 assert(ex == "-INF"); 10058 assert(ios.width() == 0); 10059 } 10060 ios.width(25); 10061 left(ios); 10062 { 10063 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10064 std::string ex(str, iter.base()); 10065 assert(ex == "-INF*********************"); 10066 assert(ios.width() == 0); 10067 } 10068 ios.width(25); 10069 right(ios); 10070 { 10071 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10072 std::string ex(str, iter.base()); 10073 assert(ex == "*********************-INF"); 10074 assert(ios.width() == 0); 10075 } 10076 ios.width(25); 10077 internal(ios); 10078 { 10079 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10080 std::string ex(str, iter.base()); 10081 assert(ex == "-*********************INF"); 10082 assert(ios.width() == 0); 10083 } 10084 } 10085 ios.imbue(lg); 10086 { 10087 ios.width(0); 10088 { 10089 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10090 std::string ex(str, iter.base()); 10091 assert(ex == "-INF"); 10092 assert(ios.width() == 0); 10093 } 10094 ios.width(25); 10095 left(ios); 10096 { 10097 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10098 std::string ex(str, iter.base()); 10099 assert(ex == "-INF*********************"); 10100 assert(ios.width() == 0); 10101 } 10102 ios.width(25); 10103 right(ios); 10104 { 10105 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10106 std::string ex(str, iter.base()); 10107 assert(ex == "*********************-INF"); 10108 assert(ios.width() == 0); 10109 } 10110 ios.width(25); 10111 internal(ios); 10112 { 10113 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10114 std::string ex(str, iter.base()); 10115 assert(ex == "-*********************INF"); 10116 assert(ios.width() == 0); 10117 } 10118 } 10119 } 10120 } 10121 } 10122 } 10123 ios.precision(6); 10124 { 10125 nouppercase(ios); 10126 { 10127 noshowpos(ios); 10128 { 10129 noshowpoint(ios); 10130 { 10131 ios.imbue(lc); 10132 { 10133 ios.width(0); 10134 { 10135 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10136 std::string ex(str, iter.base()); 10137 assert(ex == "-inf"); 10138 assert(ios.width() == 0); 10139 } 10140 ios.width(25); 10141 left(ios); 10142 { 10143 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10144 std::string ex(str, iter.base()); 10145 assert(ex == "-inf*********************"); 10146 assert(ios.width() == 0); 10147 } 10148 ios.width(25); 10149 right(ios); 10150 { 10151 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10152 std::string ex(str, iter.base()); 10153 assert(ex == "*********************-inf"); 10154 assert(ios.width() == 0); 10155 } 10156 ios.width(25); 10157 internal(ios); 10158 { 10159 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10160 std::string ex(str, iter.base()); 10161 assert(ex == "-*********************inf"); 10162 assert(ios.width() == 0); 10163 } 10164 } 10165 ios.imbue(lg); 10166 { 10167 ios.width(0); 10168 { 10169 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10170 std::string ex(str, iter.base()); 10171 assert(ex == "-inf"); 10172 assert(ios.width() == 0); 10173 } 10174 ios.width(25); 10175 left(ios); 10176 { 10177 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10178 std::string ex(str, iter.base()); 10179 assert(ex == "-inf*********************"); 10180 assert(ios.width() == 0); 10181 } 10182 ios.width(25); 10183 right(ios); 10184 { 10185 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10186 std::string ex(str, iter.base()); 10187 assert(ex == "*********************-inf"); 10188 assert(ios.width() == 0); 10189 } 10190 ios.width(25); 10191 internal(ios); 10192 { 10193 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10194 std::string ex(str, iter.base()); 10195 assert(ex == "-*********************inf"); 10196 assert(ios.width() == 0); 10197 } 10198 } 10199 } 10200 showpoint(ios); 10201 { 10202 ios.imbue(lc); 10203 { 10204 ios.width(0); 10205 { 10206 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10207 std::string ex(str, iter.base()); 10208 assert(ex == "-inf"); 10209 assert(ios.width() == 0); 10210 } 10211 ios.width(25); 10212 left(ios); 10213 { 10214 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10215 std::string ex(str, iter.base()); 10216 assert(ex == "-inf*********************"); 10217 assert(ios.width() == 0); 10218 } 10219 ios.width(25); 10220 right(ios); 10221 { 10222 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10223 std::string ex(str, iter.base()); 10224 assert(ex == "*********************-inf"); 10225 assert(ios.width() == 0); 10226 } 10227 ios.width(25); 10228 internal(ios); 10229 { 10230 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10231 std::string ex(str, iter.base()); 10232 assert(ex == "-*********************inf"); 10233 assert(ios.width() == 0); 10234 } 10235 } 10236 ios.imbue(lg); 10237 { 10238 ios.width(0); 10239 { 10240 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10241 std::string ex(str, iter.base()); 10242 assert(ex == "-inf"); 10243 assert(ios.width() == 0); 10244 } 10245 ios.width(25); 10246 left(ios); 10247 { 10248 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10249 std::string ex(str, iter.base()); 10250 assert(ex == "-inf*********************"); 10251 assert(ios.width() == 0); 10252 } 10253 ios.width(25); 10254 right(ios); 10255 { 10256 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10257 std::string ex(str, iter.base()); 10258 assert(ex == "*********************-inf"); 10259 assert(ios.width() == 0); 10260 } 10261 ios.width(25); 10262 internal(ios); 10263 { 10264 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10265 std::string ex(str, iter.base()); 10266 assert(ex == "-*********************inf"); 10267 assert(ios.width() == 0); 10268 } 10269 } 10270 } 10271 } 10272 showpos(ios); 10273 { 10274 noshowpoint(ios); 10275 { 10276 ios.imbue(lc); 10277 { 10278 ios.width(0); 10279 { 10280 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10281 std::string ex(str, iter.base()); 10282 assert(ex == "-inf"); 10283 assert(ios.width() == 0); 10284 } 10285 ios.width(25); 10286 left(ios); 10287 { 10288 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10289 std::string ex(str, iter.base()); 10290 assert(ex == "-inf*********************"); 10291 assert(ios.width() == 0); 10292 } 10293 ios.width(25); 10294 right(ios); 10295 { 10296 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10297 std::string ex(str, iter.base()); 10298 assert(ex == "*********************-inf"); 10299 assert(ios.width() == 0); 10300 } 10301 ios.width(25); 10302 internal(ios); 10303 { 10304 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10305 std::string ex(str, iter.base()); 10306 assert(ex == "-*********************inf"); 10307 assert(ios.width() == 0); 10308 } 10309 } 10310 ios.imbue(lg); 10311 { 10312 ios.width(0); 10313 { 10314 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10315 std::string ex(str, iter.base()); 10316 assert(ex == "-inf"); 10317 assert(ios.width() == 0); 10318 } 10319 ios.width(25); 10320 left(ios); 10321 { 10322 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10323 std::string ex(str, iter.base()); 10324 assert(ex == "-inf*********************"); 10325 assert(ios.width() == 0); 10326 } 10327 ios.width(25); 10328 right(ios); 10329 { 10330 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10331 std::string ex(str, iter.base()); 10332 assert(ex == "*********************-inf"); 10333 assert(ios.width() == 0); 10334 } 10335 ios.width(25); 10336 internal(ios); 10337 { 10338 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10339 std::string ex(str, iter.base()); 10340 assert(ex == "-*********************inf"); 10341 assert(ios.width() == 0); 10342 } 10343 } 10344 } 10345 showpoint(ios); 10346 { 10347 ios.imbue(lc); 10348 { 10349 ios.width(0); 10350 { 10351 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10352 std::string ex(str, iter.base()); 10353 assert(ex == "-inf"); 10354 assert(ios.width() == 0); 10355 } 10356 ios.width(25); 10357 left(ios); 10358 { 10359 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10360 std::string ex(str, iter.base()); 10361 assert(ex == "-inf*********************"); 10362 assert(ios.width() == 0); 10363 } 10364 ios.width(25); 10365 right(ios); 10366 { 10367 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10368 std::string ex(str, iter.base()); 10369 assert(ex == "*********************-inf"); 10370 assert(ios.width() == 0); 10371 } 10372 ios.width(25); 10373 internal(ios); 10374 { 10375 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10376 std::string ex(str, iter.base()); 10377 assert(ex == "-*********************inf"); 10378 assert(ios.width() == 0); 10379 } 10380 } 10381 ios.imbue(lg); 10382 { 10383 ios.width(0); 10384 { 10385 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10386 std::string ex(str, iter.base()); 10387 assert(ex == "-inf"); 10388 assert(ios.width() == 0); 10389 } 10390 ios.width(25); 10391 left(ios); 10392 { 10393 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10394 std::string ex(str, iter.base()); 10395 assert(ex == "-inf*********************"); 10396 assert(ios.width() == 0); 10397 } 10398 ios.width(25); 10399 right(ios); 10400 { 10401 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10402 std::string ex(str, iter.base()); 10403 assert(ex == "*********************-inf"); 10404 assert(ios.width() == 0); 10405 } 10406 ios.width(25); 10407 internal(ios); 10408 { 10409 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10410 std::string ex(str, iter.base()); 10411 assert(ex == "-*********************inf"); 10412 assert(ios.width() == 0); 10413 } 10414 } 10415 } 10416 } 10417 } 10418 uppercase(ios); 10419 { 10420 noshowpos(ios); 10421 { 10422 noshowpoint(ios); 10423 { 10424 ios.imbue(lc); 10425 { 10426 ios.width(0); 10427 { 10428 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10429 std::string ex(str, iter.base()); 10430 assert(ex == "-INF"); 10431 assert(ios.width() == 0); 10432 } 10433 ios.width(25); 10434 left(ios); 10435 { 10436 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10437 std::string ex(str, iter.base()); 10438 assert(ex == "-INF*********************"); 10439 assert(ios.width() == 0); 10440 } 10441 ios.width(25); 10442 right(ios); 10443 { 10444 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10445 std::string ex(str, iter.base()); 10446 assert(ex == "*********************-INF"); 10447 assert(ios.width() == 0); 10448 } 10449 ios.width(25); 10450 internal(ios); 10451 { 10452 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10453 std::string ex(str, iter.base()); 10454 assert(ex == "-*********************INF"); 10455 assert(ios.width() == 0); 10456 } 10457 } 10458 ios.imbue(lg); 10459 { 10460 ios.width(0); 10461 { 10462 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10463 std::string ex(str, iter.base()); 10464 assert(ex == "-INF"); 10465 assert(ios.width() == 0); 10466 } 10467 ios.width(25); 10468 left(ios); 10469 { 10470 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10471 std::string ex(str, iter.base()); 10472 assert(ex == "-INF*********************"); 10473 assert(ios.width() == 0); 10474 } 10475 ios.width(25); 10476 right(ios); 10477 { 10478 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10479 std::string ex(str, iter.base()); 10480 assert(ex == "*********************-INF"); 10481 assert(ios.width() == 0); 10482 } 10483 ios.width(25); 10484 internal(ios); 10485 { 10486 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10487 std::string ex(str, iter.base()); 10488 assert(ex == "-*********************INF"); 10489 assert(ios.width() == 0); 10490 } 10491 } 10492 } 10493 showpoint(ios); 10494 { 10495 ios.imbue(lc); 10496 { 10497 ios.width(0); 10498 { 10499 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10500 std::string ex(str, iter.base()); 10501 assert(ex == "-INF"); 10502 assert(ios.width() == 0); 10503 } 10504 ios.width(25); 10505 left(ios); 10506 { 10507 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10508 std::string ex(str, iter.base()); 10509 assert(ex == "-INF*********************"); 10510 assert(ios.width() == 0); 10511 } 10512 ios.width(25); 10513 right(ios); 10514 { 10515 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10516 std::string ex(str, iter.base()); 10517 assert(ex == "*********************-INF"); 10518 assert(ios.width() == 0); 10519 } 10520 ios.width(25); 10521 internal(ios); 10522 { 10523 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10524 std::string ex(str, iter.base()); 10525 assert(ex == "-*********************INF"); 10526 assert(ios.width() == 0); 10527 } 10528 } 10529 ios.imbue(lg); 10530 { 10531 ios.width(0); 10532 { 10533 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10534 std::string ex(str, iter.base()); 10535 assert(ex == "-INF"); 10536 assert(ios.width() == 0); 10537 } 10538 ios.width(25); 10539 left(ios); 10540 { 10541 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10542 std::string ex(str, iter.base()); 10543 assert(ex == "-INF*********************"); 10544 assert(ios.width() == 0); 10545 } 10546 ios.width(25); 10547 right(ios); 10548 { 10549 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10550 std::string ex(str, iter.base()); 10551 assert(ex == "*********************-INF"); 10552 assert(ios.width() == 0); 10553 } 10554 ios.width(25); 10555 internal(ios); 10556 { 10557 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10558 std::string ex(str, iter.base()); 10559 assert(ex == "-*********************INF"); 10560 assert(ios.width() == 0); 10561 } 10562 } 10563 } 10564 } 10565 showpos(ios); 10566 { 10567 noshowpoint(ios); 10568 { 10569 ios.imbue(lc); 10570 { 10571 ios.width(0); 10572 { 10573 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10574 std::string ex(str, iter.base()); 10575 assert(ex == "-INF"); 10576 assert(ios.width() == 0); 10577 } 10578 ios.width(25); 10579 left(ios); 10580 { 10581 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10582 std::string ex(str, iter.base()); 10583 assert(ex == "-INF*********************"); 10584 assert(ios.width() == 0); 10585 } 10586 ios.width(25); 10587 right(ios); 10588 { 10589 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10590 std::string ex(str, iter.base()); 10591 assert(ex == "*********************-INF"); 10592 assert(ios.width() == 0); 10593 } 10594 ios.width(25); 10595 internal(ios); 10596 { 10597 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10598 std::string ex(str, iter.base()); 10599 assert(ex == "-*********************INF"); 10600 assert(ios.width() == 0); 10601 } 10602 } 10603 ios.imbue(lg); 10604 { 10605 ios.width(0); 10606 { 10607 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10608 std::string ex(str, iter.base()); 10609 assert(ex == "-INF"); 10610 assert(ios.width() == 0); 10611 } 10612 ios.width(25); 10613 left(ios); 10614 { 10615 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10616 std::string ex(str, iter.base()); 10617 assert(ex == "-INF*********************"); 10618 assert(ios.width() == 0); 10619 } 10620 ios.width(25); 10621 right(ios); 10622 { 10623 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10624 std::string ex(str, iter.base()); 10625 assert(ex == "*********************-INF"); 10626 assert(ios.width() == 0); 10627 } 10628 ios.width(25); 10629 internal(ios); 10630 { 10631 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10632 std::string ex(str, iter.base()); 10633 assert(ex == "-*********************INF"); 10634 assert(ios.width() == 0); 10635 } 10636 } 10637 } 10638 showpoint(ios); 10639 { 10640 ios.imbue(lc); 10641 { 10642 ios.width(0); 10643 { 10644 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10645 std::string ex(str, iter.base()); 10646 assert(ex == "-INF"); 10647 assert(ios.width() == 0); 10648 } 10649 ios.width(25); 10650 left(ios); 10651 { 10652 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10653 std::string ex(str, iter.base()); 10654 assert(ex == "-INF*********************"); 10655 assert(ios.width() == 0); 10656 } 10657 ios.width(25); 10658 right(ios); 10659 { 10660 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10661 std::string ex(str, iter.base()); 10662 assert(ex == "*********************-INF"); 10663 assert(ios.width() == 0); 10664 } 10665 ios.width(25); 10666 internal(ios); 10667 { 10668 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10669 std::string ex(str, iter.base()); 10670 assert(ex == "-*********************INF"); 10671 assert(ios.width() == 0); 10672 } 10673 } 10674 ios.imbue(lg); 10675 { 10676 ios.width(0); 10677 { 10678 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10679 std::string ex(str, iter.base()); 10680 assert(ex == "-INF"); 10681 assert(ios.width() == 0); 10682 } 10683 ios.width(25); 10684 left(ios); 10685 { 10686 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10687 std::string ex(str, iter.base()); 10688 assert(ex == "-INF*********************"); 10689 assert(ios.width() == 0); 10690 } 10691 ios.width(25); 10692 right(ios); 10693 { 10694 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10695 std::string ex(str, iter.base()); 10696 assert(ex == "*********************-INF"); 10697 assert(ios.width() == 0); 10698 } 10699 ios.width(25); 10700 internal(ios); 10701 { 10702 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10703 std::string ex(str, iter.base()); 10704 assert(ex == "-*********************INF"); 10705 assert(ios.width() == 0); 10706 } 10707 } 10708 } 10709 } 10710 } 10711 } 10712 ios.precision(16); 10713 {} 10714 ios.precision(60); 10715 {} 10716 } 10717 } 10718 } 10719 10720 void test5() 10721 { 10722 char str[200]; 10723 output_iterator<char*> iter; 10724 std::locale lc = std::locale::classic(); 10725 std::locale lg(lc, new my_numpunct); 10726 const my_facet f(1); 10727 { 10728 long double v = std::nan(""); 10729 std::ios ios(0); 10730 // %g 10731 { 10732 ios.precision(0); 10733 { 10734 nouppercase(ios); 10735 { 10736 noshowpos(ios); 10737 { 10738 noshowpoint(ios); 10739 { 10740 ios.imbue(lc); 10741 { 10742 ios.width(0); 10743 { 10744 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10745 std::string ex(str, iter.base()); 10746 assert(ex == "nan"); 10747 assert(ios.width() == 0); 10748 } 10749 ios.width(25); 10750 left(ios); 10751 { 10752 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10753 std::string ex(str, iter.base()); 10754 assert(ex == "nan**********************"); 10755 assert(ios.width() == 0); 10756 } 10757 ios.width(25); 10758 right(ios); 10759 { 10760 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10761 std::string ex(str, iter.base()); 10762 assert(ex == "**********************nan"); 10763 assert(ios.width() == 0); 10764 } 10765 ios.width(25); 10766 internal(ios); 10767 { 10768 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10769 std::string ex(str, iter.base()); 10770 assert(ex == "**********************nan"); 10771 assert(ios.width() == 0); 10772 } 10773 } 10774 ios.imbue(lg); 10775 { 10776 ios.width(0); 10777 { 10778 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10779 std::string ex(str, iter.base()); 10780 assert(ex == "nan"); 10781 assert(ios.width() == 0); 10782 } 10783 ios.width(25); 10784 left(ios); 10785 { 10786 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10787 std::string ex(str, iter.base()); 10788 assert(ex == "nan**********************"); 10789 assert(ios.width() == 0); 10790 } 10791 ios.width(25); 10792 right(ios); 10793 { 10794 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10795 std::string ex(str, iter.base()); 10796 assert(ex == "**********************nan"); 10797 assert(ios.width() == 0); 10798 } 10799 ios.width(25); 10800 internal(ios); 10801 { 10802 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10803 std::string ex(str, iter.base()); 10804 assert(ex == "**********************nan"); 10805 assert(ios.width() == 0); 10806 } 10807 } 10808 } 10809 showpoint(ios); 10810 { 10811 ios.imbue(lc); 10812 { 10813 ios.width(0); 10814 { 10815 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10816 std::string ex(str, iter.base()); 10817 assert(ex == "nan"); 10818 assert(ios.width() == 0); 10819 } 10820 ios.width(25); 10821 left(ios); 10822 { 10823 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10824 std::string ex(str, iter.base()); 10825 assert(ex == "nan**********************"); 10826 assert(ios.width() == 0); 10827 } 10828 ios.width(25); 10829 right(ios); 10830 { 10831 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10832 std::string ex(str, iter.base()); 10833 assert(ex == "**********************nan"); 10834 assert(ios.width() == 0); 10835 } 10836 ios.width(25); 10837 internal(ios); 10838 { 10839 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10840 std::string ex(str, iter.base()); 10841 assert(ex == "**********************nan"); 10842 assert(ios.width() == 0); 10843 } 10844 } 10845 ios.imbue(lg); 10846 { 10847 ios.width(0); 10848 { 10849 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10850 std::string ex(str, iter.base()); 10851 assert(ex == "nan"); 10852 assert(ios.width() == 0); 10853 } 10854 ios.width(25); 10855 left(ios); 10856 { 10857 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10858 std::string ex(str, iter.base()); 10859 assert(ex == "nan**********************"); 10860 assert(ios.width() == 0); 10861 } 10862 ios.width(25); 10863 right(ios); 10864 { 10865 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10866 std::string ex(str, iter.base()); 10867 assert(ex == "**********************nan"); 10868 assert(ios.width() == 0); 10869 } 10870 ios.width(25); 10871 internal(ios); 10872 { 10873 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10874 std::string ex(str, iter.base()); 10875 assert(ex == "**********************nan"); 10876 assert(ios.width() == 0); 10877 } 10878 } 10879 } 10880 } 10881 showpos(ios); 10882 { 10883 noshowpoint(ios); 10884 { 10885 ios.imbue(lc); 10886 { 10887 ios.width(0); 10888 { 10889 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10890 std::string ex(str, iter.base()); 10891 assert(ex == "nan"); 10892 assert(ios.width() == 0); 10893 } 10894 ios.width(25); 10895 left(ios); 10896 { 10897 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10898 std::string ex(str, iter.base()); 10899 assert(ex == "nan**********************"); 10900 assert(ios.width() == 0); 10901 } 10902 ios.width(25); 10903 right(ios); 10904 { 10905 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10906 std::string ex(str, iter.base()); 10907 assert(ex == "**********************nan"); 10908 assert(ios.width() == 0); 10909 } 10910 ios.width(25); 10911 internal(ios); 10912 { 10913 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10914 std::string ex(str, iter.base()); 10915 assert(ex == "**********************nan"); 10916 assert(ios.width() == 0); 10917 } 10918 } 10919 ios.imbue(lg); 10920 { 10921 ios.width(0); 10922 { 10923 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10924 std::string ex(str, iter.base()); 10925 assert(ex == "nan"); 10926 assert(ios.width() == 0); 10927 } 10928 ios.width(25); 10929 left(ios); 10930 { 10931 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10932 std::string ex(str, iter.base()); 10933 assert(ex == "nan**********************"); 10934 assert(ios.width() == 0); 10935 } 10936 ios.width(25); 10937 right(ios); 10938 { 10939 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10940 std::string ex(str, iter.base()); 10941 assert(ex == "**********************nan"); 10942 assert(ios.width() == 0); 10943 } 10944 ios.width(25); 10945 internal(ios); 10946 { 10947 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10948 std::string ex(str, iter.base()); 10949 assert(ex == "**********************nan"); 10950 assert(ios.width() == 0); 10951 } 10952 } 10953 } 10954 showpoint(ios); 10955 { 10956 ios.imbue(lc); 10957 { 10958 ios.width(0); 10959 { 10960 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10961 std::string ex(str, iter.base()); 10962 assert(ex == "nan"); 10963 assert(ios.width() == 0); 10964 } 10965 ios.width(25); 10966 left(ios); 10967 { 10968 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10969 std::string ex(str, iter.base()); 10970 assert(ex == "nan**********************"); 10971 assert(ios.width() == 0); 10972 } 10973 ios.width(25); 10974 right(ios); 10975 { 10976 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10977 std::string ex(str, iter.base()); 10978 assert(ex == "**********************nan"); 10979 assert(ios.width() == 0); 10980 } 10981 ios.width(25); 10982 internal(ios); 10983 { 10984 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10985 std::string ex(str, iter.base()); 10986 assert(ex == "**********************nan"); 10987 assert(ios.width() == 0); 10988 } 10989 } 10990 ios.imbue(lg); 10991 { 10992 ios.width(0); 10993 { 10994 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10995 std::string ex(str, iter.base()); 10996 assert(ex == "nan"); 10997 assert(ios.width() == 0); 10998 } 10999 ios.width(25); 11000 left(ios); 11001 { 11002 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11003 std::string ex(str, iter.base()); 11004 assert(ex == "nan**********************"); 11005 assert(ios.width() == 0); 11006 } 11007 ios.width(25); 11008 right(ios); 11009 { 11010 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11011 std::string ex(str, iter.base()); 11012 assert(ex == "**********************nan"); 11013 assert(ios.width() == 0); 11014 } 11015 ios.width(25); 11016 internal(ios); 11017 { 11018 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11019 std::string ex(str, iter.base()); 11020 assert(ex == "**********************nan"); 11021 assert(ios.width() == 0); 11022 } 11023 } 11024 } 11025 } 11026 } 11027 uppercase(ios); 11028 { 11029 noshowpos(ios); 11030 { 11031 noshowpoint(ios); 11032 { 11033 ios.imbue(lc); 11034 { 11035 ios.width(0); 11036 { 11037 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11038 std::string ex(str, iter.base()); 11039 assert(ex == "NAN"); 11040 assert(ios.width() == 0); 11041 } 11042 ios.width(25); 11043 left(ios); 11044 { 11045 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11046 std::string ex(str, iter.base()); 11047 assert(ex == "NAN**********************"); 11048 assert(ios.width() == 0); 11049 } 11050 ios.width(25); 11051 right(ios); 11052 { 11053 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11054 std::string ex(str, iter.base()); 11055 assert(ex == "**********************NAN"); 11056 assert(ios.width() == 0); 11057 } 11058 ios.width(25); 11059 internal(ios); 11060 { 11061 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11062 std::string ex(str, iter.base()); 11063 assert(ex == "**********************NAN"); 11064 assert(ios.width() == 0); 11065 } 11066 } 11067 ios.imbue(lg); 11068 { 11069 ios.width(0); 11070 { 11071 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11072 std::string ex(str, iter.base()); 11073 assert(ex == "NAN"); 11074 assert(ios.width() == 0); 11075 } 11076 ios.width(25); 11077 left(ios); 11078 { 11079 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11080 std::string ex(str, iter.base()); 11081 assert(ex == "NAN**********************"); 11082 assert(ios.width() == 0); 11083 } 11084 ios.width(25); 11085 right(ios); 11086 { 11087 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11088 std::string ex(str, iter.base()); 11089 assert(ex == "**********************NAN"); 11090 assert(ios.width() == 0); 11091 } 11092 ios.width(25); 11093 internal(ios); 11094 { 11095 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11096 std::string ex(str, iter.base()); 11097 assert(ex == "**********************NAN"); 11098 assert(ios.width() == 0); 11099 } 11100 } 11101 } 11102 showpoint(ios); 11103 { 11104 ios.imbue(lc); 11105 { 11106 ios.width(0); 11107 { 11108 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11109 std::string ex(str, iter.base()); 11110 assert(ex == "NAN"); 11111 assert(ios.width() == 0); 11112 } 11113 ios.width(25); 11114 left(ios); 11115 { 11116 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11117 std::string ex(str, iter.base()); 11118 assert(ex == "NAN**********************"); 11119 assert(ios.width() == 0); 11120 } 11121 ios.width(25); 11122 right(ios); 11123 { 11124 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11125 std::string ex(str, iter.base()); 11126 assert(ex == "**********************NAN"); 11127 assert(ios.width() == 0); 11128 } 11129 ios.width(25); 11130 internal(ios); 11131 { 11132 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11133 std::string ex(str, iter.base()); 11134 assert(ex == "**********************NAN"); 11135 assert(ios.width() == 0); 11136 } 11137 } 11138 ios.imbue(lg); 11139 { 11140 ios.width(0); 11141 { 11142 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11143 std::string ex(str, iter.base()); 11144 assert(ex == "NAN"); 11145 assert(ios.width() == 0); 11146 } 11147 ios.width(25); 11148 left(ios); 11149 { 11150 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11151 std::string ex(str, iter.base()); 11152 assert(ex == "NAN**********************"); 11153 assert(ios.width() == 0); 11154 } 11155 ios.width(25); 11156 right(ios); 11157 { 11158 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11159 std::string ex(str, iter.base()); 11160 assert(ex == "**********************NAN"); 11161 assert(ios.width() == 0); 11162 } 11163 ios.width(25); 11164 internal(ios); 11165 { 11166 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11167 std::string ex(str, iter.base()); 11168 assert(ex == "**********************NAN"); 11169 assert(ios.width() == 0); 11170 } 11171 } 11172 } 11173 } 11174 showpos(ios); 11175 { 11176 noshowpoint(ios); 11177 { 11178 ios.imbue(lc); 11179 { 11180 ios.width(0); 11181 { 11182 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11183 std::string ex(str, iter.base()); 11184 assert(ex == "NAN"); 11185 assert(ios.width() == 0); 11186 } 11187 ios.width(25); 11188 left(ios); 11189 { 11190 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11191 std::string ex(str, iter.base()); 11192 assert(ex == "NAN**********************"); 11193 assert(ios.width() == 0); 11194 } 11195 ios.width(25); 11196 right(ios); 11197 { 11198 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11199 std::string ex(str, iter.base()); 11200 assert(ex == "**********************NAN"); 11201 assert(ios.width() == 0); 11202 } 11203 ios.width(25); 11204 internal(ios); 11205 { 11206 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11207 std::string ex(str, iter.base()); 11208 assert(ex == "**********************NAN"); 11209 assert(ios.width() == 0); 11210 } 11211 } 11212 ios.imbue(lg); 11213 { 11214 ios.width(0); 11215 { 11216 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11217 std::string ex(str, iter.base()); 11218 assert(ex == "NAN"); 11219 assert(ios.width() == 0); 11220 } 11221 ios.width(25); 11222 left(ios); 11223 { 11224 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11225 std::string ex(str, iter.base()); 11226 assert(ex == "NAN**********************"); 11227 assert(ios.width() == 0); 11228 } 11229 ios.width(25); 11230 right(ios); 11231 { 11232 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11233 std::string ex(str, iter.base()); 11234 assert(ex == "**********************NAN"); 11235 assert(ios.width() == 0); 11236 } 11237 ios.width(25); 11238 internal(ios); 11239 { 11240 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11241 std::string ex(str, iter.base()); 11242 assert(ex == "**********************NAN"); 11243 assert(ios.width() == 0); 11244 } 11245 } 11246 } 11247 showpoint(ios); 11248 { 11249 ios.imbue(lc); 11250 { 11251 ios.width(0); 11252 { 11253 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11254 std::string ex(str, iter.base()); 11255 assert(ex == "NAN"); 11256 assert(ios.width() == 0); 11257 } 11258 ios.width(25); 11259 left(ios); 11260 { 11261 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11262 std::string ex(str, iter.base()); 11263 assert(ex == "NAN**********************"); 11264 assert(ios.width() == 0); 11265 } 11266 ios.width(25); 11267 right(ios); 11268 { 11269 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11270 std::string ex(str, iter.base()); 11271 assert(ex == "**********************NAN"); 11272 assert(ios.width() == 0); 11273 } 11274 ios.width(25); 11275 internal(ios); 11276 { 11277 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11278 std::string ex(str, iter.base()); 11279 assert(ex == "**********************NAN"); 11280 assert(ios.width() == 0); 11281 } 11282 } 11283 ios.imbue(lg); 11284 { 11285 ios.width(0); 11286 { 11287 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11288 std::string ex(str, iter.base()); 11289 assert(ex == "NAN"); 11290 assert(ios.width() == 0); 11291 } 11292 ios.width(25); 11293 left(ios); 11294 { 11295 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11296 std::string ex(str, iter.base()); 11297 assert(ex == "NAN**********************"); 11298 assert(ios.width() == 0); 11299 } 11300 ios.width(25); 11301 right(ios); 11302 { 11303 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11304 std::string ex(str, iter.base()); 11305 assert(ex == "**********************NAN"); 11306 assert(ios.width() == 0); 11307 } 11308 ios.width(25); 11309 internal(ios); 11310 { 11311 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11312 std::string ex(str, iter.base()); 11313 assert(ex == "**********************NAN"); 11314 assert(ios.width() == 0); 11315 } 11316 } 11317 } 11318 } 11319 } 11320 } 11321 ios.precision(1); 11322 {} 11323 ios.precision(6); 11324 {} 11325 ios.precision(16); 11326 {} 11327 ios.precision(60); 11328 {} 11329 } 11330 } 11331 } 11332 11333 void test6() 11334 { 11335 char str[200]; 11336 output_iterator<char*> iter; 11337 std::locale lc = std::locale::classic(); 11338 std::locale lg(lc, new my_numpunct); 11339 const my_facet f(1); 11340 { 11341 long double v = +0.; 11342 std::ios ios(0); 11343 fixed(ios); 11344 // %f 11345 { 11346 ios.precision(0); 11347 { 11348 nouppercase(ios); 11349 { 11350 noshowpos(ios); 11351 { 11352 noshowpoint(ios); 11353 { 11354 ios.imbue(lc); 11355 { 11356 ios.width(0); 11357 { 11358 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11359 std::string ex(str, iter.base()); 11360 assert(ex == "0"); 11361 assert(ios.width() == 0); 11362 } 11363 ios.width(25); 11364 left(ios); 11365 { 11366 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11367 std::string ex(str, iter.base()); 11368 assert(ex == "0************************"); 11369 assert(ios.width() == 0); 11370 } 11371 ios.width(25); 11372 right(ios); 11373 { 11374 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11375 std::string ex(str, iter.base()); 11376 assert(ex == "************************0"); 11377 assert(ios.width() == 0); 11378 } 11379 ios.width(25); 11380 internal(ios); 11381 { 11382 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11383 std::string ex(str, iter.base()); 11384 assert(ex == "************************0"); 11385 assert(ios.width() == 0); 11386 } 11387 } 11388 ios.imbue(lg); 11389 { 11390 ios.width(0); 11391 { 11392 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11393 std::string ex(str, iter.base()); 11394 assert(ex == "0"); 11395 assert(ios.width() == 0); 11396 } 11397 ios.width(25); 11398 left(ios); 11399 { 11400 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11401 std::string ex(str, iter.base()); 11402 assert(ex == "0************************"); 11403 assert(ios.width() == 0); 11404 } 11405 ios.width(25); 11406 right(ios); 11407 { 11408 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11409 std::string ex(str, iter.base()); 11410 assert(ex == "************************0"); 11411 assert(ios.width() == 0); 11412 } 11413 ios.width(25); 11414 internal(ios); 11415 { 11416 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11417 std::string ex(str, iter.base()); 11418 assert(ex == "************************0"); 11419 assert(ios.width() == 0); 11420 } 11421 } 11422 } 11423 showpoint(ios); 11424 { 11425 ios.imbue(lc); 11426 { 11427 ios.width(0); 11428 { 11429 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11430 std::string ex(str, iter.base()); 11431 assert(ex == "0."); 11432 assert(ios.width() == 0); 11433 } 11434 ios.width(25); 11435 left(ios); 11436 { 11437 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11438 std::string ex(str, iter.base()); 11439 assert(ex == "0.***********************"); 11440 assert(ios.width() == 0); 11441 } 11442 ios.width(25); 11443 right(ios); 11444 { 11445 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11446 std::string ex(str, iter.base()); 11447 assert(ex == "***********************0."); 11448 assert(ios.width() == 0); 11449 } 11450 ios.width(25); 11451 internal(ios); 11452 { 11453 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11454 std::string ex(str, iter.base()); 11455 assert(ex == "***********************0."); 11456 assert(ios.width() == 0); 11457 } 11458 } 11459 ios.imbue(lg); 11460 { 11461 ios.width(0); 11462 { 11463 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11464 std::string ex(str, iter.base()); 11465 assert(ex == "0;"); 11466 assert(ios.width() == 0); 11467 } 11468 ios.width(25); 11469 left(ios); 11470 { 11471 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11472 std::string ex(str, iter.base()); 11473 assert(ex == "0;***********************"); 11474 assert(ios.width() == 0); 11475 } 11476 ios.width(25); 11477 right(ios); 11478 { 11479 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11480 std::string ex(str, iter.base()); 11481 assert(ex == "***********************0;"); 11482 assert(ios.width() == 0); 11483 } 11484 ios.width(25); 11485 internal(ios); 11486 { 11487 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11488 std::string ex(str, iter.base()); 11489 assert(ex == "***********************0;"); 11490 assert(ios.width() == 0); 11491 } 11492 } 11493 } 11494 } 11495 showpos(ios); 11496 { 11497 noshowpoint(ios); 11498 { 11499 ios.imbue(lc); 11500 { 11501 ios.width(0); 11502 { 11503 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11504 std::string ex(str, iter.base()); 11505 assert(ex == "+0"); 11506 assert(ios.width() == 0); 11507 } 11508 ios.width(25); 11509 left(ios); 11510 { 11511 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11512 std::string ex(str, iter.base()); 11513 assert(ex == "+0***********************"); 11514 assert(ios.width() == 0); 11515 } 11516 ios.width(25); 11517 right(ios); 11518 { 11519 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11520 std::string ex(str, iter.base()); 11521 assert(ex == "***********************+0"); 11522 assert(ios.width() == 0); 11523 } 11524 ios.width(25); 11525 internal(ios); 11526 { 11527 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11528 std::string ex(str, iter.base()); 11529 assert(ex == "+***********************0"); 11530 assert(ios.width() == 0); 11531 } 11532 } 11533 ios.imbue(lg); 11534 { 11535 ios.width(0); 11536 { 11537 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11538 std::string ex(str, iter.base()); 11539 assert(ex == "+0"); 11540 assert(ios.width() == 0); 11541 } 11542 ios.width(25); 11543 left(ios); 11544 { 11545 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11546 std::string ex(str, iter.base()); 11547 assert(ex == "+0***********************"); 11548 assert(ios.width() == 0); 11549 } 11550 ios.width(25); 11551 right(ios); 11552 { 11553 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11554 std::string ex(str, iter.base()); 11555 assert(ex == "***********************+0"); 11556 assert(ios.width() == 0); 11557 } 11558 ios.width(25); 11559 internal(ios); 11560 { 11561 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11562 std::string ex(str, iter.base()); 11563 assert(ex == "+***********************0"); 11564 assert(ios.width() == 0); 11565 } 11566 } 11567 } 11568 showpoint(ios); 11569 { 11570 ios.imbue(lc); 11571 { 11572 ios.width(0); 11573 { 11574 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11575 std::string ex(str, iter.base()); 11576 assert(ex == "+0."); 11577 assert(ios.width() == 0); 11578 } 11579 ios.width(25); 11580 left(ios); 11581 { 11582 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11583 std::string ex(str, iter.base()); 11584 assert(ex == "+0.**********************"); 11585 assert(ios.width() == 0); 11586 } 11587 ios.width(25); 11588 right(ios); 11589 { 11590 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11591 std::string ex(str, iter.base()); 11592 assert(ex == "**********************+0."); 11593 assert(ios.width() == 0); 11594 } 11595 ios.width(25); 11596 internal(ios); 11597 { 11598 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11599 std::string ex(str, iter.base()); 11600 assert(ex == "+**********************0."); 11601 assert(ios.width() == 0); 11602 } 11603 } 11604 ios.imbue(lg); 11605 { 11606 ios.width(0); 11607 { 11608 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11609 std::string ex(str, iter.base()); 11610 assert(ex == "+0;"); 11611 assert(ios.width() == 0); 11612 } 11613 ios.width(25); 11614 left(ios); 11615 { 11616 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11617 std::string ex(str, iter.base()); 11618 assert(ex == "+0;**********************"); 11619 assert(ios.width() == 0); 11620 } 11621 ios.width(25); 11622 right(ios); 11623 { 11624 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11625 std::string ex(str, iter.base()); 11626 assert(ex == "**********************+0;"); 11627 assert(ios.width() == 0); 11628 } 11629 ios.width(25); 11630 internal(ios); 11631 { 11632 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11633 std::string ex(str, iter.base()); 11634 assert(ex == "+**********************0;"); 11635 assert(ios.width() == 0); 11636 } 11637 } 11638 } 11639 } 11640 } 11641 uppercase(ios); 11642 { 11643 noshowpos(ios); 11644 { 11645 noshowpoint(ios); 11646 { 11647 ios.imbue(lc); 11648 { 11649 ios.width(0); 11650 { 11651 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11652 std::string ex(str, iter.base()); 11653 assert(ex == "0"); 11654 assert(ios.width() == 0); 11655 } 11656 ios.width(25); 11657 left(ios); 11658 { 11659 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11660 std::string ex(str, iter.base()); 11661 assert(ex == "0************************"); 11662 assert(ios.width() == 0); 11663 } 11664 ios.width(25); 11665 right(ios); 11666 { 11667 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11668 std::string ex(str, iter.base()); 11669 assert(ex == "************************0"); 11670 assert(ios.width() == 0); 11671 } 11672 ios.width(25); 11673 internal(ios); 11674 { 11675 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11676 std::string ex(str, iter.base()); 11677 assert(ex == "************************0"); 11678 assert(ios.width() == 0); 11679 } 11680 } 11681 ios.imbue(lg); 11682 { 11683 ios.width(0); 11684 { 11685 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11686 std::string ex(str, iter.base()); 11687 assert(ex == "0"); 11688 assert(ios.width() == 0); 11689 } 11690 ios.width(25); 11691 left(ios); 11692 { 11693 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11694 std::string ex(str, iter.base()); 11695 assert(ex == "0************************"); 11696 assert(ios.width() == 0); 11697 } 11698 ios.width(25); 11699 right(ios); 11700 { 11701 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11702 std::string ex(str, iter.base()); 11703 assert(ex == "************************0"); 11704 assert(ios.width() == 0); 11705 } 11706 ios.width(25); 11707 internal(ios); 11708 { 11709 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11710 std::string ex(str, iter.base()); 11711 assert(ex == "************************0"); 11712 assert(ios.width() == 0); 11713 } 11714 } 11715 } 11716 showpoint(ios); 11717 { 11718 ios.imbue(lc); 11719 { 11720 ios.width(0); 11721 { 11722 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11723 std::string ex(str, iter.base()); 11724 assert(ex == "0."); 11725 assert(ios.width() == 0); 11726 } 11727 ios.width(25); 11728 left(ios); 11729 { 11730 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11731 std::string ex(str, iter.base()); 11732 assert(ex == "0.***********************"); 11733 assert(ios.width() == 0); 11734 } 11735 ios.width(25); 11736 right(ios); 11737 { 11738 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11739 std::string ex(str, iter.base()); 11740 assert(ex == "***********************0."); 11741 assert(ios.width() == 0); 11742 } 11743 ios.width(25); 11744 internal(ios); 11745 { 11746 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11747 std::string ex(str, iter.base()); 11748 assert(ex == "***********************0."); 11749 assert(ios.width() == 0); 11750 } 11751 } 11752 ios.imbue(lg); 11753 { 11754 ios.width(0); 11755 { 11756 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11757 std::string ex(str, iter.base()); 11758 assert(ex == "0;"); 11759 assert(ios.width() == 0); 11760 } 11761 ios.width(25); 11762 left(ios); 11763 { 11764 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11765 std::string ex(str, iter.base()); 11766 assert(ex == "0;***********************"); 11767 assert(ios.width() == 0); 11768 } 11769 ios.width(25); 11770 right(ios); 11771 { 11772 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11773 std::string ex(str, iter.base()); 11774 assert(ex == "***********************0;"); 11775 assert(ios.width() == 0); 11776 } 11777 ios.width(25); 11778 internal(ios); 11779 { 11780 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11781 std::string ex(str, iter.base()); 11782 assert(ex == "***********************0;"); 11783 assert(ios.width() == 0); 11784 } 11785 } 11786 } 11787 } 11788 showpos(ios); 11789 { 11790 noshowpoint(ios); 11791 { 11792 ios.imbue(lc); 11793 { 11794 ios.width(0); 11795 { 11796 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11797 std::string ex(str, iter.base()); 11798 assert(ex == "+0"); 11799 assert(ios.width() == 0); 11800 } 11801 ios.width(25); 11802 left(ios); 11803 { 11804 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11805 std::string ex(str, iter.base()); 11806 assert(ex == "+0***********************"); 11807 assert(ios.width() == 0); 11808 } 11809 ios.width(25); 11810 right(ios); 11811 { 11812 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11813 std::string ex(str, iter.base()); 11814 assert(ex == "***********************+0"); 11815 assert(ios.width() == 0); 11816 } 11817 ios.width(25); 11818 internal(ios); 11819 { 11820 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11821 std::string ex(str, iter.base()); 11822 assert(ex == "+***********************0"); 11823 assert(ios.width() == 0); 11824 } 11825 } 11826 ios.imbue(lg); 11827 { 11828 ios.width(0); 11829 { 11830 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11831 std::string ex(str, iter.base()); 11832 assert(ex == "+0"); 11833 assert(ios.width() == 0); 11834 } 11835 ios.width(25); 11836 left(ios); 11837 { 11838 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11839 std::string ex(str, iter.base()); 11840 assert(ex == "+0***********************"); 11841 assert(ios.width() == 0); 11842 } 11843 ios.width(25); 11844 right(ios); 11845 { 11846 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11847 std::string ex(str, iter.base()); 11848 assert(ex == "***********************+0"); 11849 assert(ios.width() == 0); 11850 } 11851 ios.width(25); 11852 internal(ios); 11853 { 11854 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11855 std::string ex(str, iter.base()); 11856 assert(ex == "+***********************0"); 11857 assert(ios.width() == 0); 11858 } 11859 } 11860 } 11861 showpoint(ios); 11862 { 11863 ios.imbue(lc); 11864 { 11865 ios.width(0); 11866 { 11867 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11868 std::string ex(str, iter.base()); 11869 assert(ex == "+0."); 11870 assert(ios.width() == 0); 11871 } 11872 ios.width(25); 11873 left(ios); 11874 { 11875 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11876 std::string ex(str, iter.base()); 11877 assert(ex == "+0.**********************"); 11878 assert(ios.width() == 0); 11879 } 11880 ios.width(25); 11881 right(ios); 11882 { 11883 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11884 std::string ex(str, iter.base()); 11885 assert(ex == "**********************+0."); 11886 assert(ios.width() == 0); 11887 } 11888 ios.width(25); 11889 internal(ios); 11890 { 11891 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11892 std::string ex(str, iter.base()); 11893 assert(ex == "+**********************0."); 11894 assert(ios.width() == 0); 11895 } 11896 } 11897 ios.imbue(lg); 11898 { 11899 ios.width(0); 11900 { 11901 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11902 std::string ex(str, iter.base()); 11903 assert(ex == "+0;"); 11904 assert(ios.width() == 0); 11905 } 11906 ios.width(25); 11907 left(ios); 11908 { 11909 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11910 std::string ex(str, iter.base()); 11911 assert(ex == "+0;**********************"); 11912 assert(ios.width() == 0); 11913 } 11914 ios.width(25); 11915 right(ios); 11916 { 11917 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11918 std::string ex(str, iter.base()); 11919 assert(ex == "**********************+0;"); 11920 assert(ios.width() == 0); 11921 } 11922 ios.width(25); 11923 internal(ios); 11924 { 11925 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11926 std::string ex(str, iter.base()); 11927 assert(ex == "+**********************0;"); 11928 assert(ios.width() == 0); 11929 } 11930 } 11931 } 11932 } 11933 } 11934 } 11935 ios.precision(1); 11936 { 11937 nouppercase(ios); 11938 { 11939 noshowpos(ios); 11940 { 11941 noshowpoint(ios); 11942 { 11943 ios.imbue(lc); 11944 { 11945 ios.width(0); 11946 { 11947 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11948 std::string ex(str, iter.base()); 11949 assert(ex == "0.0"); 11950 assert(ios.width() == 0); 11951 } 11952 ios.width(25); 11953 left(ios); 11954 { 11955 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11956 std::string ex(str, iter.base()); 11957 assert(ex == "0.0**********************"); 11958 assert(ios.width() == 0); 11959 } 11960 ios.width(25); 11961 right(ios); 11962 { 11963 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11964 std::string ex(str, iter.base()); 11965 assert(ex == "**********************0.0"); 11966 assert(ios.width() == 0); 11967 } 11968 ios.width(25); 11969 internal(ios); 11970 { 11971 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11972 std::string ex(str, iter.base()); 11973 assert(ex == "**********************0.0"); 11974 assert(ios.width() == 0); 11975 } 11976 } 11977 ios.imbue(lg); 11978 { 11979 ios.width(0); 11980 { 11981 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11982 std::string ex(str, iter.base()); 11983 assert(ex == "0;0"); 11984 assert(ios.width() == 0); 11985 } 11986 ios.width(25); 11987 left(ios); 11988 { 11989 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11990 std::string ex(str, iter.base()); 11991 assert(ex == "0;0**********************"); 11992 assert(ios.width() == 0); 11993 } 11994 ios.width(25); 11995 right(ios); 11996 { 11997 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11998 std::string ex(str, iter.base()); 11999 assert(ex == "**********************0;0"); 12000 assert(ios.width() == 0); 12001 } 12002 ios.width(25); 12003 internal(ios); 12004 { 12005 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12006 std::string ex(str, iter.base()); 12007 assert(ex == "**********************0;0"); 12008 assert(ios.width() == 0); 12009 } 12010 } 12011 } 12012 showpoint(ios); 12013 { 12014 ios.imbue(lc); 12015 { 12016 ios.width(0); 12017 { 12018 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12019 std::string ex(str, iter.base()); 12020 assert(ex == "0.0"); 12021 assert(ios.width() == 0); 12022 } 12023 ios.width(25); 12024 left(ios); 12025 { 12026 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12027 std::string ex(str, iter.base()); 12028 assert(ex == "0.0**********************"); 12029 assert(ios.width() == 0); 12030 } 12031 ios.width(25); 12032 right(ios); 12033 { 12034 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12035 std::string ex(str, iter.base()); 12036 assert(ex == "**********************0.0"); 12037 assert(ios.width() == 0); 12038 } 12039 ios.width(25); 12040 internal(ios); 12041 { 12042 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12043 std::string ex(str, iter.base()); 12044 assert(ex == "**********************0.0"); 12045 assert(ios.width() == 0); 12046 } 12047 } 12048 ios.imbue(lg); 12049 { 12050 ios.width(0); 12051 { 12052 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12053 std::string ex(str, iter.base()); 12054 assert(ex == "0;0"); 12055 assert(ios.width() == 0); 12056 } 12057 ios.width(25); 12058 left(ios); 12059 { 12060 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12061 std::string ex(str, iter.base()); 12062 assert(ex == "0;0**********************"); 12063 assert(ios.width() == 0); 12064 } 12065 ios.width(25); 12066 right(ios); 12067 { 12068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12069 std::string ex(str, iter.base()); 12070 assert(ex == "**********************0;0"); 12071 assert(ios.width() == 0); 12072 } 12073 ios.width(25); 12074 internal(ios); 12075 { 12076 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12077 std::string ex(str, iter.base()); 12078 assert(ex == "**********************0;0"); 12079 assert(ios.width() == 0); 12080 } 12081 } 12082 } 12083 } 12084 showpos(ios); 12085 { 12086 noshowpoint(ios); 12087 { 12088 ios.imbue(lc); 12089 { 12090 ios.width(0); 12091 { 12092 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12093 std::string ex(str, iter.base()); 12094 assert(ex == "+0.0"); 12095 assert(ios.width() == 0); 12096 } 12097 ios.width(25); 12098 left(ios); 12099 { 12100 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12101 std::string ex(str, iter.base()); 12102 assert(ex == "+0.0*********************"); 12103 assert(ios.width() == 0); 12104 } 12105 ios.width(25); 12106 right(ios); 12107 { 12108 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12109 std::string ex(str, iter.base()); 12110 assert(ex == "*********************+0.0"); 12111 assert(ios.width() == 0); 12112 } 12113 ios.width(25); 12114 internal(ios); 12115 { 12116 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12117 std::string ex(str, iter.base()); 12118 assert(ex == "+*********************0.0"); 12119 assert(ios.width() == 0); 12120 } 12121 } 12122 ios.imbue(lg); 12123 { 12124 ios.width(0); 12125 { 12126 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12127 std::string ex(str, iter.base()); 12128 assert(ex == "+0;0"); 12129 assert(ios.width() == 0); 12130 } 12131 ios.width(25); 12132 left(ios); 12133 { 12134 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12135 std::string ex(str, iter.base()); 12136 assert(ex == "+0;0*********************"); 12137 assert(ios.width() == 0); 12138 } 12139 ios.width(25); 12140 right(ios); 12141 { 12142 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12143 std::string ex(str, iter.base()); 12144 assert(ex == "*********************+0;0"); 12145 assert(ios.width() == 0); 12146 } 12147 ios.width(25); 12148 internal(ios); 12149 { 12150 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12151 std::string ex(str, iter.base()); 12152 assert(ex == "+*********************0;0"); 12153 assert(ios.width() == 0); 12154 } 12155 } 12156 } 12157 showpoint(ios); 12158 { 12159 ios.imbue(lc); 12160 { 12161 ios.width(0); 12162 { 12163 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12164 std::string ex(str, iter.base()); 12165 assert(ex == "+0.0"); 12166 assert(ios.width() == 0); 12167 } 12168 ios.width(25); 12169 left(ios); 12170 { 12171 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12172 std::string ex(str, iter.base()); 12173 assert(ex == "+0.0*********************"); 12174 assert(ios.width() == 0); 12175 } 12176 ios.width(25); 12177 right(ios); 12178 { 12179 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12180 std::string ex(str, iter.base()); 12181 assert(ex == "*********************+0.0"); 12182 assert(ios.width() == 0); 12183 } 12184 ios.width(25); 12185 internal(ios); 12186 { 12187 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12188 std::string ex(str, iter.base()); 12189 assert(ex == "+*********************0.0"); 12190 assert(ios.width() == 0); 12191 } 12192 } 12193 ios.imbue(lg); 12194 { 12195 ios.width(0); 12196 { 12197 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12198 std::string ex(str, iter.base()); 12199 assert(ex == "+0;0"); 12200 assert(ios.width() == 0); 12201 } 12202 ios.width(25); 12203 left(ios); 12204 { 12205 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12206 std::string ex(str, iter.base()); 12207 assert(ex == "+0;0*********************"); 12208 assert(ios.width() == 0); 12209 } 12210 ios.width(25); 12211 right(ios); 12212 { 12213 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12214 std::string ex(str, iter.base()); 12215 assert(ex == "*********************+0;0"); 12216 assert(ios.width() == 0); 12217 } 12218 ios.width(25); 12219 internal(ios); 12220 { 12221 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12222 std::string ex(str, iter.base()); 12223 assert(ex == "+*********************0;0"); 12224 assert(ios.width() == 0); 12225 } 12226 } 12227 } 12228 } 12229 } 12230 uppercase(ios); 12231 { 12232 noshowpos(ios); 12233 { 12234 noshowpoint(ios); 12235 { 12236 ios.imbue(lc); 12237 { 12238 ios.width(0); 12239 { 12240 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12241 std::string ex(str, iter.base()); 12242 assert(ex == "0.0"); 12243 assert(ios.width() == 0); 12244 } 12245 ios.width(25); 12246 left(ios); 12247 { 12248 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12249 std::string ex(str, iter.base()); 12250 assert(ex == "0.0**********************"); 12251 assert(ios.width() == 0); 12252 } 12253 ios.width(25); 12254 right(ios); 12255 { 12256 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12257 std::string ex(str, iter.base()); 12258 assert(ex == "**********************0.0"); 12259 assert(ios.width() == 0); 12260 } 12261 ios.width(25); 12262 internal(ios); 12263 { 12264 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12265 std::string ex(str, iter.base()); 12266 assert(ex == "**********************0.0"); 12267 assert(ios.width() == 0); 12268 } 12269 } 12270 ios.imbue(lg); 12271 { 12272 ios.width(0); 12273 { 12274 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12275 std::string ex(str, iter.base()); 12276 assert(ex == "0;0"); 12277 assert(ios.width() == 0); 12278 } 12279 ios.width(25); 12280 left(ios); 12281 { 12282 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12283 std::string ex(str, iter.base()); 12284 assert(ex == "0;0**********************"); 12285 assert(ios.width() == 0); 12286 } 12287 ios.width(25); 12288 right(ios); 12289 { 12290 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12291 std::string ex(str, iter.base()); 12292 assert(ex == "**********************0;0"); 12293 assert(ios.width() == 0); 12294 } 12295 ios.width(25); 12296 internal(ios); 12297 { 12298 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12299 std::string ex(str, iter.base()); 12300 assert(ex == "**********************0;0"); 12301 assert(ios.width() == 0); 12302 } 12303 } 12304 } 12305 showpoint(ios); 12306 { 12307 ios.imbue(lc); 12308 { 12309 ios.width(0); 12310 { 12311 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12312 std::string ex(str, iter.base()); 12313 assert(ex == "0.0"); 12314 assert(ios.width() == 0); 12315 } 12316 ios.width(25); 12317 left(ios); 12318 { 12319 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12320 std::string ex(str, iter.base()); 12321 assert(ex == "0.0**********************"); 12322 assert(ios.width() == 0); 12323 } 12324 ios.width(25); 12325 right(ios); 12326 { 12327 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12328 std::string ex(str, iter.base()); 12329 assert(ex == "**********************0.0"); 12330 assert(ios.width() == 0); 12331 } 12332 ios.width(25); 12333 internal(ios); 12334 { 12335 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12336 std::string ex(str, iter.base()); 12337 assert(ex == "**********************0.0"); 12338 assert(ios.width() == 0); 12339 } 12340 } 12341 ios.imbue(lg); 12342 { 12343 ios.width(0); 12344 { 12345 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12346 std::string ex(str, iter.base()); 12347 assert(ex == "0;0"); 12348 assert(ios.width() == 0); 12349 } 12350 ios.width(25); 12351 left(ios); 12352 { 12353 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12354 std::string ex(str, iter.base()); 12355 assert(ex == "0;0**********************"); 12356 assert(ios.width() == 0); 12357 } 12358 ios.width(25); 12359 right(ios); 12360 { 12361 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12362 std::string ex(str, iter.base()); 12363 assert(ex == "**********************0;0"); 12364 assert(ios.width() == 0); 12365 } 12366 ios.width(25); 12367 internal(ios); 12368 { 12369 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12370 std::string ex(str, iter.base()); 12371 assert(ex == "**********************0;0"); 12372 assert(ios.width() == 0); 12373 } 12374 } 12375 } 12376 } 12377 showpos(ios); 12378 { 12379 noshowpoint(ios); 12380 { 12381 ios.imbue(lc); 12382 { 12383 ios.width(0); 12384 { 12385 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12386 std::string ex(str, iter.base()); 12387 assert(ex == "+0.0"); 12388 assert(ios.width() == 0); 12389 } 12390 ios.width(25); 12391 left(ios); 12392 { 12393 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12394 std::string ex(str, iter.base()); 12395 assert(ex == "+0.0*********************"); 12396 assert(ios.width() == 0); 12397 } 12398 ios.width(25); 12399 right(ios); 12400 { 12401 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12402 std::string ex(str, iter.base()); 12403 assert(ex == "*********************+0.0"); 12404 assert(ios.width() == 0); 12405 } 12406 ios.width(25); 12407 internal(ios); 12408 { 12409 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12410 std::string ex(str, iter.base()); 12411 assert(ex == "+*********************0.0"); 12412 assert(ios.width() == 0); 12413 } 12414 } 12415 ios.imbue(lg); 12416 { 12417 ios.width(0); 12418 { 12419 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12420 std::string ex(str, iter.base()); 12421 assert(ex == "+0;0"); 12422 assert(ios.width() == 0); 12423 } 12424 ios.width(25); 12425 left(ios); 12426 { 12427 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12428 std::string ex(str, iter.base()); 12429 assert(ex == "+0;0*********************"); 12430 assert(ios.width() == 0); 12431 } 12432 ios.width(25); 12433 right(ios); 12434 { 12435 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12436 std::string ex(str, iter.base()); 12437 assert(ex == "*********************+0;0"); 12438 assert(ios.width() == 0); 12439 } 12440 ios.width(25); 12441 internal(ios); 12442 { 12443 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12444 std::string ex(str, iter.base()); 12445 assert(ex == "+*********************0;0"); 12446 assert(ios.width() == 0); 12447 } 12448 } 12449 } 12450 showpoint(ios); 12451 { 12452 ios.imbue(lc); 12453 { 12454 ios.width(0); 12455 { 12456 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12457 std::string ex(str, iter.base()); 12458 assert(ex == "+0.0"); 12459 assert(ios.width() == 0); 12460 } 12461 ios.width(25); 12462 left(ios); 12463 { 12464 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12465 std::string ex(str, iter.base()); 12466 assert(ex == "+0.0*********************"); 12467 assert(ios.width() == 0); 12468 } 12469 ios.width(25); 12470 right(ios); 12471 { 12472 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12473 std::string ex(str, iter.base()); 12474 assert(ex == "*********************+0.0"); 12475 assert(ios.width() == 0); 12476 } 12477 ios.width(25); 12478 internal(ios); 12479 { 12480 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12481 std::string ex(str, iter.base()); 12482 assert(ex == "+*********************0.0"); 12483 assert(ios.width() == 0); 12484 } 12485 } 12486 ios.imbue(lg); 12487 { 12488 ios.width(0); 12489 { 12490 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12491 std::string ex(str, iter.base()); 12492 assert(ex == "+0;0"); 12493 assert(ios.width() == 0); 12494 } 12495 ios.width(25); 12496 left(ios); 12497 { 12498 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12499 std::string ex(str, iter.base()); 12500 assert(ex == "+0;0*********************"); 12501 assert(ios.width() == 0); 12502 } 12503 ios.width(25); 12504 right(ios); 12505 { 12506 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12507 std::string ex(str, iter.base()); 12508 assert(ex == "*********************+0;0"); 12509 assert(ios.width() == 0); 12510 } 12511 ios.width(25); 12512 internal(ios); 12513 { 12514 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12515 std::string ex(str, iter.base()); 12516 assert(ex == "+*********************0;0"); 12517 assert(ios.width() == 0); 12518 } 12519 } 12520 } 12521 } 12522 } 12523 } 12524 ios.precision(6); 12525 { 12526 nouppercase(ios); 12527 { 12528 noshowpos(ios); 12529 { 12530 noshowpoint(ios); 12531 { 12532 ios.imbue(lc); 12533 { 12534 ios.width(0); 12535 { 12536 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12537 std::string ex(str, iter.base()); 12538 assert(ex == "0.000000"); 12539 assert(ios.width() == 0); 12540 } 12541 ios.width(25); 12542 left(ios); 12543 { 12544 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12545 std::string ex(str, iter.base()); 12546 assert(ex == "0.000000*****************"); 12547 assert(ios.width() == 0); 12548 } 12549 ios.width(25); 12550 right(ios); 12551 { 12552 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12553 std::string ex(str, iter.base()); 12554 assert(ex == "*****************0.000000"); 12555 assert(ios.width() == 0); 12556 } 12557 ios.width(25); 12558 internal(ios); 12559 { 12560 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12561 std::string ex(str, iter.base()); 12562 assert(ex == "*****************0.000000"); 12563 assert(ios.width() == 0); 12564 } 12565 } 12566 ios.imbue(lg); 12567 { 12568 ios.width(0); 12569 { 12570 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12571 std::string ex(str, iter.base()); 12572 assert(ex == "0;000000"); 12573 assert(ios.width() == 0); 12574 } 12575 ios.width(25); 12576 left(ios); 12577 { 12578 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12579 std::string ex(str, iter.base()); 12580 assert(ex == "0;000000*****************"); 12581 assert(ios.width() == 0); 12582 } 12583 ios.width(25); 12584 right(ios); 12585 { 12586 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12587 std::string ex(str, iter.base()); 12588 assert(ex == "*****************0;000000"); 12589 assert(ios.width() == 0); 12590 } 12591 ios.width(25); 12592 internal(ios); 12593 { 12594 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12595 std::string ex(str, iter.base()); 12596 assert(ex == "*****************0;000000"); 12597 assert(ios.width() == 0); 12598 } 12599 } 12600 } 12601 showpoint(ios); 12602 { 12603 ios.imbue(lc); 12604 { 12605 ios.width(0); 12606 { 12607 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12608 std::string ex(str, iter.base()); 12609 assert(ex == "0.000000"); 12610 assert(ios.width() == 0); 12611 } 12612 ios.width(25); 12613 left(ios); 12614 { 12615 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12616 std::string ex(str, iter.base()); 12617 assert(ex == "0.000000*****************"); 12618 assert(ios.width() == 0); 12619 } 12620 ios.width(25); 12621 right(ios); 12622 { 12623 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12624 std::string ex(str, iter.base()); 12625 assert(ex == "*****************0.000000"); 12626 assert(ios.width() == 0); 12627 } 12628 ios.width(25); 12629 internal(ios); 12630 { 12631 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12632 std::string ex(str, iter.base()); 12633 assert(ex == "*****************0.000000"); 12634 assert(ios.width() == 0); 12635 } 12636 } 12637 ios.imbue(lg); 12638 { 12639 ios.width(0); 12640 { 12641 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12642 std::string ex(str, iter.base()); 12643 assert(ex == "0;000000"); 12644 assert(ios.width() == 0); 12645 } 12646 ios.width(25); 12647 left(ios); 12648 { 12649 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12650 std::string ex(str, iter.base()); 12651 assert(ex == "0;000000*****************"); 12652 assert(ios.width() == 0); 12653 } 12654 ios.width(25); 12655 right(ios); 12656 { 12657 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12658 std::string ex(str, iter.base()); 12659 assert(ex == "*****************0;000000"); 12660 assert(ios.width() == 0); 12661 } 12662 ios.width(25); 12663 internal(ios); 12664 { 12665 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12666 std::string ex(str, iter.base()); 12667 assert(ex == "*****************0;000000"); 12668 assert(ios.width() == 0); 12669 } 12670 } 12671 } 12672 } 12673 showpos(ios); 12674 { 12675 noshowpoint(ios); 12676 { 12677 ios.imbue(lc); 12678 { 12679 ios.width(0); 12680 { 12681 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12682 std::string ex(str, iter.base()); 12683 assert(ex == "+0.000000"); 12684 assert(ios.width() == 0); 12685 } 12686 ios.width(25); 12687 left(ios); 12688 { 12689 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12690 std::string ex(str, iter.base()); 12691 assert(ex == "+0.000000****************"); 12692 assert(ios.width() == 0); 12693 } 12694 ios.width(25); 12695 right(ios); 12696 { 12697 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12698 std::string ex(str, iter.base()); 12699 assert(ex == "****************+0.000000"); 12700 assert(ios.width() == 0); 12701 } 12702 ios.width(25); 12703 internal(ios); 12704 { 12705 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12706 std::string ex(str, iter.base()); 12707 assert(ex == "+****************0.000000"); 12708 assert(ios.width() == 0); 12709 } 12710 } 12711 ios.imbue(lg); 12712 { 12713 ios.width(0); 12714 { 12715 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12716 std::string ex(str, iter.base()); 12717 assert(ex == "+0;000000"); 12718 assert(ios.width() == 0); 12719 } 12720 ios.width(25); 12721 left(ios); 12722 { 12723 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12724 std::string ex(str, iter.base()); 12725 assert(ex == "+0;000000****************"); 12726 assert(ios.width() == 0); 12727 } 12728 ios.width(25); 12729 right(ios); 12730 { 12731 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12732 std::string ex(str, iter.base()); 12733 assert(ex == "****************+0;000000"); 12734 assert(ios.width() == 0); 12735 } 12736 ios.width(25); 12737 internal(ios); 12738 { 12739 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12740 std::string ex(str, iter.base()); 12741 assert(ex == "+****************0;000000"); 12742 assert(ios.width() == 0); 12743 } 12744 } 12745 } 12746 showpoint(ios); 12747 { 12748 ios.imbue(lc); 12749 { 12750 ios.width(0); 12751 { 12752 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12753 std::string ex(str, iter.base()); 12754 assert(ex == "+0.000000"); 12755 assert(ios.width() == 0); 12756 } 12757 ios.width(25); 12758 left(ios); 12759 { 12760 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12761 std::string ex(str, iter.base()); 12762 assert(ex == "+0.000000****************"); 12763 assert(ios.width() == 0); 12764 } 12765 ios.width(25); 12766 right(ios); 12767 { 12768 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12769 std::string ex(str, iter.base()); 12770 assert(ex == "****************+0.000000"); 12771 assert(ios.width() == 0); 12772 } 12773 ios.width(25); 12774 internal(ios); 12775 { 12776 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12777 std::string ex(str, iter.base()); 12778 assert(ex == "+****************0.000000"); 12779 assert(ios.width() == 0); 12780 } 12781 } 12782 ios.imbue(lg); 12783 { 12784 ios.width(0); 12785 { 12786 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12787 std::string ex(str, iter.base()); 12788 assert(ex == "+0;000000"); 12789 assert(ios.width() == 0); 12790 } 12791 ios.width(25); 12792 left(ios); 12793 { 12794 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12795 std::string ex(str, iter.base()); 12796 assert(ex == "+0;000000****************"); 12797 assert(ios.width() == 0); 12798 } 12799 ios.width(25); 12800 right(ios); 12801 { 12802 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12803 std::string ex(str, iter.base()); 12804 assert(ex == "****************+0;000000"); 12805 assert(ios.width() == 0); 12806 } 12807 ios.width(25); 12808 internal(ios); 12809 { 12810 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12811 std::string ex(str, iter.base()); 12812 assert(ex == "+****************0;000000"); 12813 assert(ios.width() == 0); 12814 } 12815 } 12816 } 12817 } 12818 } 12819 uppercase(ios); 12820 { 12821 noshowpos(ios); 12822 { 12823 noshowpoint(ios); 12824 { 12825 ios.imbue(lc); 12826 { 12827 ios.width(0); 12828 { 12829 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12830 std::string ex(str, iter.base()); 12831 assert(ex == "0.000000"); 12832 assert(ios.width() == 0); 12833 } 12834 ios.width(25); 12835 left(ios); 12836 { 12837 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12838 std::string ex(str, iter.base()); 12839 assert(ex == "0.000000*****************"); 12840 assert(ios.width() == 0); 12841 } 12842 ios.width(25); 12843 right(ios); 12844 { 12845 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12846 std::string ex(str, iter.base()); 12847 assert(ex == "*****************0.000000"); 12848 assert(ios.width() == 0); 12849 } 12850 ios.width(25); 12851 internal(ios); 12852 { 12853 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12854 std::string ex(str, iter.base()); 12855 assert(ex == "*****************0.000000"); 12856 assert(ios.width() == 0); 12857 } 12858 } 12859 ios.imbue(lg); 12860 { 12861 ios.width(0); 12862 { 12863 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12864 std::string ex(str, iter.base()); 12865 assert(ex == "0;000000"); 12866 assert(ios.width() == 0); 12867 } 12868 ios.width(25); 12869 left(ios); 12870 { 12871 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12872 std::string ex(str, iter.base()); 12873 assert(ex == "0;000000*****************"); 12874 assert(ios.width() == 0); 12875 } 12876 ios.width(25); 12877 right(ios); 12878 { 12879 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12880 std::string ex(str, iter.base()); 12881 assert(ex == "*****************0;000000"); 12882 assert(ios.width() == 0); 12883 } 12884 ios.width(25); 12885 internal(ios); 12886 { 12887 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12888 std::string ex(str, iter.base()); 12889 assert(ex == "*****************0;000000"); 12890 assert(ios.width() == 0); 12891 } 12892 } 12893 } 12894 showpoint(ios); 12895 { 12896 ios.imbue(lc); 12897 { 12898 ios.width(0); 12899 { 12900 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12901 std::string ex(str, iter.base()); 12902 assert(ex == "0.000000"); 12903 assert(ios.width() == 0); 12904 } 12905 ios.width(25); 12906 left(ios); 12907 { 12908 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12909 std::string ex(str, iter.base()); 12910 assert(ex == "0.000000*****************"); 12911 assert(ios.width() == 0); 12912 } 12913 ios.width(25); 12914 right(ios); 12915 { 12916 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12917 std::string ex(str, iter.base()); 12918 assert(ex == "*****************0.000000"); 12919 assert(ios.width() == 0); 12920 } 12921 ios.width(25); 12922 internal(ios); 12923 { 12924 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12925 std::string ex(str, iter.base()); 12926 assert(ex == "*****************0.000000"); 12927 assert(ios.width() == 0); 12928 } 12929 } 12930 ios.imbue(lg); 12931 { 12932 ios.width(0); 12933 { 12934 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12935 std::string ex(str, iter.base()); 12936 assert(ex == "0;000000"); 12937 assert(ios.width() == 0); 12938 } 12939 ios.width(25); 12940 left(ios); 12941 { 12942 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12943 std::string ex(str, iter.base()); 12944 assert(ex == "0;000000*****************"); 12945 assert(ios.width() == 0); 12946 } 12947 ios.width(25); 12948 right(ios); 12949 { 12950 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12951 std::string ex(str, iter.base()); 12952 assert(ex == "*****************0;000000"); 12953 assert(ios.width() == 0); 12954 } 12955 ios.width(25); 12956 internal(ios); 12957 { 12958 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12959 std::string ex(str, iter.base()); 12960 assert(ex == "*****************0;000000"); 12961 assert(ios.width() == 0); 12962 } 12963 } 12964 } 12965 } 12966 showpos(ios); 12967 { 12968 noshowpoint(ios); 12969 { 12970 ios.imbue(lc); 12971 { 12972 ios.width(0); 12973 { 12974 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12975 std::string ex(str, iter.base()); 12976 assert(ex == "+0.000000"); 12977 assert(ios.width() == 0); 12978 } 12979 ios.width(25); 12980 left(ios); 12981 { 12982 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12983 std::string ex(str, iter.base()); 12984 assert(ex == "+0.000000****************"); 12985 assert(ios.width() == 0); 12986 } 12987 ios.width(25); 12988 right(ios); 12989 { 12990 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12991 std::string ex(str, iter.base()); 12992 assert(ex == "****************+0.000000"); 12993 assert(ios.width() == 0); 12994 } 12995 ios.width(25); 12996 internal(ios); 12997 { 12998 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12999 std::string ex(str, iter.base()); 13000 assert(ex == "+****************0.000000"); 13001 assert(ios.width() == 0); 13002 } 13003 } 13004 ios.imbue(lg); 13005 { 13006 ios.width(0); 13007 { 13008 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13009 std::string ex(str, iter.base()); 13010 assert(ex == "+0;000000"); 13011 assert(ios.width() == 0); 13012 } 13013 ios.width(25); 13014 left(ios); 13015 { 13016 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13017 std::string ex(str, iter.base()); 13018 assert(ex == "+0;000000****************"); 13019 assert(ios.width() == 0); 13020 } 13021 ios.width(25); 13022 right(ios); 13023 { 13024 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13025 std::string ex(str, iter.base()); 13026 assert(ex == "****************+0;000000"); 13027 assert(ios.width() == 0); 13028 } 13029 ios.width(25); 13030 internal(ios); 13031 { 13032 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13033 std::string ex(str, iter.base()); 13034 assert(ex == "+****************0;000000"); 13035 assert(ios.width() == 0); 13036 } 13037 } 13038 } 13039 showpoint(ios); 13040 { 13041 ios.imbue(lc); 13042 { 13043 ios.width(0); 13044 { 13045 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13046 std::string ex(str, iter.base()); 13047 assert(ex == "+0.000000"); 13048 assert(ios.width() == 0); 13049 } 13050 ios.width(25); 13051 left(ios); 13052 { 13053 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13054 std::string ex(str, iter.base()); 13055 assert(ex == "+0.000000****************"); 13056 assert(ios.width() == 0); 13057 } 13058 ios.width(25); 13059 right(ios); 13060 { 13061 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13062 std::string ex(str, iter.base()); 13063 assert(ex == "****************+0.000000"); 13064 assert(ios.width() == 0); 13065 } 13066 ios.width(25); 13067 internal(ios); 13068 { 13069 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13070 std::string ex(str, iter.base()); 13071 assert(ex == "+****************0.000000"); 13072 assert(ios.width() == 0); 13073 } 13074 } 13075 ios.imbue(lg); 13076 { 13077 ios.width(0); 13078 { 13079 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13080 std::string ex(str, iter.base()); 13081 assert(ex == "+0;000000"); 13082 assert(ios.width() == 0); 13083 } 13084 ios.width(25); 13085 left(ios); 13086 { 13087 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13088 std::string ex(str, iter.base()); 13089 assert(ex == "+0;000000****************"); 13090 assert(ios.width() == 0); 13091 } 13092 ios.width(25); 13093 right(ios); 13094 { 13095 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13096 std::string ex(str, iter.base()); 13097 assert(ex == "****************+0;000000"); 13098 assert(ios.width() == 0); 13099 } 13100 ios.width(25); 13101 internal(ios); 13102 { 13103 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13104 std::string ex(str, iter.base()); 13105 assert(ex == "+****************0;000000"); 13106 assert(ios.width() == 0); 13107 } 13108 } 13109 } 13110 } 13111 } 13112 } 13113 ios.precision(16); 13114 { 13115 nouppercase(ios); 13116 { 13117 noshowpos(ios); 13118 { 13119 noshowpoint(ios); 13120 { 13121 ios.imbue(lc); 13122 { 13123 ios.width(0); 13124 { 13125 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13126 std::string ex(str, iter.base()); 13127 assert(ex == "0.0000000000000000"); 13128 assert(ios.width() == 0); 13129 } 13130 ios.width(25); 13131 left(ios); 13132 { 13133 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13134 std::string ex(str, iter.base()); 13135 assert(ex == "0.0000000000000000*******"); 13136 assert(ios.width() == 0); 13137 } 13138 ios.width(25); 13139 right(ios); 13140 { 13141 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13142 std::string ex(str, iter.base()); 13143 assert(ex == "*******0.0000000000000000"); 13144 assert(ios.width() == 0); 13145 } 13146 ios.width(25); 13147 internal(ios); 13148 { 13149 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13150 std::string ex(str, iter.base()); 13151 assert(ex == "*******0.0000000000000000"); 13152 assert(ios.width() == 0); 13153 } 13154 } 13155 ios.imbue(lg); 13156 { 13157 ios.width(0); 13158 { 13159 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13160 std::string ex(str, iter.base()); 13161 assert(ex == "0;0000000000000000"); 13162 assert(ios.width() == 0); 13163 } 13164 ios.width(25); 13165 left(ios); 13166 { 13167 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13168 std::string ex(str, iter.base()); 13169 assert(ex == "0;0000000000000000*******"); 13170 assert(ios.width() == 0); 13171 } 13172 ios.width(25); 13173 right(ios); 13174 { 13175 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13176 std::string ex(str, iter.base()); 13177 assert(ex == "*******0;0000000000000000"); 13178 assert(ios.width() == 0); 13179 } 13180 ios.width(25); 13181 internal(ios); 13182 { 13183 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13184 std::string ex(str, iter.base()); 13185 assert(ex == "*******0;0000000000000000"); 13186 assert(ios.width() == 0); 13187 } 13188 } 13189 } 13190 showpoint(ios); 13191 { 13192 ios.imbue(lc); 13193 { 13194 ios.width(0); 13195 { 13196 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13197 std::string ex(str, iter.base()); 13198 assert(ex == "0.0000000000000000"); 13199 assert(ios.width() == 0); 13200 } 13201 ios.width(25); 13202 left(ios); 13203 { 13204 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13205 std::string ex(str, iter.base()); 13206 assert(ex == "0.0000000000000000*******"); 13207 assert(ios.width() == 0); 13208 } 13209 ios.width(25); 13210 right(ios); 13211 { 13212 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13213 std::string ex(str, iter.base()); 13214 assert(ex == "*******0.0000000000000000"); 13215 assert(ios.width() == 0); 13216 } 13217 ios.width(25); 13218 internal(ios); 13219 { 13220 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13221 std::string ex(str, iter.base()); 13222 assert(ex == "*******0.0000000000000000"); 13223 assert(ios.width() == 0); 13224 } 13225 } 13226 ios.imbue(lg); 13227 { 13228 ios.width(0); 13229 { 13230 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13231 std::string ex(str, iter.base()); 13232 assert(ex == "0;0000000000000000"); 13233 assert(ios.width() == 0); 13234 } 13235 ios.width(25); 13236 left(ios); 13237 { 13238 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13239 std::string ex(str, iter.base()); 13240 assert(ex == "0;0000000000000000*******"); 13241 assert(ios.width() == 0); 13242 } 13243 ios.width(25); 13244 right(ios); 13245 { 13246 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13247 std::string ex(str, iter.base()); 13248 assert(ex == "*******0;0000000000000000"); 13249 assert(ios.width() == 0); 13250 } 13251 ios.width(25); 13252 internal(ios); 13253 { 13254 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13255 std::string ex(str, iter.base()); 13256 assert(ex == "*******0;0000000000000000"); 13257 assert(ios.width() == 0); 13258 } 13259 } 13260 } 13261 } 13262 showpos(ios); 13263 { 13264 noshowpoint(ios); 13265 { 13266 ios.imbue(lc); 13267 { 13268 ios.width(0); 13269 { 13270 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13271 std::string ex(str, iter.base()); 13272 assert(ex == "+0.0000000000000000"); 13273 assert(ios.width() == 0); 13274 } 13275 ios.width(25); 13276 left(ios); 13277 { 13278 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13279 std::string ex(str, iter.base()); 13280 assert(ex == "+0.0000000000000000******"); 13281 assert(ios.width() == 0); 13282 } 13283 ios.width(25); 13284 right(ios); 13285 { 13286 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13287 std::string ex(str, iter.base()); 13288 assert(ex == "******+0.0000000000000000"); 13289 assert(ios.width() == 0); 13290 } 13291 ios.width(25); 13292 internal(ios); 13293 { 13294 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13295 std::string ex(str, iter.base()); 13296 assert(ex == "+******0.0000000000000000"); 13297 assert(ios.width() == 0); 13298 } 13299 } 13300 ios.imbue(lg); 13301 { 13302 ios.width(0); 13303 { 13304 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13305 std::string ex(str, iter.base()); 13306 assert(ex == "+0;0000000000000000"); 13307 assert(ios.width() == 0); 13308 } 13309 ios.width(25); 13310 left(ios); 13311 { 13312 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13313 std::string ex(str, iter.base()); 13314 assert(ex == "+0;0000000000000000******"); 13315 assert(ios.width() == 0); 13316 } 13317 ios.width(25); 13318 right(ios); 13319 { 13320 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13321 std::string ex(str, iter.base()); 13322 assert(ex == "******+0;0000000000000000"); 13323 assert(ios.width() == 0); 13324 } 13325 ios.width(25); 13326 internal(ios); 13327 { 13328 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13329 std::string ex(str, iter.base()); 13330 assert(ex == "+******0;0000000000000000"); 13331 assert(ios.width() == 0); 13332 } 13333 } 13334 } 13335 showpoint(ios); 13336 { 13337 ios.imbue(lc); 13338 { 13339 ios.width(0); 13340 { 13341 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13342 std::string ex(str, iter.base()); 13343 assert(ex == "+0.0000000000000000"); 13344 assert(ios.width() == 0); 13345 } 13346 ios.width(25); 13347 left(ios); 13348 { 13349 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13350 std::string ex(str, iter.base()); 13351 assert(ex == "+0.0000000000000000******"); 13352 assert(ios.width() == 0); 13353 } 13354 ios.width(25); 13355 right(ios); 13356 { 13357 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13358 std::string ex(str, iter.base()); 13359 assert(ex == "******+0.0000000000000000"); 13360 assert(ios.width() == 0); 13361 } 13362 ios.width(25); 13363 internal(ios); 13364 { 13365 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13366 std::string ex(str, iter.base()); 13367 assert(ex == "+******0.0000000000000000"); 13368 assert(ios.width() == 0); 13369 } 13370 } 13371 ios.imbue(lg); 13372 { 13373 ios.width(0); 13374 { 13375 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13376 std::string ex(str, iter.base()); 13377 assert(ex == "+0;0000000000000000"); 13378 assert(ios.width() == 0); 13379 } 13380 ios.width(25); 13381 left(ios); 13382 { 13383 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13384 std::string ex(str, iter.base()); 13385 assert(ex == "+0;0000000000000000******"); 13386 assert(ios.width() == 0); 13387 } 13388 ios.width(25); 13389 right(ios); 13390 { 13391 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13392 std::string ex(str, iter.base()); 13393 assert(ex == "******+0;0000000000000000"); 13394 assert(ios.width() == 0); 13395 } 13396 ios.width(25); 13397 internal(ios); 13398 { 13399 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13400 std::string ex(str, iter.base()); 13401 assert(ex == "+******0;0000000000000000"); 13402 assert(ios.width() == 0); 13403 } 13404 } 13405 } 13406 } 13407 } 13408 uppercase(ios); 13409 { 13410 noshowpos(ios); 13411 { 13412 noshowpoint(ios); 13413 { 13414 ios.imbue(lc); 13415 { 13416 ios.width(0); 13417 { 13418 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13419 std::string ex(str, iter.base()); 13420 assert(ex == "0.0000000000000000"); 13421 assert(ios.width() == 0); 13422 } 13423 ios.width(25); 13424 left(ios); 13425 { 13426 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13427 std::string ex(str, iter.base()); 13428 assert(ex == "0.0000000000000000*******"); 13429 assert(ios.width() == 0); 13430 } 13431 ios.width(25); 13432 right(ios); 13433 { 13434 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13435 std::string ex(str, iter.base()); 13436 assert(ex == "*******0.0000000000000000"); 13437 assert(ios.width() == 0); 13438 } 13439 ios.width(25); 13440 internal(ios); 13441 { 13442 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13443 std::string ex(str, iter.base()); 13444 assert(ex == "*******0.0000000000000000"); 13445 assert(ios.width() == 0); 13446 } 13447 } 13448 ios.imbue(lg); 13449 { 13450 ios.width(0); 13451 { 13452 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13453 std::string ex(str, iter.base()); 13454 assert(ex == "0;0000000000000000"); 13455 assert(ios.width() == 0); 13456 } 13457 ios.width(25); 13458 left(ios); 13459 { 13460 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13461 std::string ex(str, iter.base()); 13462 assert(ex == "0;0000000000000000*******"); 13463 assert(ios.width() == 0); 13464 } 13465 ios.width(25); 13466 right(ios); 13467 { 13468 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13469 std::string ex(str, iter.base()); 13470 assert(ex == "*******0;0000000000000000"); 13471 assert(ios.width() == 0); 13472 } 13473 ios.width(25); 13474 internal(ios); 13475 { 13476 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13477 std::string ex(str, iter.base()); 13478 assert(ex == "*******0;0000000000000000"); 13479 assert(ios.width() == 0); 13480 } 13481 } 13482 } 13483 showpoint(ios); 13484 { 13485 ios.imbue(lc); 13486 { 13487 ios.width(0); 13488 { 13489 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13490 std::string ex(str, iter.base()); 13491 assert(ex == "0.0000000000000000"); 13492 assert(ios.width() == 0); 13493 } 13494 ios.width(25); 13495 left(ios); 13496 { 13497 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13498 std::string ex(str, iter.base()); 13499 assert(ex == "0.0000000000000000*******"); 13500 assert(ios.width() == 0); 13501 } 13502 ios.width(25); 13503 right(ios); 13504 { 13505 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13506 std::string ex(str, iter.base()); 13507 assert(ex == "*******0.0000000000000000"); 13508 assert(ios.width() == 0); 13509 } 13510 ios.width(25); 13511 internal(ios); 13512 { 13513 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13514 std::string ex(str, iter.base()); 13515 assert(ex == "*******0.0000000000000000"); 13516 assert(ios.width() == 0); 13517 } 13518 } 13519 ios.imbue(lg); 13520 { 13521 ios.width(0); 13522 { 13523 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13524 std::string ex(str, iter.base()); 13525 assert(ex == "0;0000000000000000"); 13526 assert(ios.width() == 0); 13527 } 13528 ios.width(25); 13529 left(ios); 13530 { 13531 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13532 std::string ex(str, iter.base()); 13533 assert(ex == "0;0000000000000000*******"); 13534 assert(ios.width() == 0); 13535 } 13536 ios.width(25); 13537 right(ios); 13538 { 13539 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13540 std::string ex(str, iter.base()); 13541 assert(ex == "*******0;0000000000000000"); 13542 assert(ios.width() == 0); 13543 } 13544 ios.width(25); 13545 internal(ios); 13546 { 13547 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13548 std::string ex(str, iter.base()); 13549 assert(ex == "*******0;0000000000000000"); 13550 assert(ios.width() == 0); 13551 } 13552 } 13553 } 13554 } 13555 showpos(ios); 13556 { 13557 noshowpoint(ios); 13558 { 13559 ios.imbue(lc); 13560 { 13561 ios.width(0); 13562 { 13563 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13564 std::string ex(str, iter.base()); 13565 assert(ex == "+0.0000000000000000"); 13566 assert(ios.width() == 0); 13567 } 13568 ios.width(25); 13569 left(ios); 13570 { 13571 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13572 std::string ex(str, iter.base()); 13573 assert(ex == "+0.0000000000000000******"); 13574 assert(ios.width() == 0); 13575 } 13576 ios.width(25); 13577 right(ios); 13578 { 13579 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13580 std::string ex(str, iter.base()); 13581 assert(ex == "******+0.0000000000000000"); 13582 assert(ios.width() == 0); 13583 } 13584 ios.width(25); 13585 internal(ios); 13586 { 13587 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13588 std::string ex(str, iter.base()); 13589 assert(ex == "+******0.0000000000000000"); 13590 assert(ios.width() == 0); 13591 } 13592 } 13593 ios.imbue(lg); 13594 { 13595 ios.width(0); 13596 { 13597 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13598 std::string ex(str, iter.base()); 13599 assert(ex == "+0;0000000000000000"); 13600 assert(ios.width() == 0); 13601 } 13602 ios.width(25); 13603 left(ios); 13604 { 13605 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13606 std::string ex(str, iter.base()); 13607 assert(ex == "+0;0000000000000000******"); 13608 assert(ios.width() == 0); 13609 } 13610 ios.width(25); 13611 right(ios); 13612 { 13613 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13614 std::string ex(str, iter.base()); 13615 assert(ex == "******+0;0000000000000000"); 13616 assert(ios.width() == 0); 13617 } 13618 ios.width(25); 13619 internal(ios); 13620 { 13621 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13622 std::string ex(str, iter.base()); 13623 assert(ex == "+******0;0000000000000000"); 13624 assert(ios.width() == 0); 13625 } 13626 } 13627 } 13628 showpoint(ios); 13629 { 13630 ios.imbue(lc); 13631 { 13632 ios.width(0); 13633 { 13634 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13635 std::string ex(str, iter.base()); 13636 assert(ex == "+0.0000000000000000"); 13637 assert(ios.width() == 0); 13638 } 13639 ios.width(25); 13640 left(ios); 13641 { 13642 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13643 std::string ex(str, iter.base()); 13644 assert(ex == "+0.0000000000000000******"); 13645 assert(ios.width() == 0); 13646 } 13647 ios.width(25); 13648 right(ios); 13649 { 13650 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13651 std::string ex(str, iter.base()); 13652 assert(ex == "******+0.0000000000000000"); 13653 assert(ios.width() == 0); 13654 } 13655 ios.width(25); 13656 internal(ios); 13657 { 13658 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13659 std::string ex(str, iter.base()); 13660 assert(ex == "+******0.0000000000000000"); 13661 assert(ios.width() == 0); 13662 } 13663 } 13664 ios.imbue(lg); 13665 { 13666 ios.width(0); 13667 { 13668 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13669 std::string ex(str, iter.base()); 13670 assert(ex == "+0;0000000000000000"); 13671 assert(ios.width() == 0); 13672 } 13673 ios.width(25); 13674 left(ios); 13675 { 13676 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13677 std::string ex(str, iter.base()); 13678 assert(ex == "+0;0000000000000000******"); 13679 assert(ios.width() == 0); 13680 } 13681 ios.width(25); 13682 right(ios); 13683 { 13684 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13685 std::string ex(str, iter.base()); 13686 assert(ex == "******+0;0000000000000000"); 13687 assert(ios.width() == 0); 13688 } 13689 ios.width(25); 13690 internal(ios); 13691 { 13692 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13693 std::string ex(str, iter.base()); 13694 assert(ex == "+******0;0000000000000000"); 13695 assert(ios.width() == 0); 13696 } 13697 } 13698 } 13699 } 13700 } 13701 } 13702 ios.precision(60); 13703 { 13704 nouppercase(ios); 13705 { 13706 noshowpos(ios); 13707 { 13708 noshowpoint(ios); 13709 { 13710 ios.imbue(lc); 13711 { 13712 ios.width(0); 13713 { 13714 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13715 std::string ex(str, iter.base()); 13716 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13717 assert(ios.width() == 0); 13718 } 13719 ios.width(25); 13720 left(ios); 13721 { 13722 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13723 std::string ex(str, iter.base()); 13724 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13725 assert(ios.width() == 0); 13726 } 13727 ios.width(25); 13728 right(ios); 13729 { 13730 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13731 std::string ex(str, iter.base()); 13732 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13733 assert(ios.width() == 0); 13734 } 13735 ios.width(25); 13736 internal(ios); 13737 { 13738 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13739 std::string ex(str, iter.base()); 13740 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13741 assert(ios.width() == 0); 13742 } 13743 } 13744 ios.imbue(lg); 13745 { 13746 ios.width(0); 13747 { 13748 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13749 std::string ex(str, iter.base()); 13750 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13751 assert(ios.width() == 0); 13752 } 13753 ios.width(25); 13754 left(ios); 13755 { 13756 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13757 std::string ex(str, iter.base()); 13758 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13759 assert(ios.width() == 0); 13760 } 13761 ios.width(25); 13762 right(ios); 13763 { 13764 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13765 std::string ex(str, iter.base()); 13766 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13767 assert(ios.width() == 0); 13768 } 13769 ios.width(25); 13770 internal(ios); 13771 { 13772 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13773 std::string ex(str, iter.base()); 13774 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13775 assert(ios.width() == 0); 13776 } 13777 } 13778 } 13779 showpoint(ios); 13780 { 13781 ios.imbue(lc); 13782 { 13783 ios.width(0); 13784 { 13785 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13786 std::string ex(str, iter.base()); 13787 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13788 assert(ios.width() == 0); 13789 } 13790 ios.width(25); 13791 left(ios); 13792 { 13793 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13794 std::string ex(str, iter.base()); 13795 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13796 assert(ios.width() == 0); 13797 } 13798 ios.width(25); 13799 right(ios); 13800 { 13801 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13802 std::string ex(str, iter.base()); 13803 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13804 assert(ios.width() == 0); 13805 } 13806 ios.width(25); 13807 internal(ios); 13808 { 13809 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13810 std::string ex(str, iter.base()); 13811 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13812 assert(ios.width() == 0); 13813 } 13814 } 13815 ios.imbue(lg); 13816 { 13817 ios.width(0); 13818 { 13819 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13820 std::string ex(str, iter.base()); 13821 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13822 assert(ios.width() == 0); 13823 } 13824 ios.width(25); 13825 left(ios); 13826 { 13827 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13828 std::string ex(str, iter.base()); 13829 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13830 assert(ios.width() == 0); 13831 } 13832 ios.width(25); 13833 right(ios); 13834 { 13835 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13836 std::string ex(str, iter.base()); 13837 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13838 assert(ios.width() == 0); 13839 } 13840 ios.width(25); 13841 internal(ios); 13842 { 13843 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13844 std::string ex(str, iter.base()); 13845 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13846 assert(ios.width() == 0); 13847 } 13848 } 13849 } 13850 } 13851 showpos(ios); 13852 { 13853 noshowpoint(ios); 13854 { 13855 ios.imbue(lc); 13856 { 13857 ios.width(0); 13858 { 13859 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13860 std::string ex(str, iter.base()); 13861 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13862 assert(ios.width() == 0); 13863 } 13864 ios.width(25); 13865 left(ios); 13866 { 13867 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13868 std::string ex(str, iter.base()); 13869 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13870 assert(ios.width() == 0); 13871 } 13872 ios.width(25); 13873 right(ios); 13874 { 13875 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13876 std::string ex(str, iter.base()); 13877 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13878 assert(ios.width() == 0); 13879 } 13880 ios.width(25); 13881 internal(ios); 13882 { 13883 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13884 std::string ex(str, iter.base()); 13885 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13886 assert(ios.width() == 0); 13887 } 13888 } 13889 ios.imbue(lg); 13890 { 13891 ios.width(0); 13892 { 13893 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13894 std::string ex(str, iter.base()); 13895 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13896 assert(ios.width() == 0); 13897 } 13898 ios.width(25); 13899 left(ios); 13900 { 13901 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13902 std::string ex(str, iter.base()); 13903 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13904 assert(ios.width() == 0); 13905 } 13906 ios.width(25); 13907 right(ios); 13908 { 13909 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13910 std::string ex(str, iter.base()); 13911 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13912 assert(ios.width() == 0); 13913 } 13914 ios.width(25); 13915 internal(ios); 13916 { 13917 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13918 std::string ex(str, iter.base()); 13919 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13920 assert(ios.width() == 0); 13921 } 13922 } 13923 } 13924 showpoint(ios); 13925 { 13926 ios.imbue(lc); 13927 { 13928 ios.width(0); 13929 { 13930 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13931 std::string ex(str, iter.base()); 13932 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13933 assert(ios.width() == 0); 13934 } 13935 ios.width(25); 13936 left(ios); 13937 { 13938 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13939 std::string ex(str, iter.base()); 13940 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13941 assert(ios.width() == 0); 13942 } 13943 ios.width(25); 13944 right(ios); 13945 { 13946 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13947 std::string ex(str, iter.base()); 13948 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13949 assert(ios.width() == 0); 13950 } 13951 ios.width(25); 13952 internal(ios); 13953 { 13954 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13955 std::string ex(str, iter.base()); 13956 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13957 assert(ios.width() == 0); 13958 } 13959 } 13960 ios.imbue(lg); 13961 { 13962 ios.width(0); 13963 { 13964 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13965 std::string ex(str, iter.base()); 13966 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13967 assert(ios.width() == 0); 13968 } 13969 ios.width(25); 13970 left(ios); 13971 { 13972 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13973 std::string ex(str, iter.base()); 13974 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13975 assert(ios.width() == 0); 13976 } 13977 ios.width(25); 13978 right(ios); 13979 { 13980 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13981 std::string ex(str, iter.base()); 13982 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13983 assert(ios.width() == 0); 13984 } 13985 ios.width(25); 13986 internal(ios); 13987 { 13988 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13989 std::string ex(str, iter.base()); 13990 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13991 assert(ios.width() == 0); 13992 } 13993 } 13994 } 13995 } 13996 } 13997 uppercase(ios); 13998 { 13999 noshowpos(ios); 14000 { 14001 noshowpoint(ios); 14002 { 14003 ios.imbue(lc); 14004 { 14005 ios.width(0); 14006 { 14007 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14008 std::string ex(str, iter.base()); 14009 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14010 assert(ios.width() == 0); 14011 } 14012 ios.width(25); 14013 left(ios); 14014 { 14015 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14016 std::string ex(str, iter.base()); 14017 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14018 assert(ios.width() == 0); 14019 } 14020 ios.width(25); 14021 right(ios); 14022 { 14023 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14024 std::string ex(str, iter.base()); 14025 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14026 assert(ios.width() == 0); 14027 } 14028 ios.width(25); 14029 internal(ios); 14030 { 14031 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14032 std::string ex(str, iter.base()); 14033 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14034 assert(ios.width() == 0); 14035 } 14036 } 14037 ios.imbue(lg); 14038 { 14039 ios.width(0); 14040 { 14041 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14042 std::string ex(str, iter.base()); 14043 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14044 assert(ios.width() == 0); 14045 } 14046 ios.width(25); 14047 left(ios); 14048 { 14049 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14050 std::string ex(str, iter.base()); 14051 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14052 assert(ios.width() == 0); 14053 } 14054 ios.width(25); 14055 right(ios); 14056 { 14057 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14058 std::string ex(str, iter.base()); 14059 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14060 assert(ios.width() == 0); 14061 } 14062 ios.width(25); 14063 internal(ios); 14064 { 14065 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14066 std::string ex(str, iter.base()); 14067 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14068 assert(ios.width() == 0); 14069 } 14070 } 14071 } 14072 showpoint(ios); 14073 { 14074 ios.imbue(lc); 14075 { 14076 ios.width(0); 14077 { 14078 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14079 std::string ex(str, iter.base()); 14080 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14081 assert(ios.width() == 0); 14082 } 14083 ios.width(25); 14084 left(ios); 14085 { 14086 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14087 std::string ex(str, iter.base()); 14088 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14089 assert(ios.width() == 0); 14090 } 14091 ios.width(25); 14092 right(ios); 14093 { 14094 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14095 std::string ex(str, iter.base()); 14096 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14097 assert(ios.width() == 0); 14098 } 14099 ios.width(25); 14100 internal(ios); 14101 { 14102 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14103 std::string ex(str, iter.base()); 14104 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14105 assert(ios.width() == 0); 14106 } 14107 } 14108 ios.imbue(lg); 14109 { 14110 ios.width(0); 14111 { 14112 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14113 std::string ex(str, iter.base()); 14114 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14115 assert(ios.width() == 0); 14116 } 14117 ios.width(25); 14118 left(ios); 14119 { 14120 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14121 std::string ex(str, iter.base()); 14122 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14123 assert(ios.width() == 0); 14124 } 14125 ios.width(25); 14126 right(ios); 14127 { 14128 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14129 std::string ex(str, iter.base()); 14130 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14131 assert(ios.width() == 0); 14132 } 14133 ios.width(25); 14134 internal(ios); 14135 { 14136 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14137 std::string ex(str, iter.base()); 14138 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14139 assert(ios.width() == 0); 14140 } 14141 } 14142 } 14143 } 14144 showpos(ios); 14145 { 14146 noshowpoint(ios); 14147 { 14148 ios.imbue(lc); 14149 { 14150 ios.width(0); 14151 { 14152 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14153 std::string ex(str, iter.base()); 14154 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14155 assert(ios.width() == 0); 14156 } 14157 ios.width(25); 14158 left(ios); 14159 { 14160 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14161 std::string ex(str, iter.base()); 14162 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14163 assert(ios.width() == 0); 14164 } 14165 ios.width(25); 14166 right(ios); 14167 { 14168 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14169 std::string ex(str, iter.base()); 14170 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14171 assert(ios.width() == 0); 14172 } 14173 ios.width(25); 14174 internal(ios); 14175 { 14176 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14177 std::string ex(str, iter.base()); 14178 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14179 assert(ios.width() == 0); 14180 } 14181 } 14182 ios.imbue(lg); 14183 { 14184 ios.width(0); 14185 { 14186 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14187 std::string ex(str, iter.base()); 14188 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14189 assert(ios.width() == 0); 14190 } 14191 ios.width(25); 14192 left(ios); 14193 { 14194 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14195 std::string ex(str, iter.base()); 14196 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14197 assert(ios.width() == 0); 14198 } 14199 ios.width(25); 14200 right(ios); 14201 { 14202 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14203 std::string ex(str, iter.base()); 14204 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14205 assert(ios.width() == 0); 14206 } 14207 ios.width(25); 14208 internal(ios); 14209 { 14210 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14211 std::string ex(str, iter.base()); 14212 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14213 assert(ios.width() == 0); 14214 } 14215 } 14216 } 14217 showpoint(ios); 14218 { 14219 ios.imbue(lc); 14220 { 14221 ios.width(0); 14222 { 14223 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14224 std::string ex(str, iter.base()); 14225 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14226 assert(ios.width() == 0); 14227 } 14228 ios.width(25); 14229 left(ios); 14230 { 14231 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14232 std::string ex(str, iter.base()); 14233 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14234 assert(ios.width() == 0); 14235 } 14236 ios.width(25); 14237 right(ios); 14238 { 14239 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14240 std::string ex(str, iter.base()); 14241 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14242 assert(ios.width() == 0); 14243 } 14244 ios.width(25); 14245 internal(ios); 14246 { 14247 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14248 std::string ex(str, iter.base()); 14249 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14250 assert(ios.width() == 0); 14251 } 14252 } 14253 ios.imbue(lg); 14254 { 14255 ios.width(0); 14256 { 14257 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14258 std::string ex(str, iter.base()); 14259 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14260 assert(ios.width() == 0); 14261 } 14262 ios.width(25); 14263 left(ios); 14264 { 14265 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14266 std::string ex(str, iter.base()); 14267 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14268 assert(ios.width() == 0); 14269 } 14270 ios.width(25); 14271 right(ios); 14272 { 14273 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14274 std::string ex(str, iter.base()); 14275 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14276 assert(ios.width() == 0); 14277 } 14278 ios.width(25); 14279 internal(ios); 14280 { 14281 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14282 std::string ex(str, iter.base()); 14283 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14284 assert(ios.width() == 0); 14285 } 14286 } 14287 } 14288 } 14289 } 14290 } 14291 } 14292 } 14293 } 14294 14295 void test7() 14296 { 14297 char str[200]; 14298 output_iterator<char*> iter; 14299 std::locale lc = std::locale::classic(); 14300 std::locale lg(lc, new my_numpunct); 14301 const my_facet f(1); 14302 { 14303 long double v = -0.; 14304 std::ios ios(0); 14305 fixed(ios); 14306 // %f 14307 { 14308 ios.precision(0); 14309 { 14310 nouppercase(ios); 14311 { 14312 noshowpos(ios); 14313 { 14314 noshowpoint(ios); 14315 { 14316 ios.imbue(lc); 14317 { 14318 ios.width(0); 14319 { 14320 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14321 std::string ex(str, iter.base()); 14322 assert(ex == "-0"); 14323 assert(ios.width() == 0); 14324 } 14325 ios.width(25); 14326 left(ios); 14327 { 14328 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14329 std::string ex(str, iter.base()); 14330 assert(ex == "-0***********************"); 14331 assert(ios.width() == 0); 14332 } 14333 ios.width(25); 14334 right(ios); 14335 { 14336 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14337 std::string ex(str, iter.base()); 14338 assert(ex == "***********************-0"); 14339 assert(ios.width() == 0); 14340 } 14341 ios.width(25); 14342 internal(ios); 14343 { 14344 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14345 std::string ex(str, iter.base()); 14346 assert(ex == "-***********************0"); 14347 assert(ios.width() == 0); 14348 } 14349 } 14350 ios.imbue(lg); 14351 { 14352 ios.width(0); 14353 { 14354 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14355 std::string ex(str, iter.base()); 14356 assert(ex == "-0"); 14357 assert(ios.width() == 0); 14358 } 14359 ios.width(25); 14360 left(ios); 14361 { 14362 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14363 std::string ex(str, iter.base()); 14364 assert(ex == "-0***********************"); 14365 assert(ios.width() == 0); 14366 } 14367 ios.width(25); 14368 right(ios); 14369 { 14370 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14371 std::string ex(str, iter.base()); 14372 assert(ex == "***********************-0"); 14373 assert(ios.width() == 0); 14374 } 14375 ios.width(25); 14376 internal(ios); 14377 { 14378 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14379 std::string ex(str, iter.base()); 14380 assert(ex == "-***********************0"); 14381 assert(ios.width() == 0); 14382 } 14383 } 14384 } 14385 showpoint(ios); 14386 { 14387 ios.imbue(lc); 14388 { 14389 ios.width(0); 14390 { 14391 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14392 std::string ex(str, iter.base()); 14393 assert(ex == "-0."); 14394 assert(ios.width() == 0); 14395 } 14396 ios.width(25); 14397 left(ios); 14398 { 14399 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14400 std::string ex(str, iter.base()); 14401 assert(ex == "-0.**********************"); 14402 assert(ios.width() == 0); 14403 } 14404 ios.width(25); 14405 right(ios); 14406 { 14407 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14408 std::string ex(str, iter.base()); 14409 assert(ex == "**********************-0."); 14410 assert(ios.width() == 0); 14411 } 14412 ios.width(25); 14413 internal(ios); 14414 { 14415 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14416 std::string ex(str, iter.base()); 14417 assert(ex == "-**********************0."); 14418 assert(ios.width() == 0); 14419 } 14420 } 14421 ios.imbue(lg); 14422 { 14423 ios.width(0); 14424 { 14425 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14426 std::string ex(str, iter.base()); 14427 assert(ex == "-0;"); 14428 assert(ios.width() == 0); 14429 } 14430 ios.width(25); 14431 left(ios); 14432 { 14433 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14434 std::string ex(str, iter.base()); 14435 assert(ex == "-0;**********************"); 14436 assert(ios.width() == 0); 14437 } 14438 ios.width(25); 14439 right(ios); 14440 { 14441 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14442 std::string ex(str, iter.base()); 14443 assert(ex == "**********************-0;"); 14444 assert(ios.width() == 0); 14445 } 14446 ios.width(25); 14447 internal(ios); 14448 { 14449 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14450 std::string ex(str, iter.base()); 14451 assert(ex == "-**********************0;"); 14452 assert(ios.width() == 0); 14453 } 14454 } 14455 } 14456 } 14457 showpos(ios); 14458 { 14459 noshowpoint(ios); 14460 { 14461 ios.imbue(lc); 14462 { 14463 ios.width(0); 14464 { 14465 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14466 std::string ex(str, iter.base()); 14467 assert(ex == "-0"); 14468 assert(ios.width() == 0); 14469 } 14470 ios.width(25); 14471 left(ios); 14472 { 14473 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14474 std::string ex(str, iter.base()); 14475 assert(ex == "-0***********************"); 14476 assert(ios.width() == 0); 14477 } 14478 ios.width(25); 14479 right(ios); 14480 { 14481 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14482 std::string ex(str, iter.base()); 14483 assert(ex == "***********************-0"); 14484 assert(ios.width() == 0); 14485 } 14486 ios.width(25); 14487 internal(ios); 14488 { 14489 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14490 std::string ex(str, iter.base()); 14491 assert(ex == "-***********************0"); 14492 assert(ios.width() == 0); 14493 } 14494 } 14495 ios.imbue(lg); 14496 { 14497 ios.width(0); 14498 { 14499 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14500 std::string ex(str, iter.base()); 14501 assert(ex == "-0"); 14502 assert(ios.width() == 0); 14503 } 14504 ios.width(25); 14505 left(ios); 14506 { 14507 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14508 std::string ex(str, iter.base()); 14509 assert(ex == "-0***********************"); 14510 assert(ios.width() == 0); 14511 } 14512 ios.width(25); 14513 right(ios); 14514 { 14515 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14516 std::string ex(str, iter.base()); 14517 assert(ex == "***********************-0"); 14518 assert(ios.width() == 0); 14519 } 14520 ios.width(25); 14521 internal(ios); 14522 { 14523 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14524 std::string ex(str, iter.base()); 14525 assert(ex == "-***********************0"); 14526 assert(ios.width() == 0); 14527 } 14528 } 14529 } 14530 showpoint(ios); 14531 { 14532 ios.imbue(lc); 14533 { 14534 ios.width(0); 14535 { 14536 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14537 std::string ex(str, iter.base()); 14538 assert(ex == "-0."); 14539 assert(ios.width() == 0); 14540 } 14541 ios.width(25); 14542 left(ios); 14543 { 14544 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14545 std::string ex(str, iter.base()); 14546 assert(ex == "-0.**********************"); 14547 assert(ios.width() == 0); 14548 } 14549 ios.width(25); 14550 right(ios); 14551 { 14552 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14553 std::string ex(str, iter.base()); 14554 assert(ex == "**********************-0."); 14555 assert(ios.width() == 0); 14556 } 14557 ios.width(25); 14558 internal(ios); 14559 { 14560 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14561 std::string ex(str, iter.base()); 14562 assert(ex == "-**********************0."); 14563 assert(ios.width() == 0); 14564 } 14565 } 14566 ios.imbue(lg); 14567 { 14568 ios.width(0); 14569 { 14570 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14571 std::string ex(str, iter.base()); 14572 assert(ex == "-0;"); 14573 assert(ios.width() == 0); 14574 } 14575 ios.width(25); 14576 left(ios); 14577 { 14578 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14579 std::string ex(str, iter.base()); 14580 assert(ex == "-0;**********************"); 14581 assert(ios.width() == 0); 14582 } 14583 ios.width(25); 14584 right(ios); 14585 { 14586 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14587 std::string ex(str, iter.base()); 14588 assert(ex == "**********************-0;"); 14589 assert(ios.width() == 0); 14590 } 14591 ios.width(25); 14592 internal(ios); 14593 { 14594 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14595 std::string ex(str, iter.base()); 14596 assert(ex == "-**********************0;"); 14597 assert(ios.width() == 0); 14598 } 14599 } 14600 } 14601 } 14602 } 14603 uppercase(ios); 14604 { 14605 noshowpos(ios); 14606 { 14607 noshowpoint(ios); 14608 { 14609 ios.imbue(lc); 14610 { 14611 ios.width(0); 14612 { 14613 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14614 std::string ex(str, iter.base()); 14615 assert(ex == "-0"); 14616 assert(ios.width() == 0); 14617 } 14618 ios.width(25); 14619 left(ios); 14620 { 14621 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14622 std::string ex(str, iter.base()); 14623 assert(ex == "-0***********************"); 14624 assert(ios.width() == 0); 14625 } 14626 ios.width(25); 14627 right(ios); 14628 { 14629 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14630 std::string ex(str, iter.base()); 14631 assert(ex == "***********************-0"); 14632 assert(ios.width() == 0); 14633 } 14634 ios.width(25); 14635 internal(ios); 14636 { 14637 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14638 std::string ex(str, iter.base()); 14639 assert(ex == "-***********************0"); 14640 assert(ios.width() == 0); 14641 } 14642 } 14643 ios.imbue(lg); 14644 { 14645 ios.width(0); 14646 { 14647 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14648 std::string ex(str, iter.base()); 14649 assert(ex == "-0"); 14650 assert(ios.width() == 0); 14651 } 14652 ios.width(25); 14653 left(ios); 14654 { 14655 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14656 std::string ex(str, iter.base()); 14657 assert(ex == "-0***********************"); 14658 assert(ios.width() == 0); 14659 } 14660 ios.width(25); 14661 right(ios); 14662 { 14663 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14664 std::string ex(str, iter.base()); 14665 assert(ex == "***********************-0"); 14666 assert(ios.width() == 0); 14667 } 14668 ios.width(25); 14669 internal(ios); 14670 { 14671 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14672 std::string ex(str, iter.base()); 14673 assert(ex == "-***********************0"); 14674 assert(ios.width() == 0); 14675 } 14676 } 14677 } 14678 showpoint(ios); 14679 { 14680 ios.imbue(lc); 14681 { 14682 ios.width(0); 14683 { 14684 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14685 std::string ex(str, iter.base()); 14686 assert(ex == "-0."); 14687 assert(ios.width() == 0); 14688 } 14689 ios.width(25); 14690 left(ios); 14691 { 14692 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14693 std::string ex(str, iter.base()); 14694 assert(ex == "-0.**********************"); 14695 assert(ios.width() == 0); 14696 } 14697 ios.width(25); 14698 right(ios); 14699 { 14700 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14701 std::string ex(str, iter.base()); 14702 assert(ex == "**********************-0."); 14703 assert(ios.width() == 0); 14704 } 14705 ios.width(25); 14706 internal(ios); 14707 { 14708 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14709 std::string ex(str, iter.base()); 14710 assert(ex == "-**********************0."); 14711 assert(ios.width() == 0); 14712 } 14713 } 14714 ios.imbue(lg); 14715 { 14716 ios.width(0); 14717 { 14718 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14719 std::string ex(str, iter.base()); 14720 assert(ex == "-0;"); 14721 assert(ios.width() == 0); 14722 } 14723 ios.width(25); 14724 left(ios); 14725 { 14726 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14727 std::string ex(str, iter.base()); 14728 assert(ex == "-0;**********************"); 14729 assert(ios.width() == 0); 14730 } 14731 ios.width(25); 14732 right(ios); 14733 { 14734 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14735 std::string ex(str, iter.base()); 14736 assert(ex == "**********************-0;"); 14737 assert(ios.width() == 0); 14738 } 14739 ios.width(25); 14740 internal(ios); 14741 { 14742 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14743 std::string ex(str, iter.base()); 14744 assert(ex == "-**********************0;"); 14745 assert(ios.width() == 0); 14746 } 14747 } 14748 } 14749 } 14750 showpos(ios); 14751 { 14752 noshowpoint(ios); 14753 { 14754 ios.imbue(lc); 14755 { 14756 ios.width(0); 14757 { 14758 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14759 std::string ex(str, iter.base()); 14760 assert(ex == "-0"); 14761 assert(ios.width() == 0); 14762 } 14763 ios.width(25); 14764 left(ios); 14765 { 14766 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14767 std::string ex(str, iter.base()); 14768 assert(ex == "-0***********************"); 14769 assert(ios.width() == 0); 14770 } 14771 ios.width(25); 14772 right(ios); 14773 { 14774 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14775 std::string ex(str, iter.base()); 14776 assert(ex == "***********************-0"); 14777 assert(ios.width() == 0); 14778 } 14779 ios.width(25); 14780 internal(ios); 14781 { 14782 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14783 std::string ex(str, iter.base()); 14784 assert(ex == "-***********************0"); 14785 assert(ios.width() == 0); 14786 } 14787 } 14788 ios.imbue(lg); 14789 { 14790 ios.width(0); 14791 { 14792 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14793 std::string ex(str, iter.base()); 14794 assert(ex == "-0"); 14795 assert(ios.width() == 0); 14796 } 14797 ios.width(25); 14798 left(ios); 14799 { 14800 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14801 std::string ex(str, iter.base()); 14802 assert(ex == "-0***********************"); 14803 assert(ios.width() == 0); 14804 } 14805 ios.width(25); 14806 right(ios); 14807 { 14808 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14809 std::string ex(str, iter.base()); 14810 assert(ex == "***********************-0"); 14811 assert(ios.width() == 0); 14812 } 14813 ios.width(25); 14814 internal(ios); 14815 { 14816 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14817 std::string ex(str, iter.base()); 14818 assert(ex == "-***********************0"); 14819 assert(ios.width() == 0); 14820 } 14821 } 14822 } 14823 showpoint(ios); 14824 { 14825 ios.imbue(lc); 14826 { 14827 ios.width(0); 14828 { 14829 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14830 std::string ex(str, iter.base()); 14831 assert(ex == "-0."); 14832 assert(ios.width() == 0); 14833 } 14834 ios.width(25); 14835 left(ios); 14836 { 14837 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14838 std::string ex(str, iter.base()); 14839 assert(ex == "-0.**********************"); 14840 assert(ios.width() == 0); 14841 } 14842 ios.width(25); 14843 right(ios); 14844 { 14845 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14846 std::string ex(str, iter.base()); 14847 assert(ex == "**********************-0."); 14848 assert(ios.width() == 0); 14849 } 14850 ios.width(25); 14851 internal(ios); 14852 { 14853 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14854 std::string ex(str, iter.base()); 14855 assert(ex == "-**********************0."); 14856 assert(ios.width() == 0); 14857 } 14858 } 14859 ios.imbue(lg); 14860 { 14861 ios.width(0); 14862 { 14863 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14864 std::string ex(str, iter.base()); 14865 assert(ex == "-0;"); 14866 assert(ios.width() == 0); 14867 } 14868 ios.width(25); 14869 left(ios); 14870 { 14871 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14872 std::string ex(str, iter.base()); 14873 assert(ex == "-0;**********************"); 14874 assert(ios.width() == 0); 14875 } 14876 ios.width(25); 14877 right(ios); 14878 { 14879 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14880 std::string ex(str, iter.base()); 14881 assert(ex == "**********************-0;"); 14882 assert(ios.width() == 0); 14883 } 14884 ios.width(25); 14885 internal(ios); 14886 { 14887 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14888 std::string ex(str, iter.base()); 14889 assert(ex == "-**********************0;"); 14890 assert(ios.width() == 0); 14891 } 14892 } 14893 } 14894 } 14895 } 14896 } 14897 ios.precision(1); 14898 { 14899 nouppercase(ios); 14900 { 14901 noshowpos(ios); 14902 { 14903 noshowpoint(ios); 14904 { 14905 ios.imbue(lc); 14906 { 14907 ios.width(0); 14908 { 14909 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14910 std::string ex(str, iter.base()); 14911 assert(ex == "-0.0"); 14912 assert(ios.width() == 0); 14913 } 14914 ios.width(25); 14915 left(ios); 14916 { 14917 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14918 std::string ex(str, iter.base()); 14919 assert(ex == "-0.0*********************"); 14920 assert(ios.width() == 0); 14921 } 14922 ios.width(25); 14923 right(ios); 14924 { 14925 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14926 std::string ex(str, iter.base()); 14927 assert(ex == "*********************-0.0"); 14928 assert(ios.width() == 0); 14929 } 14930 ios.width(25); 14931 internal(ios); 14932 { 14933 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14934 std::string ex(str, iter.base()); 14935 assert(ex == "-*********************0.0"); 14936 assert(ios.width() == 0); 14937 } 14938 } 14939 ios.imbue(lg); 14940 { 14941 ios.width(0); 14942 { 14943 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14944 std::string ex(str, iter.base()); 14945 assert(ex == "-0;0"); 14946 assert(ios.width() == 0); 14947 } 14948 ios.width(25); 14949 left(ios); 14950 { 14951 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14952 std::string ex(str, iter.base()); 14953 assert(ex == "-0;0*********************"); 14954 assert(ios.width() == 0); 14955 } 14956 ios.width(25); 14957 right(ios); 14958 { 14959 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14960 std::string ex(str, iter.base()); 14961 assert(ex == "*********************-0;0"); 14962 assert(ios.width() == 0); 14963 } 14964 ios.width(25); 14965 internal(ios); 14966 { 14967 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14968 std::string ex(str, iter.base()); 14969 assert(ex == "-*********************0;0"); 14970 assert(ios.width() == 0); 14971 } 14972 } 14973 } 14974 showpoint(ios); 14975 { 14976 ios.imbue(lc); 14977 { 14978 ios.width(0); 14979 { 14980 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14981 std::string ex(str, iter.base()); 14982 assert(ex == "-0.0"); 14983 assert(ios.width() == 0); 14984 } 14985 ios.width(25); 14986 left(ios); 14987 { 14988 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14989 std::string ex(str, iter.base()); 14990 assert(ex == "-0.0*********************"); 14991 assert(ios.width() == 0); 14992 } 14993 ios.width(25); 14994 right(ios); 14995 { 14996 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14997 std::string ex(str, iter.base()); 14998 assert(ex == "*********************-0.0"); 14999 assert(ios.width() == 0); 15000 } 15001 ios.width(25); 15002 internal(ios); 15003 { 15004 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15005 std::string ex(str, iter.base()); 15006 assert(ex == "-*********************0.0"); 15007 assert(ios.width() == 0); 15008 } 15009 } 15010 ios.imbue(lg); 15011 { 15012 ios.width(0); 15013 { 15014 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15015 std::string ex(str, iter.base()); 15016 assert(ex == "-0;0"); 15017 assert(ios.width() == 0); 15018 } 15019 ios.width(25); 15020 left(ios); 15021 { 15022 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15023 std::string ex(str, iter.base()); 15024 assert(ex == "-0;0*********************"); 15025 assert(ios.width() == 0); 15026 } 15027 ios.width(25); 15028 right(ios); 15029 { 15030 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15031 std::string ex(str, iter.base()); 15032 assert(ex == "*********************-0;0"); 15033 assert(ios.width() == 0); 15034 } 15035 ios.width(25); 15036 internal(ios); 15037 { 15038 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15039 std::string ex(str, iter.base()); 15040 assert(ex == "-*********************0;0"); 15041 assert(ios.width() == 0); 15042 } 15043 } 15044 } 15045 } 15046 showpos(ios); 15047 { 15048 noshowpoint(ios); 15049 { 15050 ios.imbue(lc); 15051 { 15052 ios.width(0); 15053 { 15054 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15055 std::string ex(str, iter.base()); 15056 assert(ex == "-0.0"); 15057 assert(ios.width() == 0); 15058 } 15059 ios.width(25); 15060 left(ios); 15061 { 15062 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15063 std::string ex(str, iter.base()); 15064 assert(ex == "-0.0*********************"); 15065 assert(ios.width() == 0); 15066 } 15067 ios.width(25); 15068 right(ios); 15069 { 15070 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15071 std::string ex(str, iter.base()); 15072 assert(ex == "*********************-0.0"); 15073 assert(ios.width() == 0); 15074 } 15075 ios.width(25); 15076 internal(ios); 15077 { 15078 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15079 std::string ex(str, iter.base()); 15080 assert(ex == "-*********************0.0"); 15081 assert(ios.width() == 0); 15082 } 15083 } 15084 ios.imbue(lg); 15085 { 15086 ios.width(0); 15087 { 15088 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15089 std::string ex(str, iter.base()); 15090 assert(ex == "-0;0"); 15091 assert(ios.width() == 0); 15092 } 15093 ios.width(25); 15094 left(ios); 15095 { 15096 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15097 std::string ex(str, iter.base()); 15098 assert(ex == "-0;0*********************"); 15099 assert(ios.width() == 0); 15100 } 15101 ios.width(25); 15102 right(ios); 15103 { 15104 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15105 std::string ex(str, iter.base()); 15106 assert(ex == "*********************-0;0"); 15107 assert(ios.width() == 0); 15108 } 15109 ios.width(25); 15110 internal(ios); 15111 { 15112 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15113 std::string ex(str, iter.base()); 15114 assert(ex == "-*********************0;0"); 15115 assert(ios.width() == 0); 15116 } 15117 } 15118 } 15119 showpoint(ios); 15120 { 15121 ios.imbue(lc); 15122 { 15123 ios.width(0); 15124 { 15125 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15126 std::string ex(str, iter.base()); 15127 assert(ex == "-0.0"); 15128 assert(ios.width() == 0); 15129 } 15130 ios.width(25); 15131 left(ios); 15132 { 15133 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15134 std::string ex(str, iter.base()); 15135 assert(ex == "-0.0*********************"); 15136 assert(ios.width() == 0); 15137 } 15138 ios.width(25); 15139 right(ios); 15140 { 15141 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15142 std::string ex(str, iter.base()); 15143 assert(ex == "*********************-0.0"); 15144 assert(ios.width() == 0); 15145 } 15146 ios.width(25); 15147 internal(ios); 15148 { 15149 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15150 std::string ex(str, iter.base()); 15151 assert(ex == "-*********************0.0"); 15152 assert(ios.width() == 0); 15153 } 15154 } 15155 ios.imbue(lg); 15156 { 15157 ios.width(0); 15158 { 15159 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15160 std::string ex(str, iter.base()); 15161 assert(ex == "-0;0"); 15162 assert(ios.width() == 0); 15163 } 15164 ios.width(25); 15165 left(ios); 15166 { 15167 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15168 std::string ex(str, iter.base()); 15169 assert(ex == "-0;0*********************"); 15170 assert(ios.width() == 0); 15171 } 15172 ios.width(25); 15173 right(ios); 15174 { 15175 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15176 std::string ex(str, iter.base()); 15177 assert(ex == "*********************-0;0"); 15178 assert(ios.width() == 0); 15179 } 15180 ios.width(25); 15181 internal(ios); 15182 { 15183 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15184 std::string ex(str, iter.base()); 15185 assert(ex == "-*********************0;0"); 15186 assert(ios.width() == 0); 15187 } 15188 } 15189 } 15190 } 15191 } 15192 uppercase(ios); 15193 { 15194 noshowpos(ios); 15195 { 15196 noshowpoint(ios); 15197 { 15198 ios.imbue(lc); 15199 { 15200 ios.width(0); 15201 { 15202 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15203 std::string ex(str, iter.base()); 15204 assert(ex == "-0.0"); 15205 assert(ios.width() == 0); 15206 } 15207 ios.width(25); 15208 left(ios); 15209 { 15210 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15211 std::string ex(str, iter.base()); 15212 assert(ex == "-0.0*********************"); 15213 assert(ios.width() == 0); 15214 } 15215 ios.width(25); 15216 right(ios); 15217 { 15218 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15219 std::string ex(str, iter.base()); 15220 assert(ex == "*********************-0.0"); 15221 assert(ios.width() == 0); 15222 } 15223 ios.width(25); 15224 internal(ios); 15225 { 15226 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15227 std::string ex(str, iter.base()); 15228 assert(ex == "-*********************0.0"); 15229 assert(ios.width() == 0); 15230 } 15231 } 15232 ios.imbue(lg); 15233 { 15234 ios.width(0); 15235 { 15236 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15237 std::string ex(str, iter.base()); 15238 assert(ex == "-0;0"); 15239 assert(ios.width() == 0); 15240 } 15241 ios.width(25); 15242 left(ios); 15243 { 15244 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15245 std::string ex(str, iter.base()); 15246 assert(ex == "-0;0*********************"); 15247 assert(ios.width() == 0); 15248 } 15249 ios.width(25); 15250 right(ios); 15251 { 15252 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15253 std::string ex(str, iter.base()); 15254 assert(ex == "*********************-0;0"); 15255 assert(ios.width() == 0); 15256 } 15257 ios.width(25); 15258 internal(ios); 15259 { 15260 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15261 std::string ex(str, iter.base()); 15262 assert(ex == "-*********************0;0"); 15263 assert(ios.width() == 0); 15264 } 15265 } 15266 } 15267 showpoint(ios); 15268 { 15269 ios.imbue(lc); 15270 { 15271 ios.width(0); 15272 { 15273 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15274 std::string ex(str, iter.base()); 15275 assert(ex == "-0.0"); 15276 assert(ios.width() == 0); 15277 } 15278 ios.width(25); 15279 left(ios); 15280 { 15281 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15282 std::string ex(str, iter.base()); 15283 assert(ex == "-0.0*********************"); 15284 assert(ios.width() == 0); 15285 } 15286 ios.width(25); 15287 right(ios); 15288 { 15289 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15290 std::string ex(str, iter.base()); 15291 assert(ex == "*********************-0.0"); 15292 assert(ios.width() == 0); 15293 } 15294 ios.width(25); 15295 internal(ios); 15296 { 15297 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15298 std::string ex(str, iter.base()); 15299 assert(ex == "-*********************0.0"); 15300 assert(ios.width() == 0); 15301 } 15302 } 15303 ios.imbue(lg); 15304 { 15305 ios.width(0); 15306 { 15307 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15308 std::string ex(str, iter.base()); 15309 assert(ex == "-0;0"); 15310 assert(ios.width() == 0); 15311 } 15312 ios.width(25); 15313 left(ios); 15314 { 15315 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15316 std::string ex(str, iter.base()); 15317 assert(ex == "-0;0*********************"); 15318 assert(ios.width() == 0); 15319 } 15320 ios.width(25); 15321 right(ios); 15322 { 15323 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15324 std::string ex(str, iter.base()); 15325 assert(ex == "*********************-0;0"); 15326 assert(ios.width() == 0); 15327 } 15328 ios.width(25); 15329 internal(ios); 15330 { 15331 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15332 std::string ex(str, iter.base()); 15333 assert(ex == "-*********************0;0"); 15334 assert(ios.width() == 0); 15335 } 15336 } 15337 } 15338 } 15339 showpos(ios); 15340 { 15341 noshowpoint(ios); 15342 { 15343 ios.imbue(lc); 15344 { 15345 ios.width(0); 15346 { 15347 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15348 std::string ex(str, iter.base()); 15349 assert(ex == "-0.0"); 15350 assert(ios.width() == 0); 15351 } 15352 ios.width(25); 15353 left(ios); 15354 { 15355 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15356 std::string ex(str, iter.base()); 15357 assert(ex == "-0.0*********************"); 15358 assert(ios.width() == 0); 15359 } 15360 ios.width(25); 15361 right(ios); 15362 { 15363 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15364 std::string ex(str, iter.base()); 15365 assert(ex == "*********************-0.0"); 15366 assert(ios.width() == 0); 15367 } 15368 ios.width(25); 15369 internal(ios); 15370 { 15371 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15372 std::string ex(str, iter.base()); 15373 assert(ex == "-*********************0.0"); 15374 assert(ios.width() == 0); 15375 } 15376 } 15377 ios.imbue(lg); 15378 { 15379 ios.width(0); 15380 { 15381 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15382 std::string ex(str, iter.base()); 15383 assert(ex == "-0;0"); 15384 assert(ios.width() == 0); 15385 } 15386 ios.width(25); 15387 left(ios); 15388 { 15389 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15390 std::string ex(str, iter.base()); 15391 assert(ex == "-0;0*********************"); 15392 assert(ios.width() == 0); 15393 } 15394 ios.width(25); 15395 right(ios); 15396 { 15397 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15398 std::string ex(str, iter.base()); 15399 assert(ex == "*********************-0;0"); 15400 assert(ios.width() == 0); 15401 } 15402 ios.width(25); 15403 internal(ios); 15404 { 15405 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15406 std::string ex(str, iter.base()); 15407 assert(ex == "-*********************0;0"); 15408 assert(ios.width() == 0); 15409 } 15410 } 15411 } 15412 showpoint(ios); 15413 { 15414 ios.imbue(lc); 15415 { 15416 ios.width(0); 15417 { 15418 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15419 std::string ex(str, iter.base()); 15420 assert(ex == "-0.0"); 15421 assert(ios.width() == 0); 15422 } 15423 ios.width(25); 15424 left(ios); 15425 { 15426 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15427 std::string ex(str, iter.base()); 15428 assert(ex == "-0.0*********************"); 15429 assert(ios.width() == 0); 15430 } 15431 ios.width(25); 15432 right(ios); 15433 { 15434 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15435 std::string ex(str, iter.base()); 15436 assert(ex == "*********************-0.0"); 15437 assert(ios.width() == 0); 15438 } 15439 ios.width(25); 15440 internal(ios); 15441 { 15442 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15443 std::string ex(str, iter.base()); 15444 assert(ex == "-*********************0.0"); 15445 assert(ios.width() == 0); 15446 } 15447 } 15448 ios.imbue(lg); 15449 { 15450 ios.width(0); 15451 { 15452 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15453 std::string ex(str, iter.base()); 15454 assert(ex == "-0;0"); 15455 assert(ios.width() == 0); 15456 } 15457 ios.width(25); 15458 left(ios); 15459 { 15460 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15461 std::string ex(str, iter.base()); 15462 assert(ex == "-0;0*********************"); 15463 assert(ios.width() == 0); 15464 } 15465 ios.width(25); 15466 right(ios); 15467 { 15468 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15469 std::string ex(str, iter.base()); 15470 assert(ex == "*********************-0;0"); 15471 assert(ios.width() == 0); 15472 } 15473 ios.width(25); 15474 internal(ios); 15475 { 15476 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15477 std::string ex(str, iter.base()); 15478 assert(ex == "-*********************0;0"); 15479 assert(ios.width() == 0); 15480 } 15481 } 15482 } 15483 } 15484 } 15485 } 15486 ios.precision(6); 15487 { 15488 nouppercase(ios); 15489 { 15490 noshowpos(ios); 15491 { 15492 noshowpoint(ios); 15493 { 15494 ios.imbue(lc); 15495 { 15496 ios.width(0); 15497 { 15498 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15499 std::string ex(str, iter.base()); 15500 assert(ex == "-0.000000"); 15501 assert(ios.width() == 0); 15502 } 15503 ios.width(25); 15504 left(ios); 15505 { 15506 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15507 std::string ex(str, iter.base()); 15508 assert(ex == "-0.000000****************"); 15509 assert(ios.width() == 0); 15510 } 15511 ios.width(25); 15512 right(ios); 15513 { 15514 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15515 std::string ex(str, iter.base()); 15516 assert(ex == "****************-0.000000"); 15517 assert(ios.width() == 0); 15518 } 15519 ios.width(25); 15520 internal(ios); 15521 { 15522 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15523 std::string ex(str, iter.base()); 15524 assert(ex == "-****************0.000000"); 15525 assert(ios.width() == 0); 15526 } 15527 } 15528 ios.imbue(lg); 15529 { 15530 ios.width(0); 15531 { 15532 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15533 std::string ex(str, iter.base()); 15534 assert(ex == "-0;000000"); 15535 assert(ios.width() == 0); 15536 } 15537 ios.width(25); 15538 left(ios); 15539 { 15540 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15541 std::string ex(str, iter.base()); 15542 assert(ex == "-0;000000****************"); 15543 assert(ios.width() == 0); 15544 } 15545 ios.width(25); 15546 right(ios); 15547 { 15548 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15549 std::string ex(str, iter.base()); 15550 assert(ex == "****************-0;000000"); 15551 assert(ios.width() == 0); 15552 } 15553 ios.width(25); 15554 internal(ios); 15555 { 15556 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15557 std::string ex(str, iter.base()); 15558 assert(ex == "-****************0;000000"); 15559 assert(ios.width() == 0); 15560 } 15561 } 15562 } 15563 showpoint(ios); 15564 { 15565 ios.imbue(lc); 15566 { 15567 ios.width(0); 15568 { 15569 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15570 std::string ex(str, iter.base()); 15571 assert(ex == "-0.000000"); 15572 assert(ios.width() == 0); 15573 } 15574 ios.width(25); 15575 left(ios); 15576 { 15577 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15578 std::string ex(str, iter.base()); 15579 assert(ex == "-0.000000****************"); 15580 assert(ios.width() == 0); 15581 } 15582 ios.width(25); 15583 right(ios); 15584 { 15585 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15586 std::string ex(str, iter.base()); 15587 assert(ex == "****************-0.000000"); 15588 assert(ios.width() == 0); 15589 } 15590 ios.width(25); 15591 internal(ios); 15592 { 15593 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15594 std::string ex(str, iter.base()); 15595 assert(ex == "-****************0.000000"); 15596 assert(ios.width() == 0); 15597 } 15598 } 15599 ios.imbue(lg); 15600 { 15601 ios.width(0); 15602 { 15603 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15604 std::string ex(str, iter.base()); 15605 assert(ex == "-0;000000"); 15606 assert(ios.width() == 0); 15607 } 15608 ios.width(25); 15609 left(ios); 15610 { 15611 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15612 std::string ex(str, iter.base()); 15613 assert(ex == "-0;000000****************"); 15614 assert(ios.width() == 0); 15615 } 15616 ios.width(25); 15617 right(ios); 15618 { 15619 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15620 std::string ex(str, iter.base()); 15621 assert(ex == "****************-0;000000"); 15622 assert(ios.width() == 0); 15623 } 15624 ios.width(25); 15625 internal(ios); 15626 { 15627 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15628 std::string ex(str, iter.base()); 15629 assert(ex == "-****************0;000000"); 15630 assert(ios.width() == 0); 15631 } 15632 } 15633 } 15634 } 15635 showpos(ios); 15636 { 15637 noshowpoint(ios); 15638 { 15639 ios.imbue(lc); 15640 { 15641 ios.width(0); 15642 { 15643 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15644 std::string ex(str, iter.base()); 15645 assert(ex == "-0.000000"); 15646 assert(ios.width() == 0); 15647 } 15648 ios.width(25); 15649 left(ios); 15650 { 15651 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15652 std::string ex(str, iter.base()); 15653 assert(ex == "-0.000000****************"); 15654 assert(ios.width() == 0); 15655 } 15656 ios.width(25); 15657 right(ios); 15658 { 15659 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15660 std::string ex(str, iter.base()); 15661 assert(ex == "****************-0.000000"); 15662 assert(ios.width() == 0); 15663 } 15664 ios.width(25); 15665 internal(ios); 15666 { 15667 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15668 std::string ex(str, iter.base()); 15669 assert(ex == "-****************0.000000"); 15670 assert(ios.width() == 0); 15671 } 15672 } 15673 ios.imbue(lg); 15674 { 15675 ios.width(0); 15676 { 15677 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15678 std::string ex(str, iter.base()); 15679 assert(ex == "-0;000000"); 15680 assert(ios.width() == 0); 15681 } 15682 ios.width(25); 15683 left(ios); 15684 { 15685 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15686 std::string ex(str, iter.base()); 15687 assert(ex == "-0;000000****************"); 15688 assert(ios.width() == 0); 15689 } 15690 ios.width(25); 15691 right(ios); 15692 { 15693 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15694 std::string ex(str, iter.base()); 15695 assert(ex == "****************-0;000000"); 15696 assert(ios.width() == 0); 15697 } 15698 ios.width(25); 15699 internal(ios); 15700 { 15701 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15702 std::string ex(str, iter.base()); 15703 assert(ex == "-****************0;000000"); 15704 assert(ios.width() == 0); 15705 } 15706 } 15707 } 15708 showpoint(ios); 15709 { 15710 ios.imbue(lc); 15711 { 15712 ios.width(0); 15713 { 15714 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15715 std::string ex(str, iter.base()); 15716 assert(ex == "-0.000000"); 15717 assert(ios.width() == 0); 15718 } 15719 ios.width(25); 15720 left(ios); 15721 { 15722 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15723 std::string ex(str, iter.base()); 15724 assert(ex == "-0.000000****************"); 15725 assert(ios.width() == 0); 15726 } 15727 ios.width(25); 15728 right(ios); 15729 { 15730 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15731 std::string ex(str, iter.base()); 15732 assert(ex == "****************-0.000000"); 15733 assert(ios.width() == 0); 15734 } 15735 ios.width(25); 15736 internal(ios); 15737 { 15738 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15739 std::string ex(str, iter.base()); 15740 assert(ex == "-****************0.000000"); 15741 assert(ios.width() == 0); 15742 } 15743 } 15744 ios.imbue(lg); 15745 { 15746 ios.width(0); 15747 { 15748 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15749 std::string ex(str, iter.base()); 15750 assert(ex == "-0;000000"); 15751 assert(ios.width() == 0); 15752 } 15753 ios.width(25); 15754 left(ios); 15755 { 15756 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15757 std::string ex(str, iter.base()); 15758 assert(ex == "-0;000000****************"); 15759 assert(ios.width() == 0); 15760 } 15761 ios.width(25); 15762 right(ios); 15763 { 15764 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15765 std::string ex(str, iter.base()); 15766 assert(ex == "****************-0;000000"); 15767 assert(ios.width() == 0); 15768 } 15769 ios.width(25); 15770 internal(ios); 15771 { 15772 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15773 std::string ex(str, iter.base()); 15774 assert(ex == "-****************0;000000"); 15775 assert(ios.width() == 0); 15776 } 15777 } 15778 } 15779 } 15780 } 15781 uppercase(ios); 15782 { 15783 noshowpos(ios); 15784 { 15785 noshowpoint(ios); 15786 { 15787 ios.imbue(lc); 15788 { 15789 ios.width(0); 15790 { 15791 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15792 std::string ex(str, iter.base()); 15793 assert(ex == "-0.000000"); 15794 assert(ios.width() == 0); 15795 } 15796 ios.width(25); 15797 left(ios); 15798 { 15799 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15800 std::string ex(str, iter.base()); 15801 assert(ex == "-0.000000****************"); 15802 assert(ios.width() == 0); 15803 } 15804 ios.width(25); 15805 right(ios); 15806 { 15807 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15808 std::string ex(str, iter.base()); 15809 assert(ex == "****************-0.000000"); 15810 assert(ios.width() == 0); 15811 } 15812 ios.width(25); 15813 internal(ios); 15814 { 15815 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15816 std::string ex(str, iter.base()); 15817 assert(ex == "-****************0.000000"); 15818 assert(ios.width() == 0); 15819 } 15820 } 15821 ios.imbue(lg); 15822 { 15823 ios.width(0); 15824 { 15825 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15826 std::string ex(str, iter.base()); 15827 assert(ex == "-0;000000"); 15828 assert(ios.width() == 0); 15829 } 15830 ios.width(25); 15831 left(ios); 15832 { 15833 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15834 std::string ex(str, iter.base()); 15835 assert(ex == "-0;000000****************"); 15836 assert(ios.width() == 0); 15837 } 15838 ios.width(25); 15839 right(ios); 15840 { 15841 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15842 std::string ex(str, iter.base()); 15843 assert(ex == "****************-0;000000"); 15844 assert(ios.width() == 0); 15845 } 15846 ios.width(25); 15847 internal(ios); 15848 { 15849 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15850 std::string ex(str, iter.base()); 15851 assert(ex == "-****************0;000000"); 15852 assert(ios.width() == 0); 15853 } 15854 } 15855 } 15856 showpoint(ios); 15857 { 15858 ios.imbue(lc); 15859 { 15860 ios.width(0); 15861 { 15862 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15863 std::string ex(str, iter.base()); 15864 assert(ex == "-0.000000"); 15865 assert(ios.width() == 0); 15866 } 15867 ios.width(25); 15868 left(ios); 15869 { 15870 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15871 std::string ex(str, iter.base()); 15872 assert(ex == "-0.000000****************"); 15873 assert(ios.width() == 0); 15874 } 15875 ios.width(25); 15876 right(ios); 15877 { 15878 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15879 std::string ex(str, iter.base()); 15880 assert(ex == "****************-0.000000"); 15881 assert(ios.width() == 0); 15882 } 15883 ios.width(25); 15884 internal(ios); 15885 { 15886 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15887 std::string ex(str, iter.base()); 15888 assert(ex == "-****************0.000000"); 15889 assert(ios.width() == 0); 15890 } 15891 } 15892 ios.imbue(lg); 15893 { 15894 ios.width(0); 15895 { 15896 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15897 std::string ex(str, iter.base()); 15898 assert(ex == "-0;000000"); 15899 assert(ios.width() == 0); 15900 } 15901 ios.width(25); 15902 left(ios); 15903 { 15904 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15905 std::string ex(str, iter.base()); 15906 assert(ex == "-0;000000****************"); 15907 assert(ios.width() == 0); 15908 } 15909 ios.width(25); 15910 right(ios); 15911 { 15912 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15913 std::string ex(str, iter.base()); 15914 assert(ex == "****************-0;000000"); 15915 assert(ios.width() == 0); 15916 } 15917 ios.width(25); 15918 internal(ios); 15919 { 15920 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15921 std::string ex(str, iter.base()); 15922 assert(ex == "-****************0;000000"); 15923 assert(ios.width() == 0); 15924 } 15925 } 15926 } 15927 } 15928 showpos(ios); 15929 { 15930 noshowpoint(ios); 15931 { 15932 ios.imbue(lc); 15933 { 15934 ios.width(0); 15935 { 15936 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15937 std::string ex(str, iter.base()); 15938 assert(ex == "-0.000000"); 15939 assert(ios.width() == 0); 15940 } 15941 ios.width(25); 15942 left(ios); 15943 { 15944 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15945 std::string ex(str, iter.base()); 15946 assert(ex == "-0.000000****************"); 15947 assert(ios.width() == 0); 15948 } 15949 ios.width(25); 15950 right(ios); 15951 { 15952 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15953 std::string ex(str, iter.base()); 15954 assert(ex == "****************-0.000000"); 15955 assert(ios.width() == 0); 15956 } 15957 ios.width(25); 15958 internal(ios); 15959 { 15960 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15961 std::string ex(str, iter.base()); 15962 assert(ex == "-****************0.000000"); 15963 assert(ios.width() == 0); 15964 } 15965 } 15966 ios.imbue(lg); 15967 { 15968 ios.width(0); 15969 { 15970 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15971 std::string ex(str, iter.base()); 15972 assert(ex == "-0;000000"); 15973 assert(ios.width() == 0); 15974 } 15975 ios.width(25); 15976 left(ios); 15977 { 15978 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15979 std::string ex(str, iter.base()); 15980 assert(ex == "-0;000000****************"); 15981 assert(ios.width() == 0); 15982 } 15983 ios.width(25); 15984 right(ios); 15985 { 15986 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15987 std::string ex(str, iter.base()); 15988 assert(ex == "****************-0;000000"); 15989 assert(ios.width() == 0); 15990 } 15991 ios.width(25); 15992 internal(ios); 15993 { 15994 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15995 std::string ex(str, iter.base()); 15996 assert(ex == "-****************0;000000"); 15997 assert(ios.width() == 0); 15998 } 15999 } 16000 } 16001 showpoint(ios); 16002 { 16003 ios.imbue(lc); 16004 { 16005 ios.width(0); 16006 { 16007 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16008 std::string ex(str, iter.base()); 16009 assert(ex == "-0.000000"); 16010 assert(ios.width() == 0); 16011 } 16012 ios.width(25); 16013 left(ios); 16014 { 16015 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16016 std::string ex(str, iter.base()); 16017 assert(ex == "-0.000000****************"); 16018 assert(ios.width() == 0); 16019 } 16020 ios.width(25); 16021 right(ios); 16022 { 16023 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16024 std::string ex(str, iter.base()); 16025 assert(ex == "****************-0.000000"); 16026 assert(ios.width() == 0); 16027 } 16028 ios.width(25); 16029 internal(ios); 16030 { 16031 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16032 std::string ex(str, iter.base()); 16033 assert(ex == "-****************0.000000"); 16034 assert(ios.width() == 0); 16035 } 16036 } 16037 ios.imbue(lg); 16038 { 16039 ios.width(0); 16040 { 16041 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16042 std::string ex(str, iter.base()); 16043 assert(ex == "-0;000000"); 16044 assert(ios.width() == 0); 16045 } 16046 ios.width(25); 16047 left(ios); 16048 { 16049 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16050 std::string ex(str, iter.base()); 16051 assert(ex == "-0;000000****************"); 16052 assert(ios.width() == 0); 16053 } 16054 ios.width(25); 16055 right(ios); 16056 { 16057 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16058 std::string ex(str, iter.base()); 16059 assert(ex == "****************-0;000000"); 16060 assert(ios.width() == 0); 16061 } 16062 ios.width(25); 16063 internal(ios); 16064 { 16065 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16066 std::string ex(str, iter.base()); 16067 assert(ex == "-****************0;000000"); 16068 assert(ios.width() == 0); 16069 } 16070 } 16071 } 16072 } 16073 } 16074 } 16075 ios.precision(16); 16076 { 16077 nouppercase(ios); 16078 { 16079 noshowpos(ios); 16080 { 16081 noshowpoint(ios); 16082 { 16083 ios.imbue(lc); 16084 { 16085 ios.width(0); 16086 { 16087 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16088 std::string ex(str, iter.base()); 16089 assert(ex == "-0.0000000000000000"); 16090 assert(ios.width() == 0); 16091 } 16092 ios.width(25); 16093 left(ios); 16094 { 16095 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16096 std::string ex(str, iter.base()); 16097 assert(ex == "-0.0000000000000000******"); 16098 assert(ios.width() == 0); 16099 } 16100 ios.width(25); 16101 right(ios); 16102 { 16103 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16104 std::string ex(str, iter.base()); 16105 assert(ex == "******-0.0000000000000000"); 16106 assert(ios.width() == 0); 16107 } 16108 ios.width(25); 16109 internal(ios); 16110 { 16111 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16112 std::string ex(str, iter.base()); 16113 assert(ex == "-******0.0000000000000000"); 16114 assert(ios.width() == 0); 16115 } 16116 } 16117 ios.imbue(lg); 16118 { 16119 ios.width(0); 16120 { 16121 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16122 std::string ex(str, iter.base()); 16123 assert(ex == "-0;0000000000000000"); 16124 assert(ios.width() == 0); 16125 } 16126 ios.width(25); 16127 left(ios); 16128 { 16129 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16130 std::string ex(str, iter.base()); 16131 assert(ex == "-0;0000000000000000******"); 16132 assert(ios.width() == 0); 16133 } 16134 ios.width(25); 16135 right(ios); 16136 { 16137 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16138 std::string ex(str, iter.base()); 16139 assert(ex == "******-0;0000000000000000"); 16140 assert(ios.width() == 0); 16141 } 16142 ios.width(25); 16143 internal(ios); 16144 { 16145 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16146 std::string ex(str, iter.base()); 16147 assert(ex == "-******0;0000000000000000"); 16148 assert(ios.width() == 0); 16149 } 16150 } 16151 } 16152 showpoint(ios); 16153 { 16154 ios.imbue(lc); 16155 { 16156 ios.width(0); 16157 { 16158 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16159 std::string ex(str, iter.base()); 16160 assert(ex == "-0.0000000000000000"); 16161 assert(ios.width() == 0); 16162 } 16163 ios.width(25); 16164 left(ios); 16165 { 16166 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16167 std::string ex(str, iter.base()); 16168 assert(ex == "-0.0000000000000000******"); 16169 assert(ios.width() == 0); 16170 } 16171 ios.width(25); 16172 right(ios); 16173 { 16174 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16175 std::string ex(str, iter.base()); 16176 assert(ex == "******-0.0000000000000000"); 16177 assert(ios.width() == 0); 16178 } 16179 ios.width(25); 16180 internal(ios); 16181 { 16182 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16183 std::string ex(str, iter.base()); 16184 assert(ex == "-******0.0000000000000000"); 16185 assert(ios.width() == 0); 16186 } 16187 } 16188 ios.imbue(lg); 16189 { 16190 ios.width(0); 16191 { 16192 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16193 std::string ex(str, iter.base()); 16194 assert(ex == "-0;0000000000000000"); 16195 assert(ios.width() == 0); 16196 } 16197 ios.width(25); 16198 left(ios); 16199 { 16200 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16201 std::string ex(str, iter.base()); 16202 assert(ex == "-0;0000000000000000******"); 16203 assert(ios.width() == 0); 16204 } 16205 ios.width(25); 16206 right(ios); 16207 { 16208 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16209 std::string ex(str, iter.base()); 16210 assert(ex == "******-0;0000000000000000"); 16211 assert(ios.width() == 0); 16212 } 16213 ios.width(25); 16214 internal(ios); 16215 { 16216 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16217 std::string ex(str, iter.base()); 16218 assert(ex == "-******0;0000000000000000"); 16219 assert(ios.width() == 0); 16220 } 16221 } 16222 } 16223 } 16224 showpos(ios); 16225 { 16226 noshowpoint(ios); 16227 { 16228 ios.imbue(lc); 16229 { 16230 ios.width(0); 16231 { 16232 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16233 std::string ex(str, iter.base()); 16234 assert(ex == "-0.0000000000000000"); 16235 assert(ios.width() == 0); 16236 } 16237 ios.width(25); 16238 left(ios); 16239 { 16240 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16241 std::string ex(str, iter.base()); 16242 assert(ex == "-0.0000000000000000******"); 16243 assert(ios.width() == 0); 16244 } 16245 ios.width(25); 16246 right(ios); 16247 { 16248 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16249 std::string ex(str, iter.base()); 16250 assert(ex == "******-0.0000000000000000"); 16251 assert(ios.width() == 0); 16252 } 16253 ios.width(25); 16254 internal(ios); 16255 { 16256 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16257 std::string ex(str, iter.base()); 16258 assert(ex == "-******0.0000000000000000"); 16259 assert(ios.width() == 0); 16260 } 16261 } 16262 ios.imbue(lg); 16263 { 16264 ios.width(0); 16265 { 16266 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16267 std::string ex(str, iter.base()); 16268 assert(ex == "-0;0000000000000000"); 16269 assert(ios.width() == 0); 16270 } 16271 ios.width(25); 16272 left(ios); 16273 { 16274 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16275 std::string ex(str, iter.base()); 16276 assert(ex == "-0;0000000000000000******"); 16277 assert(ios.width() == 0); 16278 } 16279 ios.width(25); 16280 right(ios); 16281 { 16282 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16283 std::string ex(str, iter.base()); 16284 assert(ex == "******-0;0000000000000000"); 16285 assert(ios.width() == 0); 16286 } 16287 ios.width(25); 16288 internal(ios); 16289 { 16290 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16291 std::string ex(str, iter.base()); 16292 assert(ex == "-******0;0000000000000000"); 16293 assert(ios.width() == 0); 16294 } 16295 } 16296 } 16297 showpoint(ios); 16298 { 16299 ios.imbue(lc); 16300 { 16301 ios.width(0); 16302 { 16303 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16304 std::string ex(str, iter.base()); 16305 assert(ex == "-0.0000000000000000"); 16306 assert(ios.width() == 0); 16307 } 16308 ios.width(25); 16309 left(ios); 16310 { 16311 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16312 std::string ex(str, iter.base()); 16313 assert(ex == "-0.0000000000000000******"); 16314 assert(ios.width() == 0); 16315 } 16316 ios.width(25); 16317 right(ios); 16318 { 16319 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16320 std::string ex(str, iter.base()); 16321 assert(ex == "******-0.0000000000000000"); 16322 assert(ios.width() == 0); 16323 } 16324 ios.width(25); 16325 internal(ios); 16326 { 16327 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16328 std::string ex(str, iter.base()); 16329 assert(ex == "-******0.0000000000000000"); 16330 assert(ios.width() == 0); 16331 } 16332 } 16333 ios.imbue(lg); 16334 { 16335 ios.width(0); 16336 { 16337 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16338 std::string ex(str, iter.base()); 16339 assert(ex == "-0;0000000000000000"); 16340 assert(ios.width() == 0); 16341 } 16342 ios.width(25); 16343 left(ios); 16344 { 16345 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16346 std::string ex(str, iter.base()); 16347 assert(ex == "-0;0000000000000000******"); 16348 assert(ios.width() == 0); 16349 } 16350 ios.width(25); 16351 right(ios); 16352 { 16353 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16354 std::string ex(str, iter.base()); 16355 assert(ex == "******-0;0000000000000000"); 16356 assert(ios.width() == 0); 16357 } 16358 ios.width(25); 16359 internal(ios); 16360 { 16361 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16362 std::string ex(str, iter.base()); 16363 assert(ex == "-******0;0000000000000000"); 16364 assert(ios.width() == 0); 16365 } 16366 } 16367 } 16368 } 16369 } 16370 uppercase(ios); 16371 { 16372 noshowpos(ios); 16373 { 16374 noshowpoint(ios); 16375 { 16376 ios.imbue(lc); 16377 { 16378 ios.width(0); 16379 { 16380 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16381 std::string ex(str, iter.base()); 16382 assert(ex == "-0.0000000000000000"); 16383 assert(ios.width() == 0); 16384 } 16385 ios.width(25); 16386 left(ios); 16387 { 16388 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16389 std::string ex(str, iter.base()); 16390 assert(ex == "-0.0000000000000000******"); 16391 assert(ios.width() == 0); 16392 } 16393 ios.width(25); 16394 right(ios); 16395 { 16396 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16397 std::string ex(str, iter.base()); 16398 assert(ex == "******-0.0000000000000000"); 16399 assert(ios.width() == 0); 16400 } 16401 ios.width(25); 16402 internal(ios); 16403 { 16404 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16405 std::string ex(str, iter.base()); 16406 assert(ex == "-******0.0000000000000000"); 16407 assert(ios.width() == 0); 16408 } 16409 } 16410 ios.imbue(lg); 16411 { 16412 ios.width(0); 16413 { 16414 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16415 std::string ex(str, iter.base()); 16416 assert(ex == "-0;0000000000000000"); 16417 assert(ios.width() == 0); 16418 } 16419 ios.width(25); 16420 left(ios); 16421 { 16422 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16423 std::string ex(str, iter.base()); 16424 assert(ex == "-0;0000000000000000******"); 16425 assert(ios.width() == 0); 16426 } 16427 ios.width(25); 16428 right(ios); 16429 { 16430 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16431 std::string ex(str, iter.base()); 16432 assert(ex == "******-0;0000000000000000"); 16433 assert(ios.width() == 0); 16434 } 16435 ios.width(25); 16436 internal(ios); 16437 { 16438 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16439 std::string ex(str, iter.base()); 16440 assert(ex == "-******0;0000000000000000"); 16441 assert(ios.width() == 0); 16442 } 16443 } 16444 } 16445 showpoint(ios); 16446 { 16447 ios.imbue(lc); 16448 { 16449 ios.width(0); 16450 { 16451 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16452 std::string ex(str, iter.base()); 16453 assert(ex == "-0.0000000000000000"); 16454 assert(ios.width() == 0); 16455 } 16456 ios.width(25); 16457 left(ios); 16458 { 16459 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16460 std::string ex(str, iter.base()); 16461 assert(ex == "-0.0000000000000000******"); 16462 assert(ios.width() == 0); 16463 } 16464 ios.width(25); 16465 right(ios); 16466 { 16467 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16468 std::string ex(str, iter.base()); 16469 assert(ex == "******-0.0000000000000000"); 16470 assert(ios.width() == 0); 16471 } 16472 ios.width(25); 16473 internal(ios); 16474 { 16475 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16476 std::string ex(str, iter.base()); 16477 assert(ex == "-******0.0000000000000000"); 16478 assert(ios.width() == 0); 16479 } 16480 } 16481 ios.imbue(lg); 16482 { 16483 ios.width(0); 16484 { 16485 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16486 std::string ex(str, iter.base()); 16487 assert(ex == "-0;0000000000000000"); 16488 assert(ios.width() == 0); 16489 } 16490 ios.width(25); 16491 left(ios); 16492 { 16493 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16494 std::string ex(str, iter.base()); 16495 assert(ex == "-0;0000000000000000******"); 16496 assert(ios.width() == 0); 16497 } 16498 ios.width(25); 16499 right(ios); 16500 { 16501 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16502 std::string ex(str, iter.base()); 16503 assert(ex == "******-0;0000000000000000"); 16504 assert(ios.width() == 0); 16505 } 16506 ios.width(25); 16507 internal(ios); 16508 { 16509 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16510 std::string ex(str, iter.base()); 16511 assert(ex == "-******0;0000000000000000"); 16512 assert(ios.width() == 0); 16513 } 16514 } 16515 } 16516 } 16517 showpos(ios); 16518 { 16519 noshowpoint(ios); 16520 { 16521 ios.imbue(lc); 16522 { 16523 ios.width(0); 16524 { 16525 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16526 std::string ex(str, iter.base()); 16527 assert(ex == "-0.0000000000000000"); 16528 assert(ios.width() == 0); 16529 } 16530 ios.width(25); 16531 left(ios); 16532 { 16533 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16534 std::string ex(str, iter.base()); 16535 assert(ex == "-0.0000000000000000******"); 16536 assert(ios.width() == 0); 16537 } 16538 ios.width(25); 16539 right(ios); 16540 { 16541 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16542 std::string ex(str, iter.base()); 16543 assert(ex == "******-0.0000000000000000"); 16544 assert(ios.width() == 0); 16545 } 16546 ios.width(25); 16547 internal(ios); 16548 { 16549 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16550 std::string ex(str, iter.base()); 16551 assert(ex == "-******0.0000000000000000"); 16552 assert(ios.width() == 0); 16553 } 16554 } 16555 ios.imbue(lg); 16556 { 16557 ios.width(0); 16558 { 16559 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16560 std::string ex(str, iter.base()); 16561 assert(ex == "-0;0000000000000000"); 16562 assert(ios.width() == 0); 16563 } 16564 ios.width(25); 16565 left(ios); 16566 { 16567 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16568 std::string ex(str, iter.base()); 16569 assert(ex == "-0;0000000000000000******"); 16570 assert(ios.width() == 0); 16571 } 16572 ios.width(25); 16573 right(ios); 16574 { 16575 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16576 std::string ex(str, iter.base()); 16577 assert(ex == "******-0;0000000000000000"); 16578 assert(ios.width() == 0); 16579 } 16580 ios.width(25); 16581 internal(ios); 16582 { 16583 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16584 std::string ex(str, iter.base()); 16585 assert(ex == "-******0;0000000000000000"); 16586 assert(ios.width() == 0); 16587 } 16588 } 16589 } 16590 showpoint(ios); 16591 { 16592 ios.imbue(lc); 16593 { 16594 ios.width(0); 16595 { 16596 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16597 std::string ex(str, iter.base()); 16598 assert(ex == "-0.0000000000000000"); 16599 assert(ios.width() == 0); 16600 } 16601 ios.width(25); 16602 left(ios); 16603 { 16604 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16605 std::string ex(str, iter.base()); 16606 assert(ex == "-0.0000000000000000******"); 16607 assert(ios.width() == 0); 16608 } 16609 ios.width(25); 16610 right(ios); 16611 { 16612 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16613 std::string ex(str, iter.base()); 16614 assert(ex == "******-0.0000000000000000"); 16615 assert(ios.width() == 0); 16616 } 16617 ios.width(25); 16618 internal(ios); 16619 { 16620 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16621 std::string ex(str, iter.base()); 16622 assert(ex == "-******0.0000000000000000"); 16623 assert(ios.width() == 0); 16624 } 16625 } 16626 ios.imbue(lg); 16627 { 16628 ios.width(0); 16629 { 16630 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16631 std::string ex(str, iter.base()); 16632 assert(ex == "-0;0000000000000000"); 16633 assert(ios.width() == 0); 16634 } 16635 ios.width(25); 16636 left(ios); 16637 { 16638 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16639 std::string ex(str, iter.base()); 16640 assert(ex == "-0;0000000000000000******"); 16641 assert(ios.width() == 0); 16642 } 16643 ios.width(25); 16644 right(ios); 16645 { 16646 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16647 std::string ex(str, iter.base()); 16648 assert(ex == "******-0;0000000000000000"); 16649 assert(ios.width() == 0); 16650 } 16651 ios.width(25); 16652 internal(ios); 16653 { 16654 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16655 std::string ex(str, iter.base()); 16656 assert(ex == "-******0;0000000000000000"); 16657 assert(ios.width() == 0); 16658 } 16659 } 16660 } 16661 } 16662 } 16663 } 16664 ios.precision(60); 16665 { 16666 nouppercase(ios); 16667 { 16668 noshowpos(ios); 16669 { 16670 noshowpoint(ios); 16671 { 16672 ios.imbue(lc); 16673 { 16674 ios.width(0); 16675 { 16676 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16677 std::string ex(str, iter.base()); 16678 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16679 assert(ios.width() == 0); 16680 } 16681 ios.width(25); 16682 left(ios); 16683 { 16684 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16685 std::string ex(str, iter.base()); 16686 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16687 assert(ios.width() == 0); 16688 } 16689 ios.width(25); 16690 right(ios); 16691 { 16692 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16693 std::string ex(str, iter.base()); 16694 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16695 assert(ios.width() == 0); 16696 } 16697 ios.width(25); 16698 internal(ios); 16699 { 16700 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16701 std::string ex(str, iter.base()); 16702 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16703 assert(ios.width() == 0); 16704 } 16705 } 16706 ios.imbue(lg); 16707 { 16708 ios.width(0); 16709 { 16710 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16711 std::string ex(str, iter.base()); 16712 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16713 assert(ios.width() == 0); 16714 } 16715 ios.width(25); 16716 left(ios); 16717 { 16718 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16719 std::string ex(str, iter.base()); 16720 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16721 assert(ios.width() == 0); 16722 } 16723 ios.width(25); 16724 right(ios); 16725 { 16726 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16727 std::string ex(str, iter.base()); 16728 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16729 assert(ios.width() == 0); 16730 } 16731 ios.width(25); 16732 internal(ios); 16733 { 16734 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16735 std::string ex(str, iter.base()); 16736 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16737 assert(ios.width() == 0); 16738 } 16739 } 16740 } 16741 showpoint(ios); 16742 { 16743 ios.imbue(lc); 16744 { 16745 ios.width(0); 16746 { 16747 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16748 std::string ex(str, iter.base()); 16749 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16750 assert(ios.width() == 0); 16751 } 16752 ios.width(25); 16753 left(ios); 16754 { 16755 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16756 std::string ex(str, iter.base()); 16757 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16758 assert(ios.width() == 0); 16759 } 16760 ios.width(25); 16761 right(ios); 16762 { 16763 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16764 std::string ex(str, iter.base()); 16765 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16766 assert(ios.width() == 0); 16767 } 16768 ios.width(25); 16769 internal(ios); 16770 { 16771 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16772 std::string ex(str, iter.base()); 16773 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16774 assert(ios.width() == 0); 16775 } 16776 } 16777 ios.imbue(lg); 16778 { 16779 ios.width(0); 16780 { 16781 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16782 std::string ex(str, iter.base()); 16783 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16784 assert(ios.width() == 0); 16785 } 16786 ios.width(25); 16787 left(ios); 16788 { 16789 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16790 std::string ex(str, iter.base()); 16791 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16792 assert(ios.width() == 0); 16793 } 16794 ios.width(25); 16795 right(ios); 16796 { 16797 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16798 std::string ex(str, iter.base()); 16799 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16800 assert(ios.width() == 0); 16801 } 16802 ios.width(25); 16803 internal(ios); 16804 { 16805 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16806 std::string ex(str, iter.base()); 16807 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16808 assert(ios.width() == 0); 16809 } 16810 } 16811 } 16812 } 16813 showpos(ios); 16814 { 16815 noshowpoint(ios); 16816 { 16817 ios.imbue(lc); 16818 { 16819 ios.width(0); 16820 { 16821 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16822 std::string ex(str, iter.base()); 16823 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16824 assert(ios.width() == 0); 16825 } 16826 ios.width(25); 16827 left(ios); 16828 { 16829 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16830 std::string ex(str, iter.base()); 16831 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16832 assert(ios.width() == 0); 16833 } 16834 ios.width(25); 16835 right(ios); 16836 { 16837 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16838 std::string ex(str, iter.base()); 16839 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16840 assert(ios.width() == 0); 16841 } 16842 ios.width(25); 16843 internal(ios); 16844 { 16845 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16846 std::string ex(str, iter.base()); 16847 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16848 assert(ios.width() == 0); 16849 } 16850 } 16851 ios.imbue(lg); 16852 { 16853 ios.width(0); 16854 { 16855 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16856 std::string ex(str, iter.base()); 16857 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16858 assert(ios.width() == 0); 16859 } 16860 ios.width(25); 16861 left(ios); 16862 { 16863 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16864 std::string ex(str, iter.base()); 16865 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16866 assert(ios.width() == 0); 16867 } 16868 ios.width(25); 16869 right(ios); 16870 { 16871 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16872 std::string ex(str, iter.base()); 16873 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16874 assert(ios.width() == 0); 16875 } 16876 ios.width(25); 16877 internal(ios); 16878 { 16879 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16880 std::string ex(str, iter.base()); 16881 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16882 assert(ios.width() == 0); 16883 } 16884 } 16885 } 16886 showpoint(ios); 16887 { 16888 ios.imbue(lc); 16889 { 16890 ios.width(0); 16891 { 16892 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16893 std::string ex(str, iter.base()); 16894 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16895 assert(ios.width() == 0); 16896 } 16897 ios.width(25); 16898 left(ios); 16899 { 16900 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16901 std::string ex(str, iter.base()); 16902 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16903 assert(ios.width() == 0); 16904 } 16905 ios.width(25); 16906 right(ios); 16907 { 16908 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16909 std::string ex(str, iter.base()); 16910 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16911 assert(ios.width() == 0); 16912 } 16913 ios.width(25); 16914 internal(ios); 16915 { 16916 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16917 std::string ex(str, iter.base()); 16918 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16919 assert(ios.width() == 0); 16920 } 16921 } 16922 ios.imbue(lg); 16923 { 16924 ios.width(0); 16925 { 16926 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16927 std::string ex(str, iter.base()); 16928 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16929 assert(ios.width() == 0); 16930 } 16931 ios.width(25); 16932 left(ios); 16933 { 16934 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16935 std::string ex(str, iter.base()); 16936 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16937 assert(ios.width() == 0); 16938 } 16939 ios.width(25); 16940 right(ios); 16941 { 16942 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16943 std::string ex(str, iter.base()); 16944 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16945 assert(ios.width() == 0); 16946 } 16947 ios.width(25); 16948 internal(ios); 16949 { 16950 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16951 std::string ex(str, iter.base()); 16952 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16953 assert(ios.width() == 0); 16954 } 16955 } 16956 } 16957 } 16958 } 16959 uppercase(ios); 16960 { 16961 noshowpos(ios); 16962 { 16963 noshowpoint(ios); 16964 { 16965 ios.imbue(lc); 16966 { 16967 ios.width(0); 16968 { 16969 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16970 std::string ex(str, iter.base()); 16971 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16972 assert(ios.width() == 0); 16973 } 16974 ios.width(25); 16975 left(ios); 16976 { 16977 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16978 std::string ex(str, iter.base()); 16979 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16980 assert(ios.width() == 0); 16981 } 16982 ios.width(25); 16983 right(ios); 16984 { 16985 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16986 std::string ex(str, iter.base()); 16987 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16988 assert(ios.width() == 0); 16989 } 16990 ios.width(25); 16991 internal(ios); 16992 { 16993 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16994 std::string ex(str, iter.base()); 16995 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16996 assert(ios.width() == 0); 16997 } 16998 } 16999 ios.imbue(lg); 17000 { 17001 ios.width(0); 17002 { 17003 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17004 std::string ex(str, iter.base()); 17005 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17006 assert(ios.width() == 0); 17007 } 17008 ios.width(25); 17009 left(ios); 17010 { 17011 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17012 std::string ex(str, iter.base()); 17013 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17014 assert(ios.width() == 0); 17015 } 17016 ios.width(25); 17017 right(ios); 17018 { 17019 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17020 std::string ex(str, iter.base()); 17021 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17022 assert(ios.width() == 0); 17023 } 17024 ios.width(25); 17025 internal(ios); 17026 { 17027 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17028 std::string ex(str, iter.base()); 17029 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17030 assert(ios.width() == 0); 17031 } 17032 } 17033 } 17034 showpoint(ios); 17035 { 17036 ios.imbue(lc); 17037 { 17038 ios.width(0); 17039 { 17040 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17041 std::string ex(str, iter.base()); 17042 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17043 assert(ios.width() == 0); 17044 } 17045 ios.width(25); 17046 left(ios); 17047 { 17048 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17049 std::string ex(str, iter.base()); 17050 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17051 assert(ios.width() == 0); 17052 } 17053 ios.width(25); 17054 right(ios); 17055 { 17056 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17057 std::string ex(str, iter.base()); 17058 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17059 assert(ios.width() == 0); 17060 } 17061 ios.width(25); 17062 internal(ios); 17063 { 17064 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17065 std::string ex(str, iter.base()); 17066 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17067 assert(ios.width() == 0); 17068 } 17069 } 17070 ios.imbue(lg); 17071 { 17072 ios.width(0); 17073 { 17074 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17075 std::string ex(str, iter.base()); 17076 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17077 assert(ios.width() == 0); 17078 } 17079 ios.width(25); 17080 left(ios); 17081 { 17082 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17083 std::string ex(str, iter.base()); 17084 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17085 assert(ios.width() == 0); 17086 } 17087 ios.width(25); 17088 right(ios); 17089 { 17090 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17091 std::string ex(str, iter.base()); 17092 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17093 assert(ios.width() == 0); 17094 } 17095 ios.width(25); 17096 internal(ios); 17097 { 17098 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17099 std::string ex(str, iter.base()); 17100 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17101 assert(ios.width() == 0); 17102 } 17103 } 17104 } 17105 } 17106 showpos(ios); 17107 { 17108 noshowpoint(ios); 17109 { 17110 ios.imbue(lc); 17111 { 17112 ios.width(0); 17113 { 17114 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17115 std::string ex(str, iter.base()); 17116 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17117 assert(ios.width() == 0); 17118 } 17119 ios.width(25); 17120 left(ios); 17121 { 17122 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17123 std::string ex(str, iter.base()); 17124 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17125 assert(ios.width() == 0); 17126 } 17127 ios.width(25); 17128 right(ios); 17129 { 17130 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17131 std::string ex(str, iter.base()); 17132 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17133 assert(ios.width() == 0); 17134 } 17135 ios.width(25); 17136 internal(ios); 17137 { 17138 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17139 std::string ex(str, iter.base()); 17140 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17141 assert(ios.width() == 0); 17142 } 17143 } 17144 ios.imbue(lg); 17145 { 17146 ios.width(0); 17147 { 17148 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17149 std::string ex(str, iter.base()); 17150 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17151 assert(ios.width() == 0); 17152 } 17153 ios.width(25); 17154 left(ios); 17155 { 17156 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17157 std::string ex(str, iter.base()); 17158 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17159 assert(ios.width() == 0); 17160 } 17161 ios.width(25); 17162 right(ios); 17163 { 17164 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17165 std::string ex(str, iter.base()); 17166 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17167 assert(ios.width() == 0); 17168 } 17169 ios.width(25); 17170 internal(ios); 17171 { 17172 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17173 std::string ex(str, iter.base()); 17174 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17175 assert(ios.width() == 0); 17176 } 17177 } 17178 } 17179 showpoint(ios); 17180 { 17181 ios.imbue(lc); 17182 { 17183 ios.width(0); 17184 { 17185 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17186 std::string ex(str, iter.base()); 17187 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17188 assert(ios.width() == 0); 17189 } 17190 ios.width(25); 17191 left(ios); 17192 { 17193 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17194 std::string ex(str, iter.base()); 17195 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17196 assert(ios.width() == 0); 17197 } 17198 ios.width(25); 17199 right(ios); 17200 { 17201 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17202 std::string ex(str, iter.base()); 17203 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17204 assert(ios.width() == 0); 17205 } 17206 ios.width(25); 17207 internal(ios); 17208 { 17209 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17210 std::string ex(str, iter.base()); 17211 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17212 assert(ios.width() == 0); 17213 } 17214 } 17215 ios.imbue(lg); 17216 { 17217 ios.width(0); 17218 { 17219 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17220 std::string ex(str, iter.base()); 17221 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17222 assert(ios.width() == 0); 17223 } 17224 ios.width(25); 17225 left(ios); 17226 { 17227 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17228 std::string ex(str, iter.base()); 17229 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17230 assert(ios.width() == 0); 17231 } 17232 ios.width(25); 17233 right(ios); 17234 { 17235 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17236 std::string ex(str, iter.base()); 17237 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17238 assert(ios.width() == 0); 17239 } 17240 ios.width(25); 17241 internal(ios); 17242 { 17243 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17244 std::string ex(str, iter.base()); 17245 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17246 assert(ios.width() == 0); 17247 } 17248 } 17249 } 17250 } 17251 } 17252 } 17253 } 17254 } 17255 } 17256 17257 void test8() 17258 { 17259 char str[200]; 17260 output_iterator<char*> iter; 17261 std::locale lc = std::locale::classic(); 17262 std::locale lg(lc, new my_numpunct); 17263 const my_facet f(1); 17264 { 17265 long double v = 1234567890.125; 17266 std::ios ios(0); 17267 fixed(ios); 17268 // %f 17269 { 17270 ios.precision(0); 17271 { 17272 nouppercase(ios); 17273 { 17274 noshowpos(ios); 17275 { 17276 noshowpoint(ios); 17277 { 17278 ios.imbue(lc); 17279 { 17280 ios.width(0); 17281 { 17282 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17283 std::string ex(str, iter.base()); 17284 assert(ex == "1234567890"); 17285 assert(ios.width() == 0); 17286 } 17287 ios.width(25); 17288 left(ios); 17289 { 17290 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17291 std::string ex(str, iter.base()); 17292 assert(ex == "1234567890***************"); 17293 assert(ios.width() == 0); 17294 } 17295 ios.width(25); 17296 right(ios); 17297 { 17298 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17299 std::string ex(str, iter.base()); 17300 assert(ex == "***************1234567890"); 17301 assert(ios.width() == 0); 17302 } 17303 ios.width(25); 17304 internal(ios); 17305 { 17306 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17307 std::string ex(str, iter.base()); 17308 assert(ex == "***************1234567890"); 17309 assert(ios.width() == 0); 17310 } 17311 } 17312 ios.imbue(lg); 17313 { 17314 ios.width(0); 17315 { 17316 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17317 std::string ex(str, iter.base()); 17318 assert(ex == "1_234_567_89_0"); 17319 assert(ios.width() == 0); 17320 } 17321 ios.width(25); 17322 left(ios); 17323 { 17324 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17325 std::string ex(str, iter.base()); 17326 assert(ex == "1_234_567_89_0***********"); 17327 assert(ios.width() == 0); 17328 } 17329 ios.width(25); 17330 right(ios); 17331 { 17332 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17333 std::string ex(str, iter.base()); 17334 assert(ex == "***********1_234_567_89_0"); 17335 assert(ios.width() == 0); 17336 } 17337 ios.width(25); 17338 internal(ios); 17339 { 17340 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17341 std::string ex(str, iter.base()); 17342 assert(ex == "***********1_234_567_89_0"); 17343 assert(ios.width() == 0); 17344 } 17345 } 17346 } 17347 showpoint(ios); 17348 { 17349 ios.imbue(lc); 17350 { 17351 ios.width(0); 17352 { 17353 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17354 std::string ex(str, iter.base()); 17355 assert(ex == "1234567890."); 17356 assert(ios.width() == 0); 17357 } 17358 ios.width(25); 17359 left(ios); 17360 { 17361 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17362 std::string ex(str, iter.base()); 17363 assert(ex == "1234567890.**************"); 17364 assert(ios.width() == 0); 17365 } 17366 ios.width(25); 17367 right(ios); 17368 { 17369 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17370 std::string ex(str, iter.base()); 17371 assert(ex == "**************1234567890."); 17372 assert(ios.width() == 0); 17373 } 17374 ios.width(25); 17375 internal(ios); 17376 { 17377 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17378 std::string ex(str, iter.base()); 17379 assert(ex == "**************1234567890."); 17380 assert(ios.width() == 0); 17381 } 17382 } 17383 ios.imbue(lg); 17384 { 17385 ios.width(0); 17386 { 17387 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17388 std::string ex(str, iter.base()); 17389 assert(ex == "1_234_567_89_0;"); 17390 assert(ios.width() == 0); 17391 } 17392 ios.width(25); 17393 left(ios); 17394 { 17395 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17396 std::string ex(str, iter.base()); 17397 assert(ex == "1_234_567_89_0;**********"); 17398 assert(ios.width() == 0); 17399 } 17400 ios.width(25); 17401 right(ios); 17402 { 17403 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17404 std::string ex(str, iter.base()); 17405 assert(ex == "**********1_234_567_89_0;"); 17406 assert(ios.width() == 0); 17407 } 17408 ios.width(25); 17409 internal(ios); 17410 { 17411 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17412 std::string ex(str, iter.base()); 17413 assert(ex == "**********1_234_567_89_0;"); 17414 assert(ios.width() == 0); 17415 } 17416 } 17417 } 17418 } 17419 showpos(ios); 17420 { 17421 noshowpoint(ios); 17422 { 17423 ios.imbue(lc); 17424 { 17425 ios.width(0); 17426 { 17427 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17428 std::string ex(str, iter.base()); 17429 assert(ex == "+1234567890"); 17430 assert(ios.width() == 0); 17431 } 17432 ios.width(25); 17433 left(ios); 17434 { 17435 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17436 std::string ex(str, iter.base()); 17437 assert(ex == "+1234567890**************"); 17438 assert(ios.width() == 0); 17439 } 17440 ios.width(25); 17441 right(ios); 17442 { 17443 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17444 std::string ex(str, iter.base()); 17445 assert(ex == "**************+1234567890"); 17446 assert(ios.width() == 0); 17447 } 17448 ios.width(25); 17449 internal(ios); 17450 { 17451 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17452 std::string ex(str, iter.base()); 17453 assert(ex == "+**************1234567890"); 17454 assert(ios.width() == 0); 17455 } 17456 } 17457 ios.imbue(lg); 17458 { 17459 ios.width(0); 17460 { 17461 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17462 std::string ex(str, iter.base()); 17463 assert(ex == "+1_234_567_89_0"); 17464 assert(ios.width() == 0); 17465 } 17466 ios.width(25); 17467 left(ios); 17468 { 17469 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17470 std::string ex(str, iter.base()); 17471 assert(ex == "+1_234_567_89_0**********"); 17472 assert(ios.width() == 0); 17473 } 17474 ios.width(25); 17475 right(ios); 17476 { 17477 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17478 std::string ex(str, iter.base()); 17479 assert(ex == "**********+1_234_567_89_0"); 17480 assert(ios.width() == 0); 17481 } 17482 ios.width(25); 17483 internal(ios); 17484 { 17485 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17486 std::string ex(str, iter.base()); 17487 assert(ex == "+**********1_234_567_89_0"); 17488 assert(ios.width() == 0); 17489 } 17490 } 17491 } 17492 showpoint(ios); 17493 { 17494 ios.imbue(lc); 17495 { 17496 ios.width(0); 17497 { 17498 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17499 std::string ex(str, iter.base()); 17500 assert(ex == "+1234567890."); 17501 assert(ios.width() == 0); 17502 } 17503 ios.width(25); 17504 left(ios); 17505 { 17506 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17507 std::string ex(str, iter.base()); 17508 assert(ex == "+1234567890.*************"); 17509 assert(ios.width() == 0); 17510 } 17511 ios.width(25); 17512 right(ios); 17513 { 17514 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17515 std::string ex(str, iter.base()); 17516 assert(ex == "*************+1234567890."); 17517 assert(ios.width() == 0); 17518 } 17519 ios.width(25); 17520 internal(ios); 17521 { 17522 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17523 std::string ex(str, iter.base()); 17524 assert(ex == "+*************1234567890."); 17525 assert(ios.width() == 0); 17526 } 17527 } 17528 ios.imbue(lg); 17529 { 17530 ios.width(0); 17531 { 17532 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17533 std::string ex(str, iter.base()); 17534 assert(ex == "+1_234_567_89_0;"); 17535 assert(ios.width() == 0); 17536 } 17537 ios.width(25); 17538 left(ios); 17539 { 17540 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17541 std::string ex(str, iter.base()); 17542 assert(ex == "+1_234_567_89_0;*********"); 17543 assert(ios.width() == 0); 17544 } 17545 ios.width(25); 17546 right(ios); 17547 { 17548 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17549 std::string ex(str, iter.base()); 17550 assert(ex == "*********+1_234_567_89_0;"); 17551 assert(ios.width() == 0); 17552 } 17553 ios.width(25); 17554 internal(ios); 17555 { 17556 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17557 std::string ex(str, iter.base()); 17558 assert(ex == "+*********1_234_567_89_0;"); 17559 assert(ios.width() == 0); 17560 } 17561 } 17562 } 17563 } 17564 } 17565 uppercase(ios); 17566 { 17567 noshowpos(ios); 17568 { 17569 noshowpoint(ios); 17570 { 17571 ios.imbue(lc); 17572 { 17573 ios.width(0); 17574 { 17575 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17576 std::string ex(str, iter.base()); 17577 assert(ex == "1234567890"); 17578 assert(ios.width() == 0); 17579 } 17580 ios.width(25); 17581 left(ios); 17582 { 17583 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17584 std::string ex(str, iter.base()); 17585 assert(ex == "1234567890***************"); 17586 assert(ios.width() == 0); 17587 } 17588 ios.width(25); 17589 right(ios); 17590 { 17591 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17592 std::string ex(str, iter.base()); 17593 assert(ex == "***************1234567890"); 17594 assert(ios.width() == 0); 17595 } 17596 ios.width(25); 17597 internal(ios); 17598 { 17599 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17600 std::string ex(str, iter.base()); 17601 assert(ex == "***************1234567890"); 17602 assert(ios.width() == 0); 17603 } 17604 } 17605 ios.imbue(lg); 17606 { 17607 ios.width(0); 17608 { 17609 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17610 std::string ex(str, iter.base()); 17611 assert(ex == "1_234_567_89_0"); 17612 assert(ios.width() == 0); 17613 } 17614 ios.width(25); 17615 left(ios); 17616 { 17617 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17618 std::string ex(str, iter.base()); 17619 assert(ex == "1_234_567_89_0***********"); 17620 assert(ios.width() == 0); 17621 } 17622 ios.width(25); 17623 right(ios); 17624 { 17625 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17626 std::string ex(str, iter.base()); 17627 assert(ex == "***********1_234_567_89_0"); 17628 assert(ios.width() == 0); 17629 } 17630 ios.width(25); 17631 internal(ios); 17632 { 17633 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17634 std::string ex(str, iter.base()); 17635 assert(ex == "***********1_234_567_89_0"); 17636 assert(ios.width() == 0); 17637 } 17638 } 17639 } 17640 showpoint(ios); 17641 { 17642 ios.imbue(lc); 17643 { 17644 ios.width(0); 17645 { 17646 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17647 std::string ex(str, iter.base()); 17648 assert(ex == "1234567890."); 17649 assert(ios.width() == 0); 17650 } 17651 ios.width(25); 17652 left(ios); 17653 { 17654 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17655 std::string ex(str, iter.base()); 17656 assert(ex == "1234567890.**************"); 17657 assert(ios.width() == 0); 17658 } 17659 ios.width(25); 17660 right(ios); 17661 { 17662 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17663 std::string ex(str, iter.base()); 17664 assert(ex == "**************1234567890."); 17665 assert(ios.width() == 0); 17666 } 17667 ios.width(25); 17668 internal(ios); 17669 { 17670 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17671 std::string ex(str, iter.base()); 17672 assert(ex == "**************1234567890."); 17673 assert(ios.width() == 0); 17674 } 17675 } 17676 ios.imbue(lg); 17677 { 17678 ios.width(0); 17679 { 17680 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17681 std::string ex(str, iter.base()); 17682 assert(ex == "1_234_567_89_0;"); 17683 assert(ios.width() == 0); 17684 } 17685 ios.width(25); 17686 left(ios); 17687 { 17688 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17689 std::string ex(str, iter.base()); 17690 assert(ex == "1_234_567_89_0;**********"); 17691 assert(ios.width() == 0); 17692 } 17693 ios.width(25); 17694 right(ios); 17695 { 17696 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17697 std::string ex(str, iter.base()); 17698 assert(ex == "**********1_234_567_89_0;"); 17699 assert(ios.width() == 0); 17700 } 17701 ios.width(25); 17702 internal(ios); 17703 { 17704 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17705 std::string ex(str, iter.base()); 17706 assert(ex == "**********1_234_567_89_0;"); 17707 assert(ios.width() == 0); 17708 } 17709 } 17710 } 17711 } 17712 showpos(ios); 17713 { 17714 noshowpoint(ios); 17715 { 17716 ios.imbue(lc); 17717 { 17718 ios.width(0); 17719 { 17720 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17721 std::string ex(str, iter.base()); 17722 assert(ex == "+1234567890"); 17723 assert(ios.width() == 0); 17724 } 17725 ios.width(25); 17726 left(ios); 17727 { 17728 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17729 std::string ex(str, iter.base()); 17730 assert(ex == "+1234567890**************"); 17731 assert(ios.width() == 0); 17732 } 17733 ios.width(25); 17734 right(ios); 17735 { 17736 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17737 std::string ex(str, iter.base()); 17738 assert(ex == "**************+1234567890"); 17739 assert(ios.width() == 0); 17740 } 17741 ios.width(25); 17742 internal(ios); 17743 { 17744 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17745 std::string ex(str, iter.base()); 17746 assert(ex == "+**************1234567890"); 17747 assert(ios.width() == 0); 17748 } 17749 } 17750 ios.imbue(lg); 17751 { 17752 ios.width(0); 17753 { 17754 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17755 std::string ex(str, iter.base()); 17756 assert(ex == "+1_234_567_89_0"); 17757 assert(ios.width() == 0); 17758 } 17759 ios.width(25); 17760 left(ios); 17761 { 17762 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17763 std::string ex(str, iter.base()); 17764 assert(ex == "+1_234_567_89_0**********"); 17765 assert(ios.width() == 0); 17766 } 17767 ios.width(25); 17768 right(ios); 17769 { 17770 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17771 std::string ex(str, iter.base()); 17772 assert(ex == "**********+1_234_567_89_0"); 17773 assert(ios.width() == 0); 17774 } 17775 ios.width(25); 17776 internal(ios); 17777 { 17778 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17779 std::string ex(str, iter.base()); 17780 assert(ex == "+**********1_234_567_89_0"); 17781 assert(ios.width() == 0); 17782 } 17783 } 17784 } 17785 showpoint(ios); 17786 { 17787 ios.imbue(lc); 17788 { 17789 ios.width(0); 17790 { 17791 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17792 std::string ex(str, iter.base()); 17793 assert(ex == "+1234567890."); 17794 assert(ios.width() == 0); 17795 } 17796 ios.width(25); 17797 left(ios); 17798 { 17799 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17800 std::string ex(str, iter.base()); 17801 assert(ex == "+1234567890.*************"); 17802 assert(ios.width() == 0); 17803 } 17804 ios.width(25); 17805 right(ios); 17806 { 17807 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17808 std::string ex(str, iter.base()); 17809 assert(ex == "*************+1234567890."); 17810 assert(ios.width() == 0); 17811 } 17812 ios.width(25); 17813 internal(ios); 17814 { 17815 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17816 std::string ex(str, iter.base()); 17817 assert(ex == "+*************1234567890."); 17818 assert(ios.width() == 0); 17819 } 17820 } 17821 ios.imbue(lg); 17822 { 17823 ios.width(0); 17824 { 17825 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17826 std::string ex(str, iter.base()); 17827 assert(ex == "+1_234_567_89_0;"); 17828 assert(ios.width() == 0); 17829 } 17830 ios.width(25); 17831 left(ios); 17832 { 17833 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17834 std::string ex(str, iter.base()); 17835 assert(ex == "+1_234_567_89_0;*********"); 17836 assert(ios.width() == 0); 17837 } 17838 ios.width(25); 17839 right(ios); 17840 { 17841 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17842 std::string ex(str, iter.base()); 17843 assert(ex == "*********+1_234_567_89_0;"); 17844 assert(ios.width() == 0); 17845 } 17846 ios.width(25); 17847 internal(ios); 17848 { 17849 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17850 std::string ex(str, iter.base()); 17851 assert(ex == "+*********1_234_567_89_0;"); 17852 assert(ios.width() == 0); 17853 } 17854 } 17855 } 17856 } 17857 } 17858 } 17859 ios.precision(1); 17860 { 17861 nouppercase(ios); 17862 { 17863 noshowpos(ios); 17864 { 17865 noshowpoint(ios); 17866 { 17867 ios.imbue(lc); 17868 { 17869 ios.width(0); 17870 { 17871 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17872 std::string ex(str, iter.base()); 17873 assert(ex == "1234567890.1"); 17874 assert(ios.width() == 0); 17875 } 17876 ios.width(25); 17877 left(ios); 17878 { 17879 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17880 std::string ex(str, iter.base()); 17881 assert(ex == "1234567890.1*************"); 17882 assert(ios.width() == 0); 17883 } 17884 ios.width(25); 17885 right(ios); 17886 { 17887 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17888 std::string ex(str, iter.base()); 17889 assert(ex == "*************1234567890.1"); 17890 assert(ios.width() == 0); 17891 } 17892 ios.width(25); 17893 internal(ios); 17894 { 17895 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17896 std::string ex(str, iter.base()); 17897 assert(ex == "*************1234567890.1"); 17898 assert(ios.width() == 0); 17899 } 17900 } 17901 ios.imbue(lg); 17902 { 17903 ios.width(0); 17904 { 17905 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17906 std::string ex(str, iter.base()); 17907 assert(ex == "1_234_567_89_0;1"); 17908 assert(ios.width() == 0); 17909 } 17910 ios.width(25); 17911 left(ios); 17912 { 17913 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17914 std::string ex(str, iter.base()); 17915 assert(ex == "1_234_567_89_0;1*********"); 17916 assert(ios.width() == 0); 17917 } 17918 ios.width(25); 17919 right(ios); 17920 { 17921 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17922 std::string ex(str, iter.base()); 17923 assert(ex == "*********1_234_567_89_0;1"); 17924 assert(ios.width() == 0); 17925 } 17926 ios.width(25); 17927 internal(ios); 17928 { 17929 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17930 std::string ex(str, iter.base()); 17931 assert(ex == "*********1_234_567_89_0;1"); 17932 assert(ios.width() == 0); 17933 } 17934 } 17935 } 17936 showpoint(ios); 17937 { 17938 ios.imbue(lc); 17939 { 17940 ios.width(0); 17941 { 17942 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17943 std::string ex(str, iter.base()); 17944 assert(ex == "1234567890.1"); 17945 assert(ios.width() == 0); 17946 } 17947 ios.width(25); 17948 left(ios); 17949 { 17950 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17951 std::string ex(str, iter.base()); 17952 assert(ex == "1234567890.1*************"); 17953 assert(ios.width() == 0); 17954 } 17955 ios.width(25); 17956 right(ios); 17957 { 17958 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17959 std::string ex(str, iter.base()); 17960 assert(ex == "*************1234567890.1"); 17961 assert(ios.width() == 0); 17962 } 17963 ios.width(25); 17964 internal(ios); 17965 { 17966 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17967 std::string ex(str, iter.base()); 17968 assert(ex == "*************1234567890.1"); 17969 assert(ios.width() == 0); 17970 } 17971 } 17972 ios.imbue(lg); 17973 { 17974 ios.width(0); 17975 { 17976 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17977 std::string ex(str, iter.base()); 17978 assert(ex == "1_234_567_89_0;1"); 17979 assert(ios.width() == 0); 17980 } 17981 ios.width(25); 17982 left(ios); 17983 { 17984 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17985 std::string ex(str, iter.base()); 17986 assert(ex == "1_234_567_89_0;1*********"); 17987 assert(ios.width() == 0); 17988 } 17989 ios.width(25); 17990 right(ios); 17991 { 17992 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17993 std::string ex(str, iter.base()); 17994 assert(ex == "*********1_234_567_89_0;1"); 17995 assert(ios.width() == 0); 17996 } 17997 ios.width(25); 17998 internal(ios); 17999 { 18000 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18001 std::string ex(str, iter.base()); 18002 assert(ex == "*********1_234_567_89_0;1"); 18003 assert(ios.width() == 0); 18004 } 18005 } 18006 } 18007 } 18008 showpos(ios); 18009 { 18010 noshowpoint(ios); 18011 { 18012 ios.imbue(lc); 18013 { 18014 ios.width(0); 18015 { 18016 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18017 std::string ex(str, iter.base()); 18018 assert(ex == "+1234567890.1"); 18019 assert(ios.width() == 0); 18020 } 18021 ios.width(25); 18022 left(ios); 18023 { 18024 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18025 std::string ex(str, iter.base()); 18026 assert(ex == "+1234567890.1************"); 18027 assert(ios.width() == 0); 18028 } 18029 ios.width(25); 18030 right(ios); 18031 { 18032 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18033 std::string ex(str, iter.base()); 18034 assert(ex == "************+1234567890.1"); 18035 assert(ios.width() == 0); 18036 } 18037 ios.width(25); 18038 internal(ios); 18039 { 18040 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18041 std::string ex(str, iter.base()); 18042 assert(ex == "+************1234567890.1"); 18043 assert(ios.width() == 0); 18044 } 18045 } 18046 ios.imbue(lg); 18047 { 18048 ios.width(0); 18049 { 18050 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18051 std::string ex(str, iter.base()); 18052 assert(ex == "+1_234_567_89_0;1"); 18053 assert(ios.width() == 0); 18054 } 18055 ios.width(25); 18056 left(ios); 18057 { 18058 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18059 std::string ex(str, iter.base()); 18060 assert(ex == "+1_234_567_89_0;1********"); 18061 assert(ios.width() == 0); 18062 } 18063 ios.width(25); 18064 right(ios); 18065 { 18066 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18067 std::string ex(str, iter.base()); 18068 assert(ex == "********+1_234_567_89_0;1"); 18069 assert(ios.width() == 0); 18070 } 18071 ios.width(25); 18072 internal(ios); 18073 { 18074 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18075 std::string ex(str, iter.base()); 18076 assert(ex == "+********1_234_567_89_0;1"); 18077 assert(ios.width() == 0); 18078 } 18079 } 18080 } 18081 showpoint(ios); 18082 { 18083 ios.imbue(lc); 18084 { 18085 ios.width(0); 18086 { 18087 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18088 std::string ex(str, iter.base()); 18089 assert(ex == "+1234567890.1"); 18090 assert(ios.width() == 0); 18091 } 18092 ios.width(25); 18093 left(ios); 18094 { 18095 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18096 std::string ex(str, iter.base()); 18097 assert(ex == "+1234567890.1************"); 18098 assert(ios.width() == 0); 18099 } 18100 ios.width(25); 18101 right(ios); 18102 { 18103 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18104 std::string ex(str, iter.base()); 18105 assert(ex == "************+1234567890.1"); 18106 assert(ios.width() == 0); 18107 } 18108 ios.width(25); 18109 internal(ios); 18110 { 18111 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18112 std::string ex(str, iter.base()); 18113 assert(ex == "+************1234567890.1"); 18114 assert(ios.width() == 0); 18115 } 18116 } 18117 ios.imbue(lg); 18118 { 18119 ios.width(0); 18120 { 18121 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18122 std::string ex(str, iter.base()); 18123 assert(ex == "+1_234_567_89_0;1"); 18124 assert(ios.width() == 0); 18125 } 18126 ios.width(25); 18127 left(ios); 18128 { 18129 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18130 std::string ex(str, iter.base()); 18131 assert(ex == "+1_234_567_89_0;1********"); 18132 assert(ios.width() == 0); 18133 } 18134 ios.width(25); 18135 right(ios); 18136 { 18137 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18138 std::string ex(str, iter.base()); 18139 assert(ex == "********+1_234_567_89_0;1"); 18140 assert(ios.width() == 0); 18141 } 18142 ios.width(25); 18143 internal(ios); 18144 { 18145 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18146 std::string ex(str, iter.base()); 18147 assert(ex == "+********1_234_567_89_0;1"); 18148 assert(ios.width() == 0); 18149 } 18150 } 18151 } 18152 } 18153 } 18154 uppercase(ios); 18155 { 18156 noshowpos(ios); 18157 { 18158 noshowpoint(ios); 18159 { 18160 ios.imbue(lc); 18161 { 18162 ios.width(0); 18163 { 18164 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18165 std::string ex(str, iter.base()); 18166 assert(ex == "1234567890.1"); 18167 assert(ios.width() == 0); 18168 } 18169 ios.width(25); 18170 left(ios); 18171 { 18172 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18173 std::string ex(str, iter.base()); 18174 assert(ex == "1234567890.1*************"); 18175 assert(ios.width() == 0); 18176 } 18177 ios.width(25); 18178 right(ios); 18179 { 18180 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18181 std::string ex(str, iter.base()); 18182 assert(ex == "*************1234567890.1"); 18183 assert(ios.width() == 0); 18184 } 18185 ios.width(25); 18186 internal(ios); 18187 { 18188 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18189 std::string ex(str, iter.base()); 18190 assert(ex == "*************1234567890.1"); 18191 assert(ios.width() == 0); 18192 } 18193 } 18194 ios.imbue(lg); 18195 { 18196 ios.width(0); 18197 { 18198 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18199 std::string ex(str, iter.base()); 18200 assert(ex == "1_234_567_89_0;1"); 18201 assert(ios.width() == 0); 18202 } 18203 ios.width(25); 18204 left(ios); 18205 { 18206 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18207 std::string ex(str, iter.base()); 18208 assert(ex == "1_234_567_89_0;1*********"); 18209 assert(ios.width() == 0); 18210 } 18211 ios.width(25); 18212 right(ios); 18213 { 18214 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18215 std::string ex(str, iter.base()); 18216 assert(ex == "*********1_234_567_89_0;1"); 18217 assert(ios.width() == 0); 18218 } 18219 ios.width(25); 18220 internal(ios); 18221 { 18222 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18223 std::string ex(str, iter.base()); 18224 assert(ex == "*********1_234_567_89_0;1"); 18225 assert(ios.width() == 0); 18226 } 18227 } 18228 } 18229 showpoint(ios); 18230 { 18231 ios.imbue(lc); 18232 { 18233 ios.width(0); 18234 { 18235 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18236 std::string ex(str, iter.base()); 18237 assert(ex == "1234567890.1"); 18238 assert(ios.width() == 0); 18239 } 18240 ios.width(25); 18241 left(ios); 18242 { 18243 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18244 std::string ex(str, iter.base()); 18245 assert(ex == "1234567890.1*************"); 18246 assert(ios.width() == 0); 18247 } 18248 ios.width(25); 18249 right(ios); 18250 { 18251 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18252 std::string ex(str, iter.base()); 18253 assert(ex == "*************1234567890.1"); 18254 assert(ios.width() == 0); 18255 } 18256 ios.width(25); 18257 internal(ios); 18258 { 18259 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18260 std::string ex(str, iter.base()); 18261 assert(ex == "*************1234567890.1"); 18262 assert(ios.width() == 0); 18263 } 18264 } 18265 ios.imbue(lg); 18266 { 18267 ios.width(0); 18268 { 18269 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18270 std::string ex(str, iter.base()); 18271 assert(ex == "1_234_567_89_0;1"); 18272 assert(ios.width() == 0); 18273 } 18274 ios.width(25); 18275 left(ios); 18276 { 18277 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18278 std::string ex(str, iter.base()); 18279 assert(ex == "1_234_567_89_0;1*********"); 18280 assert(ios.width() == 0); 18281 } 18282 ios.width(25); 18283 right(ios); 18284 { 18285 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18286 std::string ex(str, iter.base()); 18287 assert(ex == "*********1_234_567_89_0;1"); 18288 assert(ios.width() == 0); 18289 } 18290 ios.width(25); 18291 internal(ios); 18292 { 18293 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18294 std::string ex(str, iter.base()); 18295 assert(ex == "*********1_234_567_89_0;1"); 18296 assert(ios.width() == 0); 18297 } 18298 } 18299 } 18300 } 18301 showpos(ios); 18302 { 18303 noshowpoint(ios); 18304 { 18305 ios.imbue(lc); 18306 { 18307 ios.width(0); 18308 { 18309 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18310 std::string ex(str, iter.base()); 18311 assert(ex == "+1234567890.1"); 18312 assert(ios.width() == 0); 18313 } 18314 ios.width(25); 18315 left(ios); 18316 { 18317 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18318 std::string ex(str, iter.base()); 18319 assert(ex == "+1234567890.1************"); 18320 assert(ios.width() == 0); 18321 } 18322 ios.width(25); 18323 right(ios); 18324 { 18325 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18326 std::string ex(str, iter.base()); 18327 assert(ex == "************+1234567890.1"); 18328 assert(ios.width() == 0); 18329 } 18330 ios.width(25); 18331 internal(ios); 18332 { 18333 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18334 std::string ex(str, iter.base()); 18335 assert(ex == "+************1234567890.1"); 18336 assert(ios.width() == 0); 18337 } 18338 } 18339 ios.imbue(lg); 18340 { 18341 ios.width(0); 18342 { 18343 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18344 std::string ex(str, iter.base()); 18345 assert(ex == "+1_234_567_89_0;1"); 18346 assert(ios.width() == 0); 18347 } 18348 ios.width(25); 18349 left(ios); 18350 { 18351 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18352 std::string ex(str, iter.base()); 18353 assert(ex == "+1_234_567_89_0;1********"); 18354 assert(ios.width() == 0); 18355 } 18356 ios.width(25); 18357 right(ios); 18358 { 18359 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18360 std::string ex(str, iter.base()); 18361 assert(ex == "********+1_234_567_89_0;1"); 18362 assert(ios.width() == 0); 18363 } 18364 ios.width(25); 18365 internal(ios); 18366 { 18367 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18368 std::string ex(str, iter.base()); 18369 assert(ex == "+********1_234_567_89_0;1"); 18370 assert(ios.width() == 0); 18371 } 18372 } 18373 } 18374 showpoint(ios); 18375 { 18376 ios.imbue(lc); 18377 { 18378 ios.width(0); 18379 { 18380 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18381 std::string ex(str, iter.base()); 18382 assert(ex == "+1234567890.1"); 18383 assert(ios.width() == 0); 18384 } 18385 ios.width(25); 18386 left(ios); 18387 { 18388 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18389 std::string ex(str, iter.base()); 18390 assert(ex == "+1234567890.1************"); 18391 assert(ios.width() == 0); 18392 } 18393 ios.width(25); 18394 right(ios); 18395 { 18396 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18397 std::string ex(str, iter.base()); 18398 assert(ex == "************+1234567890.1"); 18399 assert(ios.width() == 0); 18400 } 18401 ios.width(25); 18402 internal(ios); 18403 { 18404 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18405 std::string ex(str, iter.base()); 18406 assert(ex == "+************1234567890.1"); 18407 assert(ios.width() == 0); 18408 } 18409 } 18410 ios.imbue(lg); 18411 { 18412 ios.width(0); 18413 { 18414 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18415 std::string ex(str, iter.base()); 18416 assert(ex == "+1_234_567_89_0;1"); 18417 assert(ios.width() == 0); 18418 } 18419 ios.width(25); 18420 left(ios); 18421 { 18422 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18423 std::string ex(str, iter.base()); 18424 assert(ex == "+1_234_567_89_0;1********"); 18425 assert(ios.width() == 0); 18426 } 18427 ios.width(25); 18428 right(ios); 18429 { 18430 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18431 std::string ex(str, iter.base()); 18432 assert(ex == "********+1_234_567_89_0;1"); 18433 assert(ios.width() == 0); 18434 } 18435 ios.width(25); 18436 internal(ios); 18437 { 18438 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18439 std::string ex(str, iter.base()); 18440 assert(ex == "+********1_234_567_89_0;1"); 18441 assert(ios.width() == 0); 18442 } 18443 } 18444 } 18445 } 18446 } 18447 } 18448 ios.precision(6); 18449 { 18450 nouppercase(ios); 18451 { 18452 noshowpos(ios); 18453 { 18454 noshowpoint(ios); 18455 { 18456 ios.imbue(lc); 18457 { 18458 ios.width(0); 18459 { 18460 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18461 std::string ex(str, iter.base()); 18462 assert(ex == "1234567890.125000"); 18463 assert(ios.width() == 0); 18464 } 18465 ios.width(25); 18466 left(ios); 18467 { 18468 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18469 std::string ex(str, iter.base()); 18470 assert(ex == "1234567890.125000********"); 18471 assert(ios.width() == 0); 18472 } 18473 ios.width(25); 18474 right(ios); 18475 { 18476 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18477 std::string ex(str, iter.base()); 18478 assert(ex == "********1234567890.125000"); 18479 assert(ios.width() == 0); 18480 } 18481 ios.width(25); 18482 internal(ios); 18483 { 18484 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18485 std::string ex(str, iter.base()); 18486 assert(ex == "********1234567890.125000"); 18487 assert(ios.width() == 0); 18488 } 18489 } 18490 ios.imbue(lg); 18491 { 18492 ios.width(0); 18493 { 18494 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18495 std::string ex(str, iter.base()); 18496 assert(ex == "1_234_567_89_0;125000"); 18497 assert(ios.width() == 0); 18498 } 18499 ios.width(25); 18500 left(ios); 18501 { 18502 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18503 std::string ex(str, iter.base()); 18504 assert(ex == "1_234_567_89_0;125000****"); 18505 assert(ios.width() == 0); 18506 } 18507 ios.width(25); 18508 right(ios); 18509 { 18510 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18511 std::string ex(str, iter.base()); 18512 assert(ex == "****1_234_567_89_0;125000"); 18513 assert(ios.width() == 0); 18514 } 18515 ios.width(25); 18516 internal(ios); 18517 { 18518 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18519 std::string ex(str, iter.base()); 18520 assert(ex == "****1_234_567_89_0;125000"); 18521 assert(ios.width() == 0); 18522 } 18523 } 18524 } 18525 showpoint(ios); 18526 { 18527 ios.imbue(lc); 18528 { 18529 ios.width(0); 18530 { 18531 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18532 std::string ex(str, iter.base()); 18533 assert(ex == "1234567890.125000"); 18534 assert(ios.width() == 0); 18535 } 18536 ios.width(25); 18537 left(ios); 18538 { 18539 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18540 std::string ex(str, iter.base()); 18541 assert(ex == "1234567890.125000********"); 18542 assert(ios.width() == 0); 18543 } 18544 ios.width(25); 18545 right(ios); 18546 { 18547 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18548 std::string ex(str, iter.base()); 18549 assert(ex == "********1234567890.125000"); 18550 assert(ios.width() == 0); 18551 } 18552 ios.width(25); 18553 internal(ios); 18554 { 18555 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18556 std::string ex(str, iter.base()); 18557 assert(ex == "********1234567890.125000"); 18558 assert(ios.width() == 0); 18559 } 18560 } 18561 ios.imbue(lg); 18562 { 18563 ios.width(0); 18564 { 18565 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18566 std::string ex(str, iter.base()); 18567 assert(ex == "1_234_567_89_0;125000"); 18568 assert(ios.width() == 0); 18569 } 18570 ios.width(25); 18571 left(ios); 18572 { 18573 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18574 std::string ex(str, iter.base()); 18575 assert(ex == "1_234_567_89_0;125000****"); 18576 assert(ios.width() == 0); 18577 } 18578 ios.width(25); 18579 right(ios); 18580 { 18581 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18582 std::string ex(str, iter.base()); 18583 assert(ex == "****1_234_567_89_0;125000"); 18584 assert(ios.width() == 0); 18585 } 18586 ios.width(25); 18587 internal(ios); 18588 { 18589 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18590 std::string ex(str, iter.base()); 18591 assert(ex == "****1_234_567_89_0;125000"); 18592 assert(ios.width() == 0); 18593 } 18594 } 18595 } 18596 } 18597 showpos(ios); 18598 { 18599 noshowpoint(ios); 18600 { 18601 ios.imbue(lc); 18602 { 18603 ios.width(0); 18604 { 18605 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18606 std::string ex(str, iter.base()); 18607 assert(ex == "+1234567890.125000"); 18608 assert(ios.width() == 0); 18609 } 18610 ios.width(25); 18611 left(ios); 18612 { 18613 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18614 std::string ex(str, iter.base()); 18615 assert(ex == "+1234567890.125000*******"); 18616 assert(ios.width() == 0); 18617 } 18618 ios.width(25); 18619 right(ios); 18620 { 18621 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18622 std::string ex(str, iter.base()); 18623 assert(ex == "*******+1234567890.125000"); 18624 assert(ios.width() == 0); 18625 } 18626 ios.width(25); 18627 internal(ios); 18628 { 18629 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18630 std::string ex(str, iter.base()); 18631 assert(ex == "+*******1234567890.125000"); 18632 assert(ios.width() == 0); 18633 } 18634 } 18635 ios.imbue(lg); 18636 { 18637 ios.width(0); 18638 { 18639 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18640 std::string ex(str, iter.base()); 18641 assert(ex == "+1_234_567_89_0;125000"); 18642 assert(ios.width() == 0); 18643 } 18644 ios.width(25); 18645 left(ios); 18646 { 18647 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18648 std::string ex(str, iter.base()); 18649 assert(ex == "+1_234_567_89_0;125000***"); 18650 assert(ios.width() == 0); 18651 } 18652 ios.width(25); 18653 right(ios); 18654 { 18655 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18656 std::string ex(str, iter.base()); 18657 assert(ex == "***+1_234_567_89_0;125000"); 18658 assert(ios.width() == 0); 18659 } 18660 ios.width(25); 18661 internal(ios); 18662 { 18663 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18664 std::string ex(str, iter.base()); 18665 assert(ex == "+***1_234_567_89_0;125000"); 18666 assert(ios.width() == 0); 18667 } 18668 } 18669 } 18670 showpoint(ios); 18671 { 18672 ios.imbue(lc); 18673 { 18674 ios.width(0); 18675 { 18676 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18677 std::string ex(str, iter.base()); 18678 assert(ex == "+1234567890.125000"); 18679 assert(ios.width() == 0); 18680 } 18681 ios.width(25); 18682 left(ios); 18683 { 18684 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18685 std::string ex(str, iter.base()); 18686 assert(ex == "+1234567890.125000*******"); 18687 assert(ios.width() == 0); 18688 } 18689 ios.width(25); 18690 right(ios); 18691 { 18692 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18693 std::string ex(str, iter.base()); 18694 assert(ex == "*******+1234567890.125000"); 18695 assert(ios.width() == 0); 18696 } 18697 ios.width(25); 18698 internal(ios); 18699 { 18700 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18701 std::string ex(str, iter.base()); 18702 assert(ex == "+*******1234567890.125000"); 18703 assert(ios.width() == 0); 18704 } 18705 } 18706 ios.imbue(lg); 18707 { 18708 ios.width(0); 18709 { 18710 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18711 std::string ex(str, iter.base()); 18712 assert(ex == "+1_234_567_89_0;125000"); 18713 assert(ios.width() == 0); 18714 } 18715 ios.width(25); 18716 left(ios); 18717 { 18718 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18719 std::string ex(str, iter.base()); 18720 assert(ex == "+1_234_567_89_0;125000***"); 18721 assert(ios.width() == 0); 18722 } 18723 ios.width(25); 18724 right(ios); 18725 { 18726 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18727 std::string ex(str, iter.base()); 18728 assert(ex == "***+1_234_567_89_0;125000"); 18729 assert(ios.width() == 0); 18730 } 18731 ios.width(25); 18732 internal(ios); 18733 { 18734 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18735 std::string ex(str, iter.base()); 18736 assert(ex == "+***1_234_567_89_0;125000"); 18737 assert(ios.width() == 0); 18738 } 18739 } 18740 } 18741 } 18742 } 18743 uppercase(ios); 18744 { 18745 noshowpos(ios); 18746 { 18747 noshowpoint(ios); 18748 { 18749 ios.imbue(lc); 18750 { 18751 ios.width(0); 18752 { 18753 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18754 std::string ex(str, iter.base()); 18755 assert(ex == "1234567890.125000"); 18756 assert(ios.width() == 0); 18757 } 18758 ios.width(25); 18759 left(ios); 18760 { 18761 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18762 std::string ex(str, iter.base()); 18763 assert(ex == "1234567890.125000********"); 18764 assert(ios.width() == 0); 18765 } 18766 ios.width(25); 18767 right(ios); 18768 { 18769 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18770 std::string ex(str, iter.base()); 18771 assert(ex == "********1234567890.125000"); 18772 assert(ios.width() == 0); 18773 } 18774 ios.width(25); 18775 internal(ios); 18776 { 18777 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18778 std::string ex(str, iter.base()); 18779 assert(ex == "********1234567890.125000"); 18780 assert(ios.width() == 0); 18781 } 18782 } 18783 ios.imbue(lg); 18784 { 18785 ios.width(0); 18786 { 18787 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18788 std::string ex(str, iter.base()); 18789 assert(ex == "1_234_567_89_0;125000"); 18790 assert(ios.width() == 0); 18791 } 18792 ios.width(25); 18793 left(ios); 18794 { 18795 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18796 std::string ex(str, iter.base()); 18797 assert(ex == "1_234_567_89_0;125000****"); 18798 assert(ios.width() == 0); 18799 } 18800 ios.width(25); 18801 right(ios); 18802 { 18803 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18804 std::string ex(str, iter.base()); 18805 assert(ex == "****1_234_567_89_0;125000"); 18806 assert(ios.width() == 0); 18807 } 18808 ios.width(25); 18809 internal(ios); 18810 { 18811 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18812 std::string ex(str, iter.base()); 18813 assert(ex == "****1_234_567_89_0;125000"); 18814 assert(ios.width() == 0); 18815 } 18816 } 18817 } 18818 showpoint(ios); 18819 { 18820 ios.imbue(lc); 18821 { 18822 ios.width(0); 18823 { 18824 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18825 std::string ex(str, iter.base()); 18826 assert(ex == "1234567890.125000"); 18827 assert(ios.width() == 0); 18828 } 18829 ios.width(25); 18830 left(ios); 18831 { 18832 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18833 std::string ex(str, iter.base()); 18834 assert(ex == "1234567890.125000********"); 18835 assert(ios.width() == 0); 18836 } 18837 ios.width(25); 18838 right(ios); 18839 { 18840 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18841 std::string ex(str, iter.base()); 18842 assert(ex == "********1234567890.125000"); 18843 assert(ios.width() == 0); 18844 } 18845 ios.width(25); 18846 internal(ios); 18847 { 18848 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18849 std::string ex(str, iter.base()); 18850 assert(ex == "********1234567890.125000"); 18851 assert(ios.width() == 0); 18852 } 18853 } 18854 ios.imbue(lg); 18855 { 18856 ios.width(0); 18857 { 18858 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18859 std::string ex(str, iter.base()); 18860 assert(ex == "1_234_567_89_0;125000"); 18861 assert(ios.width() == 0); 18862 } 18863 ios.width(25); 18864 left(ios); 18865 { 18866 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18867 std::string ex(str, iter.base()); 18868 assert(ex == "1_234_567_89_0;125000****"); 18869 assert(ios.width() == 0); 18870 } 18871 ios.width(25); 18872 right(ios); 18873 { 18874 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18875 std::string ex(str, iter.base()); 18876 assert(ex == "****1_234_567_89_0;125000"); 18877 assert(ios.width() == 0); 18878 } 18879 ios.width(25); 18880 internal(ios); 18881 { 18882 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18883 std::string ex(str, iter.base()); 18884 assert(ex == "****1_234_567_89_0;125000"); 18885 assert(ios.width() == 0); 18886 } 18887 } 18888 } 18889 } 18890 showpos(ios); 18891 { 18892 noshowpoint(ios); 18893 { 18894 ios.imbue(lc); 18895 { 18896 ios.width(0); 18897 { 18898 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18899 std::string ex(str, iter.base()); 18900 assert(ex == "+1234567890.125000"); 18901 assert(ios.width() == 0); 18902 } 18903 ios.width(25); 18904 left(ios); 18905 { 18906 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18907 std::string ex(str, iter.base()); 18908 assert(ex == "+1234567890.125000*******"); 18909 assert(ios.width() == 0); 18910 } 18911 ios.width(25); 18912 right(ios); 18913 { 18914 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18915 std::string ex(str, iter.base()); 18916 assert(ex == "*******+1234567890.125000"); 18917 assert(ios.width() == 0); 18918 } 18919 ios.width(25); 18920 internal(ios); 18921 { 18922 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18923 std::string ex(str, iter.base()); 18924 assert(ex == "+*******1234567890.125000"); 18925 assert(ios.width() == 0); 18926 } 18927 } 18928 ios.imbue(lg); 18929 { 18930 ios.width(0); 18931 { 18932 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18933 std::string ex(str, iter.base()); 18934 assert(ex == "+1_234_567_89_0;125000"); 18935 assert(ios.width() == 0); 18936 } 18937 ios.width(25); 18938 left(ios); 18939 { 18940 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18941 std::string ex(str, iter.base()); 18942 assert(ex == "+1_234_567_89_0;125000***"); 18943 assert(ios.width() == 0); 18944 } 18945 ios.width(25); 18946 right(ios); 18947 { 18948 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18949 std::string ex(str, iter.base()); 18950 assert(ex == "***+1_234_567_89_0;125000"); 18951 assert(ios.width() == 0); 18952 } 18953 ios.width(25); 18954 internal(ios); 18955 { 18956 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18957 std::string ex(str, iter.base()); 18958 assert(ex == "+***1_234_567_89_0;125000"); 18959 assert(ios.width() == 0); 18960 } 18961 } 18962 } 18963 showpoint(ios); 18964 { 18965 ios.imbue(lc); 18966 { 18967 ios.width(0); 18968 { 18969 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18970 std::string ex(str, iter.base()); 18971 assert(ex == "+1234567890.125000"); 18972 assert(ios.width() == 0); 18973 } 18974 ios.width(25); 18975 left(ios); 18976 { 18977 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18978 std::string ex(str, iter.base()); 18979 assert(ex == "+1234567890.125000*******"); 18980 assert(ios.width() == 0); 18981 } 18982 ios.width(25); 18983 right(ios); 18984 { 18985 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18986 std::string ex(str, iter.base()); 18987 assert(ex == "*******+1234567890.125000"); 18988 assert(ios.width() == 0); 18989 } 18990 ios.width(25); 18991 internal(ios); 18992 { 18993 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18994 std::string ex(str, iter.base()); 18995 assert(ex == "+*******1234567890.125000"); 18996 assert(ios.width() == 0); 18997 } 18998 } 18999 ios.imbue(lg); 19000 { 19001 ios.width(0); 19002 { 19003 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19004 std::string ex(str, iter.base()); 19005 assert(ex == "+1_234_567_89_0;125000"); 19006 assert(ios.width() == 0); 19007 } 19008 ios.width(25); 19009 left(ios); 19010 { 19011 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19012 std::string ex(str, iter.base()); 19013 assert(ex == "+1_234_567_89_0;125000***"); 19014 assert(ios.width() == 0); 19015 } 19016 ios.width(25); 19017 right(ios); 19018 { 19019 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19020 std::string ex(str, iter.base()); 19021 assert(ex == "***+1_234_567_89_0;125000"); 19022 assert(ios.width() == 0); 19023 } 19024 ios.width(25); 19025 internal(ios); 19026 { 19027 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19028 std::string ex(str, iter.base()); 19029 assert(ex == "+***1_234_567_89_0;125000"); 19030 assert(ios.width() == 0); 19031 } 19032 } 19033 } 19034 } 19035 } 19036 } 19037 ios.precision(16); 19038 {} 19039 ios.precision(60); 19040 {} 19041 } 19042 } 19043 } 19044 19045 void test9() 19046 { 19047 char str[200]; 19048 output_iterator<char*> iter; 19049 std::locale lc = std::locale::classic(); 19050 std::locale lg(lc, new my_numpunct); 19051 const my_facet f(1); 19052 { 19053 long double v = -0.; 19054 std::ios ios(0); 19055 scientific(ios); 19056 // %e 19057 { 19058 ios.precision(0); 19059 { 19060 nouppercase(ios); 19061 { 19062 noshowpos(ios); 19063 { 19064 noshowpoint(ios); 19065 { 19066 ios.imbue(lc); 19067 { 19068 ios.width(0); 19069 { 19070 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19071 std::string ex(str, iter.base()); 19072 assert(ex == "-0e+00"); 19073 assert(ios.width() == 0); 19074 } 19075 ios.width(25); 19076 left(ios); 19077 { 19078 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19079 std::string ex(str, iter.base()); 19080 assert(ex == "-0e+00*******************"); 19081 assert(ios.width() == 0); 19082 } 19083 ios.width(25); 19084 right(ios); 19085 { 19086 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19087 std::string ex(str, iter.base()); 19088 assert(ex == "*******************-0e+00"); 19089 assert(ios.width() == 0); 19090 } 19091 ios.width(25); 19092 internal(ios); 19093 { 19094 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19095 std::string ex(str, iter.base()); 19096 assert(ex == "-*******************0e+00"); 19097 assert(ios.width() == 0); 19098 } 19099 } 19100 ios.imbue(lg); 19101 { 19102 ios.width(0); 19103 { 19104 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19105 std::string ex(str, iter.base()); 19106 assert(ex == "-0e+00"); 19107 assert(ios.width() == 0); 19108 } 19109 ios.width(25); 19110 left(ios); 19111 { 19112 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19113 std::string ex(str, iter.base()); 19114 assert(ex == "-0e+00*******************"); 19115 assert(ios.width() == 0); 19116 } 19117 ios.width(25); 19118 right(ios); 19119 { 19120 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19121 std::string ex(str, iter.base()); 19122 assert(ex == "*******************-0e+00"); 19123 assert(ios.width() == 0); 19124 } 19125 ios.width(25); 19126 internal(ios); 19127 { 19128 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19129 std::string ex(str, iter.base()); 19130 assert(ex == "-*******************0e+00"); 19131 assert(ios.width() == 0); 19132 } 19133 } 19134 } 19135 showpoint(ios); 19136 { 19137 ios.imbue(lc); 19138 { 19139 ios.width(0); 19140 { 19141 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19142 std::string ex(str, iter.base()); 19143 assert(ex == "-0.e+00"); 19144 assert(ios.width() == 0); 19145 } 19146 ios.width(25); 19147 left(ios); 19148 { 19149 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19150 std::string ex(str, iter.base()); 19151 assert(ex == "-0.e+00******************"); 19152 assert(ios.width() == 0); 19153 } 19154 ios.width(25); 19155 right(ios); 19156 { 19157 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19158 std::string ex(str, iter.base()); 19159 assert(ex == "******************-0.e+00"); 19160 assert(ios.width() == 0); 19161 } 19162 ios.width(25); 19163 internal(ios); 19164 { 19165 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19166 std::string ex(str, iter.base()); 19167 assert(ex == "-******************0.e+00"); 19168 assert(ios.width() == 0); 19169 } 19170 } 19171 ios.imbue(lg); 19172 { 19173 ios.width(0); 19174 { 19175 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19176 std::string ex(str, iter.base()); 19177 assert(ex == "-0;e+00"); 19178 assert(ios.width() == 0); 19179 } 19180 ios.width(25); 19181 left(ios); 19182 { 19183 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19184 std::string ex(str, iter.base()); 19185 assert(ex == "-0;e+00******************"); 19186 assert(ios.width() == 0); 19187 } 19188 ios.width(25); 19189 right(ios); 19190 { 19191 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19192 std::string ex(str, iter.base()); 19193 assert(ex == "******************-0;e+00"); 19194 assert(ios.width() == 0); 19195 } 19196 ios.width(25); 19197 internal(ios); 19198 { 19199 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19200 std::string ex(str, iter.base()); 19201 assert(ex == "-******************0;e+00"); 19202 assert(ios.width() == 0); 19203 } 19204 } 19205 } 19206 } 19207 showpos(ios); 19208 { 19209 noshowpoint(ios); 19210 { 19211 ios.imbue(lc); 19212 { 19213 ios.width(0); 19214 { 19215 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19216 std::string ex(str, iter.base()); 19217 assert(ex == "-0e+00"); 19218 assert(ios.width() == 0); 19219 } 19220 ios.width(25); 19221 left(ios); 19222 { 19223 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19224 std::string ex(str, iter.base()); 19225 assert(ex == "-0e+00*******************"); 19226 assert(ios.width() == 0); 19227 } 19228 ios.width(25); 19229 right(ios); 19230 { 19231 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19232 std::string ex(str, iter.base()); 19233 assert(ex == "*******************-0e+00"); 19234 assert(ios.width() == 0); 19235 } 19236 ios.width(25); 19237 internal(ios); 19238 { 19239 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19240 std::string ex(str, iter.base()); 19241 assert(ex == "-*******************0e+00"); 19242 assert(ios.width() == 0); 19243 } 19244 } 19245 ios.imbue(lg); 19246 { 19247 ios.width(0); 19248 { 19249 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19250 std::string ex(str, iter.base()); 19251 assert(ex == "-0e+00"); 19252 assert(ios.width() == 0); 19253 } 19254 ios.width(25); 19255 left(ios); 19256 { 19257 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19258 std::string ex(str, iter.base()); 19259 assert(ex == "-0e+00*******************"); 19260 assert(ios.width() == 0); 19261 } 19262 ios.width(25); 19263 right(ios); 19264 { 19265 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19266 std::string ex(str, iter.base()); 19267 assert(ex == "*******************-0e+00"); 19268 assert(ios.width() == 0); 19269 } 19270 ios.width(25); 19271 internal(ios); 19272 { 19273 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19274 std::string ex(str, iter.base()); 19275 assert(ex == "-*******************0e+00"); 19276 assert(ios.width() == 0); 19277 } 19278 } 19279 } 19280 showpoint(ios); 19281 { 19282 ios.imbue(lc); 19283 { 19284 ios.width(0); 19285 { 19286 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19287 std::string ex(str, iter.base()); 19288 assert(ex == "-0.e+00"); 19289 assert(ios.width() == 0); 19290 } 19291 ios.width(25); 19292 left(ios); 19293 { 19294 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19295 std::string ex(str, iter.base()); 19296 assert(ex == "-0.e+00******************"); 19297 assert(ios.width() == 0); 19298 } 19299 ios.width(25); 19300 right(ios); 19301 { 19302 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19303 std::string ex(str, iter.base()); 19304 assert(ex == "******************-0.e+00"); 19305 assert(ios.width() == 0); 19306 } 19307 ios.width(25); 19308 internal(ios); 19309 { 19310 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19311 std::string ex(str, iter.base()); 19312 assert(ex == "-******************0.e+00"); 19313 assert(ios.width() == 0); 19314 } 19315 } 19316 ios.imbue(lg); 19317 { 19318 ios.width(0); 19319 { 19320 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19321 std::string ex(str, iter.base()); 19322 assert(ex == "-0;e+00"); 19323 assert(ios.width() == 0); 19324 } 19325 ios.width(25); 19326 left(ios); 19327 { 19328 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19329 std::string ex(str, iter.base()); 19330 assert(ex == "-0;e+00******************"); 19331 assert(ios.width() == 0); 19332 } 19333 ios.width(25); 19334 right(ios); 19335 { 19336 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19337 std::string ex(str, iter.base()); 19338 assert(ex == "******************-0;e+00"); 19339 assert(ios.width() == 0); 19340 } 19341 ios.width(25); 19342 internal(ios); 19343 { 19344 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19345 std::string ex(str, iter.base()); 19346 assert(ex == "-******************0;e+00"); 19347 assert(ios.width() == 0); 19348 } 19349 } 19350 } 19351 } 19352 } 19353 uppercase(ios); 19354 { 19355 noshowpos(ios); 19356 { 19357 noshowpoint(ios); 19358 { 19359 ios.imbue(lc); 19360 { 19361 ios.width(0); 19362 { 19363 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19364 std::string ex(str, iter.base()); 19365 assert(ex == "-0E+00"); 19366 assert(ios.width() == 0); 19367 } 19368 ios.width(25); 19369 left(ios); 19370 { 19371 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19372 std::string ex(str, iter.base()); 19373 assert(ex == "-0E+00*******************"); 19374 assert(ios.width() == 0); 19375 } 19376 ios.width(25); 19377 right(ios); 19378 { 19379 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19380 std::string ex(str, iter.base()); 19381 assert(ex == "*******************-0E+00"); 19382 assert(ios.width() == 0); 19383 } 19384 ios.width(25); 19385 internal(ios); 19386 { 19387 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19388 std::string ex(str, iter.base()); 19389 assert(ex == "-*******************0E+00"); 19390 assert(ios.width() == 0); 19391 } 19392 } 19393 ios.imbue(lg); 19394 { 19395 ios.width(0); 19396 { 19397 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19398 std::string ex(str, iter.base()); 19399 assert(ex == "-0E+00"); 19400 assert(ios.width() == 0); 19401 } 19402 ios.width(25); 19403 left(ios); 19404 { 19405 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19406 std::string ex(str, iter.base()); 19407 assert(ex == "-0E+00*******************"); 19408 assert(ios.width() == 0); 19409 } 19410 ios.width(25); 19411 right(ios); 19412 { 19413 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19414 std::string ex(str, iter.base()); 19415 assert(ex == "*******************-0E+00"); 19416 assert(ios.width() == 0); 19417 } 19418 ios.width(25); 19419 internal(ios); 19420 { 19421 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19422 std::string ex(str, iter.base()); 19423 assert(ex == "-*******************0E+00"); 19424 assert(ios.width() == 0); 19425 } 19426 } 19427 } 19428 showpoint(ios); 19429 { 19430 ios.imbue(lc); 19431 { 19432 ios.width(0); 19433 { 19434 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19435 std::string ex(str, iter.base()); 19436 assert(ex == "-0.E+00"); 19437 assert(ios.width() == 0); 19438 } 19439 ios.width(25); 19440 left(ios); 19441 { 19442 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19443 std::string ex(str, iter.base()); 19444 assert(ex == "-0.E+00******************"); 19445 assert(ios.width() == 0); 19446 } 19447 ios.width(25); 19448 right(ios); 19449 { 19450 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19451 std::string ex(str, iter.base()); 19452 assert(ex == "******************-0.E+00"); 19453 assert(ios.width() == 0); 19454 } 19455 ios.width(25); 19456 internal(ios); 19457 { 19458 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19459 std::string ex(str, iter.base()); 19460 assert(ex == "-******************0.E+00"); 19461 assert(ios.width() == 0); 19462 } 19463 } 19464 ios.imbue(lg); 19465 { 19466 ios.width(0); 19467 { 19468 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19469 std::string ex(str, iter.base()); 19470 assert(ex == "-0;E+00"); 19471 assert(ios.width() == 0); 19472 } 19473 ios.width(25); 19474 left(ios); 19475 { 19476 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19477 std::string ex(str, iter.base()); 19478 assert(ex == "-0;E+00******************"); 19479 assert(ios.width() == 0); 19480 } 19481 ios.width(25); 19482 right(ios); 19483 { 19484 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19485 std::string ex(str, iter.base()); 19486 assert(ex == "******************-0;E+00"); 19487 assert(ios.width() == 0); 19488 } 19489 ios.width(25); 19490 internal(ios); 19491 { 19492 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19493 std::string ex(str, iter.base()); 19494 assert(ex == "-******************0;E+00"); 19495 assert(ios.width() == 0); 19496 } 19497 } 19498 } 19499 } 19500 showpos(ios); 19501 { 19502 noshowpoint(ios); 19503 { 19504 ios.imbue(lc); 19505 { 19506 ios.width(0); 19507 { 19508 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19509 std::string ex(str, iter.base()); 19510 assert(ex == "-0E+00"); 19511 assert(ios.width() == 0); 19512 } 19513 ios.width(25); 19514 left(ios); 19515 { 19516 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19517 std::string ex(str, iter.base()); 19518 assert(ex == "-0E+00*******************"); 19519 assert(ios.width() == 0); 19520 } 19521 ios.width(25); 19522 right(ios); 19523 { 19524 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19525 std::string ex(str, iter.base()); 19526 assert(ex == "*******************-0E+00"); 19527 assert(ios.width() == 0); 19528 } 19529 ios.width(25); 19530 internal(ios); 19531 { 19532 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19533 std::string ex(str, iter.base()); 19534 assert(ex == "-*******************0E+00"); 19535 assert(ios.width() == 0); 19536 } 19537 } 19538 ios.imbue(lg); 19539 { 19540 ios.width(0); 19541 { 19542 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19543 std::string ex(str, iter.base()); 19544 assert(ex == "-0E+00"); 19545 assert(ios.width() == 0); 19546 } 19547 ios.width(25); 19548 left(ios); 19549 { 19550 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19551 std::string ex(str, iter.base()); 19552 assert(ex == "-0E+00*******************"); 19553 assert(ios.width() == 0); 19554 } 19555 ios.width(25); 19556 right(ios); 19557 { 19558 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19559 std::string ex(str, iter.base()); 19560 assert(ex == "*******************-0E+00"); 19561 assert(ios.width() == 0); 19562 } 19563 ios.width(25); 19564 internal(ios); 19565 { 19566 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19567 std::string ex(str, iter.base()); 19568 assert(ex == "-*******************0E+00"); 19569 assert(ios.width() == 0); 19570 } 19571 } 19572 } 19573 showpoint(ios); 19574 { 19575 ios.imbue(lc); 19576 { 19577 ios.width(0); 19578 { 19579 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19580 std::string ex(str, iter.base()); 19581 assert(ex == "-0.E+00"); 19582 assert(ios.width() == 0); 19583 } 19584 ios.width(25); 19585 left(ios); 19586 { 19587 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19588 std::string ex(str, iter.base()); 19589 assert(ex == "-0.E+00******************"); 19590 assert(ios.width() == 0); 19591 } 19592 ios.width(25); 19593 right(ios); 19594 { 19595 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19596 std::string ex(str, iter.base()); 19597 assert(ex == "******************-0.E+00"); 19598 assert(ios.width() == 0); 19599 } 19600 ios.width(25); 19601 internal(ios); 19602 { 19603 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19604 std::string ex(str, iter.base()); 19605 assert(ex == "-******************0.E+00"); 19606 assert(ios.width() == 0); 19607 } 19608 } 19609 ios.imbue(lg); 19610 { 19611 ios.width(0); 19612 { 19613 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19614 std::string ex(str, iter.base()); 19615 assert(ex == "-0;E+00"); 19616 assert(ios.width() == 0); 19617 } 19618 ios.width(25); 19619 left(ios); 19620 { 19621 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19622 std::string ex(str, iter.base()); 19623 assert(ex == "-0;E+00******************"); 19624 assert(ios.width() == 0); 19625 } 19626 ios.width(25); 19627 right(ios); 19628 { 19629 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19630 std::string ex(str, iter.base()); 19631 assert(ex == "******************-0;E+00"); 19632 assert(ios.width() == 0); 19633 } 19634 ios.width(25); 19635 internal(ios); 19636 { 19637 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19638 std::string ex(str, iter.base()); 19639 assert(ex == "-******************0;E+00"); 19640 assert(ios.width() == 0); 19641 } 19642 } 19643 } 19644 } 19645 } 19646 } 19647 ios.precision(1); 19648 { 19649 nouppercase(ios); 19650 { 19651 noshowpos(ios); 19652 { 19653 noshowpoint(ios); 19654 { 19655 ios.imbue(lc); 19656 { 19657 ios.width(0); 19658 { 19659 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19660 std::string ex(str, iter.base()); 19661 assert(ex == "-0.0e+00"); 19662 assert(ios.width() == 0); 19663 } 19664 ios.width(25); 19665 left(ios); 19666 { 19667 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19668 std::string ex(str, iter.base()); 19669 assert(ex == "-0.0e+00*****************"); 19670 assert(ios.width() == 0); 19671 } 19672 ios.width(25); 19673 right(ios); 19674 { 19675 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19676 std::string ex(str, iter.base()); 19677 assert(ex == "*****************-0.0e+00"); 19678 assert(ios.width() == 0); 19679 } 19680 ios.width(25); 19681 internal(ios); 19682 { 19683 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19684 std::string ex(str, iter.base()); 19685 assert(ex == "-*****************0.0e+00"); 19686 assert(ios.width() == 0); 19687 } 19688 } 19689 ios.imbue(lg); 19690 { 19691 ios.width(0); 19692 { 19693 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19694 std::string ex(str, iter.base()); 19695 assert(ex == "-0;0e+00"); 19696 assert(ios.width() == 0); 19697 } 19698 ios.width(25); 19699 left(ios); 19700 { 19701 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19702 std::string ex(str, iter.base()); 19703 assert(ex == "-0;0e+00*****************"); 19704 assert(ios.width() == 0); 19705 } 19706 ios.width(25); 19707 right(ios); 19708 { 19709 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19710 std::string ex(str, iter.base()); 19711 assert(ex == "*****************-0;0e+00"); 19712 assert(ios.width() == 0); 19713 } 19714 ios.width(25); 19715 internal(ios); 19716 { 19717 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19718 std::string ex(str, iter.base()); 19719 assert(ex == "-*****************0;0e+00"); 19720 assert(ios.width() == 0); 19721 } 19722 } 19723 } 19724 showpoint(ios); 19725 { 19726 ios.imbue(lc); 19727 { 19728 ios.width(0); 19729 { 19730 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19731 std::string ex(str, iter.base()); 19732 assert(ex == "-0.0e+00"); 19733 assert(ios.width() == 0); 19734 } 19735 ios.width(25); 19736 left(ios); 19737 { 19738 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19739 std::string ex(str, iter.base()); 19740 assert(ex == "-0.0e+00*****************"); 19741 assert(ios.width() == 0); 19742 } 19743 ios.width(25); 19744 right(ios); 19745 { 19746 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19747 std::string ex(str, iter.base()); 19748 assert(ex == "*****************-0.0e+00"); 19749 assert(ios.width() == 0); 19750 } 19751 ios.width(25); 19752 internal(ios); 19753 { 19754 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19755 std::string ex(str, iter.base()); 19756 assert(ex == "-*****************0.0e+00"); 19757 assert(ios.width() == 0); 19758 } 19759 } 19760 ios.imbue(lg); 19761 { 19762 ios.width(0); 19763 { 19764 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19765 std::string ex(str, iter.base()); 19766 assert(ex == "-0;0e+00"); 19767 assert(ios.width() == 0); 19768 } 19769 ios.width(25); 19770 left(ios); 19771 { 19772 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19773 std::string ex(str, iter.base()); 19774 assert(ex == "-0;0e+00*****************"); 19775 assert(ios.width() == 0); 19776 } 19777 ios.width(25); 19778 right(ios); 19779 { 19780 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19781 std::string ex(str, iter.base()); 19782 assert(ex == "*****************-0;0e+00"); 19783 assert(ios.width() == 0); 19784 } 19785 ios.width(25); 19786 internal(ios); 19787 { 19788 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19789 std::string ex(str, iter.base()); 19790 assert(ex == "-*****************0;0e+00"); 19791 assert(ios.width() == 0); 19792 } 19793 } 19794 } 19795 } 19796 showpos(ios); 19797 { 19798 noshowpoint(ios); 19799 { 19800 ios.imbue(lc); 19801 { 19802 ios.width(0); 19803 { 19804 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19805 std::string ex(str, iter.base()); 19806 assert(ex == "-0.0e+00"); 19807 assert(ios.width() == 0); 19808 } 19809 ios.width(25); 19810 left(ios); 19811 { 19812 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19813 std::string ex(str, iter.base()); 19814 assert(ex == "-0.0e+00*****************"); 19815 assert(ios.width() == 0); 19816 } 19817 ios.width(25); 19818 right(ios); 19819 { 19820 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19821 std::string ex(str, iter.base()); 19822 assert(ex == "*****************-0.0e+00"); 19823 assert(ios.width() == 0); 19824 } 19825 ios.width(25); 19826 internal(ios); 19827 { 19828 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19829 std::string ex(str, iter.base()); 19830 assert(ex == "-*****************0.0e+00"); 19831 assert(ios.width() == 0); 19832 } 19833 } 19834 ios.imbue(lg); 19835 { 19836 ios.width(0); 19837 { 19838 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19839 std::string ex(str, iter.base()); 19840 assert(ex == "-0;0e+00"); 19841 assert(ios.width() == 0); 19842 } 19843 ios.width(25); 19844 left(ios); 19845 { 19846 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19847 std::string ex(str, iter.base()); 19848 assert(ex == "-0;0e+00*****************"); 19849 assert(ios.width() == 0); 19850 } 19851 ios.width(25); 19852 right(ios); 19853 { 19854 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19855 std::string ex(str, iter.base()); 19856 assert(ex == "*****************-0;0e+00"); 19857 assert(ios.width() == 0); 19858 } 19859 ios.width(25); 19860 internal(ios); 19861 { 19862 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19863 std::string ex(str, iter.base()); 19864 assert(ex == "-*****************0;0e+00"); 19865 assert(ios.width() == 0); 19866 } 19867 } 19868 } 19869 showpoint(ios); 19870 { 19871 ios.imbue(lc); 19872 { 19873 ios.width(0); 19874 { 19875 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19876 std::string ex(str, iter.base()); 19877 assert(ex == "-0.0e+00"); 19878 assert(ios.width() == 0); 19879 } 19880 ios.width(25); 19881 left(ios); 19882 { 19883 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19884 std::string ex(str, iter.base()); 19885 assert(ex == "-0.0e+00*****************"); 19886 assert(ios.width() == 0); 19887 } 19888 ios.width(25); 19889 right(ios); 19890 { 19891 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19892 std::string ex(str, iter.base()); 19893 assert(ex == "*****************-0.0e+00"); 19894 assert(ios.width() == 0); 19895 } 19896 ios.width(25); 19897 internal(ios); 19898 { 19899 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19900 std::string ex(str, iter.base()); 19901 assert(ex == "-*****************0.0e+00"); 19902 assert(ios.width() == 0); 19903 } 19904 } 19905 ios.imbue(lg); 19906 { 19907 ios.width(0); 19908 { 19909 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19910 std::string ex(str, iter.base()); 19911 assert(ex == "-0;0e+00"); 19912 assert(ios.width() == 0); 19913 } 19914 ios.width(25); 19915 left(ios); 19916 { 19917 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19918 std::string ex(str, iter.base()); 19919 assert(ex == "-0;0e+00*****************"); 19920 assert(ios.width() == 0); 19921 } 19922 ios.width(25); 19923 right(ios); 19924 { 19925 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19926 std::string ex(str, iter.base()); 19927 assert(ex == "*****************-0;0e+00"); 19928 assert(ios.width() == 0); 19929 } 19930 ios.width(25); 19931 internal(ios); 19932 { 19933 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19934 std::string ex(str, iter.base()); 19935 assert(ex == "-*****************0;0e+00"); 19936 assert(ios.width() == 0); 19937 } 19938 } 19939 } 19940 } 19941 } 19942 uppercase(ios); 19943 { 19944 noshowpos(ios); 19945 { 19946 noshowpoint(ios); 19947 { 19948 ios.imbue(lc); 19949 { 19950 ios.width(0); 19951 { 19952 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19953 std::string ex(str, iter.base()); 19954 assert(ex == "-0.0E+00"); 19955 assert(ios.width() == 0); 19956 } 19957 ios.width(25); 19958 left(ios); 19959 { 19960 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19961 std::string ex(str, iter.base()); 19962 assert(ex == "-0.0E+00*****************"); 19963 assert(ios.width() == 0); 19964 } 19965 ios.width(25); 19966 right(ios); 19967 { 19968 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19969 std::string ex(str, iter.base()); 19970 assert(ex == "*****************-0.0E+00"); 19971 assert(ios.width() == 0); 19972 } 19973 ios.width(25); 19974 internal(ios); 19975 { 19976 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19977 std::string ex(str, iter.base()); 19978 assert(ex == "-*****************0.0E+00"); 19979 assert(ios.width() == 0); 19980 } 19981 } 19982 ios.imbue(lg); 19983 { 19984 ios.width(0); 19985 { 19986 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19987 std::string ex(str, iter.base()); 19988 assert(ex == "-0;0E+00"); 19989 assert(ios.width() == 0); 19990 } 19991 ios.width(25); 19992 left(ios); 19993 { 19994 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19995 std::string ex(str, iter.base()); 19996 assert(ex == "-0;0E+00*****************"); 19997 assert(ios.width() == 0); 19998 } 19999 ios.width(25); 20000 right(ios); 20001 { 20002 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20003 std::string ex(str, iter.base()); 20004 assert(ex == "*****************-0;0E+00"); 20005 assert(ios.width() == 0); 20006 } 20007 ios.width(25); 20008 internal(ios); 20009 { 20010 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20011 std::string ex(str, iter.base()); 20012 assert(ex == "-*****************0;0E+00"); 20013 assert(ios.width() == 0); 20014 } 20015 } 20016 } 20017 showpoint(ios); 20018 { 20019 ios.imbue(lc); 20020 { 20021 ios.width(0); 20022 { 20023 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20024 std::string ex(str, iter.base()); 20025 assert(ex == "-0.0E+00"); 20026 assert(ios.width() == 0); 20027 } 20028 ios.width(25); 20029 left(ios); 20030 { 20031 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20032 std::string ex(str, iter.base()); 20033 assert(ex == "-0.0E+00*****************"); 20034 assert(ios.width() == 0); 20035 } 20036 ios.width(25); 20037 right(ios); 20038 { 20039 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20040 std::string ex(str, iter.base()); 20041 assert(ex == "*****************-0.0E+00"); 20042 assert(ios.width() == 0); 20043 } 20044 ios.width(25); 20045 internal(ios); 20046 { 20047 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20048 std::string ex(str, iter.base()); 20049 assert(ex == "-*****************0.0E+00"); 20050 assert(ios.width() == 0); 20051 } 20052 } 20053 ios.imbue(lg); 20054 { 20055 ios.width(0); 20056 { 20057 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20058 std::string ex(str, iter.base()); 20059 assert(ex == "-0;0E+00"); 20060 assert(ios.width() == 0); 20061 } 20062 ios.width(25); 20063 left(ios); 20064 { 20065 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20066 std::string ex(str, iter.base()); 20067 assert(ex == "-0;0E+00*****************"); 20068 assert(ios.width() == 0); 20069 } 20070 ios.width(25); 20071 right(ios); 20072 { 20073 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20074 std::string ex(str, iter.base()); 20075 assert(ex == "*****************-0;0E+00"); 20076 assert(ios.width() == 0); 20077 } 20078 ios.width(25); 20079 internal(ios); 20080 { 20081 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20082 std::string ex(str, iter.base()); 20083 assert(ex == "-*****************0;0E+00"); 20084 assert(ios.width() == 0); 20085 } 20086 } 20087 } 20088 } 20089 showpos(ios); 20090 { 20091 noshowpoint(ios); 20092 { 20093 ios.imbue(lc); 20094 { 20095 ios.width(0); 20096 { 20097 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20098 std::string ex(str, iter.base()); 20099 assert(ex == "-0.0E+00"); 20100 assert(ios.width() == 0); 20101 } 20102 ios.width(25); 20103 left(ios); 20104 { 20105 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20106 std::string ex(str, iter.base()); 20107 assert(ex == "-0.0E+00*****************"); 20108 assert(ios.width() == 0); 20109 } 20110 ios.width(25); 20111 right(ios); 20112 { 20113 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20114 std::string ex(str, iter.base()); 20115 assert(ex == "*****************-0.0E+00"); 20116 assert(ios.width() == 0); 20117 } 20118 ios.width(25); 20119 internal(ios); 20120 { 20121 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20122 std::string ex(str, iter.base()); 20123 assert(ex == "-*****************0.0E+00"); 20124 assert(ios.width() == 0); 20125 } 20126 } 20127 ios.imbue(lg); 20128 { 20129 ios.width(0); 20130 { 20131 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20132 std::string ex(str, iter.base()); 20133 assert(ex == "-0;0E+00"); 20134 assert(ios.width() == 0); 20135 } 20136 ios.width(25); 20137 left(ios); 20138 { 20139 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20140 std::string ex(str, iter.base()); 20141 assert(ex == "-0;0E+00*****************"); 20142 assert(ios.width() == 0); 20143 } 20144 ios.width(25); 20145 right(ios); 20146 { 20147 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20148 std::string ex(str, iter.base()); 20149 assert(ex == "*****************-0;0E+00"); 20150 assert(ios.width() == 0); 20151 } 20152 ios.width(25); 20153 internal(ios); 20154 { 20155 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20156 std::string ex(str, iter.base()); 20157 assert(ex == "-*****************0;0E+00"); 20158 assert(ios.width() == 0); 20159 } 20160 } 20161 } 20162 showpoint(ios); 20163 { 20164 ios.imbue(lc); 20165 { 20166 ios.width(0); 20167 { 20168 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20169 std::string ex(str, iter.base()); 20170 assert(ex == "-0.0E+00"); 20171 assert(ios.width() == 0); 20172 } 20173 ios.width(25); 20174 left(ios); 20175 { 20176 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20177 std::string ex(str, iter.base()); 20178 assert(ex == "-0.0E+00*****************"); 20179 assert(ios.width() == 0); 20180 } 20181 ios.width(25); 20182 right(ios); 20183 { 20184 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20185 std::string ex(str, iter.base()); 20186 assert(ex == "*****************-0.0E+00"); 20187 assert(ios.width() == 0); 20188 } 20189 ios.width(25); 20190 internal(ios); 20191 { 20192 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20193 std::string ex(str, iter.base()); 20194 assert(ex == "-*****************0.0E+00"); 20195 assert(ios.width() == 0); 20196 } 20197 } 20198 ios.imbue(lg); 20199 { 20200 ios.width(0); 20201 { 20202 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20203 std::string ex(str, iter.base()); 20204 assert(ex == "-0;0E+00"); 20205 assert(ios.width() == 0); 20206 } 20207 ios.width(25); 20208 left(ios); 20209 { 20210 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20211 std::string ex(str, iter.base()); 20212 assert(ex == "-0;0E+00*****************"); 20213 assert(ios.width() == 0); 20214 } 20215 ios.width(25); 20216 right(ios); 20217 { 20218 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20219 std::string ex(str, iter.base()); 20220 assert(ex == "*****************-0;0E+00"); 20221 assert(ios.width() == 0); 20222 } 20223 ios.width(25); 20224 internal(ios); 20225 { 20226 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20227 std::string ex(str, iter.base()); 20228 assert(ex == "-*****************0;0E+00"); 20229 assert(ios.width() == 0); 20230 } 20231 } 20232 } 20233 } 20234 } 20235 } 20236 ios.precision(6); 20237 { 20238 nouppercase(ios); 20239 { 20240 noshowpos(ios); 20241 { 20242 noshowpoint(ios); 20243 { 20244 ios.imbue(lc); 20245 { 20246 ios.width(0); 20247 { 20248 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20249 std::string ex(str, iter.base()); 20250 assert(ex == "-0.000000e+00"); 20251 assert(ios.width() == 0); 20252 } 20253 ios.width(25); 20254 left(ios); 20255 { 20256 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20257 std::string ex(str, iter.base()); 20258 assert(ex == "-0.000000e+00************"); 20259 assert(ios.width() == 0); 20260 } 20261 ios.width(25); 20262 right(ios); 20263 { 20264 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20265 std::string ex(str, iter.base()); 20266 assert(ex == "************-0.000000e+00"); 20267 assert(ios.width() == 0); 20268 } 20269 ios.width(25); 20270 internal(ios); 20271 { 20272 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20273 std::string ex(str, iter.base()); 20274 assert(ex == "-************0.000000e+00"); 20275 assert(ios.width() == 0); 20276 } 20277 } 20278 ios.imbue(lg); 20279 { 20280 ios.width(0); 20281 { 20282 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20283 std::string ex(str, iter.base()); 20284 assert(ex == "-0;000000e+00"); 20285 assert(ios.width() == 0); 20286 } 20287 ios.width(25); 20288 left(ios); 20289 { 20290 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20291 std::string ex(str, iter.base()); 20292 assert(ex == "-0;000000e+00************"); 20293 assert(ios.width() == 0); 20294 } 20295 ios.width(25); 20296 right(ios); 20297 { 20298 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20299 std::string ex(str, iter.base()); 20300 assert(ex == "************-0;000000e+00"); 20301 assert(ios.width() == 0); 20302 } 20303 ios.width(25); 20304 internal(ios); 20305 { 20306 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20307 std::string ex(str, iter.base()); 20308 assert(ex == "-************0;000000e+00"); 20309 assert(ios.width() == 0); 20310 } 20311 } 20312 } 20313 showpoint(ios); 20314 { 20315 ios.imbue(lc); 20316 { 20317 ios.width(0); 20318 { 20319 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20320 std::string ex(str, iter.base()); 20321 assert(ex == "-0.000000e+00"); 20322 assert(ios.width() == 0); 20323 } 20324 ios.width(25); 20325 left(ios); 20326 { 20327 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20328 std::string ex(str, iter.base()); 20329 assert(ex == "-0.000000e+00************"); 20330 assert(ios.width() == 0); 20331 } 20332 ios.width(25); 20333 right(ios); 20334 { 20335 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20336 std::string ex(str, iter.base()); 20337 assert(ex == "************-0.000000e+00"); 20338 assert(ios.width() == 0); 20339 } 20340 ios.width(25); 20341 internal(ios); 20342 { 20343 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20344 std::string ex(str, iter.base()); 20345 assert(ex == "-************0.000000e+00"); 20346 assert(ios.width() == 0); 20347 } 20348 } 20349 ios.imbue(lg); 20350 { 20351 ios.width(0); 20352 { 20353 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20354 std::string ex(str, iter.base()); 20355 assert(ex == "-0;000000e+00"); 20356 assert(ios.width() == 0); 20357 } 20358 ios.width(25); 20359 left(ios); 20360 { 20361 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20362 std::string ex(str, iter.base()); 20363 assert(ex == "-0;000000e+00************"); 20364 assert(ios.width() == 0); 20365 } 20366 ios.width(25); 20367 right(ios); 20368 { 20369 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20370 std::string ex(str, iter.base()); 20371 assert(ex == "************-0;000000e+00"); 20372 assert(ios.width() == 0); 20373 } 20374 ios.width(25); 20375 internal(ios); 20376 { 20377 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20378 std::string ex(str, iter.base()); 20379 assert(ex == "-************0;000000e+00"); 20380 assert(ios.width() == 0); 20381 } 20382 } 20383 } 20384 } 20385 showpos(ios); 20386 { 20387 noshowpoint(ios); 20388 { 20389 ios.imbue(lc); 20390 { 20391 ios.width(0); 20392 { 20393 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20394 std::string ex(str, iter.base()); 20395 assert(ex == "-0.000000e+00"); 20396 assert(ios.width() == 0); 20397 } 20398 ios.width(25); 20399 left(ios); 20400 { 20401 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20402 std::string ex(str, iter.base()); 20403 assert(ex == "-0.000000e+00************"); 20404 assert(ios.width() == 0); 20405 } 20406 ios.width(25); 20407 right(ios); 20408 { 20409 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20410 std::string ex(str, iter.base()); 20411 assert(ex == "************-0.000000e+00"); 20412 assert(ios.width() == 0); 20413 } 20414 ios.width(25); 20415 internal(ios); 20416 { 20417 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20418 std::string ex(str, iter.base()); 20419 assert(ex == "-************0.000000e+00"); 20420 assert(ios.width() == 0); 20421 } 20422 } 20423 ios.imbue(lg); 20424 { 20425 ios.width(0); 20426 { 20427 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20428 std::string ex(str, iter.base()); 20429 assert(ex == "-0;000000e+00"); 20430 assert(ios.width() == 0); 20431 } 20432 ios.width(25); 20433 left(ios); 20434 { 20435 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20436 std::string ex(str, iter.base()); 20437 assert(ex == "-0;000000e+00************"); 20438 assert(ios.width() == 0); 20439 } 20440 ios.width(25); 20441 right(ios); 20442 { 20443 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20444 std::string ex(str, iter.base()); 20445 assert(ex == "************-0;000000e+00"); 20446 assert(ios.width() == 0); 20447 } 20448 ios.width(25); 20449 internal(ios); 20450 { 20451 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20452 std::string ex(str, iter.base()); 20453 assert(ex == "-************0;000000e+00"); 20454 assert(ios.width() == 0); 20455 } 20456 } 20457 } 20458 showpoint(ios); 20459 { 20460 ios.imbue(lc); 20461 { 20462 ios.width(0); 20463 { 20464 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20465 std::string ex(str, iter.base()); 20466 assert(ex == "-0.000000e+00"); 20467 assert(ios.width() == 0); 20468 } 20469 ios.width(25); 20470 left(ios); 20471 { 20472 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20473 std::string ex(str, iter.base()); 20474 assert(ex == "-0.000000e+00************"); 20475 assert(ios.width() == 0); 20476 } 20477 ios.width(25); 20478 right(ios); 20479 { 20480 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20481 std::string ex(str, iter.base()); 20482 assert(ex == "************-0.000000e+00"); 20483 assert(ios.width() == 0); 20484 } 20485 ios.width(25); 20486 internal(ios); 20487 { 20488 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20489 std::string ex(str, iter.base()); 20490 assert(ex == "-************0.000000e+00"); 20491 assert(ios.width() == 0); 20492 } 20493 } 20494 ios.imbue(lg); 20495 { 20496 ios.width(0); 20497 { 20498 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20499 std::string ex(str, iter.base()); 20500 assert(ex == "-0;000000e+00"); 20501 assert(ios.width() == 0); 20502 } 20503 ios.width(25); 20504 left(ios); 20505 { 20506 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20507 std::string ex(str, iter.base()); 20508 assert(ex == "-0;000000e+00************"); 20509 assert(ios.width() == 0); 20510 } 20511 ios.width(25); 20512 right(ios); 20513 { 20514 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20515 std::string ex(str, iter.base()); 20516 assert(ex == "************-0;000000e+00"); 20517 assert(ios.width() == 0); 20518 } 20519 ios.width(25); 20520 internal(ios); 20521 { 20522 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20523 std::string ex(str, iter.base()); 20524 assert(ex == "-************0;000000e+00"); 20525 assert(ios.width() == 0); 20526 } 20527 } 20528 } 20529 } 20530 } 20531 uppercase(ios); 20532 { 20533 noshowpos(ios); 20534 { 20535 noshowpoint(ios); 20536 { 20537 ios.imbue(lc); 20538 { 20539 ios.width(0); 20540 { 20541 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20542 std::string ex(str, iter.base()); 20543 assert(ex == "-0.000000E+00"); 20544 assert(ios.width() == 0); 20545 } 20546 ios.width(25); 20547 left(ios); 20548 { 20549 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20550 std::string ex(str, iter.base()); 20551 assert(ex == "-0.000000E+00************"); 20552 assert(ios.width() == 0); 20553 } 20554 ios.width(25); 20555 right(ios); 20556 { 20557 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20558 std::string ex(str, iter.base()); 20559 assert(ex == "************-0.000000E+00"); 20560 assert(ios.width() == 0); 20561 } 20562 ios.width(25); 20563 internal(ios); 20564 { 20565 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20566 std::string ex(str, iter.base()); 20567 assert(ex == "-************0.000000E+00"); 20568 assert(ios.width() == 0); 20569 } 20570 } 20571 ios.imbue(lg); 20572 { 20573 ios.width(0); 20574 { 20575 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20576 std::string ex(str, iter.base()); 20577 assert(ex == "-0;000000E+00"); 20578 assert(ios.width() == 0); 20579 } 20580 ios.width(25); 20581 left(ios); 20582 { 20583 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20584 std::string ex(str, iter.base()); 20585 assert(ex == "-0;000000E+00************"); 20586 assert(ios.width() == 0); 20587 } 20588 ios.width(25); 20589 right(ios); 20590 { 20591 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20592 std::string ex(str, iter.base()); 20593 assert(ex == "************-0;000000E+00"); 20594 assert(ios.width() == 0); 20595 } 20596 ios.width(25); 20597 internal(ios); 20598 { 20599 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20600 std::string ex(str, iter.base()); 20601 assert(ex == "-************0;000000E+00"); 20602 assert(ios.width() == 0); 20603 } 20604 } 20605 } 20606 showpoint(ios); 20607 { 20608 ios.imbue(lc); 20609 { 20610 ios.width(0); 20611 { 20612 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20613 std::string ex(str, iter.base()); 20614 assert(ex == "-0.000000E+00"); 20615 assert(ios.width() == 0); 20616 } 20617 ios.width(25); 20618 left(ios); 20619 { 20620 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20621 std::string ex(str, iter.base()); 20622 assert(ex == "-0.000000E+00************"); 20623 assert(ios.width() == 0); 20624 } 20625 ios.width(25); 20626 right(ios); 20627 { 20628 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20629 std::string ex(str, iter.base()); 20630 assert(ex == "************-0.000000E+00"); 20631 assert(ios.width() == 0); 20632 } 20633 ios.width(25); 20634 internal(ios); 20635 { 20636 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20637 std::string ex(str, iter.base()); 20638 assert(ex == "-************0.000000E+00"); 20639 assert(ios.width() == 0); 20640 } 20641 } 20642 ios.imbue(lg); 20643 { 20644 ios.width(0); 20645 { 20646 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20647 std::string ex(str, iter.base()); 20648 assert(ex == "-0;000000E+00"); 20649 assert(ios.width() == 0); 20650 } 20651 ios.width(25); 20652 left(ios); 20653 { 20654 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20655 std::string ex(str, iter.base()); 20656 assert(ex == "-0;000000E+00************"); 20657 assert(ios.width() == 0); 20658 } 20659 ios.width(25); 20660 right(ios); 20661 { 20662 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20663 std::string ex(str, iter.base()); 20664 assert(ex == "************-0;000000E+00"); 20665 assert(ios.width() == 0); 20666 } 20667 ios.width(25); 20668 internal(ios); 20669 { 20670 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20671 std::string ex(str, iter.base()); 20672 assert(ex == "-************0;000000E+00"); 20673 assert(ios.width() == 0); 20674 } 20675 } 20676 } 20677 } 20678 showpos(ios); 20679 { 20680 noshowpoint(ios); 20681 { 20682 ios.imbue(lc); 20683 { 20684 ios.width(0); 20685 { 20686 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20687 std::string ex(str, iter.base()); 20688 assert(ex == "-0.000000E+00"); 20689 assert(ios.width() == 0); 20690 } 20691 ios.width(25); 20692 left(ios); 20693 { 20694 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20695 std::string ex(str, iter.base()); 20696 assert(ex == "-0.000000E+00************"); 20697 assert(ios.width() == 0); 20698 } 20699 ios.width(25); 20700 right(ios); 20701 { 20702 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20703 std::string ex(str, iter.base()); 20704 assert(ex == "************-0.000000E+00"); 20705 assert(ios.width() == 0); 20706 } 20707 ios.width(25); 20708 internal(ios); 20709 { 20710 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20711 std::string ex(str, iter.base()); 20712 assert(ex == "-************0.000000E+00"); 20713 assert(ios.width() == 0); 20714 } 20715 } 20716 ios.imbue(lg); 20717 { 20718 ios.width(0); 20719 { 20720 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20721 std::string ex(str, iter.base()); 20722 assert(ex == "-0;000000E+00"); 20723 assert(ios.width() == 0); 20724 } 20725 ios.width(25); 20726 left(ios); 20727 { 20728 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20729 std::string ex(str, iter.base()); 20730 assert(ex == "-0;000000E+00************"); 20731 assert(ios.width() == 0); 20732 } 20733 ios.width(25); 20734 right(ios); 20735 { 20736 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20737 std::string ex(str, iter.base()); 20738 assert(ex == "************-0;000000E+00"); 20739 assert(ios.width() == 0); 20740 } 20741 ios.width(25); 20742 internal(ios); 20743 { 20744 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20745 std::string ex(str, iter.base()); 20746 assert(ex == "-************0;000000E+00"); 20747 assert(ios.width() == 0); 20748 } 20749 } 20750 } 20751 showpoint(ios); 20752 { 20753 ios.imbue(lc); 20754 { 20755 ios.width(0); 20756 { 20757 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20758 std::string ex(str, iter.base()); 20759 assert(ex == "-0.000000E+00"); 20760 assert(ios.width() == 0); 20761 } 20762 ios.width(25); 20763 left(ios); 20764 { 20765 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20766 std::string ex(str, iter.base()); 20767 assert(ex == "-0.000000E+00************"); 20768 assert(ios.width() == 0); 20769 } 20770 ios.width(25); 20771 right(ios); 20772 { 20773 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20774 std::string ex(str, iter.base()); 20775 assert(ex == "************-0.000000E+00"); 20776 assert(ios.width() == 0); 20777 } 20778 ios.width(25); 20779 internal(ios); 20780 { 20781 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20782 std::string ex(str, iter.base()); 20783 assert(ex == "-************0.000000E+00"); 20784 assert(ios.width() == 0); 20785 } 20786 } 20787 ios.imbue(lg); 20788 { 20789 ios.width(0); 20790 { 20791 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20792 std::string ex(str, iter.base()); 20793 assert(ex == "-0;000000E+00"); 20794 assert(ios.width() == 0); 20795 } 20796 ios.width(25); 20797 left(ios); 20798 { 20799 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20800 std::string ex(str, iter.base()); 20801 assert(ex == "-0;000000E+00************"); 20802 assert(ios.width() == 0); 20803 } 20804 ios.width(25); 20805 right(ios); 20806 { 20807 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20808 std::string ex(str, iter.base()); 20809 assert(ex == "************-0;000000E+00"); 20810 assert(ios.width() == 0); 20811 } 20812 ios.width(25); 20813 internal(ios); 20814 { 20815 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20816 std::string ex(str, iter.base()); 20817 assert(ex == "-************0;000000E+00"); 20818 assert(ios.width() == 0); 20819 } 20820 } 20821 } 20822 } 20823 } 20824 } 20825 ios.precision(16); 20826 { 20827 } 20828 ios.precision(60); 20829 { 20830 } 20831 } 20832 } 20833 } 20834 20835 void test10() 20836 { 20837 char str[200]; 20838 output_iterator<char*> iter; 20839 std::locale lc = std::locale::classic(); 20840 std::locale lg(lc, new my_numpunct); 20841 const my_facet f(1); 20842 { 20843 long double v = 1234567890.125; 20844 std::ios ios(0); 20845 scientific(ios); 20846 // %e 20847 { 20848 ios.precision(0); 20849 { 20850 nouppercase(ios); 20851 { 20852 noshowpos(ios); 20853 { 20854 noshowpoint(ios); 20855 { 20856 ios.imbue(lc); 20857 { 20858 ios.width(0); 20859 { 20860 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20861 std::string ex(str, iter.base()); 20862 assert(ex == "1e+09"); 20863 assert(ios.width() == 0); 20864 } 20865 ios.width(25); 20866 left(ios); 20867 { 20868 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20869 std::string ex(str, iter.base()); 20870 assert(ex == "1e+09********************"); 20871 assert(ios.width() == 0); 20872 } 20873 ios.width(25); 20874 right(ios); 20875 { 20876 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20877 std::string ex(str, iter.base()); 20878 assert(ex == "********************1e+09"); 20879 assert(ios.width() == 0); 20880 } 20881 ios.width(25); 20882 internal(ios); 20883 { 20884 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20885 std::string ex(str, iter.base()); 20886 assert(ex == "********************1e+09"); 20887 assert(ios.width() == 0); 20888 } 20889 } 20890 ios.imbue(lg); 20891 { 20892 ios.width(0); 20893 { 20894 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20895 std::string ex(str, iter.base()); 20896 assert(ex == "1e+09"); 20897 assert(ios.width() == 0); 20898 } 20899 ios.width(25); 20900 left(ios); 20901 { 20902 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20903 std::string ex(str, iter.base()); 20904 assert(ex == "1e+09********************"); 20905 assert(ios.width() == 0); 20906 } 20907 ios.width(25); 20908 right(ios); 20909 { 20910 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20911 std::string ex(str, iter.base()); 20912 assert(ex == "********************1e+09"); 20913 assert(ios.width() == 0); 20914 } 20915 ios.width(25); 20916 internal(ios); 20917 { 20918 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20919 std::string ex(str, iter.base()); 20920 assert(ex == "********************1e+09"); 20921 assert(ios.width() == 0); 20922 } 20923 } 20924 } 20925 showpoint(ios); 20926 { 20927 ios.imbue(lc); 20928 { 20929 ios.width(0); 20930 { 20931 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20932 std::string ex(str, iter.base()); 20933 assert(ex == "1.e+09"); 20934 assert(ios.width() == 0); 20935 } 20936 ios.width(25); 20937 left(ios); 20938 { 20939 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20940 std::string ex(str, iter.base()); 20941 assert(ex == "1.e+09*******************"); 20942 assert(ios.width() == 0); 20943 } 20944 ios.width(25); 20945 right(ios); 20946 { 20947 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20948 std::string ex(str, iter.base()); 20949 assert(ex == "*******************1.e+09"); 20950 assert(ios.width() == 0); 20951 } 20952 ios.width(25); 20953 internal(ios); 20954 { 20955 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20956 std::string ex(str, iter.base()); 20957 assert(ex == "*******************1.e+09"); 20958 assert(ios.width() == 0); 20959 } 20960 } 20961 ios.imbue(lg); 20962 { 20963 ios.width(0); 20964 { 20965 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20966 std::string ex(str, iter.base()); 20967 assert(ex == "1;e+09"); 20968 assert(ios.width() == 0); 20969 } 20970 ios.width(25); 20971 left(ios); 20972 { 20973 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20974 std::string ex(str, iter.base()); 20975 assert(ex == "1;e+09*******************"); 20976 assert(ios.width() == 0); 20977 } 20978 ios.width(25); 20979 right(ios); 20980 { 20981 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20982 std::string ex(str, iter.base()); 20983 assert(ex == "*******************1;e+09"); 20984 assert(ios.width() == 0); 20985 } 20986 ios.width(25); 20987 internal(ios); 20988 { 20989 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20990 std::string ex(str, iter.base()); 20991 assert(ex == "*******************1;e+09"); 20992 assert(ios.width() == 0); 20993 } 20994 } 20995 } 20996 } 20997 showpos(ios); 20998 { 20999 noshowpoint(ios); 21000 { 21001 ios.imbue(lc); 21002 { 21003 ios.width(0); 21004 { 21005 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21006 std::string ex(str, iter.base()); 21007 assert(ex == "+1e+09"); 21008 assert(ios.width() == 0); 21009 } 21010 ios.width(25); 21011 left(ios); 21012 { 21013 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21014 std::string ex(str, iter.base()); 21015 assert(ex == "+1e+09*******************"); 21016 assert(ios.width() == 0); 21017 } 21018 ios.width(25); 21019 right(ios); 21020 { 21021 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21022 std::string ex(str, iter.base()); 21023 assert(ex == "*******************+1e+09"); 21024 assert(ios.width() == 0); 21025 } 21026 ios.width(25); 21027 internal(ios); 21028 { 21029 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21030 std::string ex(str, iter.base()); 21031 assert(ex == "+*******************1e+09"); 21032 assert(ios.width() == 0); 21033 } 21034 } 21035 ios.imbue(lg); 21036 { 21037 ios.width(0); 21038 { 21039 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21040 std::string ex(str, iter.base()); 21041 assert(ex == "+1e+09"); 21042 assert(ios.width() == 0); 21043 } 21044 ios.width(25); 21045 left(ios); 21046 { 21047 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21048 std::string ex(str, iter.base()); 21049 assert(ex == "+1e+09*******************"); 21050 assert(ios.width() == 0); 21051 } 21052 ios.width(25); 21053 right(ios); 21054 { 21055 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21056 std::string ex(str, iter.base()); 21057 assert(ex == "*******************+1e+09"); 21058 assert(ios.width() == 0); 21059 } 21060 ios.width(25); 21061 internal(ios); 21062 { 21063 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21064 std::string ex(str, iter.base()); 21065 assert(ex == "+*******************1e+09"); 21066 assert(ios.width() == 0); 21067 } 21068 } 21069 } 21070 showpoint(ios); 21071 { 21072 ios.imbue(lc); 21073 { 21074 ios.width(0); 21075 { 21076 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21077 std::string ex(str, iter.base()); 21078 assert(ex == "+1.e+09"); 21079 assert(ios.width() == 0); 21080 } 21081 ios.width(25); 21082 left(ios); 21083 { 21084 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21085 std::string ex(str, iter.base()); 21086 assert(ex == "+1.e+09******************"); 21087 assert(ios.width() == 0); 21088 } 21089 ios.width(25); 21090 right(ios); 21091 { 21092 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21093 std::string ex(str, iter.base()); 21094 assert(ex == "******************+1.e+09"); 21095 assert(ios.width() == 0); 21096 } 21097 ios.width(25); 21098 internal(ios); 21099 { 21100 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21101 std::string ex(str, iter.base()); 21102 assert(ex == "+******************1.e+09"); 21103 assert(ios.width() == 0); 21104 } 21105 } 21106 ios.imbue(lg); 21107 { 21108 ios.width(0); 21109 { 21110 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21111 std::string ex(str, iter.base()); 21112 assert(ex == "+1;e+09"); 21113 assert(ios.width() == 0); 21114 } 21115 ios.width(25); 21116 left(ios); 21117 { 21118 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21119 std::string ex(str, iter.base()); 21120 assert(ex == "+1;e+09******************"); 21121 assert(ios.width() == 0); 21122 } 21123 ios.width(25); 21124 right(ios); 21125 { 21126 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21127 std::string ex(str, iter.base()); 21128 assert(ex == "******************+1;e+09"); 21129 assert(ios.width() == 0); 21130 } 21131 ios.width(25); 21132 internal(ios); 21133 { 21134 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21135 std::string ex(str, iter.base()); 21136 assert(ex == "+******************1;e+09"); 21137 assert(ios.width() == 0); 21138 } 21139 } 21140 } 21141 } 21142 } 21143 uppercase(ios); 21144 { 21145 noshowpos(ios); 21146 { 21147 noshowpoint(ios); 21148 { 21149 ios.imbue(lc); 21150 { 21151 ios.width(0); 21152 { 21153 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21154 std::string ex(str, iter.base()); 21155 assert(ex == "1E+09"); 21156 assert(ios.width() == 0); 21157 } 21158 ios.width(25); 21159 left(ios); 21160 { 21161 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21162 std::string ex(str, iter.base()); 21163 assert(ex == "1E+09********************"); 21164 assert(ios.width() == 0); 21165 } 21166 ios.width(25); 21167 right(ios); 21168 { 21169 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21170 std::string ex(str, iter.base()); 21171 assert(ex == "********************1E+09"); 21172 assert(ios.width() == 0); 21173 } 21174 ios.width(25); 21175 internal(ios); 21176 { 21177 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21178 std::string ex(str, iter.base()); 21179 assert(ex == "********************1E+09"); 21180 assert(ios.width() == 0); 21181 } 21182 } 21183 ios.imbue(lg); 21184 { 21185 ios.width(0); 21186 { 21187 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21188 std::string ex(str, iter.base()); 21189 assert(ex == "1E+09"); 21190 assert(ios.width() == 0); 21191 } 21192 ios.width(25); 21193 left(ios); 21194 { 21195 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21196 std::string ex(str, iter.base()); 21197 assert(ex == "1E+09********************"); 21198 assert(ios.width() == 0); 21199 } 21200 ios.width(25); 21201 right(ios); 21202 { 21203 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21204 std::string ex(str, iter.base()); 21205 assert(ex == "********************1E+09"); 21206 assert(ios.width() == 0); 21207 } 21208 ios.width(25); 21209 internal(ios); 21210 { 21211 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21212 std::string ex(str, iter.base()); 21213 assert(ex == "********************1E+09"); 21214 assert(ios.width() == 0); 21215 } 21216 } 21217 } 21218 showpoint(ios); 21219 { 21220 ios.imbue(lc); 21221 { 21222 ios.width(0); 21223 { 21224 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21225 std::string ex(str, iter.base()); 21226 assert(ex == "1.E+09"); 21227 assert(ios.width() == 0); 21228 } 21229 ios.width(25); 21230 left(ios); 21231 { 21232 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21233 std::string ex(str, iter.base()); 21234 assert(ex == "1.E+09*******************"); 21235 assert(ios.width() == 0); 21236 } 21237 ios.width(25); 21238 right(ios); 21239 { 21240 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21241 std::string ex(str, iter.base()); 21242 assert(ex == "*******************1.E+09"); 21243 assert(ios.width() == 0); 21244 } 21245 ios.width(25); 21246 internal(ios); 21247 { 21248 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21249 std::string ex(str, iter.base()); 21250 assert(ex == "*******************1.E+09"); 21251 assert(ios.width() == 0); 21252 } 21253 } 21254 ios.imbue(lg); 21255 { 21256 ios.width(0); 21257 { 21258 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21259 std::string ex(str, iter.base()); 21260 assert(ex == "1;E+09"); 21261 assert(ios.width() == 0); 21262 } 21263 ios.width(25); 21264 left(ios); 21265 { 21266 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21267 std::string ex(str, iter.base()); 21268 assert(ex == "1;E+09*******************"); 21269 assert(ios.width() == 0); 21270 } 21271 ios.width(25); 21272 right(ios); 21273 { 21274 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21275 std::string ex(str, iter.base()); 21276 assert(ex == "*******************1;E+09"); 21277 assert(ios.width() == 0); 21278 } 21279 ios.width(25); 21280 internal(ios); 21281 { 21282 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21283 std::string ex(str, iter.base()); 21284 assert(ex == "*******************1;E+09"); 21285 assert(ios.width() == 0); 21286 } 21287 } 21288 } 21289 } 21290 showpos(ios); 21291 { 21292 noshowpoint(ios); 21293 { 21294 ios.imbue(lc); 21295 { 21296 ios.width(0); 21297 { 21298 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21299 std::string ex(str, iter.base()); 21300 assert(ex == "+1E+09"); 21301 assert(ios.width() == 0); 21302 } 21303 ios.width(25); 21304 left(ios); 21305 { 21306 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21307 std::string ex(str, iter.base()); 21308 assert(ex == "+1E+09*******************"); 21309 assert(ios.width() == 0); 21310 } 21311 ios.width(25); 21312 right(ios); 21313 { 21314 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21315 std::string ex(str, iter.base()); 21316 assert(ex == "*******************+1E+09"); 21317 assert(ios.width() == 0); 21318 } 21319 ios.width(25); 21320 internal(ios); 21321 { 21322 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21323 std::string ex(str, iter.base()); 21324 assert(ex == "+*******************1E+09"); 21325 assert(ios.width() == 0); 21326 } 21327 } 21328 ios.imbue(lg); 21329 { 21330 ios.width(0); 21331 { 21332 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21333 std::string ex(str, iter.base()); 21334 assert(ex == "+1E+09"); 21335 assert(ios.width() == 0); 21336 } 21337 ios.width(25); 21338 left(ios); 21339 { 21340 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21341 std::string ex(str, iter.base()); 21342 assert(ex == "+1E+09*******************"); 21343 assert(ios.width() == 0); 21344 } 21345 ios.width(25); 21346 right(ios); 21347 { 21348 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21349 std::string ex(str, iter.base()); 21350 assert(ex == "*******************+1E+09"); 21351 assert(ios.width() == 0); 21352 } 21353 ios.width(25); 21354 internal(ios); 21355 { 21356 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21357 std::string ex(str, iter.base()); 21358 assert(ex == "+*******************1E+09"); 21359 assert(ios.width() == 0); 21360 } 21361 } 21362 } 21363 showpoint(ios); 21364 { 21365 ios.imbue(lc); 21366 { 21367 ios.width(0); 21368 { 21369 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21370 std::string ex(str, iter.base()); 21371 assert(ex == "+1.E+09"); 21372 assert(ios.width() == 0); 21373 } 21374 ios.width(25); 21375 left(ios); 21376 { 21377 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21378 std::string ex(str, iter.base()); 21379 assert(ex == "+1.E+09******************"); 21380 assert(ios.width() == 0); 21381 } 21382 ios.width(25); 21383 right(ios); 21384 { 21385 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21386 std::string ex(str, iter.base()); 21387 assert(ex == "******************+1.E+09"); 21388 assert(ios.width() == 0); 21389 } 21390 ios.width(25); 21391 internal(ios); 21392 { 21393 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21394 std::string ex(str, iter.base()); 21395 assert(ex == "+******************1.E+09"); 21396 assert(ios.width() == 0); 21397 } 21398 } 21399 ios.imbue(lg); 21400 { 21401 ios.width(0); 21402 { 21403 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21404 std::string ex(str, iter.base()); 21405 assert(ex == "+1;E+09"); 21406 assert(ios.width() == 0); 21407 } 21408 ios.width(25); 21409 left(ios); 21410 { 21411 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21412 std::string ex(str, iter.base()); 21413 assert(ex == "+1;E+09******************"); 21414 assert(ios.width() == 0); 21415 } 21416 ios.width(25); 21417 right(ios); 21418 { 21419 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21420 std::string ex(str, iter.base()); 21421 assert(ex == "******************+1;E+09"); 21422 assert(ios.width() == 0); 21423 } 21424 ios.width(25); 21425 internal(ios); 21426 { 21427 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21428 std::string ex(str, iter.base()); 21429 assert(ex == "+******************1;E+09"); 21430 assert(ios.width() == 0); 21431 } 21432 } 21433 } 21434 } 21435 } 21436 } 21437 ios.precision(1); 21438 { 21439 nouppercase(ios); 21440 { 21441 noshowpos(ios); 21442 { 21443 noshowpoint(ios); 21444 { 21445 ios.imbue(lc); 21446 { 21447 ios.width(0); 21448 { 21449 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21450 std::string ex(str, iter.base()); 21451 assert(ex == "1.2e+09"); 21452 assert(ios.width() == 0); 21453 } 21454 ios.width(25); 21455 left(ios); 21456 { 21457 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21458 std::string ex(str, iter.base()); 21459 assert(ex == "1.2e+09******************"); 21460 assert(ios.width() == 0); 21461 } 21462 ios.width(25); 21463 right(ios); 21464 { 21465 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21466 std::string ex(str, iter.base()); 21467 assert(ex == "******************1.2e+09"); 21468 assert(ios.width() == 0); 21469 } 21470 ios.width(25); 21471 internal(ios); 21472 { 21473 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21474 std::string ex(str, iter.base()); 21475 assert(ex == "******************1.2e+09"); 21476 assert(ios.width() == 0); 21477 } 21478 } 21479 ios.imbue(lg); 21480 { 21481 ios.width(0); 21482 { 21483 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21484 std::string ex(str, iter.base()); 21485 assert(ex == "1;2e+09"); 21486 assert(ios.width() == 0); 21487 } 21488 ios.width(25); 21489 left(ios); 21490 { 21491 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21492 std::string ex(str, iter.base()); 21493 assert(ex == "1;2e+09******************"); 21494 assert(ios.width() == 0); 21495 } 21496 ios.width(25); 21497 right(ios); 21498 { 21499 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21500 std::string ex(str, iter.base()); 21501 assert(ex == "******************1;2e+09"); 21502 assert(ios.width() == 0); 21503 } 21504 ios.width(25); 21505 internal(ios); 21506 { 21507 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21508 std::string ex(str, iter.base()); 21509 assert(ex == "******************1;2e+09"); 21510 assert(ios.width() == 0); 21511 } 21512 } 21513 } 21514 showpoint(ios); 21515 { 21516 ios.imbue(lc); 21517 { 21518 ios.width(0); 21519 { 21520 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21521 std::string ex(str, iter.base()); 21522 assert(ex == "1.2e+09"); 21523 assert(ios.width() == 0); 21524 } 21525 ios.width(25); 21526 left(ios); 21527 { 21528 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21529 std::string ex(str, iter.base()); 21530 assert(ex == "1.2e+09******************"); 21531 assert(ios.width() == 0); 21532 } 21533 ios.width(25); 21534 right(ios); 21535 { 21536 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21537 std::string ex(str, iter.base()); 21538 assert(ex == "******************1.2e+09"); 21539 assert(ios.width() == 0); 21540 } 21541 ios.width(25); 21542 internal(ios); 21543 { 21544 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21545 std::string ex(str, iter.base()); 21546 assert(ex == "******************1.2e+09"); 21547 assert(ios.width() == 0); 21548 } 21549 } 21550 ios.imbue(lg); 21551 { 21552 ios.width(0); 21553 { 21554 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21555 std::string ex(str, iter.base()); 21556 assert(ex == "1;2e+09"); 21557 assert(ios.width() == 0); 21558 } 21559 ios.width(25); 21560 left(ios); 21561 { 21562 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21563 std::string ex(str, iter.base()); 21564 assert(ex == "1;2e+09******************"); 21565 assert(ios.width() == 0); 21566 } 21567 ios.width(25); 21568 right(ios); 21569 { 21570 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21571 std::string ex(str, iter.base()); 21572 assert(ex == "******************1;2e+09"); 21573 assert(ios.width() == 0); 21574 } 21575 ios.width(25); 21576 internal(ios); 21577 { 21578 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21579 std::string ex(str, iter.base()); 21580 assert(ex == "******************1;2e+09"); 21581 assert(ios.width() == 0); 21582 } 21583 } 21584 } 21585 } 21586 showpos(ios); 21587 { 21588 noshowpoint(ios); 21589 { 21590 ios.imbue(lc); 21591 { 21592 ios.width(0); 21593 { 21594 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21595 std::string ex(str, iter.base()); 21596 assert(ex == "+1.2e+09"); 21597 assert(ios.width() == 0); 21598 } 21599 ios.width(25); 21600 left(ios); 21601 { 21602 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21603 std::string ex(str, iter.base()); 21604 assert(ex == "+1.2e+09*****************"); 21605 assert(ios.width() == 0); 21606 } 21607 ios.width(25); 21608 right(ios); 21609 { 21610 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21611 std::string ex(str, iter.base()); 21612 assert(ex == "*****************+1.2e+09"); 21613 assert(ios.width() == 0); 21614 } 21615 ios.width(25); 21616 internal(ios); 21617 { 21618 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21619 std::string ex(str, iter.base()); 21620 assert(ex == "+*****************1.2e+09"); 21621 assert(ios.width() == 0); 21622 } 21623 } 21624 ios.imbue(lg); 21625 { 21626 ios.width(0); 21627 { 21628 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21629 std::string ex(str, iter.base()); 21630 assert(ex == "+1;2e+09"); 21631 assert(ios.width() == 0); 21632 } 21633 ios.width(25); 21634 left(ios); 21635 { 21636 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21637 std::string ex(str, iter.base()); 21638 assert(ex == "+1;2e+09*****************"); 21639 assert(ios.width() == 0); 21640 } 21641 ios.width(25); 21642 right(ios); 21643 { 21644 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21645 std::string ex(str, iter.base()); 21646 assert(ex == "*****************+1;2e+09"); 21647 assert(ios.width() == 0); 21648 } 21649 ios.width(25); 21650 internal(ios); 21651 { 21652 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21653 std::string ex(str, iter.base()); 21654 assert(ex == "+*****************1;2e+09"); 21655 assert(ios.width() == 0); 21656 } 21657 } 21658 } 21659 showpoint(ios); 21660 { 21661 ios.imbue(lc); 21662 { 21663 ios.width(0); 21664 { 21665 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21666 std::string ex(str, iter.base()); 21667 assert(ex == "+1.2e+09"); 21668 assert(ios.width() == 0); 21669 } 21670 ios.width(25); 21671 left(ios); 21672 { 21673 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21674 std::string ex(str, iter.base()); 21675 assert(ex == "+1.2e+09*****************"); 21676 assert(ios.width() == 0); 21677 } 21678 ios.width(25); 21679 right(ios); 21680 { 21681 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21682 std::string ex(str, iter.base()); 21683 assert(ex == "*****************+1.2e+09"); 21684 assert(ios.width() == 0); 21685 } 21686 ios.width(25); 21687 internal(ios); 21688 { 21689 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21690 std::string ex(str, iter.base()); 21691 assert(ex == "+*****************1.2e+09"); 21692 assert(ios.width() == 0); 21693 } 21694 } 21695 ios.imbue(lg); 21696 { 21697 ios.width(0); 21698 { 21699 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21700 std::string ex(str, iter.base()); 21701 assert(ex == "+1;2e+09"); 21702 assert(ios.width() == 0); 21703 } 21704 ios.width(25); 21705 left(ios); 21706 { 21707 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21708 std::string ex(str, iter.base()); 21709 assert(ex == "+1;2e+09*****************"); 21710 assert(ios.width() == 0); 21711 } 21712 ios.width(25); 21713 right(ios); 21714 { 21715 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21716 std::string ex(str, iter.base()); 21717 assert(ex == "*****************+1;2e+09"); 21718 assert(ios.width() == 0); 21719 } 21720 ios.width(25); 21721 internal(ios); 21722 { 21723 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21724 std::string ex(str, iter.base()); 21725 assert(ex == "+*****************1;2e+09"); 21726 assert(ios.width() == 0); 21727 } 21728 } 21729 } 21730 } 21731 } 21732 uppercase(ios); 21733 { 21734 noshowpos(ios); 21735 { 21736 noshowpoint(ios); 21737 { 21738 ios.imbue(lc); 21739 { 21740 ios.width(0); 21741 { 21742 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21743 std::string ex(str, iter.base()); 21744 assert(ex == "1.2E+09"); 21745 assert(ios.width() == 0); 21746 } 21747 ios.width(25); 21748 left(ios); 21749 { 21750 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21751 std::string ex(str, iter.base()); 21752 assert(ex == "1.2E+09******************"); 21753 assert(ios.width() == 0); 21754 } 21755 ios.width(25); 21756 right(ios); 21757 { 21758 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21759 std::string ex(str, iter.base()); 21760 assert(ex == "******************1.2E+09"); 21761 assert(ios.width() == 0); 21762 } 21763 ios.width(25); 21764 internal(ios); 21765 { 21766 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21767 std::string ex(str, iter.base()); 21768 assert(ex == "******************1.2E+09"); 21769 assert(ios.width() == 0); 21770 } 21771 } 21772 ios.imbue(lg); 21773 { 21774 ios.width(0); 21775 { 21776 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21777 std::string ex(str, iter.base()); 21778 assert(ex == "1;2E+09"); 21779 assert(ios.width() == 0); 21780 } 21781 ios.width(25); 21782 left(ios); 21783 { 21784 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21785 std::string ex(str, iter.base()); 21786 assert(ex == "1;2E+09******************"); 21787 assert(ios.width() == 0); 21788 } 21789 ios.width(25); 21790 right(ios); 21791 { 21792 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21793 std::string ex(str, iter.base()); 21794 assert(ex == "******************1;2E+09"); 21795 assert(ios.width() == 0); 21796 } 21797 ios.width(25); 21798 internal(ios); 21799 { 21800 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21801 std::string ex(str, iter.base()); 21802 assert(ex == "******************1;2E+09"); 21803 assert(ios.width() == 0); 21804 } 21805 } 21806 } 21807 showpoint(ios); 21808 { 21809 ios.imbue(lc); 21810 { 21811 ios.width(0); 21812 { 21813 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21814 std::string ex(str, iter.base()); 21815 assert(ex == "1.2E+09"); 21816 assert(ios.width() == 0); 21817 } 21818 ios.width(25); 21819 left(ios); 21820 { 21821 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21822 std::string ex(str, iter.base()); 21823 assert(ex == "1.2E+09******************"); 21824 assert(ios.width() == 0); 21825 } 21826 ios.width(25); 21827 right(ios); 21828 { 21829 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21830 std::string ex(str, iter.base()); 21831 assert(ex == "******************1.2E+09"); 21832 assert(ios.width() == 0); 21833 } 21834 ios.width(25); 21835 internal(ios); 21836 { 21837 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21838 std::string ex(str, iter.base()); 21839 assert(ex == "******************1.2E+09"); 21840 assert(ios.width() == 0); 21841 } 21842 } 21843 ios.imbue(lg); 21844 { 21845 ios.width(0); 21846 { 21847 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21848 std::string ex(str, iter.base()); 21849 assert(ex == "1;2E+09"); 21850 assert(ios.width() == 0); 21851 } 21852 ios.width(25); 21853 left(ios); 21854 { 21855 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21856 std::string ex(str, iter.base()); 21857 assert(ex == "1;2E+09******************"); 21858 assert(ios.width() == 0); 21859 } 21860 ios.width(25); 21861 right(ios); 21862 { 21863 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21864 std::string ex(str, iter.base()); 21865 assert(ex == "******************1;2E+09"); 21866 assert(ios.width() == 0); 21867 } 21868 ios.width(25); 21869 internal(ios); 21870 { 21871 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21872 std::string ex(str, iter.base()); 21873 assert(ex == "******************1;2E+09"); 21874 assert(ios.width() == 0); 21875 } 21876 } 21877 } 21878 } 21879 showpos(ios); 21880 { 21881 noshowpoint(ios); 21882 { 21883 ios.imbue(lc); 21884 { 21885 ios.width(0); 21886 { 21887 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21888 std::string ex(str, iter.base()); 21889 assert(ex == "+1.2E+09"); 21890 assert(ios.width() == 0); 21891 } 21892 ios.width(25); 21893 left(ios); 21894 { 21895 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21896 std::string ex(str, iter.base()); 21897 assert(ex == "+1.2E+09*****************"); 21898 assert(ios.width() == 0); 21899 } 21900 ios.width(25); 21901 right(ios); 21902 { 21903 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21904 std::string ex(str, iter.base()); 21905 assert(ex == "*****************+1.2E+09"); 21906 assert(ios.width() == 0); 21907 } 21908 ios.width(25); 21909 internal(ios); 21910 { 21911 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21912 std::string ex(str, iter.base()); 21913 assert(ex == "+*****************1.2E+09"); 21914 assert(ios.width() == 0); 21915 } 21916 } 21917 ios.imbue(lg); 21918 { 21919 ios.width(0); 21920 { 21921 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21922 std::string ex(str, iter.base()); 21923 assert(ex == "+1;2E+09"); 21924 assert(ios.width() == 0); 21925 } 21926 ios.width(25); 21927 left(ios); 21928 { 21929 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21930 std::string ex(str, iter.base()); 21931 assert(ex == "+1;2E+09*****************"); 21932 assert(ios.width() == 0); 21933 } 21934 ios.width(25); 21935 right(ios); 21936 { 21937 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21938 std::string ex(str, iter.base()); 21939 assert(ex == "*****************+1;2E+09"); 21940 assert(ios.width() == 0); 21941 } 21942 ios.width(25); 21943 internal(ios); 21944 { 21945 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21946 std::string ex(str, iter.base()); 21947 assert(ex == "+*****************1;2E+09"); 21948 assert(ios.width() == 0); 21949 } 21950 } 21951 } 21952 showpoint(ios); 21953 { 21954 ios.imbue(lc); 21955 { 21956 ios.width(0); 21957 { 21958 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21959 std::string ex(str, iter.base()); 21960 assert(ex == "+1.2E+09"); 21961 assert(ios.width() == 0); 21962 } 21963 ios.width(25); 21964 left(ios); 21965 { 21966 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21967 std::string ex(str, iter.base()); 21968 assert(ex == "+1.2E+09*****************"); 21969 assert(ios.width() == 0); 21970 } 21971 ios.width(25); 21972 right(ios); 21973 { 21974 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21975 std::string ex(str, iter.base()); 21976 assert(ex == "*****************+1.2E+09"); 21977 assert(ios.width() == 0); 21978 } 21979 ios.width(25); 21980 internal(ios); 21981 { 21982 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21983 std::string ex(str, iter.base()); 21984 assert(ex == "+*****************1.2E+09"); 21985 assert(ios.width() == 0); 21986 } 21987 } 21988 ios.imbue(lg); 21989 { 21990 ios.width(0); 21991 { 21992 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21993 std::string ex(str, iter.base()); 21994 assert(ex == "+1;2E+09"); 21995 assert(ios.width() == 0); 21996 } 21997 ios.width(25); 21998 left(ios); 21999 { 22000 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22001 std::string ex(str, iter.base()); 22002 assert(ex == "+1;2E+09*****************"); 22003 assert(ios.width() == 0); 22004 } 22005 ios.width(25); 22006 right(ios); 22007 { 22008 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22009 std::string ex(str, iter.base()); 22010 assert(ex == "*****************+1;2E+09"); 22011 assert(ios.width() == 0); 22012 } 22013 ios.width(25); 22014 internal(ios); 22015 { 22016 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22017 std::string ex(str, iter.base()); 22018 assert(ex == "+*****************1;2E+09"); 22019 assert(ios.width() == 0); 22020 } 22021 } 22022 } 22023 } 22024 } 22025 } 22026 ios.precision(6); 22027 { 22028 } 22029 ios.precision(16); 22030 { 22031 } 22032 ios.precision(60); 22033 { 22034 nouppercase(ios); 22035 { 22036 noshowpos(ios); 22037 { 22038 noshowpoint(ios); 22039 { 22040 ios.imbue(lc); 22041 { 22042 ios.width(0); 22043 { 22044 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22045 std::string ex(str, iter.base()); 22046 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22047 assert(ios.width() == 0); 22048 } 22049 ios.width(25); 22050 left(ios); 22051 { 22052 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22053 std::string ex(str, iter.base()); 22054 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22055 assert(ios.width() == 0); 22056 } 22057 ios.width(25); 22058 right(ios); 22059 { 22060 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22061 std::string ex(str, iter.base()); 22062 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22063 assert(ios.width() == 0); 22064 } 22065 ios.width(25); 22066 internal(ios); 22067 { 22068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22069 std::string ex(str, iter.base()); 22070 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22071 assert(ios.width() == 0); 22072 } 22073 } 22074 ios.imbue(lg); 22075 { 22076 ios.width(0); 22077 { 22078 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22079 std::string ex(str, iter.base()); 22080 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22081 assert(ios.width() == 0); 22082 } 22083 ios.width(25); 22084 left(ios); 22085 { 22086 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22087 std::string ex(str, iter.base()); 22088 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22089 assert(ios.width() == 0); 22090 } 22091 ios.width(25); 22092 right(ios); 22093 { 22094 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22095 std::string ex(str, iter.base()); 22096 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22097 assert(ios.width() == 0); 22098 } 22099 ios.width(25); 22100 internal(ios); 22101 { 22102 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22103 std::string ex(str, iter.base()); 22104 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22105 assert(ios.width() == 0); 22106 } 22107 } 22108 } 22109 showpoint(ios); 22110 { 22111 ios.imbue(lc); 22112 { 22113 ios.width(0); 22114 { 22115 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22116 std::string ex(str, iter.base()); 22117 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22118 assert(ios.width() == 0); 22119 } 22120 ios.width(25); 22121 left(ios); 22122 { 22123 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22124 std::string ex(str, iter.base()); 22125 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22126 assert(ios.width() == 0); 22127 } 22128 ios.width(25); 22129 right(ios); 22130 { 22131 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22132 std::string ex(str, iter.base()); 22133 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22134 assert(ios.width() == 0); 22135 } 22136 ios.width(25); 22137 internal(ios); 22138 { 22139 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22140 std::string ex(str, iter.base()); 22141 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22142 assert(ios.width() == 0); 22143 } 22144 } 22145 ios.imbue(lg); 22146 { 22147 ios.width(0); 22148 { 22149 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22150 std::string ex(str, iter.base()); 22151 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22152 assert(ios.width() == 0); 22153 } 22154 ios.width(25); 22155 left(ios); 22156 { 22157 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22158 std::string ex(str, iter.base()); 22159 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22160 assert(ios.width() == 0); 22161 } 22162 ios.width(25); 22163 right(ios); 22164 { 22165 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22166 std::string ex(str, iter.base()); 22167 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22168 assert(ios.width() == 0); 22169 } 22170 ios.width(25); 22171 internal(ios); 22172 { 22173 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22174 std::string ex(str, iter.base()); 22175 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22176 assert(ios.width() == 0); 22177 } 22178 } 22179 } 22180 } 22181 showpos(ios); 22182 { 22183 noshowpoint(ios); 22184 { 22185 ios.imbue(lc); 22186 { 22187 ios.width(0); 22188 { 22189 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22190 std::string ex(str, iter.base()); 22191 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22192 assert(ios.width() == 0); 22193 } 22194 ios.width(25); 22195 left(ios); 22196 { 22197 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22198 std::string ex(str, iter.base()); 22199 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22200 assert(ios.width() == 0); 22201 } 22202 ios.width(25); 22203 right(ios); 22204 { 22205 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22206 std::string ex(str, iter.base()); 22207 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22208 assert(ios.width() == 0); 22209 } 22210 ios.width(25); 22211 internal(ios); 22212 { 22213 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22214 std::string ex(str, iter.base()); 22215 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22216 assert(ios.width() == 0); 22217 } 22218 } 22219 ios.imbue(lg); 22220 { 22221 ios.width(0); 22222 { 22223 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22224 std::string ex(str, iter.base()); 22225 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22226 assert(ios.width() == 0); 22227 } 22228 ios.width(25); 22229 left(ios); 22230 { 22231 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22232 std::string ex(str, iter.base()); 22233 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22234 assert(ios.width() == 0); 22235 } 22236 ios.width(25); 22237 right(ios); 22238 { 22239 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22240 std::string ex(str, iter.base()); 22241 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22242 assert(ios.width() == 0); 22243 } 22244 ios.width(25); 22245 internal(ios); 22246 { 22247 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22248 std::string ex(str, iter.base()); 22249 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22250 assert(ios.width() == 0); 22251 } 22252 } 22253 } 22254 showpoint(ios); 22255 { 22256 ios.imbue(lc); 22257 { 22258 ios.width(0); 22259 { 22260 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22261 std::string ex(str, iter.base()); 22262 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22263 assert(ios.width() == 0); 22264 } 22265 ios.width(25); 22266 left(ios); 22267 { 22268 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22269 std::string ex(str, iter.base()); 22270 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22271 assert(ios.width() == 0); 22272 } 22273 ios.width(25); 22274 right(ios); 22275 { 22276 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22277 std::string ex(str, iter.base()); 22278 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22279 assert(ios.width() == 0); 22280 } 22281 ios.width(25); 22282 internal(ios); 22283 { 22284 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22285 std::string ex(str, iter.base()); 22286 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22287 assert(ios.width() == 0); 22288 } 22289 } 22290 ios.imbue(lg); 22291 { 22292 ios.width(0); 22293 { 22294 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22295 std::string ex(str, iter.base()); 22296 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22297 assert(ios.width() == 0); 22298 } 22299 ios.width(25); 22300 left(ios); 22301 { 22302 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22303 std::string ex(str, iter.base()); 22304 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22305 assert(ios.width() == 0); 22306 } 22307 ios.width(25); 22308 right(ios); 22309 { 22310 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22311 std::string ex(str, iter.base()); 22312 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22313 assert(ios.width() == 0); 22314 } 22315 ios.width(25); 22316 internal(ios); 22317 { 22318 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22319 std::string ex(str, iter.base()); 22320 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22321 assert(ios.width() == 0); 22322 } 22323 } 22324 } 22325 } 22326 } 22327 uppercase(ios); 22328 { 22329 noshowpos(ios); 22330 { 22331 noshowpoint(ios); 22332 { 22333 ios.imbue(lc); 22334 { 22335 ios.width(0); 22336 { 22337 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22338 std::string ex(str, iter.base()); 22339 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22340 assert(ios.width() == 0); 22341 } 22342 ios.width(25); 22343 left(ios); 22344 { 22345 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22346 std::string ex(str, iter.base()); 22347 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22348 assert(ios.width() == 0); 22349 } 22350 ios.width(25); 22351 right(ios); 22352 { 22353 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22354 std::string ex(str, iter.base()); 22355 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22356 assert(ios.width() == 0); 22357 } 22358 ios.width(25); 22359 internal(ios); 22360 { 22361 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22362 std::string ex(str, iter.base()); 22363 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22364 assert(ios.width() == 0); 22365 } 22366 } 22367 ios.imbue(lg); 22368 { 22369 ios.width(0); 22370 { 22371 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22372 std::string ex(str, iter.base()); 22373 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22374 assert(ios.width() == 0); 22375 } 22376 ios.width(25); 22377 left(ios); 22378 { 22379 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22380 std::string ex(str, iter.base()); 22381 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22382 assert(ios.width() == 0); 22383 } 22384 ios.width(25); 22385 right(ios); 22386 { 22387 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22388 std::string ex(str, iter.base()); 22389 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22390 assert(ios.width() == 0); 22391 } 22392 ios.width(25); 22393 internal(ios); 22394 { 22395 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22396 std::string ex(str, iter.base()); 22397 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22398 assert(ios.width() == 0); 22399 } 22400 } 22401 } 22402 showpoint(ios); 22403 { 22404 ios.imbue(lc); 22405 { 22406 ios.width(0); 22407 { 22408 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22409 std::string ex(str, iter.base()); 22410 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22411 assert(ios.width() == 0); 22412 } 22413 ios.width(25); 22414 left(ios); 22415 { 22416 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22417 std::string ex(str, iter.base()); 22418 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22419 assert(ios.width() == 0); 22420 } 22421 ios.width(25); 22422 right(ios); 22423 { 22424 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22425 std::string ex(str, iter.base()); 22426 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22427 assert(ios.width() == 0); 22428 } 22429 ios.width(25); 22430 internal(ios); 22431 { 22432 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22433 std::string ex(str, iter.base()); 22434 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22435 assert(ios.width() == 0); 22436 } 22437 } 22438 ios.imbue(lg); 22439 { 22440 ios.width(0); 22441 { 22442 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22443 std::string ex(str, iter.base()); 22444 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22445 assert(ios.width() == 0); 22446 } 22447 ios.width(25); 22448 left(ios); 22449 { 22450 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22451 std::string ex(str, iter.base()); 22452 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22453 assert(ios.width() == 0); 22454 } 22455 ios.width(25); 22456 right(ios); 22457 { 22458 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22459 std::string ex(str, iter.base()); 22460 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22461 assert(ios.width() == 0); 22462 } 22463 ios.width(25); 22464 internal(ios); 22465 { 22466 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22467 std::string ex(str, iter.base()); 22468 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22469 assert(ios.width() == 0); 22470 } 22471 } 22472 } 22473 } 22474 showpos(ios); 22475 { 22476 noshowpoint(ios); 22477 { 22478 ios.imbue(lc); 22479 { 22480 ios.width(0); 22481 { 22482 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22483 std::string ex(str, iter.base()); 22484 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22485 assert(ios.width() == 0); 22486 } 22487 ios.width(25); 22488 left(ios); 22489 { 22490 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22491 std::string ex(str, iter.base()); 22492 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22493 assert(ios.width() == 0); 22494 } 22495 ios.width(25); 22496 right(ios); 22497 { 22498 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22499 std::string ex(str, iter.base()); 22500 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22501 assert(ios.width() == 0); 22502 } 22503 ios.width(25); 22504 internal(ios); 22505 { 22506 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22507 std::string ex(str, iter.base()); 22508 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22509 assert(ios.width() == 0); 22510 } 22511 } 22512 ios.imbue(lg); 22513 { 22514 ios.width(0); 22515 { 22516 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22517 std::string ex(str, iter.base()); 22518 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22519 assert(ios.width() == 0); 22520 } 22521 ios.width(25); 22522 left(ios); 22523 { 22524 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22525 std::string ex(str, iter.base()); 22526 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22527 assert(ios.width() == 0); 22528 } 22529 ios.width(25); 22530 right(ios); 22531 { 22532 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22533 std::string ex(str, iter.base()); 22534 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22535 assert(ios.width() == 0); 22536 } 22537 ios.width(25); 22538 internal(ios); 22539 { 22540 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22541 std::string ex(str, iter.base()); 22542 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22543 assert(ios.width() == 0); 22544 } 22545 } 22546 } 22547 showpoint(ios); 22548 { 22549 ios.imbue(lc); 22550 { 22551 ios.width(0); 22552 { 22553 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22554 std::string ex(str, iter.base()); 22555 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22556 assert(ios.width() == 0); 22557 } 22558 ios.width(25); 22559 left(ios); 22560 { 22561 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22562 std::string ex(str, iter.base()); 22563 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22564 assert(ios.width() == 0); 22565 } 22566 ios.width(25); 22567 right(ios); 22568 { 22569 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22570 std::string ex(str, iter.base()); 22571 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22572 assert(ios.width() == 0); 22573 } 22574 ios.width(25); 22575 internal(ios); 22576 { 22577 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22578 std::string ex(str, iter.base()); 22579 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22580 assert(ios.width() == 0); 22581 } 22582 } 22583 ios.imbue(lg); 22584 { 22585 ios.width(0); 22586 { 22587 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22588 std::string ex(str, iter.base()); 22589 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22590 assert(ios.width() == 0); 22591 } 22592 ios.width(25); 22593 left(ios); 22594 { 22595 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22596 std::string ex(str, iter.base()); 22597 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22598 assert(ios.width() == 0); 22599 } 22600 ios.width(25); 22601 right(ios); 22602 { 22603 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22604 std::string ex(str, iter.base()); 22605 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22606 assert(ios.width() == 0); 22607 } 22608 ios.width(25); 22609 internal(ios); 22610 { 22611 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22612 std::string ex(str, iter.base()); 22613 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22614 assert(ios.width() == 0); 22615 } 22616 } 22617 } 22618 } 22619 } 22620 } 22621 } 22622 } 22623 } 22624 22625 void test11() 22626 { 22627 char str[200]; 22628 output_iterator<char*> iter; 22629 std::locale lc = std::locale::classic(); 22630 std::locale lg(lc, new my_numpunct); 22631 const my_facet f(1); 22632 { 22633 long double v = -0.; 22634 std::ios ios(0); 22635 hexfloat(ios); 22636 // %a 22637 { 22638 ios.precision(0); 22639 { 22640 nouppercase(ios); 22641 { 22642 noshowpos(ios); 22643 { 22644 noshowpoint(ios); 22645 { 22646 ios.imbue(lc); 22647 { 22648 ios.width(0); 22649 { 22650 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22651 std::string ex(str, iter.base()); 22652 assert(ex == "-0x0p+0"); 22653 assert(ios.width() == 0); 22654 } 22655 ios.width(25); 22656 left(ios); 22657 { 22658 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22659 std::string ex(str, iter.base()); 22660 assert(ex == "-0x0p+0******************"); 22661 assert(ios.width() == 0); 22662 } 22663 ios.width(25); 22664 right(ios); 22665 { 22666 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22667 std::string ex(str, iter.base()); 22668 assert(ex == "******************-0x0p+0"); 22669 assert(ios.width() == 0); 22670 } 22671 ios.width(25); 22672 internal(ios); 22673 { 22674 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22675 std::string ex(str, iter.base()); 22676 assert(ex == "-******************0x0p+0"); 22677 assert(ios.width() == 0); 22678 } 22679 } 22680 ios.imbue(lg); 22681 { 22682 ios.width(0); 22683 { 22684 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22685 std::string ex(str, iter.base()); 22686 assert(ex == "-0x0p+0"); 22687 assert(ios.width() == 0); 22688 } 22689 ios.width(25); 22690 left(ios); 22691 { 22692 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22693 std::string ex(str, iter.base()); 22694 assert(ex == "-0x0p+0******************"); 22695 assert(ios.width() == 0); 22696 } 22697 ios.width(25); 22698 right(ios); 22699 { 22700 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22701 std::string ex(str, iter.base()); 22702 assert(ex == "******************-0x0p+0"); 22703 assert(ios.width() == 0); 22704 } 22705 ios.width(25); 22706 internal(ios); 22707 { 22708 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22709 std::string ex(str, iter.base()); 22710 assert(ex == "-******************0x0p+0"); 22711 assert(ios.width() == 0); 22712 } 22713 } 22714 } 22715 showpoint(ios); 22716 { 22717 ios.imbue(lc); 22718 { 22719 ios.width(0); 22720 { 22721 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22722 std::string ex(str, iter.base()); 22723 assert(ex == "-0x0.p+0"); 22724 assert(ios.width() == 0); 22725 } 22726 ios.width(25); 22727 left(ios); 22728 { 22729 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22730 std::string ex(str, iter.base()); 22731 assert(ex == "-0x0.p+0*****************"); 22732 assert(ios.width() == 0); 22733 } 22734 ios.width(25); 22735 right(ios); 22736 { 22737 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22738 std::string ex(str, iter.base()); 22739 assert(ex == "*****************-0x0.p+0"); 22740 assert(ios.width() == 0); 22741 } 22742 ios.width(25); 22743 internal(ios); 22744 { 22745 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22746 std::string ex(str, iter.base()); 22747 assert(ex == "-*****************0x0.p+0"); 22748 assert(ios.width() == 0); 22749 } 22750 } 22751 ios.imbue(lg); 22752 { 22753 ios.width(0); 22754 { 22755 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22756 std::string ex(str, iter.base()); 22757 assert(ex == "-0x0;p+0"); 22758 assert(ios.width() == 0); 22759 } 22760 ios.width(25); 22761 left(ios); 22762 { 22763 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22764 std::string ex(str, iter.base()); 22765 assert(ex == "-0x0;p+0*****************"); 22766 assert(ios.width() == 0); 22767 } 22768 ios.width(25); 22769 right(ios); 22770 { 22771 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22772 std::string ex(str, iter.base()); 22773 assert(ex == "*****************-0x0;p+0"); 22774 assert(ios.width() == 0); 22775 } 22776 ios.width(25); 22777 internal(ios); 22778 { 22779 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22780 std::string ex(str, iter.base()); 22781 assert(ex == "-*****************0x0;p+0"); 22782 assert(ios.width() == 0); 22783 } 22784 } 22785 } 22786 } 22787 showpos(ios); 22788 { 22789 noshowpoint(ios); 22790 { 22791 ios.imbue(lc); 22792 { 22793 ios.width(0); 22794 { 22795 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22796 std::string ex(str, iter.base()); 22797 assert(ex == "-0x0p+0"); 22798 assert(ios.width() == 0); 22799 } 22800 ios.width(25); 22801 left(ios); 22802 { 22803 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22804 std::string ex(str, iter.base()); 22805 assert(ex == "-0x0p+0******************"); 22806 assert(ios.width() == 0); 22807 } 22808 ios.width(25); 22809 right(ios); 22810 { 22811 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22812 std::string ex(str, iter.base()); 22813 assert(ex == "******************-0x0p+0"); 22814 assert(ios.width() == 0); 22815 } 22816 ios.width(25); 22817 internal(ios); 22818 { 22819 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22820 std::string ex(str, iter.base()); 22821 assert(ex == "-******************0x0p+0"); 22822 assert(ios.width() == 0); 22823 } 22824 } 22825 ios.imbue(lg); 22826 { 22827 ios.width(0); 22828 { 22829 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22830 std::string ex(str, iter.base()); 22831 assert(ex == "-0x0p+0"); 22832 assert(ios.width() == 0); 22833 } 22834 ios.width(25); 22835 left(ios); 22836 { 22837 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22838 std::string ex(str, iter.base()); 22839 assert(ex == "-0x0p+0******************"); 22840 assert(ios.width() == 0); 22841 } 22842 ios.width(25); 22843 right(ios); 22844 { 22845 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22846 std::string ex(str, iter.base()); 22847 assert(ex == "******************-0x0p+0"); 22848 assert(ios.width() == 0); 22849 } 22850 ios.width(25); 22851 internal(ios); 22852 { 22853 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22854 std::string ex(str, iter.base()); 22855 assert(ex == "-******************0x0p+0"); 22856 assert(ios.width() == 0); 22857 } 22858 } 22859 } 22860 showpoint(ios); 22861 { 22862 ios.imbue(lc); 22863 { 22864 ios.width(0); 22865 { 22866 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22867 std::string ex(str, iter.base()); 22868 assert(ex == "-0x0.p+0"); 22869 assert(ios.width() == 0); 22870 } 22871 ios.width(25); 22872 left(ios); 22873 { 22874 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22875 std::string ex(str, iter.base()); 22876 assert(ex == "-0x0.p+0*****************"); 22877 assert(ios.width() == 0); 22878 } 22879 ios.width(25); 22880 right(ios); 22881 { 22882 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22883 std::string ex(str, iter.base()); 22884 assert(ex == "*****************-0x0.p+0"); 22885 assert(ios.width() == 0); 22886 } 22887 ios.width(25); 22888 internal(ios); 22889 { 22890 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22891 std::string ex(str, iter.base()); 22892 assert(ex == "-*****************0x0.p+0"); 22893 assert(ios.width() == 0); 22894 } 22895 } 22896 ios.imbue(lg); 22897 { 22898 ios.width(0); 22899 { 22900 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22901 std::string ex(str, iter.base()); 22902 assert(ex == "-0x0;p+0"); 22903 assert(ios.width() == 0); 22904 } 22905 ios.width(25); 22906 left(ios); 22907 { 22908 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22909 std::string ex(str, iter.base()); 22910 assert(ex == "-0x0;p+0*****************"); 22911 assert(ios.width() == 0); 22912 } 22913 ios.width(25); 22914 right(ios); 22915 { 22916 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22917 std::string ex(str, iter.base()); 22918 assert(ex == "*****************-0x0;p+0"); 22919 assert(ios.width() == 0); 22920 } 22921 ios.width(25); 22922 internal(ios); 22923 { 22924 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22925 std::string ex(str, iter.base()); 22926 assert(ex == "-*****************0x0;p+0"); 22927 assert(ios.width() == 0); 22928 } 22929 } 22930 } 22931 } 22932 } 22933 uppercase(ios); 22934 { 22935 noshowpos(ios); 22936 { 22937 noshowpoint(ios); 22938 { 22939 ios.imbue(lc); 22940 { 22941 ios.width(0); 22942 { 22943 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22944 std::string ex(str, iter.base()); 22945 assert(ex == "-0X0P+0"); 22946 assert(ios.width() == 0); 22947 } 22948 ios.width(25); 22949 left(ios); 22950 { 22951 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22952 std::string ex(str, iter.base()); 22953 assert(ex == "-0X0P+0******************"); 22954 assert(ios.width() == 0); 22955 } 22956 ios.width(25); 22957 right(ios); 22958 { 22959 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22960 std::string ex(str, iter.base()); 22961 assert(ex == "******************-0X0P+0"); 22962 assert(ios.width() == 0); 22963 } 22964 ios.width(25); 22965 internal(ios); 22966 { 22967 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22968 std::string ex(str, iter.base()); 22969 assert(ex == "-******************0X0P+0"); 22970 assert(ios.width() == 0); 22971 } 22972 } 22973 ios.imbue(lg); 22974 { 22975 ios.width(0); 22976 { 22977 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22978 std::string ex(str, iter.base()); 22979 assert(ex == "-0X0P+0"); 22980 assert(ios.width() == 0); 22981 } 22982 ios.width(25); 22983 left(ios); 22984 { 22985 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22986 std::string ex(str, iter.base()); 22987 assert(ex == "-0X0P+0******************"); 22988 assert(ios.width() == 0); 22989 } 22990 ios.width(25); 22991 right(ios); 22992 { 22993 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22994 std::string ex(str, iter.base()); 22995 assert(ex == "******************-0X0P+0"); 22996 assert(ios.width() == 0); 22997 } 22998 ios.width(25); 22999 internal(ios); 23000 { 23001 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23002 std::string ex(str, iter.base()); 23003 assert(ex == "-******************0X0P+0"); 23004 assert(ios.width() == 0); 23005 } 23006 } 23007 } 23008 showpoint(ios); 23009 { 23010 ios.imbue(lc); 23011 { 23012 ios.width(0); 23013 { 23014 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23015 std::string ex(str, iter.base()); 23016 assert(ex == "-0X0.P+0"); 23017 assert(ios.width() == 0); 23018 } 23019 ios.width(25); 23020 left(ios); 23021 { 23022 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23023 std::string ex(str, iter.base()); 23024 assert(ex == "-0X0.P+0*****************"); 23025 assert(ios.width() == 0); 23026 } 23027 ios.width(25); 23028 right(ios); 23029 { 23030 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23031 std::string ex(str, iter.base()); 23032 assert(ex == "*****************-0X0.P+0"); 23033 assert(ios.width() == 0); 23034 } 23035 ios.width(25); 23036 internal(ios); 23037 { 23038 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23039 std::string ex(str, iter.base()); 23040 assert(ex == "-*****************0X0.P+0"); 23041 assert(ios.width() == 0); 23042 } 23043 } 23044 ios.imbue(lg); 23045 { 23046 ios.width(0); 23047 { 23048 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23049 std::string ex(str, iter.base()); 23050 assert(ex == "-0X0;P+0"); 23051 assert(ios.width() == 0); 23052 } 23053 ios.width(25); 23054 left(ios); 23055 { 23056 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23057 std::string ex(str, iter.base()); 23058 assert(ex == "-0X0;P+0*****************"); 23059 assert(ios.width() == 0); 23060 } 23061 ios.width(25); 23062 right(ios); 23063 { 23064 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23065 std::string ex(str, iter.base()); 23066 assert(ex == "*****************-0X0;P+0"); 23067 assert(ios.width() == 0); 23068 } 23069 ios.width(25); 23070 internal(ios); 23071 { 23072 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23073 std::string ex(str, iter.base()); 23074 assert(ex == "-*****************0X0;P+0"); 23075 assert(ios.width() == 0); 23076 } 23077 } 23078 } 23079 } 23080 showpos(ios); 23081 { 23082 noshowpoint(ios); 23083 { 23084 ios.imbue(lc); 23085 { 23086 ios.width(0); 23087 { 23088 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23089 std::string ex(str, iter.base()); 23090 assert(ex == "-0X0P+0"); 23091 assert(ios.width() == 0); 23092 } 23093 ios.width(25); 23094 left(ios); 23095 { 23096 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23097 std::string ex(str, iter.base()); 23098 assert(ex == "-0X0P+0******************"); 23099 assert(ios.width() == 0); 23100 } 23101 ios.width(25); 23102 right(ios); 23103 { 23104 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23105 std::string ex(str, iter.base()); 23106 assert(ex == "******************-0X0P+0"); 23107 assert(ios.width() == 0); 23108 } 23109 ios.width(25); 23110 internal(ios); 23111 { 23112 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23113 std::string ex(str, iter.base()); 23114 assert(ex == "-******************0X0P+0"); 23115 assert(ios.width() == 0); 23116 } 23117 } 23118 ios.imbue(lg); 23119 { 23120 ios.width(0); 23121 { 23122 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23123 std::string ex(str, iter.base()); 23124 assert(ex == "-0X0P+0"); 23125 assert(ios.width() == 0); 23126 } 23127 ios.width(25); 23128 left(ios); 23129 { 23130 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23131 std::string ex(str, iter.base()); 23132 assert(ex == "-0X0P+0******************"); 23133 assert(ios.width() == 0); 23134 } 23135 ios.width(25); 23136 right(ios); 23137 { 23138 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23139 std::string ex(str, iter.base()); 23140 assert(ex == "******************-0X0P+0"); 23141 assert(ios.width() == 0); 23142 } 23143 ios.width(25); 23144 internal(ios); 23145 { 23146 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23147 std::string ex(str, iter.base()); 23148 assert(ex == "-******************0X0P+0"); 23149 assert(ios.width() == 0); 23150 } 23151 } 23152 } 23153 showpoint(ios); 23154 { 23155 ios.imbue(lc); 23156 { 23157 ios.width(0); 23158 { 23159 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23160 std::string ex(str, iter.base()); 23161 assert(ex == "-0X0.P+0"); 23162 assert(ios.width() == 0); 23163 } 23164 ios.width(25); 23165 left(ios); 23166 { 23167 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23168 std::string ex(str, iter.base()); 23169 assert(ex == "-0X0.P+0*****************"); 23170 assert(ios.width() == 0); 23171 } 23172 ios.width(25); 23173 right(ios); 23174 { 23175 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23176 std::string ex(str, iter.base()); 23177 assert(ex == "*****************-0X0.P+0"); 23178 assert(ios.width() == 0); 23179 } 23180 ios.width(25); 23181 internal(ios); 23182 { 23183 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23184 std::string ex(str, iter.base()); 23185 assert(ex == "-*****************0X0.P+0"); 23186 assert(ios.width() == 0); 23187 } 23188 } 23189 ios.imbue(lg); 23190 { 23191 ios.width(0); 23192 { 23193 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23194 std::string ex(str, iter.base()); 23195 assert(ex == "-0X0;P+0"); 23196 assert(ios.width() == 0); 23197 } 23198 ios.width(25); 23199 left(ios); 23200 { 23201 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23202 std::string ex(str, iter.base()); 23203 assert(ex == "-0X0;P+0*****************"); 23204 assert(ios.width() == 0); 23205 } 23206 ios.width(25); 23207 right(ios); 23208 { 23209 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23210 std::string ex(str, iter.base()); 23211 assert(ex == "*****************-0X0;P+0"); 23212 assert(ios.width() == 0); 23213 } 23214 ios.width(25); 23215 internal(ios); 23216 { 23217 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23218 std::string ex(str, iter.base()); 23219 assert(ex == "-*****************0X0;P+0"); 23220 assert(ios.width() == 0); 23221 } 23222 } 23223 } 23224 } 23225 } 23226 } 23227 ios.precision(1); 23228 { 23229 nouppercase(ios); 23230 { 23231 noshowpos(ios); 23232 { 23233 noshowpoint(ios); 23234 { 23235 ios.imbue(lc); 23236 { 23237 ios.width(0); 23238 { 23239 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23240 std::string ex(str, iter.base()); 23241 assert(ex == "-0x0p+0"); 23242 assert(ios.width() == 0); 23243 } 23244 ios.width(25); 23245 left(ios); 23246 { 23247 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23248 std::string ex(str, iter.base()); 23249 assert(ex == "-0x0p+0******************"); 23250 assert(ios.width() == 0); 23251 } 23252 ios.width(25); 23253 right(ios); 23254 { 23255 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23256 std::string ex(str, iter.base()); 23257 assert(ex == "******************-0x0p+0"); 23258 assert(ios.width() == 0); 23259 } 23260 ios.width(25); 23261 internal(ios); 23262 { 23263 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23264 std::string ex(str, iter.base()); 23265 assert(ex == "-******************0x0p+0"); 23266 assert(ios.width() == 0); 23267 } 23268 } 23269 ios.imbue(lg); 23270 { 23271 ios.width(0); 23272 { 23273 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23274 std::string ex(str, iter.base()); 23275 assert(ex == "-0x0p+0"); 23276 assert(ios.width() == 0); 23277 } 23278 ios.width(25); 23279 left(ios); 23280 { 23281 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23282 std::string ex(str, iter.base()); 23283 assert(ex == "-0x0p+0******************"); 23284 assert(ios.width() == 0); 23285 } 23286 ios.width(25); 23287 right(ios); 23288 { 23289 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23290 std::string ex(str, iter.base()); 23291 assert(ex == "******************-0x0p+0"); 23292 assert(ios.width() == 0); 23293 } 23294 ios.width(25); 23295 internal(ios); 23296 { 23297 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23298 std::string ex(str, iter.base()); 23299 assert(ex == "-******************0x0p+0"); 23300 assert(ios.width() == 0); 23301 } 23302 } 23303 } 23304 showpoint(ios); 23305 { 23306 ios.imbue(lc); 23307 { 23308 ios.width(0); 23309 { 23310 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23311 std::string ex(str, iter.base()); 23312 assert(ex == "-0x0.p+0"); 23313 assert(ios.width() == 0); 23314 } 23315 ios.width(25); 23316 left(ios); 23317 { 23318 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23319 std::string ex(str, iter.base()); 23320 assert(ex == "-0x0.p+0*****************"); 23321 assert(ios.width() == 0); 23322 } 23323 ios.width(25); 23324 right(ios); 23325 { 23326 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23327 std::string ex(str, iter.base()); 23328 assert(ex == "*****************-0x0.p+0"); 23329 assert(ios.width() == 0); 23330 } 23331 ios.width(25); 23332 internal(ios); 23333 { 23334 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23335 std::string ex(str, iter.base()); 23336 assert(ex == "-*****************0x0.p+0"); 23337 assert(ios.width() == 0); 23338 } 23339 } 23340 ios.imbue(lg); 23341 { 23342 ios.width(0); 23343 { 23344 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23345 std::string ex(str, iter.base()); 23346 assert(ex == "-0x0;p+0"); 23347 assert(ios.width() == 0); 23348 } 23349 ios.width(25); 23350 left(ios); 23351 { 23352 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23353 std::string ex(str, iter.base()); 23354 assert(ex == "-0x0;p+0*****************"); 23355 assert(ios.width() == 0); 23356 } 23357 ios.width(25); 23358 right(ios); 23359 { 23360 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23361 std::string ex(str, iter.base()); 23362 assert(ex == "*****************-0x0;p+0"); 23363 assert(ios.width() == 0); 23364 } 23365 ios.width(25); 23366 internal(ios); 23367 { 23368 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23369 std::string ex(str, iter.base()); 23370 assert(ex == "-*****************0x0;p+0"); 23371 assert(ios.width() == 0); 23372 } 23373 } 23374 } 23375 } 23376 showpos(ios); 23377 { 23378 noshowpoint(ios); 23379 { 23380 ios.imbue(lc); 23381 { 23382 ios.width(0); 23383 { 23384 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23385 std::string ex(str, iter.base()); 23386 assert(ex == "-0x0p+0"); 23387 assert(ios.width() == 0); 23388 } 23389 ios.width(25); 23390 left(ios); 23391 { 23392 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23393 std::string ex(str, iter.base()); 23394 assert(ex == "-0x0p+0******************"); 23395 assert(ios.width() == 0); 23396 } 23397 ios.width(25); 23398 right(ios); 23399 { 23400 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23401 std::string ex(str, iter.base()); 23402 assert(ex == "******************-0x0p+0"); 23403 assert(ios.width() == 0); 23404 } 23405 ios.width(25); 23406 internal(ios); 23407 { 23408 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23409 std::string ex(str, iter.base()); 23410 assert(ex == "-******************0x0p+0"); 23411 assert(ios.width() == 0); 23412 } 23413 } 23414 ios.imbue(lg); 23415 { 23416 ios.width(0); 23417 { 23418 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23419 std::string ex(str, iter.base()); 23420 assert(ex == "-0x0p+0"); 23421 assert(ios.width() == 0); 23422 } 23423 ios.width(25); 23424 left(ios); 23425 { 23426 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23427 std::string ex(str, iter.base()); 23428 assert(ex == "-0x0p+0******************"); 23429 assert(ios.width() == 0); 23430 } 23431 ios.width(25); 23432 right(ios); 23433 { 23434 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23435 std::string ex(str, iter.base()); 23436 assert(ex == "******************-0x0p+0"); 23437 assert(ios.width() == 0); 23438 } 23439 ios.width(25); 23440 internal(ios); 23441 { 23442 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23443 std::string ex(str, iter.base()); 23444 assert(ex == "-******************0x0p+0"); 23445 assert(ios.width() == 0); 23446 } 23447 } 23448 } 23449 showpoint(ios); 23450 { 23451 ios.imbue(lc); 23452 { 23453 ios.width(0); 23454 { 23455 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23456 std::string ex(str, iter.base()); 23457 assert(ex == "-0x0.p+0"); 23458 assert(ios.width() == 0); 23459 } 23460 ios.width(25); 23461 left(ios); 23462 { 23463 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23464 std::string ex(str, iter.base()); 23465 assert(ex == "-0x0.p+0*****************"); 23466 assert(ios.width() == 0); 23467 } 23468 ios.width(25); 23469 right(ios); 23470 { 23471 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23472 std::string ex(str, iter.base()); 23473 assert(ex == "*****************-0x0.p+0"); 23474 assert(ios.width() == 0); 23475 } 23476 ios.width(25); 23477 internal(ios); 23478 { 23479 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23480 std::string ex(str, iter.base()); 23481 assert(ex == "-*****************0x0.p+0"); 23482 assert(ios.width() == 0); 23483 } 23484 } 23485 ios.imbue(lg); 23486 { 23487 ios.width(0); 23488 { 23489 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23490 std::string ex(str, iter.base()); 23491 assert(ex == "-0x0;p+0"); 23492 assert(ios.width() == 0); 23493 } 23494 ios.width(25); 23495 left(ios); 23496 { 23497 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23498 std::string ex(str, iter.base()); 23499 assert(ex == "-0x0;p+0*****************"); 23500 assert(ios.width() == 0); 23501 } 23502 ios.width(25); 23503 right(ios); 23504 { 23505 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23506 std::string ex(str, iter.base()); 23507 assert(ex == "*****************-0x0;p+0"); 23508 assert(ios.width() == 0); 23509 } 23510 ios.width(25); 23511 internal(ios); 23512 { 23513 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23514 std::string ex(str, iter.base()); 23515 assert(ex == "-*****************0x0;p+0"); 23516 assert(ios.width() == 0); 23517 } 23518 } 23519 } 23520 } 23521 } 23522 uppercase(ios); 23523 { 23524 noshowpos(ios); 23525 { 23526 noshowpoint(ios); 23527 { 23528 ios.imbue(lc); 23529 { 23530 ios.width(0); 23531 { 23532 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23533 std::string ex(str, iter.base()); 23534 assert(ex == "-0X0P+0"); 23535 assert(ios.width() == 0); 23536 } 23537 ios.width(25); 23538 left(ios); 23539 { 23540 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23541 std::string ex(str, iter.base()); 23542 assert(ex == "-0X0P+0******************"); 23543 assert(ios.width() == 0); 23544 } 23545 ios.width(25); 23546 right(ios); 23547 { 23548 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23549 std::string ex(str, iter.base()); 23550 assert(ex == "******************-0X0P+0"); 23551 assert(ios.width() == 0); 23552 } 23553 ios.width(25); 23554 internal(ios); 23555 { 23556 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23557 std::string ex(str, iter.base()); 23558 assert(ex == "-******************0X0P+0"); 23559 assert(ios.width() == 0); 23560 } 23561 } 23562 ios.imbue(lg); 23563 { 23564 ios.width(0); 23565 { 23566 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23567 std::string ex(str, iter.base()); 23568 assert(ex == "-0X0P+0"); 23569 assert(ios.width() == 0); 23570 } 23571 ios.width(25); 23572 left(ios); 23573 { 23574 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23575 std::string ex(str, iter.base()); 23576 assert(ex == "-0X0P+0******************"); 23577 assert(ios.width() == 0); 23578 } 23579 ios.width(25); 23580 right(ios); 23581 { 23582 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23583 std::string ex(str, iter.base()); 23584 assert(ex == "******************-0X0P+0"); 23585 assert(ios.width() == 0); 23586 } 23587 ios.width(25); 23588 internal(ios); 23589 { 23590 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23591 std::string ex(str, iter.base()); 23592 assert(ex == "-******************0X0P+0"); 23593 assert(ios.width() == 0); 23594 } 23595 } 23596 } 23597 showpoint(ios); 23598 { 23599 ios.imbue(lc); 23600 { 23601 ios.width(0); 23602 { 23603 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23604 std::string ex(str, iter.base()); 23605 assert(ex == "-0X0.P+0"); 23606 assert(ios.width() == 0); 23607 } 23608 ios.width(25); 23609 left(ios); 23610 { 23611 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23612 std::string ex(str, iter.base()); 23613 assert(ex == "-0X0.P+0*****************"); 23614 assert(ios.width() == 0); 23615 } 23616 ios.width(25); 23617 right(ios); 23618 { 23619 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23620 std::string ex(str, iter.base()); 23621 assert(ex == "*****************-0X0.P+0"); 23622 assert(ios.width() == 0); 23623 } 23624 ios.width(25); 23625 internal(ios); 23626 { 23627 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23628 std::string ex(str, iter.base()); 23629 assert(ex == "-*****************0X0.P+0"); 23630 assert(ios.width() == 0); 23631 } 23632 } 23633 ios.imbue(lg); 23634 { 23635 ios.width(0); 23636 { 23637 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23638 std::string ex(str, iter.base()); 23639 assert(ex == "-0X0;P+0"); 23640 assert(ios.width() == 0); 23641 } 23642 ios.width(25); 23643 left(ios); 23644 { 23645 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23646 std::string ex(str, iter.base()); 23647 assert(ex == "-0X0;P+0*****************"); 23648 assert(ios.width() == 0); 23649 } 23650 ios.width(25); 23651 right(ios); 23652 { 23653 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23654 std::string ex(str, iter.base()); 23655 assert(ex == "*****************-0X0;P+0"); 23656 assert(ios.width() == 0); 23657 } 23658 ios.width(25); 23659 internal(ios); 23660 { 23661 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23662 std::string ex(str, iter.base()); 23663 assert(ex == "-*****************0X0;P+0"); 23664 assert(ios.width() == 0); 23665 } 23666 } 23667 } 23668 } 23669 showpos(ios); 23670 { 23671 noshowpoint(ios); 23672 { 23673 ios.imbue(lc); 23674 { 23675 ios.width(0); 23676 { 23677 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23678 std::string ex(str, iter.base()); 23679 assert(ex == "-0X0P+0"); 23680 assert(ios.width() == 0); 23681 } 23682 ios.width(25); 23683 left(ios); 23684 { 23685 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23686 std::string ex(str, iter.base()); 23687 assert(ex == "-0X0P+0******************"); 23688 assert(ios.width() == 0); 23689 } 23690 ios.width(25); 23691 right(ios); 23692 { 23693 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23694 std::string ex(str, iter.base()); 23695 assert(ex == "******************-0X0P+0"); 23696 assert(ios.width() == 0); 23697 } 23698 ios.width(25); 23699 internal(ios); 23700 { 23701 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23702 std::string ex(str, iter.base()); 23703 assert(ex == "-******************0X0P+0"); 23704 assert(ios.width() == 0); 23705 } 23706 } 23707 ios.imbue(lg); 23708 { 23709 ios.width(0); 23710 { 23711 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23712 std::string ex(str, iter.base()); 23713 assert(ex == "-0X0P+0"); 23714 assert(ios.width() == 0); 23715 } 23716 ios.width(25); 23717 left(ios); 23718 { 23719 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23720 std::string ex(str, iter.base()); 23721 assert(ex == "-0X0P+0******************"); 23722 assert(ios.width() == 0); 23723 } 23724 ios.width(25); 23725 right(ios); 23726 { 23727 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23728 std::string ex(str, iter.base()); 23729 assert(ex == "******************-0X0P+0"); 23730 assert(ios.width() == 0); 23731 } 23732 ios.width(25); 23733 internal(ios); 23734 { 23735 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23736 std::string ex(str, iter.base()); 23737 assert(ex == "-******************0X0P+0"); 23738 assert(ios.width() == 0); 23739 } 23740 } 23741 } 23742 showpoint(ios); 23743 { 23744 ios.imbue(lc); 23745 { 23746 ios.width(0); 23747 { 23748 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23749 std::string ex(str, iter.base()); 23750 assert(ex == "-0X0.P+0"); 23751 assert(ios.width() == 0); 23752 } 23753 ios.width(25); 23754 left(ios); 23755 { 23756 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23757 std::string ex(str, iter.base()); 23758 assert(ex == "-0X0.P+0*****************"); 23759 assert(ios.width() == 0); 23760 } 23761 ios.width(25); 23762 right(ios); 23763 { 23764 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23765 std::string ex(str, iter.base()); 23766 assert(ex == "*****************-0X0.P+0"); 23767 assert(ios.width() == 0); 23768 } 23769 ios.width(25); 23770 internal(ios); 23771 { 23772 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23773 std::string ex(str, iter.base()); 23774 assert(ex == "-*****************0X0.P+0"); 23775 assert(ios.width() == 0); 23776 } 23777 } 23778 ios.imbue(lg); 23779 { 23780 ios.width(0); 23781 { 23782 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23783 std::string ex(str, iter.base()); 23784 assert(ex == "-0X0;P+0"); 23785 assert(ios.width() == 0); 23786 } 23787 ios.width(25); 23788 left(ios); 23789 { 23790 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23791 std::string ex(str, iter.base()); 23792 assert(ex == "-0X0;P+0*****************"); 23793 assert(ios.width() == 0); 23794 } 23795 ios.width(25); 23796 right(ios); 23797 { 23798 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23799 std::string ex(str, iter.base()); 23800 assert(ex == "*****************-0X0;P+0"); 23801 assert(ios.width() == 0); 23802 } 23803 ios.width(25); 23804 internal(ios); 23805 { 23806 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23807 std::string ex(str, iter.base()); 23808 assert(ex == "-*****************0X0;P+0"); 23809 assert(ios.width() == 0); 23810 } 23811 } 23812 } 23813 } 23814 } 23815 } 23816 ios.precision(6); 23817 { 23818 nouppercase(ios); 23819 { 23820 noshowpos(ios); 23821 { 23822 noshowpoint(ios); 23823 { 23824 ios.imbue(lc); 23825 { 23826 ios.width(0); 23827 { 23828 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23829 std::string ex(str, iter.base()); 23830 assert(ex == "-0x0p+0"); 23831 assert(ios.width() == 0); 23832 } 23833 ios.width(25); 23834 left(ios); 23835 { 23836 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23837 std::string ex(str, iter.base()); 23838 assert(ex == "-0x0p+0******************"); 23839 assert(ios.width() == 0); 23840 } 23841 ios.width(25); 23842 right(ios); 23843 { 23844 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23845 std::string ex(str, iter.base()); 23846 assert(ex == "******************-0x0p+0"); 23847 assert(ios.width() == 0); 23848 } 23849 ios.width(25); 23850 internal(ios); 23851 { 23852 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23853 std::string ex(str, iter.base()); 23854 assert(ex == "-******************0x0p+0"); 23855 assert(ios.width() == 0); 23856 } 23857 } 23858 ios.imbue(lg); 23859 { 23860 ios.width(0); 23861 { 23862 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23863 std::string ex(str, iter.base()); 23864 assert(ex == "-0x0p+0"); 23865 assert(ios.width() == 0); 23866 } 23867 ios.width(25); 23868 left(ios); 23869 { 23870 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23871 std::string ex(str, iter.base()); 23872 assert(ex == "-0x0p+0******************"); 23873 assert(ios.width() == 0); 23874 } 23875 ios.width(25); 23876 right(ios); 23877 { 23878 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23879 std::string ex(str, iter.base()); 23880 assert(ex == "******************-0x0p+0"); 23881 assert(ios.width() == 0); 23882 } 23883 ios.width(25); 23884 internal(ios); 23885 { 23886 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23887 std::string ex(str, iter.base()); 23888 assert(ex == "-******************0x0p+0"); 23889 assert(ios.width() == 0); 23890 } 23891 } 23892 } 23893 showpoint(ios); 23894 { 23895 ios.imbue(lc); 23896 { 23897 ios.width(0); 23898 { 23899 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23900 std::string ex(str, iter.base()); 23901 assert(ex == "-0x0.p+0"); 23902 assert(ios.width() == 0); 23903 } 23904 ios.width(25); 23905 left(ios); 23906 { 23907 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23908 std::string ex(str, iter.base()); 23909 assert(ex == "-0x0.p+0*****************"); 23910 assert(ios.width() == 0); 23911 } 23912 ios.width(25); 23913 right(ios); 23914 { 23915 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23916 std::string ex(str, iter.base()); 23917 assert(ex == "*****************-0x0.p+0"); 23918 assert(ios.width() == 0); 23919 } 23920 ios.width(25); 23921 internal(ios); 23922 { 23923 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23924 std::string ex(str, iter.base()); 23925 assert(ex == "-*****************0x0.p+0"); 23926 assert(ios.width() == 0); 23927 } 23928 } 23929 ios.imbue(lg); 23930 { 23931 ios.width(0); 23932 { 23933 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23934 std::string ex(str, iter.base()); 23935 assert(ex == "-0x0;p+0"); 23936 assert(ios.width() == 0); 23937 } 23938 ios.width(25); 23939 left(ios); 23940 { 23941 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23942 std::string ex(str, iter.base()); 23943 assert(ex == "-0x0;p+0*****************"); 23944 assert(ios.width() == 0); 23945 } 23946 ios.width(25); 23947 right(ios); 23948 { 23949 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23950 std::string ex(str, iter.base()); 23951 assert(ex == "*****************-0x0;p+0"); 23952 assert(ios.width() == 0); 23953 } 23954 ios.width(25); 23955 internal(ios); 23956 { 23957 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23958 std::string ex(str, iter.base()); 23959 assert(ex == "-*****************0x0;p+0"); 23960 assert(ios.width() == 0); 23961 } 23962 } 23963 } 23964 } 23965 showpos(ios); 23966 { 23967 noshowpoint(ios); 23968 { 23969 ios.imbue(lc); 23970 { 23971 ios.width(0); 23972 { 23973 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23974 std::string ex(str, iter.base()); 23975 assert(ex == "-0x0p+0"); 23976 assert(ios.width() == 0); 23977 } 23978 ios.width(25); 23979 left(ios); 23980 { 23981 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23982 std::string ex(str, iter.base()); 23983 assert(ex == "-0x0p+0******************"); 23984 assert(ios.width() == 0); 23985 } 23986 ios.width(25); 23987 right(ios); 23988 { 23989 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23990 std::string ex(str, iter.base()); 23991 assert(ex == "******************-0x0p+0"); 23992 assert(ios.width() == 0); 23993 } 23994 ios.width(25); 23995 internal(ios); 23996 { 23997 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23998 std::string ex(str, iter.base()); 23999 assert(ex == "-******************0x0p+0"); 24000 assert(ios.width() == 0); 24001 } 24002 } 24003 ios.imbue(lg); 24004 { 24005 ios.width(0); 24006 { 24007 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24008 std::string ex(str, iter.base()); 24009 assert(ex == "-0x0p+0"); 24010 assert(ios.width() == 0); 24011 } 24012 ios.width(25); 24013 left(ios); 24014 { 24015 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24016 std::string ex(str, iter.base()); 24017 assert(ex == "-0x0p+0******************"); 24018 assert(ios.width() == 0); 24019 } 24020 ios.width(25); 24021 right(ios); 24022 { 24023 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24024 std::string ex(str, iter.base()); 24025 assert(ex == "******************-0x0p+0"); 24026 assert(ios.width() == 0); 24027 } 24028 ios.width(25); 24029 internal(ios); 24030 { 24031 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24032 std::string ex(str, iter.base()); 24033 assert(ex == "-******************0x0p+0"); 24034 assert(ios.width() == 0); 24035 } 24036 } 24037 } 24038 showpoint(ios); 24039 { 24040 ios.imbue(lc); 24041 { 24042 ios.width(0); 24043 { 24044 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24045 std::string ex(str, iter.base()); 24046 assert(ex == "-0x0.p+0"); 24047 assert(ios.width() == 0); 24048 } 24049 ios.width(25); 24050 left(ios); 24051 { 24052 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24053 std::string ex(str, iter.base()); 24054 assert(ex == "-0x0.p+0*****************"); 24055 assert(ios.width() == 0); 24056 } 24057 ios.width(25); 24058 right(ios); 24059 { 24060 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24061 std::string ex(str, iter.base()); 24062 assert(ex == "*****************-0x0.p+0"); 24063 assert(ios.width() == 0); 24064 } 24065 ios.width(25); 24066 internal(ios); 24067 { 24068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24069 std::string ex(str, iter.base()); 24070 assert(ex == "-*****************0x0.p+0"); 24071 assert(ios.width() == 0); 24072 } 24073 } 24074 ios.imbue(lg); 24075 { 24076 ios.width(0); 24077 { 24078 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24079 std::string ex(str, iter.base()); 24080 assert(ex == "-0x0;p+0"); 24081 assert(ios.width() == 0); 24082 } 24083 ios.width(25); 24084 left(ios); 24085 { 24086 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24087 std::string ex(str, iter.base()); 24088 assert(ex == "-0x0;p+0*****************"); 24089 assert(ios.width() == 0); 24090 } 24091 ios.width(25); 24092 right(ios); 24093 { 24094 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24095 std::string ex(str, iter.base()); 24096 assert(ex == "*****************-0x0;p+0"); 24097 assert(ios.width() == 0); 24098 } 24099 ios.width(25); 24100 internal(ios); 24101 { 24102 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24103 std::string ex(str, iter.base()); 24104 assert(ex == "-*****************0x0;p+0"); 24105 assert(ios.width() == 0); 24106 } 24107 } 24108 } 24109 } 24110 } 24111 uppercase(ios); 24112 { 24113 noshowpos(ios); 24114 { 24115 noshowpoint(ios); 24116 { 24117 ios.imbue(lc); 24118 { 24119 ios.width(0); 24120 { 24121 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24122 std::string ex(str, iter.base()); 24123 assert(ex == "-0X0P+0"); 24124 assert(ios.width() == 0); 24125 } 24126 ios.width(25); 24127 left(ios); 24128 { 24129 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24130 std::string ex(str, iter.base()); 24131 assert(ex == "-0X0P+0******************"); 24132 assert(ios.width() == 0); 24133 } 24134 ios.width(25); 24135 right(ios); 24136 { 24137 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24138 std::string ex(str, iter.base()); 24139 assert(ex == "******************-0X0P+0"); 24140 assert(ios.width() == 0); 24141 } 24142 ios.width(25); 24143 internal(ios); 24144 { 24145 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24146 std::string ex(str, iter.base()); 24147 assert(ex == "-******************0X0P+0"); 24148 assert(ios.width() == 0); 24149 } 24150 } 24151 ios.imbue(lg); 24152 { 24153 ios.width(0); 24154 { 24155 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24156 std::string ex(str, iter.base()); 24157 assert(ex == "-0X0P+0"); 24158 assert(ios.width() == 0); 24159 } 24160 ios.width(25); 24161 left(ios); 24162 { 24163 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24164 std::string ex(str, iter.base()); 24165 assert(ex == "-0X0P+0******************"); 24166 assert(ios.width() == 0); 24167 } 24168 ios.width(25); 24169 right(ios); 24170 { 24171 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24172 std::string ex(str, iter.base()); 24173 assert(ex == "******************-0X0P+0"); 24174 assert(ios.width() == 0); 24175 } 24176 ios.width(25); 24177 internal(ios); 24178 { 24179 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24180 std::string ex(str, iter.base()); 24181 assert(ex == "-******************0X0P+0"); 24182 assert(ios.width() == 0); 24183 } 24184 } 24185 } 24186 showpoint(ios); 24187 { 24188 ios.imbue(lc); 24189 { 24190 ios.width(0); 24191 { 24192 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24193 std::string ex(str, iter.base()); 24194 assert(ex == "-0X0.P+0"); 24195 assert(ios.width() == 0); 24196 } 24197 ios.width(25); 24198 left(ios); 24199 { 24200 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24201 std::string ex(str, iter.base()); 24202 assert(ex == "-0X0.P+0*****************"); 24203 assert(ios.width() == 0); 24204 } 24205 ios.width(25); 24206 right(ios); 24207 { 24208 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24209 std::string ex(str, iter.base()); 24210 assert(ex == "*****************-0X0.P+0"); 24211 assert(ios.width() == 0); 24212 } 24213 ios.width(25); 24214 internal(ios); 24215 { 24216 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24217 std::string ex(str, iter.base()); 24218 assert(ex == "-*****************0X0.P+0"); 24219 assert(ios.width() == 0); 24220 } 24221 } 24222 ios.imbue(lg); 24223 { 24224 ios.width(0); 24225 { 24226 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24227 std::string ex(str, iter.base()); 24228 assert(ex == "-0X0;P+0"); 24229 assert(ios.width() == 0); 24230 } 24231 ios.width(25); 24232 left(ios); 24233 { 24234 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24235 std::string ex(str, iter.base()); 24236 assert(ex == "-0X0;P+0*****************"); 24237 assert(ios.width() == 0); 24238 } 24239 ios.width(25); 24240 right(ios); 24241 { 24242 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24243 std::string ex(str, iter.base()); 24244 assert(ex == "*****************-0X0;P+0"); 24245 assert(ios.width() == 0); 24246 } 24247 ios.width(25); 24248 internal(ios); 24249 { 24250 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24251 std::string ex(str, iter.base()); 24252 assert(ex == "-*****************0X0;P+0"); 24253 assert(ios.width() == 0); 24254 } 24255 } 24256 } 24257 } 24258 showpos(ios); 24259 { 24260 noshowpoint(ios); 24261 { 24262 ios.imbue(lc); 24263 { 24264 ios.width(0); 24265 { 24266 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24267 std::string ex(str, iter.base()); 24268 assert(ex == "-0X0P+0"); 24269 assert(ios.width() == 0); 24270 } 24271 ios.width(25); 24272 left(ios); 24273 { 24274 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24275 std::string ex(str, iter.base()); 24276 assert(ex == "-0X0P+0******************"); 24277 assert(ios.width() == 0); 24278 } 24279 ios.width(25); 24280 right(ios); 24281 { 24282 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24283 std::string ex(str, iter.base()); 24284 assert(ex == "******************-0X0P+0"); 24285 assert(ios.width() == 0); 24286 } 24287 ios.width(25); 24288 internal(ios); 24289 { 24290 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24291 std::string ex(str, iter.base()); 24292 assert(ex == "-******************0X0P+0"); 24293 assert(ios.width() == 0); 24294 } 24295 } 24296 ios.imbue(lg); 24297 { 24298 ios.width(0); 24299 { 24300 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24301 std::string ex(str, iter.base()); 24302 assert(ex == "-0X0P+0"); 24303 assert(ios.width() == 0); 24304 } 24305 ios.width(25); 24306 left(ios); 24307 { 24308 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24309 std::string ex(str, iter.base()); 24310 assert(ex == "-0X0P+0******************"); 24311 assert(ios.width() == 0); 24312 } 24313 ios.width(25); 24314 right(ios); 24315 { 24316 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24317 std::string ex(str, iter.base()); 24318 assert(ex == "******************-0X0P+0"); 24319 assert(ios.width() == 0); 24320 } 24321 ios.width(25); 24322 internal(ios); 24323 { 24324 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24325 std::string ex(str, iter.base()); 24326 assert(ex == "-******************0X0P+0"); 24327 assert(ios.width() == 0); 24328 } 24329 } 24330 } 24331 showpoint(ios); 24332 { 24333 ios.imbue(lc); 24334 { 24335 ios.width(0); 24336 { 24337 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24338 std::string ex(str, iter.base()); 24339 assert(ex == "-0X0.P+0"); 24340 assert(ios.width() == 0); 24341 } 24342 ios.width(25); 24343 left(ios); 24344 { 24345 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24346 std::string ex(str, iter.base()); 24347 assert(ex == "-0X0.P+0*****************"); 24348 assert(ios.width() == 0); 24349 } 24350 ios.width(25); 24351 right(ios); 24352 { 24353 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24354 std::string ex(str, iter.base()); 24355 assert(ex == "*****************-0X0.P+0"); 24356 assert(ios.width() == 0); 24357 } 24358 ios.width(25); 24359 internal(ios); 24360 { 24361 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24362 std::string ex(str, iter.base()); 24363 assert(ex == "-*****************0X0.P+0"); 24364 assert(ios.width() == 0); 24365 } 24366 } 24367 ios.imbue(lg); 24368 { 24369 ios.width(0); 24370 { 24371 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24372 std::string ex(str, iter.base()); 24373 assert(ex == "-0X0;P+0"); 24374 assert(ios.width() == 0); 24375 } 24376 ios.width(25); 24377 left(ios); 24378 { 24379 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24380 std::string ex(str, iter.base()); 24381 assert(ex == "-0X0;P+0*****************"); 24382 assert(ios.width() == 0); 24383 } 24384 ios.width(25); 24385 right(ios); 24386 { 24387 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24388 std::string ex(str, iter.base()); 24389 assert(ex == "*****************-0X0;P+0"); 24390 assert(ios.width() == 0); 24391 } 24392 ios.width(25); 24393 internal(ios); 24394 { 24395 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24396 std::string ex(str, iter.base()); 24397 assert(ex == "-*****************0X0;P+0"); 24398 assert(ios.width() == 0); 24399 } 24400 } 24401 } 24402 } 24403 } 24404 } 24405 ios.precision(16); 24406 { 24407 } 24408 ios.precision(60); 24409 { 24410 } 24411 } 24412 } 24413 } 24414 24415 void test12() 24416 { 24417 char str[200]; 24418 output_iterator<char*> iter; 24419 std::locale lc = std::locale::classic(); 24420 std::locale lg(lc, new my_numpunct); 24421 #ifdef __APPLE__ 24422 // This test is failing on FreeBSD, possibly due to different representations 24423 // of the floating point numbers. 24424 const my_facet f(1); 24425 { 24426 long double v = 1234567890.125; 24427 std::ios ios(0); 24428 hexfloat(ios); 24429 // %a 24430 { 24431 ios.precision(0); 24432 { 24433 nouppercase(ios); 24434 { 24435 noshowpos(ios); 24436 { 24437 noshowpoint(ios); 24438 { 24439 ios.width(0); 24440 ios.imbue(lc); 24441 { 24442 { 24443 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24444 std::string ex(str, iter.base()); 24445 assert(ex == "0x9.32c05a44p+27"); 24446 assert(ios.width() == 0); 24447 } 24448 ios.width(25); 24449 left(ios); 24450 { 24451 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24452 std::string ex(str, iter.base()); 24453 assert(ex == "0x9.32c05a44p+27*********"); 24454 assert(ios.width() == 0); 24455 } 24456 ios.width(25); 24457 right(ios); 24458 { 24459 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24460 std::string ex(str, iter.base()); 24461 assert(ex == "*********0x9.32c05a44p+27"); 24462 assert(ios.width() == 0); 24463 } 24464 ios.width(25); 24465 internal(ios); 24466 { 24467 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24468 std::string ex(str, iter.base()); 24469 assert(ex == "0x*********9.32c05a44p+27"); 24470 assert(ios.width() == 0); 24471 } 24472 } 24473 ios.imbue(lg); 24474 { 24475 ios.width(0); 24476 { 24477 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24478 std::string ex(str, iter.base()); 24479 assert(ex == "0x9;32c05a44p+27"); 24480 assert(ios.width() == 0); 24481 } 24482 ios.width(25); 24483 left(ios); 24484 { 24485 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24486 std::string ex(str, iter.base()); 24487 assert(ex == "0x9;32c05a44p+27*********"); 24488 assert(ios.width() == 0); 24489 } 24490 ios.width(25); 24491 right(ios); 24492 { 24493 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24494 std::string ex(str, iter.base()); 24495 assert(ex == "*********0x9;32c05a44p+27"); 24496 assert(ios.width() == 0); 24497 } 24498 ios.width(25); 24499 internal(ios); 24500 { 24501 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24502 std::string ex(str, iter.base()); 24503 assert(ex == "0x*********9;32c05a44p+27"); 24504 assert(ios.width() == 0); 24505 } 24506 } 24507 } 24508 showpoint(ios); 24509 { 24510 ios.imbue(lc); 24511 { 24512 ios.width(0); 24513 { 24514 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24515 std::string ex(str, iter.base()); 24516 assert(ex == "0x9.32c05a44p+27"); 24517 assert(ios.width() == 0); 24518 } 24519 ios.width(25); 24520 left(ios); 24521 { 24522 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24523 std::string ex(str, iter.base()); 24524 assert(ex == "0x9.32c05a44p+27*********"); 24525 assert(ios.width() == 0); 24526 } 24527 ios.width(25); 24528 right(ios); 24529 { 24530 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24531 std::string ex(str, iter.base()); 24532 assert(ex == "*********0x9.32c05a44p+27"); 24533 assert(ios.width() == 0); 24534 } 24535 ios.width(25); 24536 internal(ios); 24537 { 24538 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24539 std::string ex(str, iter.base()); 24540 assert(ex == "0x*********9.32c05a44p+27"); 24541 assert(ios.width() == 0); 24542 } 24543 } 24544 ios.imbue(lg); 24545 { 24546 ios.width(0); 24547 { 24548 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24549 std::string ex(str, iter.base()); 24550 assert(ex == "0x9;32c05a44p+27"); 24551 assert(ios.width() == 0); 24552 } 24553 ios.width(25); 24554 left(ios); 24555 { 24556 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24557 std::string ex(str, iter.base()); 24558 assert(ex == "0x9;32c05a44p+27*********"); 24559 assert(ios.width() == 0); 24560 } 24561 ios.width(25); 24562 right(ios); 24563 { 24564 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24565 std::string ex(str, iter.base()); 24566 assert(ex == "*********0x9;32c05a44p+27"); 24567 assert(ios.width() == 0); 24568 } 24569 ios.width(25); 24570 internal(ios); 24571 { 24572 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24573 std::string ex(str, iter.base()); 24574 assert(ex == "0x*********9;32c05a44p+27"); 24575 assert(ios.width() == 0); 24576 } 24577 } 24578 } 24579 } 24580 showpos(ios); 24581 { 24582 noshowpoint(ios); 24583 { 24584 ios.imbue(lc); 24585 { 24586 ios.width(0); 24587 { 24588 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24589 std::string ex(str, iter.base()); 24590 assert(ex == "+0x9.32c05a44p+27"); 24591 assert(ios.width() == 0); 24592 } 24593 ios.width(25); 24594 left(ios); 24595 { 24596 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24597 std::string ex(str, iter.base()); 24598 assert(ex == "+0x9.32c05a44p+27********"); 24599 assert(ios.width() == 0); 24600 } 24601 ios.width(25); 24602 right(ios); 24603 { 24604 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24605 std::string ex(str, iter.base()); 24606 assert(ex == "********+0x9.32c05a44p+27"); 24607 assert(ios.width() == 0); 24608 } 24609 ios.width(25); 24610 internal(ios); 24611 { 24612 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24613 std::string ex(str, iter.base()); 24614 assert(ex == "+********0x9.32c05a44p+27"); 24615 assert(ios.width() == 0); 24616 } 24617 } 24618 ios.imbue(lg); 24619 { 24620 ios.width(0); 24621 { 24622 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24623 std::string ex(str, iter.base()); 24624 assert(ex == "+0x9;32c05a44p+27"); 24625 assert(ios.width() == 0); 24626 } 24627 ios.width(25); 24628 left(ios); 24629 { 24630 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24631 std::string ex(str, iter.base()); 24632 assert(ex == "+0x9;32c05a44p+27********"); 24633 assert(ios.width() == 0); 24634 } 24635 ios.width(25); 24636 right(ios); 24637 { 24638 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24639 std::string ex(str, iter.base()); 24640 assert(ex == "********+0x9;32c05a44p+27"); 24641 assert(ios.width() == 0); 24642 } 24643 ios.width(25); 24644 internal(ios); 24645 { 24646 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24647 std::string ex(str, iter.base()); 24648 assert(ex == "+********0x9;32c05a44p+27"); 24649 assert(ios.width() == 0); 24650 } 24651 } 24652 } 24653 showpoint(ios); 24654 { 24655 ios.imbue(lc); 24656 { 24657 ios.width(0); 24658 { 24659 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24660 std::string ex(str, iter.base()); 24661 assert(ex == "+0x9.32c05a44p+27"); 24662 assert(ios.width() == 0); 24663 } 24664 ios.width(25); 24665 left(ios); 24666 { 24667 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24668 std::string ex(str, iter.base()); 24669 assert(ex == "+0x9.32c05a44p+27********"); 24670 assert(ios.width() == 0); 24671 } 24672 ios.width(25); 24673 right(ios); 24674 { 24675 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24676 std::string ex(str, iter.base()); 24677 assert(ex == "********+0x9.32c05a44p+27"); 24678 assert(ios.width() == 0); 24679 } 24680 ios.width(25); 24681 internal(ios); 24682 { 24683 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24684 std::string ex(str, iter.base()); 24685 assert(ex == "+********0x9.32c05a44p+27"); 24686 assert(ios.width() == 0); 24687 } 24688 } 24689 ios.imbue(lg); 24690 { 24691 ios.width(0); 24692 { 24693 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24694 std::string ex(str, iter.base()); 24695 assert(ex == "+0x9;32c05a44p+27"); 24696 assert(ios.width() == 0); 24697 } 24698 ios.width(25); 24699 left(ios); 24700 { 24701 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24702 std::string ex(str, iter.base()); 24703 assert(ex == "+0x9;32c05a44p+27********"); 24704 assert(ios.width() == 0); 24705 } 24706 ios.width(25); 24707 right(ios); 24708 { 24709 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24710 std::string ex(str, iter.base()); 24711 assert(ex == "********+0x9;32c05a44p+27"); 24712 assert(ios.width() == 0); 24713 } 24714 ios.width(25); 24715 internal(ios); 24716 { 24717 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24718 std::string ex(str, iter.base()); 24719 assert(ex == "+********0x9;32c05a44p+27"); 24720 assert(ios.width() == 0); 24721 } 24722 } 24723 } 24724 } 24725 } 24726 uppercase(ios); 24727 { 24728 noshowpos(ios); 24729 { 24730 noshowpoint(ios); 24731 { 24732 ios.imbue(lc); 24733 { 24734 ios.width(0); 24735 { 24736 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24737 std::string ex(str, iter.base()); 24738 assert(ex == "0X9.32C05A44P+27"); 24739 assert(ios.width() == 0); 24740 } 24741 ios.width(25); 24742 left(ios); 24743 { 24744 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24745 std::string ex(str, iter.base()); 24746 assert(ex == "0X9.32C05A44P+27*********"); 24747 assert(ios.width() == 0); 24748 } 24749 ios.width(25); 24750 right(ios); 24751 { 24752 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24753 std::string ex(str, iter.base()); 24754 assert(ex == "*********0X9.32C05A44P+27"); 24755 assert(ios.width() == 0); 24756 } 24757 ios.width(25); 24758 internal(ios); 24759 { 24760 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24761 std::string ex(str, iter.base()); 24762 assert(ex == "0X*********9.32C05A44P+27"); 24763 assert(ios.width() == 0); 24764 } 24765 } 24766 ios.imbue(lg); 24767 { 24768 ios.width(0); 24769 { 24770 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24771 std::string ex(str, iter.base()); 24772 assert(ex == "0X9;32C05A44P+27"); 24773 assert(ios.width() == 0); 24774 } 24775 ios.width(25); 24776 left(ios); 24777 { 24778 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24779 std::string ex(str, iter.base()); 24780 assert(ex == "0X9;32C05A44P+27*********"); 24781 assert(ios.width() == 0); 24782 } 24783 ios.width(25); 24784 right(ios); 24785 { 24786 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24787 std::string ex(str, iter.base()); 24788 assert(ex == "*********0X9;32C05A44P+27"); 24789 assert(ios.width() == 0); 24790 } 24791 ios.width(25); 24792 internal(ios); 24793 { 24794 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24795 std::string ex(str, iter.base()); 24796 assert(ex == "0X*********9;32C05A44P+27"); 24797 assert(ios.width() == 0); 24798 } 24799 } 24800 } 24801 showpoint(ios); 24802 { 24803 ios.imbue(lc); 24804 { 24805 ios.width(0); 24806 { 24807 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24808 std::string ex(str, iter.base()); 24809 assert(ex == "0X9.32C05A44P+27"); 24810 assert(ios.width() == 0); 24811 } 24812 ios.width(25); 24813 left(ios); 24814 { 24815 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24816 std::string ex(str, iter.base()); 24817 assert(ex == "0X9.32C05A44P+27*********"); 24818 assert(ios.width() == 0); 24819 } 24820 ios.width(25); 24821 right(ios); 24822 { 24823 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24824 std::string ex(str, iter.base()); 24825 assert(ex == "*********0X9.32C05A44P+27"); 24826 assert(ios.width() == 0); 24827 } 24828 ios.width(25); 24829 internal(ios); 24830 { 24831 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24832 std::string ex(str, iter.base()); 24833 assert(ex == "0X*********9.32C05A44P+27"); 24834 assert(ios.width() == 0); 24835 } 24836 } 24837 ios.imbue(lg); 24838 { 24839 ios.width(0); 24840 { 24841 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24842 std::string ex(str, iter.base()); 24843 assert(ex == "0X9;32C05A44P+27"); 24844 assert(ios.width() == 0); 24845 } 24846 ios.width(25); 24847 left(ios); 24848 { 24849 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24850 std::string ex(str, iter.base()); 24851 assert(ex == "0X9;32C05A44P+27*********"); 24852 assert(ios.width() == 0); 24853 } 24854 ios.width(25); 24855 right(ios); 24856 { 24857 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24858 std::string ex(str, iter.base()); 24859 assert(ex == "*********0X9;32C05A44P+27"); 24860 assert(ios.width() == 0); 24861 } 24862 ios.width(25); 24863 internal(ios); 24864 { 24865 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24866 std::string ex(str, iter.base()); 24867 assert(ex == "0X*********9;32C05A44P+27"); 24868 assert(ios.width() == 0); 24869 } 24870 } 24871 } 24872 } 24873 showpos(ios); 24874 { 24875 noshowpoint(ios); 24876 { 24877 ios.imbue(lc); 24878 { 24879 ios.width(0); 24880 { 24881 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24882 std::string ex(str, iter.base()); 24883 assert(ex == "+0X9.32C05A44P+27"); 24884 assert(ios.width() == 0); 24885 } 24886 ios.width(25); 24887 left(ios); 24888 { 24889 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24890 std::string ex(str, iter.base()); 24891 assert(ex == "+0X9.32C05A44P+27********"); 24892 assert(ios.width() == 0); 24893 } 24894 ios.width(25); 24895 right(ios); 24896 { 24897 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24898 std::string ex(str, iter.base()); 24899 assert(ex == "********+0X9.32C05A44P+27"); 24900 assert(ios.width() == 0); 24901 } 24902 ios.width(25); 24903 internal(ios); 24904 { 24905 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24906 std::string ex(str, iter.base()); 24907 assert(ex == "+********0X9.32C05A44P+27"); 24908 assert(ios.width() == 0); 24909 } 24910 } 24911 ios.imbue(lg); 24912 { 24913 ios.width(0); 24914 { 24915 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24916 std::string ex(str, iter.base()); 24917 assert(ex == "+0X9;32C05A44P+27"); 24918 assert(ios.width() == 0); 24919 } 24920 ios.width(25); 24921 left(ios); 24922 { 24923 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24924 std::string ex(str, iter.base()); 24925 assert(ex == "+0X9;32C05A44P+27********"); 24926 assert(ios.width() == 0); 24927 } 24928 ios.width(25); 24929 right(ios); 24930 { 24931 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24932 std::string ex(str, iter.base()); 24933 assert(ex == "********+0X9;32C05A44P+27"); 24934 assert(ios.width() == 0); 24935 } 24936 ios.width(25); 24937 internal(ios); 24938 { 24939 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24940 std::string ex(str, iter.base()); 24941 assert(ex == "+********0X9;32C05A44P+27"); 24942 assert(ios.width() == 0); 24943 } 24944 } 24945 } 24946 showpoint(ios); 24947 { 24948 ios.imbue(lc); 24949 { 24950 ios.width(0); 24951 { 24952 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24953 std::string ex(str, iter.base()); 24954 assert(ex == "+0X9.32C05A44P+27"); 24955 assert(ios.width() == 0); 24956 } 24957 ios.width(25); 24958 left(ios); 24959 { 24960 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24961 std::string ex(str, iter.base()); 24962 assert(ex == "+0X9.32C05A44P+27********"); 24963 assert(ios.width() == 0); 24964 } 24965 ios.width(25); 24966 right(ios); 24967 { 24968 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24969 std::string ex(str, iter.base()); 24970 assert(ex == "********+0X9.32C05A44P+27"); 24971 assert(ios.width() == 0); 24972 } 24973 ios.width(25); 24974 internal(ios); 24975 { 24976 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24977 std::string ex(str, iter.base()); 24978 assert(ex == "+********0X9.32C05A44P+27"); 24979 assert(ios.width() == 0); 24980 } 24981 } 24982 ios.imbue(lg); 24983 { 24984 ios.width(0); 24985 { 24986 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24987 std::string ex(str, iter.base()); 24988 assert(ex == "+0X9;32C05A44P+27"); 24989 assert(ios.width() == 0); 24990 } 24991 ios.width(25); 24992 left(ios); 24993 { 24994 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24995 std::string ex(str, iter.base()); 24996 assert(ex == "+0X9;32C05A44P+27********"); 24997 assert(ios.width() == 0); 24998 } 24999 ios.width(25); 25000 right(ios); 25001 { 25002 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25003 std::string ex(str, iter.base()); 25004 assert(ex == "********+0X9;32C05A44P+27"); 25005 assert(ios.width() == 0); 25006 } 25007 ios.width(25); 25008 internal(ios); 25009 { 25010 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25011 std::string ex(str, iter.base()); 25012 assert(ex == "+********0X9;32C05A44P+27"); 25013 assert(ios.width() == 0); 25014 } 25015 } 25016 } 25017 } 25018 } 25019 } 25020 ios.precision(1); 25021 { 25022 nouppercase(ios); 25023 { 25024 noshowpos(ios); 25025 { 25026 noshowpoint(ios); 25027 { 25028 ios.imbue(lc); 25029 { 25030 ios.width(0); 25031 { 25032 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25033 std::string ex(str, iter.base()); 25034 assert(ex == "0x9.32c05a44p+27"); 25035 assert(ios.width() == 0); 25036 } 25037 ios.width(25); 25038 left(ios); 25039 { 25040 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25041 std::string ex(str, iter.base()); 25042 assert(ex == "0x9.32c05a44p+27*********"); 25043 assert(ios.width() == 0); 25044 } 25045 ios.width(25); 25046 right(ios); 25047 { 25048 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25049 std::string ex(str, iter.base()); 25050 assert(ex == "*********0x9.32c05a44p+27"); 25051 assert(ios.width() == 0); 25052 } 25053 ios.width(25); 25054 internal(ios); 25055 { 25056 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25057 std::string ex(str, iter.base()); 25058 assert(ex == "0x*********9.32c05a44p+27"); 25059 assert(ios.width() == 0); 25060 } 25061 } 25062 ios.imbue(lg); 25063 { 25064 ios.width(0); 25065 { 25066 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25067 std::string ex(str, iter.base()); 25068 assert(ex == "0x9;32c05a44p+27"); 25069 assert(ios.width() == 0); 25070 } 25071 ios.width(25); 25072 left(ios); 25073 { 25074 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25075 std::string ex(str, iter.base()); 25076 assert(ex == "0x9;32c05a44p+27*********"); 25077 assert(ios.width() == 0); 25078 } 25079 ios.width(25); 25080 right(ios); 25081 { 25082 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25083 std::string ex(str, iter.base()); 25084 assert(ex == "*********0x9;32c05a44p+27"); 25085 assert(ios.width() == 0); 25086 } 25087 ios.width(25); 25088 internal(ios); 25089 { 25090 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25091 std::string ex(str, iter.base()); 25092 assert(ex == "0x*********9;32c05a44p+27"); 25093 assert(ios.width() == 0); 25094 } 25095 } 25096 } 25097 showpoint(ios); 25098 { 25099 ios.imbue(lc); 25100 { 25101 ios.width(0); 25102 { 25103 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25104 std::string ex(str, iter.base()); 25105 assert(ex == "0x9.32c05a44p+27"); 25106 assert(ios.width() == 0); 25107 } 25108 ios.width(25); 25109 left(ios); 25110 { 25111 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25112 std::string ex(str, iter.base()); 25113 assert(ex == "0x9.32c05a44p+27*********"); 25114 assert(ios.width() == 0); 25115 } 25116 ios.width(25); 25117 right(ios); 25118 { 25119 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25120 std::string ex(str, iter.base()); 25121 assert(ex == "*********0x9.32c05a44p+27"); 25122 assert(ios.width() == 0); 25123 } 25124 ios.width(25); 25125 internal(ios); 25126 { 25127 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25128 std::string ex(str, iter.base()); 25129 assert(ex == "0x*********9.32c05a44p+27"); 25130 assert(ios.width() == 0); 25131 } 25132 } 25133 ios.imbue(lg); 25134 { 25135 ios.width(0); 25136 { 25137 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25138 std::string ex(str, iter.base()); 25139 assert(ex == "0x9;32c05a44p+27"); 25140 assert(ios.width() == 0); 25141 } 25142 ios.width(25); 25143 left(ios); 25144 { 25145 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25146 std::string ex(str, iter.base()); 25147 assert(ex == "0x9;32c05a44p+27*********"); 25148 assert(ios.width() == 0); 25149 } 25150 ios.width(25); 25151 right(ios); 25152 { 25153 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25154 std::string ex(str, iter.base()); 25155 assert(ex == "*********0x9;32c05a44p+27"); 25156 assert(ios.width() == 0); 25157 } 25158 ios.width(25); 25159 internal(ios); 25160 { 25161 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25162 std::string ex(str, iter.base()); 25163 assert(ex == "0x*********9;32c05a44p+27"); 25164 assert(ios.width() == 0); 25165 } 25166 } 25167 } 25168 } 25169 showpos(ios); 25170 { 25171 noshowpoint(ios); 25172 { 25173 ios.imbue(lc); 25174 { 25175 ios.width(0); 25176 { 25177 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25178 std::string ex(str, iter.base()); 25179 assert(ex == "+0x9.32c05a44p+27"); 25180 assert(ios.width() == 0); 25181 } 25182 ios.width(25); 25183 left(ios); 25184 { 25185 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25186 std::string ex(str, iter.base()); 25187 assert(ex == "+0x9.32c05a44p+27********"); 25188 assert(ios.width() == 0); 25189 } 25190 ios.width(25); 25191 right(ios); 25192 { 25193 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25194 std::string ex(str, iter.base()); 25195 assert(ex == "********+0x9.32c05a44p+27"); 25196 assert(ios.width() == 0); 25197 } 25198 ios.width(25); 25199 internal(ios); 25200 { 25201 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25202 std::string ex(str, iter.base()); 25203 assert(ex == "+********0x9.32c05a44p+27"); 25204 assert(ios.width() == 0); 25205 } 25206 } 25207 ios.imbue(lg); 25208 { 25209 ios.width(0); 25210 { 25211 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25212 std::string ex(str, iter.base()); 25213 assert(ex == "+0x9;32c05a44p+27"); 25214 assert(ios.width() == 0); 25215 } 25216 ios.width(25); 25217 left(ios); 25218 { 25219 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25220 std::string ex(str, iter.base()); 25221 assert(ex == "+0x9;32c05a44p+27********"); 25222 assert(ios.width() == 0); 25223 } 25224 ios.width(25); 25225 right(ios); 25226 { 25227 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25228 std::string ex(str, iter.base()); 25229 assert(ex == "********+0x9;32c05a44p+27"); 25230 assert(ios.width() == 0); 25231 } 25232 ios.width(25); 25233 internal(ios); 25234 { 25235 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25236 std::string ex(str, iter.base()); 25237 assert(ex == "+********0x9;32c05a44p+27"); 25238 assert(ios.width() == 0); 25239 } 25240 } 25241 } 25242 showpoint(ios); 25243 { 25244 ios.imbue(lc); 25245 { 25246 ios.width(0); 25247 { 25248 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25249 std::string ex(str, iter.base()); 25250 assert(ex == "+0x9.32c05a44p+27"); 25251 assert(ios.width() == 0); 25252 } 25253 ios.width(25); 25254 left(ios); 25255 { 25256 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25257 std::string ex(str, iter.base()); 25258 assert(ex == "+0x9.32c05a44p+27********"); 25259 assert(ios.width() == 0); 25260 } 25261 ios.width(25); 25262 right(ios); 25263 { 25264 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25265 std::string ex(str, iter.base()); 25266 assert(ex == "********+0x9.32c05a44p+27"); 25267 assert(ios.width() == 0); 25268 } 25269 ios.width(25); 25270 internal(ios); 25271 { 25272 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25273 std::string ex(str, iter.base()); 25274 assert(ex == "+********0x9.32c05a44p+27"); 25275 assert(ios.width() == 0); 25276 } 25277 } 25278 ios.imbue(lg); 25279 { 25280 ios.width(0); 25281 { 25282 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25283 std::string ex(str, iter.base()); 25284 assert(ex == "+0x9;32c05a44p+27"); 25285 assert(ios.width() == 0); 25286 } 25287 ios.width(25); 25288 left(ios); 25289 { 25290 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25291 std::string ex(str, iter.base()); 25292 assert(ex == "+0x9;32c05a44p+27********"); 25293 assert(ios.width() == 0); 25294 } 25295 ios.width(25); 25296 right(ios); 25297 { 25298 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25299 std::string ex(str, iter.base()); 25300 assert(ex == "********+0x9;32c05a44p+27"); 25301 assert(ios.width() == 0); 25302 } 25303 ios.width(25); 25304 internal(ios); 25305 { 25306 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25307 std::string ex(str, iter.base()); 25308 assert(ex == "+********0x9;32c05a44p+27"); 25309 assert(ios.width() == 0); 25310 } 25311 } 25312 } 25313 } 25314 } 25315 uppercase(ios); 25316 { 25317 noshowpos(ios); 25318 { 25319 noshowpoint(ios); 25320 { 25321 ios.imbue(lc); 25322 { 25323 ios.width(0); 25324 { 25325 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25326 std::string ex(str, iter.base()); 25327 assert(ex == "0X9.32C05A44P+27"); 25328 assert(ios.width() == 0); 25329 } 25330 ios.width(25); 25331 left(ios); 25332 { 25333 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25334 std::string ex(str, iter.base()); 25335 assert(ex == "0X9.32C05A44P+27*********"); 25336 assert(ios.width() == 0); 25337 } 25338 ios.width(25); 25339 right(ios); 25340 { 25341 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25342 std::string ex(str, iter.base()); 25343 assert(ex == "*********0X9.32C05A44P+27"); 25344 assert(ios.width() == 0); 25345 } 25346 ios.width(25); 25347 internal(ios); 25348 { 25349 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25350 std::string ex(str, iter.base()); 25351 assert(ex == "0X*********9.32C05A44P+27"); 25352 assert(ios.width() == 0); 25353 } 25354 } 25355 ios.imbue(lg); 25356 { 25357 ios.width(0); 25358 { 25359 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25360 std::string ex(str, iter.base()); 25361 assert(ex == "0X9;32C05A44P+27"); 25362 assert(ios.width() == 0); 25363 } 25364 ios.width(25); 25365 left(ios); 25366 { 25367 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25368 std::string ex(str, iter.base()); 25369 assert(ex == "0X9;32C05A44P+27*********"); 25370 assert(ios.width() == 0); 25371 } 25372 ios.width(25); 25373 right(ios); 25374 { 25375 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25376 std::string ex(str, iter.base()); 25377 assert(ex == "*********0X9;32C05A44P+27"); 25378 assert(ios.width() == 0); 25379 } 25380 ios.width(25); 25381 internal(ios); 25382 { 25383 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25384 std::string ex(str, iter.base()); 25385 assert(ex == "0X*********9;32C05A44P+27"); 25386 assert(ios.width() == 0); 25387 } 25388 } 25389 } 25390 showpoint(ios); 25391 { 25392 ios.imbue(lc); 25393 { 25394 ios.width(0); 25395 { 25396 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25397 std::string ex(str, iter.base()); 25398 assert(ex == "0X9.32C05A44P+27"); 25399 assert(ios.width() == 0); 25400 } 25401 ios.width(25); 25402 left(ios); 25403 { 25404 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25405 std::string ex(str, iter.base()); 25406 assert(ex == "0X9.32C05A44P+27*********"); 25407 assert(ios.width() == 0); 25408 } 25409 ios.width(25); 25410 right(ios); 25411 { 25412 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25413 std::string ex(str, iter.base()); 25414 assert(ex == "*********0X9.32C05A44P+27"); 25415 assert(ios.width() == 0); 25416 } 25417 ios.width(25); 25418 internal(ios); 25419 { 25420 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25421 std::string ex(str, iter.base()); 25422 assert(ex == "0X*********9.32C05A44P+27"); 25423 assert(ios.width() == 0); 25424 } 25425 } 25426 ios.imbue(lg); 25427 { 25428 ios.width(0); 25429 { 25430 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25431 std::string ex(str, iter.base()); 25432 assert(ex == "0X9;32C05A44P+27"); 25433 assert(ios.width() == 0); 25434 } 25435 ios.width(25); 25436 left(ios); 25437 { 25438 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25439 std::string ex(str, iter.base()); 25440 assert(ex == "0X9;32C05A44P+27*********"); 25441 assert(ios.width() == 0); 25442 } 25443 ios.width(25); 25444 right(ios); 25445 { 25446 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25447 std::string ex(str, iter.base()); 25448 assert(ex == "*********0X9;32C05A44P+27"); 25449 assert(ios.width() == 0); 25450 } 25451 ios.width(25); 25452 internal(ios); 25453 { 25454 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25455 std::string ex(str, iter.base()); 25456 assert(ex == "0X*********9;32C05A44P+27"); 25457 assert(ios.width() == 0); 25458 } 25459 } 25460 } 25461 } 25462 showpos(ios); 25463 { 25464 noshowpoint(ios); 25465 { 25466 ios.imbue(lc); 25467 { 25468 ios.width(0); 25469 { 25470 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25471 std::string ex(str, iter.base()); 25472 assert(ex == "+0X9.32C05A44P+27"); 25473 assert(ios.width() == 0); 25474 } 25475 ios.width(25); 25476 left(ios); 25477 { 25478 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25479 std::string ex(str, iter.base()); 25480 assert(ex == "+0X9.32C05A44P+27********"); 25481 assert(ios.width() == 0); 25482 } 25483 ios.width(25); 25484 right(ios); 25485 { 25486 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25487 std::string ex(str, iter.base()); 25488 assert(ex == "********+0X9.32C05A44P+27"); 25489 assert(ios.width() == 0); 25490 } 25491 ios.width(25); 25492 internal(ios); 25493 { 25494 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25495 std::string ex(str, iter.base()); 25496 assert(ex == "+********0X9.32C05A44P+27"); 25497 assert(ios.width() == 0); 25498 } 25499 } 25500 ios.imbue(lg); 25501 { 25502 ios.width(0); 25503 { 25504 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25505 std::string ex(str, iter.base()); 25506 assert(ex == "+0X9;32C05A44P+27"); 25507 assert(ios.width() == 0); 25508 } 25509 ios.width(25); 25510 left(ios); 25511 { 25512 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25513 std::string ex(str, iter.base()); 25514 assert(ex == "+0X9;32C05A44P+27********"); 25515 assert(ios.width() == 0); 25516 } 25517 ios.width(25); 25518 right(ios); 25519 { 25520 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25521 std::string ex(str, iter.base()); 25522 assert(ex == "********+0X9;32C05A44P+27"); 25523 assert(ios.width() == 0); 25524 } 25525 ios.width(25); 25526 internal(ios); 25527 { 25528 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25529 std::string ex(str, iter.base()); 25530 assert(ex == "+********0X9;32C05A44P+27"); 25531 assert(ios.width() == 0); 25532 } 25533 } 25534 } 25535 showpoint(ios); 25536 { 25537 ios.imbue(lc); 25538 { 25539 ios.width(0); 25540 { 25541 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25542 std::string ex(str, iter.base()); 25543 assert(ex == "+0X9.32C05A44P+27"); 25544 assert(ios.width() == 0); 25545 } 25546 ios.width(25); 25547 left(ios); 25548 { 25549 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25550 std::string ex(str, iter.base()); 25551 assert(ex == "+0X9.32C05A44P+27********"); 25552 assert(ios.width() == 0); 25553 } 25554 ios.width(25); 25555 right(ios); 25556 { 25557 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25558 std::string ex(str, iter.base()); 25559 assert(ex == "********+0X9.32C05A44P+27"); 25560 assert(ios.width() == 0); 25561 } 25562 ios.width(25); 25563 internal(ios); 25564 { 25565 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25566 std::string ex(str, iter.base()); 25567 assert(ex == "+********0X9.32C05A44P+27"); 25568 assert(ios.width() == 0); 25569 } 25570 } 25571 ios.imbue(lg); 25572 { 25573 ios.width(0); 25574 { 25575 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25576 std::string ex(str, iter.base()); 25577 assert(ex == "+0X9;32C05A44P+27"); 25578 assert(ios.width() == 0); 25579 } 25580 ios.width(25); 25581 left(ios); 25582 { 25583 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25584 std::string ex(str, iter.base()); 25585 assert(ex == "+0X9;32C05A44P+27********"); 25586 assert(ios.width() == 0); 25587 } 25588 ios.width(25); 25589 right(ios); 25590 { 25591 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25592 std::string ex(str, iter.base()); 25593 assert(ex == "********+0X9;32C05A44P+27"); 25594 assert(ios.width() == 0); 25595 } 25596 ios.width(25); 25597 internal(ios); 25598 { 25599 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25600 std::string ex(str, iter.base()); 25601 assert(ex == "+********0X9;32C05A44P+27"); 25602 assert(ios.width() == 0); 25603 } 25604 } 25605 } 25606 } 25607 } 25608 } 25609 ios.precision(6); 25610 { 25611 } 25612 ios.precision(16); 25613 { 25614 } 25615 ios.precision(60); 25616 { 25617 nouppercase(ios); 25618 { 25619 noshowpos(ios); 25620 { 25621 noshowpoint(ios); 25622 { 25623 ios.imbue(lc); 25624 { 25625 ios.width(0); 25626 { 25627 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25628 std::string ex(str, iter.base()); 25629 assert(ex == "0x9.32c05a44p+27"); 25630 assert(ios.width() == 0); 25631 } 25632 ios.width(25); 25633 left(ios); 25634 { 25635 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25636 std::string ex(str, iter.base()); 25637 assert(ex == "0x9.32c05a44p+27*********"); 25638 assert(ios.width() == 0); 25639 } 25640 ios.width(25); 25641 right(ios); 25642 { 25643 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25644 std::string ex(str, iter.base()); 25645 assert(ex == "*********0x9.32c05a44p+27"); 25646 assert(ios.width() == 0); 25647 } 25648 ios.width(25); 25649 internal(ios); 25650 { 25651 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25652 std::string ex(str, iter.base()); 25653 assert(ex == "0x*********9.32c05a44p+27"); 25654 assert(ios.width() == 0); 25655 } 25656 } 25657 ios.imbue(lg); 25658 { 25659 ios.width(0); 25660 { 25661 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25662 std::string ex(str, iter.base()); 25663 assert(ex == "0x9;32c05a44p+27"); 25664 assert(ios.width() == 0); 25665 } 25666 ios.width(25); 25667 left(ios); 25668 { 25669 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25670 std::string ex(str, iter.base()); 25671 assert(ex == "0x9;32c05a44p+27*********"); 25672 assert(ios.width() == 0); 25673 } 25674 ios.width(25); 25675 right(ios); 25676 { 25677 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25678 std::string ex(str, iter.base()); 25679 assert(ex == "*********0x9;32c05a44p+27"); 25680 assert(ios.width() == 0); 25681 } 25682 ios.width(25); 25683 internal(ios); 25684 { 25685 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25686 std::string ex(str, iter.base()); 25687 assert(ex == "0x*********9;32c05a44p+27"); 25688 assert(ios.width() == 0); 25689 } 25690 } 25691 } 25692 showpoint(ios); 25693 { 25694 ios.imbue(lc); 25695 { 25696 ios.width(0); 25697 { 25698 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25699 std::string ex(str, iter.base()); 25700 assert(ex == "0x9.32c05a44p+27"); 25701 assert(ios.width() == 0); 25702 } 25703 ios.width(25); 25704 left(ios); 25705 { 25706 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25707 std::string ex(str, iter.base()); 25708 assert(ex == "0x9.32c05a44p+27*********"); 25709 assert(ios.width() == 0); 25710 } 25711 ios.width(25); 25712 right(ios); 25713 { 25714 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25715 std::string ex(str, iter.base()); 25716 assert(ex == "*********0x9.32c05a44p+27"); 25717 assert(ios.width() == 0); 25718 } 25719 ios.width(25); 25720 internal(ios); 25721 { 25722 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25723 std::string ex(str, iter.base()); 25724 assert(ex == "0x*********9.32c05a44p+27"); 25725 assert(ios.width() == 0); 25726 } 25727 } 25728 ios.imbue(lg); 25729 { 25730 ios.width(0); 25731 { 25732 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25733 std::string ex(str, iter.base()); 25734 assert(ex == "0x9;32c05a44p+27"); 25735 assert(ios.width() == 0); 25736 } 25737 ios.width(25); 25738 left(ios); 25739 { 25740 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25741 std::string ex(str, iter.base()); 25742 assert(ex == "0x9;32c05a44p+27*********"); 25743 assert(ios.width() == 0); 25744 } 25745 ios.width(25); 25746 right(ios); 25747 { 25748 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25749 std::string ex(str, iter.base()); 25750 assert(ex == "*********0x9;32c05a44p+27"); 25751 assert(ios.width() == 0); 25752 } 25753 ios.width(25); 25754 internal(ios); 25755 { 25756 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25757 std::string ex(str, iter.base()); 25758 assert(ex == "0x*********9;32c05a44p+27"); 25759 assert(ios.width() == 0); 25760 } 25761 } 25762 } 25763 } 25764 showpos(ios); 25765 { 25766 noshowpoint(ios); 25767 { 25768 ios.imbue(lc); 25769 { 25770 ios.width(0); 25771 { 25772 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25773 std::string ex(str, iter.base()); 25774 assert(ex == "+0x9.32c05a44p+27"); 25775 assert(ios.width() == 0); 25776 } 25777 ios.width(25); 25778 left(ios); 25779 { 25780 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25781 std::string ex(str, iter.base()); 25782 assert(ex == "+0x9.32c05a44p+27********"); 25783 assert(ios.width() == 0); 25784 } 25785 ios.width(25); 25786 right(ios); 25787 { 25788 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25789 std::string ex(str, iter.base()); 25790 assert(ex == "********+0x9.32c05a44p+27"); 25791 assert(ios.width() == 0); 25792 } 25793 ios.width(25); 25794 internal(ios); 25795 { 25796 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25797 std::string ex(str, iter.base()); 25798 assert(ex == "+********0x9.32c05a44p+27"); 25799 assert(ios.width() == 0); 25800 } 25801 } 25802 ios.imbue(lg); 25803 { 25804 ios.width(0); 25805 { 25806 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25807 std::string ex(str, iter.base()); 25808 assert(ex == "+0x9;32c05a44p+27"); 25809 assert(ios.width() == 0); 25810 } 25811 ios.width(25); 25812 left(ios); 25813 { 25814 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25815 std::string ex(str, iter.base()); 25816 assert(ex == "+0x9;32c05a44p+27********"); 25817 assert(ios.width() == 0); 25818 } 25819 ios.width(25); 25820 right(ios); 25821 { 25822 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25823 std::string ex(str, iter.base()); 25824 assert(ex == "********+0x9;32c05a44p+27"); 25825 assert(ios.width() == 0); 25826 } 25827 ios.width(25); 25828 internal(ios); 25829 { 25830 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25831 std::string ex(str, iter.base()); 25832 assert(ex == "+********0x9;32c05a44p+27"); 25833 assert(ios.width() == 0); 25834 } 25835 } 25836 } 25837 showpoint(ios); 25838 { 25839 ios.imbue(lc); 25840 { 25841 ios.width(0); 25842 { 25843 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25844 std::string ex(str, iter.base()); 25845 assert(ex == "+0x9.32c05a44p+27"); 25846 assert(ios.width() == 0); 25847 } 25848 ios.width(25); 25849 left(ios); 25850 { 25851 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25852 std::string ex(str, iter.base()); 25853 assert(ex == "+0x9.32c05a44p+27********"); 25854 assert(ios.width() == 0); 25855 } 25856 ios.width(25); 25857 right(ios); 25858 { 25859 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25860 std::string ex(str, iter.base()); 25861 assert(ex == "********+0x9.32c05a44p+27"); 25862 assert(ios.width() == 0); 25863 } 25864 ios.width(25); 25865 internal(ios); 25866 { 25867 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25868 std::string ex(str, iter.base()); 25869 assert(ex == "+********0x9.32c05a44p+27"); 25870 assert(ios.width() == 0); 25871 } 25872 } 25873 ios.imbue(lg); 25874 { 25875 ios.width(0); 25876 { 25877 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25878 std::string ex(str, iter.base()); 25879 assert(ex == "+0x9;32c05a44p+27"); 25880 assert(ios.width() == 0); 25881 } 25882 ios.width(25); 25883 left(ios); 25884 { 25885 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25886 std::string ex(str, iter.base()); 25887 assert(ex == "+0x9;32c05a44p+27********"); 25888 assert(ios.width() == 0); 25889 } 25890 ios.width(25); 25891 right(ios); 25892 { 25893 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25894 std::string ex(str, iter.base()); 25895 assert(ex == "********+0x9;32c05a44p+27"); 25896 assert(ios.width() == 0); 25897 } 25898 ios.width(25); 25899 internal(ios); 25900 { 25901 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25902 std::string ex(str, iter.base()); 25903 assert(ex == "+********0x9;32c05a44p+27"); 25904 assert(ios.width() == 0); 25905 } 25906 } 25907 } 25908 } 25909 } 25910 uppercase(ios); 25911 { 25912 noshowpos(ios); 25913 { 25914 noshowpoint(ios); 25915 { 25916 ios.imbue(lc); 25917 { 25918 ios.width(0); 25919 { 25920 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25921 std::string ex(str, iter.base()); 25922 assert(ex == "0X9.32C05A44P+27"); 25923 assert(ios.width() == 0); 25924 } 25925 ios.width(25); 25926 left(ios); 25927 { 25928 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25929 std::string ex(str, iter.base()); 25930 assert(ex == "0X9.32C05A44P+27*********"); 25931 assert(ios.width() == 0); 25932 } 25933 ios.width(25); 25934 right(ios); 25935 { 25936 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25937 std::string ex(str, iter.base()); 25938 assert(ex == "*********0X9.32C05A44P+27"); 25939 assert(ios.width() == 0); 25940 } 25941 ios.width(25); 25942 internal(ios); 25943 { 25944 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25945 std::string ex(str, iter.base()); 25946 assert(ex == "0X*********9.32C05A44P+27"); 25947 assert(ios.width() == 0); 25948 } 25949 } 25950 ios.imbue(lg); 25951 { 25952 ios.width(0); 25953 { 25954 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25955 std::string ex(str, iter.base()); 25956 assert(ex == "0X9;32C05A44P+27"); 25957 assert(ios.width() == 0); 25958 } 25959 ios.width(25); 25960 left(ios); 25961 { 25962 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25963 std::string ex(str, iter.base()); 25964 assert(ex == "0X9;32C05A44P+27*********"); 25965 assert(ios.width() == 0); 25966 } 25967 ios.width(25); 25968 right(ios); 25969 { 25970 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25971 std::string ex(str, iter.base()); 25972 assert(ex == "*********0X9;32C05A44P+27"); 25973 assert(ios.width() == 0); 25974 } 25975 ios.width(25); 25976 internal(ios); 25977 { 25978 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25979 std::string ex(str, iter.base()); 25980 assert(ex == "0X*********9;32C05A44P+27"); 25981 assert(ios.width() == 0); 25982 } 25983 } 25984 } 25985 showpoint(ios); 25986 { 25987 ios.imbue(lc); 25988 { 25989 ios.width(0); 25990 { 25991 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25992 std::string ex(str, iter.base()); 25993 assert(ex == "0X9.32C05A44P+27"); 25994 assert(ios.width() == 0); 25995 } 25996 ios.width(25); 25997 left(ios); 25998 { 25999 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26000 std::string ex(str, iter.base()); 26001 assert(ex == "0X9.32C05A44P+27*********"); 26002 assert(ios.width() == 0); 26003 } 26004 ios.width(25); 26005 right(ios); 26006 { 26007 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26008 std::string ex(str, iter.base()); 26009 assert(ex == "*********0X9.32C05A44P+27"); 26010 assert(ios.width() == 0); 26011 } 26012 ios.width(25); 26013 internal(ios); 26014 { 26015 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26016 std::string ex(str, iter.base()); 26017 assert(ex == "0X*********9.32C05A44P+27"); 26018 assert(ios.width() == 0); 26019 } 26020 } 26021 ios.imbue(lg); 26022 { 26023 ios.width(0); 26024 { 26025 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26026 std::string ex(str, iter.base()); 26027 assert(ex == "0X9;32C05A44P+27"); 26028 assert(ios.width() == 0); 26029 } 26030 ios.width(25); 26031 left(ios); 26032 { 26033 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26034 std::string ex(str, iter.base()); 26035 assert(ex == "0X9;32C05A44P+27*********"); 26036 assert(ios.width() == 0); 26037 } 26038 ios.width(25); 26039 right(ios); 26040 { 26041 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26042 std::string ex(str, iter.base()); 26043 assert(ex == "*********0X9;32C05A44P+27"); 26044 assert(ios.width() == 0); 26045 } 26046 ios.width(25); 26047 internal(ios); 26048 { 26049 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26050 std::string ex(str, iter.base()); 26051 assert(ex == "0X*********9;32C05A44P+27"); 26052 assert(ios.width() == 0); 26053 } 26054 } 26055 } 26056 } 26057 showpos(ios); 26058 { 26059 noshowpoint(ios); 26060 { 26061 ios.imbue(lc); 26062 { 26063 ios.width(0); 26064 { 26065 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26066 std::string ex(str, iter.base()); 26067 assert(ex == "+0X9.32C05A44P+27"); 26068 assert(ios.width() == 0); 26069 } 26070 ios.width(25); 26071 left(ios); 26072 { 26073 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26074 std::string ex(str, iter.base()); 26075 assert(ex == "+0X9.32C05A44P+27********"); 26076 assert(ios.width() == 0); 26077 } 26078 ios.width(25); 26079 right(ios); 26080 { 26081 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26082 std::string ex(str, iter.base()); 26083 assert(ex == "********+0X9.32C05A44P+27"); 26084 assert(ios.width() == 0); 26085 } 26086 ios.width(25); 26087 internal(ios); 26088 { 26089 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26090 std::string ex(str, iter.base()); 26091 assert(ex == "+********0X9.32C05A44P+27"); 26092 assert(ios.width() == 0); 26093 } 26094 } 26095 ios.imbue(lg); 26096 { 26097 ios.width(0); 26098 { 26099 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26100 std::string ex(str, iter.base()); 26101 assert(ex == "+0X9;32C05A44P+27"); 26102 assert(ios.width() == 0); 26103 } 26104 ios.width(25); 26105 left(ios); 26106 { 26107 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26108 std::string ex(str, iter.base()); 26109 assert(ex == "+0X9;32C05A44P+27********"); 26110 assert(ios.width() == 0); 26111 } 26112 ios.width(25); 26113 right(ios); 26114 { 26115 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26116 std::string ex(str, iter.base()); 26117 assert(ex == "********+0X9;32C05A44P+27"); 26118 assert(ios.width() == 0); 26119 } 26120 ios.width(25); 26121 internal(ios); 26122 { 26123 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26124 std::string ex(str, iter.base()); 26125 assert(ex == "+********0X9;32C05A44P+27"); 26126 assert(ios.width() == 0); 26127 } 26128 } 26129 } 26130 showpoint(ios); 26131 { 26132 ios.imbue(lc); 26133 { 26134 ios.width(0); 26135 { 26136 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26137 std::string ex(str, iter.base()); 26138 assert(ex == "+0X9.32C05A44P+27"); 26139 assert(ios.width() == 0); 26140 } 26141 ios.width(25); 26142 left(ios); 26143 { 26144 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26145 std::string ex(str, iter.base()); 26146 assert(ex == "+0X9.32C05A44P+27********"); 26147 assert(ios.width() == 0); 26148 } 26149 ios.width(25); 26150 right(ios); 26151 { 26152 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26153 std::string ex(str, iter.base()); 26154 assert(ex == "********+0X9.32C05A44P+27"); 26155 assert(ios.width() == 0); 26156 } 26157 ios.width(25); 26158 internal(ios); 26159 { 26160 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26161 std::string ex(str, iter.base()); 26162 assert(ex == "+********0X9.32C05A44P+27"); 26163 assert(ios.width() == 0); 26164 } 26165 } 26166 ios.imbue(lg); 26167 { 26168 ios.width(0); 26169 { 26170 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26171 std::string ex(str, iter.base()); 26172 assert(ex == "+0X9;32C05A44P+27"); 26173 assert(ios.width() == 0); 26174 } 26175 ios.width(25); 26176 left(ios); 26177 { 26178 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26179 std::string ex(str, iter.base()); 26180 assert(ex == "+0X9;32C05A44P+27********"); 26181 assert(ios.width() == 0); 26182 } 26183 ios.width(25); 26184 right(ios); 26185 { 26186 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26187 std::string ex(str, iter.base()); 26188 assert(ex == "********+0X9;32C05A44P+27"); 26189 assert(ios.width() == 0); 26190 } 26191 ios.width(25); 26192 internal(ios); 26193 { 26194 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26195 std::string ex(str, iter.base()); 26196 assert(ex == "+********0X9;32C05A44P+27"); 26197 assert(ios.width() == 0); 26198 } 26199 } 26200 } 26201 } 26202 } 26203 } 26204 } 26205 } 26206 #endif 26207 } 26208 26209 int main() 26210 { 26211 test1(); 26212 test2(); 26213 test3(); 26214 test4(); 26215 test5(); 26216 test6(); 26217 test7(); 26218 test8(); 26219 test9(); 26220 test10(); 26221 test11(); 26222 test12(); 26223 char str[200]; 26224 output_iterator<char*> iter; 26225 std::locale lc = std::locale::classic(); 26226 std::locale lg(lc, new my_numpunct); 26227 const my_facet f(1); 26228 { 26229 long double v = -INFINITY; 26230 } 26231 { 26232 long double v = std::nan(""); 26233 } 26234 26235 { 26236 long double v = +0.; 26237 } 26238 { 26239 long double v = -INFINITY; 26240 } 26241 { 26242 long double v = std::nan(""); 26243 } 26244 { 26245 long double v = -INFINITY; 26246 } 26247 { 26248 long double v = std::nan(""); 26249 } 26250 } 26251